Merge pull request #119 from Masutayunikon/release-please--branches--main

chore(main): release 3.16.0

.claude/settings.local.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(find src:*)",
-      "Bash(find server:*)"
-    ]
-  }
-}

.github/workflows/build-binaries.yml

@@ -14,11 +14,11 @@ jobs:
 
       - uses: pnpm/action-setup@v3
         with:
-          version: latest
+          version: 10
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 22
           cache: pnpm
 
       - name: Install dependencies
@@ -78,11 +78,11 @@ jobs:
 
       - uses: pnpm/action-setup@v3
         with:
-          version: latest
+          version: 10
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 22
           cache: pnpm
 
       - name: Install dependencies

.github/workflows/containerize.yml

@@ -35,6 +35,8 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           push: true
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
           tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            BUILD_VERSION=${{ steps.meta.outputs.version }}

.gitignore

@@ -1,3 +1,6 @@
+# Claude Code
+.claude/
+
 # Logs
 logs
 *.log

CHANGELOG.md

@@ -1,5 +1,185 @@
 # Changelog
 
+## [3.16.0](https://github.com/Masutayunikon/FanKarr/compare/v3.15.0...v3.16.0) (2026-05-11)
+
+
+### Features
+
+* **log:** + de logs sur les erreurs d'import (chemin tenté et fichier du torrent chercher) ([cb28baf](https://github.com/Masutayunikon/FanKarr/commit/cb28baf25d7f24148ed7e13a0a4ea46f085b2ba4))
+* **rss:** ajout du rss sur les series ([086ca30](https://github.com/Masutayunikon/FanKarr/commit/086ca3053f5e563d8c3c2bb82379ff45d77a5499))
+* **UI/UX:** affichage de la serie et des episodes sur la page download du torrent ([cb28baf](https://github.com/Masutayunikon/FanKarr/commit/cb28baf25d7f24148ed7e13a0a4ea46f085b2ba4))
+
+
+### Bug Fixes
+
+* **client:** fix de plusieurs torrent et refonte du tableau de compatibilité ([086ca30](https://github.com/Masutayunikon/FanKarr/commit/086ca3053f5e563d8c3c2bb82379ff45d77a5499))
+* **docker:** ajout du fichier de versions pour la navbar dans docker lors du build ([cb28baf](https://github.com/Masutayunikon/FanKarr/commit/cb28baf25d7f24148ed7e13a0a4ea46f085b2ba4))
+* **download:** le telechargement de saison ne propose plus tout les torrents des episodes de la saisons si la serie n'a que des torrent par episodes ([c9040ea](https://github.com/Masutayunikon/FanKarr/commit/c9040ea68c52e65a656824ccfd101a04a2251edd))
+* **import:** les episodes avec une association changé n'apparait plus sur la page serie ([8972679](https://github.com/Masutayunikon/FanKarr/commit/8972679e2588b6e5cd3e9fd53b0223e3d1a6e56c))
+* **import:** les imports se font maintenant sur les series sans torrents qui n'avais pas de fichier de catalogue depuis le scraper ([cb28baf](https://github.com/Masutayunikon/FanKarr/commit/cb28baf25d7f24148ed7e13a0a4ea46f085b2ba4))
+* **import:** on ne peux plus importer plusieurs fichiers sur le meme episodes, celui deja importé ce retire de l'importation dans le modal ([ad829c0](https://github.com/Masutayunikon/FanKarr/commit/ad829c0a99b29ade7eba4673b1218c0ab768a2d7))
+* **import:** si on change un fichier son association alors il est bien retirer de l'import ([ad829c0](https://github.com/Masutayunikon/FanKarr/commit/ad829c0a99b29ade7eba4673b1218c0ab768a2d7))
+* les torrents n'utilise plus la pause ([cb28baf](https://github.com/Masutayunikon/FanKarr/commit/cb28baf25d7f24148ed7e13a0a4ea46f085b2ba4))
+* **rss:** le rss est maintenant sur les ajout apres l'activation de la surveillance ([a5e2aa0](https://github.com/Masutayunikon/FanKarr/commit/a5e2aa0da1b3af445a102d1acd77a3a08017689a))
+* **UI/UX:** la bar de progression de saison a été retirer et les bars de progression s'affiche meme si le fichier est à 0% dans le torrent ([f07b608](https://github.com/Masutayunikon/FanKarr/commit/f07b608288afd4b01079367b428123b72182b714))
+* **UI/UX:** retour sur le modal d'import et refresh ([a5e2aa0](https://github.com/Masutayunikon/FanKarr/commit/a5e2aa0da1b3af445a102d1acd77a3a08017689a))
+* **UI/UX:** retour visuel lors de l'import d'une serie/episode ([cb28baf](https://github.com/Masutayunikon/FanKarr/commit/cb28baf25d7f24148ed7e13a0a4ea46f085b2ba4))
+* utilisation de URLSearchParams pour les appels autre que pour le add du fichier .torrent ([42c9795](https://github.com/Masutayunikon/FanKarr/commit/42c979536b51e8ed263b23559b7c4a2d4d2b2902))
+
+## [3.15.0](https://github.com/Masutayunikon/FanKarr/compare/v3.14.6...v3.15.0) (2026-05-10)
+
+
+### Features
+
+* ajout build docker pour arm32 ([950a2ab](https://github.com/Masutayunikon/FanKarr/commit/950a2abc49fe0b7b5bcc0f47d781a45a01838ec3))
+
+## [3.14.6](https://github.com/Masutayunikon/FanKarr/compare/v3.14.5...v3.14.6) (2026-05-08)
+
+
+### Bug Fixes
+
+* pnpm build ([fcb176d](https://github.com/Masutayunikon/FanKarr/commit/fcb176d519b1bff49c40b79192e71b6062671998))
+
+## [3.14.5](https://github.com/Masutayunikon/FanKarr/compare/v3.14.4...v3.14.5) (2026-05-08)
+
+
+### Bug Fixes
+
+* pnpm build ([d04ca79](https://github.com/Masutayunikon/FanKarr/commit/d04ca79e0057e3d6cf92e49822d812266f629dba))
+
+## [3.14.4](https://github.com/Masutayunikon/FanKarr/compare/v3.14.3...v3.14.4) (2026-05-08)
+
+
+### Bug Fixes
+
+* lock file for build ([ef527c2](https://github.com/Masutayunikon/FanKarr/commit/ef527c2072a93650f9159de12ae875a671fb845c))
+
+## [3.14.3](https://github.com/Masutayunikon/FanKarr/compare/v3.14.2...v3.14.3) (2026-05-08)
+
+
+### Bug Fixes
+
+* build binaries node version ([6d8ea36](https://github.com/Masutayunikon/FanKarr/commit/6d8ea36260cb76e0592bbee3ce5450d2424b9209))
+
+## [3.14.2](https://github.com/Masutayunikon/FanKarr/compare/v3.14.1...v3.14.2) (2026-05-07)
+
+
+### Bug Fixes
+
+* build binaries node version ([9ebaca9](https://github.com/Masutayunikon/FanKarr/commit/9ebaca92f18213fd6a79bf55f22cfb8358c4f7e0))
+
+## [3.14.1](https://github.com/Masutayunikon/FanKarr/compare/v3.14.0...v3.14.1) (2026-05-07)
+
+
+### Bug Fixes
+
+* eslint build ([25ab373](https://github.com/Masutayunikon/FanKarr/commit/25ab373539c20942202e82cf678e5b7577ff0027))
+
+## [3.14.0](https://github.com/Masutayunikon/FanKarr/compare/v3.13.2...v3.14.0) (2026-05-07)
+
+
+### Features
+
+* **qbittorrent:** support API key authentication (≥5.2.0) ([702847a](https://github.com/Masutayunikon/FanKarr/commit/702847a5c2eb5956f54a8475fefc80a08fca70f1))
+* **qbittorrent:** support cookie name (≥5.2.0) ([aa8b500](https://github.com/Masutayunikon/FanKarr/commit/aa8b500f57efb97aae10eb0bd8e254388a8aff42))
+
+
+### Bug Fixes
+
+* ajout de log pour le cookie ([2b3fd79](https://github.com/Masutayunikon/FanKarr/commit/2b3fd79a92bbc7d7ed2142b7a23e03799efe0a28))
+* cookie ([7da5a8d](https://github.com/Masutayunikon/FanKarr/commit/7da5a8d4e853f7e92770f20352478a76ee91642d))
+* le bouton rename n'apparait plus quand on utilise differents torrents entre les épisode ([105cc05](https://github.com/Masutayunikon/FanKarr/commit/105cc05bdf38127089869ea201165ac1d3479275))
+* on ne vois plus le telechargement de fichier qui ont une priorité basse (ne pas télécharger) ([1f50f9a](https://github.com/Masutayunikon/FanKarr/commit/1f50f9ae72ec9958bfb92b2e6936c699e19272f3))
+* renaming dans le managements des series ([1e92934](https://github.com/Masutayunikon/FanKarr/commit/1e92934f531c82b9da90c8597ec08cd162b5a9ee))
+* renaming dans le managements des series ([bf3f303](https://github.com/Masutayunikon/FanKarr/commit/bf3f30356e086d310b7213b267356bc20976589c))
+* rtorrent priority default to 1 ([bfabf9b](https://github.com/Masutayunikon/FanKarr/commit/bfabf9b7937f055579add331cd918a13f05084bf))
+
+## [3.13.2](https://github.com/Masutayunikon/FanKarr/compare/v3.13.1...v3.13.2) (2026-05-06)
+
+
+### Bug Fixes
+
+* le bouton rename n'apparait plus quand on utilise differents torrents entre les épisode ([0d5d44a](https://github.com/Masutayunikon/FanKarr/commit/0d5d44a4840df27d8b23bde9935d12c664d5ad6c))
+
+## [3.13.1](https://github.com/Masutayunikon/FanKarr/compare/v3.13.0...v3.13.1) (2026-05-06)
+
+
+### Bug Fixes
+
+* ajout du champ wiki dans l'api ([95d2b27](https://github.com/Masutayunikon/FanKarr/commit/95d2b270dcb3052b65f5918ec770799b43316cd6))
+
+## [3.13.0](https://github.com/Masutayunikon/FanKarr/compare/v3.12.1...v3.13.0) (2026-05-06)
+
+
+### Features
+
+* ajout de la mise a jour des id's ([39463bf](https://github.com/Masutayunikon/FanKarr/commit/39463bfbcb74c7241420504ba51bd91108df20e4))
+* ajout de la prise en charges des codex ([83437de](https://github.com/Masutayunikon/FanKarr/commit/83437def32618c8a5b9ca4364db992762b9359f8))
+* **organize:** vérification de complétion par fichier avant d'importer ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* **serie:** badges épisodes et chapitres extraits du synopsis ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* **serie:** lien wiki dans le header de la série si serie.wiki est défini ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* **torrent-clients:** ajout du driver Real-Debrid ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+
+
+### Bug Fixes
+
+* ajout de log ([d299b76](https://github.com/Masutayunikon/FanKarr/commit/d299b76bd3fc8a8411e71f9f05318901df8372ef))
+* **organize:** retry EBUSY sur unlink — 5 tentatives × 500 ms (Windows) ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* **organize:** suppression des entrées orphelines lors de la migration d'IDs ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* progression ([35655d7](https://github.com/Masutayunikon/FanKarr/commit/35655d7784025c9b2d7f992b24181d62b8488130))
+* **qbittorrent:** FanKarr télécharge le .torrent et l'uploade directement à qBit ([434da54](https://github.com/Masutayunikon/FanKarr/commit/434da54ede8ece06c1fbcf4d66fe6ecdf87557a5))
+* **qbittorrent:** pause uniquement pour les .torrent, pas pour les magnets ([9f90b6a](https://github.com/Masutayunikon/FanKarr/commit/9f90b6ab6c0aa97e33244d827370492abcfe9a13))
+* **qbittorrent:** suppression de paused/stopped à l'ajout du torrent ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* **serie:** header mobile — items-start + aspect-[2/3] sur le poster ([2a77a38](https://github.com/Masutayunikon/FanKarr/commit/2a77a38655dcc307e36371422f8698e33fd73135))
+* utilisation de formated_name depuis les paths ([39463bf](https://github.com/Masutayunikon/FanKarr/commit/39463bfbcb74c7241420504ba51bd91108df20e4))
+
+## [3.12.1](https://github.com/Masutayunikon/FanKarr/compare/v3.12.0...v3.12.1) (2026-04-29)
+
+
+### Bug Fixes
+
+* **UI/UX:** ajout d'un modal de confirmation lors de l'activation des nfo ([8b98b0e](https://github.com/Masutayunikon/FanKarr/commit/8b98b0edf926ba6b542501afdf524050d72f043b))
+
+## [3.12.0](https://github.com/Masutayunikon/FanKarr/compare/v3.11.5...v3.12.0) (2026-04-29)
+
+
+### Features
+
+* désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission ([2446622](https://github.com/Masutayunikon/FanKarr/commit/24466228ef5305c36574f58fb2590aee8ee86e13))
+* désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission ([fcb1b88](https://github.com/Masutayunikon/FanKarr/commit/fcb1b88870bebb1bf0b4e484b2462e56ab3975fc))
+* désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission ([3fb4119](https://github.com/Masutayunikon/FanKarr/commit/3fb4119c79908c1023f3cbf9999b524eb1bc267e))
+
+
+### Bug Fixes
+
+* qbitorrent ([9834023](https://github.com/Masutayunikon/FanKarr/commit/98340235226394c4583159f36cce74e316eedf26))
+* qbitorrent header ([f5094c6](https://github.com/Masutayunikon/FanKarr/commit/f5094c68c6834f816b0b6d019e5d5637400e16ab))
+* spinner infinie apres supression ([39d2f99](https://github.com/Masutayunikon/FanKarr/commit/39d2f996aecb9f07dcd8c1ec7911090276908a2f))
+* spinner infinie apres supression ([97c573c](https://github.com/Masutayunikon/FanKarr/commit/97c573cc1d4fb76787ba5d1df4fda30faec5fbf2))
+* **UI/UX:** chevron pour ouvrir la description, bouton desimporter de la serie passer à supprimer et affichage de toute la description de la serie lors d'un clique ([f6ef818](https://github.com/Masutayunikon/FanKarr/commit/f6ef818e60875a1ac5d859480c1e0e53082c0858))
+* **UI/UX:** meilleur comprehension des parametres avancés des clients ([040a8d7](https://github.com/Masutayunikon/FanKarr/commit/040a8d7b339090d819c6e3dc049f1ab9d8b221f5))
+
+## [3.11.5](https://github.com/Masutayunikon/FanKarr/compare/v3.11.4...v3.11.5) (2026-04-26)
+
+
+### Bug Fixes
+
+* le folder picker affiche tous les disques depuis le bouton homes sous windows ([7149022](https://github.com/Masutayunikon/FanKarr/commit/7149022c8701f79d194c675da87c6cb2d5793a35))
+
+## [3.11.4](https://github.com/Masutayunikon/FanKarr/compare/v3.11.3...v3.11.4) (2026-04-26)
+
+
+### Bug Fixes
+
+* ajout de la mise a jour des noms toutes les 1h ([0fe5c8c](https://github.com/Masutayunikon/FanKarr/commit/0fe5c8ccb7ecdc1643b5e69de3957c39dfd8085e))
+
+## [3.11.3](https://github.com/Masutayunikon/FanKarr/compare/v3.11.2...v3.11.3) (2026-04-26)
+
+
+### Bug Fixes
+
+* dockerfile node version to 22 ([5983494](https://github.com/Masutayunikon/FanKarr/commit/598349407750c729579bd639680ebc6a8ebcc12f))
+
 ## [3.11.2](https://github.com/Masutayunikon/FanKarr/compare/v3.11.1...v3.11.2) (2026-04-26)
 
 

Dockerfile

@@ -1,7 +1,7 @@
-FROM node:20-slim AS base
+FROM node:22-slim AS base
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
-RUN corepack enable
+RUN corepack enable && corepack prepare pnpm@10 --activate
 COPY . /app
 WORKDIR /app
 
@@ -15,7 +15,8 @@ RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
 RUN pnpm run build
 
 # ── Production ─────────────────────────────────────────────────
-FROM node:20-slim
+FROM node:22-slim
+ARG BUILD_VERSION=dev
 RUN apt-get update && apt-get install -y gosu && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
@@ -25,7 +26,8 @@ COPY --from=build /app/dist/client /app/public
 COPY entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh
 RUN mkdir -p /config
+RUN echo "$BUILD_VERSION" > /app/version.txt
 
 EXPOSE 3001
 ENV NODE_ENV=production
-ENTRYPOINT ["/entrypoint.sh"]
+ENTRYPOINT ["/entrypoint.sh"]

README.md

@@ -139,6 +139,13 @@ fankarr-windows-x64/
 **Linux / macOS** — rendre le binaire exécutable avant le premier lancement :
 
 ```bash
+wget https://github.com/Masutayunikon/FanKarr/releases/download/v3.14.6/fankarr-linux-arm64.zip
+unzip fankarr-linux-arm64.zip -d fankarr
+cd fankarr
+################
+# if the "fankarr" files in inside the binaries directory use this command
+# mv ./binaries/fankarr .
+##################
 chmod +x fankarr
 ./fankarr
 ```

server/index.ts

@@ -11,7 +11,8 @@ import transmissionDriver from './torrent-clients/transmission.js'
 import synologyDsDriver   from './torrent-clients/synology-ds.js'
 import utorrentDriver     from './torrent-clients/utorrent.js'
 import rtorrentDriver     from './torrent-clients/rtorrent.js'
-import { autoOrganizeAll, scanMediaPath } from './organize.js'
+import realDebridDriver   from './torrent-clients/real-debrid.js'
+import { autoOrganizeAll, scanMediaPath, syncFilenameChanges, migrateOrganizedEpisodeIds } from './organize.js'
 import { logger } from './logger.js'
 import { DATA_DIR, BASE_DIR } from './config.js'
 import { readAvailable, readInfohashMap, loadEnrichedSeriesData } from './lib/github-cache.js'
@@ -27,12 +28,15 @@ import importRouter        from './routes/import.js'
 import systemRouter        from './routes/system.js'
 import nfoUpdatesRouter    from './routes/nfo-updates.js'
 import plexRouter          from './routes/plex.js'
+import rssSyncRouter       from './routes/rss-sync.js'
+import { runRssSync }      from './lib/rss-sync.js'
 
 registerDriver(qbittorrentDriver)
 registerDriver(transmissionDriver)
 registerDriver(synologyDsDriver)
 registerDriver(utorrentDriver)
 registerDriver(rtorrentDriver)
+registerDriver(realDebridDriver)
 
 const app  = express()
 const PORT = Number(process.env.PORT) || 9898
@@ -61,6 +65,7 @@ app.use('/api', importRouter)
 app.use('/api', systemRouter)
 app.use('/api', nfoUpdatesRouter)
 app.use('/api', plexRouter)
+app.use('/api', rssSyncRouter)
 
 // ── Catch-all SPA ──────────────────────────────────────────────
 if (fs.existsSync(PUBLIC_PATH)) {
@@ -97,7 +102,10 @@ server.listen(PORT, async () => {
     } catch {}
 
     loadEnrichedSeriesData()
-        .then(seriesData => scanMediaPath(mediaPath, ORGANIZED_PATH, seriesData))
+        .then(async seriesData => {
+            await migrateOrganizedEpisodeIds(ORGANIZED_PATH, seriesData)
+            return scanMediaPath(mediaPath, ORGANIZED_PATH, seriesData)
+        })
         .catch(err => logger.error('api', `Scan initial échoué : ${err instanceof Error ? err.message : err}`))
 
     const autoOrganize = async () => {
@@ -139,4 +147,29 @@ server.listen(PORT, async () => {
             checkNfoUpdates().catch(err => logger.error('nfo-update', `Vérif horaire échouée : ${err instanceof Error ? err.message : err}`))
         }, 60 * 60_000)
     }, 30_000)
+
+    // Sync automatique des noms de fichiers toutes les heures.
+    // Le TTL du cache GitHub est de 1h — ce setInterval tire toujours sur des données fraîches.
+    setInterval(async () => {
+        try {
+            const seriesData   = await loadEnrichedSeriesData()
+            const organizedPath = path.join(DATA_DIR, 'organized.json')
+            const { updated }  = await migrateOrganizedEpisodeIds(organizedPath, seriesData)
+            if (updated > 0)
+                logger.info('api', `Migration IDs auto — ${updated} ID(s) mis à jour`)
+            const { renamed }  = await syncFilenameChanges(seriesData, organizedPath)
+            if (renamed > 0)
+                logger.info('api', `Sync noms auto — ${renamed} fichier(s) renommé(s)`)
+        } catch (err) {
+            logger.error('api', `Sync noms auto échoué : ${err instanceof Error ? err.message : err}`)
+        }
+    }, 60 * 60_000)
+
+    // RSS sync — auto-téléchargement des nouveaux épisodes toutes les 6 heures.
+    setTimeout(() => {
+        runRssSync().catch(err => logger.error('rss-sync', `Sync initial échoué : ${err instanceof Error ? err.message : err}`))
+        setInterval(() => {
+            runRssSync().catch(err => logger.error('rss-sync', `Sync périodique échoué : ${err instanceof Error ? err.message : err}`))
+        }, 6 * 60 * 60_000)
+    }, 60_000) // premier cycle 1 min après le démarrage
 })

server/lib/rss-sync.ts

@@ -0,0 +1,241 @@
+/**
+ * RSS Sync — auto-téléchargement des épisodes sortis après l'activation de la surveillance.
+ *
+ * Toutes les 6 heures, FanKarr cherche les épisodes dont le champ `date_added`
+ * (date d'ajout dans la base metadata) est postérieur à la date d'activation
+ * du sync pour cette série. Si ces épisodes ont un torrent fankai et ne sont
+ * pas encore organisés, ils sont envoyés automatiquement au client torrent.
+ */
+
+import path from 'path'
+import fs   from 'fs'
+import { DATA_DIR } from '../config.js'
+import { logger }   from '../logger.js'
+import { loadEnrichedSeriesData, readInfohashMap } from './github-cache.js'
+import { dispatchDownload, dispatchList }          from '../torrent-clients/index.js'
+import { readSettings }                            from '../settings.js'
+
+// ── Types ─────────────────────────────────────────────────────
+
+export interface SyncedSerie {
+    serieId  : number
+    serieName: string
+    addedAt  : string   // ISO — date d'activation de la surveillance
+}
+
+type SyncedMap = Record<number, SyncedSerie>
+
+// ── Persistance ───────────────────────────────────────────────
+
+const SYNC_FILE = path.join(DATA_DIR, 'rss-synced.json')
+
+export function loadSynced(): SyncedMap {
+    try {
+        if (fs.existsSync(SYNC_FILE))
+            return JSON.parse(fs.readFileSync(SYNC_FILE, 'utf-8')) as SyncedMap
+    } catch {}
+    return {}
+}
+
+function saveSynced(map: SyncedMap): void {
+    fs.mkdirSync(DATA_DIR, { recursive: true })
+    fs.writeFileSync(SYNC_FILE, JSON.stringify(map, null, 2), 'utf-8')
+}
+
+export function setSync(serieId: number, serieName: string, enabled: boolean): SyncedMap {
+    const map = loadSynced()
+    if (enabled) {
+        map[serieId] = { serieId, serieName, addedAt: new Date().toISOString() }
+    } else {
+        delete map[serieId]
+    }
+    saveSynced(map)
+    return map
+}
+
+export function isSynced(serieId: number): boolean {
+    return !!loadSynced()[serieId]
+}
+
+// ── Helpers ───────────────────────────────────────────────────
+
+function readOrganized(): Record<string, Record<string, any>> {
+    try {
+        const p = path.join(DATA_DIR, 'organized.json')
+        if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, 'utf-8'))
+    } catch {}
+    return {}
+}
+
+function getOrganizedEpisodeIds(sd: any, organized: Record<string, Record<string, any>>): Set<number> {
+    const ids = new Set<number>()
+
+    const manual = organized['manual'] ?? {}
+    for (const season of sd.seasons ?? [])
+        for (const ep of season.episodes ?? [])
+            if (manual[String(ep.id)]) ids.add(ep.id)
+
+    for (const t of sd.torrents ?? []) {
+        const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+        for (const season of sd.seasons ?? [])
+            for (const ep of season.episodes ?? [])
+                if (orgFiles[String(ep.id)] !== undefined) ids.add(ep.id)
+    }
+
+    for (const season of sd.seasons ?? []) {
+        for (const t of season.torrents ?? []) {
+            const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+            for (const ep of season.episodes ?? [])
+                if (orgFiles[String(ep.id)] !== undefined) ids.add(ep.id)
+        }
+        for (const ep of season.episodes ?? []) {
+            for (const t of ep.torrents ?? []) {
+                const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                if (orgFiles[String(ep.id)] !== undefined) ids.add(ep.id)
+                const pathEntry = (ep.paths ?? []).find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === t.infohash?.toLowerCase())
+                if (pathEntry) {
+                    const fname = pathEntry.path?.split('/').pop()
+                    if (fname && orgFiles[fname] !== undefined) ids.add(ep.id)
+                }
+            }
+        }
+    }
+
+    return ids
+}
+
+// ── Logique de sync ───────────────────────────────────────────
+
+export async function runRssSync(): Promise<{ sent: number; skipped: number; errors: number }> {
+    const synced = loadSynced()
+    const ids    = Object.keys(synced).map(Number)
+    if (ids.length === 0) return { sent: 0, skipped: 0, errors: 0 }
+
+    logger.info('rss-sync', `Démarrage sync — ${ids.length} série(s) surveillée(s)`)
+
+    const organized  = readOrganized()
+    const seriesData = await loadEnrichedSeriesData()
+
+    const activeHashes = new Set<string>()
+    try {
+        const { category } = readSettings()
+        const infohashMap  = await readInfohashMap()
+        const active       = await dispatchList(category ?? 'fankai', infohashMap)
+        for (const t of active) if (t.hash) activeHashes.add(t.hash.toLowerCase())
+    } catch (err) {
+        logger.warn('rss-sync', `Impossible de lire les torrents actifs : ${err instanceof Error ? err.message : err}`)
+    }
+
+    let sent    = 0
+    let skipped = 0
+    let errors  = 0
+
+    for (const serieId of ids) {
+        const syncedEntry = synced[serieId]
+        const sd          = seriesData.find((s: any) => s.id === serieId)
+        if (!sd) {
+            logger.warn('rss-sync', `Série ${serieId} introuvable dans le cache`)
+            continue
+        }
+
+        const title      = sd.title ?? sd.show_title ?? String(serieId)
+        const activatedAt = new Date(syncedEntry.addedAt)
+        const organizedIds = getOrganizedEpisodeIds(sd, organized)
+
+        logger.info('rss-sync', `Vérification : ${title} (sync activé le ${activatedAt.toLocaleDateString('fr-FR')})`)
+
+        // Épisodes candidats : date_added > date d'activation ET pas encore organisés
+        const candidateIds = new Set<number>()
+        for (const season of sd.seasons ?? []) {
+            for (const ep of season.episodes ?? []) {
+                if (!ep.date_added) continue
+                const epDate = new Date(ep.date_added)
+                if (epDate <= activatedAt) continue
+                if (organizedIds.has(ep.id)) continue
+                // Doit avoir au moins un torrent fankai
+                const hasTorrent = (ep.torrents ?? []).some((t: any) => t.fankai && (t.torrent_url || t.magnet))
+                if (!hasTorrent) continue
+                candidateIds.add(ep.id)
+            }
+        }
+
+        if (candidateIds.size === 0) {
+            logger.info('rss-sync', `${title} — aucun nouvel épisode depuis l'activation`)
+            continue
+        }
+
+        logger.info('rss-sync', `${title} — ${candidateIds.size} nouvel(s) épisode(s) à télécharger`)
+
+        // Construire les téléchargements : pack saison si couvre des candidats, sinon épisode par épisode
+        const toDownload: { url: string; file_index?: number | null; file_path?: string | null; infohash?: string | null; label: string }[] = []
+        const coveredIds  = new Set<number>()
+
+        // 1. Packs saison couvrant au moins un candidat
+        for (const season of sd.seasons ?? []) {
+            for (const t of season.torrents ?? []) {
+                if (!t.fankai) continue
+                const url  = t.torrent_url ?? t.magnet
+                if (!url)  continue
+                const hash = t.infohash?.toLowerCase()
+                if (hash && activeHashes.has(hash)) { skipped++; continue }
+
+                const coversSomeCandidate = (season.episodes ?? []).some((ep: any) =>
+                    candidateIds.has(ep.id) && !coveredIds.has(ep.id)
+                )
+                if (!coversSomeCandidate) { skipped++; continue }
+
+                toDownload.push({ url, infohash: hash ?? null, label: `S${season.season_number} ${title}` })
+                for (const ep of season.episodes ?? []) coveredIds.add(ep.id)
+            }
+        }
+
+        // 2. Épisodes individuels candidats non couverts par un pack
+        for (const season of sd.seasons ?? []) {
+            for (const ep of season.episodes ?? []) {
+                if (!candidateIds.has(ep.id) || coveredIds.has(ep.id)) continue
+
+                for (const t of ep.torrents ?? []) {
+                    if (!t.fankai) continue
+                    const url  = t.torrent_url ?? t.magnet
+                    if (!url)  continue
+                    const hash = t.infohash?.toLowerCase()
+                    if (hash && activeHashes.has(hash)) { skipped++; continue }
+
+                    const pathEntry = (ep.paths ?? []).find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === hash)
+                    toDownload.push({
+                        url,
+                        infohash  : hash ?? null,
+                        file_index: pathEntry?.file_index ?? null,
+                        file_path : pathEntry?.path ?? null,
+                        label     : `S${season.season_number}E${ep.episode_number} ${title}`,
+                    })
+                    coveredIds.add(ep.id)
+                    break
+                }
+            }
+        }
+
+        for (const dl of toDownload) {
+            try {
+                const results = await dispatchDownload(dl.url, {
+                    file_index: dl.file_index,
+                    file_path : dl.file_path,
+                    infohash  : dl.infohash,
+                })
+                if (results.some((r: any) => r.ok)) {
+                    logger.info('rss-sync', `Envoyé : ${dl.label}`)
+                    sent++
+                } else {
+                    logger.warn('rss-sync', `Échec envoi : ${dl.label}`)
+                    errors++
+                }
+            } catch (err) {
+                logger.error('rss-sync', `Erreur dispatch ${dl.label} : ${err instanceof Error ? err.message : err}`)
+                errors++
+            }
+        }
+    }
+
+    logger.info('rss-sync', `Sync terminé — ${sent} envoyé(s), ${skipped} ignoré(s), ${errors} erreur(s)`)
+    return { sent, skipped, errors }
+}

server/lib/serie-helpers.ts

@@ -1,3 +1,5 @@
+import path from 'path'
+
 const FANKAI_API = 'https://metadata.fankai.fr'
 
 export async function fankaiGet(endpoint: string): Promise<any> {
@@ -43,6 +45,77 @@ export function extractTorrentsFromSerieData(sd: any): any[] {
     return result
 }
 
+/**
+ * Résout les noms d'un épisode en préférant les valeurs du path entry
+ * correspondant au hash donné (spécifique au torrent/encoding),
+ * avec fallback sur les champs de niveau épisode.
+ *
+ * Utilisation :
+ *   const { formatted_name, nfo_filename, original_filename } = resolveEpNaming(ep, hash)
+ */
+export function resolveEpNaming(ep: any, hash?: string | null): {
+    formatted_name   : string | null
+    nfo_filename     : string | null
+    original_filename: string | null
+} {
+    const h = hash?.toLowerCase() ?? null
+    const pathEntry = h
+        ? (ep.paths ?? []).find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === h)
+        : null
+    return {
+        formatted_name   : pathEntry?.formatted_name    ?? ep.formatted_name    ?? null,
+        nfo_filename     : pathEntry?.nfo_filename      ?? ep.nfo_filename      ?? null,
+        original_filename: pathEntry?.original_filename ?? ep.original_filename ?? null,
+    }
+}
+
+/**
+ * Calcule le nom attendu d'un fichier épisode selon le mode (NFO ou formaté).
+ * Source unique de vérité partagée entre organized-summary, organized/:id, rename-episode et rename-all.
+ */
+export function computeExpectedName(
+    ep      : any,
+    orgEntry: any,
+    hash    : string | null,
+    nfoSupport: boolean,
+): { currentName: string; expectedName: string; needsRename: boolean } {
+    const currentName = orgEntry.dest_path ? path.basename(orgEntry.dest_path) : orgEntry.dest_filename
+    const srcExt      = path.extname(currentName)
+    const { formatted_name: rawFmt, nfo_filename: rawNfo } = resolveEpNaming(ep, hash)
+    const expectedName = nfoSupport
+        ? (rawNfo  ? rawNfo.replace(/\.[^.]+$/, '')  + srcExt : currentName)
+        : (rawFmt?.trim() ? rawFmt.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : currentName)
+    return { currentName, expectedName, needsRename: expectedName !== currentName }
+}
+
+/**
+ * Dédoublonne une liste d'épisodes par episode_number.
+ * Quand plusieurs variantes existent (ex. x264 + x265), on garde la première
+ * comme épisode principal et on fusionne les torrents des autres dans sa liste.
+ */
+export function deduplicateEpisodes(episodes: any[]): any[] {
+    const map = new Map<number, any>()
+    for (const ep of episodes) {
+        const key = ep.episode_number
+        if (!map.has(key)) {
+            map.set(key, { ...ep, torrents: [...(ep.torrents ?? [])] })
+        } else {
+            const primary = map.get(key)!
+            const seenHashes = new Set(primary.torrents.map((t: any) => t.infohash).filter(Boolean))
+            for (const t of ep.torrents ?? []) {
+                if (!t.infohash || !seenHashes.has(t.infohash)) {
+                    primary.torrents.push(t)
+                    if (t.infohash) seenHashes.add(t.infohash)
+                }
+            }
+            primary.torrent   = primary.torrents[0] ?? null
+            primary.available = primary.available || ep.available
+            primary.organized = primary.organized || ep.organized
+        }
+    }
+    return Array.from(map.values())
+}
+
 export function buildResolvedEpisodes(sd: any, hash: string, seasonFilter?: number): any[] {
     const resolved: any[] = []
     const h = hash.toLowerCase()
@@ -69,14 +142,19 @@ export function computeSerieDownloadState(serieData: any | null, organized: Reco
 
     if (allTorrents.some(t => t.infohash && activeTorrents.has(t.infohash.toLowerCase()))) return 'downloading'
 
-    const allEpisodeIds = new Set<number>()
+    // Dédoublonnage : épisodes uniques par (season_number, episode_number)
+    // pour éviter de compter x264 + x265 comme deux épisodes distincts
+    const uniqueEpKeys = new Set<string>()
+    const epIdToKey    = new Map<number, string>()
     for (const season of serieData.seasons ?? []) {
         for (const ep of season.episodes ?? []) {
-            allEpisodeIds.add(ep.id)
+            const key = `${season.season_number}:${ep.episode_number}`
+            uniqueEpKeys.add(key)
+            epIdToKey.set(ep.id, key)
         }
     }
 
-    const organizedEpisodeIds = new Set<number>()
+    const organizedEpKeys = new Set<string>()
 
     for (const t of allTorrents) {
         const hash = t.infohash?.toLowerCase()
@@ -85,18 +163,24 @@ export function computeSerieDownloadState(serieData: any | null, organized: Reco
         if (Object.keys(orgFiles).length === 0) continue
         for (const ep of buildResolvedEpisodes(serieData, hash, t.season_number)) {
             const isOrganized = orgFiles[String(ep.episode_id)] !== undefined || orgFiles[ep.filename] !== undefined
-            if (isOrganized) organizedEpisodeIds.add(ep.episode_id)
+            if (isOrganized) {
+                const key = epIdToKey.get(ep.episode_id)
+                if (key) organizedEpKeys.add(key)
+            }
         }
     }
 
     const manualOrg = organized['manual'] ?? {}
     for (const season of serieData.seasons ?? []) {
         for (const ep of season.episodes ?? []) {
-            if (manualOrg[String(ep.id)]) organizedEpisodeIds.add(ep.id)
+            if (manualOrg[String(ep.id)]) {
+                const key = epIdToKey.get(ep.id)
+                if (key) organizedEpKeys.add(key)
+            }
         }
     }
 
-    if (allEpisodeIds.size === 0 || organizedEpisodeIds.size === 0) return 'none'
-    if (organizedEpisodeIds.size >= allEpisodeIds.size) return 'complete'
+    if (uniqueEpKeys.size === 0 || organizedEpKeys.size === 0) return 'none'
+    if (organizedEpKeys.size >= uniqueEpKeys.size) return 'complete'
     return 'partial'
 }

server/organize-worker.ts

@@ -113,13 +113,15 @@ function buildFileMap(
         if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
         for (const ep of season.episodes ?? []) {
             const paths: any[] = ep.paths ?? []
-            let matchedPath: string | null = null
+            let matchedPath   : string | null = null
+            let matchedPathObj: any            = null
 
             for (const p of paths) {
                 if (typeof p === 'string') {
                     if (!matchedPath) matchedPath = p.replace(/\\/g, '/')
                 } else if (p?.infohash?.toLowerCase() === h) {
-                    matchedPath = p.path.replace(/\\/g, '/')
+                    matchedPath    = p.path.replace(/\\/g, '/')
+                    matchedPathObj = p
                     break
                 }
             }
@@ -127,8 +129,12 @@ function buildFileMap(
             if (!matchedPath) continue
             const filename = matchedPath.split('/').pop() ?? matchedPath
 
-            const fmtName = ep.formatted_name?.trim()
-                ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '') + '.mkv'
+            // Nommage : priorité aux valeurs du path entry (spécifique au torrent/encoding)
+            const rawFmt      = matchedPathObj?.formatted_name    ?? ep.formatted_name
+            const rawNfo      = matchedPathObj?.nfo_filename      ?? ep.nfo_filename
+            const rawOriginal = matchedPathObj?.original_filename ?? ep.original_filename
+            const fmtName     = rawFmt?.trim()
+                ? rawFmt.replace(/[<>:"/\\|?*]/g, '') + '.mkv'
                 : null
 
             if (!nfoSupport && !fmtName) {
@@ -137,8 +143,8 @@ function buildFileMap(
 
             const srcExt = path.extname(filename)
             const resolvedName = nfoSupport
-                ? (ep.nfo_filename ?? ep.original_filename ?? filename)
-                : (fmtName ?? ep.nfo_filename ?? ep.original_filename ?? filename)
+                ? (rawNfo ?? rawOriginal ?? filename)
+                : (fmtName ?? rawNfo ?? rawOriginal ?? filename)
             const destName = swapExtension(resolvedName, srcExt)
 
             map.set(filename, {
@@ -247,6 +253,26 @@ function seasonFolder(n: number): string {
     return n === 0 ? 'Specials' : `Saison ${n}`
 }
 
+/**
+ * Supprime un fichier avec retry en cas d'EBUSY (Windows : fichier encore ouvert par qBit/autre).
+ * 5 tentatives × 500 ms = 2,5 s max avant de remonter l'erreur.
+ */
+async function unlinkWithRetry(filePath: string, maxAttempts = 5): Promise<void> {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            await fsp.unlink(filePath)
+            return
+        } catch (err: any) {
+            if (err?.code === 'EBUSY' && attempt < maxAttempts - 1) {
+                warn(`EBUSY sur "${path.basename(filePath)}" — retry ${attempt + 1}/${maxAttempts - 1}`)
+                await new Promise(r => setTimeout(r, 500))
+            } else {
+                throw err
+            }
+        }
+    }
+}
+
 function tryHardlink(src: string, dest: string): boolean {
     try { fs.linkSync(src, dest); return true }
     catch (err) {
@@ -264,7 +290,13 @@ function sanitizeDirName(name: string): string {
 }
 
 // ─── Organise un torrent ──────────────────────────────────────
-async function organizeTorrent(hash: string, name: string, savePath: string, seriesData: any[]) {
+async function organizeTorrent(
+    hash              : string,
+    name              : string,
+    savePath          : string,
+    seriesData        : any[],
+    completedFileNames: Set<string> | null = null,
+) {
     const { mediaPath, completePath, organizeMode, nfoSupport } = readSettings()
     const result = { total: 0, skipped: 0, done: 0, errors: [] as { file: string; error: string }[] }
 
@@ -289,20 +321,29 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
         const ep      = torrent._episode
         const season  = torrent._season
         const paths: any[] = ep.paths ?? []
-        let filePath: string | null = null
+        let filePath   : string | null = null
+        let matchedPathObj: any         = null
         for (const p of paths) {
             if (typeof p === 'string') { if (!filePath) filePath = p.replace(/\\/g, '/') }
-            else if (p?.infohash?.toLowerCase() === hash.toLowerCase()) { filePath = p.path.replace(/\\/g, '/'); break }
+            else if (p?.infohash?.toLowerCase() === hash.toLowerCase()) {
+                filePath       = p.path.replace(/\\/g, '/')
+                matchedPathObj = p
+                break
+            }
         }
         const filename = filePath?.split('/').pop() ?? name
-        const fmtName  = ep.formatted_name?.trim()
-            ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '') + '.mkv'
+        // Nommage : priorité aux valeurs du path entry (spécifique au torrent/encoding)
+        const rawFmt      = matchedPathObj?.formatted_name    ?? ep.formatted_name
+        const rawNfo      = matchedPathObj?.nfo_filename      ?? ep.nfo_filename
+        const rawOriginal = matchedPathObj?.original_filename ?? ep.original_filename
+        const fmtName     = rawFmt?.trim()
+            ? rawFmt.replace(/[<>:"/\\|?*]/g, '') + '.mkv'
             : null
 
         const srcExt       = path.extname(filename)
         const resolvedName = nfoSupport
-            ? (ep.nfo_filename ?? ep.original_filename ?? filename)
-            : (fmtName ?? ep.nfo_filename ?? ep.original_filename ?? filename)
+            ? (rawNfo ?? rawOriginal ?? filename)
+            : (fmtName ?? rawNfo ?? rawOriginal ?? filename)
         const destName = swapExtension(resolvedName, srcExt)
 
         const destDir = path.join(mediaPath, serieTitle, seasonFolder(season.season_number ?? 1))
@@ -310,6 +351,12 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
 
         if (isOrganized(hash, ep.id)) return { ...result, total: 1, skipped: 1 }
 
+        // Vérification de complétion pour épisode unique
+        if (completedFileNames !== null && !completedFileNames.has(filename.toLowerCase())) {
+            warn(`Skip (incomplet / priorité 0) : ${filename}`)
+            return { ...result, total: 1, skipped: 1 }
+        }
+
         const candidates = filePath ? [
             path.join(savePath, filePath),
             path.join(completePath, filePath),
@@ -324,8 +371,8 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
         for (const c of candidates) { if (fs.existsSync(c)) { src = c; break } }
 
         if (!src) {
-            error(`Fichier source introuvable : ${filename}`)
-            return { ...result, total: 1, errors: [{ file: filename, error: 'Source introuvable' }] }
+            error(`Fichier source introuvable : ${filename}\n  Chemins essayés :\n${candidates.map(c => `    - ${c}`).join('\n')}`)
+            return { ...result, total: 1, errors: [{ file: filename, error: `Source introuvable (chemins essayés : ${candidates.join(', ')})` }] }
         }
 
         if (!fs.existsSync(dest)) {
@@ -341,7 +388,7 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
                     episode: ep.episode_number, episode_id: ep.id,
                     src_filename: filename, dest_filename: destName, dest_path: dest,
                 })
-                await fsp.unlink(src)
+                await unlinkWithRetry(src)
                 log(`${destName} → Saison ${season.season_number}`)
                 return { ...result, total: 1, done: 1 }
             }
@@ -370,6 +417,14 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
     for (const [filename, { season_number, episode_number, episode_id, nfo_filename, fullPath }] of fileMap) {
         if (isOrganized(hash, episode_id)) { result.skipped++; continue }
 
+        // Vérification de complétion : si on a les infos de progression par fichier,
+        // on skip les fichiers pas encore à 100% (ex: priorité 0 ou en cours de téléchargement).
+        if (completedFileNames !== null && !completedFileNames.has(filename.toLowerCase())) {
+            warn(`Skip (incomplet / priorité 0) : ${filename}`)
+            result.skipped++
+            continue
+        }
+
         const candidates = [
             path.join(savePath, fullPath),
             path.join(completePath, fullPath),
@@ -381,8 +436,7 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
 
         if (!src) {
             // Fichier absent du disque : pas encore téléchargé ou hors sélection (priorité 0).
-            // On skip silencieusement — pas une erreur.
-            debug(`Fichier non disponible (skip) : ${filename}`)
+            warn(`Skip (fichier absent) : ${filename}\n  Chemins essayés :\n${candidates.map(c => `    - ${c}`).join('\n')}`)
             result.skipped++
             continue
         }
@@ -418,7 +472,7 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser
                     episode: episode_number, episode_id,
                     src_filename: filename, dest_filename: nfo_filename, dest_path: dest,
                 })
-                await fsp.unlink(src)
+                await unlinkWithRetry(src)
             }
             result.done++
             debug(`${nfo_filename} → Saison ${season_number}`)
@@ -464,7 +518,29 @@ parentPort?.on('message', async (msg: any) => {
         }
 
         try {
-            const result = await organizeTorrent(t.hash, t.name, t.save_path, seriesData)
+            // Construire l'ensemble des fichiers 100% complets à partir des infos de progression.
+            // On ne filtre QUE si le client fournit des noms de fichiers (qBittorrent, Transmission).
+            // Si aucun fichier n'a de nom (rtorrent…), on passe null → pas de filtrage.
+            let completedFileNames: Set<string> | null = null
+            if (Array.isArray(t.files) && t.files.length > 0) {
+                // Vérifier qu'au moins un fichier a un nom non vide
+                const hasNames = t.files.some((f: any) => f.name && String(f.name).trim())
+                if (hasNames) {
+                    completedFileNames = new Set(
+                        t.files
+                            .filter((f: any) => (f.progress ?? 0) >= 1 && f.name && String(f.name).trim())
+                            .map((f: any) => {
+                                // f.name est un chemin relatif ex: "Pack S1/Episode1.mkv"
+                                // on ne garde que le basename pour comparer au filename du fileMap
+                                const parts = String(f.name).replace(/\\/g, '/').split('/')
+                                return (parts[parts.length - 1] ?? '').toLowerCase()
+                            })
+                            .filter(Boolean)
+                    )
+                }
+            }
+
+            const result = await organizeTorrent(t.hash, t.name, t.save_path, seriesData, completedFileNames)
             parentPort?.postMessage({ type: 'result', hash: t.hash, name: t.name, ...result })
         } catch (err) {
             error(`Erreur lors de l'import de "${t.name}" : ${err instanceof Error ? err.message : err}`)

server/organize.ts

@@ -100,10 +100,17 @@ export async function scanMediaPath(
                     const srcFilename = p.path.replace(/\\/g, '/').split('/').pop()
                     if (!srcFilename) continue
                     idx(srcFilename, hash)
-                    if (ep.nfo_filename) idx(ep.nfo_filename, hash, ep.nfo_filename)
+                    // nfo_filename et formatted_name du path en priorité sur ceux de l'épisode
+                    const pathNfo = p.nfo_filename ?? ep.nfo_filename
+                    if (pathNfo) idx(pathNfo, hash, pathNfo)
+                    const pathFmt = p.formatted_name ?? ep.formatted_name
+                    if (pathFmt?.trim()) {
+                        const fmtBase = pathFmt.replace(/[<>:"/\\|?*]/g, '').trim()
+                        idx(fmtBase, hash, fmtBase)
+                    }
                 }
 
-                // 2. original_filename, nfo_filename et formatted_name — indexés même si paths est vide
+                // 2. original_filename, nfo_filename et formatted_name épisode — fallback
                 const fallbackHash = ep.paths?.[0]?.infohash?.toLowerCase() ?? 'manual'
                 if (ep.original_filename) idx(ep.original_filename, fallbackHash, ep.original_filename)
                 if (ep.nfo_filename)      idx(ep.nfo_filename, fallbackHash, ep.nfo_filename)
@@ -327,6 +334,101 @@ export async function autoOrganizeAll(
     worker.postMessage({ type: 'run', torrents, seriesData })
 }
 
+// ── Migration des IDs épisodes ────────────────────────────────
+//
+// Les IDs d'épisodes, saisons et séries peuvent changer entre deux passages
+// du scraper. On utilise (infohash, season_number, episode_number) comme clé
+// stable pour retrouver le nouvel ID et mettre à jour organized.json.
+
+export async function migrateOrganizedEpisodeIds(
+    organizedPath: string,
+    seriesData   : any[]
+): Promise<{ updated: number; orphaned: number }> {
+
+    // 1. Construire les tables de lookup depuis le catalogue actuel
+    //    hashEpMap : infohash → Map<"S:E", new_episode_id>
+    const hashEpMap = new Map<string, Map<string, number>>()
+    const validIds  = new Set<number>()
+
+    for (const sd of seriesData) {
+        for (const season of sd.seasons ?? []) {
+            for (const ep of season.episodes ?? []) {
+                validIds.add(ep.id)
+                for (const p of ep.paths ?? []) {
+                    if (typeof p !== 'object' || !p.infohash) continue
+                    const h   = p.infohash.toLowerCase()
+                    const key = `${season.season_number}:${ep.episode_number}`
+                    if (!hashEpMap.has(h)) hashEpMap.set(h, new Map())
+                    hashEpMap.get(h)!.set(key, ep.id)
+                }
+            }
+        }
+    }
+
+    // 2. Charger organized.json
+    let organized: Organized = {}
+    try {
+        if (fs.existsSync(organizedPath))
+            organized = JSON.parse(fs.readFileSync(organizedPath, 'utf-8'))
+    } catch { return { updated: 0, orphaned: 0 } }
+
+    let updated = 0
+    let orphaned = 0
+    let changed  = false
+
+    for (const [hash, episodes] of Object.entries(organized)) {
+        if (hash === 'manual') continue
+        const epMap = hashEpMap.get(hash.toLowerCase())
+
+        const newEpisodes: Record<string, any> = {}
+        for (const [oldIdStr, entry] of Object.entries(episodes as Record<string, any>)) {
+            const oldId = Number(oldIdStr)
+
+            if (validIds.has(oldId)) {
+                // ID encore valide, aucun changement
+                newEpisodes[oldIdStr] = entry
+                continue
+            }
+
+            // ID orphelin — chercher le nouvel ID via (hash, saison, épisode)
+            const key   = `${entry.season}:${entry.episode}`
+            const newId = epMap?.get(key)
+
+            if (newId && newId !== oldId) {
+                // Vérifier qu'on n'écrase pas une entrée déjà présente avec le nouvel ID
+                if (newEpisodes[String(newId)] || (episodes as any)[String(newId)]) {
+                    // Le nouvel ID est déjà présent → l'ancien est un orphelin inutile, on le supprime simplement
+                    changed = true
+                    logger.info('organize', `Migration ID : ep ${oldId} orphelin supprimé (${newId} déjà présent) (${hash.slice(0, 8)}… S${entry.season}E${entry.episode})`)
+                } else {
+                    newEpisodes[String(newId)] = { ...entry, episode_id: newId }
+                    updated++
+                    changed = true
+                    logger.info('organize', `Migration ID : ep ${oldId} → ${newId} (${hash.slice(0, 8)}… S${entry.season}E${entry.episode})`)
+                }
+            } else {
+                // Introuvable — on conserve pour ne pas perdre l'entrée
+                orphaned++
+                newEpisodes[oldIdStr] = entry
+                logger.warn('organize', `Migration ID : ep ${oldId} introuvable dans le catalogue (${hash.slice(0, 8)}… S${entry.season}E${entry.episode})`)
+            }
+        }
+
+        organized[hash] = newEpisodes
+        // Nettoyer les hash vides
+        if (Object.keys(organized[hash]).length === 0) delete organized[hash]
+    }
+
+    if (changed) {
+        fs.writeFileSync(organizedPath, JSON.stringify(organized, null, 2), 'utf-8')
+        logger.info('organize', `Migration IDs terminée — ${updated} mis à jour${orphaned > 0 ? `, ${orphaned} non résolus` : ''}`)
+    } else {
+        logger.debug('organize', `Migration IDs — aucun changement nécessaire${orphaned > 0 ? ` (${orphaned} IDs inconnus conservés)` : ''}`)
+    }
+
+    return { updated, orphaned }
+}
+
 // ── Sync des noms de fichiers après mise à jour du scraper ────
 
 export async function syncFilenameChanges(
@@ -362,9 +464,15 @@ export async function syncFilenameChanges(
                     ? path.basename(orgEntry.dest_path)
                     : orgEntry.dest_filename
                 const srcExt = path.extname(currentName)
+                // Priorité aux valeurs du path entry correspondant au hash organisé
+                const matchedPathEntry = (ep.paths ?? []).find((p: any) =>
+                    typeof p === 'object' && p.infohash?.toLowerCase() === orgHash
+                )
+                const rawFmt = matchedPathEntry?.formatted_name ?? ep.formatted_name
+                const rawNfo = matchedPathEntry?.nfo_filename   ?? ep.nfo_filename
                 const expectedName: string = nfoSupport
-                    ? (ep.nfo_filename ? ep.nfo_filename.replace(/\.[^.]+$/, '') + srcExt : currentName)
-                    : (ep.formatted_name?.trim() ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : currentName)
+                    ? (rawNfo ? rawNfo.replace(/\.[^.]+$/, '') + srcExt : currentName)
+                    : (rawFmt?.trim() ? rawFmt.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : currentName)
 
                 if (expectedName === currentName) continue
 

server/routes/downloads.ts

@@ -19,9 +19,10 @@ router.post('/download', requireAuth, async (req, res) => {
     const url = torrent_url ?? magnet
     if (!url) { res.status(400).json({ error: 'torrent_url ou magnet requis' }); return }
     const file_index: number | null = req.body.file_index != null ? Number(req.body.file_index) : null
-    const file_path : string | null = req.body.file_path ?? null
-    logger.info('api', `Téléchargement demandé via ${torrent_url ? '.torrent' : 'magnet'}${file_index != null ? ` (fichier #${file_index})` : ''}`)
-    const results = await dispatchDownload(url, { file_index, file_path, magnet })
+    const file_path : string | null = req.body.file_path  ?? null
+    const infohash  : string | null = req.body.infohash   ?? null
+    logger.info('api', `Téléchargement demandé via ${torrent_url ? '.torrent' : 'magnet'}${file_path ? ` (${file_path})` : ''}`)
+    const results = await dispatchDownload(url, { file_index, file_path, infohash, magnet })
     res.status(results.every((r: any) => r.ok) ? 200 : 207).json({ results })
 })
 
@@ -48,19 +49,27 @@ router.get('/downloads', requireAuth, async (_req, res) => {
         const enriched = await Promise.all(torrents.map(async (t: any) => {
             const orgFiles = organized[t.hash] ?? {}
             let totalFiles = 1
+            let serieName: string | undefined
+            let episodes: any[] = []
             try {
                 const availableIds = await readAvailable()
                 for (const id of availableIds) {
                     const sd = await readSerieData(id)
                     if (!sd) continue
                     const match = extractTorrentsFromSerieData(sd).find((st: any) => st.infohash?.toLowerCase() === t.hash?.toLowerCase())
-                    if (match) { totalFiles = buildResolvedEpisodes(sd, match.infohash, match.season_number).length || 1; break }
+                    if (match) {
+                        const resolved = buildResolvedEpisodes(sd, match.infohash, match.season_number)
+                        totalFiles = resolved.length || 1
+                        serieName  = sd.title ?? sd.show_title
+                        episodes   = resolved
+                        break
+                    }
                 }
             } catch {}
             const doneFiles = Object.keys(orgFiles).length
             const organizeState: 'none' | 'partial' | 'done' = doneFiles >= totalFiles ? 'done' : doneFiles > 0 ? 'partial' : 'none'
             const notif = recentOrganized.find(n => n.hash === t.hash)
-            return { ...t, organizeState, organizeProgress: { done: doneFiles, total: totalFiles }, errorFiles: notif?.errorFiles ?? [] }
+            return { ...t, organizeState, organizeProgress: { done: doneFiles, total: totalFiles }, errorFiles: notif?.errorFiles ?? [], serieName, episodes }
         }))
         res.json(enriched)
     } catch (err) {

server/routes/import.ts

@@ -7,7 +7,9 @@ import { DATA_DIR } from '../config.js'
 import { readSettings } from '../settings.js'
 import { getGitlabTitle } from '../gitlab-map.js'
 import { readSerieData, loadEnrichedSeriesData } from '../lib/github-cache.js'
+import { resolveEpNaming, computeExpectedName } from '../lib/serie-helpers.js'
 import { GITLAB_API_NFO, GITLAB_RAW_NFO } from '../lib/nfo.js'
+import { dispatchRemove } from '../torrent-clients/index.js'
 
 const router = Router()
 
@@ -30,7 +32,13 @@ router.post('/manual-import', requireAuth, async (req, res) => {
     }
     const { mediaPath, organizeMode, nfoSupport } = readSettings()
     const organized = loadOrganizedJson()
-    const sd = await readSerieData(Number(serie_id))
+    let sd = await readSerieData(Number(serie_id))
+    if (!sd) {
+        // readSerieData ne couvre que le cache local — fallback sur le catalogue complet
+        // (utile pour les séries sans torrent officiel dont les données sont peut-être absentes du cache individuel)
+        const all = await loadEnrichedSeriesData()
+        sd = all.find((s: any) => s.id === Number(serie_id)) ?? null
+    }
     if (!sd) { res.status(404).json({ error: 'Série introuvable dans le catalogue' }); return }
     const rawTitle   = sd.title ?? sd.show_title ?? ''
     const serieTitle = rawTitle.replace(/:/g, ' -').replace(/[<>"/\\|?*]/g, '').replace(/\s+/g, ' ').trim()
@@ -50,10 +58,11 @@ router.post('/manual-import', requireAuth, async (req, res) => {
         const { ep, season } = found
         const srcFilename   = path.basename(file_path)
         const srcExt        = path.extname(srcFilename)
-        const fmtName       = ep.formatted_name?.trim() ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '') + '.mkv' : null
+        const { formatted_name: rawFmt, nfo_filename: rawNfo, original_filename: rawOrig } = resolveEpNaming(ep, hash)
+        const fmtName       = rawFmt?.trim() ? rawFmt.replace(/[<>:"/\\|?*]/g, '') + '.mkv' : null
         const resolvedName  = nfoSupport
-            ? (ep.nfo_filename ?? ep.original_filename ?? srcFilename)
-            : (fmtName ?? ep.nfo_filename ?? ep.original_filename ?? srcFilename)
+            ? (rawNfo ?? rawOrig ?? srcFilename)
+            : (fmtName ?? rawNfo ?? rawOrig ?? srcFilename)
         const resolvedExt  = path.extname(resolvedName)
         const destFilename = resolvedExt && resolvedExt !== srcExt
             ? resolvedName.slice(0, -resolvedExt.length) + srcExt
@@ -63,6 +72,19 @@ router.post('/manual-import', requireAuth, async (req, res) => {
         const destPath      = path.join(destDir, destFilename)
         try {
             if (!fs.existsSync(file_path)) throw new Error('Fichier source introuvable')
+
+            // Nettoyer toute entrée organized qui référence ce même fichier physique
+            // sous un épisode différent (réassignation → l'ancien enregistrement devient invalide)
+            for (const [h, eps] of Object.entries(organized)) {
+                for (const [epId, entry] of Object.entries(eps)) {
+                    if (entry?.dest_path === file_path && Number(epId) !== Number(episode_id)) {
+                        delete (organized[h] as any)[epId]
+                        logger.info('api', `Import manuel : suppression entrée stale ep ${epId} (fichier réassigné)`)
+                    }
+                }
+                if (Object.keys(organized[h]).length === 0) delete organized[h]
+            }
+
             fs.mkdirSync(destDir, { recursive: true })
             if (file_path !== destPath) {
                 const serieRootPath  = path.join(mediaPath, serieTitle)
@@ -136,19 +158,26 @@ router.get('/organized/:serieId', requireAuth, async (req, res) => {
     try {
         const sd = await readSerieData(serieId)
         if (!sd) { res.status(404).json({ error: 'Série introuvable' }); return }
-        const organized = loadOrganizedJson()
+        const organized    = loadOrganizedJson()
+        const { nfoSupport } = readSettings()
         const result: Record<string, any> = {}
         for (const season of sd.seasons ?? []) {
             for (const ep of season.episodes ?? []) {
+                let entry: any    = null
+                let entryHash     = 'manual'
                 for (const p of ep.paths ?? []) {
                     if (typeof p !== 'object' || !p.infohash) continue
-                    const hash    = p.infohash.toLowerCase()
-                    const entry   = (organized[hash] ?? {})[String(ep.id)]
-                    if (entry) { result[String(ep.id)] = entry; break }
+                    const h = p.infohash.toLowerCase()
+                    const e = (organized[h] ?? {})[String(ep.id)]
+                    if (e) { entry = e; entryHash = h; break }
                 }
-                if (!result[String(ep.id)] && organized['manual']?.[String(ep.id)]) {
-                    result[String(ep.id)] = organized['manual'][String(ep.id)]
+                if (!entry && organized['manual']?.[String(ep.id)]) {
+                    entry = organized['manual'][String(ep.id)]
                 }
+                if (!entry) continue
+
+                const { needsRename } = computeExpectedName(ep, entry, entryHash, nfoSupport)
+                result[String(ep.id)] = { ...entry, hash: entryHash, needs_rename: needsRename }
             }
         }
         res.json(result)
@@ -183,15 +212,8 @@ router.post('/rename-episode', requireAuth, async (req, res) => {
         }
     }
     if (!orgEntry) { res.status(404).json({ error: 'Épisode non importé' }); return }
-    const currentName = orgEntry.dest_path ? path.basename(orgEntry.dest_path) : orgEntry.dest_filename
-    const srcExt = path.extname(currentName)
-    let newName: string
-    if (nfoSupport) {
-        newName = ep.nfo_filename ? ep.nfo_filename.replace(/\.[^.]+$/, '') + srcExt : currentName
-    } else {
-        newName = ep.formatted_name?.trim() ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : currentName
-    }
-    if (newName === currentName) { res.json({ ok: true, renamed: false, message: 'Nom déjà correct' }); return }
+    const { currentName, expectedName: newName, needsRename } = computeExpectedName(ep, orgEntry, entryHash, nfoSupport)
+    if (!needsRename) { res.json({ ok: true, renamed: false, message: 'Nom déjà correct' }); return }
     const oldPath = orgEntry.dest_path
     const newPath = path.join(path.dirname(oldPath), newName)
     try {
@@ -222,6 +244,7 @@ router.delete('/organized/:serieId', requireAuth, async (req, res) => {
     }
     let removed = 0
     const errors: string[] = []
+    const emptyHashes: string[] = []
     for (const [hash, episodes] of Object.entries(organized)) {
         for (const epId of Object.keys(episodes)) {
             if (!episodeIds.has(epId)) continue
@@ -232,10 +255,53 @@ router.delete('/organized/:serieId', requireAuth, async (req, res) => {
             delete organized[hash][epId]
             removed++
         }
-        if (Object.keys(organized[hash]).length === 0) delete organized[hash]
+        if (Object.keys(organized[hash]).length === 0) { delete organized[hash]; emptyHashes.push(hash) }
     }
     saveOrganizedJson(organized)
-    logger.info('api', `Désimport série ${serieId} — ${removed} épisode(s) retirés`)
+    if (deleteFile) {
+        for (const hash of emptyHashes) {
+            if (hash === 'manual') continue
+            dispatchRemove(hash, false).catch(err => logger.warn('api', `Impossible de retirer le torrent ${hash.slice(0, 8)}… du client : ${err instanceof Error ? err.message : err}`))
+        }
+    }
+    logger.info('api', `Désimport série ${serieId} — ${removed} épisode(s) retirés${deleteFile && emptyHashes.length ? `, ${emptyHashes.length} torrent(s) retirés du client` : ''}`)
+    res.json({ ok: true, removed, errors })
+})
+
+// ── Désimport saison ───────────────────────────────────────────
+router.delete('/organized/:serieId/seasons/:seasonId', requireAuth, async (req, res) => {
+    const serieId    = String(req.params.serieId)
+    const seasonId   = Number(req.params.seasonId)
+    const deleteFile = req.query.deleteFile === 'true'
+    const organized  = loadOrganizedJson()
+    const sd = await readSerieData(Number(serieId))
+    if (!sd) { res.status(404).json({ error: 'Série introuvable' }); return }
+    const season = sd.seasons?.find((s: any) => s.id === seasonId)
+    if (!season) { res.status(404).json({ error: 'Saison introuvable' }); return }
+    const episodeIds = new Set<string>(season.episodes?.map((e: any) => String(e.id)) ?? [])
+    let removed = 0
+    const errors: string[] = []
+    const emptyHashes: string[] = []
+    for (const [hash, episodes] of Object.entries(organized)) {
+        for (const epId of Object.keys(episodes)) {
+            if (!episodeIds.has(epId)) continue
+            const entry = episodes[epId]
+            if (deleteFile && entry?.dest_path && fs.existsSync(entry.dest_path)) {
+                try { fs.unlinkSync(entry.dest_path) } catch { errors.push(entry.dest_path) }
+            }
+            delete organized[hash][epId]
+            removed++
+        }
+        if (Object.keys(organized[hash]).length === 0) { delete organized[hash]; emptyHashes.push(hash) }
+    }
+    saveOrganizedJson(organized)
+    if (deleteFile) {
+        for (const hash of emptyHashes) {
+            if (hash === 'manual') continue
+            dispatchRemove(hash, false).catch(err => logger.warn('api', `Impossible de retirer le torrent ${hash.slice(0, 8)}… du client : ${err instanceof Error ? err.message : err}`))
+        }
+    }
+    logger.info('api', `Désimport saison ${seasonId} (série ${serieId}) — ${removed} épisode(s) retirés${deleteFile && emptyHashes.length ? `, ${emptyHashes.length} torrent(s) retirés du client` : ''}`)
     res.json({ ok: true, removed, errors })
 })
 
@@ -256,9 +322,14 @@ router.delete('/organized/:serieId/:episodeId', requireAuth, async (req, res) =>
             logger.info('api', `Désimport + suppression fichier : "${foundEntry.dest_path}"`)
         }
         delete organized[foundHash][episodeId]
-        if (Object.keys(organized[foundHash]).length === 0) delete organized[foundHash]
+        const torrentEmpty = Object.keys(organized[foundHash]).length === 0
+        if (torrentEmpty) delete organized[foundHash]
         saveOrganizedJson(organized)
-        logger.info('api', `Désimport ep ${episodeId}`)
+        // Si plus aucun épisode de ce torrent n'est importé → retirer le torrent du client
+        if (deleteFile && torrentEmpty && foundHash !== 'manual') {
+            dispatchRemove(foundHash, false).catch(err => logger.warn('api', `Impossible de retirer le torrent ${foundHash.slice(0, 8)}… du client : ${err instanceof Error ? err.message : err}`))
+        }
+        logger.info('api', `Désimport ep ${episodeId}${deleteFile && torrentEmpty ? ` + torrent ${foundHash.slice(0, 8)}… retiré du client` : ''}`)
         res.json({ ok: true })
     } catch (err) {
         const msg = err instanceof Error ? err.message : 'Erreur inconnue'
@@ -282,20 +353,20 @@ router.get('/organized-summary', requireAuth, async (_req, res) => {
                 for (const ep of season.episodes ?? []) {
                     let orgEntry: any = null
                     let orgHash: string | null = null
-                    for (const [hash, eps] of Object.entries(organized)) {
-                        if (eps[String(ep.id)]) { orgEntry = eps[String(ep.id)]; orgHash = hash; break }
+                    // Même stratégie que organized/:serieId : on cherche via ep.paths d'abord
+                    // pour garantir le bon hash → bon formatted_name dans resolveEpNaming
+                    for (const p of ep.paths ?? []) {
+                        if (typeof p !== 'object' || !p.infohash) continue
+                        const h = p.infohash.toLowerCase()
+                        const e = (organized[h] ?? {})[String(ep.id)]
+                        if (e) { orgEntry = e; orgHash = h; break }
+                    }
+                    if (!orgEntry && organized['manual']?.[String(ep.id)]) {
+                        orgEntry = organized['manual'][String(ep.id)]; orgHash = 'manual'
                     }
                     if (!orgEntry) continue
-                    const currentName = orgEntry.dest_path ? path.basename(orgEntry.dest_path) : orgEntry.dest_filename
-                    const srcExt = path.extname(currentName)
-                    let expectedName: string
-                    if (nfoSupport) {
-                        expectedName = ep.nfo_filename ? ep.nfo_filename.replace(/\.[^.]+$/, '') + srcExt : currentName
-                    } else {
-                        expectedName = ep.formatted_name?.trim() ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : currentName
-                    }
-                    const needsRename = expectedName !== currentName
-                    const fileExists  = orgEntry.dest_path ? fs.existsSync(orgEntry.dest_path) : false
+                    const { currentName, expectedName, needsRename } = computeExpectedName(ep, orgEntry, orgHash, nfoSupport)
+                    const fileExists = orgEntry.dest_path ? fs.existsSync(orgEntry.dest_path) : false
                     episodes.push({ episode_id: ep.id, episode_number: ep.episode_number, season_number: season.season_number, title: ep.title, current_name: currentName, expected_name: expectedName, dest_path: orgEntry.dest_path, torrent_hash: orgHash, needs_rename: needsRename, file_exists: fileExists })
                 }
             }
@@ -328,15 +399,8 @@ router.post('/rename-all', requireAuth, async (req, res) => {
                     if (eps[String(ep.id)]) { orgEntry = eps[String(ep.id)]; orgHash = hash; break }
                 }
                 if (!orgEntry || !orgHash) continue
-                const currentName = orgEntry.dest_path ? path.basename(orgEntry.dest_path) : orgEntry.dest_filename
-                const srcExt = path.extname(currentName)
-                let expectedName: string
-                if (nfoSupport) {
-                    expectedName = ep.nfo_filename ? ep.nfo_filename.replace(/\.[^.]+$/, '') + srcExt : currentName
-                } else {
-                    expectedName = ep.formatted_name?.trim() ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : currentName
-                }
-                if (expectedName === currentName) continue
+                const { currentName, expectedName, needsRename } = computeExpectedName(ep, orgEntry, orgHash, nfoSupport)
+                if (!needsRename) continue
                 const oldPath = orgEntry.dest_path
                 const newPath = path.join(path.dirname(oldPath), expectedName)
                 try {

server/routes/organize.ts

@@ -1,12 +1,26 @@
 import { Router } from 'express'
 import { requireAuth } from '../auth.js'
 import { logger } from '../logger.js'
-import { organizeTorrent } from '../organize.js'
+import { organizeTorrent, migrateOrganizedEpisodeIds } from '../organize.js'
 import { loadEnrichedSeriesData } from '../lib/github-cache.js'
 import { recentOrganized, pushNotif } from '../lib/notifs.js'
+import { DATA_DIR } from '../config.js'
+import path from 'path'
 
 const router = Router()
 
+router.post('/organize/migrate-ids', requireAuth, async (_req, res) => {
+    try {
+        const seriesData    = await loadEnrichedSeriesData()
+        const organizedPath = path.join(DATA_DIR, 'organized.json')
+        const result        = await migrateOrganizedEpisodeIds(organizedPath, seriesData)
+        res.json({ ok: true, ...result })
+    } catch (err) {
+        logger.error('api', `Migration IDs échouée : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
 router.get('/organize/recent', requireAuth, (_req, res) => {
     res.json(recentOrganized)
 })

server/routes/rss-sync.ts

@@ -0,0 +1,48 @@
+import { Router } from 'express'
+import { requireAuth } from '../auth.js'
+import { logger }      from '../logger.js'
+import { loadSynced, setSync, isSynced, runRssSync } from '../lib/rss-sync.js'
+
+const router = Router()
+
+/** GET /api/rss-sync → liste des séries surveillées */
+router.get('/rss-sync', requireAuth, (_req, res) => {
+    res.json(Object.values(loadSynced()))
+})
+
+/** POST /api/rss-sync/run → forcer un cycle de sync maintenant (avant /:id) */
+router.post('/rss-sync/run', requireAuth, async (_req, res) => {
+    try {
+        const result = await runRssSync()
+        res.json({ ok: true, ...result })
+    } catch (err) {
+        logger.error('rss-sync', `Sync forcé échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+/** GET /api/rss-sync/:id → statut sync pour une série */
+router.get('/rss-sync/:id', requireAuth, (req, res) => {
+    const serieId = Number(req.params.id)
+    res.json({ synced: isSynced(serieId) })
+})
+
+/** POST /api/rss-sync/:id → activer la surveillance */
+router.post('/rss-sync/:id', requireAuth, (req, res) => {
+    const serieId   = Number(req.params.id)
+    const serieName = String(req.body.serieName ?? '')
+    if (!serieId || !serieName) { res.status(400).json({ error: 'serieId et serieName requis' }); return }
+    const map = setSync(serieId, serieName, true)
+    logger.info('rss-sync', `Surveillance activée pour "${serieName}" (id ${serieId})`)
+    res.json({ synced: true, total: Object.keys(map).length })
+})
+
+/** DELETE /api/rss-sync/:id → désactiver la surveillance */
+router.delete('/rss-sync/:id', requireAuth, (req, res) => {
+    const serieId = Number(req.params.id)
+    const map     = setSync(serieId, '', false)
+    logger.info('rss-sync', `Surveillance désactivée pour la série ${serieId}`)
+    res.json({ synced: false, total: Object.keys(map).length })
+})
+
+export default router

server/routes/series.ts

@@ -10,6 +10,7 @@ import { readAvailable, readInfohashMap, readSerieData } from '../lib/github-cac
 import {
     fankaiGet, normalizeSerie, normalizeSeason, normalizeEpisode,
     extractTorrentsFromSerieData, buildResolvedEpisodes, computeSerieDownloadState,
+    deduplicateEpisodes,
 } from '../lib/serie-helpers.js'
 
 const router = Router()
@@ -40,7 +41,7 @@ router.get('/series/:id', requireAuth, async (req, res) => {
     const id = Number(req.params.id)
     try {
         const [serieRaw, seasonsData, serieData] = await Promise.all([fankaiGet(`/series/${id}`), fankaiGet(`/series/${id}/seasons`), readSerieData(id)])
-        const serie   = normalizeSerie(serieRaw)
+        const serie   = { ...normalizeSerie(serieRaw), wiki: serieData?.wiki ?? null }
         const seasons = Array.isArray(seasonsData) ? seasonsData : (seasonsData.seasons ?? [])
         const seasonsWithEpisodes = await Promise.all(seasons.map(async (season: any) => {
             const epsData  = await fankaiGet(`/seasons/${season.id}/episodes`)
@@ -99,7 +100,7 @@ router.get('/series/:id', requireAuth, async (req, res) => {
                     for (const t of (ep.torrents ?? [])) {
                         if (!episodeTorrentMap[ep.id]) episodeTorrentMap[ep.id] = []
                         const pathEntry = (ep.paths ?? []).find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === t.infohash?.toLowerCase())
-                        episodeTorrentMap[ep.id].push({ torrent_url: t.torrent_url, magnet: t.magnet, infohash: t.infohash?.toLowerCase() ?? null, type: 'episode', raw: t.title, torrent_name: t.torrent_name ?? null, manual: t.manual ?? false, fankai: t.fankai ?? true, file_index: pathEntry?.file_index ?? null, file_path: pathEntry?.path ?? null })
+                        episodeTorrentMap[ep.id].push({ torrent_url: t.torrent_url, magnet: t.magnet, infohash: t.infohash?.toLowerCase() ?? null, type: 'episode', raw: t.title, torrent_name: t.torrent_name ?? null, manual: t.manual ?? false, fankai: t.fankai ?? true, file_index: pathEntry?.file_index ?? null, file_path: pathEntry?.path ?? null, formatted_name: pathEntry?.formatted_name ?? ep.formatted_name ?? null })
                         availableEpisodeIds.add(ep.id)
                         const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
                         const isOrg = orgFiles[String(ep.id)] !== undefined
@@ -124,7 +125,7 @@ router.get('/series/:id', requireAuth, async (req, res) => {
                             if (!pack) continue
                             seenPackHashes.add(hashKey)
                             if (!episodeTorrentMap[ep.id]) episodeTorrentMap[ep.id] = []
-                            episodeTorrentMap[ep.id].push({ torrent_url: pack.torrent_url, magnet: pack.magnet, infohash: hashKey, type: pack.type, raw: pack.raw, torrent_name: pack.torrent_name ?? null, manual: false, fankai: pack.fankai, file_index: pathEntry.file_index ?? null, file_path: pathEntry.path ?? null })
+                            episodeTorrentMap[ep.id].push({ torrent_url: pack.torrent_url, magnet: pack.magnet, infohash: hashKey, type: pack.type, raw: pack.raw, torrent_name: pack.torrent_name ?? null, manual: false, fankai: pack.fankai, file_index: pathEntry.file_index ?? null, file_path: pathEntry.path ?? null, formatted_name: pathEntry.formatted_name ?? ep.formatted_name ?? null })
                             availableEpisodeIds.add(ep.id)
                         }
                     }
@@ -133,7 +134,7 @@ router.get('/series/:id', requireAuth, async (req, res) => {
         }
 
         const enrichedSeasons = seasonsWithEpisodes.map((season: any) => {
-            const eps = season.episodes.map((ep: any) => {
+            const rawEps = season.episodes.map((ep: any) => {
                 const epTorrents = episodeTorrentMap[ep.id] ?? []
                 const epTorrent = epTorrents[0] ?? null
                 let fankai: boolean | null = epTorrent ? (epTorrent.fankai ?? true) : null
@@ -160,6 +161,9 @@ router.get('/series/:id', requireAuth, async (req, res) => {
                     organized: organizedEpisodeIds.has(ep.id),
                 }
             })
+            // Dédoublonnage : plusieurs variantes (x264/x265…) du même episode_number
+            // sont fusionnées en un seul épisode avec la liste de torrents combinée
+            const eps = deduplicateEpisodes(rawEps)
             const total    = eps.filter((e: any) => e.available).length
             const orgCount = eps.filter((e: any) => e.organized).length
             const epTotal  = eps.length

server/routes/system.ts

@@ -47,11 +47,36 @@ router.get('/version', (_req, res) => {
 
 // ── Parcours fichiers ──────────────────────────────────────────
 router.get('/browse', requireAuth, (req, res) => {
-    const dirPath = (req.query.path as string) || '/'
+    const isWindows = process.platform === 'win32'
+    const dirPath   = (req.query.path as string) || '/'
+
+    // ── Racine virtuelle Windows : liste les lecteurs disponibles ──
+    if (isWindows && dirPath === '/') {
+        const drives: string[] = []
+        for (const letter of 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') {
+            const d = `${letter}:\\`
+            try { fs.readdirSync(d); drives.push(d) } catch {}
+        }
+        res.json({ path: '/', parent: null, dirs: drives, drivesRoot: true })
+        return
+    }
+
     try {
         const entries = fs.readdirSync(dirPath, { withFileTypes: true })
         const dirs    = entries.filter(e => e.isDirectory()).map(e => e.name).filter(n => !n.startsWith('.')).sort((a, b) => a.localeCompare(b))
-        res.json({ path: dirPath, parent: dirPath === '/' ? null : path.dirname(dirPath), dirs })
+
+        // Sur Windows, remonter à '/' quand on est à la racine d'un lecteur (ex: C:\)
+        let parent: string | null
+        if (dirPath === '/') {
+            parent = null
+        } else if (isWindows && /^[A-Za-z]:\\?$/.test(dirPath)) {
+            parent = '/'
+        } else {
+            const up = path.dirname(dirPath)
+            parent   = up === dirPath ? null : up   // dirname de C:\ retourne C:\ → null
+        }
+
+        res.json({ path: dirPath, parent, dirs })
     } catch (err) {
         logger.warn('api', `Lecture dossier "${dirPath}" impossible : ${err instanceof Error ? err.message : err}`)
         res.status(400).json({ error: err instanceof Error ? err.message : 'Erreur lecture dossier' })

server/torrent-clients/index.ts

@@ -36,7 +36,9 @@ export interface SavedClient {
 
 export interface TorrentFileProgress {
     index   : number
-    progress: number   // 0–100
+    name   ?: string   // chemin relatif dans le torrent (ex: "Pack S1/Episode1.mkv") — optionnel selon le client
+    progress: number   // 0–1
+    priority: number   // 0 = do not download, 1 = normal, 6 = high, 7 = max
 }
 
 export interface TorrentInfo {
@@ -59,7 +61,8 @@ export interface TorrentInfo {
 export interface DownloadOptions {
     file_index?: number | null
     file_path ?: string | null
-    magnet    ?: string | null   // conservé pour extraire le hash même quand on envoie le .torrent
+    infohash  ?: string | null   // hash direct depuis les données API (plus fiable que parser le magnet)
+    magnet    ?: string | null   // fallback pour extraire le hash si infohash absent
 }
 
 export interface TorrentClientDriver {
@@ -69,6 +72,7 @@ export interface TorrentClientDriver {
     add         : (config: Record<string, string | number>, url: string, options?: DownloadOptions) => Promise<void>
     list        : (config: Record<string, string | number>, category?: string) => Promise<TorrentInfo[]>
     remove      : (config: Record<string, string | number>, hash: string, deleteFiles?: boolean) => Promise<void>
+    getFiles   ?: (config: Record<string, string | number>, hash: string) => Promise<TorrentFileProgress[]>
 }
 
 // ─── Registry ─────────────────────────────────────────────────────────────────
@@ -340,4 +344,27 @@ export async function dispatchList(
     }
 
     return results
+}
+
+// ─── Dispatch file progress ────────────────────────────────────────────────────
+// Retourne la liste des fichiers d'un torrent avec leur progression (0–1).
+// clientUuid optionnel : si fourni, interroge uniquement ce client.
+
+export async function dispatchGetFiles(
+    hash       : string,
+    clientUuid?: string,
+): Promise<TorrentFileProgress[]> {
+    const clients = clientUuid
+        ? loadClients().filter(c => c.uuid === clientUuid)
+        : loadClients()
+
+    for (const client of clients) {
+        const driver = getDriver(client.type)
+        if (!driver?.getFiles) continue
+        try {
+            const files = await driver.getFiles(client.config, hash)
+            if (files.length > 0) return files
+        } catch {}
+    }
+    return []
 }

server/torrent-clients/qbittorrent.ts

@@ -1,5 +1,6 @@
 /**
  * qBittorrent Driver
+ * Supports qBittorrent 4.x and 5.x (including 5.2.0+ API key authentication)
  */
 
 import type { TorrentClientDriver, TorrentInfo, DownloadOptions } from './index.js'
@@ -14,6 +15,15 @@ function mapState(state: string): TorrentInfo['state'] {
     return 'unknown'
 }
 
+// Retourne les headers d'authentification : Bearer (≥5.2.0) ou cookie SID
+async function qbAuth(config: Record<string, string | number>): Promise<Record<string, string>> {
+    if (config.apiKey) {
+        return { Authorization: `Bearer ${config.apiKey}` }
+    }
+    const cookie = await qbLogin(config)
+    return { Cookie: cookie }
+}
+
 async function qbLogin(config: Record<string, string | number>): Promise<string> {
     const form = new URLSearchParams()
     form.append('username', String(config.username ?? ''))
@@ -26,18 +36,17 @@ async function qbLogin(config: Record<string, string | number>): Promise<string>
     })
 
     const text = await res.text()
-    if (text !== 'Ok.') throw new Error(`Login échoué : ${text}`)
+    if (!res.ok) throw new Error(`Login échoué : ${text.trim() || res.status}`)
 
-    const cookie = res.headers.get('set-cookie') ?? ''
-    const sid    = cookie.match(/SID=([^;]+)/)?.[1]
-    if (!sid) throw new Error('Cookie SID introuvable')
-    return sid
+    const cookie = (res.headers.get('set-cookie') ?? '').split(';')[0].trim()
+    if (!cookie) throw new Error('Cookie de session introuvable')
+    return cookie
 }
 
-async function qbTorrentExists(config: Record<string, string | number>, sid: string, hash: string): Promise<boolean> {
+async function qbTorrentExists(config: Record<string, string | number>, authHeaders: Record<string, string>, hash: string): Promise<boolean> {
     try {
         const res = await fetch(`${config.url}/api/v2/torrents/info?hashes=${hash}`, {
-            headers: { Cookie: `SID=${sid}` },
+            headers: authHeaders,
         })
         if (!res.ok) return false
         const list = await res.json()
@@ -48,79 +57,71 @@ async function qbTorrentExists(config: Record<string, string | number>, sid: str
 }
 
 /**
- * Attend que les métadonnées soient disponibles, applique les priorités, puis reprend le torrent.
- * Utilisé après un ajout avec stopCondition=MetadataReceived (qBit actif → auto-pause après metadata)
- * ou pour un torrent déjà présent (resume=false, juste mise à jour de priorité).
+ * Attend que les fichiers soient disponibles, résout l'index par chemin si possible,
+ * puis applique les priorités (désactive tout sauf la cible).
  */
 async function qbApplyFilePriority(
     config   : Record<string, string | number>,
     hash     : string,
     fileIndex: number,
-    resume   : boolean,
 ): Promise<void> {
-    // 60 tentatives × 500 ms = 30 s max
+    // Première tentative rapide (100 ms), puis 500 ms — 60 tentatives max ≈ 30 s
     for (let attempt = 0; attempt < 60; attempt++) {
-        await new Promise(r => setTimeout(r, 500))
+        await new Promise(r => setTimeout(r, attempt === 0 ? 100 : 500))
         try {
-            const sid = await qbLogin(config)
+            const authH = await qbAuth(config)
             const res = await fetch(`${config.url}/api/v2/torrents/files?hash=${hash}`, {
-                headers: { Cookie: `SID=${sid}` },
+                headers: authH,
             })
             if (!res.ok) continue
             const files: any[] = await res.json()
             if (!Array.isArray(files) || files.length === 0) continue
 
+            if (fileIndex >= files.length) {
+                throw new Error(`Index fichier ${fileIndex} hors limites (torrent a ${files.length} fichiers)`)
+            }
+
             // Si tous les fichiers sont à priorité normale (état initial du torrent),
             // on applique le filtrage complet : on désactive tout sauf la cible.
             // Si certains sont déjà à 0 (filtrage déjà effectué pour un épisode précédent),
             // on se contente d'activer la nouvelle cible sans toucher aux autres.
             const isInitialState = files.every((f: any) => (f.priority ?? 1) > 0)
 
+            const headers = { ...authH, 'Content-Type': 'application/x-www-form-urlencoded' }
+
             if (isInitialState) {
                 const unwanted = files.map((_, i) => i).filter(i => i !== fileIndex)
                 if (unwanted.length > 0) {
-                    const form = new FormData()
-                    form.append('hash', hash)
-                    form.append('id', unwanted.join('|'))
-                    form.append('priority', '0')
-                    await fetch(`${config.url}/api/v2/torrents/filePrio`, { method: 'POST', body: form, headers: { Cookie: `SID=${sid}` } })
+                    const body = new URLSearchParams({ hash, id: unwanted.join('|'), priority: '0' })
+                    const r = await fetch(`${config.url}/api/v2/torrents/filePrio`, { method: 'POST', body, headers })
+                    if (!r.ok) { logger.warn('qbittorrent', `filePrio désactivation échouée (${r.status}) — retry`); continue }
                 }
             }
 
             // Activer le fichier cible (dans tous les cas)
-            const form2 = new FormData()
-            form2.append('hash', hash)
-            form2.append('id', String(fileIndex))
-            form2.append('priority', '1')
-            await fetch(`${config.url}/api/v2/torrents/filePrio`, { method: 'POST', body: form2, headers: { Cookie: `SID=${sid}` } })
+            const r2 = await fetch(`${config.url}/api/v2/torrents/filePrio`, {
+                method: 'POST',
+                body   : new URLSearchParams({ hash, id: String(fileIndex), priority: '1' }),
+                headers,
+            })
+            if (!r2.ok) { logger.warn('qbittorrent', `filePrio activation échouée (${r2.status}) — retry`); continue }
 
-            // Reprendre (torrent auto-mis en pause par stopCondition=MetadataReceived)
-            // On appelle les deux endpoints : resume (qBit ≤ 4.x) et start (qBit ≥ 5.0)
-            if (resume) {
-                const resumeForm = new FormData()
-                resumeForm.append('hashes', hash)
-                await Promise.allSettled([
-                    fetch(`${config.url}/api/v2/torrents/resume`, { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
-                    fetch(`${config.url}/api/v2/torrents/start`,  { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
-                ])
+            // Vérification : le fichier cible est bien à priorité > 0
+            const verif = await fetch(`${config.url}/api/v2/torrents/files?hash=${hash}`, { headers: authH })
+            if (verif.ok) {
+                const verifiedFiles: any[] = await verif.json()
+                const target = verifiedFiles[fileIndex]
+                if (!target || (target.priority ?? 0) === 0) {
+                    logger.warn('qbittorrent', `Fichier ${fileIndex} toujours à priorité 0 après application — retry`)
+                    continue
+                }
             }
 
-            logger.info('qbittorrent', `Fichier ${fileIndex} sélectionné${resume ? ' + reprise' : ''} pour ${hash.slice(0, 8)}…`)
+            logger.info('qbittorrent', `Fichier ${fileIndex} sélectionné pour ${hash.slice(0, 8)}…`)
             return
-        } catch {}
-    }
-
-    // Timeout : reprendre quand même pour ne pas laisser le torrent bloqué
-    if (resume) {
-        try {
-            const sid = await qbLogin(config)
-            const resumeForm = new FormData()
-            resumeForm.append('hashes', hash)
-            await Promise.allSettled([
-                fetch(`${config.url}/api/v2/torrents/resume`, { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
-                fetch(`${config.url}/api/v2/torrents/start`,  { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
-            ])
-        } catch {}
+        } catch (err) {
+            if (err instanceof Error && err.message.includes('hors limites')) throw err
+        }
     }
 
     throw new Error(`Timeout : métadonnées non disponibles pour ${hash.slice(0, 8)}…`)
@@ -132,8 +133,9 @@ const QB: TorrentClientDriver = {
         label : 'qBittorrent',
         fields: [
             { key: 'url',      label: 'URL WebUI',       type: 'url',      placeholder: 'http://localhost:8080', required: true },
-            { key: 'username', label: 'Identifiant',     type: 'text',     placeholder: 'admin',                required: true },
-            { key: 'password', label: 'Mot de passe',    type: 'password', placeholder: '••••••••',             required: true },
+            { key: 'apiKey',   label: 'Clé API (≥5.2.0)', type: 'password', placeholder: 'qbt_xxxx…',           required: false },
+            { key: 'username', label: 'Identifiant',     type: 'text',     placeholder: 'admin',                required: false },
+            { key: 'password', label: 'Mot de passe',    type: 'password', placeholder: '••••••••',             required: false },
             { key: 'category', label: 'Catégorie',       type: 'text',     placeholder: 'fankai',               required: false, default: 'fankai' },
             { key: 'savePath',   label: 'Dossier cible',          type: 'text', placeholder: '/downloads/fankai',     required: false },
             { key: 'remotePath', label: 'Chemin distant (client)', type: 'text', placeholder: '/downloads',           required: false },
@@ -143,7 +145,9 @@ const QB: TorrentClientDriver = {
 
     async test(config) {
         try {
-            await qbLogin(config)
+            const authH = await qbAuth(config)
+            const res = await fetch(`${config.url}/api/v2/app/version`, { headers: authH })
+            if (!res.ok) throw new Error(`HTTP ${res.status}`)
             logger.info('qbittorrent', `Test de connexion réussi sur ${config.url}`)
             return { ok: true, message: 'Connexion réussie' }
         } catch (err) {
@@ -155,9 +159,9 @@ const QB: TorrentClientDriver = {
 
     async healthcheck(config) {
         try {
-            const sid = await qbLogin(config)
+            const authH = await qbAuth(config)
             const res = await fetch(`${config.url}/api/v2/app/version`, {
-                headers: { Cookie: `SID=${sid}` },
+                headers: authH,
             })
             if (!res.ok) return { online: false }
             const version = (await res.text()).trim()
@@ -170,11 +174,11 @@ const QB: TorrentClientDriver = {
     },
 
     async list(config, category) {
-        const sid    = await qbLogin(config)
+        const authH  = await qbAuth(config)
         const params = new URLSearchParams()
         if (category) params.set('category', category)
         const res = await fetch(`${config.url}/api/v2/torrents/info?${params}`, {
-            headers: { Cookie: `SID=${sid}` },
+            headers: authH,
         })
         if (!res.ok) throw new Error(`qB list échoué : ${res.status}`)
         const data: any[] = await res.json()
@@ -184,7 +188,7 @@ const QB: TorrentClientDriver = {
         await Promise.all(data.map(async (t: any) => {
             try {
                 const r = await fetch(`${config.url}/api/v2/torrents/files?hash=${t.hash}`, {
-                    headers: { Cookie: `SID=${sid}` },
+                    headers: authH,
                 })
                 if (r.ok) fileMap.set(t.hash, await r.json())
             } catch {}
@@ -207,63 +211,132 @@ const QB: TorrentClientDriver = {
                 save_path : t.save_path,
                 category  : t.category ?? '',
                 files     : fileInfo.length > 0
-                    ? fileInfo.map((f: any, i: number) => ({ index: i, progress: Math.round((f.progress ?? 0) * 100) }))
+                    ? fileInfo.map((f: any, i: number) => ({
+                        index   : i,
+                        name    : String(f.name ?? ''),
+                        progress: f.progress ?? 0,   // 0–1
+                        priority: f.priority ?? 1,
+                    }))
                     : undefined,
             } satisfies TorrentInfo
         })
     },
 
+    async getFiles(config, hash) {
+        const authH = await qbAuth(config)
+        const res = await fetch(`${config.url}/api/v2/torrents/files?hash=${hash}`, {
+            headers: authH,
+        })
+        if (!res.ok) return []
+        const data: any[] = await res.json()
+        return data.map((f: any, i: number) => ({
+            index   : i,
+            name    : String(f.name ?? ''),
+            progress: f.progress ?? 0,
+            priority: f.priority ?? 1,
+        }))
+    },
+
     async add(config, url, options?: DownloadOptions) {
-        const sid = await qbLogin(config)
+        const authH = await qbAuth(config)
 
-        // Extraire le hash depuis l'URL (si magnet) ou depuis options.magnet (si .torrent URL)
-        const hashMatch = url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
-                       ?? options?.magnet?.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
-        const hash      = hashMatch?.[1]?.toLowerCase() ?? null
+        // Priorité : infohash direct (depuis les données API) > parsing du magnet/URL
+        const hash = (options?.infohash?.toLowerCase() ?? null)
+                  || url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)?.[1]?.toLowerCase()
+                  || options?.magnet?.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)?.[1]?.toLowerCase()
+                  || null
 
-        if (options?.file_index != null && hash) {
-            const exists = await qbTorrentExists(config, sid, hash)
-
-            if (exists) {
-                // Torrent déjà présent → mettre à jour la priorité directement (async OK)
-                logger.info('qbittorrent', `Torrent ${hash.slice(0, 8)}… déjà présent, mise à jour priorité fichier ${options.file_index}`)
-                qbApplyFilePriority(config, hash, options.file_index, false).catch(err =>
-                    logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
-                )
-                return
+        if (options?.file_index != null) {
+            if (hash) {
+                const exists = await qbTorrentExists(config, authH, hash)
+                if (exists) {
+                    logger.info('qbittorrent', `Torrent ${hash.slice(0, 8)}… déjà présent, mise à jour priorité fichier ${options.file_index}`)
+                    qbApplyFilePriority(config, hash, options.file_index).catch(err =>
+                        logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
+                    )
+                    return
+                }
             }
 
-            // Nouveau torrent → ajout actif avec stopCondition=MetadataReceived
-            // qBit fetch les métadonnées normalement via DHT/peers,
-            // puis se met en pause automatiquement dès qu'elles sont disponibles.
-            // On set les priorités sur la pause, puis on reprend. Zéro data indésirable.
-            const form = new FormData()
-            form.append('urls', url)
-            if (config.category) form.append('category', String(config.category))
-            if (config.savePath)  form.append('savepath', String(config.savePath))
-            form.append('stopCondition', 'MetadataReceived')  // qBit ≥ 4.6
+            // Snapshot des hashes avant ajout (pour retrouver le nouveau si hash inconnu)
+            let knownHashes: Set<string> = new Set()
+            if (!hash) {
+                try {
+                    const lr = await fetch(`${config.url}/api/v2/torrents/info`, { headers: authH })
+                    if (lr.ok) knownHashes = new Set((await lr.json()).map((t: any) => String(t.hash).toLowerCase()))
+                } catch {}
+            }
 
-            const res  = await fetch(`${config.url}/api/v2/torrents/add`, {
-                method: 'POST', body: form, headers: { Cookie: `SID=${sid}` },
-            })
+            // Stratégie d'ajout selon le type de lien :
+            //   magnet link  → URLSearchParams (application/x-www-form-urlencoded), pas de binaire
+            //   .torrent URL → FormData multipart obligatoire pour uploader le blob binaire
+            //                  (qBit n'a pas forcément accès à internet / nyaa.si depuis son réseau Docker)
+            const isMagnet = url.startsWith('magnet:')
+            let res: Response
+
+            if (isMagnet) {
+                const params = new URLSearchParams()
+                params.set('urls', url)
+                if (config.category) params.set('category', String(config.category))
+                if (config.savePath)  params.set('savepath', String(config.savePath))
+                res = await fetch(`${config.url}/api/v2/torrents/add`, {
+                    method: 'POST', body: params,
+                    headers: { ...authH, 'Content-Type': 'application/x-www-form-urlencoded' },
+                })
+            } else {
+                // FanKarr télécharge le .torrent et l'envoie directement à qBit
+                logger.debug('qbittorrent', `Téléchargement .torrent via FanKarr : ${url.slice(0, 120)}`)
+                const torrentRes = await fetch(url, { headers: { 'User-Agent': 'FanKarr/1.0' } })
+                if (!torrentRes.ok) throw new Error(`Impossible de télécharger le .torrent (${torrentRes.status}) : ${url}`)
+                const torrentBytes = await torrentRes.arrayBuffer()
+                const form = new FormData()
+                if (config.category) form.append('category', String(config.category))
+                if (config.savePath)  form.append('savepath', String(config.savePath))
+                form.append('torrents', new Blob([torrentBytes], { type: 'application/x-bittorrent' }), 'torrent.torrent')
+                res = await fetch(`${config.url}/api/v2/torrents/add`, { method: 'POST', body: form, headers: authH })
+            }
             const text = await res.text()
             if (text !== 'Ok.') throw new Error(`Ajout échoué : ${text}`)
 
-            logger.info('qbittorrent', `Torrent ajouté (stopCondition=MetadataReceived, sélection fichier ${options.file_index} en attente)`)
-            qbApplyFilePriority(config, hash, options.file_index, true).catch(err =>
-                logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
-            )
+            if (hash) {
+                logger.info('qbittorrent', `Torrent ajouté — sélection fichier ${options.file_index} en attente des métadonnées`)
+                qbApplyFilePriority(config, hash, options.file_index).catch(err =>
+                    logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
+                )
+            } else {
+                // Hash inconnu (pas d'infohash, pas de magnet) → retrouve le nouveau torrent par diff de liste
+                logger.info('qbittorrent', `Torrent ajouté sans hash connu — recherche dans la liste (sélection fichier ${options.file_index})`)
+                const fileIndex = options.file_index
+                ;(async () => {
+                    for (let attempt = 0; attempt < 20; attempt++) {
+                        await new Promise(r => setTimeout(r, 500))
+                        try {
+                            const ah = await qbAuth(config)
+                            const lr = await fetch(`${config.url}/api/v2/torrents/info`, { headers: ah })
+                            if (!lr.ok) continue
+                            const newT = (await lr.json()).find((t: any) => !knownHashes.has(String(t.hash).toLowerCase()))
+                            if (!newT) continue
+                            const resolvedHash = String(newT.hash).toLowerCase()
+                            logger.info('qbittorrent', `Hash résolu : ${resolvedHash.slice(0, 8)}… — application priorité fichier ${fileIndex}`)
+                            await qbApplyFilePriority(config, resolvedHash, fileIndex)
+                            return
+                        } catch {}
+                    }
+                    logger.warn('qbittorrent', `Impossible de résoudre le hash pour appliquer la priorité fichier ${fileIndex}`)
+                })().catch(() => {})
+            }
             return
         }
 
-        // Pas de sélection de fichier → ajout normal
-        const form = new FormData()
-        form.append('urls', url)
-        if (config.category) form.append('category', String(config.category))
-        if (config.savePath)  form.append('savepath', String(config.savePath))
+        // Pas de sélection de fichier → ajout normal (URLSearchParams, pas de binaire)
+        const params = new URLSearchParams()
+        params.set('urls', url)
+        if (config.category) params.set('category', String(config.category))
+        if (config.savePath)  params.set('savepath', String(config.savePath))
 
         const res  = await fetch(`${config.url}/api/v2/torrents/add`, {
-            method: 'POST', body: form, headers: { Cookie: `SID=${sid}` },
+            method: 'POST', body: params,
+            headers: { ...authH, 'Content-Type': 'application/x-www-form-urlencoded' },
         })
         const text = await res.text()
         if (text !== 'Ok.') throw new Error(`Ajout échoué : ${text}`)
@@ -271,14 +344,12 @@ const QB: TorrentClientDriver = {
     },
 
     async remove(config, hash, deleteFiles = false) {
-        const sid  = await qbLogin(config)
-        const form = new FormData()
-        form.append('hashes', hash)
-        form.append('deleteFiles', deleteFiles ? 'true' : 'false')
+        const authH = await qbAuth(config)
+        const params = new URLSearchParams({ hashes: hash, deleteFiles: deleteFiles ? 'true' : 'false' })
         const res = await fetch(`${config.url}/api/v2/torrents/delete`, {
             method : 'POST',
-            body   : form,
-            headers: { Cookie: `SID=${sid}` },
+            body   : params,
+            headers: { ...authH, 'Content-Type': 'application/x-www-form-urlencoded' },
         })
         if (!res.ok) throw new Error(`Suppression échouée : ${res.status}`)
         logger.info('qbittorrent', `Torrent ${hash.slice(0, 8)}… supprimé${deleteFiles ? ' (avec fichiers)' : ''}`)

server/torrent-clients/real-debrid.ts

@@ -0,0 +1,254 @@
+/**
+ * Real-Debrid Driver
+ *
+ * Real-Debrid est un service debrid cloud : les torrents téléchargent sur leurs serveurs,
+ * puis les fichiers sont accessibles via des liens directs (HTTPS).
+ *
+ * Workflow FanKarr :
+ *   1. add()  → POST /torrents/addMagnet puis selectFiles si file_index fourni
+ *   2. list() → GET  /torrents  (filtre par status=downloaded pour state='seeding')
+ *   3. remove() → DELETE /torrents/delete/{id}
+ *
+ * Le save_path de chaque torrent est construit à partir du localPath configuré
+ * (dossier où l'utilisateur télécharge ses fichiers RD via FUSE, WebDAV ou autre).
+ */
+
+import type { TorrentClientDriver, TorrentInfo, TorrentFileProgress, DownloadOptions } from './index.js'
+import { logger } from '../logger.js'
+
+const RD_BASE = 'https://api.real-debrid.com/rest/1.0'
+
+function rdHeaders(config: Record<string, string | number>) {
+    return {
+        Authorization: `Bearer ${config.apiKey}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+    }
+}
+
+async function rdFetch(
+    config : Record<string, string | number>,
+    method : 'GET' | 'POST' | 'DELETE',
+    path   : string,
+    body  ?: URLSearchParams,
+): Promise<any> {
+    const res = await fetch(`${RD_BASE}${path}`, {
+        method,
+        headers: rdHeaders(config),
+        body   : body,
+    })
+    if (res.status === 204) return null
+    if (!res.ok) {
+        const text = await res.text().catch(() => '')
+        throw new Error(`Real-Debrid HTTP ${res.status} : ${text}`)
+    }
+    return res.json()
+}
+
+function mapStatus(status: string): TorrentInfo['state'] {
+    switch (status) {
+        case 'downloaded':                  return 'seeding'
+        case 'downloading':
+        case 'queued':
+        case 'compressing':
+        case 'uploading':
+        case 'magnet_conversion': return 'downloading'
+        case 'waiting_files_selection':     return 'paused'
+        case 'magnet_error':
+        case 'error':
+        case 'virus':
+        case 'dead':              return 'error'
+        default:                           return 'unknown'
+    }
+}
+
+const rdDriver: TorrentClientDriver = {
+    definition: {
+        id    : 'real-debrid',
+        label : 'Real-Debrid',
+        fields: [
+            { key: 'apiKey',    label: 'Clé API',              type: 'password', required: true },
+            { key: 'localPath', label: 'Dossier local (FUSE/WebDAV/…)', type: 'text', placeholder: '/mnt/real-debrid', required: false },
+        ],
+    },
+
+    async test(config) {
+        try {
+            const user = await rdFetch(config, 'GET', '/user')
+            logger.info('real-debrid', `Connexion réussie — utilisateur : ${user.username}`)
+            return { ok: true, message: `Connecté en tant que ${user.username}` }
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+            logger.warn('real-debrid', `Test de connexion échoué : ${msg}`)
+            return { ok: false, message: msg }
+        }
+    },
+
+    async healthcheck(config) {
+        try {
+            const user = await rdFetch(config, 'GET', '/user')
+            return { online: true, version: `RD — ${user.username}` }
+        } catch {
+            return { online: false }
+        }
+    },
+
+    async add(config, url, options?: DownloadOptions) {
+        const isMagnet  = url.startsWith('magnet:')
+        const hash      = (options?.infohash?.toLowerCase() ?? null)
+                       || url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)?.[1]?.toLowerCase()
+                       || null
+
+        // Vérifier si le torrent est déjà présent sur RD
+        if (hash) {
+            try {
+                const list: any[] = await rdFetch(config, 'GET', '/torrents')
+                const existing = list.find((t: any) => t.hash?.toLowerCase() === hash)
+                if (existing) {
+                    logger.info('real-debrid', `Torrent ${hash.slice(0, 8)}… déjà présent sur RD`)
+                    if (options?.file_index != null && existing.status === 'waiting_files_selection') {
+                        const files: any[] = await rdFetch(config, 'GET', `/torrents/info/${existing.id}`)
+                            .then((info: any) => info.files ?? [])
+                        const fileId = files[options.file_index]?.id
+                        if (fileId) {
+                            await rdFetch(config, 'POST', `/torrents/selectFiles/${existing.id}`,
+                                new URLSearchParams({ files: String(fileId) }))
+                        }
+                    }
+                    return
+                }
+            } catch {}
+        }
+
+        let torrentId: string
+
+        if (isMagnet) {
+            const data = await rdFetch(config, 'POST', '/torrents/addMagnet',
+                new URLSearchParams({ magnet: url }))
+            torrentId = data.id
+            logger.info('real-debrid', `Magnet ajouté → ID ${torrentId}`)
+        } else {
+            // URL de fichier .torrent : télécharger puis uploader
+            const torrentRes = await fetch(url)
+            if (!torrentRes.ok) throw new Error(`Impossible de télécharger le fichier .torrent : ${torrentRes.status}`)
+            const torrentBuf = await torrentRes.arrayBuffer()
+            const formData   = new FormData()
+            formData.append('torrent', new Blob([torrentBuf], { type: 'application/x-bittorrent' }), 'torrent.torrent')
+            const uploadRes  = await fetch(`${RD_BASE}/torrents/addTorrent`, {
+                method : 'PUT',
+                headers: { Authorization: `Bearer ${config.apiKey}` },
+                body   : formData,
+            })
+            if (!uploadRes.ok) throw new Error(`Ajout .torrent échoué : ${uploadRes.status}`)
+            const data = await uploadRes.json()
+            torrentId  = data.id
+            logger.info('real-debrid', `.torrent uploadé → ID ${torrentId}`)
+        }
+
+        // Sélection des fichiers
+        if (options?.file_index != null) {
+            // Attendre que la liste des fichiers soit disponible (état waiting_files_selection)
+            let files: any[] = []
+            for (let attempt = 0; attempt < 20; attempt++) {
+                await new Promise(r => setTimeout(r, 500))
+                try {
+                    const info = await rdFetch(config, 'GET', `/torrents/info/${torrentId}`)
+                    if (info.status === 'waiting_files_selection' && Array.isArray(info.files) && info.files.length > 0) {
+                        files = info.files
+                        break
+                    }
+                    if (info.status === 'downloading' || info.status === 'downloaded') break
+                } catch {}
+            }
+            if (files.length > 0 && options.file_index < files.length) {
+                const fileId = files[options.file_index]?.id
+                if (fileId) {
+                    await rdFetch(config, 'POST', `/torrents/selectFiles/${torrentId}`,
+                        new URLSearchParams({ files: String(fileId) }))
+                    logger.info('real-debrid', `Fichier ${options.file_index} sélectionné sur torrent RD ${torrentId}`)
+                }
+            } else if (files.length > 0) {
+                // Sélectionner tous les fichiers si index hors limites
+                await rdFetch(config, 'POST', `/torrents/selectFiles/${torrentId}`,
+                    new URLSearchParams({ files: 'all' }))
+            }
+        } else {
+            // Pas de sélection spécifique : tous les fichiers
+            // Attendre waiting_files_selection pour envoyer "all"
+            for (let attempt = 0; attempt < 10; attempt++) {
+                await new Promise(r => setTimeout(r, 500))
+                try {
+                    const info = await rdFetch(config, 'GET', `/torrents/info/${torrentId}`)
+                    if (info.status === 'waiting_files_selection') {
+                        await rdFetch(config, 'POST', `/torrents/selectFiles/${torrentId}`,
+                            new URLSearchParams({ files: 'all' }))
+                        break
+                    }
+                    if (info.status !== 'magnet_conversion') break
+                } catch {}
+            }
+        }
+    },
+
+    async list(config, _category?) {
+        const torrents: any[] = await rdFetch(config, 'GET', '/torrents')
+        const localBase = String(config.localPath ?? '').replace(/\/+$/, '')
+
+        return torrents.map((t: any): TorrentInfo => {
+            const progress = typeof t.progress === 'number' ? t.progress / 100 : 0
+            // Construire un save_path "virtuel" à partir du localPath configuré + nom du torrent
+            const save_path = localBase ? `${localBase}/${t.filename ?? t.id}` : ''
+
+            // Les liens sont les fichiers téléchargés (disponibles si status=downloaded)
+            const files: TorrentFileProgress[] | undefined =
+                Array.isArray(t.files) && t.files.length > 0
+                    ? t.files.map((f: any, i: number) => ({
+                        index   : i,
+                        name    : String(f.path ?? f.name ?? ''),
+                        progress: f.selected ? progress : 0,
+                    }))
+                    : undefined
+
+            return {
+                hash      : String(t.hash ?? t.id ?? '').toLowerCase(),
+                name      : String(t.filename ?? t.id ?? ''),
+                state     : mapStatus(t.status ?? ''),
+                progress  : Math.round(progress * 100),
+                size      : typeof t.bytes === 'number' ? t.bytes : 0,
+                downloaded: typeof t.bytes === 'number' ? Math.round(t.bytes * progress) : 0,
+                uploaded  : 0,
+                ratio     : 0,
+                speed     : typeof t.speed === 'number' ? t.speed : 0,
+                upspeed   : 0,
+                eta       : -1,
+                save_path,
+                category  : '',
+                files,
+            }
+        })
+    },
+
+    async remove(config, hash, _deleteFiles?) {
+        // Retrouver l'ID RD depuis le hash
+        const list: any[] = await rdFetch(config, 'GET', '/torrents')
+        const target = list.find((t: any) => String(t.hash ?? t.id ?? '').toLowerCase() === hash.toLowerCase())
+        if (!target) throw new Error(`Torrent ${hash.slice(0, 8)}… introuvable sur Real-Debrid`)
+        await rdFetch(config, 'DELETE', `/torrents/delete/${target.id}`)
+        logger.info('real-debrid', `Torrent ${hash.slice(0, 8)}… supprimé de Real-Debrid`)
+    },
+
+    async getFiles(config, hash) {
+        const list: any[] = await rdFetch(config, 'GET', '/torrents')
+        const target = list.find((t: any) => String(t.hash ?? t.id ?? '').toLowerCase() === hash.toLowerCase())
+        if (!target) return []
+        const info = await rdFetch(config, 'GET', `/torrents/info/${target.id}`)
+        const overallProgress = typeof info.progress === 'number' ? info.progress / 100 : 0
+        if (!Array.isArray(info.files)) return []
+        return info.files.map((f: any, i: number) => ({
+            index   : i,
+            name    : String(f.path ?? f.name ?? ''),
+            progress: f.selected ? overallProgress : 0,
+        }))
+    },
+}
+
+export default rdDriver

server/torrent-clients/rtorrent.ts

@@ -244,7 +244,7 @@ const RT: TorrentClientDriver = {
         await Promise.all(rows.map(async (r: any) => {
             const hash = String(r[0]).toUpperCase()
             try {
-                const files = await rpcCall(config, 'f.multicall', [hash, '', 'f.completed_length=', 'f.size_bytes='])
+                const files = await rpcCall(config, 'f.multicall', [hash, '', 'f.completed_length=', 'f.size_bytes=', 'f.path=', 'f.priority='])
                 if (Array.isArray(files) && files.length > 0) fileMap.set(hash.toLowerCase(), files)
             } catch {}
         }))
@@ -277,7 +277,9 @@ const RT: TorrentClientDriver = {
                     files     : fileInfo.length > 0
                         ? fileInfo.map((f: any, i: number) => ({
                             index   : i,
-                            progress: Number(f[1]) > 0 ? Math.round((Number(f[0]) / Number(f[1])) * 100) : 0,
+                            name    : String(f[2] ?? ''),
+                            progress: Number(f[1]) > 0 ? Number(f[0]) / Number(f[1]) : 0,
+                            priority: Number(f[3] ?? 1) === 0 ? 0 : 1,
                         }))
                         : undefined,
                 } satisfies TorrentInfo

server/torrent-clients/synology-ds.ts

@@ -166,7 +166,7 @@ const DS: TorrentClientDriver = {
             version: '1',
             method : 'delete',
             id     : found.id,
-            force_complete: deleteFiles ? 'false' : 'false',
+            force_complete: deleteFiles ? 'true' : 'false',
             _sid   : sid,
         })
         const res = await fetch(`${config.url}/webapi/DownloadStation/task.cgi?${params}`)

server/torrent-clients/transmission.ts

@@ -52,6 +52,44 @@ async function trRequest(
     return { ...data, sessionId }
 }
 
+async function trGetIdByHash(config: Record<string, string | number>, hash: string): Promise<number | null> {
+    const data     = await trRequest(config, 'torrent-get', { fields: ['hashString', 'id'] })
+    const torrents = data.arguments?.torrents ?? []
+    return torrents.find((t: any) => t.hashString?.toLowerCase() === hash.toLowerCase())?.id ?? null
+}
+
+/**
+ * Attend que les métadonnées soient disponibles (polling 500 ms),
+ * puis applique les priorités : fichier cible voulu, tous les autres ignorés.
+ */
+async function trApplyFilePriority(
+    config   : Record<string, string | number>,
+    hash     : string,
+    fileIndex: number,
+): Promise<void> {
+    for (let attempt = 0; attempt < 100; attempt++) {
+        await new Promise(r => setTimeout(r, 500))
+        try {
+            const id = await trGetIdByHash(config, hash)
+            if (id == null) continue
+
+            const data  = await trRequest(config, 'torrent-get', { ids: [id], fields: ['files'] })
+            const files = data.arguments?.torrents?.[0]?.files
+            if (!Array.isArray(files) || files.length === 0) continue
+
+            const unwanted = files.map((_: any, i: number) => i).filter((i: number) => i !== fileIndex)
+            await trRequest(config, 'torrent-set', {
+                ids              : [id],
+                'files-wanted'   : [fileIndex],
+                'files-unwanted' : unwanted,
+            })
+            logger.info('transmission', `Fichier ${fileIndex} sélectionné pour ${hash.slice(0, 8)}…`)
+            return
+        } catch {}
+    }
+    throw new Error(`Timeout : métadonnées non disponibles pour ${hash.slice(0, 8)}…`)
+}
+
 const TR: TorrentClientDriver = {
     definition: {
         id    : 'transmission',
@@ -96,7 +134,7 @@ const TR: TorrentClientDriver = {
             'hashString', 'name', 'status', 'percentDone', 'totalSize',
             'downloadedEver', 'uploadedEver', 'uploadRatio',
             'rateDownload', 'rateUpload', 'eta', 'downloadDir', 'labels',
-            'fileStats',   // progression par fichier (bytesCompleted + length)
+            'files',  // bytesCompleted + length par fichier (fileStats n'a pas 'length')
         ]
         const data = await trRequest(config, 'torrent-get', { fields })
         const torrents: any[] = data.arguments?.torrents ?? []
@@ -120,42 +158,37 @@ const TR: TorrentClientDriver = {
                 eta       : t.eta ?? -1,
                 save_path : t.downloadDir,
                 category  : t.labels?.[0] ?? '',
-                files     : Array.isArray(t.fileStats) && t.fileStats.length > 0
-                    ? t.fileStats.map((fs: any, i: number) => ({
+                files     : Array.isArray(t.files) && t.files.length > 0
+                    ? t.files.map((f: any, i: number) => ({
                         index   : i,
-                        progress: fs.length > 0 ? Math.round((fs.bytesCompleted / fs.length) * 100) : 0,
+                        name    : String(f.name ?? ''),
+                        progress: f.length > 0 ? f.bytesCompleted / f.length : 0,
                     }))
                     : undefined,
             } satisfies TorrentInfo))
     },
 
     async add(config, url, options?: DownloadOptions) {
-        const args: Record<string, unknown> = { filename: url }
+        const hashMatch = url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
+                       ?? options?.magnet?.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
+        const hash      = hashMatch?.[1]?.toLowerCase() ?? null
 
+        const args: Record<string, unknown> = { filename: url }
         if (config.savePath) args['download-dir'] = String(config.savePath)
         if (config.category) args['labels']        = [String(config.category)]
 
-        // Transmission applique files-wanted après récupération des métadonnées,
-        // sans démarrer les autres fichiers entre-temps — natif et fiable.
-        if (options?.file_index != null) {
-            args['files-wanted'] = [options.file_index]
-        }
-
         const res = await trRequest(config, 'torrent-add', args)
 
-        // Torrent déjà présent → Transmission renvoie torrent-duplicate
-        // On s'assure quand même que le fichier voulu est activé
-        if (options?.file_index != null && res.arguments?.['torrent-duplicate']) {
-            const dup = res.arguments['torrent-duplicate']
-            try {
-                await trRequest(config, 'torrent-set', {
-                    ids           : [dup.id],
-                    'files-wanted': [options.file_index],
-                })
-                logger.info('transmission', `Torrent ${dup.hashString?.slice(0, 8)}… déjà présent, fichier ${options.file_index} activé`)
-            } catch (err) {
-                logger.warn('transmission', `Activation fichier sur torrent existant échouée : ${err instanceof Error ? err.message : err}`)
+        if (options?.file_index != null && hash) {
+            const isDuplicate = !!res.arguments?.['torrent-duplicate']
+            if (isDuplicate) {
+                logger.info('transmission', `Torrent ${hash.slice(0, 8)}… déjà présent, mise à jour priorité fichier ${options.file_index}`)
+            } else {
+                logger.info('transmission', `Torrent ajouté (sélection fichier ${options.file_index} en attente de métadonnées)`)
             }
+            trApplyFilePriority(config, hash, options.file_index).catch(err =>
+                logger.warn('transmission', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
+            )
             return
         }
 

src/components/FolderPicker.vue

@@ -14,7 +14,7 @@
 
         <!-- Chemin éditable -->
         <div class="px-5 py-3 border-b border-border shrink-0 flex gap-2">
-          <button @click="navigateTo('/')" class="btn-secondary px-2 text-muted hover:text-primary" title="Retour à la racine">
+          <button @click="navigateTo('/')" class="btn-secondary px-2 text-muted hover:text-primary" :title="drivesRoot ? 'Lecteurs' : 'Retour à la racine'">
             <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
               <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>
               <polyline points="9 22 9 12 15 12 15 22"/>
@@ -85,12 +85,13 @@ import { ref, watch } from 'vue'
 const props = defineProps<{ initialPath?: string }>()
 const emit  = defineEmits<{ select: [path: string]; cancel: [] }>()
 
-const current   = ref(props.initialPath || '/')
-const inputPath = ref(current.value)
-const dirs      = ref<string[]>([])
-const parent    = ref<string | null>(null)
-const loading   = ref(false)
-const error     = ref('')
+const current    = ref(props.initialPath || '/')
+const inputPath  = ref(current.value)
+const dirs       = ref<string[]>([])
+const parent     = ref<string | null>(null)
+const loading    = ref(false)
+const error      = ref('')
+const drivesRoot = ref(false)   // true quand la liste affiche les lecteurs Windows
 
 // FIX : la regex /\/+$/ dans un @click inline fait planter le parser Vue
 function selectCurrent() {
@@ -98,8 +99,10 @@ function selectCurrent() {
 }
 
 function joinPath(base: string, name: string): string {
+  // Lecteur Windows complet (ex: "C:\") → chemin absolu, pas de jointure
+  if (/^[A-Za-z]:\\$/.test(name)) return name
   if (base === '/') return `/${name}`
-  const cleanBase = base.endsWith('/') ? base.slice(0, -1) : base
+  const cleanBase = base.replace(/[\\/]+$/, '')
   return `${cleanBase}/${name}`
 }
 
@@ -114,10 +117,11 @@ async function navigateTo(p: string) {
       return
     }
     const data  = await res.json()
-    current.value   = data.path
-    inputPath.value = data.path
-    parent.value    = data.parent
-    dirs.value      = data.dirs
+    current.value    = data.path
+    inputPath.value  = data.path
+    parent.value     = data.parent
+    dirs.value       = data.dirs
+    drivesRoot.value = data.drivesRoot ?? false
   } catch {
     error.value = 'Impossible de lire ce dossier'
   } finally {

src/components/ManualImportModal.vue

@@ -32,7 +32,7 @@
         </div>
 
         <!-- Liste fichiers -->
-        <template v-else-if="items.length > 0">
+        <template v-else-if="items.length > 0 && step !== 'done'">
 
           <!-- Toolbar -->
           <div class="flex items-center justify-between px-6 py-3 border-b border-border shrink-0 gap-3">
@@ -120,8 +120,10 @@
 
         <!-- Résultat -->
         <div v-else-if="step === 'done'" class="flex flex-col items-center gap-4 px-6 py-10 text-center">
-          <div class="w-12 h-12 rounded-full bg-green-500/10 flex items-center justify-center">
-            <svg width="20" height="20" viewBox="0 0 24 24" stroke="#22c55e" stroke-width="2.5" fill="none"><polyline points="20 6 9 17 4 12"/></svg>
+          <div class="w-12 h-12 rounded-full flex items-center justify-center"
+               :class="importResult.errors.length === 0 ? 'bg-green-500/10' : 'bg-yellow-500/10'">
+            <svg v-if="importResult.errors.length === 0" width="20" height="20" viewBox="0 0 24 24" stroke="#22c55e" stroke-width="2.5" fill="none"><polyline points="20 6 9 17 4 12"/></svg>
+            <svg v-else width="20" height="20" viewBox="0 0 24 24" stroke="#eab308" stroke-width="2" fill="none"><path d="M12 2l9.27 16H2.73L12 2z"/><line x1="12" y1="9" x2="12" y2="13"/><circle cx="12" cy="16.5" r=".5" fill="currentColor"/></svg>
           </div>
           <div>
             <p class="text-sm font-semibold text-primary">Import terminé</p>
@@ -138,7 +140,10 @@
               <span class="text-primary font-mono">{{ e.file }}</span> — {{ e.error }}
             </div>
           </div>
-          <button @click="$emit('close'); $emit('imported')" class="btn-primary">Fermer</button>
+          <div class="flex gap-2">
+            <button @click="backToList" class="btn-secondary">Voir les fichiers</button>
+            <button @click="$emit('close')" class="btn-primary">Fermer</button>
+          </div>
         </div>
 
       </div>
@@ -180,11 +185,12 @@ const serieTitle  = computed(() =>
 const serieFolder = computed(() => `${props.initialPath}/${serieTitle.value}`)
 
 interface FileItem {
-  file           : { name: string; path: string; size: number }
-  episode_id     : number | null
-  hash           : string | null
-  alreadyImported: boolean
-  willRename     : boolean
+  file              : { name: string; path: string; size: number }
+  episode_id        : number | null
+  originalEpisodeId : number | null   // ep_id au moment du scan (immuable) — sert au serveur pour cleanup
+  hash              : string | null
+  alreadyImported   : boolean
+  willRename        : boolean
 }
 
 const items = ref<FileItem[]>([])
@@ -261,8 +267,20 @@ function formatSize(bytes: number): string {
 }
 
 function onEpisodeChange(i: number) {
-  items.value[i].hash           = getHashForEpisode(Number(items.value[i].episode_id))
-  items.value[i].alreadyImported = false
+  const item    = items.value[i]
+  const newEpId = item.episode_id   // v-model a déjà mis à jour la valeur
+
+  item.hash            = getHashForEpisode(Number(newEpId))
+  item.alreadyImported = false
+  item.willRename      = newEpId !== null
+
+  // Retirer les autres fichiers "déjà importés" pour ce même épisode :
+  // l'utilisateur a choisi de les remplacer par ce fichier-ci.
+  if (newEpId !== null) {
+    items.value = items.value.filter(other =>
+      other === item || !(other.episode_id === newEpId && other.alreadyImported)
+    )
+  }
 }
 
 // ─── Actions ──────────────────────────────────────────────────
@@ -287,11 +305,11 @@ async function scan() {
       // Vérifier si déjà importé via dest_path
       const existingEpId = organizedByPath.get(f.path) ?? null
       if (existingEpId) {
-        return { file: f, episode_id: existingEpId, hash: getHashForEpisode(existingEpId), alreadyImported: true, willRename: false }
+        return { file: f, episode_id: existingEpId, originalEpisodeId: existingEpId, hash: getHashForEpisode(existingEpId), alreadyImported: true, willRename: false }
       }
 
       const match = autoMatch(f.name)
-      return { file: f, ...match, alreadyImported: false, willRename: match.episode_id !== null }
+      return { file: f, ...match, originalEpisodeId: null, alreadyImported: false, willRename: match.episode_id !== null }
     })
   } catch {
     scanError.value = 'Impossible de contacter le serveur'
@@ -322,15 +340,37 @@ async function doImport() {
       body       : JSON.stringify({ serie_id: props.serieId, items: payload }),
     })
     const data = await res.json()
-    if (!res.ok) { importError.value = data.error ?? 'Erreur inconnue'; return }
+    if (!res.ok) {
+      importError.value = data.error ?? 'Erreur inconnue'
+      toast(data.error ?? 'Erreur lors de l\'import', 'error')
+      return
+    }
+
     importResult.value = { done: data.done, errors: data.errors ?? [] }
+
+    if (data.done > 0) {
+      toast(`${data.done} fichier${data.done > 1 ? 's' : ''} importé${data.done > 1 ? 's' : ''} ✓`, 'success')
+    }
+    if ((data.errors ?? []).length > 0) {
+      toast(`${data.errors.length} fichier${data.errors.length > 1 ? 's' : ''} en erreur`, 'error')
+    }
+
+    // Notifier le parent immédiatement (rafraîchit organizedByEpisode + page série)
+    emit('imported')
+
     step.value = 'done'
   } catch {
     importError.value = 'Impossible de contacter le serveur'
+    toast('Impossible de contacter le serveur', 'error')
   } finally {
     importing.value = false
   }
 }
 
+function backToList() {
+  step.value = 'list'
+  scan()   // re-scan → les fichiers importés passent en "déjà importé"
+}
+
 onMounted(scan)
 </script>

src/components/downloads/TorrentCard.vue

@@ -4,7 +4,30 @@
     <!-- Nom + état -->
     <div class="flex items-start justify-between gap-4">
       <div class="flex-1 min-w-0">
-        <p class="text-sm text-primary font-medium truncate">{{ torrent.name }}</p>
+        <!-- Nom du torrent + tooltip épisodes -->
+        <div class="relative group/eps inline-block max-w-full">
+          <p class="text-sm text-primary font-medium truncate cursor-default">{{ torrent.name }}</p>
+          <!-- Tooltip épisodes -->
+          <div v-if="episodesWithProgress.length > 0"
+               class="absolute bottom-full left-0 mb-2 hidden group-hover/eps:block z-20 min-w-56 max-w-80">
+            <div class="bg-card border border-border rounded-lg p-3 text-xs shadow-xl">
+              <p class="text-muted font-medium mb-2">{{ episodesWithProgress.length }} épisode{{ episodesWithProgress.length > 1 ? 's' : '' }}</p>
+              <div class="flex flex-col gap-1 max-h-48 overflow-y-auto">
+                <div v-for="ep in episodesWithProgress" :key="ep.episode_id"
+                     class="flex items-center justify-between gap-3">
+                  <span class="text-primary shrink-0">S{{ String(ep.season_number).padStart(2,'0') }}E{{ String(ep.episode_number).padStart(2,'0') }}</span>
+                  <span v-if="ep.progress !== null"
+                        class="text-[10px] px-1.5 py-0.5 rounded shrink-0"
+                        :class="ep.progress >= 100 ? 'bg-green-500/15 text-green-500' : ep.priority === 0 ? 'bg-border/50 text-muted' : 'bg-accent/15 text-accent'">
+                    {{ ep.priority === 0 ? 'ignoré' : ep.progress >= 100 ? '✓' : `${ep.progress}%` }}
+                  </span>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        <!-- Nom de la série -->
+        <p v-if="torrent.serieName" class="text-[11px] text-muted truncate mt-0.5">{{ torrent.serieName }}</p>
         <div class="flex items-center gap-2 mt-1">
           <span class="text-[10px] px-2 py-0.5 rounded border" :class="stateBadge(torrent.state).class">{{ stateBadge(torrent.state).label }}</span>
           <span v-if="columns.client" class="text-xs text-muted">{{ torrent.client_name }}</span>
@@ -65,8 +88,12 @@
                 : 'Non importé' }}
           </span>
 
-          <button v-if="torrent.organizeState !== 'done'" @click="emit('import', torrent)" :disabled="importing" class="btn-secondary text-xs py-1">
-            {{ importing ? '...' : 'Importer' }}
+          <button v-if="torrent.organizeState !== 'done'" @click="emit('import', torrent)" :disabled="importing"
+                  class="btn-secondary text-xs py-1 flex items-center gap-1.5 min-w-[72px] justify-center">
+            <svg v-if="importing" width="10" height="10" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2.5" fill="none" class="animate-spin shrink-0">
+              <path d="M21 12a9 9 0 1 1-6.219-8.56"/>
+            </svg>
+            {{ importing ? 'Import…' : 'Importer' }}
           </button>
         </template>
 
@@ -130,6 +157,23 @@ const withFiles = ref(false)
 
 const clampedProgress = computed(() => Math.min(100, Math.max(0, props.torrent.progress ?? 0)))
 
+// Épisodes enrichis avec leur progression depuis les données de fichiers du client
+const episodesWithProgress = computed(() => {
+  const eps: any[] = props.torrent.episodes ?? []
+  if (!eps.length) return []
+  return eps.map((ep: any) => {
+    const file = (props.torrent.files ?? []).find((f: any) => {
+      const basename = String(f.name ?? '').replace(/\\/g, '/').split('/').pop() ?? ''
+      return basename.toLowerCase() === ep.filename?.toLowerCase()
+    })
+    return {
+      ...ep,
+      progress: file != null ? Math.round((file.progress ?? 0) * 100) : null,
+      priority: file?.priority ?? 1,
+    }
+  })
+})
+
 function stateBadge(state: string) {
   return ({
     downloading: { label: 'Téléchargement', class: 'border-accent/40 text-accent' },

src/components/serie/SerieHero.vue

@@ -9,9 +9,9 @@
       <div class="absolute inset-0 bg-gradient-to-b from-transparent to-main" />
     </div>
 
-    <div class="relative px-4 md:px-8 pt-6 pb-10 flex gap-6 min-h-[200px]">
+    <div class="relative px-4 md:px-8 pt-6 pb-10 flex items-start gap-6 min-h-[200px]">
       <!-- Poster -->
-      <div class="shrink-0 w-32 rounded-xl overflow-hidden border border-border shadow-xl hidden sm:block">
+      <div class="shrink-0 w-32 aspect-[2/3] rounded-xl overflow-hidden border border-border shadow-xl hidden sm:block">
         <img v-if="serie.poster_image" :src="serie.poster_image" class="w-full h-full object-cover" />
         <div v-else class="w-full aspect-[2/3] bg-card flex items-center justify-center text-muted">
           <Tv :size="28" />
@@ -39,17 +39,36 @@
           >{{ serie.status }}</span>
         </div>
 
-        <p v-if="serie.plot" class="text-sm text-secondary leading-relaxed max-w-2xl line-clamp-3">
+        <p
+            v-if="serie.plot"
+            @click="expanded = !expanded"
+            class="text-sm text-secondary leading-relaxed max-w-2xl cursor-pointer select-none transition-all"
+            :class="expanded ? '' : 'line-clamp-3'"
+        >
           {{ serie.plot }}
         </p>
+
+        <!-- Lien wiki -->
+        <a
+            v-if="serie.wiki"
+            :href="serie.wiki"
+            target="_blank"
+            rel="noopener noreferrer"
+            class="inline-flex items-center gap-1.5 text-xs text-accent hover:text-accent/80 transition-colors w-fit"
+        >
+          <ExternalLink :size="12" />
+          Wiki
+        </a>
       </div>
     </div>
   </div>
 </template>
 
 <script setup lang="ts">
+import { ref } from 'vue'
 import { RouterLink } from 'vue-router'
-import { ArrowLeft, Tv } from 'lucide-vue-next'
+import { ArrowLeft, Tv, ExternalLink } from 'lucide-vue-next'
 
 defineProps<{ serie: any }>()
+const expanded = ref(false)
 </script>

src/components/serie/SerieSeasonCard.vue

@@ -31,6 +31,15 @@
 
       <!-- Boutons saison -->
       <div class="flex items-center gap-2">
+        <!-- Corbeille saison -->
+        <button
+            v-if="season.organized_count > 0"
+            @click.stop="openUnimportSeasonModal"
+            class="w-8 h-8 rounded-lg border flex items-center justify-center transition-colors border-red-500/30 text-red-400 bg-red-500/10 hover:bg-red-500/20"
+            title="Désimporter la saison"
+        >
+          <Trash2 :size="14" />
+        </button>
         <!-- Pas de pack saison : bouton "Saison" (dropdown si plusieurs packs via intégrales) -->
         <template v-if="season.torrents.length === 0 && hasDownloadable">
           <div v-if="uniquePackOptions.length > 1" class="relative" @click.stop>
@@ -104,14 +113,6 @@
       </div>
     </div>
 
-    <!-- Progression saison -->
-    <div v-if="seasonProgress && seasonProgress.progress < 100" class="px-5 pb-3 -mt-1">
-      <div class="h-0.5 bg-border rounded-full overflow-hidden">
-        <div class="h-full bg-accent rounded-full transition-all duration-500" :style="{ width: `${seasonProgress.progress}%` }" />
-      </div>
-      <p class="text-[11px] text-muted mt-1">{{ seasonProgress.progress }}%</p>
-    </div>
-
     <!-- Épisodes -->
     <div v-if="!collapsed" class="divide-y divide-border/50">
       <div
@@ -140,7 +141,7 @@
                   title="Ce fichier ne provient pas du catalogue Fan-Kai officiel"
               >Hors Fankai</span>
             </div>
-            <div class="flex items-center gap-2 mt-0.5">
+            <div class="flex items-center gap-2 mt-0.5 flex-wrap">
               <span v-if="ep.aired" class="text-xs text-muted">{{ formatDate(ep.aired) }}</span>
               <span v-if="ep.duration" class="text-xs text-muted">{{ formatDuration(ep.duration) }}</span>
               <!-- Badge langue -->
@@ -166,11 +167,23 @@
                 <svg width="14" height="10" viewBox="0 0 14 10" class="rounded-[1px] shrink-0"><rect width="14" height="10" fill="#ED2939"/><rect width="9.33" height="10" fill="#fff"/><rect width="4.67" height="10" fill="#002395"/></svg>
                 VOSTFR
               </span>
+              <!-- Badge épisodes -->
+              <span
+                  v-if="parseEpChap(ep.plot).episodes"
+                  class="shrink-0 text-[10px] font-medium leading-none px-1.5 py-0.5 rounded border bg-violet-500/10 border-violet-500/20 text-violet-300 select-none"
+                  :title="`Plage d'épisodes couverts`"
+              >{{ parseEpChap(ep.plot).episodes }}</span>
+              <!-- Badge chapitres -->
+              <span
+                  v-if="parseEpChap(ep.plot).chapters"
+                  class="shrink-0 text-[10px] font-medium leading-none px-1.5 py-0.5 rounded border bg-teal-500/10 border-teal-500/20 text-teal-300 select-none"
+                  :title="`Plage de chapitres manga couverts`"
+              >{{ parseEpChap(ep.plot).chapters }}</span>
             </div>
           </div>
 
-          <!-- Bouton état épisode (dropdown si plusieurs options) -->
-          <div class="relative shrink-0" @click.stop>
+          <!-- Bouton téléchargement épisode (uniquement si non organisé) -->
+          <div v-if="!ep.organized" class="relative shrink-0" @click.stop>
             <button
                 class="w-8 h-8 rounded-lg border flex items-center justify-center transition-colors"
                 :class="epBtnClass(ep)"
@@ -180,7 +193,7 @@
               <component :is="epStateIcon(ep)" />
             </button>
             <!-- Dropdown quand plusieurs options de torrent -->
-            <div v-if="epOptionsOpen === ep.id && !ep.organized && ep.torrents && ep.torrents.length > 1"
+            <div v-if="epOptionsOpen === ep.id && ep.torrents && ep.torrents.length > 1"
                  class="absolute right-0 bottom-full mb-1 bg-card border border-border rounded-xl p-1 z-20 w-52 shadow-xl flex flex-col gap-0.5">
               <button
                   v-for="(t, i) in ep.torrents"
@@ -188,7 +201,7 @@
                   class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-primary hover:bg-hover transition-colors"
                   :class="(isDownloaded(`ep-${ep.id}-${i}`) || isAlreadyQueued(t)) ? 'opacity-50 cursor-not-allowed' : ''"
                   :disabled="isDownloaded(`ep-${ep.id}-${i}`) || isAlreadyQueued(t)"
-                  @click="!isDownloaded(`ep-${ep.id}-${i}`) && !isAlreadyQueued(t) && (emit('download', `ep-${ep.id}-${i}`, t.torrent_url, t.magnet, t.file_index ?? null, t.file_path ?? null), epOptionsOpen = null)"
+                  @click="!isDownloaded(`ep-${ep.id}-${i}`) && !isAlreadyQueued(t) && (emit('download', `ep-${ep.id}-${i}`, t.torrent_url, t.magnet, t.file_index ?? null, t.file_path ?? null, t.infohash ?? null), epOptionsOpen = null)"
               >
                 <component :is="(isDownloaded(`ep-${ep.id}-${i}`) || isAlreadyQueued(t)) ? checkIcon : downloadIcon" />
                 {{ groupLabels(ep.torrents)[i] }}
@@ -198,35 +211,35 @@
 
           <!-- Actions épisode importé -->
           <template v-if="ep.organized && organizedByEpisode[String(ep.id)]">
-            <span
+            <!-- Badge rename cliquable -->
+            <button
                 v-if="epNeedsRename(ep)"
-                class="shrink-0 text-[10px] px-1.5 py-0.5 rounded border bg-yellow-500/10 text-yellow-400 border-yellow-500/20 cursor-default"
+                @click.stop="emit('renameEpisode', ep, season)"
+                :disabled="epActionLoading[ep.id]"
+                class="shrink-0 text-[10px] px-1.5 py-0.5 rounded border bg-yellow-500/10 text-yellow-400 border-yellow-500/20 hover:bg-yellow-500/20 transition-colors"
                 :title="`Actuel : ${organizedByEpisode[String(ep.id)]?.dest_filename}\nAttendu : ${epExpectedName(ep)}`"
-            >Rename</span>
-
-            <div class="relative" @click.stop>
-              <button
-                  @click="epMenuOpen = epMenuOpen === ep.id ? null : ep.id"
-                  class="w-6 h-6 flex items-center justify-center rounded text-muted hover:text-primary transition-colors"
-              >
-                <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor"><circle cx="12" cy="5" r="1.5"/><circle cx="12" cy="12" r="1.5"/><circle cx="12" cy="19" r="1.5"/></svg>
-              </button>
-              <div v-if="epMenuOpen === ep.id" class="absolute right-0 top-full mt-1 bg-card border border-border rounded-xl p-1 z-20 w-44 shadow-xl flex flex-col gap-0.5">
-                <button v-if="epNeedsRename(ep)" @click="emit('renameEpisode', ep, season); epMenuOpen = null" :disabled="epActionLoading[ep.id]" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-primary hover:bg-hover transition-colors">
-                  <svg width="11" height="11" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
-                  Renommer
-                </button>
-                <button @click="emit('unimportEpisode', ep, season, false); epMenuOpen = null" :disabled="epActionLoading[ep.id]" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-muted hover:bg-hover transition-colors">
-                  <svg width="11" height="11" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/></svg>
-                  Désimporter
-                </button>
-                <button @click="emit('unimportEpisode', ep, season, true); epMenuOpen = null" :disabled="epActionLoading[ep.id]" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-red-400 hover:bg-red-500/10 transition-colors">
-                  <svg width="11" height="11" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/></svg>
-                  Supprimer le fichier
-                </button>
-              </div>
-            </div>
+            >Rename</button>
+            <!-- Corbeille épisode -->
+            <button
+                @click.stop="openUnimportModal(ep, season)"
+                :disabled="epActionLoading[ep.id]"
+                class="w-6 h-6 flex items-center justify-center rounded text-red-400 hover:bg-red-500/10 transition-colors"
+                title="Désimporter l'épisode"
+            >
+              <Trash2 :size="12" />
+            </button>
           </template>
+
+          <!-- Chevron synopsis (à droite, visible si l'épisode a un plot) -->
+          <button
+              v-if="ep.plot"
+              @click.stop="togglePlot(ep.id)"
+              class="w-6 h-6 flex items-center justify-center rounded transition-colors shrink-0"
+              :class="plotOpen === ep.id ? 'text-accent' : 'text-muted hover:text-primary'"
+              title="Voir le synopsis"
+          >
+            <ChevronUp :size="14" class="transition-transform duration-200" :class="plotOpen === ep.id ? '' : 'rotate-180'" />
+          </button>
         </div>
 
         <!-- Barre progression épisode -->
@@ -235,16 +248,61 @@
             <div class="h-full bg-accent rounded-full transition-all duration-500" :style="{ width: `${epProgress(ep)!.progress}%` }" />
           </div>
         </div>
+
+        <!-- Synopsis -->
+        <div v-if="plotOpen === ep.id && ep.plot" class="mt-2 sm:pl-[92px]">
+          <p class="text-xs text-muted leading-relaxed" style="white-space: pre-line">{{ parseEpChap(ep.plot).cleanPlot }}</p>
+        </div>
       </div>
     </div>
   </div>
+
+  <!-- Modal désimport épisode -->
+  <Teleport to="body">
+    <div v-if="unimportModal" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="unimportModal = false">
+      <div class="bg-card border border-border rounded-2xl p-6 w-full max-w-sm shadow-2xl mx-4">
+        <h3 class="text-sm font-semibold text-primary mb-1">Désimporter l'épisode</h3>
+        <p class="text-xs text-muted mb-4">L'épisode sera retiré de la bibliothèque.</p>
+        <label class="flex items-center gap-2 mb-5 cursor-pointer select-none">
+          <input type="checkbox" v-model="deleteFileOnUnimport" class="accent-red-500" />
+          <span class="text-xs text-muted">Supprimer le fichier du disque</span>
+        </label>
+        <div class="flex gap-2 justify-end">
+          <button @click="unimportModal = false" class="px-4 py-2 text-xs rounded-lg border border-border text-muted hover:bg-hover transition-colors">Annuler</button>
+          <button @click="confirmUnimport" class="px-4 py-2 text-xs rounded-lg bg-red-500/20 border border-red-500/30 text-red-400 hover:bg-red-500/30 transition-colors">
+            {{ deleteFileOnUnimport ? 'Supprimer' : 'Désimporter' }}
+          </button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
+
+  <!-- Modal désimport saison -->
+  <Teleport to="body">
+    <div v-if="unimportSeasonModal" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="unimportSeasonModal = false">
+      <div class="bg-card border border-border rounded-2xl p-6 w-full max-w-sm shadow-2xl mx-4">
+        <h3 class="text-sm font-semibold text-primary mb-1">Désimporter la saison</h3>
+        <p class="text-xs text-muted mb-4">Tous les épisodes importés de cette saison seront retirés de la bibliothèque.</p>
+        <label class="flex items-center gap-2 mb-5 cursor-pointer select-none">
+          <input type="checkbox" v-model="deleteSeasonFiles" class="accent-red-500" />
+          <span class="text-xs text-muted">Supprimer les fichiers du disque</span>
+        </label>
+        <div class="flex gap-2 justify-end">
+          <button @click="unimportSeasonModal = false" class="px-4 py-2 text-xs rounded-lg border border-border text-muted hover:bg-hover transition-colors">Annuler</button>
+          <button @click="confirmUnimportSeason" class="px-4 py-2 text-xs rounded-lg bg-red-500/20 border border-red-500/30 text-red-400 hover:bg-red-500/30 transition-colors">
+            {{ deleteSeasonFiles ? 'Supprimer' : 'Désimporter' }}
+          </button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
 </template>
 
 <script setup lang="ts">
 import { ref, computed, h, onMounted, onUnmounted } from 'vue'
-import { ChevronUp, Download, Loader, Check, X } from 'lucide-vue-next'
+import { ChevronUp, Download, Loader, Check, X, Trash2 } from 'lucide-vue-next'
 
-interface ActiveTorrent { hash: string; progress: number; state: string; files?: { index: number; progress: number }[] }
+interface ActiveTorrent { hash: string; progress: number; state: string; files?: { index: number; progress: number; priority?: number }[] }
 
 const props = defineProps<{
   season            : any
@@ -260,15 +318,21 @@ const props = defineProps<{
 
 const emit = defineEmits<{
   toggle         : [id: number]
-  download       : [key: string, url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null]
+  download       : [key: string, url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null, infohash?: string | null]
   downloadSeason : [season: any, packHash?: string]
   renameEpisode  : [ep: any, season: any]
   unimportEpisode: [ep: any, season: any, deleteFile: boolean]
+  unimportSeason : [season: any, deleteFiles: boolean]
 }>()
 
-const epMenuOpen    = ref<number | null>(null)
-const epOptionsOpen = ref<number | null>(null)
-const seasonMenuOpen = ref(false)
+const epOptionsOpen      = ref<number | null>(null)
+const plotOpen           = ref<number | null>(null)
+const seasonMenuOpen     = ref(false)
+const unimportModal      = ref(false)
+const deleteFileOnUnimport = ref(false)
+const unimportEpTarget   = ref<{ ep: any; season: any } | null>(null)
+const unimportSeasonModal = ref(false)
+const deleteSeasonFiles  = ref(false)
 const downloadIcon = h(Download, { size: 12 })
 const loaderIcon   = h(Loader, { size: 12, class: 'animate-spin' })
 const checkIcon    = h(Check, { size: 12 })
@@ -366,15 +430,16 @@ function epProgress(ep: any): ActiveTorrent | null {
       const sessionDl = isDownloaded(key0) || isDownloaded(keyI)
       if (active.files && active.files.length > 0) {
         const file = active.files.find(f => f.index === t.file_index)
-        // Avec données par fichier on se fie à la progression réelle du fichier précis,
-        // pas à l'état global du torrent — évite d'afficher les fichiers non sélectionnés (progress 0).
-        if (file != null && (sessionDl || file.progress > 0)) {
-          return { ...active, progress: file.progress }
+        // Avec données par fichier on se fie à la progression réelle du fichier précis.
+        // Si le fichier est à 100% sans session active → déjà téléchargé hors session
+        // (ex : désimporté puis re-consulté) → ne pas afficher le spinner.
+        if (file != null && file.priority !== 0 && (sessionDl || file.progress < 1)) {
+          return { ...active, progress: Math.round(file.progress * 100) }
         }
         if (!sessionDl) continue
       } else {
-        // Pas de données par fichier : session ou torrent terminé
-        if (!sessionDl && active.state !== 'seeding') continue
+        // Pas de données par fichier : ignorer si pas de session active
+        if (!sessionDl) continue
         return { ...active, progress: active.state === 'seeding' ? 100 : active.progress }
       }
     }
@@ -393,7 +458,7 @@ function handleEpBtnClick(ep: any) {
   }
   // Option unique → téléchargement direct
   if (ep.torrent && !isAlreadyQueued(ep.torrent)) {
-    emit('download', `ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet, ep.torrent.file_index ?? null, ep.torrent.file_path ?? null)
+    emit('download', `ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet, ep.torrent.file_index ?? null, ep.torrent.file_path ?? null, ep.torrent.infohash ?? null)
   }
 }
 
@@ -430,14 +495,69 @@ function epExpectedName(ep: any): string {
   if (props.nfoSupport) {
     return ep.nfo_filename ? ep.nfo_filename.replace(/\.[^.]+$/, '') + srcExt : entry.dest_filename
   } else {
-    return ep.formatted_name?.trim() ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : entry.dest_filename
+    // Préférer le formatted_name du torrent qui correspond au fichier importé.
+    // On essaie de matcher par hash (si l'entrée organized l'expose), sinon on
+    // cherche le premier torrent qui a un formatted_name.
+    const usedHash = entry.hash?.toLowerCase() ?? null
+    const matchedName = usedHash
+      ? (ep.torrents ?? []).find((t: any) => t.infohash === usedHash)?.formatted_name
+      : null
+    const name = matchedName
+      ?? (ep.torrents ?? []).find((t: any) => t.formatted_name)?.formatted_name
+      ?? ep.formatted_name
+    return name?.trim() ? name.replace(/[<>:"/\\|?*]/g, '').trim() + srcExt : entry.dest_filename
   }
 }
 function epNeedsRename(ep: any): boolean {
   const entry = props.organizedByEpisode[String(ep.id)]
   if (!entry) return false
-  const expected = epExpectedName(ep)
-  return !!expected && expected !== entry.dest_filename
+  return entry.needs_rename === true
+}
+
+// ── Extraction épisodes / chapitres depuis le synopsis ─────────
+// Cache léger pour éviter de recalculer pour chaque accès template (badges + synopsis)
+const _epChapCache = new Map<string | null | undefined, ReturnType<typeof _parseEpChap>>()
+/**
+ * Extrait les plages d'épisodes et chapitres depuis un synopsis.
+ * Ex: "...épisodes 628 à 634 soit les chapitres 700 à 706."
+ * → { episodes: "628–634", chapters: "700–706", cleanPlot: "..." }
+ * La phrase (ou ligne) contenant ces infos est retirée du synopsis affiché.
+ */
+function _parseEpChap(plot: string | null | undefined): {
+  episodes: string | null
+  chapters: string | null
+  cleanPlot: string
+} {
+  const text = plot ?? ''
+
+  const epMatch   = text.match(/[éeÉE]pisodes?\s+(\d+)(?:\s+[àa]\s+(\d+))?/i)
+  const chapMatch = text.match(/chapitres?\s+(\d+)(?:\s+[àa]\s+(\d+))?/i)
+
+  const episodes = epMatch
+    ? (epMatch[2] ? `Ép. ${epMatch[1]}–${epMatch[2]}` : `Ép. ${epMatch[1]}`)
+    : null
+  const chapters = chapMatch
+    ? (chapMatch[2] ? `Ch. ${chapMatch[1]}–${chapMatch[2]}` : `Ch. ${chapMatch[1]}`)
+    : null
+
+  // Retirer les lignes contenant les références d'épisodes ou chapitres
+  let cleanPlot = text
+  if (episodes || chapters) {
+    cleanPlot = text
+      .split(/\r?\n/)
+      .filter(line => !/[éeÉE]pisodes?\s+\d+|chapitres?\s+\d+/i.test(line))
+      .join('\n')
+      .replace(/\n{3,}/g, '\n\n')
+      .trim()
+  }
+
+  return { episodes, chapters, cleanPlot }
+}
+function parseEpChap(plot: string | null | undefined) {
+  if (_epChapCache.has(plot)) return _epChapCache.get(plot)!
+  const result = _parseEpChap(plot)
+  _epChapCache.set(plot, result)
+  return result
 }
 
 // ── Détection langue ───────────────────────────────────────────
@@ -474,23 +594,33 @@ function groupLabels(torrents: any[]): string[] {
 }
 
 // Packs parents distincts couvrant cette saison (quand pas de pack saison explicite)
-// Permet le dropdown "Saison ▾" quand une saison est couverte par plusieurs intégrales
+// Permet le dropdown "Saison ▾" quand une saison est couverte par plusieurs intégrales.
+// Un torrent individuel par épisode (hash unique) n'est PAS un pack → ignoré ici,
+// le bouton "Saison" simple suffira pour lancer tous les épisodes.
 const uniquePackOptions = computed(() => {
   if (props.season.torrents?.length) return []
-  const seen = new Set<string>()
-  const raw: { infohash: string; torrent: any }[] = []
+
+  // Compter combien d'épisodes chaque hash couvre
+  const hashCount   = new Map<string, number>()
+  const hashTorrent = new Map<string, any>()
   for (const ep of props.season.episodes) {
     if (!ep.available) continue
     for (const t of (ep.torrents ?? [])) {
       const hash = t.infohash ?? extractHash(t)
-      if (!hash || seen.has(hash)) continue
-      seen.add(hash)
-      raw.push({ infohash: hash, torrent: t })
+      if (!hash) continue
+      hashCount.set(hash, (hashCount.get(hash) ?? 0) + 1)
+      if (!hashTorrent.has(hash)) hashTorrent.set(hash, t)
     }
   }
-  if (raw.length <= 1) return []
-  const labels = groupLabels(raw.map(r => r.torrent))
-  return raw.map((r, i) => ({ infohash: r.infohash, label: labels[i] }))
+
+  // Garder uniquement les hash qui couvrent ≥ 2 épisodes (= vrais packs / intégrales)
+  const packs = [...hashCount.entries()]
+    .filter(([, count]) => count > 1)
+    .map(([hash]) => ({ infohash: hash, torrent: hashTorrent.get(hash)! }))
+
+  if (packs.length <= 1) return []
+  const labels = groupLabels(packs.map(r => r.torrent))
+  return packs.map((r, i) => ({ infohash: r.infohash, label: labels[i] }))
 })
 
 function formatDate(d: string): string {
@@ -505,9 +635,35 @@ function formatDuration(seconds: number): string {
   return `${m} min`
 }
 
+function togglePlot(epId: number) {
+  plotOpen.value = plotOpen.value === epId ? null : epId
+}
+
+function openUnimportModal(ep: any, season: any) {
+  unimportEpTarget.value   = { ep, season }
+  deleteFileOnUnimport.value = false
+  unimportModal.value      = true
+}
+
+function confirmUnimport() {
+  if (!unimportEpTarget.value) return
+  emit('unimportEpisode', unimportEpTarget.value.ep, unimportEpTarget.value.season, deleteFileOnUnimport.value)
+  unimportModal.value = false
+  unimportEpTarget.value = null
+}
+
+function openUnimportSeasonModal() {
+  deleteSeasonFiles.value   = false
+  unimportSeasonModal.value = true
+}
+
+function confirmUnimportSeason() {
+  emit('unimportSeason', props.season, deleteSeasonFiles.value)
+  unimportSeasonModal.value = false
+}
+
 function closeAllMenus() {
-  epMenuOpen.value    = null
-  epOptionsOpen.value = null
+  epOptionsOpen.value  = null
   seasonMenuOpen.value = false
 }
 

src/layouts/AppLayout.vue

@@ -16,7 +16,7 @@
     </Transition>
 
     <div class="flex-1 flex flex-col min-w-0 overflow-hidden">
-      <header class="md:hidden flex items-center gap-3 px-4 py-3 border-b border-border bg-sidebar shrink-0">
+      <header class="md:hidden flex items-center gap-3 px-4 py-3 border-b border-border bg-sidebar shrink-0 relative z-10">
         <button @click="mobileOpen = true" class="text-muted hover:text-primary transition-colors">
           <Menu :size="20" />
         </button>

src/stores/series.ts

@@ -100,12 +100,12 @@ export const useSeriesStore = defineStore('series', () => {
         }
     }
 
-    async function download(torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null): Promise<{ success: boolean; error?: string }> {
+    async function download(torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null, infohash?: string | null): Promise<{ success: boolean; error?: string }> {
         try {
             const res = await fetch('/api/download', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ torrent_url, magnet, file_index: file_index ?? null, file_path: file_path ?? null })
+                body: JSON.stringify({ torrent_url, magnet, file_index: file_index ?? null, file_path: file_path ?? null, infohash: infohash ?? null })
             })
             const data = await res.json()
             if (res.ok) return { success: true }

src/views/SerieView.vue

@@ -35,30 +35,39 @@
             Import manuel
           </button>
 
-          <!-- Désimporter -->
-          <div v-if="Object.keys(organizedByEpisode).length > 0" class="relative" @click.stop>
-            <button
-                @click="unimportMenuOpen = !unimportMenuOpen"
-                class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg bg-red-500/10 text-red-400 border border-red-500/20 hover:bg-red-500/20 transition"
-            >
-              <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
-                <path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/>
-              </svg>
-              Désimporter
-            </button>
-            <div v-if="unimportMenuOpen" class="absolute top-full left-0 mt-1 bg-card border border-border rounded-xl p-1 z-20 w-48 shadow-xl flex flex-col gap-0.5">
-              <button @click="unimportSerie(false); unimportMenuOpen = false" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-muted hover:bg-hover transition-colors">
-                Retirer de la bibliothèque
-              </button>
-              <button @click="unimportSerie(true); unimportMenuOpen = false" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-red-400 hover:bg-red-500/10 transition-colors">
-                Supprimer les fichiers
-              </button>
-            </div>
-          </div>
+          <!-- Supprimer série -->
+          <button
+              v-if="Object.keys(organizedByEpisode).length > 0"
+              @click="openUnimportSerieModal"
+              class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg bg-red-500/10 text-red-400 border border-red-500/20 hover:bg-red-500/20 transition"
+          >
+            <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+              <path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/>
+            </svg>
+            Supprimer
+          </button>
         </div>
 
         <!-- Droite : téléchargements -->
         <div class="flex flex-wrap items-center gap-2">
+          <!-- Bouton RSS sync -->
+          <button
+              @click="toggleRssSync"
+              :title="rssSync ? 'Surveillance activée — cliquer pour désactiver' : 'Surveiller les nouveaux épisodes'"
+              class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border transition"
+              :class="rssSync
+                ? 'bg-green-500/10 text-green-400 border-green-500/20 hover:bg-green-500/20'
+                : 'bg-shell text-muted border-border hover:text-primary hover:bg-hover'"
+          >
+            <!-- Icône antenne RSS -->
+            <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+              <path d="M4 11a9 9 0 0 1 9 9"/>
+              <path d="M4 4a16 16 0 0 1 16 16"/>
+              <circle cx="5" cy="19" r="1" fill="currentColor" stroke="none"/>
+            </svg>
+            {{ rssSync ? 'Surveillé' : 'Surveiller' }}
+          </button>
+
           <!-- Bouton unique "Tout télécharger" — dropdown si plusieurs intégrales -->
           <div v-if="hasSomethingToDownload" class="relative" @click.stop>
             <button
@@ -109,14 +118,37 @@
             :downloading-season="!!downloadingSeason[season.id]"
             :nfo-support="nfoSupport"
             @toggle="toggleSeason"
-            @download="(key, url, magnet, fi, fp) => download(key, url, magnet, fi, fp)"
+            @download="(key, url, magnet, fi, fp, ih) => download(key, url, magnet, fi, fp, ih)"
             @download-season="(s, h) => downloadSeason(s, h)"
             @rename-episode="(ep, s) => renameEpisode(ep, s)"
             @unimport-episode="(ep, s, del) => unimportEpisode(ep, s, del)"
+            @unimport-season="(s, del) => unimportSeason(s, del)"
         />
       </div>
     </template>
 
+    <!-- Modal désimport série -->
+    <Teleport to="body">
+      <div v-if="unimportSerieModal" class="fixed inset-0 bg-black/60 flex items-center justify-center z-50 px-4" @click.self="unimportSerieModal = false">
+        <div class="bg-card border border-border rounded-xl w-full max-w-sm p-6 flex flex-col gap-5">
+          <div>
+            <p class="text-sm font-semibold text-primary">Supprimer la série</p>
+            <p class="text-xs text-muted mt-1 truncate">{{ data?.serie?.title }}</p>
+          </div>
+          <label class="flex items-center gap-3 cursor-pointer select-none">
+            <input type="checkbox" v-model="deleteSerieFiles" class="w-4 h-4 rounded border-border accent-accent" />
+            <span class="text-xs text-muted">Supprimer également les fichiers physiques du disque</span>
+          </label>
+          <div class="flex items-center justify-end gap-2">
+            <button @click="unimportSerieModal = false" class="btn-secondary text-xs">Annuler</button>
+            <button @click="confirmUnimportSerie" class="px-4 py-2 rounded-lg border border-red-500/30 text-red-400 bg-red-500/10 hover:bg-red-500/20 transition-colors text-xs font-medium">
+              {{ deleteSerieFiles ? 'Supprimer les fichiers' : 'Supprimer' }}
+            </button>
+          </div>
+        </div>
+      </div>
+    </Teleport>
+
     <!-- Modal import manuel -->
     <ManualImportModal
         v-if="manualImportOpen && data"
@@ -126,7 +158,7 @@
         :organized="organizedByEpisode"
         :initial-path="mediaPath"
         @close="manualImportOpen = false"
-        @imported="load(); fetchOrganized(); manualImportOpen = false"
+        @imported="load(); fetchOrganized()"
     />
 
   </div>
@@ -154,10 +186,12 @@ const organizedByEpisode = ref<Record<string, any>>({})
 const mediaPath          = ref('/')
 const nfoSupport         = ref(false)
 const epActionLoading    = ref<Record<number, boolean>>({})
-const unimportMenuOpen   = ref(false)
+const unimportSerieModal = ref(false)
+const deleteSerieFiles   = ref(false)
 const downloadMenuOpen   = ref(false)
 const downloadingAll     = ref(false)
 const downloadingSeason  = ref<Record<number, boolean>>({})
+const rssSync            = ref(false)
 
 export interface ActiveTorrent { hash: string; progress: number; state: string; files?: { index: number; progress: number }[]; save_path?: string; name?: string }
 const activeTorrents = ref<ActiveTorrent[]>([])
@@ -214,7 +248,13 @@ function isDownloading(key: string) { return downloading.value.includes(key) }
 function isDownloaded(key: string)  { return downloaded.value.includes(key) }
 function addDownloading(key: string) { if (!downloading.value.includes(key)) downloading.value.push(key) }
 function removeDownloading(key: string) { downloading.value = downloading.value.filter(k => k !== key) }
-function addDownloaded(key: string) { if (!downloaded.value.includes(key)) downloaded.value.push(key) }
+function addDownloaded(key: string)    { if (!downloaded.value.includes(key)) downloaded.value.push(key) }
+function removeDownloaded(key: string) { downloaded.value = downloaded.value.filter(k => k !== key) }
+function clearEpDownloaded(ep: any) {
+  removeDownloaded(`ep-${ep.id}`)
+  const count = ep.torrents?.length ?? 0
+  for (let i = 0; i < count; i++) removeDownloaded(`ep-${ep.id}-${i}`)
+}
 function extractHash(torrent: any): string | null {
   if (torrent?.infohash) return torrent.infohash.toLowerCase()
   if (!torrent?.magnet) return null
@@ -247,6 +287,30 @@ async function fetchSettings() {
   } catch {}
 }
 
+async function fetchRssSync() {
+  try {
+    const res = await fetch(`/api/rss-sync/${route.params.id}`, { credentials: 'include' })
+    if (res.ok) { const d = await res.json(); rssSync.value = !!d.synced }
+  } catch {}
+}
+
+async function toggleRssSync() {
+  const serieId   = Number(route.params.id)
+  const serieName = data.value?.serie?.title ?? String(serieId)
+  try {
+    if (rssSync.value) {
+      const res = await fetch(`/api/rss-sync/${serieId}`, { method: 'DELETE', credentials: 'include' })
+      if (res.ok) { rssSync.value = false; toast('Surveillance désactivée', 'success') }
+    } else {
+      const res = await fetch(`/api/rss-sync/${serieId}`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+        body: JSON.stringify({ serieName }),
+      })
+      if (res.ok) { rssSync.value = true; toast('Surveillance activée — les nouveaux épisodes seront téléchargés automatiquement ✓', 'success') }
+    }
+  } catch { toast('Erreur lors de la mise à jour de la surveillance', 'error') }
+}
+
 async function fetchActiveDownloads() {
   try {
     const res = await fetch('/api/downloads', { credentials: 'include' })
@@ -264,7 +328,7 @@ async function fetchActiveDownloads() {
           const key     = `${t.hash}:${f.index}`
           const prevProg = _prevFileProgresses.get(key)
           _prevFileProgresses.set(key, f.progress)
-          if (!isFirstPoll && prevProg !== undefined && prevProg < 100 && f.progress === 100 && !_recentlyOrganized.has(key)) {
+          if (!isFirstPoll && prevProg !== undefined && prevProg < 1 && f.progress >= 1 && !_recentlyOrganized.has(key)) {
             _recentlyOrganized.add(key)
             triggerOrganize(t)
           }
@@ -314,16 +378,16 @@ async function triggerOrganize(torrent: any) {
 function openManualImport() { fetchOrganized(); manualImportOpen.value = true }
 
 // ── Download ──────────────────────────────────────────────────
-async function download(key: string, torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null) {
+async function download(key: string, torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null, infohash?: string | null) {
   if (isDownloading(key) || isDownloaded(key)) return
   addDownloading(key)
-  const result = await store.download(torrent_url, magnet, file_index, file_path)
+  const result = await store.download(torrent_url, magnet, file_index, file_path, infohash)
   removeDownloading(key)
   if (result.success) { addDownloaded(key); toast('Téléchargement lancé ✓', 'success'); fetchActiveDownloads() }
   else toast(result.error ?? 'Erreur inconnue', 'error')
 }
 
-type DlItem = { key: string; torrent_url: string | null; magnet: string | null; file_index?: number | null; file_path?: string | null }
+type DlItem = { key: string; torrent_url: string | null; magnet: string | null; file_index?: number | null; file_path?: string | null; infohash?: string | null }
 
 // Construit la liste de tout ce qui doit être téléchargé.
 // integraleIndex : si défini, utilise uniquement cette intégrale (+ épisodes non couverts).
@@ -369,7 +433,7 @@ function collectDownloadables(integraleIndex?: number): DlItem[] {
   for (const season of data.value.seasons)
     for (const ep of season.episodes) {
       if (!ep.torrent || !ep.available || ep.organized || isAlreadyQueued(ep.torrent) || isDownloaded(`ep-${ep.id}`) || covered.has(ep.id)) continue
-      result.push({ key: `ep-${ep.id}`, torrent_url: ep.torrent.torrent_url, magnet: ep.torrent.magnet, file_index: ep.torrent.file_index ?? null, file_path: ep.torrent.file_path ?? null })
+      result.push({ key: `ep-${ep.id}`, torrent_url: ep.torrent.torrent_url, magnet: ep.torrent.magnet, file_index: ep.torrent.file_index ?? null, file_path: ep.torrent.file_path ?? null, infohash: ep.torrent.infohash ?? null })
     }
 
   return result
@@ -393,7 +457,7 @@ async function downloadAll(integraleIndex?: number) {
   const torrents = collectDownloadables(integraleIndex)
   let sent = 0
   for (const t of torrents) {
-    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
+    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path, t.infohash); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
   }
   downloadingAll.value = false
   if (sent > 0) { toast(`${sent} torrent(s) envoyé(s) ✓`, 'success'); fetchActiveDownloads() }
@@ -418,12 +482,12 @@ async function downloadSeason(season: Season, packHash?: string) {
         ? (ep.torrents?.find((t: any) => (t.infohash ?? extractHash(t)) === packHash) ?? ep.torrent)
         : ep.torrent
       if (!epTorrent || !ep.available || ep.organized || isAlreadyQueued(epTorrent) || isDownloaded(`ep-${ep.id}`)) continue
-      torrents.push({ key: `ep-${ep.id}`, torrent_url: epTorrent.torrent_url, magnet: epTorrent.magnet, file_index: epTorrent.file_index ?? null, file_path: epTorrent.file_path ?? null })
+      torrents.push({ key: `ep-${ep.id}`, torrent_url: epTorrent.torrent_url, magnet: epTorrent.magnet, file_index: epTorrent.file_index ?? null, file_path: epTorrent.file_path ?? null, infohash: epTorrent.infohash ?? null })
     }
   }
   let sent = 0
   for (const t of torrents) {
-    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
+    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path, t.infohash); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
   }
   downloadingSeason.value[season.id] = false
   if (sent > 0) { toast(`${sent} torrent(s) envoyé(s) ✓`, 'success'); fetchActiveDownloads() }
@@ -436,12 +500,28 @@ function toggleSeason(id: number) {
   else collapsedSeasons.value.add(id)
 }
 
+function openUnimportSerieModal() { deleteSerieFiles.value = false; unimportSerieModal.value = true }
+async function confirmUnimportSerie() { unimportSerieModal.value = false; await unimportSerie(deleteSerieFiles.value) }
+
+async function unimportSeason(season: any, deleteFile: boolean) {
+  try {
+    const res = await fetch(`/api/organized/${route.params.id}/seasons/${season.id}?deleteFile=${deleteFile}`, { method: 'DELETE', credentials: 'include' })
+    if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur désimport saison', 'error'); return }
+    const d = await res.json()
+    toast(`${d.removed} épisode(s) désimporté(s) ✓`, 'success')
+    for (const ep of season.episodes ?? []) clearEpDownloaded(ep)
+    removeDownloaded(`season-${season.id}`)
+    await fetchOrganized(); load()
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+}
+
 async function unimportSerie(deleteFile: boolean) {
   try {
     const res = await fetch(`/api/organized/${route.params.id}?deleteFile=${deleteFile}`, { method: 'DELETE', credentials: 'include' })
     if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur désimport', 'error'); return }
     const d = await res.json()
     toast(`${d.removed} épisode(s) désimporté(s) ✓`, 'success')
+    downloaded.value = []
     await fetchOrganized(); load()
   } catch { toast('Impossible de contacter le serveur', 'error') }
 }
@@ -468,15 +548,16 @@ async function unimportEpisode(ep: any, _season: any, deleteFile: boolean) {
     const res = await fetch(`/api/organized/${route.params.id}/${ep.id}?deleteFile=${deleteFile}`, { method: 'DELETE', credentials: 'include' })
     if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur désimport', 'error'); return }
     toast(deleteFile ? 'Fichier supprimé ✓' : 'Désimporté ✓', 'success')
+    clearEpDownloaded(ep)
     await fetchOrganized(); load()
   } catch { toast('Impossible de contacter le serveur', 'error') }
   finally { epActionLoading.value[ep.id] = false }
 }
 
-const closeMenus = () => { unimportMenuOpen.value = false; downloadMenuOpen.value = false }
+const closeMenus = () => { downloadMenuOpen.value = false }
 
 onMounted(() => {
-  load(); fetchSettings(); fetchOrganized(); fetchActiveDownloads()
+  load(); fetchSettings(); fetchOrganized(); fetchActiveDownloads(); fetchRssSync()
   pollTimer = setInterval(fetchActiveDownloads, 5000)
   document.addEventListener('click', closeMenus)
 })

src/views/settings/DownloadClientView.vue

@@ -48,40 +48,64 @@
         <table class="w-full text-xs">
           <thead>
             <tr class="border-b border-border bg-shell">
-              <th class="text-left px-4 py-2.5 text-muted font-medium">Client</th>
-              <th class="text-center px-3 py-2.5 text-muted font-medium">Sélection fichier</th>
-              <th class="text-center px-3 py-2.5 text-muted font-medium">Catégories</th>
-              <th class="text-center px-3 py-2.5 text-muted font-medium">Dossier cible</th>
-              <th class="text-center px-3 py-2.5 text-muted font-medium">Remap. chemin</th>
+              <th class="text-left px-4 py-2.5 text-muted font-medium whitespace-nowrap">Client</th>
+              <th class="text-center px-3 py-2.5 text-muted font-medium whitespace-nowrap">Auth</th>
+              <th class="text-center px-3 py-2.5 text-muted font-medium whitespace-nowrap">Sél. fichier</th>
+              <th class="text-center px-3 py-2.5 text-muted font-medium whitespace-nowrap">Prog. fichier</th>
+              <th class="text-center px-3 py-2.5 text-muted font-medium whitespace-nowrap">Upload .torrent</th>
+              <th class="text-center px-3 py-2.5 text-muted font-medium whitespace-nowrap">Catégories</th>
+              <th class="text-center px-3 py-2.5 text-muted font-medium whitespace-nowrap">Suppr. fichiers</th>
             </tr>
           </thead>
           <tbody class="divide-y divide-border/60">
             <tr v-for="row in clientMatrix" :key="row.id" class="hover:bg-hover/40 transition-colors">
+              <!-- Client + version -->
               <td class="px-4 py-2.5">
                 <div class="flex items-center gap-2">
                   <span class="w-1.5 h-1.5 rounded-full shrink-0"
-                        :class="healthStatus[clients.find(c => c.type === row.id)?.uuid ?? ''] === true ? 'bg-green-500' :
-                                healthStatus[clients.find(c => c.type === row.id)?.uuid ?? ''] === false ? 'bg-red-500' : 'bg-transparent'" />
-                  <span class="text-primary font-medium">{{ row.label }}</span>
+                        :class="healthStatus[clients.find(c => c.type === row.id)?.uuid ?? ''] === true  ? 'bg-green-500' :
+                                healthStatus[clients.find(c => c.type === row.id)?.uuid ?? ''] === false ? 'bg-red-500'   : 'bg-transparent'" />
+                  <div>
+                    <p class="text-primary font-medium">{{ row.label }}</p>
+                    <p class="text-[10px] text-muted mt-0.5">{{ row.version }}</p>
+                  </div>
                 </div>
               </td>
+              <!-- Auth -->
+              <td class="text-center px-3 py-2.5 text-secondary whitespace-nowrap">{{ row.auth }}</td>
+              <!-- Sélection fichier -->
               <td class="text-center px-3 py-2.5">
-                <span :class="row.fileSelect === '✗' ? 'text-muted' : row.fileSelect.startsWith('Async') ? 'text-yellow-500' : 'text-green-400'">
-                  {{ row.fileSelect }}
+                <span :class="row.fileSelect ? 'text-yellow-400' : 'text-muted'">
+                  {{ row.fileSelect ? 'Async ✓' : '✗' }}
                 </span>
               </td>
-              <td class="text-center px-3 py-2.5" :class="row.categories ? 'text-green-400' : 'text-muted'">{{ row.categories ? '✓' : '✗' }}</td>
-              <td class="text-center px-3 py-2.5 text-green-400">✓</td>
-              <td class="text-center px-3 py-2.5 text-green-400">✓</td>
+              <!-- Progression par fichier -->
+              <td class="text-center px-3 py-2.5" :class="row.fileProgress ? 'text-green-400' : 'text-muted'">
+                {{ row.fileProgress ? '✓' : '✗' }}
+              </td>
+              <!-- Upload .torrent (FanKarr proxy) -->
+              <td class="text-center px-3 py-2.5">
+                <span :class="row.torrentUpload === 'proxy' ? 'text-green-400' : row.torrentUpload === 'url' ? 'text-secondary' : 'text-muted'">
+                  {{ row.torrentUpload === 'proxy' ? '✓ Proxy' : row.torrentUpload === 'url' ? 'URL' : '✗' }}
+                </span>
+              </td>
+              <!-- Catégories -->
+              <td class="text-center px-3 py-2.5" :class="row.categories ? 'text-green-400' : 'text-muted'">
+                {{ row.categories ? '✓' : '✗' }}
+              </td>
+              <!-- Suppression fichiers -->
+              <td class="text-center px-3 py-2.5" :class="row.deleteFiles ? 'text-green-400' : 'text-muted'">
+                {{ row.deleteFiles ? '✓' : '✗' }}
+              </td>
             </tr>
           </tbody>
         </table>
       </div>
-      <p class="text-[11px] text-muted mt-2">
-        <span class="text-green-400">✓ Natif</span> — sélection à l'ajout, aucun fichier superflu ·
-        <span class="text-green-400">Async ✓</span> — sélection dès réception des métadonnées, avant tout téléchargement ·
-        <span class="text-muted">✗</span> — non supporté, torrent complet téléchargé
-      </p>
+      <div class="flex flex-wrap gap-x-4 gap-y-1 mt-2 text-[11px] text-muted">
+        <span><span class="text-yellow-400">Async ✓</span> — sélection dès réception des métadonnées, aucun octet superflu téléchargé</span>
+        <span><span class="text-green-400">✓ Proxy</span> — FanKarr télécharge le .torrent et l'envoie au client (liens protégés supportés)</span>
+        <span><span class="text-secondary">URL</span> — le client télécharge le .torrent directement depuis l'URL</span>
+      </div>
     </div>
 
     <!-- Modal ajout -->
@@ -110,18 +134,61 @@
                 <option v-for="def in availableClients" :key="def.id" :value="def.id">{{ def.label }}</option>
               </select>
             </div>
-            <div v-if="currentDefinition" v-for="field in currentDefinition.fields" :key="field.key">
-              <label class="settings-label">
-                {{ field.label }}
-                <span v-if="field.required" class="text-red-400 ml-0.5">*</span>
-              </label>
-              <input
-                  v-model="modal.config[field.key]"
-                  :type="field.type === 'password' ? 'password' : 'text'"
-                  :placeholder="field.placeholder ?? ''"
-                  class="settings-input"
-              />
-            </div>
+
+            <!-- Champs principaux -->
+            <template v-if="currentDefinition">
+              <div v-for="field in basicFields" :key="field.key">
+                <label class="settings-label">
+                  {{ field.label }}
+                  <span v-if="field.required" class="text-red-400 ml-0.5">*</span>
+                </label>
+                <input
+                    v-model="modal.config[field.key]"
+                    :type="field.type === 'password' ? 'password' : 'text'"
+                    :placeholder="field.placeholder ?? ''"
+                    class="settings-input"
+                />
+              </div>
+
+              <!-- Paramètres avancés -->
+              <div v-if="advancedFields.length > 0">
+                <button
+                    type="button"
+                    @click="advancedOpen = !advancedOpen"
+                    class="flex items-center gap-1.5 text-xs text-muted hover:text-primary transition-colors w-full py-1"
+                >
+                  <ChevronDown
+                      :size="13"
+                      class="transition-transform duration-200 shrink-0"
+                      :class="advancedOpen ? 'rotate-180' : ''"
+                  />
+                  Paramètres avancés
+                </button>
+
+                <div v-if="advancedOpen" class="flex flex-col gap-3 mt-2 pl-3 border-l border-border">
+                  <div v-for="field in advancedFields" :key="field.key">
+                    <label class="settings-label flex items-center gap-1.5">
+                      {{ field.label }}
+                      <span
+                          class="inline-flex items-center justify-center w-4 h-4 rounded-full border border-border text-[10px] text-muted cursor-default leading-none shrink-0 relative group"
+                          tabindex="-1"
+                      >
+                        i
+                        <span class="absolute bottom-full left-1/2 -translate-x-1/2 mb-1.5 w-56 text-[11px] text-secondary bg-card border border-border rounded-lg px-2.5 py-1.5 shadow-lg pointer-events-none opacity-0 group-hover:opacity-100 transition-opacity z-10 leading-relaxed">
+                          {{ fieldTooltip(field.key) }}
+                        </span>
+                      </span>
+                    </label>
+                    <input
+                        v-model="modal.config[field.key]"
+                        :type="field.type === 'password' ? 'password' : 'text'"
+                        placeholder=""
+                        class="settings-input"
+                    />
+                  </div>
+                </div>
+              </div>
+            </template>
           </div>
 
           <p v-if="!modal.tested && modal.type" class="text-xs text-muted">
@@ -154,6 +221,7 @@
 
 <script setup lang="ts">
 import { ref, computed, watch, onMounted } from 'vue'
+import { ChevronDown } from 'lucide-vue-next'
 import { useToast } from '@/composables/useToast'
 
 const { add: toast } = useToast()
@@ -163,11 +231,30 @@ const availableClients = ref<any[]>([])
 const healthStatus     = ref<Record<string, boolean | null>>({})
 
 const clientMatrix = [
-  { id: 'qbittorrent',  label: 'qBittorrent',              fileSelect: 'Async ✓',  categories: true  },
-  { id: 'transmission', label: 'Transmission',             fileSelect: '✓ Natif',  categories: true  },
-  { id: 'rtorrent',     label: 'rTorrent / ruTorrent',     fileSelect: 'Async ✓',  categories: true  },
-  { id: 'utorrent',     label: 'uTorrent',                 fileSelect: 'Async ✓',  categories: true  },
-  { id: 'synology-ds',  label: 'Synology Download Station', fileSelect: '✗',       categories: false },
+  {
+    id: 'qbittorrent',  label: 'qBittorrent',              version: '4.1+',
+    auth: 'Login / MdP · Clé API (5.2+)', fileSelect: true,  fileProgress: true,  torrentUpload: 'proxy', categories: true,  deleteFiles: true,
+  },
+  {
+    id: 'transmission', label: 'Transmission',             version: '3.x / 4.x',
+    auth: 'Login / MdP',     fileSelect: true,  fileProgress: true,  torrentUpload: 'url',   categories: true,  deleteFiles: true,
+  },
+  {
+    id: 'rtorrent',     label: 'rTorrent / ruTorrent',     version: '0.9+',
+    auth: 'URL xmlrpc',      fileSelect: true,  fileProgress: true,  torrentUpload: 'url',   categories: true,  deleteFiles: true,
+  },
+  {
+    id: 'utorrent',     label: 'uTorrent',                 version: '3.x',
+    auth: 'Login / MdP',     fileSelect: true,  fileProgress: false, torrentUpload: 'url',   categories: true,  deleteFiles: true,
+  },
+  {
+    id: 'synology-ds',  label: 'Synology Download Station', version: '6.x+',
+    auth: 'Login / MdP',     fileSelect: false, fileProgress: false, torrentUpload: 'url',   categories: false, deleteFiles: true,
+  },
+  {
+    id: 'real-debrid',  label: 'Real-Debrid',              version: 'API v1',
+    auth: 'Clé API',          fileSelect: true,  fileProgress: true,  torrentUpload: 'proxy', categories: false, deleteFiles: true,
+  },
 ]
 
 const modal = ref({
@@ -181,10 +268,32 @@ const modal = ref({
   tested : false,
 })
 
+const ADVANCED_KEYS = ['savePath', 'remotePath', 'localPath']
+
+const FIELD_TOOLTIPS: Record<string, string> = {
+  savePath   : 'Optionnel. Permet de placer les téléchargements dans un sous-dossier spécifique à l\'intérieur du dossier déjà configuré dans la gestion des médias.',
+  remotePath : 'Si le client tourne sur une autre machine, indiquez ici le chemin qu\'il utilise (ex: /downloads). À associer avec le chemin local ci-dessous.',
+  localPath  : 'Chemin équivalent au chemin distant, mais vu par FanKarr sur sa machine (ex: /mnt/nas/downloads). Les deux champs fonctionnent en binôme pour faire la correspondance.',
+}
+
+function fieldTooltip(key: string): string {
+  return FIELD_TOOLTIPS[key] ?? ''
+}
+
+const advancedOpen = ref(false)
+
 const currentDefinition = computed(() =>
     availableClients.value.find(d => d.id === modal.value.type) ?? null
 )
 
+const basicFields = computed(() =>
+    currentDefinition.value?.fields.filter((f: any) => !ADVANCED_KEYS.includes(f.key)) ?? []
+)
+
+const advancedFields = computed(() =>
+    currentDefinition.value?.fields.filter((f: any) => ADVANCED_KEYS.includes(f.key)) ?? []
+)
+
 function clientLabel(type: string) {
   return availableClients.value.find(d => d.id === type)?.label ?? type
 }
@@ -229,6 +338,7 @@ async function deleteClient(uuid: string) {
 
 function openAddModal() {
   modal.value = { open: true, uuid: null, name: '', type: '', config: {}, testing: false, saving: false, tested: false }
+  advancedOpen.value = false
 }
 
 function editClient(client: any) {
@@ -249,6 +359,7 @@ function closeModal() { modal.value.open = false }
 function onTypeChange() {
   modal.value.config = {}
   modal.value.tested = false
+  advancedOpen.value = false
   const def = currentDefinition.value
   if (def) {
     for (const field of def.fields) {

src/views/settings/MediaManagementView.vue

@@ -87,7 +87,8 @@
             description="Importer automatiquement dès qu'un téléchargement est terminé. Vérifie toutes les 5 minutes."
         />
         <SettingsToggle
-            v-model="form.nfoSupport"
+            :model-value="form.nfoSupport"
+            @update:model-value="onNfoToggle"
             label="NFO / Métadonnées"
             description="Télécharge les NFO et images depuis GitLab lors de l'import (Kodi, Infuse, etc.)."
         />
@@ -146,6 +147,34 @@
       :media-path="form.mediaPath"
       @close="plexOpen = false"
   />
+
+  <!-- Confirmation NFO -->
+  <Teleport to="body">
+    <div
+        v-if="nfoConfirmOpen"
+        class="fixed inset-0 bg-black/60 flex items-center justify-center z-50 px-4"
+        @click.self="nfoConfirmOpen = false"
+    >
+      <div class="bg-card border border-border rounded-xl w-full max-w-sm p-6 flex flex-col gap-4">
+        <div class="flex flex-col gap-1.5">
+          <h3 class="text-sm font-semibold text-primary">Activer les NFO / Métadonnées ?</h3>
+          <p class="text-xs text-muted leading-relaxed">
+            Si vous utilisez l'agent Fankai sur <span class="text-primary">Jellyfin, Plex ou Emby</span>,
+            les métadonnées sont déjà gérées directement par l'agent — activer les NFO est inutile
+            et peut créer des conflits.
+          </p>
+          <p class="text-xs text-muted leading-relaxed">
+            Activez cette option uniquement si vous utilisez <span class="text-primary">Kodi, Infuse</span>
+            ou un lecteur qui lit les fichiers NFO locaux.
+          </p>
+        </div>
+        <div class="flex gap-2 pt-1">
+          <button @click="confirmNfo" class="btn-primary text-xs">Oui, activer quand même</button>
+          <button @click="nfoConfirmOpen = false" class="btn-secondary text-xs">Annuler</button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
 </template>
 
 <script setup lang="ts">
@@ -157,12 +186,26 @@ import PlexWizard from '@/components/settings/PlexWizard.vue'
 
 const { add: toast } = useToast()
 
-const saving     = ref(false)
-const scanning   = ref(false)
-const isDocker   = ref(false)
-const loaded     = ref(false)
-const plexOpen   = ref(false)
-const scanResult = ref<{ found: number; added: number } | null>(null)
+const saving         = ref(false)
+const scanning       = ref(false)
+const isDocker       = ref(false)
+const loaded         = ref(false)
+const plexOpen       = ref(false)
+const nfoConfirmOpen = ref(false)
+const scanResult     = ref<{ found: number; added: number } | null>(null)
+
+function onNfoToggle(val: boolean) {
+  if (val && !form.value.nfoSupport) {
+    nfoConfirmOpen.value = true
+  } else {
+    form.value.nfoSupport = val
+  }
+}
+
+function confirmNfo() {
+  form.value.nfoSupport = true
+  nfoConfirmOpen.value  = false
+}
 
 const form = ref({
   mediaPath           : '',

version.txt

@@ -1 +1 @@
-3.11.2
+3.16.0