Mirror download job logs to stdout

Add a Queue page bulk action and API route to remove all failed jobs, cover it with regression tests, and update the version, changelog, and README for the new queue workflow.

CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 0.49.4 - 2026-07-19
+
+- Added optional download job stdout mirroring with `ANI_CLI_WEB_JOB_STDOUT`, enabled by default in Docker and Docker Compose so container log collectors can capture downloader output.
+
+## 0.49.3 - 2026-07-19
+
+- Changed Docker builds to copy the current local `ani-cli-web` checkout into the image instead of cloning the configured remote branch, so rebuilt images include local Docker/runtime fixes immediately.
+- Installed Docker `anipy-cli` and `animdl` in separate virtualenvs, with `animdl` pinned under Python 3.11 so its older native dependency pins resolve and remain executable.
+- Removed the unused `ANI_CLI_WEB` compose build argument and updated Docker documentation to match the local-checkout build flow.
+
+## 0.49.2 - 2026-07-19
+
+- Fixed the Config page dependency check so Docker-installed fallback tools are detected from `/usr/local/bin` and `/usr/bin`, matching the runtime command lookup.
+- Set the Docker image `PATH` explicitly to include system binary directories before the app starts.
+
+## 0.49.1 - 2026-07-19
+
+- Fixed Docker fallback tool discovery by exposing `anipy-cli` and `animdl` from fixed system paths and checking common system install locations at runtime.
+- Changed queue jobs to fail immediately with a clear message when every selected download method is unavailable, instead of trying to launch an unavailable command.
+
+## 0.49.0 - 2026-07-19
+
+- Added `animdl` as a third queue download backend and Docker-installed fallback tool.
+- Replaced the single `anipy-cli` fallback toggle with selectable download methods for `ani-cli`, `anipy-cli`, and `animdl`; queue jobs try the checked methods in that order.
+- Exposed `animdl` availability and version in the Config page runtime checks.
+
+## 0.48.3 - 2026-07-17
+
+- Added Jellyfin handoff jobs to the Queue page so manual copy jobs appear alongside downloads with live progress, moved-file counts, and recent handoff activity.
+
+## 0.48.2 - 2026-07-09
+
+- Added support for a checked-in `favicon.png`, serving it from the app and wiring it into the website pages so browsers show the custom favicon.
+
+## 0.48.1 - 2026-07-09
+
+- Changed queue inserts so adding a download that exactly matches an existing failed job now reuses that failed entry and resets it to pending instead of creating another duplicate failed row.
+
+## 0.48.0 - 2026-07-09
+
+- Added a `Clear failed` bulk action to the Queue page so failed jobs can be removed without touching pending, running, finished, or canceled downloads.
+
 ## 0.47.1 - 2026-07-09
 
 - Fixed `anipy-cli` fallback renaming for queued TV downloads so retried jobs now keep the requested episode numbers from the queue, avoiding cases like a retried `S02E11` being renamed as `S02E01`.

Dockerfile

@@ -1,20 +1,20 @@
-FROM python:3.12-slim
+FROM python:3.12-slim-bookworm
 
 ARG ANI_CLI=https://github.com/pystardust/ani-cli.git
 ARG ANI_CLI_BRANCH=master
-ARG ANI_CLI_WEB=https://gitea.coreplay.eu/Dymas/ani-cli-web.git
-ARG ANI_CLI_WEB_BRANCH=main
 ARG YT_DLP_RELEASE_URL=https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp
 
 ENV DEBIAN_FRONTEND=noninteractive \
     ANI_CLI_REPO=${ANI_CLI} \
     ANI_CLI_BRANCH=${ANI_CLI_BRANCH} \
-    ANI_CLI_WEB_REPO=${ANI_CLI_WEB} \
-    ANI_CLI_WEB_BRANCH=${ANI_CLI_WEB_BRANCH} \
+    PATH=/usr/local/bin:/usr/bin:/bin \
     ANI_CLI_BIN=ani-cli \
+    ANIPY_CLI_BIN=/usr/local/bin/anipy-cli \
+    ANIMDL_BIN=/usr/local/bin/animdl \
     ANI_CLI_DOWNLOAD_DIR=/downloads \
     ANI_CLI_WEB_HOST=0.0.0.0 \
     ANI_CLI_WEB_PORT=8421 \
+    ANI_CLI_WEB_JOB_STDOUT=true \
     UPDATE_ON_START=false \
     USER_UID= \
     USER_GID=
@@ -22,14 +22,20 @@ ENV DEBIAN_FRONTEND=noninteractive \
 RUN apt-get update \
     && apt-get install -y --no-install-recommends \
         aria2 \
+        botan \
         ca-certificates \
         curl \
         ffmpeg \
         fzf \
+        build-essential \
         git \
         grep \
+        libxml2-dev \
+        libxslt1-dev \
         openssl \
         patch \
+        python3.11 \
+        python3.11-venv \
         sed \
         sudo \
         util-linux \
@@ -48,20 +54,25 @@ RUN curl -fL "${YT_DLP_RELEASE_URL}" -o /usr/local/bin/yt-dlp \
     && chmod 0755 /usr/local/bin/yt-dlp \
     && yt-dlp --version
 
-RUN python3 -m pip install --no-cache-dir anipy-cli \
-    && anipy-cli --version
+RUN python3 -m venv /opt/anipy-cli \
+    && /opt/anipy-cli/bin/pip install --no-cache-dir --upgrade pip \
+    && /opt/anipy-cli/bin/pip install --no-cache-dir anipy-cli \
+    && python3.11 -m venv /opt/animdl \
+    && /opt/animdl/bin/pip install --no-cache-dir --upgrade pip \
+    && /opt/animdl/bin/pip install --no-cache-dir animdl==1.7.27 \
+    && test -x /opt/anipy-cli/bin/anipy-cli \
+    && test -x /opt/animdl/bin/animdl \
+    && printf '%s\n' '#!/bin/sh' 'exec /opt/anipy-cli/bin/anipy-cli "$@"' > /usr/local/bin/anipy-cli \
+    && printf '%s\n' '#!/bin/sh' 'exec /opt/animdl/bin/animdl "$@"' > /usr/local/bin/animdl \
+    && chmod 0755 /usr/local/bin/anipy-cli /usr/local/bin/animdl \
+    && ln -sf /usr/local/bin/anipy-cli /usr/bin/anipy-cli \
+    && ln -sf /usr/local/bin/animdl /usr/bin/animdl \
+    && /usr/local/bin/anipy-cli --version \
+    && /usr/local/bin/animdl --version
 
-RUN git clone --depth 1 --branch "${ANI_CLI_WEB_BRANCH}" "${ANI_CLI_WEB}" /app \
-    && rm -rf /app/.git \
-    && rm -f \
-        /app/.dockerignore \
-        /app/.gitignore \
-        /app/Dockerfile \
-        /app/README.md \
-        /app/ani-cli-web \
-        /app/docker-compose.yaml \
-        /app/docker-entrypoint.sh \
-        /app/test_app.py
+RUN mkdir -p /app
+
+COPY app.py app_support.py config_page.py http_handler.py queue_jobs.py queue_page.py search_page.py template_helpers.py title_matching.py watchlist_identity.py watchlist_page.py web_templates.py VERSION CHANGELOG.md favicon.png /app/
 
 COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
 

README.md

@@ -2,34 +2,35 @@
 
 Local web UI for a system-wide `ani-cli` install.
 
-Current version: `0.47.1`
+Current version: `0.49.4`
 
 ## What it does
 
 - Search anime in `sub` or `dub`, with poster-style results shown below the selection panel and the first English alternate title when available
 - Queue downloads with folder, quality, media type, season, and episode controls
-- Optionally retry failed `ani-cli` downloads with `anipy-cli`
+- Choose which download backends queue jobs may use: `ani-cli`, `anipy-cli`, and `animdl`
 - Track shows in a watchlist with `Watching`, `Planned`, `Finished`, and `Dropped` categories
 - Expose a small JSON summary endpoint for Homepage dashboard widgets
 - Refresh watchlist episode counts manually or on a schedule
 - Auto-download missing episodes for `Watching` entries after later refreshes, with a per-show `Source name` override for `ani-cli` search
-- Move fully completed libraries into Jellyfin TV or movie folders with a tracked background handoff job
+- Move fully completed libraries into Jellyfin TV or movie folders with tracked background handoff jobs that also appear in the Queue page
 - Send optional Discord webhook notifications
+- Serve a checked-in `favicon.png` as the site favicon
 
 ## Pages
 
 - `/`: Search and queue downloads, with poster-card search results below the selection box and alternate English titles under the main name when available
-- `/queue`: Monitor jobs, inspect logs, retry failed jobs, remove finished jobs
+- `/queue`: Monitor downloads and Jellyfin handoff jobs, inspect logs, retry failed downloads, avoid duplicate re-queues for the same failed download, clear failed jobs, and remove finished jobs
 - `/watchlist`: Track shows, refresh them, download all available episodes, and manage auto-download settings such as `Source name`, library `Name`, season, and episode offset
-- `/config`: Save defaults, toggle `anipy-cli` fallback retries, schedule refreshes, configure Jellyfin and Discord, monitor Jellyfin handoff progress, and view runtime info and the changelog
+- `/config`: Save defaults, choose queue download methods and fallback retries, schedule refreshes, configure Jellyfin and Discord, monitor Jellyfin handoff progress, and view runtime info and the changelog
 
 ## Quick start
 
 Requirements:
 
 - `ani-cli` installed and available in `PATH`
-- Optional: `anipy-cli` installed and available in `PATH` if you want automatic fallback retries outside Docker
-- Common runtime tools used by `ani-cli`, especially `curl`, `ffmpeg`, `fzf`, `grep`, `openssl`, `sed`, `aria2c`, and `yt-dlp`
+- Optional: `anipy-cli` and/or `animdl` installed and available in `PATH` if you want automatic fallback retries outside Docker
+- Common runtime tools used by `ani-cli`, especially `curl`, `ffmpeg`, `fzf`, `grep`, `openssl`, `sed`, `aria2c`, `botan`, and `yt-dlp`
 
 Run locally:
 
@@ -48,8 +49,10 @@ Useful flags and env:
 - `./ani-cli-web --debug`
 - `ANI_CLI_WEB_HOST=0.0.0.0`
 - `ANI_CLI_WEB_PORT=8421`
+- `ANI_CLI_WEB_JOB_STDOUT=true`
 - `ANI_CLI_BIN=/path/to/ani-cli`
 - `ANIPY_CLI_BIN=/path/to/anipy-cli`
+- `ANIMDL_BIN=/path/to/animdl`
 
 ## Docker
 
@@ -59,13 +62,7 @@ Build:
 docker build -t ani-cli-web .
 ```
 
-Build a specific `ani-cli-web` branch:
-
-```sh
-docker build \
-  --build-arg ANI_CLI_WEB_BRANCH=anipy_backup \
-  -t ani-cli-web .
-```
+Docker builds the app from the current local checkout.
 
 Run:
 
@@ -92,8 +89,9 @@ Docker notes:
 - App state is stored under `/app/.ani-cli-web`
 - `USER_UID` and `USER_GID` help keep mounted files owned by your host user
 - `UPDATE_ON_START=true` runs `ani-cli --update` before startup
-- `ANI_CLI_WEB_BRANCH` lets the image clone a specific `ani-cli-web` branch at build time
-- `anipy-cli` is installed systemwide inside the container, so fallback retries are available without extra container setup
+- `ANI_CLI_WEB_JOB_STDOUT=true` mirrors download job output to container stdout for log collectors; set it to `false` to keep job output only in the Queue page
+- `botan` is installed inside the container for providers or scripts that need Botan cryptography tooling
+- `anipy-cli` and `animdl` are installed systemwide inside the container at `/usr/local/bin`, linked from `/usr/bin`, and included in the runtime `PATH`; `animdl` is isolated in a Python 3.11 virtualenv so its pinned dependencies stay executable
 
 ## Key behavior
 
@@ -115,9 +113,16 @@ Docker notes:
 ### Download fallback
 
 - Optional and configured from `/config`
-- When enabled, a failed `ani-cli` queue job retries once with `anipy-cli`
-- Fallback retries keep the queued episode numbers when the downloaded `anipy-cli` filenames are renumbered from `1`
-- Docker images install `anipy-cli` automatically; non-Docker installs should provide it in `PATH` themselves
+- Queue jobs can use any checked combination of `ani-cli`, `anipy-cli`, and `animdl`
+- Checked methods are tried in this order: `ani-cli`, `anipy-cli`, then `animdl`
+- Selecting one method disables fallback retry; selecting multiple methods makes later methods automatic fallbacks
+- Fallback retries keep the queued episode numbers when fallback downloader filenames are renumbered from `1`
+- Docker images install `anipy-cli` and `animdl` automatically; non-Docker installs should provide the selected tools in `PATH` themselves
+
+### Queue retries
+
+- Adding a download that exactly matches an existing failed queue job reuses that failed entry and sets it back to `pending`
+- This avoids stacking multiple failed rows for the same episode when you queue the same job again
 
 ### Jellyfin handoff
 
@@ -155,7 +160,7 @@ The Config page runtime panel shows:
 
 - `ani-cli-web` version loaded from `VERSION`
 - Installed `ani-cli` version
-- Installed `anipy-cli` version and dependency status
+- Installed `anipy-cli` and `animdl` versions and dependency status
 - A `Changelog` button that opens a scrollable viewer backed by `CHANGELOG.md`
 
 ## Remote access
@@ -204,6 +209,7 @@ Most users only need these environment variables:
 
 - `ANI_CLI_BIN`
 - `ANIPY_CLI_BIN`
+- `ANIMDL_BIN`
 - `ANI_CLI_WEB_HOST`
 - `ANI_CLI_WEB_PORT`
 - `ANI_CLI_WEB_ALLOW_REMOTE`

VERSION

@@ -1 +1 @@
-0.47.1
+0.49.4

app.py

@@ -2766,6 +2766,8 @@ def save_runtime_config(config):
     current = get_config_snapshot(fallback=DEFAULT_CONFIG)
     merged = dict(current)
     if isinstance(config, dict):
+        if "anipy_cli_fallback_enabled" in config and "download_methods" not in config:
+            merged.pop("download_methods", None)
         merged.update(config)
     normalized = normalize_config(merged)
     previous_fingerprint = remote_access_session_fingerprint(current)

app_support.py

@@ -22,8 +22,24 @@ from uuid import uuid4
 
 
 PROJECT_ROOT = Path(__file__).resolve().parent
-ANI_CLI = os.environ.get("ANI_CLI_BIN") or shutil.which("ani-cli") or "ani-cli"
-ANIPY_CLI = os.environ.get("ANIPY_CLI_BIN") or shutil.which("anipy-cli") or "anipy-cli"
+
+
+def configured_cli_command(env_name, executable_name):
+    configured = str(os.environ.get(env_name) or "").strip()
+    if configured:
+        return configured
+    resolved = shutil.which(executable_name)
+    if resolved:
+        return resolved
+    for candidate in (Path("/usr/local/bin") / executable_name, Path("/usr/bin") / executable_name):
+        if candidate.exists() and os.access(candidate, os.X_OK):
+            return str(candidate)
+    return executable_name
+
+
+ANI_CLI = configured_cli_command("ANI_CLI_BIN", "ani-cli")
+ANIPY_CLI = configured_cli_command("ANIPY_CLI_BIN", "anipy-cli")
+ANIMDL = configured_cli_command("ANIMDL_BIN", "animdl")
 APP_NAME = "ani-cli-web"
 VERSION_FILE = PROJECT_ROOT / "VERSION"
 CHANGELOG_FILE = PROJECT_ROOT / "CHANGELOG.md"
@@ -41,6 +57,7 @@ DEBUG_MODE = False
 
 QUALITY_CHOICES = {"best", "1080", "1080p", "720", "720p", "480", "480p", "360", "360p", "worst"}
 MODE_CHOICES = {"sub", "dub"}
+DOWNLOAD_METHOD_CHOICES = ("ani-cli", "anipy-cli", "animdl")
 MEDIA_TYPE_CHOICES = {"tv", "movie"}
 WATCHLIST_CATEGORY_LABELS = {
     "watching": "Watching",
@@ -254,6 +271,10 @@ def background_workers_enabled():
     return not env_flag("ANI_CLI_WEB_DISABLE_WORKER")
 
 
+def job_stdout_enabled():
+    return env_flag("ANI_CLI_WEB_JOB_STDOUT")
+
+
 def client_address_is_local(host):
     text = str(host or "").strip()
     if not text:
@@ -292,6 +313,7 @@ DEFAULT_CONFIG = {
     "mode": os.environ.get("ANI_CLI_MODE", "sub"),
     "quality": os.environ.get("ANI_CLI_QUALITY", "best"),
     "anipy_cli_fallback_enabled": False,
+    "download_methods": ["ani-cli"],
     "watchlist_auto_refresh_enabled": False,
     "watchlist_auto_refresh_minutes": WATCHLIST_AUTO_REFRESH_DEFAULT_MINUTES,
     "watchlist_refresh_delay_seconds": WATCHLIST_REFRESH_DELAY_DEFAULT_SECONDS,
@@ -438,6 +460,7 @@ def write_json(path, data):
 
 
 def normalize_config(data):
+    source_has_download_methods = isinstance(data, dict) and "download_methods" in data
     config = dict(DEFAULT_CONFIG)
     if isinstance(data, dict):
         config.update({key: data[key] for key in DEFAULT_CONFIG if key in data})
@@ -448,6 +471,7 @@ def normalize_config(data):
         quality = quality[:-1]
     download_dir = str(config.get("download_dir") or DEFAULT_CONFIG["download_dir"])
     anipy_cli_fallback_enabled = config.get("anipy_cli_fallback_enabled")
+    download_methods = config.get("download_methods")
     auto_refresh_enabled = config.get("watchlist_auto_refresh_enabled")
     auto_refresh_minutes = config.get("watchlist_auto_refresh_minutes")
     refresh_delay_seconds = config.get("watchlist_refresh_delay_seconds")
@@ -468,6 +492,18 @@ def normalize_config(data):
         anipy_cli_fallback_enabled = anipy_cli_fallback_enabled.strip().lower() in {"1", "true", "yes", "on"}
     else:
         anipy_cli_fallback_enabled = bool(anipy_cli_fallback_enabled)
+    if isinstance(download_methods, str):
+        method_values = [part.strip().lower() for part in re.split(r"[\s,]+", download_methods) if part.strip()]
+    elif isinstance(download_methods, list):
+        method_values = [str(part or "").strip().lower() for part in download_methods]
+    else:
+        method_values = []
+    normalized_methods = []
+    for method in method_values:
+        if method in DOWNLOAD_METHOD_CHOICES and method not in normalized_methods:
+            normalized_methods.append(method)
+    if not normalized_methods or not source_has_download_methods:
+        normalized_methods = ["ani-cli", "anipy-cli"] if anipy_cli_fallback_enabled else ["ani-cli"]
     if isinstance(auto_refresh_enabled, str):
         auto_refresh_enabled = auto_refresh_enabled.strip().lower() in {"1", "true", "yes", "on"}
     else:
@@ -501,7 +537,8 @@ def normalize_config(data):
     config["mode"] = mode if mode in MODE_CHOICES else "sub"
     config["quality"] = quality if quality in QUALITY_CHOICES else "best"
     config["download_dir"] = str(Path(download_dir).expanduser())
-    config["anipy_cli_fallback_enabled"] = anipy_cli_fallback_enabled
+    config["download_methods"] = normalized_methods
+    config["anipy_cli_fallback_enabled"] = len(normalized_methods) > 1
     config["watchlist_auto_refresh_enabled"] = auto_refresh_enabled
     config["watchlist_auto_refresh_minutes"] = auto_refresh_minutes
     config["watchlist_refresh_delay_seconds"] = refresh_delay_seconds
@@ -976,6 +1013,10 @@ def cli_executable_exists(command):
     return bool(shutil.which(text) or (Path(text).exists() and os.access(text, os.X_OK)))
 
 
+def cli_executable_exists_any(*commands):
+    return any(cli_executable_exists(command) for command in commands)
+
+
 def printable_command(command):
     return " ".join(sh_quote(part) for part in command)
 
@@ -1131,7 +1172,7 @@ def finalize_library_files(job):
             final_name = f"{library_name}{source.suffix}"
         else:
             ep = None
-            if backend == "anipy-cli" and requested_episode_values:
+            if backend in {"anipy-cli", "animdl"} and requested_episode_values:
                 ep = requested_episode_values.pop(0)
             if ep is None:
                 ep = extract_episode_from_filename(source)
@@ -1211,6 +1252,22 @@ def command_for_job(job, backend="ani-cli", download_path=None):
         if download_path:
             command.extend(["-l", str(download_path)])
         return command
+    if normalized_backend == "animdl":
+        query = str(job.get("query") or "").strip()
+        command = [
+            ANIMDL,
+            "download",
+            query,
+            "-r",
+            job["episodes"],
+            "-q",
+            job["quality"],
+            "--index",
+            "1",
+        ]
+        if download_path:
+            command.extend(["-d", str(download_path)])
+        return command
     command = [
         ANI_CLI,
         "-d",

config_page.py

@@ -21,6 +21,7 @@ CONFIG_HTML = r"""<!doctype html>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>ani-cli web - config</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="/favicon.png">
   <style>
     :root {
       color-scheme: dark;
@@ -462,6 +463,7 @@ CONFIG_HTML = r"""<!doctype html>
           <p id="versionLine">Loading version...</p>
           <p id="aniCliVersionLine">Detecting ani-cli version...</p>
           <p id="anipyCliVersionLine">Detecting anipy-cli fallback...</p>
+          <p id="animdlVersionLine">Detecting animdl fallback...</p>
           <p>Saved settings live in `.ani-cli-web/config.json` inside this project.</p>
         </div>
         <button class="ghost wide-button" id="openChangelogBtn" type="button">Changelog</button>
@@ -511,18 +513,15 @@ CONFIG_HTML = r"""<!doctype html>
           <div class="toolbar">
             <div>
               <h2>Download fallback</h2>
-              <p class="muted">If a queued `ani-cli` download fails, optionally retry it once with `anipy-cli`.</p>
+              <p class="muted">Choose the download methods queue jobs may use, in fallback order.</p>
             </div>
           </div>
-          <div class="form-grid">
-            <label>Automatic retry with anipy-cli
-              <select id="anipyCliFallbackEnabled">
-                <option value="false">Disabled</option>
-                <option value="true">Enabled</option>
-              </select>
-            </label>
+          <div class="check-grid">
+            <label class="check-item"><input class="download-method" type="checkbox" value="ani-cli"> <span>ani-cli</span></label>
+            <label class="check-item"><input class="download-method" type="checkbox" value="anipy-cli"> <span>anipy-cli</span></label>
+            <label class="check-item"><input class="download-method" type="checkbox" value="animdl"> <span>animdl</span></label>
           </div>
-          <div class="field-hint">This only kicks in after an `ani-cli` failure. Install `anipy-cli` separately and keep it in `PATH` if you enable this option.</div>
+          <div class="field-hint">Jobs try checked methods in this order: ani-cli, anipy-cli, animdl. With one method checked, fallback retry is disabled.</div>
         </section>
 
         <section class="settings settings-main">
@@ -686,6 +685,7 @@ CONFIG_HTML = r"""<!doctype html>
         quality: "best",
         download_dir: "",
         anipy_cli_fallback_enabled: false,
+        download_methods: ["ani-cli"],
         watchlist_auto_refresh_enabled: false,
         watchlist_auto_refresh_minutes: 60,
         watchlist_refresh_delay_seconds: 5,
@@ -747,12 +747,17 @@ CONFIG_HTML = r"""<!doctype html>
       return [...document.querySelectorAll(".webhook-event:checked")].map((input) => input.value);
     }
 
+    function selectedDownloadMethods() {
+      const methods = [...document.querySelectorAll(".download-method:checked")].map((input) => input.value);
+      return methods.length ? methods : ["ani-cli"];
+    }
+
     function formConfigPayload() {
       return {
         download_dir: $("downloadDir").value,
         mode: $("configMode").value,
         quality: $("configQuality").value,
-        anipy_cli_fallback_enabled: $("anipyCliFallbackEnabled").value === "true",
+        download_methods: selectedDownloadMethods(),
         watchlist_auto_refresh_enabled: $("watchlistAutoRefreshEnabled").value === "true",
         watchlist_auto_refresh_minutes: $("watchlistAutoRefreshMinutes").value,
         watchlist_refresh_delay_seconds: $("watchlistRefreshDelaySeconds").value,
@@ -772,7 +777,10 @@ CONFIG_HTML = r"""<!doctype html>
       $("downloadDir").value = data.download_dir;
       $("configMode").value = data.mode;
       $("configQuality").value = data.quality;
-      $("anipyCliFallbackEnabled").value = String(Boolean(data.anipy_cli_fallback_enabled));
+      const methods = new Set(data.download_methods || ["ani-cli"]);
+      for (const input of document.querySelectorAll(".download-method")) {
+        input.checked = methods.has(input.value);
+      }
       $("watchlistAutoRefreshEnabled").value = String(Boolean(data.watchlist_auto_refresh_enabled));
       $("watchlistAutoRefreshMinutes").value = data.watchlist_auto_refresh_minutes;
       $("watchlistRefreshDelaySeconds").value = data.watchlist_refresh_delay_seconds;
@@ -983,6 +991,7 @@ CONFIG_HTML = r"""<!doctype html>
       $("versionLine").textContent = `${data.name} ${data.version}`;
       $("aniCliVersionLine").textContent = `ani-cli ${data.ani_cli_version || "Unavailable"}`;
       $("anipyCliVersionLine").textContent = `anipy-cli ${data.anipy_cli_version || "Unavailable"}`;
+      $("animdlVersionLine").textContent = `animdl ${data.animdl_version || "Unavailable"}`;
     }
 
     async function openChangelog() {

docker-compose.yaml

@@ -6,7 +6,6 @@ services:
       args:
         ANI_CLI: ${ANI_CLI:-https://github.com/pystardust/ani-cli.git}
         ANI_CLI_BRANCH: ${ANI_CLI_BRANCH:-master}
-        ANI_CLI_WEB: ${ANI_CLI_WEB:-https://gitea.coreplay.eu/Dymas/ani-cli-web.git}
     image: ani-cli-web:latest
     container_name: ani-cli-web
     restart: unless-stopped
@@ -21,6 +20,7 @@ services:
       ANI_CLI_WEB_ALLOW_REMOTE: ${ANI_CLI_WEB_ALLOW_REMOTE:-false}
       ANI_CLI_WEB_AUTH_USERNAME: ${ANI_CLI_WEB_AUTH_USERNAME:-}
       ANI_CLI_WEB_AUTH_PASSWORD: ${ANI_CLI_WEB_AUTH_PASSWORD:-}
+      ANI_CLI_WEB_JOB_STDOUT: ${ANI_CLI_WEB_JOB_STDOUT:-true}
       ANI_CLI_DOWNLOAD_DIR: /downloads
     volumes:
       - ./downloads:/downloads

http_handler.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from urllib.parse import parse_qs, unquote, urlencode, urlparse, urlunparse
 
 from app_support import (
+    ANIMDL,
     ANI_CLI,
     ANIPY_CLI,
     APP_NAME,
@@ -27,12 +28,14 @@ from app_support import (
     CLIENT_DISCONNECT_ERRORS,
     MAX_JSON_BODY_BYTES,
     MODE_CHOICES,
+    PROJECT_ROOT,
     VERSION,
     client_address_is_local,
     configured_remote_path_roots,
     debug_enabled,
     debug_log,
     load_project_text_file,
+    cli_executable_exists_any,
     cli_executable_exists,
     normalize_config,
     path_is_within_roots,
@@ -46,6 +49,8 @@ from app_support import (
     validate_discord_webhook_url,
 )
 
+FAVICON_PATH = PROJECT_ROOT / "favicon.png"
+
 @dataclass(frozen=True)
 class HandlerContext:
     add_to_watchlist: object
@@ -90,7 +95,18 @@ def dependency_status():
     checks = ["curl", "sed", "grep", "openssl", "fzf", "aria2c", "ffmpeg", "yt-dlp"]
     result = {name: bool(shutil.which(name)) for name in checks}
     result["ani-cli"] = cli_executable_exists(ANI_CLI)
-    result["anipy-cli"] = cli_executable_exists(ANIPY_CLI)
+    result["anipy-cli"] = cli_executable_exists_any(
+        ANIPY_CLI,
+        "anipy-cli",
+        "/usr/local/bin/anipy-cli",
+        "/usr/bin/anipy-cli",
+    )
+    result["animdl"] = cli_executable_exists_any(
+        ANIMDL,
+        "animdl",
+        "/usr/local/bin/animdl",
+        "/usr/bin/animdl",
+    )
     return result
 
 
@@ -153,6 +169,66 @@ def browse_filesystem(path_value="", mode="dir", allowed_roots=None):
     }
 
 
+def queue_list_payload(runtime, page=1, per_page=10):
+    page = max(1, int(page or 1))
+    per_page = min(50, max(1, int(per_page or 10)))
+    download_queue = runtime["download_queue"]
+    jellyfin_jobs = runtime.get("watchlist_jellyfin_sync")
+    download_payload = download_queue.list(page=1, per_page=50)
+    jobs = list(download_payload.get("jobs") or [])
+    for download_page in range(2, int(download_payload.get("pages") or 1) + 1):
+        jobs.extend(download_queue.list(page=download_page, per_page=50).get("jobs") or [])
+    if jellyfin_jobs is not None:
+        jobs.extend(jellyfin_jobs.list_queue_jobs(limit=200))
+    jobs.sort(key=lambda job: str(job.get("created_at") or ""), reverse=True)
+    total = len(jobs)
+    pages = max(1, (total + per_page - 1) // per_page)
+    offset = (page - 1) * per_page
+    return {
+        "jobs": jobs[offset : offset + per_page],
+        "page": page,
+        "per_page": per_page,
+        "total": total,
+        "pages": pages,
+    }
+
+
+def queue_get_job(runtime, job_id):
+    try:
+        return runtime["download_queue"].get(job_id)
+    except KeyError:
+        jellyfin_jobs = runtime.get("watchlist_jellyfin_sync")
+        if jellyfin_jobs is None:
+            raise
+        return jellyfin_jobs.get_queue_job(job_id)
+
+
+def queue_remove_job(runtime, job_id):
+    try:
+        return runtime["download_queue"].remove(job_id)
+    except KeyError:
+        jellyfin_jobs = runtime.get("watchlist_jellyfin_sync")
+        if jellyfin_jobs is None:
+            raise
+        return jellyfin_jobs.remove_queue_job(job_id)
+
+
+def queue_clear_finished(runtime):
+    result = runtime["download_queue"].clear_finished()
+    jellyfin_jobs = runtime.get("watchlist_jellyfin_sync")
+    if jellyfin_jobs is not None:
+        result["count"] = int(result.get("count") or 0) + int(jellyfin_jobs.clear_finished_queue_jobs().get("count") or 0)
+    return result
+
+
+def queue_clear_failed(runtime):
+    result = runtime["download_queue"].clear_failed()
+    jellyfin_jobs = runtime.get("watchlist_jellyfin_sync")
+    if jellyfin_jobs is not None:
+        result["count"] = int(result.get("count") or 0) + int(jellyfin_jobs.clear_failed_queue_jobs().get("count") or 0)
+    return result
+
+
 @lru_cache(maxsize=1)
 def installed_ani_cli_version():
     try:
@@ -185,6 +261,22 @@ def installed_anipy_cli_version():
     return version or "Unavailable"
 
 
+@lru_cache(maxsize=1)
+def installed_animdl_version():
+    try:
+        completed = subprocess.run(
+            [ANIMDL, "--version"],
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=6,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return "Unavailable"
+    version = str(completed.stdout or completed.stderr or "").strip()
+    return version or "Unavailable"
+
+
 class Handler(BaseHTTPRequestHandler):
     server_version = "AniCliWeb/1.0"
     remote_session_cookie_name = "ani_cli_web_session"
@@ -382,6 +474,7 @@ class Handler(BaseHTTPRequestHandler):
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>{APP_NAME} sign in</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="/favicon.png">
   <style>
     :root {{
       color-scheme: dark;
@@ -545,6 +638,11 @@ class Handler(BaseHTTPRequestHandler):
             self.ensure_client_access()
             if parsed.path == "/":
                 self.html(Handler._context(self).index_html)
+            elif parsed.path in {"/favicon.png", "/favicon.ico"}:
+                if not FAVICON_PATH.exists():
+                    self.error(HTTPStatus.NOT_FOUND, "Favicon not found")
+                    return
+                self.file(FAVICON_PATH)
             elif parsed.path == "/queue":
                 self.html(Handler._context(self).queue_html)
             elif parsed.path == "/config":
@@ -560,6 +658,7 @@ class Handler(BaseHTTPRequestHandler):
                         "version": VERSION,
                         "ani_cli_version": installed_ani_cli_version(),
                         "anipy_cli_version": installed_anipy_cli_version(),
+                        "animdl_version": installed_animdl_version(),
                     }
                 )
             elif parsed.path == "/api/changelog":
@@ -610,7 +709,7 @@ class Handler(BaseHTTPRequestHandler):
                 params = parse_qs(parsed.query)
                 page = (params.get("page") or ["1"])[0]
                 per_page = (params.get("per_page") or ["10"])[0]
-                self.json(runtime["download_queue"].list(page=page, per_page=per_page))
+                self.json(queue_list_payload(runtime, page=page, per_page=per_page))
             elif parsed.path.startswith("/api/queue/"):
                 runtime = Handler._runtime(self)
                 parts = parsed.path.strip("/").split("/")
@@ -618,7 +717,7 @@ class Handler(BaseHTTPRequestHandler):
                     self.error(HTTPStatus.NOT_FOUND, "Not found")
                     return
                 _, _, job_id = parts
-                self.json(runtime["download_queue"].get(job_id))
+                self.json(queue_get_job(runtime, job_id))
             elif parsed.path.startswith("/api/watchlist/thumb/"):
                 runtime = Handler._runtime(self)
                 show_id = unquote(parsed.path[len("/api/watchlist/thumb/") :]).strip()
@@ -703,7 +802,10 @@ class Handler(BaseHTTPRequestHandler):
                 self.json(runtime["download_queue"].retry_all_failed())
             elif parsed.path == "/api/queue/clear-finished":
                 runtime = Handler._runtime(self)
-                self.json(runtime["download_queue"].clear_finished())
+                self.json(queue_clear_finished(runtime))
+            elif parsed.path == "/api/queue/clear-failed":
+                runtime = Handler._runtime(self)
+                self.json(queue_clear_failed(runtime))
             elif parsed.path.startswith("/api/queue/"):
                 runtime = Handler._runtime(self)
                 parts = parsed.path.strip("/").split("/")
@@ -714,7 +816,7 @@ class Handler(BaseHTTPRequestHandler):
                 actions = {
                     "retry": runtime["download_queue"].retry,
                     "cancel": runtime["download_queue"].cancel,
-                    "remove": runtime["download_queue"].remove,
+                    "remove": lambda job_id: queue_remove_job(runtime, job_id),
                 }
                 if action not in actions:
                     self.error(HTTPStatus.NOT_FOUND, "Not found")

queue_jobs.py

@@ -13,7 +13,10 @@ import time
 import re
 
 from app_support import (
+    ANIMDL,
     ANIPY_CLI,
+    ANI_CLI,
+    DOWNLOAD_METHOD_CHOICES,
     MAX_LOG_LINES,
     PROJECT_ROOT,
     QUEUE_PATH,
@@ -26,6 +29,7 @@ from app_support import (
     finalize_library_files,
     job_output_dir,
     job_staging_dir,
+    job_stdout_enabled,
     load_json,
     normalize_config,
     now_iso,
@@ -37,6 +41,11 @@ from app_support import (
 
 LOG_PERSIST_INTERVAL_SECONDS = 0.75
 LOG_PERSIST_LINE_BATCH = 8
+DOWNLOAD_BACKEND_COMMANDS = {
+    "ani-cli": ANI_CLI,
+    "anipy-cli": ANIPY_CLI,
+    "animdl": ANIMDL,
+}
 JOB_STRUCTURED_COLUMNS = (
     "show_id",
     "title",
@@ -647,6 +656,74 @@ class JellyfinSyncJobs:
     def _copy_job(self, job):
         return json.loads(json.dumps(job))
 
+    def _queue_job_payload(self, job):
+        config = job.get("config") or {}
+        target_paths = [
+            str(config.get(key) or "").strip()
+            for key in ("jellyfin_tv_dir", "jellyfin_movie_dir")
+            if str(config.get(key) or "").strip()
+        ]
+        log_lines = [str(job.get("message") or "")]
+        if job.get("current_file"):
+            log_lines.append(f"Moving: {job['current_file']}")
+        for item in job.get("items") or []:
+            title = str(item.get("title") or item.get("show_id") or "Unknown title")
+            outcome = "moved" if item.get("moved") else str(item.get("reason") or "skipped")
+            target = str(item.get("target") or "").strip()
+            suffix = f" -> {target}" if target else ""
+            log_lines.append(f"{title}: {outcome}{suffix}")
+        payload = self._copy_job(job)
+        payload.update(
+            {
+                "job_type": "jellyfin_handoff",
+                "title": "Jellyfin handoff",
+                "anime_name": "Jellyfin handoff",
+                "mode": "copy",
+                "quality": "library",
+                "episodes": f"{int(job.get('completed') or 0)}/{int(job.get('total') or 0)} entries",
+                "download_dir": str(config.get("download_dir") or ""),
+                "target_dir": ", ".join(target_paths),
+                "exit_code": 1 if job.get("status") == "failed" else None,
+                "log": [line for line in log_lines if line],
+            }
+        )
+        return payload
+
+    def list_queue_jobs(self, limit=50):
+        limit = min(200, max(1, int(limit or 50)))
+        with self.lock, self._connect() as conn:
+            rows = conn.execute(
+                "SELECT payload FROM jellyfin_sync_jobs ORDER BY created_at DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+        return [self._queue_job_payload(self._job_from_row(row)) for row in rows]
+
+    def get_queue_job(self, job_id):
+        with self.lock, self._connect() as conn:
+            row = conn.execute("SELECT payload FROM jellyfin_sync_jobs WHERE id = ?", (job_id,)).fetchone()
+        if row:
+            return self._queue_job_payload(self._job_from_row(row))
+        raise KeyError("Job not found")
+
+    def remove_queue_job(self, job_id):
+        with self.lock:
+            job = self.get_queue_job(job_id)
+            if job["status"] in {"pending", "running"}:
+                raise ValueError("Running Jellyfin handoff jobs cannot be removed")
+            with self._connect() as conn:
+                conn.execute("DELETE FROM jellyfin_sync_jobs WHERE id = ?", (job_id,))
+            return {"ok": True}
+
+    def clear_finished_queue_jobs(self):
+        with self.lock, self._connect() as conn:
+            cursor = conn.execute("DELETE FROM jellyfin_sync_jobs WHERE status IN ('done', 'interrupted')")
+            return {"ok": True, "count": cursor.rowcount}
+
+    def clear_failed_queue_jobs(self):
+        with self.lock, self._connect() as conn:
+            cursor = conn.execute("DELETE FROM jellyfin_sync_jobs WHERE status = 'failed'")
+            return {"ok": True, "count": cursor.rowcount}
+
     def _find_locked(self, job_id):
         for job in self.jobs:
             if job["id"] == job_id:
@@ -1136,6 +1213,51 @@ class DownloadQueue:
         with self.lock:
             return self._find(job_id)
 
+    def _job_identity_fields(self, job):
+        return (
+            str(job.get("show_id") or "").strip(),
+            str(job.get("title") or "").strip(),
+            str(job.get("anime_name") or "").strip(),
+            str(job.get("media_type") or "").strip(),
+            str(job.get("season") or "").strip(),
+            str(job.get("episode_offset") or "").strip(),
+            str(job.get("query") or "").strip(),
+            job.get("result_index"),
+            str(job.get("mode") or "").strip().lower(),
+            str(job.get("quality") or "").strip().lower(),
+            str(job.get("episodes") or "").strip(),
+            str(job.get("download_dir") or "").strip(),
+        )
+
+    def _find_reusable_failed_job_locked(self, job):
+        expected = self._job_identity_fields(job)
+        with self._connect() as conn:
+            rows = conn.execute(
+                """
+                SELECT *
+                FROM jobs
+                WHERE status = 'failed'
+                ORDER BY created_at DESC
+                """
+            ).fetchall()
+        for row in rows:
+            candidate = self._job_from_row(row)
+            if self._job_identity_fields(candidate) == expected:
+                return candidate
+        return None
+
+    def _reset_retryable_job_locked(self, job):
+        job["status"] = "pending"
+        job["exit_code"] = None
+        job["pid"] = None
+        job["started_at"] = None
+        job["finished_at"] = None
+        job["updated_at"] = now_iso()
+        job["cancel_requested"] = False
+        job["log"] = []
+        self._save_job_locked(job)
+        return job
+
     def add(self, payload):
         job = build_job(payload, self.config_getter())
         if self.job_prepare_fn is not None:
@@ -1143,6 +1265,10 @@ class DownloadQueue:
             if prepared is not None:
                 job = prepared
         with self.lock:
+            reusable = self._find_reusable_failed_job_locked(job)
+            if reusable is not None:
+                job = self._reset_retryable_job_locked(reusable)
+            else:
                 self._save_job_locked(job)
         self.wakeup.set()
         return job
@@ -1221,15 +1347,7 @@ class DownloadQueue:
                 raise ValueError("Running jobs cannot be retried")
             if job["status"] not in {"failed", "canceled"}:
                 raise ValueError("Only failed or canceled jobs can be retried")
-            job["status"] = "pending"
-            job["exit_code"] = None
-            job["pid"] = None
-            job["started_at"] = None
-            job["finished_at"] = None
-            job["updated_at"] = now_iso()
-            job["cancel_requested"] = False
-            job["log"] = []
-            self._save_job_locked(job)
+            job = self._reset_retryable_job_locked(job)
         self.wakeup.set()
         return job
 
@@ -1291,6 +1409,11 @@ class DownloadQueue:
             cursor = conn.execute("DELETE FROM jobs WHERE status IN ('done', 'canceled')")
             return {"ok": True, "count": cursor.rowcount}
 
+    def clear_failed(self):
+        with self.lock, self._connect() as conn:
+            cursor = conn.execute("DELETE FROM jobs WHERE status = 'failed'")
+            return {"ok": True, "count": cursor.rowcount}
+
     def _find(self, job_id):
         with self._connect() as conn:
             row = conn.execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
@@ -1312,6 +1435,7 @@ class DownloadQueue:
         text = strip_control(line).strip()
         if not text:
             return
+        self._stdout_log(job, text)
         with self.lock:
             job.setdefault("log", []).append(text)
             job["log"] = job["log"][-MAX_LOG_LINES:]
@@ -1325,6 +1449,16 @@ class DownloadQueue:
             if should_flush:
                 self._save_job_locked(job)
 
+    def _stdout_log(self, job, line):
+        if not job_stdout_enabled():
+            return
+        text = strip_control(str(line)).strip()
+        if not text:
+            return
+        job_id = str((job or {}).get("id") or "-")
+        backend = str((job or {}).get("download_backend") or "download")
+        print(f"[download:{job_id}:{backend}] {text}", flush=True)
+
     def _cleanup_staging_dir(self, job):
         staging_dir = job_staging_dir(job)
         if not staging_dir.exists():
@@ -1376,9 +1510,9 @@ class DownloadQueue:
         self._cleanup_staging_dir(job)
 
     def _command_attempts(self, job, staging_dir):
-        config = normalize_config(self.config_getter() or {})
-        attempts = [
-            {
+        def attempt_for(method):
+            if method == "ani-cli":
+                return {
                     "backend": "ani-cli",
                     "command": command_for_job(job, backend="ani-cli"),
                     "env": {
@@ -1389,21 +1523,33 @@ class DownloadQueue:
                         "TERM": os.environ.get("TERM", "xterm-256color"),
                     },
                 }
-        ]
-        fallback_enabled = bool(config.get("anipy_cli_fallback_enabled"))
-        fallback_available = cli_executable_exists(ANIPY_CLI)
-        if fallback_enabled and fallback_available:
-            attempts.append(
-                {
-                    "backend": "anipy-cli",
-                    "command": command_for_job(job, backend="anipy-cli", download_path=staging_dir),
+            return {
+                "backend": method,
+                "command": command_for_job(job, backend=method, download_path=staging_dir),
                 "env": {
                     **os.environ.copy(),
                     "TERM": os.environ.get("TERM", "xterm-256color"),
                 },
             }
-            )
-        return attempts, fallback_enabled, fallback_available
+
+        config = normalize_config(self.config_getter() or {})
+        selected_methods = [
+            method
+            for method in config.get("download_methods") or ["ani-cli"]
+            if method in DOWNLOAD_METHOD_CHOICES
+        ]
+        if not selected_methods:
+            selected_methods = ["ani-cli"]
+        attempts = []
+        unavailable_methods = []
+        for method in selected_methods:
+            if not cli_executable_exists(DOWNLOAD_BACKEND_COMMANDS.get(method)):
+                unavailable_methods.append(method)
+                continue
+            attempts.append(attempt_for(method))
+        if not attempts and selected_methods == ["ani-cli"]:
+            attempts.append(attempt_for("ani-cli"))
+        return attempts, selected_methods, unavailable_methods
 
     def _run(self):
         while not self.stop_event.is_set():
@@ -1419,7 +1565,34 @@ class DownloadQueue:
         target_dir = job_output_dir(job)
         staging_dir.mkdir(parents=True, exist_ok=True)
         target_dir.mkdir(parents=True, exist_ok=True)
-        attempts, fallback_enabled, fallback_available = self._command_attempts(job, staging_dir)
+        attempts, selected_methods, unavailable_methods = self._command_attempts(job, staging_dir)
+        if not attempts:
+            with self.lock:
+                job["status"] = "failed"
+                job["started_at"] = now_iso()
+                job["finished_at"] = job["started_at"]
+                job["updated_at"] = job["finished_at"]
+                job["exit_code"] = 1
+                job["pid"] = None
+                job["staging_dir"] = str(staging_dir)
+                job["target_dir"] = str(target_dir)
+                job["download_backend"] = selected_methods[0] if selected_methods else None
+                job["fallback_used"] = False
+                job["log"] = [
+                    f"Staging in: {job['staging_dir']}",
+                    f"Final folder: {job['target_dir']}",
+                    f"Download methods: {', '.join(selected_methods)}",
+                    (
+                        "No selected download methods are installed or executable: "
+                        f"{', '.join(unavailable_methods or selected_methods)}."
+                    ),
+                ]
+                self.current_process = None
+                self.current_job_id = None
+                self.current_job = None
+                self._save_job_locked(job)
+            self._cleanup_staging_dir(job)
+            return
         primary_command = attempts[0]["command"]
 
         with self.lock:
@@ -1429,17 +1602,21 @@ class DownloadQueue:
             job["command"] = printable_command(primary_command)
             job["staging_dir"] = str(staging_dir)
             job["target_dir"] = str(target_dir)
-            job["download_backend"] = "ani-cli"
+            job["download_backend"] = attempts[0]["backend"]
             job["fallback_used"] = False
             job["log"] = [
                 f"Starting: {job['command']}",
                 f"Staging in: {job['staging_dir']}",
                 f"Final folder: {job['target_dir']}",
+                f"Download methods: {', '.join(selected_methods)}",
             ]
-            if fallback_enabled and fallback_available:
-                job["log"].append("anipy-cli fallback is enabled and will retry automatically if ani-cli fails.")
-            elif fallback_enabled:
-                job["log"].append("anipy-cli fallback is enabled, but anipy-cli is not installed or not executable.")
+            if len(attempts) > 1:
+                job["log"].append("Fallback retry is enabled for the selected download methods.")
+            if unavailable_methods:
+                job["log"].append(
+                    "Skipped unavailable download method"
+                    f"{'s' if len(unavailable_methods) != 1 else ''}: {', '.join(unavailable_methods)}."
+                )
             job["cancel_requested"] = False
             job["_dirty_log_lines"] = 0
             self._save_job_locked(job)
@@ -1479,8 +1656,8 @@ class DownloadQueue:
                     )
                 except Exception as exc:
                     if should_fallback:
-                        self._append_log(job, f"ani-cli could not start: {exc}")
-                        self._append_log(job, "Retrying with anipy-cli fallback.")
+                        self._append_log(job, f"{backend} could not start: {exc}")
+                        self._append_log(job, f"Retrying with {attempts[index + 1]['backend']} fallback.")
                         self._cleanup_staging_dir(job)
                         staging_dir.mkdir(parents=True, exist_ok=True)
                         continue
@@ -1507,9 +1684,9 @@ class DownloadQueue:
                 if job.get("cancel_requested"):
                     break
 
-                if backend == "ani-cli" and exit_code != 0 and should_fallback:
-                    self._append_log(job, f"ani-cli failed with exit code {exit_code}.")
-                    self._append_log(job, "Retrying with anipy-cli fallback.")
+                if exit_code != 0 and should_fallback:
+                    self._append_log(job, f"{backend} failed with exit code {exit_code}.")
+                    self._append_log(job, f"Retrying with {attempts[index + 1]['backend']} fallback.")
                     self._cleanup_staging_dir(job)
                     staging_dir.mkdir(parents=True, exist_ok=True)
                     continue
@@ -1520,10 +1697,10 @@ class DownloadQueue:
                     except Exception as exc:
                         finalize_error = exc
                         no_files_downloaded = "No downloaded files were found in the staging folder" in str(exc)
-                        if backend == "ani-cli" and no_files_downloaded and should_fallback:
+                        if no_files_downloaded and should_fallback:
                             self._append_log(
                                 job,
-                                "ani-cli exited without downloading any files. Retrying with anipy-cli fallback.",
+                                f"{backend} exited without downloading any files. Retrying with {attempts[index + 1]['backend']} fallback.",
                             )
                             self._cleanup_staging_dir(job)
                             staging_dir.mkdir(parents=True, exist_ok=True)
@@ -1560,8 +1737,8 @@ class DownloadQueue:
                     cleanup_staging = True
                 elif exit_code == 0:
                     job["status"] = "done"
-                    if successful_backend == "anipy-cli":
-                        job.setdefault("log", []).append("Fallback download completed with anipy-cli.")
+                    if successful_backend and successful_backend != attempts[0]["backend"]:
+                        job.setdefault("log", []).append(f"Fallback download completed with {successful_backend}.")
                     for path in moved_files:
                         job.setdefault("log", []).append(f"Saved: {path}")
                     job.setdefault("log", []).append("Download completed.")

queue_page.py

@@ -11,6 +11,7 @@ QUEUE_HTML = r"""<!doctype html>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>ani-cli web queue</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="/favicon.png">
   <style>
     :root {
       color-scheme: dark;
@@ -317,6 +318,7 @@ QUEUE_HTML = r"""<!doctype html>
         <p class="muted">Monitor active downloads, inspect recent output, and clean up finished jobs without leaving the queue view.</p>
         <div class="row">
           <button class="ghost" id="retryFailedBtn" type="button">Retry failed</button>
+          <button class="ghost" id="clearFailedBtn" type="button">Clear failed</button>
           <button class="ghost" id="removeFinishedBtn" type="button">Remove finished</button>
         </div>
       </section>
@@ -388,6 +390,13 @@ QUEUE_HTML = r"""<!doctype html>
     }
 
     function buildJobSummary(job) {
+      if (job.job_type === "jellyfin_handoff") {
+        const progress = `${job.completed || 0}/${job.total || 0} entries`;
+        const moved = `${job.moved || 0} moved`;
+        const files = `${job.moved_files || 0} files`;
+        const target = job.target_dir || "Jellyfin libraries";
+        return `${progress} · ${moved} · ${files} · ${target}`;
+      }
       const libraryName = job.anime_name || job.title;
       const season = String(job.season || "1").padStart(2, "0");
       const seasonFolder = `Season ${season}`;
@@ -401,6 +410,12 @@ QUEUE_HTML = r"""<!doctype html>
 
     function renderJobActions(job, actions) {
       actions.innerHTML = "";
+      if (job.job_type === "jellyfin_handoff") {
+        if (job.status !== "running" && job.status !== "pending") {
+          actions.append(actionButton("Remove", () => queueAction(job.id, "remove")));
+        }
+        return;
+      }
       if (job.status === "running" || job.status === "pending") {
         actions.append(actionButton("Cancel", () => queueAction(job.id, "cancel"), "danger"));
         return;
@@ -414,14 +429,14 @@ QUEUE_HTML = r"""<!doctype html>
     function updateJobCard(item, job) {
       item.dataset.jobId = job.id;
       item.dataset.jobStatus = job.status;
-      item.querySelector(".job-title").textContent = job.title;
+      item.querySelector(".job-title").textContent = job.title || "Untitled job";
       item.querySelector(".job-head .muted").textContent = buildJobSummary(job);
       const status = item.querySelector(".status");
       status.textContent = job.status;
       status.className = "status";
       status.classList.add(job.status);
       item.querySelector("pre").textContent = buildJobLog(job) || "Waiting...";
-      item.querySelector(".toolbar .muted").textContent = job.exit_code === null ? "" : `exit ${job.exit_code}`;
+      item.querySelector(".toolbar .muted").textContent = job.exit_code === null || job.exit_code === undefined ? "" : `exit ${job.exit_code}`;
       renderJobActions(job, item.querySelector(".row"));
       state.jobCards[job.id] = item;
     }
@@ -548,6 +563,7 @@ QUEUE_HTML = r"""<!doctype html>
     }
 
     $("removeFinishedBtn").addEventListener("click", () => queueBulkAction("/api/queue/clear-finished", "Removed finished and canceled jobs"));
+    $("clearFailedBtn").addEventListener("click", () => queueBulkAction("/api/queue/clear-failed", "Removed failed jobs"));
     $("retryFailedBtn").addEventListener("click", () => queueBulkAction("/api/queue/retry-failed", "Retried failed jobs"));
 
     (async function init() {

search_page.py

@@ -11,6 +11,7 @@ INDEX_HTML = r"""<!doctype html>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>ani-cli web</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="/favicon.png">
   <style>
     :root {
       color-scheme: dark;

test_app.py

@@ -176,6 +176,14 @@ class NetworkGuardTests(unittest.TestCase):
         self.assertIn("Username", body)
         self.assertIn("Password", body)
 
+    def test_favicon_route_serves_checked_in_png(self):
+        handler = DummyHandler("/favicon.png")
+        handler.command = "GET"
+
+        APP.Handler.do_GET(handler)
+
+        self.assertEqual(handler.file_path, http_handler.FAVICON_PATH)
+
     def test_remote_login_page_escapes_hidden_next_value(self):
         handler = DummyHandler('/?next="><script>alert(1)</script>')
         handler.client_address = ("192.168.1.25", 8421)
@@ -373,6 +381,21 @@ class DownloadQueueCancelTests(unittest.TestCase):
         self.assertEqual(len(saved), 1)
         self.assertEqual(saved[0][-1], "line flush")
 
+    def test_append_log_can_mirror_download_output_to_stdout(self):
+        queue = object.__new__(APP.DownloadQueue)
+        queue.lock = threading.RLock()
+        queue._save_job_locked = lambda _job: None
+        job = {"id": "job-1", "download_backend": "animdl", "log": [], "updated_at": APP.now_iso()}
+
+        with mock.patch.dict(os.environ, {"ANI_CLI_WEB_JOB_STDOUT": "true"}, clear=False), mock.patch("builtins.print") as print_mock:
+            APP.DownloadQueue._append_log(queue, job, "\x1b[32mDownloading episode 1\x1b[0m\n")
+
+        print_mock.assert_called_once_with(
+            "[download:job-1:animdl] Downloading episode 1",
+            flush=True,
+        )
+        self.assertEqual(job["log"], ["Downloading episode 1"])
+
 
 class QueueApiTests(unittest.TestCase):
     def setUp(self):
@@ -381,6 +404,7 @@ class QueueApiTests(unittest.TestCase):
         self.queue = APP.DOWNLOAD_QUEUE
         with self.queue._connect() as conn:
             conn.execute("DELETE FROM jobs")
+            conn.execute("DELETE FROM jellyfin_sync_jobs")
 
     def test_download_queue_get_returns_single_job(self):
         created = self.queue.add(
@@ -421,6 +445,42 @@ class QueueApiTests(unittest.TestCase):
         self.assertEqual(handler.json_status, HTTPStatus.OK)
         self.assertEqual(handler.json_payload["id"], created["id"])
 
+    def test_queue_route_includes_jellyfin_handoff_jobs(self):
+        APP.WATCHLIST_JELLYFIN_SYNC.start(
+            config={
+                "download_dir": "/tmp/downloads",
+                "jellyfin_sync_enabled": True,
+                "jellyfin_tv_dir": "/tmp/jellyfin-tv",
+                "jellyfin_movie_dir": "/tmp/jellyfin-movies",
+            }
+        )
+        handler = DummyHandler("/api/queue?page=1&per_page=10")
+
+        APP.Handler.do_GET(handler)
+
+        self.assertEqual(handler.json_status, HTTPStatus.OK)
+        jellyfin_jobs = [job for job in handler.json_payload["jobs"] if job.get("job_type") == "jellyfin_handoff"]
+        self.assertEqual(len(jellyfin_jobs), 1)
+        self.assertEqual(jellyfin_jobs[0]["title"], "Jellyfin handoff")
+        self.assertEqual(jellyfin_jobs[0]["mode"], "copy")
+
+    def test_queue_item_get_route_returns_jellyfin_handoff_job(self):
+        created = APP.WATCHLIST_JELLYFIN_SYNC.start(
+            config={
+                "download_dir": "/tmp/downloads",
+                "jellyfin_sync_enabled": True,
+                "jellyfin_tv_dir": "/tmp/jellyfin-tv",
+                "jellyfin_movie_dir": "",
+            }
+        )["job"]
+        handler = DummyHandler(f"/api/queue/{created['id']}")
+
+        APP.Handler.do_GET(handler)
+
+        self.assertEqual(handler.json_status, HTTPStatus.OK)
+        self.assertEqual(handler.json_payload["id"], created["id"])
+        self.assertEqual(handler.json_payload["job_type"], "jellyfin_handoff")
+
     def test_retry_rejects_done_jobs(self):
         created = self.queue.add(
             {
@@ -466,6 +526,121 @@ class QueueApiTests(unittest.TestCase):
         self.assertEqual(retried["status"], "pending")
         self.assertFalse(retried["cancel_requested"])
 
+    def test_add_reuses_matching_failed_job_instead_of_creating_duplicate(self):
+        payload = {
+            "show_id": "show-42",
+            "query": "Failed Show",
+            "title": "Failed Show",
+            "anime_name": "Failed Show",
+            "media_type": "tv",
+            "mode": "dub",
+            "quality": "best",
+            "episodes": "11",
+            "download_dir": "/tmp/example",
+            "season": "2",
+            "episode_offset": "13",
+        }
+        created = self.queue.add(payload)
+        with self.queue.lock:
+            job = self.queue._find(created["id"])
+            job["status"] = "failed"
+            job["exit_code"] = 1
+            job["cancel_requested"] = True
+            job["started_at"] = APP.now_iso()
+            job["finished_at"] = APP.now_iso()
+            job["log"] = ["Download failed"]
+            self.queue._save_job_locked(job)
+
+        retried = self.queue.add(payload)
+        listing = self.queue.list(per_page=10)
+
+        self.assertEqual(retried["id"], created["id"])
+        self.assertEqual(retried["status"], "pending")
+        self.assertEqual(retried["log"], [])
+        self.assertIsNone(retried["exit_code"])
+        self.assertFalse(retried["cancel_requested"])
+        self.assertEqual(listing["total"], 1)
+
+    def test_add_keeps_new_job_when_failed_job_differs(self):
+        created = self.queue.add(
+            {
+                "show_id": "show-42",
+                "query": "Failed Show",
+                "title": "Failed Show",
+                "anime_name": "Failed Show",
+                "media_type": "tv",
+                "mode": "dub",
+                "quality": "best",
+                "episodes": "11",
+                "download_dir": "/tmp/example",
+                "season": "2",
+                "episode_offset": "13",
+            }
+        )
+        with self.queue.lock:
+            job = self.queue._find(created["id"])
+            job["status"] = "failed"
+            self.queue._save_job_locked(job)
+
+        new_job = self.queue.add(
+            {
+                "show_id": "show-42",
+                "query": "Failed Show",
+                "title": "Failed Show",
+                "anime_name": "Failed Show",
+                "media_type": "tv",
+                "mode": "dub",
+                "quality": "720",
+                "episodes": "11",
+                "download_dir": "/tmp/example",
+                "season": "2",
+                "episode_offset": "13",
+            }
+        )
+        listing = self.queue.list(per_page=10)
+
+        self.assertNotEqual(new_job["id"], created["id"])
+        self.assertEqual(listing["total"], 2)
+
+    def test_clear_failed_removes_only_failed_jobs(self):
+        failed = self.queue.add(
+            {
+                "query": "Failed Show",
+                "title": "Failed Show",
+                "anime_name": "Failed Show",
+                "mode": "sub",
+                "quality": "best",
+                "episodes": "1",
+                "download_dir": "/tmp/example",
+                "season": "1",
+            }
+        )
+        done = self.queue.add(
+            {
+                "query": "Done Show",
+                "title": "Done Show",
+                "anime_name": "Done Show",
+                "mode": "sub",
+                "quality": "best",
+                "episodes": "1",
+                "download_dir": "/tmp/example",
+                "season": "1",
+            }
+        )
+        with self.queue.lock:
+            failed_job = self.queue._find(failed["id"])
+            failed_job["status"] = "failed"
+            self.queue._save_job_locked(failed_job)
+            done_job = self.queue._find(done["id"])
+            done_job["status"] = "done"
+            self.queue._save_job_locked(done_job)
+
+        result = self.queue.clear_failed()
+        listing = self.queue.list()
+
+        self.assertEqual(result["count"], 1)
+        self.assertEqual([job["id"] for job in listing["jobs"]], [done["id"]])
+
     def test_detach_show_clears_queue_coverage_and_sync_binding(self):
         created = self.queue.add(
             {
@@ -619,6 +794,36 @@ class QueueApiTests(unittest.TestCase):
             )
             self.assertTrue(Path(moved[0]).exists())
 
+    def test_tv_finalizer_uses_requested_episode_numbers_for_animdl_fallback(self):
+        with tempfile.TemporaryDirectory() as temp_root:
+            job = APP.app_support.build_job(
+                {
+                    "query": "Fallback Show",
+                    "title": "Fallback Show",
+                    "anime_name": "Fallback Show",
+                    "media_type": "tv",
+                    "mode": "sub",
+                    "quality": "best",
+                    "episodes": "12",
+                    "download_dir": temp_root,
+                    "season": "2",
+                },
+                {"mode": "sub", "quality": "best", "download_dir": temp_root},
+            )
+            job["download_backend"] = "animdl"
+            staging_dir = APP.app_support.job_staging_dir(job)
+            staging_dir.mkdir(parents=True, exist_ok=True)
+            source = staging_dir / "Fallback Show - S02E01.mp4"
+            source.write_bytes(b"fallback")
+
+            moved = APP.app_support.finalize_library_files(job)
+
+            self.assertEqual(
+                moved,
+                [f"{temp_root}/tv/Fallback Show/Season 02/Fallback Show - S02E12.mp4"],
+            )
+            self.assertTrue(Path(moved[0]).exists())
+
     def test_shutdown_wait_cancels_active_process_for_deterministic_teardown(self):
         queue = object.__new__(APP.DownloadQueue)
         queue.lock = threading.RLock()
@@ -846,6 +1051,76 @@ class DownloadQueueWorkerFailureTests(unittest.TestCase):
         self.assertEqual(commands[1][0], APP.app_support.ANIPY_CLI)
         self.assertIn("Fallback download completed with anipy-cli.", stored["log"])
 
+    def test_selected_unavailable_animdl_fails_without_start_attempt(self):
+        queue = APP.DownloadQueue(
+            lambda: {
+                "mode": "sub",
+                "quality": "best",
+                "download_dir": "/tmp/example",
+                "download_methods": ["animdl"],
+            },
+            start_worker=False,
+        )
+        job = queue.add({"query": "Queue Show", "title": "Queue Show", "season": "1", "episodes": "1"})
+        staging_dir = queue_jobs.job_staging_dir(job)
+
+        with mock.patch.object(queue_jobs, "cli_executable_exists", return_value=False), mock.patch.object(
+            queue_jobs.subprocess, "Popen"
+        ) as popen:
+            queue._run_job(job)
+
+        stored = queue._find(job["id"])
+        self.assertEqual(stored["status"], "failed")
+        self.assertEqual(stored["download_backend"], "animdl")
+        self.assertIn("No selected download methods are installed or executable: animdl.", stored["log"])
+        self.assertFalse(staging_dir.exists())
+        popen.assert_not_called()
+
+    def test_selected_download_methods_retry_through_animdl(self):
+        queue = APP.DownloadQueue(
+            lambda: {
+                "mode": "sub",
+                "quality": "best",
+                "download_dir": "/tmp/example",
+                "download_methods": ["ani-cli", "anipy-cli", "animdl"],
+            },
+            start_worker=False,
+        )
+        job = queue.add({"query": "Queue Show", "title": "Queue Show", "season": "1", "episodes": "1"})
+        commands = []
+
+        class FakeProc:
+            def __init__(self, pid, stdout, exit_code):
+                self.pid = pid
+                self.stdout = stdout
+                self._exit_code = exit_code
+
+            def wait(self):
+                return self._exit_code
+
+        processes = [
+            FakeProc(4321, ["ani-cli attempt\n"], 1),
+            FakeProc(5432, ["anipy-cli attempt\n"], 1),
+            FakeProc(6543, ["animdl attempt\n"], 0),
+        ]
+
+        def fake_popen(command, **kwargs):
+            commands.append(command)
+            return processes.pop(0)
+
+        with mock.patch.object(queue_jobs, "cli_executable_exists", return_value=True), mock.patch.object(
+            queue_jobs.subprocess, "Popen", side_effect=fake_popen
+        ), mock.patch.object(
+            queue_jobs, "finalize_library_files", return_value=["/tmp/example/Queue Show - S01E01.mp4"]
+        ):
+            queue._run_job(job)
+
+        stored = queue._find(job["id"])
+        self.assertEqual(stored["status"], "done")
+        self.assertTrue(stored["fallback_used"])
+        self.assertEqual([command[0] for command in commands], [APP.app_support.ANI_CLI, APP.app_support.ANIPY_CLI, APP.app_support.ANIMDL])
+        self.assertIn("Fallback download completed with animdl.", stored["log"])
+
 
 class WatchlistRefreshAllTests(unittest.TestCase):
     def test_refresh_all_iterates_only_watching_and_planned_show_ids(self):
@@ -1689,6 +1964,25 @@ class WatchlistCompletionTests(unittest.TestCase):
         self.assertIn("-l", command)
         self.assertEqual(command[-1], "/tmp/anipy-staging")
 
+    def test_command_for_job_builds_animdl_download_command(self):
+        command = APP.app_support.command_for_job(
+            {
+                "query": "Re:Zero",
+                "quality": "720",
+                "episodes": "1-3",
+                "mode": "dub",
+            },
+            backend="animdl",
+            download_path="/tmp/animdl-staging",
+        )
+
+        self.assertEqual(command[0], APP.app_support.ANIMDL)
+        self.assertEqual(command[1:4], ["download", "Re:Zero", "-r"])
+        self.assertIn("-q", command)
+        self.assertIn("--index", command)
+        self.assertIn("-d", command)
+        self.assertEqual(command[-1], "/tmp/animdl-staging")
+
     def test_download_watchlist_item_queues_full_episode_range_for_selected_mode(self):
         item = {
             "show_id": "show-42",
@@ -2170,6 +2464,7 @@ class ConfigSnapshotTests(unittest.TestCase):
         self.assertEqual(config["watchlist_auto_refresh_minutes"], 60)
         self.assertEqual(config["watchlist_refresh_delay_seconds"], 5)
         self.assertFalse(config["anipy_cli_fallback_enabled"])
+        self.assertEqual(config["download_methods"], ["ani-cli"])
         self.assertFalse(config["auto_download_enabled"])
         self.assertEqual(config["auto_download_mode"], "dub")
         self.assertEqual(config["auto_download_quality"], "best")
@@ -2195,6 +2490,7 @@ class ConfigSnapshotTests(unittest.TestCase):
             }
         )
         self.assertTrue(config["anipy_cli_fallback_enabled"])
+        self.assertEqual(config["download_methods"], ["ani-cli", "anipy-cli"])
         self.assertTrue(config["watchlist_auto_refresh_enabled"])
         self.assertEqual(config["watchlist_auto_refresh_minutes"], 15)
         self.assertEqual(config["watchlist_refresh_delay_seconds"], 7)
@@ -2205,6 +2501,16 @@ class ConfigSnapshotTests(unittest.TestCase):
         self.assertIn("jellyfin", config["jellyfin_tv_dir"])
         self.assertIn("jellyfin", config["jellyfin_movie_dir"])
 
+    def test_normalize_config_filters_download_methods(self):
+        config = APP.normalize_config(
+            {
+                "download_methods": ["animdl", "bad-method", "anipy-cli", "animdl"],
+            }
+        )
+
+        self.assertEqual(config["download_methods"], ["animdl", "anipy-cli"])
+        self.assertTrue(config["anipy_cli_fallback_enabled"])
+
     def test_normalize_config_filters_discord_webhook_events(self):
         config = APP.normalize_config(
             {
@@ -2792,6 +3098,7 @@ class HandlerRouteTests(unittest.TestCase):
         APP.Handler.do_POST(handler)
         self.assertEqual(handler.json_status, HTTPStatus.OK)
         self.assertTrue(handler.json_payload["anipy_cli_fallback_enabled"])
+        self.assertEqual(handler.json_payload["download_methods"], ["ani-cli", "anipy-cli"])
         self.assertTrue(handler.json_payload["watchlist_auto_refresh_enabled"])
         self.assertEqual(handler.json_payload["watchlist_auto_refresh_minutes"], 25)
         self.assertEqual(handler.json_payload["watchlist_refresh_delay_seconds"], 9)
@@ -2802,6 +3109,14 @@ class HandlerRouteTests(unittest.TestCase):
         self.assertEqual(handler.json_payload["jellyfin_tv_dir"], "/tmp/jellyfin-tv")
         self.assertEqual(handler.json_payload["jellyfin_movie_dir"], "/tmp/jellyfin-movies")
 
+    def test_config_post_accepts_download_methods(self):
+        body = b'{"download_dir":"/tmp/example","mode":"sub","quality":"best","download_methods":["ani-cli","animdl"]}'
+        handler = DummyHandler("/api/config", body=body, content_length=len(body))
+        APP.Handler.do_POST(handler)
+        self.assertEqual(handler.json_status, HTTPStatus.OK)
+        self.assertEqual(handler.json_payload["download_methods"], ["ani-cli", "animdl"])
+        self.assertTrue(handler.json_payload["anipy_cli_fallback_enabled"])
+
     def test_version_route_includes_cli_versions(self):
         handler = DummyHandler("/api/version")
         APP.Handler.do_GET(handler)
@@ -2810,12 +3125,61 @@ class HandlerRouteTests(unittest.TestCase):
         self.assertEqual(handler.json_payload["version"], APP.VERSION)
         self.assertIn("ani_cli_version", handler.json_payload)
         self.assertIn("anipy_cli_version", handler.json_payload)
+        self.assertIn("animdl_version", handler.json_payload)
 
-    def test_dependencies_route_reports_anipy_cli_status(self):
+    def test_dependencies_route_reports_fallback_tool_status(self):
         handler = DummyHandler("/api/dependencies")
         APP.Handler.do_GET(handler)
         self.assertEqual(handler.json_status, HTTPStatus.OK)
         self.assertIn("anipy-cli", handler.json_payload)
+        self.assertIn("animdl", handler.json_payload)
+
+    def test_dependency_status_checks_docker_fallback_tool_paths(self):
+        with mock.patch.object(http_handler, "cli_executable_exists", return_value=True), mock.patch.object(
+            http_handler, "cli_executable_exists_any", return_value=True
+        ) as exists_any:
+            status = http_handler.dependency_status()
+
+        self.assertTrue(status["animdl"])
+        exists_any.assert_any_call(
+            http_handler.ANIMDL,
+            "animdl",
+            "/usr/local/bin/animdl",
+            "/usr/bin/animdl",
+        )
+        exists_any.assert_any_call(
+            http_handler.ANIPY_CLI,
+            "anipy-cli",
+            "/usr/local/bin/anipy-cli",
+            "/usr/bin/anipy-cli",
+        )
+
+    def test_clear_failed_route_removes_failed_jobs(self):
+        with APP.DOWNLOAD_QUEUE._connect() as conn:
+            conn.execute("DELETE FROM jobs")
+        job = APP.DOWNLOAD_QUEUE.add(
+            {
+                "query": "Failed Route Show",
+                "title": "Failed Route Show",
+                "anime_name": "Failed Route Show",
+                "mode": "sub",
+                "quality": "best",
+                "episodes": "1",
+                "download_dir": "/tmp/example",
+                "season": "1",
+            }
+        )
+        with APP.DOWNLOAD_QUEUE.lock:
+            stored = APP.DOWNLOAD_QUEUE._find(job["id"])
+            stored["status"] = "failed"
+            APP.DOWNLOAD_QUEUE._save_job_locked(stored)
+
+        handler = DummyHandler("/api/queue/clear-failed", body=b"{}", content_length=2)
+        APP.Handler.do_POST(handler)
+
+        self.assertEqual(handler.json_status, HTTPStatus.OK)
+        self.assertEqual(handler.json_payload["count"], 1)
+        self.assertEqual(APP.DOWNLOAD_QUEUE.list()["total"], 0)
 
     def test_changelog_route_returns_project_changelog_content(self):
         handler = DummyHandler("/api/changelog")
@@ -3340,6 +3704,13 @@ class TemplateHelperTests(unittest.TestCase):
         self.assertIn("async function api(path, options = {})", APP.CONFIG_HTML)
         self.assertIn("async function api(path, options = {})", APP.WATCHLIST_HTML)
 
+    def test_pages_include_favicon_link(self):
+        expected = '<link rel="icon" type="image/png" sizes="32x32" href="/favicon.png">'
+        self.assertIn(expected, APP.INDEX_HTML)
+        self.assertIn(expected, APP.QUEUE_HTML)
+        self.assertIn(expected, APP.CONFIG_HTML)
+        self.assertIn(expected, APP.WATCHLIST_HTML)
+
     def test_config_page_places_dependencies_before_settings_grid(self):
         self.assertIn('<section class="deps" id="deps"></section>', APP.CONFIG_HTML)
         self.assertIn('<div class="settings-grid">', APP.CONFIG_HTML)
@@ -3348,9 +3719,11 @@ class TemplateHelperTests(unittest.TestCase):
         self.assertIn("justify-items: stretch;", APP.CONFIG_HTML)
         self.assertIn('id="aniCliVersionLine"', APP.CONFIG_HTML)
         self.assertIn('id="anipyCliVersionLine"', APP.CONFIG_HTML)
+        self.assertIn('id="animdlVersionLine"', APP.CONFIG_HTML)
         self.assertIn('ani-cli ${data.ani_cli_version || "Unavailable"}', APP.CONFIG_HTML)
         self.assertIn('anipy-cli ${data.anipy_cli_version || "Unavailable"}', APP.CONFIG_HTML)
-        self.assertIn('id="anipyCliFallbackEnabled"', APP.CONFIG_HTML)
+        self.assertIn('animdl ${data.animdl_version || "Unavailable"}', APP.CONFIG_HTML)
+        self.assertIn('class="download-method" type="checkbox" value="animdl"', APP.CONFIG_HTML)
         self.assertIn('id="openChangelogBtn"', APP.CONFIG_HTML)
         self.assertIn('id="changelogOverlay"', APP.CONFIG_HTML)
         self.assertIn('const data = await api("/api/changelog");', APP.CONFIG_HTML)
@@ -3366,6 +3739,16 @@ class TemplateHelperTests(unittest.TestCase):
     def test_search_page_sends_watchlist_auto_download_series(self):
         self.assertIn('auto_download_series: $("seasonInput").value || "1"', APP.INDEX_HTML)
 
+    def test_queue_page_includes_clear_failed_bulk_action(self):
+        self.assertIn('id="clearFailedBtn"', APP.QUEUE_HTML)
+        self.assertIn('/api/queue/clear-failed', APP.QUEUE_HTML)
+        self.assertIn('Removed failed jobs', APP.QUEUE_HTML)
+
+    def test_queue_page_formats_jellyfin_handoff_jobs(self):
+        self.assertIn('job.job_type === "jellyfin_handoff"', APP.QUEUE_HTML)
+        self.assertIn('const progress = `${job.completed || 0}/${job.total || 0} entries`;', APP.QUEUE_HTML)
+        self.assertIn('const moved = `${job.moved || 0} moved`;', APP.QUEUE_HTML)
+
     def test_search_page_queues_selected_title_without_result_index(self):
         self.assertIn('query: state.selected.title,', APP.INDEX_HTML)
         self.assertNotIn('index: state.selected.index,', APP.INDEX_HTML)

watchlist_page.py

@@ -11,6 +11,7 @@ WATCHLIST_HTML = r"""<!doctype html>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>ani-cli web - watchlist</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="/favicon.png">
   <style>
     :root {
       color-scheme: dark;