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

chore(main): release 3.9.1
2026-04-16 09:38:44 +02:00 · 2026-04-16 09:22:08 +02:00 · 2026-04-16 09:21:35 +02:00 · 2026-04-16 09:21:26 +02:00 · 2026-04-15 07:21:09 +00:00 · 2026-04-15 09:20:42 +02:00
45 changed files with 3970 additions and 1924 deletions
@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find src:*)",
+      "Bash(find server:*)"
+    ]
+  }
+}
@@ -48,12 +48,11 @@ jobs:
            bun-target: bun-windows-x64
            binary: binaries/fankarr.exe
            archive: fankarr-windows-x64.zip
-          # Baseline pour les CPUs Windows anciens (sans AVX2, avant ~2013)
-          - target: windows-x64-baseline
-            os: windows-latest
+          - target: windows-x64-legacy
+            os: ubuntu-latest
            bun-target: bun-windows-x64-baseline
            binary: binaries/fankarr.exe
-            archive: fankarr-windows-x64-baseline.zip
+            archive: fankarr-windows-x64-legacy.zip
          - target: linux-x64
            os: ubuntu-latest
            bun-target: bun-linux-x64
@@ -63,7 +62,7 @@ jobs:
            os: ubuntu-latest
            bun-target: bun-linux-arm64
            binary: binaries/fankarr
-            archive: fankarr-linux-arm64-termux.zip
+            archive: fankarr-linux-arm64.zip
          - target: macos
            os: macos-latest
            bun-target: bun-darwin-arm64
@@ -96,13 +95,13 @@ jobs:
          path: public/

      - name: Build binary (Unix)
-        if: matrix.target != 'windows-x64' && matrix.target != 'windows-x64-baseline'
+        if: matrix.target != 'windows-x64'
        run: |
          mkdir -p binaries
          bun build server/index.ts --compile --target ${{ matrix.bun-target }} --outfile ${{ matrix.binary }}

      - name: Build binary (Windows)
-        if: matrix.target == 'windows-x64' || matrix.target == 'windows-x64-baseline'
+        if: matrix.target == 'windows-x64'
        run: |
          New-Item -ItemType Directory -Force -Path binaries
          bun build server/index.ts --compile --target ${{ matrix.bun-target }} --outfile ${{ matrix.binary }}
@@ -112,15 +111,14 @@ jobs:
        run: bun build server/organize-worker.ts --target node --outfile organize-worker.js

      - name: Package archive (Windows)
-        if: matrix.target == 'windows-x64' || matrix.target == 'windows-x64-baseline'
-        run: Compress-Archive -Path ${{ matrix.binary }}, organize-worker.js, public -DestinationPath ${{ matrix.archive }}
+        if: matrix.target == 'windows-x64' || matrix.target == 'windows-x64-legacy'
+        run: Compress-Archive -Path ${{ matrix.binary }}, organize-worker.js, public, version.txt -DestinationPath ${{ matrix.archive }}
        shell: pwsh

      - name: Package archive (Unix)
-        if: matrix.target != 'windows-x64' && matrix.target != 'windows-x64-baseline'
+        if: matrix.target != 'windows-x64' && matrix.target != 'windows-x64-legacy'
        run: |
-          chmod +x ${{ matrix.binary }}
-          zip -r ${{ matrix.archive }} ${{ matrix.binary }} organize-worker.js public/
+          zip -r ${{ matrix.archive }} ${{ matrix.binary }} organize-worker.js public/ version.txt

      - name: Upload archive to Release
        uses: softprops/action-gh-release@v2
@@ -9,8 +9,28 @@ name: release-please
 jobs:
  release-please:
    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
    steps:
      - uses: googleapis/release-please-action@v4
+        id: release
        with:
          token: ${{ secrets.FINED_TOKEN }}
-          release-type: simple
+          release-type: simple
+
+      # Quand une release est créée, on écrit version.txt et on le committe
+      - uses: actions/checkout@v4
+        if: ${{ steps.release.outputs.release_created }}
+        with:
+          token: ${{ secrets.FINED_TOKEN }}
+
+      - name: Write version.txt
+        if: ${{ steps.release.outputs.release_created }}
+        run: |
+          echo "${{ steps.release.outputs.tag_name }}" > version.txt
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add version.txt
+          git commit -m "chore: update version.txt to ${{ steps.release.outputs.tag_name }}"
+          git push
@@ -1,5 +1,103 @@
 # Changelog

+## [3.9.1](https://github.com/Masutayunikon/FanKarr/compare/v3.9.0...v3.9.1) (2026-04-16)
+
+
+### Bug Fixes
+
+* le badge de rename utilise la meme logique que coté serveur et n'apparait plus sur les vue series si il ne devrais pas ([9764d2d](https://github.com/Masutayunikon/FanKarr/commit/9764d2db8ed2531af3feb6ceba947eaf116c1e76))
+
+## [3.9.0](https://github.com/Masutayunikon/FanKarr/compare/v3.8.1...v3.9.0) (2026-04-15)
+
+
+### Features
+
+* ajout d'un bouton supprimé l'importation dans le menu d'importation d'une serie ([286106e](https://github.com/Masutayunikon/FanKarr/commit/286106ef1eed2803cf14549af7a172b13b9c2b88))
+* ajout de badge quand le fichier est introuvable ([286106e](https://github.com/Masutayunikon/FanKarr/commit/286106ef1eed2803cf14549af7a172b13b9c2b88))
+* ajout de la possibilité de renommer des imports dans le bon format ([67444d4](https://github.com/Masutayunikon/FanKarr/commit/67444d418d65cf0d0323c8955adb8d9e136a8797))
+* ajout du bouton suppresion de torrent en cours ([286106e](https://github.com/Masutayunikon/FanKarr/commit/286106ef1eed2803cf14549af7a172b13b9c2b88))
+* ajout setup plex ([2123e73](https://github.com/Masutayunikon/FanKarr/commit/2123e73b7fec9c637b349e63da9c9a88dd9fccd6))
+* bouton tous télécharger sur les saisons et series ([286106e](https://github.com/Masutayunikon/FanKarr/commit/286106ef1eed2803cf14549af7a172b13b9c2b88))
+* suppression des series supprimé ([286106e](https://github.com/Masutayunikon/FanKarr/commit/286106ef1eed2803cf14549af7a172b13b9c2b88))
+
+
+### Bug Fixes
+
+* ajout d'un loader sur certaines pages pour pas avoir des trucs par default qui s'affiche ([d241be3](https://github.com/Masutayunikon/FanKarr/commit/d241be30d126f5b975aca72d2c21ab74e7215fa4))
+* ajout de la page management dans le layout ([5dc0531](https://github.com/Masutayunikon/FanKarr/commit/5dc0531bfd50ac9ca5a59126670757179ed8a226))
+* cast string ([16d1bfe](https://github.com/Masutayunikon/FanKarr/commit/16d1bfe7e7766987876db80f84e6c0dc31217403))
+* Deux corrections : ([5398a4f](https://github.com/Masutayunikon/FanKarr/commit/5398a4fe12b1ac235884bb9c6218174b0c438ac1))
+* le bouton tout telecharger apparait sur les packs de saisons et les integrals + autres et pas que sur les series avec des episodes telechargable ([e105587](https://github.com/Masutayunikon/FanKarr/commit/e105587147e03e39e2c3b985a114434c2512417a))
+* move plex settings en haut des boutons ([96af23d](https://github.com/Masutayunikon/FanKarr/commit/96af23d258e14dacf371b043b92b554c2b22f80c))
+* plex catcher ([ba0dc8d](https://github.com/Masutayunikon/FanKarr/commit/ba0dc8d21bca098b0203f9553d81a47048fad452))
+* suppression de dest_filename du fichier d'organisation qui est faux et ne sert à rien ([3c69eba](https://github.com/Masutayunikon/FanKarr/commit/3c69eba440f4f83180bd5d3f25a2ad0499b91940))
+* utorrent prend desormais le dossier cible correctement ([cc68fef](https://github.com/Masutayunikon/FanKarr/commit/cc68fef88d6e13339867f6b6b47667a141a86091))
+* wrong file copy ([fa7da76](https://github.com/Masutayunikon/FanKarr/commit/fa7da7681193e89214a521c5bd16106f0ca03f46))
+
+## [3.8.1](https://github.com/Masutayunikon/FanKarr/compare/v3.8.0...v3.8.1) (2026-04-11)
+
+
+### Bug Fixes
+
+* la version dev se met uniquement en dev ([79e5478](https://github.com/Masutayunikon/FanKarr/commit/79e547859720f36330d95036de813240da034bbd))
+
+## [3.8.0](https://github.com/Masutayunikon/FanKarr/compare/v3.7.1...v3.8.0) (2026-04-11)
+
+
+### Features
+
+* force release for test ([d921fc1](https://github.com/Masutayunikon/FanKarr/commit/d921fc16d6b19d8aeb354fc3a5fc533afc81cb5b))
+
+## [3.7.1](https://github.com/Masutayunikon/FanKarr/compare/v3.7.0...v3.7.1) (2026-04-11)
+
+
+### Bug Fixes
+
+* ajout de la copy dans le worker ([a7d4488](https://github.com/Masutayunikon/FanKarr/commit/a7d44886ddb4c5ca4e12bfa5dbb15e115257d9c8))
+
+## [3.7.0](https://github.com/Masutayunikon/FanKarr/compare/v3.6.1...v3.7.0) (2026-04-11)
+
+
+### Features
+
+* activation de l'import manuel ([9712644](https://github.com/Masutayunikon/FanKarr/commit/971264446c45401f5aaa3b3acae0fab6cae15264))
+* ajout d'une "notification" dans la navbar si une nouvelle versions est disponible ([9712644](https://github.com/Masutayunikon/FanKarr/commit/971264446c45401f5aaa3b3acae0fab6cae15264))
+* ajout d'une hashmap pour matcher les titres sur synologie et ajouter les hash de torrent manuellement ([3b8c448](https://github.com/Masutayunikon/FanKarr/commit/3b8c448ea0b0917e40d493ad4bf0e81cd35dff5a))
+* ajout de l'option supprimé le torrent si l'option déplacer est activé ([3e83dc0](https://github.com/Masutayunikon/FanKarr/commit/3e83dc0d79107e46cac14f73dd3ef04794ad824d))
+* ajout de la suppression des torrents depuis l'interface ([3e83dc0](https://github.com/Masutayunikon/FanKarr/commit/3e83dc0d79107e46cac14f73dd3ef04794ad824d))
+* ajout du bouton copie ([3e83dc0](https://github.com/Masutayunikon/FanKarr/commit/3e83dc0d79107e46cac14f73dd3ef04794ad824d))
+* ajout du ratio, upload speed, etc dans les activités ([ee34a53](https://github.com/Masutayunikon/FanKarr/commit/ee34a5350086dcd7e783f9c14ca60e09c60eb032))
+* edit d'episodes importer dans le menu d'importation ([3017cac](https://github.com/Masutayunikon/FanKarr/commit/3017cac67a5d3f5ccb9f153f233a446b0afaaec8))
+
+
+### Bug Fixes
+
+* ajout de l'option de suppresion dans l'interface settings.ts ([a70e65f](https://github.com/Masutayunikon/FanKarr/commit/a70e65f0e4323369d1fd7401665fb3033352a286))
+* ajout de logs lors de non match ([0c6c802](https://github.com/Masutayunikon/FanKarr/commit/0c6c802cbfdf297df40aa5944eacf16f58489bd1))
+* ajout des series non disponible pour pouvoir les add manuellement ([9e0664a](https://github.com/Masutayunikon/FanKarr/commit/9e0664aa49d6f99be8ca7e7bbd7c8e7cec0f9e7c))
+* changer le noms de build arm64 et windows legacy pour une meilleur comprehension ([47d81e6](https://github.com/Masutayunikon/FanKarr/commit/47d81e692d866beedf80a6c46317dfe79213547d))
+* formatage ([82a61eb](https://github.com/Masutayunikon/FanKarr/commit/82a61ebe74b8196891a50c1380ffaa89178c1fd1))
+* formatage ([f6b384e](https://github.com/Masutayunikon/FanKarr/commit/f6b384ec49bf018e23eb0a0b15917aee4578d66e))
+* l'import a le meme comportement que radarr/sonarr en ouvrant l'import dans le dossier de la serie attendu directement ([1485efe](https://github.com/Masutayunikon/FanKarr/commit/1485efe053d3281521978bb2d29a6c9ce219c2fd))
+* les series sans torrent et non ajoutées manuellement sont bien grisé ([2bdafd8](https://github.com/Masutayunikon/FanKarr/commit/2bdafd8e377d1a957903f228c61c1f3ab3a45955))
+* les series sans torrent et non ajoutées manuellement sont bien grisé ([d854247](https://github.com/Masutayunikon/FanKarr/commit/d854247b7fe6d5e01b0803ff7d415aba431c4f0d))
+* les series sans torrents sont bien organiser si importé manuellement ([6ed77c1](https://github.com/Masutayunikon/FanKarr/commit/6ed77c1196c45e57dbd989cc049f42403f522821))
+* les series sans torrents sont bien organiser si importé manuellement ([bc10889](https://github.com/Masutayunikon/FanKarr/commit/bc1088903053b7b98cabbe24c9cdcb8ac4c489b2))
+* log ([ef4b364](https://github.com/Masutayunikon/FanKarr/commit/ef4b3643c2852500f048ee330b92d60fed4b5ba5))
+* organisation utilise l'extension du fichier au lieu de tester si ça existe ([2b7bf48](https://github.com/Masutayunikon/FanKarr/commit/2b7bf4808e4a11d450403f477ea3031add8a2ebc))
+* settings ([60a548f](https://github.com/Masutayunikon/FanKarr/commit/60a548f6bd658fe9986d94c094cad0fbed103882))
+* type ([f4305b5](https://github.com/Masutayunikon/FanKarr/commit/f4305b537f2ab0a1370445eae9e9150a34e44e86))
+* type ([bdfe74b](https://github.com/Masutayunikon/FanKarr/commit/bdfe74bb8132b6bff0b14ccb135bb3b90f3441b6))
+* vue des series importer ([6786cb5](https://github.com/Masutayunikon/FanKarr/commit/6786cb50f4c50b95f1dcd48d15742b1ae6602ed5))
+* vue des series importer ([50efd74](https://github.com/Masutayunikon/FanKarr/commit/50efd74a5b918c4ff61e7d4feac2643693db1861))
+
+## [3.6.1](https://github.com/Masutayunikon/FanKarr/compare/v3.6.0...v3.6.1) (2026-04-10)
+
+
+### Bug Fixes
+
+* windows baseline ([0469031](https://github.com/Masutayunikon/FanKarr/commit/0469031ff05c8794b20f73bc7c3ac417ab473e5d))
+
 ## [3.6.0](https://github.com/Masutayunikon/FanKarr/compare/v3.5.0...v3.6.0) (2026-04-10)


@@ -0,0 +1,22 @@
+/**
+ * gitlab-map.ts
+ * =============
+ * Map des titres API → titres GitLab pour le téléchargement des NFO.
+ * Partagé entre organize-worker.ts et index.ts.
+ */
+
+export const SERIE_TITLE_GITLAB_MAP: Record<string, string> = {
+    'Enfer Et Paradis Henshū'          : 'Enfer et Paradis Henshū',
+    'Hajime No Ippo Henshū'            : 'Hajime no Ippo Henshū',
+    'Hikaru No Go Henshū'              : 'Hikaru no Go Henshū',
+    'Hokuto No Ken Kaï'                : 'Hokuto no Ken Kaï',
+    'Kaguya-sama : Love is War Henshū' : 'Kaguya-sama - Love is War Henshū',
+    'Kenshin le Vagabond Henshū'       : 'Kenshin le vagabond Henshū',
+    'Kuroko No Basket Henshū'          : 'Kuroko no Basket Henshū',
+    'Shingeki No Kyojin Henshū'        : 'Shingeki no Kyojin Henshū',
+    'Tower Of God Henshū'              : 'Tower of God Henshū',
+}
+
+export function getGitlabTitle(title: string): string {
+    return SERIE_TITLE_GITLAB_MAP[title] ?? title
+}
@@ -3,22 +3,30 @@ import cookieParser from 'cookie-parser'
 import http from 'http'
 import fs from 'fs'
 import path from 'path'
-import { authStatus, authSetup, authLogin, authLogout, requireAuth } from './auth.js'
-import { readSettings, writeSettings } from './settings.js'
-import {
-    registerDriver, getDriver, getAvailableClients,
-    listClients, addClient, removeClient, getClient,
-    sanitizeClient, dispatchDownload, dispatchList, updateClient
-} from './torrent-clients/index.js'
+import { authStatus, authSetup, authLogin, authLogout } from './auth.js'
+import { readSettings } from './settings.js'
+import { registerDriver, dispatchList, dispatchRemove } from './torrent-clients/index.js'
 import qbittorrentDriver  from './torrent-clients/qbittorrent.js'
 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 { organizeTorrent, autoOrganizeAll, scanMediaPath, workerRunning } from './organize.js'
-import { logger, readLogs, clearLogs, logsFileSize } from './logger.js'
+import { autoOrganizeAll, scanMediaPath } from './organize.js'
+import { logger } from './logger.js'
 import { DATA_DIR, BASE_DIR } from './config.js'
-import { systemInfo } from './system.js'
+import { readAvailable, readInfohashMap, loadEnrichedSeriesData } from './lib/github-cache.js'
+import { pushNotif } from './lib/notifs.js'
+import { checkNfoUpdates } from './lib/nfo.js'
+
+import settingsRouter      from './routes/settings.js'
+import torrentClientsRouter from './routes/torrent-clients.js'
+import seriesRouter        from './routes/series.js'
+import downloadsRouter     from './routes/downloads.js'
+import organizeRouter      from './routes/organize.js'
+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'

 registerDriver(qbittorrentDriver)
 registerDriver(transmissionDriver)
@@ -28,9 +36,6 @@ registerDriver(rtorrentDriver)

 const app  = express()
 const PORT = Number(process.env.PORT) || 9898
-const FANKAI_API  = 'https://metadata.fankai.fr'
-const GITHUB_BASE = process.env.GITHUB_BASE
-    ?? 'https://raw.githubusercontent.com/masutayunikon/fankarr-scraper/main'

 app.use(express.json())
 app.use(cookieParser())
@@ -46,746 +51,16 @@ app.post('/api/auth/setup',  authSetup)
 app.post('/api/auth/login',  authLogin)
 app.post('/api/auth/logout', authLogout)

-app.get('/api/system/info', systemInfo)
-
-// ── Settings ───────────────────────────────────────────────────
-app.get('/api/settings', requireAuth, (_req, res) => {
-    res.json(readSettings())
-})
-app.post('/api/settings', requireAuth, (req, res) => {
-    const { mediaPath, completePath, organizeMode, category, nfoSupport, autoImport, devMode } = req.body
-    const patch: Record<string, any> = {}
-    if (mediaPath     !== undefined) patch.mediaPath     = mediaPath
-    if (completePath  !== undefined) patch.completePath  = completePath
-    if (organizeMode  !== undefined) patch.organizeMode  = organizeMode
-    if (category      !== undefined) patch.category      = category
-    if (nfoSupport    !== undefined) patch.nfoSupport    = nfoSupport
-    if (autoImport    !== undefined) patch.autoImport    = autoImport
-    if (devMode       !== undefined) patch.devMode       = devMode
-    const updated = writeSettings(patch)
-    logger.info('api', 'Paramètres mis à jour')
-    res.json(updated)
-})
-
-// ── Torrent clients ────────────────────────────────────────────
-app.get('/api/torrent-clients/available', requireAuth, (_req, res) => {
-    res.json(getAvailableClients())
-})
-app.get('/api/torrent-clients', requireAuth, (_req, res) => {
-    res.json(listClients().map((c: any) => sanitizeClient(c)))
-})
-app.post('/api/torrent-clients', requireAuth, (req, res) => {
-    const { name, type, config } = req.body
-    if (!name || !type || !config) { res.status(400).json({ error: 'name, type et config requis' }); return }
-    if (!getDriver(type))          { res.status(400).json({ error: `Type inconnu : ${type}` }); return }
-    res.json(sanitizeClient(addClient(name, type, config)))
-})
-app.delete('/api/torrent-clients/:uuid', requireAuth, (req, res) => {
-    const ok = removeClient(String(req.params.uuid))
-    if (!ok) { res.status(404).json({ error: 'Client introuvable' }); return }
-    res.json({ ok: true })
-})
-app.put('/api/torrent-clients/:uuid', requireAuth, (req, res) => {
-    const { name, type, config } = req.body
-    if (!name || !type || !config) { res.status(400).json({ error: 'name, type et config requis' }); return }
-    if (!getDriver(type))          { res.status(400).json({ error: `Type inconnu : ${type}` }); return }
-    const oldClient = getClient(String(req.params.uuid))
-    if (oldClient) {
-        const driver = getDriver(type)
-        if (driver) {
-            for (const field of driver.definition.fields) {
-                if (field.type === 'password' && config[field.key] === '••••••••') {
-                    config[field.key] = oldClient.config[field.key]
-                }
-            }
-        }
-    }
-    const updated = updateClient(String(req.params.uuid), name, type, config)
-    if (!updated) { res.status(404).json({ error: 'Client introuvable' }); return }
-    res.json(sanitizeClient(updated))
-})
-app.post('/api/torrent-clients/test-config', requireAuth, async (req, res) => {
-    const { type, config, uuid } = req.body
-    if (!type || !config) { res.status(400).json({ error: 'type et config requis' }); return }
-    const driver = getDriver(type)
-    if (!driver) { res.status(400).json({ error: `Type inconnu : ${type}` }); return }
-    if (uuid) {
-        const oldClient = getClient(uuid)
-        if (oldClient) {
-            for (const field of driver.definition.fields) {
-                if (field.type === 'password' && config[field.key] === '••••••••') {
-                    config[field.key] = oldClient.config[field.key]
-                }
-            }
-        }
-    }
-    res.json(await driver.test(config))
-})
-app.post('/api/torrent-clients/:uuid/test', requireAuth, async (req, res) => {
-    const client = getClient(String(req.params.uuid))
-    if (!client) { res.status(404).json({ error: 'Client introuvable' }); return }
-    const driver = getDriver(client.type)
-    if (!driver) { res.status(400).json({ error: 'Driver introuvable' }); return }
-    res.json(await driver.test(client.config))
-})
-app.get('/api/torrent-clients/:uuid/healthcheck', requireAuth, async (req, res) => {
-    const client = getClient(String(req.params.uuid))
-    if (!client) { res.status(404).json({ error: 'Client introuvable' }); return }
-    const driver = getDriver(client.type)
-    if (!driver) { res.status(400).json({ error: 'Driver introuvable' }); return }
-    res.json(await driver.healthcheck(client.config))
-})
-
-// ── Cache GitHub ───────────────────────────────────────────────
-const CACHE_TTL_MS = 6 * 60 * 60 * 1000
-
-interface CacheEntry<T> { data: T; expiresAt: number }
-const _cache = new Map<string, CacheEntry<any>>()
-
-function cacheGet<T>(key: string): T | null {
-    const entry = _cache.get(key)
-    if (!entry) return null
-    if (Date.now() > entry.expiresAt) { _cache.delete(key); return null }
-    return entry.data as T
-}
-
-function cacheSet<T>(key: string, data: T): void {
-    _cache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS })
-}
-
-function cacheClear(): void { _cache.clear() }
-
-async function githubGet(urlPath: string): Promise<any> {
-    const cached = cacheGet(urlPath)
-    if (cached) return cached
-    const res = await fetch(`${GITHUB_BASE}/${urlPath}`)
-    if (!res.ok) throw new Error(`GitHub ${res.status}: ${urlPath}`)
-    const data = await res.json()
-    cacheSet(urlPath, data)
-    return data
-}
-
-async function readAvailable(): Promise<number[]> {
-    try { return await githubGet('available.json') as number[] }
-    catch { return [] }
-}
-
-async function readSerieData(serieId: number): Promise<any | null> {
-    try { return await githubGet(`series/${serieId}.json`) }
-    catch { return null }
-}
-
-function extractTorrentsFromSerieData(sd: any): any[] {
-    const result: any[] = []
-    if (!sd) return result
-    for (const t of sd.torrents ?? []) {
-        result.push({ ...t, raw: t.title, type: 'pack_integrale', serie_id: sd.id, serie_title: sd.title, _serieLevel: true, _serieData: sd, _torrentIdx: (sd.torrents ?? []).indexOf(t) })
-    }
-    for (const season of sd.seasons ?? []) {
-        for (const t of season.torrents ?? []) {
-            result.push({ ...t, raw: t.title, type: 'pack_saison', serie_id: sd.id, serie_title: sd.title, season_id: season.id, season_number: season.season_number, _seasonLevel: true, _season: season, _torrentIdx: (season.torrents ?? []).indexOf(t) })
-        }
-        for (const ep of season.episodes ?? []) {
-            for (const t of ep.torrents ?? []) {
-                result.push({ ...t, raw: t.title, type: 'episode', serie_id: sd.id, serie_title: sd.title, season_id: season.id, season_number: season.season_number, episode_id: ep.id, episode_number: ep.episode_number, _episodeLevel: true, _episode: ep, _torrentIdx: (ep.torrents ?? []).indexOf(t) })
-            }
-        }
-    }
-    return result
-}
-
-function buildResolvedEpisodes(sd: any, hash: string, seasonFilter?: number): any[] {
-    const resolved: any[] = []
-    const h = hash.toLowerCase()
-    for (const season of sd.seasons ?? []) {
-        if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
-        for (const ep of season.episodes ?? []) {
-            const paths: any[] = ep.paths ?? []
-            let filePath: string | null = null
-            for (const p of paths) {
-                if (typeof p === 'string') { if (!filePath) filePath = p.replace(/\\/g, '/') }
-                else if (p?.infohash?.toLowerCase() === h) { filePath = p.path.replace(/\\/g, '/'); break }
-            }
-            if (!filePath) continue
-            const filename = filePath.split('/').pop() ?? filePath
-            resolved.push({ episode_id: ep.id, episode_number: ep.episode_number, season_number: season.season_number, season_id: season.id, filename, original_filename: filename })
-        }
-    }
-    return resolved
-}
-
-async function fankaiGet(endpoint: string): Promise<any> {
-    const res = await fetch(`${FANKAI_API}${endpoint}`)
-    if (!res.ok) throw new Error(`Fankai API ${res.status}: ${endpoint}`)
-    return res.json()
-}
-
-function imgProxy(url: string | null | undefined, w: number, q = 70): string | null {
-    if (!url) return null
-    const stripped = url.replace(/^https?:\/\//, '')
-    return `https://wsrv.nl/?url=${stripped}&w=${w}&q=${q}`
-}
-
-function normalizeSerie(serie: any): any {
-    return { ...serie, poster_image: imgProxy(serie.poster_image ?? serie.images?.poster ?? null, 300), fanart_image: imgProxy(serie.fanart_image ?? serie.images?.fanart ?? null, 1280, 60) }
-}
-function normalizeSeason(season: any): any {
-    return { ...season, poster_image: imgProxy(season.poster_image ?? season.images?.poster ?? null, 300) }
-}
-function normalizeEpisode(ep: any): any {
-    return { ...ep, thumb_image: imgProxy(ep.thumb_image ?? ep.thumbnail ?? null, 400) }
-}
-
-async function loadEnrichedSeriesData(): Promise<any[]> {
-    const ids   = await readAvailable()
-    const allSd = await Promise.all(ids.map(id => readSerieData(id)))
-    return allSd.filter(Boolean)
-}
-
-function computeSerieDownloadState(serieData: any | null, organized: Record<string, Record<string, any>>, activeTorrents: Set<string>): 'none' | 'downloading' | 'partial' | 'complete' {
-    if (!serieData) return 'none'
-    const allTorrents = extractTorrentsFromSerieData(serieData)
-    if (allTorrents.length === 0) return 'none'
-    if (allTorrents.some(t => t.infohash && activeTorrents.has(t.infohash.toLowerCase()))) return 'downloading'
-    const allEpisodeIds = new Set<number>()
-    const organizedEpisodeIds = new Set<number>()
-    for (const season of serieData.seasons ?? []) {
-        for (const ep of season.episodes ?? []) {
-            if ((ep.torrents ?? []).length > 0 || (ep.paths ?? []).length > 0) allEpisodeIds.add(ep.id)
-        }
-    }
-    for (const t of allTorrents) {
-        const hash = t.infohash?.toLowerCase()
-        if (!hash) continue
-        const orgFiles = organized[hash] ?? {}
-        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 (allEpisodeIds.size === 0 || organizedEpisodeIds.size === 0) return 'none'
-    if (organizedEpisodeIds.size >= allEpisodeIds.size) return 'complete'
-    return 'partial'
-}
-
-// ── Routes série ───────────────────────────────────────────────
-app.get('/api/series', requireAuth, async (_req, res) => {
-    try {
-        const [apiData, availableIds] = await Promise.all([fankaiGet('/series'), readAvailable()])
-        const availableSet = new Set<number>(availableIds)
-        let organized: Record<string, Record<string, any>> = {}
-        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
-        const activeTorrents = new Set<string>()
-        try { const { category } = readSettings(); const active = await dispatchList(category ?? 'fankai'); for (const t of active) { if (t.hash && t.state === 'downloading') activeTorrents.add(t.hash.toLowerCase()) } } catch {}
-        const seriesRaw = (Array.isArray(apiData) ? apiData : (apiData.series ?? [])).map(normalizeSerie)
-        const serieDataMap = new Map<number, any>()
-        await Promise.all(seriesRaw.filter((s: any) => availableSet.has(s.id)).map(async (s: any) => { const sd = await readSerieData(s.id); if (sd) serieDataMap.set(s.id, sd) }))
-        res.json({ series: seriesRaw.map((serie: any) => {
-                const hasTorrents = availableSet.has(serie.id)
-                const serieData   = serieDataMap.get(serie.id) ?? null
-                return { ...serie, torrent_count: serieData ? extractTorrentsFromSerieData(serieData).length : 0, has_torrents: hasTorrents, download_state: computeSerieDownloadState(serieData, organized, activeTorrents) }
-            })})
-    } catch (err) {
-        logger.error('api', `GET /api/series échoué : ${err instanceof Error ? err.message : err}`)
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-app.get('/api/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 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`)
-            const episodes = (Array.isArray(epsData) ? epsData : (epsData.episodes ?? [])).map(normalizeEpisode)
-            return { ...normalizeSeason(season), episodes }
-        }))
-        let organized: Record<string, Record<string, any>> = {}
-        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
-        const availableEpisodeIds  = new Set<number>()
-        const episodeTorrentMap    : Record<number, any> = {}
-        const seasonTorrentMapBySn : Record<number, any> = {}
-        const integraleTorrents    : any[] = []
-        const organizedEpisodeIds  = new Set<number>()
-        if (serieData) {
-            for (const t of (serieData.torrents ?? [])) {
-                integraleTorrents.push({ ...t, raw: t.title })
-                const resolved = buildResolvedEpisodes(serieData, t.infohash)
-                for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
-                const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
-                for (const ep of resolved) {
-                    const isOrg = orgFiles[String(ep.episode_id)] !== undefined || orgFiles[ep.filename] !== undefined
-                    if (isOrg) organizedEpisodeIds.add(ep.episode_id)
-                }
-            }
-            for (const season of serieData.seasons ?? []) {
-                for (const t of (season.torrents ?? [])) {
-                    seasonTorrentMapBySn[season.season_number] = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'pack_saison', raw: t.title, manual: t.manual ?? false }
-                    const resolved = buildResolvedEpisodes(serieData, t.infohash, season.season_number)
-                    for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
-                    const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
-                    for (const ep of resolved) {
-                        const isOrg = orgFiles[String(ep.episode_id)] !== undefined || orgFiles[ep.filename] !== undefined
-                        if (isOrg) organizedEpisodeIds.add(ep.episode_id)
-                    }
-                }
-                for (const ep of season.episodes ?? []) {
-                    for (const t of (ep.torrents ?? [])) {
-                        episodeTorrentMap[ep.id] = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'episode', raw: t.title, manual: t.manual ?? false, fankai: t.fankai ?? true }
-                        availableEpisodeIds.add(ep.id)
-                        const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
-                        const isOrg = orgFiles[String(ep.id)] !== undefined
-                        if (!isOrg) {
-                            const match = (ep.paths ?? []).find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === t.infohash?.toLowerCase())
-                            const filename = match ? match.path.split('/').pop() : null
-                            if (filename && orgFiles[filename]) organizedEpisodeIds.add(ep.id)
-                        } else {
-                            organizedEpisodeIds.add(ep.id)
-                        }
-                    }
-                }
-            }
-        }
-        const enrichedSeasons = seasonsWithEpisodes.map((season: any) => {
-            const eps = season.episodes.map((ep: any) => {
-                const epTorrent = episodeTorrentMap[ep.id] ?? null
-                let fankai: boolean | null = epTorrent ? (epTorrent.fankai ?? true) : null
-                if (fankai === null && serieData) {
-                    outer: for (const sd_season of serieData.seasons ?? []) {
-                        for (const sdEp of sd_season.episodes ?? []) {
-                            if (sdEp.id !== ep.id) continue
-                            for (const p of sdEp.paths ?? []) {
-                                const ih = typeof p === 'object' ? p.infohash?.toLowerCase() : null
-                                if (!ih) continue
-                                for (const t of serieData.torrents ?? []) { if (t.infohash?.toLowerCase() === ih) { fankai = t.fankai ?? true; break outer } }
-                                for (const s of serieData.seasons ?? []) { for (const t of s.torrents ?? []) { if (t.infohash?.toLowerCase() === ih) { fankai = t.fankai ?? true; break outer } } }
-                            }
-                        }
-                    }
-                }
-                return { ...ep, available: availableEpisodeIds.has(ep.id), torrent: epTorrent ? { ...epTorrent, fankai: fankai ?? true } : null, fankai, organized: organizedEpisodeIds.has(ep.id) }
-            })
-            const total    = eps.filter((e: any) => e.available).length
-            const orgCount = eps.filter((e: any) => e.organized).length
-            return { ...season, torrent: seasonTorrentMapBySn[season.season_number] ?? null, organized_state: orgCount === 0 ? 'none' : orgCount >= total && total > 0 ? 'complete' : 'partial', organized_count: orgCount, episodes: eps }
-        })
-        res.json({ serie, seasons: enrichedSeasons, torrents_integrale: integraleTorrents.map(t => ({ label: 'Intégrale', torrent_url: t.torrent_url, magnet: t.magnet, raw: t.title ?? t.raw })) })
-    } catch (err) {
-        logger.error('api', `GET /api/series/${id} échoué : ${err instanceof Error ? err.message : err}`)
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-// ── Download ───────────────────────────────────────────────────
-app.post('/api/download', requireAuth, async (req, res) => {
-    const url = req.body.magnet ?? req.body.torrent_url
-    if (!url) { res.status(400).json({ error: 'torrent_url ou magnet requis' }); return }
-    logger.info('api', 'Téléchargement demandé')
-    const results = await dispatchDownload(url)
-    res.status(results.every((r: any) => r.ok) ? 200 : 207).json({ results })
-})
-
-// ── Downloads list ─────────────────────────────────────────────
-app.get('/api/downloads', requireAuth, async (_req, res) => {
-    try {
-        const { category } = readSettings()
-        const torrents = await dispatchList(category ?? 'fankai')
-        let organized: Record<string, Record<string, any>> = {}
-        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
-        const enriched = await Promise.all(torrents.map(async (t: any) => {
-            const orgFiles = organized[t.hash] ?? {}
-            let totalFiles = 1
-            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 }
-                }
-            } 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 ?? [] }
-        }))
-        res.json(enriched)
-    } catch (err) {
-        logger.error('api', `GET /api/downloads échoué : ${err instanceof Error ? err.message : err}`)
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-// ── Organize ───────────────────────────────────────────────────
-interface OrganizeNotif {
-    hash: string; name: string; done: number; skipped: number; errors: number
-    errorFiles: { file: string; error: string }[]; at: string
-}
-const recentOrganized: OrganizeNotif[] = []
-const MAX_NOTIFS = 20
-
-function pushNotif(n: OrganizeNotif) {
-    recentOrganized.unshift(n)
-    if (recentOrganized.length > MAX_NOTIFS) recentOrganized.pop()
-}
-
-app.get('/api/organize/recent', requireAuth, (_req, res) => {
-    res.json(recentOrganized)
-})
-app.post('/api/organize/recent/clear', requireAuth, (_req, res) => {
-    recentOrganized.length = 0
-    logger.info('api', 'Historique des imports effacé')
-    res.json({ ok: true })
-})
-app.post('/api/organize', requireAuth, async (req, res) => {
-    const { hash, name, save_path } = req.body
-    if (!hash || !name || !save_path) { res.status(400).json({ error: 'hash, name et save_path requis' }); return }
-    try {
-        const seriesData = await loadEnrichedSeriesData()
-        const result     = await organizeTorrent(hash, name, save_path, seriesData)
-        if (result.done > 0 || result.errors.length > 0) {
-            pushNotif({ hash, name, done: result.done, skipped: result.skipped, errors: result.errors.length, errorFiles: result.errors, at: new Date().toISOString() })
-        }
-        res.json(result)
-    } catch (err) {
-        logger.error('api', `Import manuel de "${name}" échoué : ${err instanceof Error ? err.message : err}`)
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-// ── Logs ───────────────────────────────────────────────────────
-app.get('/api/logs', requireAuth, (req, res) => {
-    const limit   = Number(req.query.limit)  || 100
-    const level   = (req.query.level  as string) || 'all'
-    const source  = (req.query.source as string) || undefined
-    res.json({ entries: readLogs({ limit, level: level as any, source }), size: logsFileSize() })
-})
-app.post('/api/logs/clear', requireAuth, (_req, res) => {
-    clearLogs()
-    logger.info('api', 'Logs effacés')
-    res.json({ ok: true })
-})
-
-// ── Système ────────────────────────────────────────────────────
-app.get('/api/system', requireAuth, (_req, res) => {
-    res.json({ isDocker: fs.existsSync('/.dockerenv') })
-})
-
-app.get('/api/browse', requireAuth, (req, res) => {
-    const dirPath = (req.query.path as string) || '/'
-    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 })
-    } 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' })
-    }
-})
-
-app.get('/api/browse-files', requireAuth, (req, res) => {
-    const dirPath = (req.query.path as string) || '/'
-    const VIDEO_EXTS = new Set(['.mkv', '.mp4', '.avi', '.m4v', '.mov', '.wmv'])
-    try {
-        const files: { name: string; path: string; size: number }[] = []
-        function walk(dir: string) {
-            let entries: fs.Dirent[]
-            try { entries = fs.readdirSync(dir, { withFileTypes: true }) }
-            catch { return }
-            for (const entry of entries) {
-                if (entry.name.startsWith('.')) continue
-                const full = path.join(dir, entry.name)
-                if (entry.isDirectory()) {
-                    walk(full)
-                } else if (entry.isFile() && VIDEO_EXTS.has(path.extname(entry.name).toLowerCase())) {
-                    try {
-                        const stat = fs.statSync(full)
-                        files.push({ name: entry.name, path: full, size: stat.size })
-                    } catch {}
-                }
-            }
-        }
-        walk(dirPath)
-        files.sort((a, b) => a.name.localeCompare(b.name, 'fr'))
-        res.json({ path: dirPath, files })
-    } catch (err) {
-        logger.warn('api', `browse-files "${dirPath}" : ${err instanceof Error ? err.message : err}`)
-        res.status(400).json({ error: err instanceof Error ? err.message : 'Erreur lecture dossier' })
-    }
-})
-
-app.get('/api/torrents/status', requireAuth, async (_req, res) => {
-    try {
-        const available = await readAvailable()
-        res.json({ exists: available.length > 0, count: available.length, empty: available.length === 0 })
-    } catch { res.json({ exists: false, count: 0, empty: true }) }
-})
-
-app.post('/api/update', requireAuth, async (_req, res) => {
-    try {
-        cacheClear()
-        logger.info('api', 'Cache GitHub vidé — rechargement forcé')
-        const availableIds = await readAvailable()
-        if (!Array.isArray(availableIds)) throw new Error('available.json invalide')
-        logger.info('api', `Catalogue rechargé — ${availableIds.length} séries disponibles`)
-        res.json({ ok: true, count: availableIds.length })
-    } catch (err) {
-        logger.error('api', `Mise à jour catalogue échouée : ${err instanceof Error ? err.message : err}`)
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-app.post('/api/scan', requireAuth, async (_req, res) => {
-    try {
-        const { mediaPath } = readSettings()
-        logger.info('api', 'Scan médiathèque manuel lancé')
-        const seriesData = await loadEnrichedSeriesData()
-        const result     = await scanMediaPath(mediaPath, path.join(DATA_DIR, 'organized.json'), seriesData)
-        res.json({ ok: true, ...result })
-    } catch (err) {
-        logger.error('api', `Scan médiathèque échoué : ${err instanceof Error ? err.message : err}`)
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-// ── Import manuel ──────────────────────────────────────────────
-app.post('/api/manual-import', requireAuth, async (req, res) => {
-    const { serie_id, items } = req.body
-    if (!serie_id || !Array.isArray(items) || items.length === 0) {
-        res.status(400).json({ error: 'serie_id et items requis' }); return
-    }
-    const { mediaPath, organizeMode, nfoSupport } = readSettings()
-    const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
-    let organized: Record<string, Record<string, any>> = {}
-    try { if (fs.existsSync(ORGANIZED_PATH)) organized = JSON.parse(fs.readFileSync(ORGANIZED_PATH, 'utf-8')) } catch {}
-    const sd = await readSerieData(Number(serie_id))
-    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()
-    const episodeIndex = new Map<number, { ep: any; season: any }>()
-    for (const season of sd.seasons ?? []) {
-        for (const ep of season.episodes ?? []) {
-            episodeIndex.set(ep.id, { ep, season })
-        }
-    }
-    const done: number[] = []
-    const errors: { file: string; error: string }[] = []
-    for (const item of items) {
-        const { file_path, episode_id, hash } = item
-        if (!file_path || !episode_id) { errors.push({ file: file_path ?? '?', error: 'Paramètres manquants' }); continue }
-        const found = episodeIndex.get(Number(episode_id))
-        if (!found) { errors.push({ file: file_path, error: `Épisode ${episode_id} introuvable` }); continue }
-        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 resolvedName  = nfoSupport
-            ? (ep.nfo_filename ?? ep.original_filename ?? srcFilename)
-            : (fmtName ?? ep.nfo_filename ?? ep.original_filename ?? srcFilename)
-        const destFilename  = resolvedName.endsWith('.nfo') ? resolvedName.slice(0, -4) + srcExt : resolvedName
-        const seasonFolder  = season.season_number === 0 ? 'Specials' : `Saison ${season.season_number}`
-        const destDir       = path.join(mediaPath, serieTitle, seasonFolder)
-        const destPath      = path.join(destDir, destFilename)
-        try {
-            if (!fs.existsSync(file_path)) throw new Error('Fichier source introuvable')
-            fs.mkdirSync(destDir, { recursive: true })
-            if (!fs.existsSync(destPath)) {
-                if (organizeMode === 'hardlink') {
-                    try { fs.linkSync(file_path, destPath) }
-                    catch { await fs.promises.copyFile(file_path, destPath) }
-                } else {
-                    await fs.promises.copyFile(file_path, destPath)
-                    await fs.promises.unlink(file_path)
-                }
-            }
-            const torrentHash = String(hash || '').toLowerCase() || 'manual'
-            if (!organized[torrentHash]) organized[torrentHash] = {}
-            organized[torrentHash][String(episode_id)] = {
-                at: new Date().toISOString(), season: season.season_number,
-                episode: ep.episode_number, episode_id: ep.id,
-                src_filename: srcFilename, dest_filename: destFilename, dest_path: destPath,
-            }
-            done.push(episode_id)
-            logger.info('api', `Import manuel : "${srcFilename}" → "${destPath}"`)
-        } catch (err) {
-            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
-            errors.push({ file: srcFilename, error: msg })
-            logger.error('api', `Import manuel échoué pour "${srcFilename}" : ${msg}`)
-        }
-    }
-    fs.writeFileSync(ORGANIZED_PATH, JSON.stringify(organized, null, 2), 'utf-8')
-    res.json({ ok: true, done: done.length, errors })
-})
-
-app.get('/api/organized/:serieId', requireAuth, async (req, res) => {
-    const serieId = Number(req.params.serieId)
-    try {
-        const sd = await readSerieData(serieId)
-        if (!sd) { res.status(404).json({ error: 'Série introuvable' }); return }
-        let organized: Record<string, Record<string, any>> = {}
-        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
-        const result: Record<string, any> = {}
-        for (const season of sd.seasons ?? []) {
-            for (const ep of season.episodes ?? []) {
-                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 }
-                }
-                if (!result[String(ep.id)] && organized['manual']?.[String(ep.id)]) {
-                    result[String(ep.id)] = organized['manual'][String(ep.id)]
-                }
-            }
-        }
-        res.json(result)
-    } catch (err) {
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
-    }
-})
-
-// ── Debug ──────────────────────────────────────────────────────
-app.get('/api/debug/stats', requireAuth, (req, res) => {
-    const { devMode } = readSettings()
-    if (!devMode) { res.status(403).json({ error: 'Dev mode désactivé' }); return }
-    const mem     = process.memoryUsage()
-    const uptimeS = Math.floor(process.uptime())
-    const h       = Math.floor(uptimeS / 3600)
-    const m       = Math.floor((uptimeS % 3600) / 60)
-    const s       = uptimeS % 60
-    let organizedCount = 0
-    try {
-        const orgPath = path.join(DATA_DIR, 'organized.json')
-        if (fs.existsSync(orgPath)) {
-            const org = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
-            organizedCount = Object.values(org).reduce((acc: number, episodes: any) => acc + Object.keys(episodes).length, 0)
-        }
-    } catch {}
-    res.json({
-        memory   : { heapUsed: Math.round(mem.heapUsed / 1024 / 1024), heapTotal: Math.round(mem.heapTotal / 1024 / 1024), rss: Math.round(mem.rss / 1024 / 1024) },
-        cache    : { entries: _cache.size, ttlHours: 6 },
-        uptime   : `${h}h ${m}m ${s}s`,
-        uptimeSeconds: uptimeS,
-        worker   : { running: workerRunning },
-        organized: { trackedFiles: organizedCount },
-        requests : { notifs: recentOrganized.length },
-    })
-})
-
-// ── NFO Updates ────────────────────────────────────────────────
-interface NfoUpdateNotif {
-    serieTitle: string; commitSha: string; commitMsg: string
-    updatedAt: string; status: 'updated' | 'error'; error?: string
-}
-const recentNfoUpdates: NfoUpdateNotif[] = []
-const MAX_NFO_NOTIFS   = 30
-const NFO_COMMITS_PATH = path.join(DATA_DIR, 'nfo_commits.json')
-const GITLAB_API_NFO   = 'https://gitlab.com/api/v4/projects/ElPouki%2Ffankai_pack/repository'
-const GITLAB_RAW_NFO   = 'https://gitlab.com/ElPouki/fankai_pack/-/raw/main/pack'
-
-const SERIE_TITLE_GITLAB_MAP: Record<string, string> = {
-    'Enfer Et Paradis Henshū'          : 'Enfer et Paradis Henshū',
-    'Hajime No Ippo Henshū'            : 'Hajime no Ippo Henshū',
-    'Hikaru No Go Henshū'              : 'Hikaru no Go Henshū',
-    'Hokuto No Ken Kaï'                : 'Hokuto no Ken Kaï',
-    'Kaguya-sama : Love is War Henshū' : 'Kaguya-sama - Love is War Henshū',
-    'Kenshin le Vagabond Henshū'       : 'Kenshin le vagabond Henshū',
-    'Kuroko No Basket Henshū'          : 'Kuroko no Basket Henshū',
-    'Shingeki No Kyojin Henshū'        : 'Shingeki no Kyojin Henshū',
-    'Tower Of God Henshū'              : 'Tower of God Henshū',
-}
-
-function getGitlabTitle(title: string): string { return SERIE_TITLE_GITLAB_MAP[title] ?? title }
-
-function loadNfoCommits(): Record<string, string> {
-    try { if (!fs.existsSync(NFO_COMMITS_PATH)) return {}; return JSON.parse(fs.readFileSync(NFO_COMMITS_PATH, 'utf-8')) }
-    catch { return {} }
-}
-function saveNfoCommits(commits: Record<string, string>) {
-    fs.mkdirSync(path.dirname(NFO_COMMITS_PATH), { recursive: true })
-    fs.writeFileSync(NFO_COMMITS_PATH, JSON.stringify(commits, null, 2), 'utf-8')
-}
-
-async function getLatestGitlabCommit(gitlabTitle: string): Promise<{ sha: string; message: string } | null> {
-    try {
-        const res = await fetch(`${GITLAB_API_NFO}/commits?path=${encodeURIComponent('pack/' + gitlabTitle)}&per_page=1&ref_name=main`, { headers: { 'User-Agent': 'fankarr' } })
-        if (!res.ok) return null
-        const data: any[] = await res.json()
-        if (!data.length) return null
-        return { sha: data[0].id, message: data[0].title ?? data[0].message ?? '' }
-    } catch { return null }
-}
-
-async function downloadNfoFolder(gitlabTitle: string, destRoot: string): Promise<void> {
-    let files: any[] = [], page = 1
-    while (true) {
-        const batch = await fetch(`${GITLAB_API_NFO}/tree?path=${encodeURIComponent('pack/' + gitlabTitle)}&recursive=true&per_page=100&page=${page}&ref=main`, { headers: { 'User-Agent': 'fankarr' } }).then(r => r.ok ? r.json() : [])
-        if (!Array.isArray(batch) || batch.length === 0) break
-        files.push(...batch); if (batch.length < 100) break; page++
-    }
-    let downloaded = 0, skipped = 0
-    for (const entry of files.filter((f: any) => f.type === 'blob')) {
-        const relativePath = entry.path.replace(`pack/${gitlabTitle}/`, '')
-        const destPath     = path.join(destRoot, relativePath)
-        try {
-            const res = await fetch(`${GITLAB_RAW_NFO}/${encodeURIComponent(gitlabTitle)}/${relativePath.split('/').map(encodeURIComponent).join('/')}`, { headers: { 'User-Agent': 'fankarr' } })
-            if (!res.ok) { skipped++; continue }
-            fs.mkdirSync(path.dirname(destPath), { recursive: true })
-            fs.writeFileSync(destPath, Buffer.from(await res.arrayBuffer()))
-            downloaded++
-        } catch { skipped++ }
-    }
-    logger.info('nfo-update', `"${gitlabTitle}" — ${downloaded} fichiers mis à jour, ${skipped} ignorés`)
-}
-
-async function checkNfoUpdates() {
-    const { mediaPath, nfoSupport } = readSettings()
-    if (!nfoSupport) return
-    let organized: Record<string, Record<string, any>> = {}
-    try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
-    if (Object.keys(organized).length === 0) return
-    const seriesData  = await loadEnrichedSeriesData()
-    const knownHashes = new Set(Object.keys(organized))
-    const serieTitles = new Set<string>()
-    for (const sd of seriesData) {
-        const allTorrents = [...(sd.torrents ?? []), ...(sd.seasons ?? []).flatMap((s: any) => s.torrents ?? []), ...(sd.seasons ?? []).flatMap((s: any) => (s.episodes ?? []).flatMap((e: any) => e.torrents ?? []))]
-        if (allTorrents.some((t: any) => knownHashes.has(t.infohash?.toLowerCase()))) {
-            const rawTitle = sd.title ?? sd.show_title ?? ''
-            if (rawTitle) serieTitles.add(rawTitle.replace(/:/g, ' -').replace(/[<>"/\\|?*]/g, '').replace(/\s+/g, ' ').trim())
-        }
-    }
-    if (serieTitles.size === 0) return
-    const commits = loadNfoCommits()
-    let hasChanges = false
-    for (const serieTitle of serieTitles) {
-        const gitlabTitle = getGitlabTitle(serieTitle)
-        const latest      = await getLatestGitlabCommit(gitlabTitle)
-        if (!latest || commits[gitlabTitle] === latest.sha) continue
-        logger.info('nfo-update', `MAJ NFO détectée pour "${gitlabTitle}" (${latest.sha.slice(0, 8)})`)
-        try {
-            await downloadNfoFolder(gitlabTitle, path.join(mediaPath, serieTitle))
-            commits[gitlabTitle] = latest.sha
-            hasChanges = true
-            recentNfoUpdates.unshift({ serieTitle, commitSha: latest.sha.slice(0, 8), commitMsg: latest.message, updatedAt: new Date().toISOString(), status: 'updated' })
-        } catch (err) {
-            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
-            logger.error('nfo-update', `Échec MAJ NFO "${gitlabTitle}" : ${msg}`)
-            recentNfoUpdates.unshift({ serieTitle, commitSha: latest.sha.slice(0, 8), commitMsg: latest.message, updatedAt: new Date().toISOString(), status: 'error', error: msg })
-        }
-        if (recentNfoUpdates.length > MAX_NFO_NOTIFS) recentNfoUpdates.pop()
-    }
-    if (hasChanges) saveNfoCommits(commits)
-}
-
-app.get('/api/nfo-updates/recent', requireAuth, (_req, res) => { res.json(recentNfoUpdates) })
-app.post('/api/nfo-updates/check', requireAuth, async (_req, res) => {
-    logger.info('nfo-update', 'Vérification manuelle des MAJ NFO lancée')
-    checkNfoUpdates().catch(err => logger.error('nfo-update', `Vérif manuelle échouée : ${err instanceof Error ? err.message : err}`))
-    res.json({ ok: true, message: 'Vérification lancée en arrière-plan' })
-})
+// ── Routes ─────────────────────────────────────────────────────
+app.use('/api', settingsRouter)
+app.use('/api', torrentClientsRouter)
+app.use('/api', seriesRouter)
+app.use('/api', downloadsRouter)
+app.use('/api', organizeRouter)
+app.use('/api', importRouter)
+app.use('/api', systemRouter)
+app.use('/api', nfoUpdatesRouter)
+app.use('/api', plexRouter)

 // ── Catch-all SPA ──────────────────────────────────────────────
 if (fs.existsSync(PUBLIC_PATH)) {
@@ -828,14 +103,24 @@ server.listen(PORT, async () => {
    const autoOrganize = async () => {
        try {
            const { category } = readSettings()
+            const infohashMap  = await readInfohashMap()
            const seriesData   = await loadEnrichedSeriesData()
            await autoOrganizeAll(
-                () => dispatchList(category ?? 'fankai'),
+                () => dispatchList(category ?? 'fankai', infohashMap),
                seriesData,
-                (result) => {
+                async (result) => {
                    if (result.done > 0 || result.errors > 0) {
                        pushNotif({ ...result, at: new Date().toISOString() })
                    }
+                    const { organizeMode, deleteTorrentOnMove } = readSettings()
+                    if (organizeMode === 'move' && deleteTorrentOnMove && result.done > 0) {
+                        try {
+                            await dispatchRemove(result.hash, false)
+                            logger.info('api', `Torrent "${result.name}" supprimé après move`)
+                        } catch (err) {
+                            logger.warn('api', `Impossible de supprimer le torrent "${result.name}" : ${err instanceof Error ? err.message : err}`)
+                        }
+                    }
                }
            )
        } catch (err) {
@@ -854,4 +139,4 @@ 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)
-})
+})
@@ -0,0 +1,65 @@
+import { DATA_DIR } from '../config.js'
+import path from 'path'
+import fs from 'fs'
+
+const GITHUB_BASE = process.env.GITHUB_BASE
+    ?? 'https://raw.githubusercontent.com/masutayunikon/fankarr-scraper/main'
+
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000
+
+interface CacheEntry<T> { data: T; expiresAt: number }
+const _cache = new Map<string, CacheEntry<any>>()
+
+export function cacheGet<T>(key: string): T | null {
+    const entry = _cache.get(key)
+    if (!entry) return null
+    if (Date.now() > entry.expiresAt) { _cache.delete(key); return null }
+    return entry.data as T
+}
+
+export function cacheSet<T>(key: string, data: T): void {
+    _cache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS })
+}
+
+export function cacheClear(): void { _cache.clear() }
+
+export function cacheSize(): number { return _cache.size }
+
+export async function githubGet(urlPath: string): Promise<any> {
+    const cached = cacheGet(urlPath)
+    if (cached) return cached
+    const res = await fetch(`${GITHUB_BASE}/${urlPath}`)
+    if (!res.ok) throw new Error(`GitHub ${res.status}: ${urlPath}`)
+    const data = await res.json()
+    cacheSet(urlPath, data)
+    return data
+}
+
+export async function readAvailable(): Promise<number[]> {
+    try { return await githubGet('available.json') as number[] }
+    catch { return [] }
+}
+
+export async function readInfohashMap(): Promise<Record<string, string>> {
+    try { return await githubGet('infohash_map.json') as Record<string, string> }
+    catch { return {} }
+}
+
+export async function readSerieData(serieId: number): Promise<any | null> {
+    try { return await githubGet(`series/${serieId}.json`) }
+    catch { return null }
+}
+
+export async function loadEnrichedSeriesData(): Promise<any[]> {
+    const ids   = await readAvailable()
+    const allSd = await Promise.all(ids.map(id => readSerieData(id)))
+    return allSd.filter(Boolean)
+}
+
+export function loadOrganized(): 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 {}
+}
@@ -0,0 +1,99 @@
+import fs from 'fs'
+import path from 'path'
+import { DATA_DIR } from '../config.js'
+import { readSettings } from '../settings.js'
+import { logger } from '../logger.js'
+import { getGitlabTitle } from '../gitlab-map.js'
+import { loadEnrichedSeriesData, loadOrganized } from './github-cache.js'
+
+export const GITLAB_API_NFO = 'https://gitlab.com/api/v4/projects/ElPouki%2Ffankai_pack/repository'
+export const GITLAB_RAW_NFO = 'https://gitlab.com/ElPouki/fankai_pack/-/raw/main/pack'
+
+export interface NfoUpdateNotif {
+    serieTitle: string; commitSha: string; commitMsg: string
+    updatedAt: string; status: 'updated' | 'error'; error?: string
+}
+
+export const recentNfoUpdates: NfoUpdateNotif[] = []
+const MAX_NFO_NOTIFS   = 30
+const NFO_COMMITS_PATH = path.join(DATA_DIR, 'nfo_commits.json')
+
+export function loadNfoCommits(): Record<string, string> {
+    try { if (!fs.existsSync(NFO_COMMITS_PATH)) return {}; return JSON.parse(fs.readFileSync(NFO_COMMITS_PATH, 'utf-8')) }
+    catch { return {} }
+}
+
+export function saveNfoCommits(commits: Record<string, string>) {
+    fs.mkdirSync(path.dirname(NFO_COMMITS_PATH), { recursive: true })
+    fs.writeFileSync(NFO_COMMITS_PATH, JSON.stringify(commits, null, 2), 'utf-8')
+}
+
+export async function getLatestGitlabCommit(gitlabTitle: string): Promise<{ sha: string; message: string } | null> {
+    try {
+        const res = await fetch(`${GITLAB_API_NFO}/commits?path=${encodeURIComponent('pack/' + gitlabTitle)}&per_page=1&ref_name=main`, { headers: { 'User-Agent': 'fankarr' } })
+        if (!res.ok) return null
+        const data: any[] = await res.json()
+        if (!data.length) return null
+        return { sha: data[0].id, message: data[0].title ?? data[0].message ?? '' }
+    } catch { return null }
+}
+
+export async function downloadNfoFolder(gitlabTitle: string, destRoot: string): Promise<void> {
+    let files: any[] = [], page = 1
+    while (true) {
+        const batch = await fetch(`${GITLAB_API_NFO}/tree?path=${encodeURIComponent('pack/' + gitlabTitle)}&recursive=true&per_page=100&page=${page}&ref=main`, { headers: { 'User-Agent': 'fankarr' } }).then(r => r.ok ? r.json() : [])
+        if (!Array.isArray(batch) || batch.length === 0) break
+        files.push(...batch); if (batch.length < 100) break; page++
+    }
+    let downloaded = 0, skipped = 0
+    for (const entry of files.filter((f: any) => f.type === 'blob')) {
+        const relativePath = entry.path.replace(`pack/${gitlabTitle}/`, '')
+        const destPath     = path.join(destRoot, relativePath)
+        try {
+            const res = await fetch(`${GITLAB_RAW_NFO}/${encodeURIComponent(gitlabTitle)}/${relativePath.split('/').map(encodeURIComponent).join('/')}`, { headers: { 'User-Agent': 'fankarr' } })
+            if (!res.ok) { skipped++; continue }
+            fs.mkdirSync(path.dirname(destPath), { recursive: true })
+            fs.writeFileSync(destPath, Buffer.from(await res.arrayBuffer()))
+            downloaded++
+        } catch { skipped++ }
+    }
+    logger.info('nfo-update', `"${gitlabTitle}" — ${downloaded} fichiers mis à jour, ${skipped} ignorés`)
+}
+
+export async function checkNfoUpdates() {
+    const { mediaPath, nfoSupport } = readSettings()
+    if (!nfoSupport) return
+    const organized = loadOrganized()
+    if (Object.keys(organized).length === 0) return
+    const seriesData  = await loadEnrichedSeriesData()
+    const knownHashes = new Set(Object.keys(organized))
+    const serieTitles = new Set<string>()
+    for (const sd of seriesData) {
+        const allTorrents = [...(sd.torrents ?? []), ...(sd.seasons ?? []).flatMap((s: any) => s.torrents ?? []), ...(sd.seasons ?? []).flatMap((s: any) => (s.episodes ?? []).flatMap((e: any) => e.torrents ?? []))]
+        if (allTorrents.some((t: any) => knownHashes.has(t.infohash?.toLowerCase()))) {
+            const rawTitle = sd.title ?? sd.show_title ?? ''
+            if (rawTitle) serieTitles.add(rawTitle.replace(/:/g, ' -').replace(/[<>"/\\|?*]/g, '').replace(/\s+/g, ' ').trim())
+        }
+    }
+    if (serieTitles.size === 0) return
+    const commits = loadNfoCommits()
+    let hasChanges = false
+    for (const serieTitle of serieTitles) {
+        const gitlabTitle = getGitlabTitle(serieTitle)
+        const latest      = await getLatestGitlabCommit(gitlabTitle)
+        if (!latest || commits[gitlabTitle] === latest.sha) continue
+        logger.info('nfo-update', `MAJ NFO détectée pour "${gitlabTitle}" (${latest.sha.slice(0, 8)})`)
+        try {
+            await downloadNfoFolder(gitlabTitle, path.join(mediaPath, serieTitle))
+            commits[gitlabTitle] = latest.sha
+            hasChanges = true
+            recentNfoUpdates.unshift({ serieTitle, commitSha: latest.sha.slice(0, 8), commitMsg: latest.message, updatedAt: new Date().toISOString(), status: 'updated' })
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+            logger.error('nfo-update', `Échec MAJ NFO "${gitlabTitle}" : ${msg}`)
+            recentNfoUpdates.unshift({ serieTitle, commitSha: latest.sha.slice(0, 8), commitMsg: latest.message, updatedAt: new Date().toISOString(), status: 'error', error: msg })
+        }
+        if (recentNfoUpdates.length > MAX_NFO_NOTIFS) recentNfoUpdates.pop()
+    }
+    if (hasChanges) saveNfoCommits(commits)
+}
@@ -0,0 +1,12 @@
+export interface OrganizeNotif {
+    hash: string; name: string; done: number; skipped: number; errors: number
+    errorFiles: { file: string; error: string }[]; at: string
+}
+
+export const recentOrganized: OrganizeNotif[] = []
+const MAX_NOTIFS = 20
+
+export function pushNotif(n: OrganizeNotif) {
+    recentOrganized.unshift(n)
+    if (recentOrganized.length > MAX_NOTIFS) recentOrganized.pop()
+}
@@ -0,0 +1,102 @@
+const FANKAI_API = 'https://metadata.fankai.fr'
+
+export async function fankaiGet(endpoint: string): Promise<any> {
+    const res = await fetch(`${FANKAI_API}${endpoint}`)
+    if (!res.ok) throw new Error(`Fankai API ${res.status}: ${endpoint}`)
+    return res.json()
+}
+
+export function imgProxy(url: string | null | undefined, w: number, q = 70): string | null {
+    if (!url) return null
+    const stripped = url.replace(/^https?:\/\//, '')
+    return `https://wsrv.nl/?url=${stripped}&w=${w}&q=${q}`
+}
+
+export function normalizeSerie(serie: any): any {
+    return { ...serie, poster_image: imgProxy(serie.poster_image ?? serie.images?.poster ?? null, 300), fanart_image: imgProxy(serie.fanart_image ?? serie.images?.fanart ?? null, 1280, 60) }
+}
+
+export function normalizeSeason(season: any): any {
+    return { ...season, poster_image: imgProxy(season.poster_image ?? season.images?.poster ?? null, 300) }
+}
+
+export function normalizeEpisode(ep: any): any {
+    return { ...ep, thumb_image: imgProxy(ep.thumb_image ?? ep.thumbnail ?? null, 400) }
+}
+
+export function extractTorrentsFromSerieData(sd: any): any[] {
+    const result: any[] = []
+    if (!sd) return result
+    for (const t of sd.torrents ?? []) {
+        result.push({ ...t, raw: t.title, type: 'pack_integrale', serie_id: sd.id, serie_title: sd.title, _serieLevel: true, _serieData: sd, _torrentIdx: (sd.torrents ?? []).indexOf(t) })
+    }
+    for (const season of sd.seasons ?? []) {
+        for (const t of season.torrents ?? []) {
+            result.push({ ...t, raw: t.title, type: 'pack_saison', serie_id: sd.id, serie_title: sd.title, season_id: season.id, season_number: season.season_number, _seasonLevel: true, _season: season, _torrentIdx: (season.torrents ?? []).indexOf(t) })
+        }
+        for (const ep of season.episodes ?? []) {
+            for (const t of ep.torrents ?? []) {
+                result.push({ ...t, raw: t.title, type: 'episode', serie_id: sd.id, serie_title: sd.title, season_id: season.id, season_number: season.season_number, episode_id: ep.id, episode_number: ep.episode_number, _episodeLevel: true, _episode: ep, _torrentIdx: (ep.torrents ?? []).indexOf(t) })
+            }
+        }
+    }
+    return result
+}
+
+export function buildResolvedEpisodes(sd: any, hash: string, seasonFilter?: number): any[] {
+    const resolved: any[] = []
+    const h = hash.toLowerCase()
+    for (const season of sd.seasons ?? []) {
+        if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
+        for (const ep of season.episodes ?? []) {
+            const paths: any[] = ep.paths ?? []
+            let filePath: string | null = null
+            for (const p of paths) {
+                if (typeof p === 'string') { if (!filePath) filePath = p.replace(/\\/g, '/') }
+                else if (p?.infohash?.toLowerCase() === h) { filePath = p.path.replace(/\\/g, '/'); break }
+            }
+            if (!filePath) continue
+            const filename = filePath.split('/').pop() ?? filePath
+            resolved.push({ episode_id: ep.id, episode_number: ep.episode_number, season_number: season.season_number, season_id: season.id, filename, original_filename: filename })
+        }
+    }
+    return resolved
+}
+
+export function computeSerieDownloadState(serieData: any | null, organized: Record<string, Record<string, any>>, activeTorrents: Set<string>): 'none' | 'downloading' | 'partial' | 'complete' {
+    if (!serieData) return 'none'
+    const allTorrents = extractTorrentsFromSerieData(serieData)
+
+    if (allTorrents.some(t => t.infohash && activeTorrents.has(t.infohash.toLowerCase()))) return 'downloading'
+
+    const allEpisodeIds = new Set<number>()
+    for (const season of serieData.seasons ?? []) {
+        for (const ep of season.episodes ?? []) {
+            allEpisodeIds.add(ep.id)
+        }
+    }
+
+    const organizedEpisodeIds = new Set<number>()
+
+    for (const t of allTorrents) {
+        const hash = t.infohash?.toLowerCase()
+        if (!hash) continue
+        const orgFiles = organized[hash] ?? {}
+        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)
+        }
+    }
+
+    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 (allEpisodeIds.size === 0 || organizedEpisodeIds.size === 0) return 'none'
+    if (organizedEpisodeIds.size >= allEpisodeIds.size) return 'complete'
+    return 'partial'
+}
@@ -9,6 +9,7 @@ import fsp  from 'fs/promises'
 import path from 'path'
 import { parentPort } from 'worker_threads'
 import { DATA_DIR } from './config.js'
+import { getGitlabTitle } from './gitlab-map.js'

 const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')

@@ -170,23 +171,6 @@ function isInExcludedFolder(filePath: string[]): boolean {
    return false
 }

-// ─── Map titres API → GitLab ──────────────────────────────────
-const SERIE_TITLE_GITLAB_MAP: Record<string, string> = {
-    'Enfer Et Paradis Henshū'          : 'Enfer et Paradis Henshū',
-    'Hajime No Ippo Henshū'            : 'Hajime no Ippo Henshū',
-    'Hikaru No Go Henshū'              : 'Hikaru no Go Henshū',
-    'Hokuto No Ken Kaï'                : 'Hokuto no Ken Kaï',
-    'Kaguya-sama : Love is War Henshū' : 'Kaguya-sama - Love is War Henshū',
-    'Kenshin le Vagabond Henshū'       : 'Kenshin le vagabond Henshū',
-    'Kuroko No Basket Henshū'          : 'Kuroko no Basket Henshū',
-    'Shingeki No Kyojin Henshū'        : 'Shingeki no Kyojin Henshū',
-    'Tower Of God Henshū'              : 'Tower of God Henshū',
-}
-
-function getGitlabSerieTitle(serieTitle: string): string {
-    return SERIE_TITLE_GITLAB_MAP[serieTitle] ?? serieTitle
-}
-
 // ─── GitLab NFO downloader ────────────────────────────────────
 const GITLAB_API      = 'https://gitlab.com/api/v4/projects/ElPouki%2Ffankai_pack/repository'
 const GITLAB_RAW_BASE = 'https://gitlab.com/ElPouki/fankai_pack/-/raw/main/pack'
@@ -206,7 +190,7 @@ async function fetchBinary(url: string): Promise<Buffer> {
 }

 async function downloadGitlabFolder(serieTitle: string, destRoot: string): Promise<void> {
-    const gitlabTitle = getGitlabSerieTitle(serieTitle)
+    const gitlabTitle = getGitlabTitle(serieTitle)
    const folderPath  = `pack/${gitlabTitle}`
    log(`Téléchargement NFO/images depuis GitLab pour "${gitlabTitle}"`)

@@ -346,7 +330,9 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser

        if (!fs.existsSync(dest)) {
            fs.mkdirSync(destDir, { recursive: true })
-            if (organizeMode === 'hardlink') {
+            if (organizeMode === 'copy') {
+              await  fsp.copyFile(src, dest)
+            } else if (organizeMode === 'hardlink') {
                if (!tryHardlink(src, dest)) await fsp.copyFile(src, dest)
            } else {
                await fsp.copyFile(src, dest)
@@ -414,7 +400,9 @@ async function organizeTorrent(hash: string, name: string, savePath: string, ser

        try {
            fs.mkdirSync(destDir, { recursive: true })
-            if (organizeMode === 'hardlink') {
+            if (organizeMode === 'copy') {
+                await  fsp.copyFile(src, dest)
+            } else if (organizeMode === 'hardlink') {
                if (!tryHardlink(src, dest)) await fsp.copyFile(src, dest)
                markOrganized(hash, episode_id, {
                    at: new Date().toISOString(), season: season_number,
@@ -64,7 +64,8 @@ export async function scanMediaPath(

    logger.info('organize', `Scan de la médiathèque : ${mediaPath}`)

-    // Map : nom_sur_disque → { hash, srcFilename, episodeId, season, episode }
+    // Map : nom_sans_extension → { hash, srcFilename, episodeId, season, episode }
+    // On indexe par nom sans extension pour matcher quelle que soit l'extension sur le disque
    const filenameIndex = new Map<string, {
        hash        : string
        srcFilename : string
@@ -77,43 +78,38 @@ export async function scanMediaPath(
    for (const sd of seriesData) {
        for (const season of sd.seasons ?? []) {
            for (const ep of season.episodes ?? []) {
-                for (const p of ep.paths ?? []) {
-                    if (typeof p === 'string') continue
-                    const hash = p.infohash?.toLowerCase()
-                    if (!hash || !p.path) continue

-                    const srcFilename = p.path.replace(/\\/g, '/').split('/').pop()
-                    if (!srcFilename) continue
-
-                    const srcExt = path.extname(srcFilename)
-                    const entry = {
+                // Helper : indexer par nom sans extension
+                const idx = (filename: string, hash: string, destFilename?: string) => {
+                    const base = filename.replace(/\.[^.]+$/, '')
+                    if (!base) return
+                    filenameIndex.set(base, {
                        hash,
-                        srcFilename,
+                        srcFilename : filename,
                        episodeId   : ep.id,
                        season      : season.season_number,
                        episode     : ep.episode_number,
-                        destFilename: srcFilename,
-                    }
+                        destFilename: destFilename ?? filename,
+                    })
+                }

-                    // 1. Nom brut source
-                    filenameIndex.set(srcFilename, entry)
+                // 1. Noms depuis les paths (avec vrai infohash)
+                for (const p of ep.paths ?? []) {
+                    if (typeof p !== 'object' || !p.infohash || !p.path) continue
+                    const hash        = p.infohash.toLowerCase()
+                    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)
+                }

-                    // 2. nfo_filename avec extension swappée
-                    if (ep.nfo_filename) {
-                        const nfoRenamed = swapExt(ep.nfo_filename, srcExt)
-                        filenameIndex.set(nfoRenamed, { ...entry, destFilename: nfoRenamed })
-                    }
-
-                    // 3. original_filename
-                    if (ep.original_filename) {
-                        filenameIndex.set(ep.original_filename, { ...entry, destFilename: ep.original_filename })
-                    }
-
-                    // 4. formatted_name + .mkv
-                    if (ep.formatted_name?.trim()) {
-                        const fmtName = ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim() + '.mkv'
-                        filenameIndex.set(fmtName, { ...entry, destFilename: fmtName })
-                    }
+                // 2. original_filename, nfo_filename et formatted_name — indexés même si paths est vide
+                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)
+                if (ep.formatted_name?.trim()) {
+                    const fmtBase = ep.formatted_name.replace(/[<>:"/\\|?*]/g, '').trim()
+                    idx(fmtBase, fallbackHash, fmtBase)
                }
            }
        }
@@ -127,6 +123,7 @@ export async function scanMediaPath(

    // Track les paires hash:episodeId présentes
    const presentFiles = new Set<string>()
+    let noMatch = 0

    function walk(dir: string) {
        let entries: fs.Dirent[]
@@ -136,12 +133,33 @@ export async function scanMediaPath(
            const full = path.join(dir, entry.name)
            if (entry.isDirectory()) {
                walk(full)
-            } else if (entry.isFile() && entry.name.endsWith('.mkv')) {
+            } else if (entry.isFile() && /\.(mkv|mp4|avi|m4v|mov|wmv)$/i.test(entry.name)) {
                result.found++
-                const match = filenameIndex.get(entry.name)
-                if (!match) continue
+                const nameWithoutExt = entry.name.replace(/\.[^.]+$/, '')
+                let match = filenameIndex.get(nameWithoutExt)

-                const { hash, srcFilename, episodeId, season, episode, destFilename } = match
+                // Fallback : chercher si un candidat de l'index est un préfixe du nom du fichier
+                // ex: index a "Wind Breaker.S01E01.MULTI.1080p" et le fichier est "Wind Breaker.S01E01.MULTI.1080p.x264-FANKAI"
+                if (!match) {
+                    const lower = nameWithoutExt.toLowerCase()
+                    for (const [key, val] of filenameIndex.entries()) {
+                        if (lower.startsWith(key.toLowerCase() + '.') || lower === key.toLowerCase()) {
+                            match = val
+                            break
+                        }
+                    }
+                }
+
+                if (!match) {
+                    noMatch++
+                    const prefix    = nameWithoutExt.slice(0, 20).toLowerCase()
+                    const close     = [...filenameIndex.keys()].filter(k => k.toLowerCase().startsWith(prefix)).slice(0, 3)
+                    const closeStr  = close.length > 0 ? ` | candidats : ${close.map(c => `"${c}"`).join(', ')}` : ' | aucun candidat proche'
+                    logger.warn('organize', `Scan no match : "${nameWithoutExt}"${closeStr}`)
+                    continue
+                }
+
+                const { hash, srcFilename, episodeId, season, episode } = match
                presentFiles.add(`${hash}:${episodeId}`)

                if (organized[hash]?.[String(episodeId)]) continue
@@ -153,7 +171,7 @@ export async function scanMediaPath(
                    episode,
                    episode_id   : episodeId,
                    src_filename : srcFilename,
-                    dest_filename: destFilename,
+                    dest_filename: entry.name,   // vrai nom sur disque
                    dest_path    : full,
                }
                result.added++
@@ -178,13 +196,29 @@ export async function scanMediaPath(
        if (Object.keys(organized[hash]).length === 0) delete organized[hash]
    }

-    if (result.added > 0 || removed > 0) {
-        fs.writeFileSync(organizedPath, JSON.stringify(organized, null, 2), 'utf-8')
-        logger.info('organize', `Scan terminé — ${result.found} fichiers, ${result.added} ajoutés, ${removed} orphelins supprimés`)
-    } else {
-        logger.info('organize', `Scan terminé — ${result.found} fichiers, rien de nouveau`)
+    // Désimport automatique des fichiers manquants sur le disque
+    const { autoUnimportMissing } = readSettings() as any
+    let autoRemoved = 0
+    if (autoUnimportMissing) {
+        for (const [hash, episodes] of Object.entries(organized)) {
+            for (const [episodeId, entry] of Object.entries(episodes as Record<string, any>)) {
+                const destPath = entry?.dest_path
+                if (destPath && !fs.existsSync(destPath)) {
+                    delete (organized[hash] as any)[episodeId]
+                    autoRemoved++
+                    logger.info('organize', `Désimport auto : fichier introuvable "${destPath}"`)
+                }
+            }
+            if (Object.keys(organized[hash]).length === 0) delete organized[hash]
+        }
    }

+    if (result.added > 0 || removed > 0 || autoRemoved > 0) {
+        fs.writeFileSync(organizedPath, JSON.stringify(organized, null, 2), 'utf-8')
+    }
+
+    logger.info('organize', `Scan terminé — ${result.found} fichiers, ${result.added} ajoutés, ${removed} orphelins supprimés${autoRemoved > 0 ? `, ${autoRemoved} désimportés auto (fichier manquant)` : ''}${noMatch > 0 ? `, ${noMatch} non matchés` : ''}`)
+
    return result
 }

@@ -0,0 +1,67 @@
+import { Router } from 'express'
+import path from 'path'
+import fs from 'fs'
+import { requireAuth } from '../auth.js'
+import { logger } from '../logger.js'
+import { DATA_DIR } from '../config.js'
+import { readSettings } from '../settings.js'
+import { dispatchDownload, dispatchList, dispatchRemove } from '../torrent-clients/index.js'
+import { readAvailable, readInfohashMap, readSerieData } from '../lib/github-cache.js'
+import { extractTorrentsFromSerieData, buildResolvedEpisodes } from '../lib/serie-helpers.js'
+import { recentOrganized } from '../lib/notifs.js'
+
+const router = Router()
+
+router.post('/download', requireAuth, async (req, res) => {
+    const url = req.body.magnet ?? req.body.torrent_url
+    if (!url) { res.status(400).json({ error: 'torrent_url ou magnet requis' }); return }
+    logger.info('api', 'Téléchargement demandé')
+    const results = await dispatchDownload(url)
+    res.status(results.every((r: any) => r.ok) ? 200 : 207).json({ results })
+})
+
+router.delete('/torrent/:hash', requireAuth, async (req, res) => {
+    const hash        = String(req.params.hash)
+    const deleteFiles = req.query.deleteFiles === 'true'
+    if (!hash) { res.status(400).json({ error: 'hash requis' }); return }
+    try {
+        const result = await dispatchRemove(hash, deleteFiles)
+        res.json(result)
+    } catch (err) {
+        logger.error('api', `Suppression torrent échouée : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+router.get('/downloads', requireAuth, async (_req, res) => {
+    try {
+        const { category } = readSettings()
+        const infohashMap = await readInfohashMap()
+        const torrents = await dispatchList(category ?? 'fankai', infohashMap)
+        let organized: Record<string, Record<string, any>> = {}
+        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
+        const enriched = await Promise.all(torrents.map(async (t: any) => {
+            const orgFiles = organized[t.hash] ?? {}
+            let totalFiles = 1
+            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 }
+                }
+            } 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 ?? [] }
+        }))
+        res.json(enriched)
+    } catch (err) {
+        logger.error('api', `GET /api/downloads échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+export default router
@@ -0,0 +1,354 @@
+import { Router } from 'express'
+import path from 'path'
+import fs from 'fs'
+import { requireAuth } from '../auth.js'
+import { logger } from '../logger.js'
+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 { GITLAB_API_NFO, GITLAB_RAW_NFO } from '../lib/nfo.js'
+
+const router = Router()
+
+const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
+
+function loadOrganizedJson(): Record<string, Record<string, any>> {
+    try { if (fs.existsSync(ORGANIZED_PATH)) return JSON.parse(fs.readFileSync(ORGANIZED_PATH, 'utf-8')) } catch {}
+    return {}
+}
+
+function saveOrganizedJson(data: Record<string, Record<string, any>>) {
+    fs.writeFileSync(ORGANIZED_PATH, JSON.stringify(data, null, 2), 'utf-8')
+}
+
+// ── Import manuel ──────────────────────────────────────────────
+router.post('/manual-import', requireAuth, async (req, res) => {
+    const { serie_id, items } = req.body
+    if (!serie_id || !Array.isArray(items) || items.length === 0) {
+        res.status(400).json({ error: 'serie_id et items requis' }); return
+    }
+    const { mediaPath, organizeMode, nfoSupport } = readSettings()
+    const organized = loadOrganizedJson()
+    const sd = await readSerieData(Number(serie_id))
+    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()
+    const episodeIndex = new Map<number, { ep: any; season: any }>()
+    for (const season of sd.seasons ?? []) {
+        for (const ep of season.episodes ?? []) {
+            episodeIndex.set(ep.id, { ep, season })
+        }
+    }
+    const done: number[] = []
+    const errors: { file: string; error: string }[] = []
+    for (const item of items) {
+        const { file_path, episode_id, hash } = item
+        if (!file_path || !episode_id) { errors.push({ file: file_path ?? '?', error: 'Paramètres manquants' }); continue }
+        const found = episodeIndex.get(Number(episode_id))
+        if (!found) { errors.push({ file: file_path, error: `Épisode ${episode_id} introuvable` }); continue }
+        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 resolvedName  = nfoSupport
+            ? (ep.nfo_filename ?? ep.original_filename ?? srcFilename)
+            : (fmtName ?? ep.nfo_filename ?? ep.original_filename ?? srcFilename)
+        const resolvedExt  = path.extname(resolvedName)
+        const destFilename = resolvedExt && resolvedExt !== srcExt
+            ? resolvedName.slice(0, -resolvedExt.length) + srcExt
+            : resolvedName
+        const seasonFolder  = season.season_number === 0 ? 'Specials' : `Saison ${season.season_number}`
+        const destDir       = path.join(mediaPath, serieTitle, seasonFolder)
+        const destPath      = path.join(destDir, destFilename)
+        try {
+            if (!fs.existsSync(file_path)) throw new Error('Fichier source introuvable')
+            fs.mkdirSync(destDir, { recursive: true })
+            if (file_path !== destPath) {
+                const serieRootPath  = path.join(mediaPath, serieTitle)
+                const isInSeriePath  = file_path.startsWith(serieRootPath + path.sep) || file_path.startsWith(serieRootPath + '/')
+                if (isInSeriePath && !fs.existsSync(destPath)) {
+                    fs.renameSync(file_path, destPath)
+                    logger.info('api', `Import manuel (rename) : "${srcFilename}" → "${destFilename}"`)
+                } else if (!isInSeriePath && !fs.existsSync(destPath)) {
+                    if (organizeMode === 'hardlink') {
+                        try { fs.linkSync(file_path, destPath) }
+                        catch { await fs.promises.copyFile(file_path, destPath) }
+                    } else if (organizeMode === 'move') {
+                        try { fs.renameSync(file_path, destPath) }
+                        catch { await fs.promises.copyFile(file_path, destPath); await fs.promises.unlink(file_path) }
+                    } else {
+                        await fs.promises.copyFile(file_path, destPath)
+                    }
+                    logger.info('api', `Import manuel : "${srcFilename}" → "${destPath}"`)
+                }
+            } else {
+                logger.debug('api', `Import manuel : "${srcFilename}" déjà en place`)
+            }
+            const torrentHash = String(hash || '').toLowerCase() || 'manual'
+            if (!organized[torrentHash]) organized[torrentHash] = {}
+            organized[torrentHash][String(episode_id)] = {
+                at: new Date().toISOString(), season: season.season_number,
+                episode: ep.episode_number, episode_id: ep.id,
+                src_filename: srcFilename, dest_filename: destFilename, dest_path: destPath,
+            }
+            done.push(episode_id)
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+            errors.push({ file: srcFilename, error: msg })
+            logger.error('api', `Import manuel échoué pour "${srcFilename}" : ${msg}`)
+        }
+    }
+    saveOrganizedJson(organized)
+
+    if (nfoSupport && done.length > 0) {
+        const gitlabTitle = getGitlabTitle(serieTitle)
+        ;(async () => {
+            try {
+                let files: any[] = [], page = 1
+                while (true) {
+                    const batch = await fetch(`${GITLAB_API_NFO}/tree?path=${encodeURIComponent('pack/' + gitlabTitle)}&recursive=true&per_page=100&page=${page}&ref=main`, { headers: { 'User-Agent': 'fankarr' } }).then(r => r.ok ? r.json() : [])
+                    if (!Array.isArray(batch) || batch.length === 0) break
+                    files.push(...batch); if (batch.length < 100) break; page++
+                }
+                for (const entry of files.filter((f: any) => f.type === 'blob')) {
+                    const rel  = entry.path.replace(`pack/${gitlabTitle}/`, '')
+                    const dest = path.join(mediaPath, serieTitle, rel)
+                    if (fs.existsSync(dest)) continue
+                    const raw  = await fetch(`${GITLAB_RAW_NFO}/${encodeURIComponent(gitlabTitle)}/${rel.split('/').map(encodeURIComponent).join('/')}`, { headers: { 'User-Agent': 'fankarr' } })
+                    if (!raw.ok) continue
+                    fs.mkdirSync(path.dirname(dest), { recursive: true })
+                    fs.writeFileSync(dest, Buffer.from(await raw.arrayBuffer()))
+                }
+                logger.info('api', `NFO téléchargés pour "${gitlabTitle}" (import manuel)`)
+            } catch (err) {
+                logger.warn('api', `Échec téléchargement NFO pour "${gitlabTitle}" : ${err instanceof Error ? err.message : err}`)
+            }
+        })()
+    }
+
+    res.json({ ok: true, done: done.length, errors })
+})
+
+// ── Récap organisés d'une série ────────────────────────────────
+router.get('/organized/:serieId', requireAuth, async (req, res) => {
+    const serieId = Number(req.params.serieId)
+    try {
+        const sd = await readSerieData(serieId)
+        if (!sd) { res.status(404).json({ error: 'Série introuvable' }); return }
+        const organized = loadOrganizedJson()
+        const result: Record<string, any> = {}
+        for (const season of sd.seasons ?? []) {
+            for (const ep of season.episodes ?? []) {
+                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 }
+                }
+                if (!result[String(ep.id)] && organized['manual']?.[String(ep.id)]) {
+                    result[String(ep.id)] = organized['manual'][String(ep.id)]
+                }
+            }
+        }
+        res.json(result)
+    } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+// ── Rename épisode ─────────────────────────────────────────────
+router.post('/rename-episode', requireAuth, async (req, res) => {
+    const { serie_id, episode_id, torrent_hash } = req.body
+    if (!serie_id || !episode_id) { res.status(400).json({ error: 'serie_id et episode_id requis' }); return }
+    const { nfoSupport } = readSettings()
+    const organized = loadOrganizedJson()
+    const sd = await readSerieData(Number(serie_id))
+    if (!sd) { res.status(404).json({ error: 'Série introuvable' }); return }
+    let foundEp: any = null
+    for (const season of sd.seasons ?? []) {
+        for (const ep of season.episodes ?? []) {
+            if (ep.id === Number(episode_id)) { foundEp = { ep, season }; break }
+        }
+        if (foundEp) break
+    }
+    if (!foundEp) { res.status(404).json({ error: 'Épisode introuvable' }); return }
+    const { ep, season } = foundEp
+    const hash = torrent_hash?.toLowerCase() ?? 'manual'
+    const orgEntry = organized[hash]?.[String(episode_id)] ?? organized['manual']?.[String(episode_id)]
+    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 oldPath = orgEntry.dest_path
+    const newPath = path.join(path.dirname(oldPath), newName)
+    try {
+        if (!fs.existsSync(oldPath)) throw new Error('Fichier source introuvable sur le disque')
+        if (fs.existsSync(newPath)) throw new Error(`Un fichier avec ce nom existe déjà : ${newName}`)
+        fs.renameSync(oldPath, newPath)
+        const entryHash = organized[hash]?.[String(episode_id)] ? hash : 'manual'
+        organized[entryHash][String(episode_id)] = { ...orgEntry, dest_filename: newName, dest_path: newPath, at: new Date().toISOString() }
+        saveOrganizedJson(organized)
+        logger.info('api', `Rename : "${orgEntry.dest_filename}" → "${newName}"`)
+        res.json({ ok: true, renamed: true, old_name: orgEntry.dest_filename, new_name: newName })
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+        logger.error('api', `Rename échoué pour ep ${episode_id} : ${msg}`)
+        res.status(500).json({ error: msg })
+    }
+})
+
+// ── Désimport série complète ───────────────────────────────────
+router.delete('/organized/:serieId', requireAuth, async (req, res) => {
+    const serieId    = String(req.params.serieId)
+    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 episodeIds = new Set<string>()
+    for (const season of sd.seasons ?? []) {
+        for (const ep of season.episodes ?? []) episodeIds.add(String(ep.id))
+    }
+    let removed = 0
+    const errors: 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]
+    }
+    saveOrganizedJson(organized)
+    logger.info('api', `Désimport série ${serieId} — ${removed} épisode(s) retirés`)
+    res.json({ ok: true, removed, errors })
+})
+
+// ── Désimport épisode ──────────────────────────────────────────
+router.delete('/organized/:serieId/:episodeId', requireAuth, async (req, res) => {
+    const episodeId  = String(req.params.episodeId)
+    const deleteFile = req.query.deleteFile === 'true'
+    const organized  = loadOrganizedJson()
+    let foundHash: string | null = null
+    let foundEntry: any = null
+    for (const [hash, episodes] of Object.entries(organized)) {
+        if (episodes[episodeId]) { foundHash = hash; foundEntry = episodes[episodeId]; break }
+    }
+    if (!foundHash || !foundEntry) { res.status(404).json({ error: 'Épisode non importé' }); return }
+    try {
+        if (deleteFile && foundEntry.dest_path && fs.existsSync(foundEntry.dest_path)) {
+            fs.unlinkSync(foundEntry.dest_path)
+            logger.info('api', `Désimport + suppression fichier : "${foundEntry.dest_path}"`)
+        }
+        delete organized[foundHash][episodeId]
+        if (Object.keys(organized[foundHash]).length === 0) delete organized[foundHash]
+        saveOrganizedJson(organized)
+        logger.info('api', `Désimport ep ${episodeId}`)
+        res.json({ ok: true })
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+        logger.error('api', `Désimport échoué : ${msg}`)
+        res.status(500).json({ error: msg })
+    }
+})
+
+// ── Récap global des imports ───────────────────────────────────
+router.get('/organized-summary', requireAuth, async (_req, res) => {
+    try {
+        const { nfoSupport } = readSettings()
+        const organized  = loadOrganizedJson()
+        const seriesData = await loadEnrichedSeriesData()
+        const result: any[] = []
+        for (const sd of seriesData) {
+            const rawTitle   = sd.title ?? sd.show_title ?? ''
+            const serieTitle = rawTitle.replace(/:/g, ' -').replace(/[<>"/\\|?*]/g, '').replace(/\s+/g, ' ').trim()
+            const episodes: any[] = []
+            for (const season of sd.seasons ?? []) {
+                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 }
+                    }
+                    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
+                    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 })
+                }
+            }
+            if (episodes.length > 0) {
+                result.push({ serie_id: sd.id, serie_title: rawTitle, serie_title_clean: serieTitle, total: episodes.length, needs_rename: episodes.filter(e => e.needs_rename).length, episodes })
+            }
+        }
+        res.json({ series: result, nfo_support: nfoSupport })
+    } catch (err) {
+        logger.error('api', `organized-summary échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+// ── Rename en masse ────────────────────────────────────────────
+router.post('/rename-all', requireAuth, async (req, res) => {
+    const { serie_id } = req.body
+    const { nfoSupport } = readSettings()
+    const organized  = loadOrganizedJson()
+    const seriesData = await loadEnrichedSeriesData()
+    const done: number[] = []
+    const errors: { episode_id: number; error: string }[] = []
+    for (const sd of seriesData) {
+        if (serie_id && sd.id !== Number(serie_id)) continue
+        for (const season of sd.seasons ?? []) {
+            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 }
+                }
+                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 oldPath = orgEntry.dest_path
+                const newPath = path.join(path.dirname(oldPath), expectedName)
+                try {
+                    if (!fs.existsSync(oldPath)) { errors.push({ episode_id: ep.id, error: 'Fichier introuvable' }); continue }
+                    if (fs.existsSync(newPath)) { errors.push({ episode_id: ep.id, error: `Fichier existant : ${expectedName}` }); continue }
+                    fs.renameSync(oldPath, newPath)
+                    organized[orgHash][String(ep.id)] = { ...orgEntry, dest_filename: expectedName, dest_path: newPath, at: new Date().toISOString() }
+                    done.push(ep.id)
+                    logger.info('api', `Rename masse : "${currentName}" → "${expectedName}"`)
+                } catch (err) {
+                    errors.push({ episode_id: ep.id, error: err instanceof Error ? err.message : 'Erreur' })
+                }
+            }
+        }
+    }
+    saveOrganizedJson(organized)
+    res.json({ ok: true, done: done.length, errors })
+})
+
+export default router
@@ -0,0 +1,18 @@
+import { Router } from 'express'
+import { requireAuth } from '../auth.js'
+import { logger } from '../logger.js'
+import { checkNfoUpdates, recentNfoUpdates } from '../lib/nfo.js'
+
+const router = Router()
+
+router.get('/nfo-updates/recent', requireAuth, (_req, res) => {
+    res.json(recentNfoUpdates)
+})
+
+router.post('/nfo-updates/check', requireAuth, async (_req, res) => {
+    logger.info('nfo-update', 'Vérification manuelle des MAJ NFO lancée')
+    checkNfoUpdates().catch(err => logger.error('nfo-update', `Vérif manuelle échouée : ${err instanceof Error ? err.message : err}`))
+    res.json({ ok: true, message: 'Vérification lancée en arrière-plan' })
+})
+
+export default router
@@ -0,0 +1,36 @@
+import { Router } from 'express'
+import { requireAuth } from '../auth.js'
+import { logger } from '../logger.js'
+import { organizeTorrent } from '../organize.js'
+import { loadEnrichedSeriesData } from '../lib/github-cache.js'
+import { recentOrganized, pushNotif } from '../lib/notifs.js'
+
+const router = Router()
+
+router.get('/organize/recent', requireAuth, (_req, res) => {
+    res.json(recentOrganized)
+})
+
+router.post('/organize/recent/clear', requireAuth, (_req, res) => {
+    recentOrganized.length = 0
+    logger.info('api', 'Historique des imports effacé')
+    res.json({ ok: true })
+})
+
+router.post('/organize', requireAuth, async (req, res) => {
+    const { hash, name, save_path } = req.body
+    if (!hash || !name || !save_path) { res.status(400).json({ error: 'hash, name et save_path requis' }); return }
+    try {
+        const seriesData = await loadEnrichedSeriesData()
+        const result     = await organizeTorrent(hash, name, save_path, seriesData)
+        if (result.done > 0 || result.errors.length > 0) {
+            pushNotif({ hash, name, done: result.done, skipped: result.skipped, errors: result.errors.length, errorFiles: result.errors, at: new Date().toISOString() })
+        }
+        res.json(result)
+    } catch (err) {
+        logger.error('api', `Import manuel de "${name}" échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+export default router
@@ -0,0 +1,169 @@
+import { Router } from 'express'
+import { requireAuth } from '../auth.js'
+import { logger } from '../logger.js'
+
+const router = Router()
+
+const PLEX_TV_API = 'https://plex.tv/api/v2'
+
+async function plexFetch(url: string, options: RequestInit = {}): Promise<any> {
+    const res = await fetch(url, {
+        ...options,
+        headers: {
+            'Accept'                  : 'application/json',
+            'X-Plex-Client-Identifier': 'fankarr',
+            'X-Plex-Product'          : 'FanKarr',
+            'X-Plex-Version'          : '1.0',
+            ...(options.headers ?? {}),
+        },
+    })
+    if (!res.ok) throw new Error(`Plex ${res.status}: ${await res.text()}`)
+    const text = await res.text()
+    return text ? JSON.parse(text) : {}
+}
+
+function mapServers(resources: any[]) {
+    return (Array.isArray(resources) ? resources : [])
+        .filter((r: any) => r.product === 'Plex Media Server')
+        .map((r: any) => ({
+            name       : r.name,
+            owned      : r.owned,
+            connections: (r.connections ?? []).map((c: any) => ({ uri: c.uri, local: c.local, relay: c.relay })),
+        }))
+}
+
+// POST /api/plex/connect — auth plex.tv + liste serveurs
+router.post('/plex/connect', requireAuth, async (req, res) => {
+    const { username, password, code } = req.body
+    if (!username || !password) { res.status(400).json({ error: 'Email et mot de passe requis' }); return }
+    try {
+        const params = new URLSearchParams({ login: username, password })
+        if (code) params.set('verificationCode', code)
+        const authData = await plexFetch(`${PLEX_TV_API}/users/signin`, {
+            method : 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body   : params.toString(),
+        })
+        const token = authData.authToken ?? authData.user?.authToken
+        if (!token) throw new Error('Token non reçu')
+        const resources = await plexFetch('https://plex.tv/api/v2/resources?includeHttps=1&includeRelay=1&includeIPv6=1', { headers: { 'X-Plex-Token': token } })
+        const servers = mapServers(resources)
+        logger.info('plex', `Auth réussie pour ${username} — ${servers.length} serveur(s)`)
+        res.json({ ok: true, token, servers })
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+        if (msg.includes('401')) {
+            res.status(401).json({ error: '2FA requis ou identifiants incorrects', requires2FA: true })
+        } else {
+            logger.error('plex', `Auth échouée : ${msg}`)
+            res.status(401).json({ error: 'Authentification échouée — vérifiez vos identifiants' })
+        }
+    }
+})
+
+// POST /api/plex/oauth/start — démarre le flow OAuth
+router.post('/plex/oauth/start', requireAuth, async (_req, res) => {
+    try {
+        const data = await plexFetch(`${PLEX_TV_API}/pins`, {
+            method : 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body   : new URLSearchParams({ strong: 'true', 'X-Plex-Client-Identifier': 'fankarr' }).toString(),
+        })
+        const pinId   = data.id
+        const pinCode = data.code
+        if (!pinId || !pinCode) throw new Error('Pin non reçu')
+        const authUrl = `https://app.plex.tv/auth#?clientID=fankarr&code=${pinCode}&context%5Bdevice%5D%5Bproduct%5D=FanKarr&forwardUrl=https%3A%2F%2Fplex.tv`
+        logger.info('plex', `OAuth démarré — pinId ${pinId}`)
+        res.json({ ok: true, pinId, pinCode, authUrl })
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur'
+        logger.error('plex', `OAuth start échoué : ${msg}`)
+        res.status(500).json({ error: msg })
+    }
+})
+
+// GET /api/plex/oauth/poll/:pinId — vérifie si l'OAuth est complété
+router.get('/plex/oauth/poll/:pinId', requireAuth, async (req, res) => {
+    const pinId = String(req.params.pinId)
+    try {
+        const data = await plexFetch(`${PLEX_TV_API}/pins/${pinId}?X-Plex-Client-Identifier=fankarr`)
+        const token = data.authToken
+        if (!token) { res.json({ ok: false, pending: true }); return }
+        const resources = await plexFetch('https://plex.tv/api/v2/resources?includeHttps=1&includeRelay=1&includeIPv6=1', { headers: { 'X-Plex-Token': token } })
+        const servers = mapServers(resources)
+        logger.info('plex', `OAuth complété — ${servers.length} serveur(s)`)
+        res.json({ ok: true, pending: false, token, servers })
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur'
+        res.status(500).json({ error: msg })
+    }
+})
+
+// POST /api/plex/setup — enregistre l'agent Fankai + crée la bibliothèque
+router.post('/plex/setup', requireAuth, async (req, res) => {
+    const { token, serverUrl, libraryName, libraryPath } = req.body
+    if (!token || !serverUrl || !libraryName || !libraryPath) {
+        res.status(400).json({ error: 'token, serverUrl, libraryName, libraryPath requis' }); return
+    }
+    const headers: Record<string, string> = { 'X-Plex-Token': token, 'Accept': 'application/json' }
+    const TARGET_AGENT_URI = 'https://metadata.fankai.fr/plex'
+    const steps: { step: string; ok: boolean; message: string }[] = []
+    let agentIdentifier = 'tv.plex.agents.custom.fankai'
+    let groupId: string | null = null
+    let agentSetupOk = false
+
+    // ── Étape 1 : Enregistrer le provider Fankai ─────────────
+    try {
+        const providersRes = await fetch(`${serverUrl}/media/providers/metadata`, { headers })
+        if (providersRes.ok) {
+            const data = await providersRes.json()
+            const providers: any[] = data?.MediaContainer?.MetadataAgentProvider ?? []
+            let provider = providers.find((p: any) => p.uri === TARGET_AGENT_URI)
+            if (!provider) {
+                const r = await fetch(`${serverUrl}/media/providers/metadata?uri=${encodeURIComponent(TARGET_AGENT_URI)}`, { method: 'POST', headers })
+                if (r.ok) provider = (await r.json())?.MediaContainer?.MetadataAgentProvider?.[0]
+            }
+            if (provider) {
+                agentIdentifier = provider.identifier ?? agentIdentifier
+                steps.push({ step: 'provider', ok: true, message: `Provider enregistré (${agentIdentifier})` })
+            }
+            const groupsRes = await fetch(`${serverUrl}/media/providers/metadata/group`, { headers })
+            if (groupsRes.ok) {
+                const gdata = await groupsRes.json()
+                const groups: any[] = gdata?.MediaContainer?.MetadataAgentProviderGroup ?? []
+                let group = groups.find((g: any) => g.primaryIdentifier === agentIdentifier)
+                if (!group) {
+                    const r = await fetch(`${serverUrl}/media/providers/metadata/group?title=Fankai&primaryIdentifier=${encodeURIComponent(agentIdentifier)}`, { method: 'POST', headers })
+                    if (r.ok) group = (await r.json())?.MediaContainer?.MetadataAgentProviderGroup?.[0]
+                }
+                if (group) {
+                    groupId = String(group.id ?? '')
+                    steps.push({ step: 'group', ok: true, message: `Groupe d'agents créé (ID: ${groupId})` })
+                    agentSetupOk = true
+                }
+            }
+        }
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur'
+        steps.push({ step: 'agent', ok: false, message: `Agent non configuré (Plex < 1.43 ?) — setup manuel requis` })
+        logger.warn('plex', `Setup agent Fankai échoué : ${msg}`)
+    }
+
+    // ── Étape 2 : Créer la bibliothèque ──────────────────────
+    try {
+        const params = new URLSearchParams({ type: 'show', name: libraryName, agent: agentIdentifier, scanner: 'Plex TV Series', language: 'fr-FR', location: libraryPath })
+        if (groupId) params.set('metadataAgentProviderGroupId', groupId)
+        const libRes = await fetch(`${serverUrl}/library/sections?${params}`, { method: 'POST', headers })
+        if (!libRes.ok) throw new Error(`HTTP ${libRes.status}: ${await libRes.text()}`)
+        steps.push({ step: 'library', ok: true, message: `Bibliothèque "${libraryName}" créée` })
+        logger.info('plex', `Bibliothèque "${libraryName}" créée sur ${serverUrl}`)
+        res.json({ ok: true, agentSetupOk, steps, manualSetup: !agentSetupOk })
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Erreur'
+        steps.push({ step: 'library', ok: false, message: `Création bibliothèque échouée : ${msg}` })
+        logger.error('plex', `Création bibliothèque échouée : ${msg}`)
+        res.status(500).json({ ok: false, steps, error: msg })
+    }
+})
+
+export default router
@@ -0,0 +1,146 @@
+import { Router } from 'express'
+import path from 'path'
+import fs from 'fs'
+import { requireAuth } from '../auth.js'
+import { logger } from '../logger.js'
+import { DATA_DIR } from '../config.js'
+import { readSettings } from '../settings.js'
+import { dispatchList } from '../torrent-clients/index.js'
+import { readAvailable, readInfohashMap, readSerieData } from '../lib/github-cache.js'
+import {
+    fankaiGet, normalizeSerie, normalizeSeason, normalizeEpisode,
+    extractTorrentsFromSerieData, buildResolvedEpisodes, computeSerieDownloadState,
+} from '../lib/serie-helpers.js'
+
+const router = Router()
+
+router.get('/series', requireAuth, async (_req, res) => {
+    try {
+        const [apiData, availableIds] = await Promise.all([fankaiGet('/series'), readAvailable()])
+        const availableSet = new Set<number>(availableIds)
+        let organized: Record<string, Record<string, any>> = {}
+        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
+        const activeTorrents = 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 && t.state === 'downloading') activeTorrents.add(t.hash.toLowerCase()) } } catch {}
+        const seriesRaw = (Array.isArray(apiData) ? apiData : (apiData.series ?? [])).map(normalizeSerie)
+        const serieDataMap = new Map<number, any>()
+        await Promise.all(seriesRaw.filter((s: any) => availableSet.has(s.id)).map(async (s: any) => { const sd = await readSerieData(s.id); if (sd) serieDataMap.set(s.id, sd) }))
+        res.json({ series: seriesRaw.map((serie: any) => {
+            const serieData   = serieDataMap.get(serie.id) ?? null
+            const hasTorrents = serieData ? extractTorrentsFromSerieData(serieData).length > 0 : false
+            return { ...serie, torrent_count: serieData ? extractTorrentsFromSerieData(serieData).length : 0, has_torrents: hasTorrents, download_state: computeSerieDownloadState(serieData, organized, activeTorrents) }
+        })})
+    } catch (err) {
+        logger.error('api', `GET /api/series échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+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 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`)
+            const episodes = (Array.isArray(epsData) ? epsData : (epsData.episodes ?? [])).map(normalizeEpisode)
+            return { ...normalizeSeason(season), episodes }
+        }))
+        let organized: Record<string, Record<string, any>> = {}
+        try { const p = path.join(DATA_DIR, 'organized.json'); if (fs.existsSync(p)) organized = JSON.parse(fs.readFileSync(p, 'utf-8')) } catch {}
+
+        const availableEpisodeIds  = new Set<number>()
+        const episodeTorrentMap    : Record<number, any> = {}
+        const seasonTorrentMapBySn : Record<number, any> = {}
+        const integraleTorrents    : any[] = []
+        const organizedEpisodeIds  = new Set<number>()
+
+        const manualOrg = organized['manual'] ?? {}
+        if (serieData) {
+            for (const season of serieData.seasons ?? []) {
+                for (const ep of season.episodes ?? []) {
+                    if (manualOrg[String(ep.id)]) organizedEpisodeIds.add(ep.id)
+                }
+            }
+        }
+        if (serieData) {
+            for (const t of (serieData.torrents ?? [])) {
+                integraleTorrents.push({ ...t, raw: t.title })
+                const resolved = buildResolvedEpisodes(serieData, t.infohash)
+                for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
+                const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                for (const ep of resolved) {
+                    const isOrg = orgFiles[String(ep.episode_id)] !== undefined || orgFiles[ep.filename] !== undefined
+                    if (isOrg) organizedEpisodeIds.add(ep.episode_id)
+                }
+            }
+            for (const season of serieData.seasons ?? []) {
+                for (const t of (season.torrents ?? [])) {
+                    seasonTorrentMapBySn[season.season_number] = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'pack_saison', raw: t.title, manual: t.manual ?? false }
+                    const resolved = buildResolvedEpisodes(serieData, t.infohash, season.season_number)
+                    for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
+                    const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                    for (const ep of resolved) {
+                        const isOrg = orgFiles[String(ep.episode_id)] !== undefined || orgFiles[ep.filename] !== undefined
+                        if (isOrg) organizedEpisodeIds.add(ep.episode_id)
+                    }
+                }
+                for (const ep of season.episodes ?? []) {
+                    for (const t of (ep.torrents ?? [])) {
+                        episodeTorrentMap[ep.id] = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'episode', raw: t.title, manual: t.manual ?? false, fankai: t.fankai ?? true }
+                        availableEpisodeIds.add(ep.id)
+                        const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                        const isOrg = orgFiles[String(ep.id)] !== undefined
+                        if (!isOrg) {
+                            const match = (ep.paths ?? []).find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === t.infohash?.toLowerCase())
+                            const filename = match ? match.path.split('/').pop() : null
+                            if (filename && orgFiles[filename]) organizedEpisodeIds.add(ep.id)
+                        } else {
+                            organizedEpisodeIds.add(ep.id)
+                        }
+                    }
+                }
+            }
+        }
+
+        const enrichedSeasons = seasonsWithEpisodes.map((season: any) => {
+            const eps = season.episodes.map((ep: any) => {
+                const epTorrent = episodeTorrentMap[ep.id] ?? null
+                let fankai: boolean | null = epTorrent ? (epTorrent.fankai ?? true) : null
+                if (fankai === null && serieData) {
+                    outer: for (const sd_season of serieData.seasons ?? []) {
+                        for (const sdEp of sd_season.episodes ?? []) {
+                            if (sdEp.id !== ep.id) continue
+                            for (const p of sdEp.paths ?? []) {
+                                const ih = typeof p === 'object' ? p.infohash?.toLowerCase() : null
+                                if (!ih) continue
+                                for (const t of serieData.torrents ?? []) { if (t.infohash?.toLowerCase() === ih) { fankai = t.fankai ?? true; break outer } }
+                                for (const s of serieData.seasons ?? []) { for (const t of s.torrents ?? []) { if (t.infohash?.toLowerCase() === ih) { fankai = t.fankai ?? true; break outer } } }
+                            }
+                        }
+                    }
+                }
+                return { ...ep, available: availableEpisodeIds.has(ep.id), torrent: epTorrent ? { ...epTorrent, fankai: fankai ?? true } : null, fankai, organized: organizedEpisodeIds.has(ep.id) }
+            })
+            const total    = eps.filter((e: any) => e.available).length
+            const orgCount = eps.filter((e: any) => e.organized).length
+            const epTotal  = eps.length
+            const orgState = orgCount === 0
+                ? 'none'
+                : orgCount >= epTotal
+                    ? 'complete'
+                    : total > 0 && orgCount >= total
+                        ? 'complete'
+                        : 'partial'
+            return { ...season, torrent: seasonTorrentMapBySn[season.season_number] ?? null, organized_state: orgState, organized_count: orgCount, episodes: eps }
+        })
+
+        res.json({ serie, seasons: enrichedSeasons, torrents_integrale: integraleTorrents.map(t => ({ label: 'Intégrale', torrent_url: t.torrent_url, magnet: t.magnet, raw: t.title ?? t.raw })) })
+    } catch (err) {
+        logger.error('api', `GET /api/series/${id} échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+export default router
@@ -0,0 +1,29 @@
+import { Router } from 'express'
+import { requireAuth } from '../auth.js'
+import { readSettings, writeSettings } from '../settings.js'
+import { logger } from '../logger.js'
+
+const router = Router()
+
+router.get('/settings', requireAuth, (_req, res) => {
+    res.json(readSettings())
+})
+
+router.post('/settings', requireAuth, (req, res) => {
+    const { mediaPath, completePath, organizeMode, category, nfoSupport, autoImport, devMode, deleteTorrentOnMove, autoUnimportMissing } = req.body
+    const patch: Record<string, any> = {}
+    if (mediaPath             !== undefined) patch.mediaPath             = mediaPath
+    if (completePath          !== undefined) patch.completePath          = completePath
+    if (organizeMode          !== undefined) patch.organizeMode          = organizeMode
+    if (category              !== undefined) patch.category              = category
+    if (nfoSupport            !== undefined) patch.nfoSupport            = nfoSupport
+    if (autoImport            !== undefined) patch.autoImport            = autoImport
+    if (devMode               !== undefined) patch.devMode               = devMode
+    if (deleteTorrentOnMove   !== undefined) patch.deleteTorrentOnMove   = deleteTorrentOnMove
+    if (autoUnimportMissing   !== undefined) patch.autoUnimportMissing   = autoUnimportMissing
+    const updated = writeSettings(patch)
+    logger.info('api', 'Paramètres mis à jour')
+    res.json(updated)
+})
+
+export default router
@@ -0,0 +1,159 @@
+import { Router } from 'express'
+import path from 'path'
+import fs from 'fs'
+import { requireAuth } from '../auth.js'
+import { logger, readLogs, clearLogs, logsFileSize } from '../logger.js'
+import { DATA_DIR, BASE_DIR } from '../config.js'
+import { readSettings } from '../settings.js'
+import { systemInfo } from '../system.js'
+import { scanMediaPath } from '../organize.js'
+import { readAvailable, loadEnrichedSeriesData, cacheClear } from '../lib/github-cache.js'
+import { cacheSize } from '../lib/github-cache.js'
+import { recentOrganized } from '../lib/notifs.js'
+import { workerRunning } from '../organize.js'
+
+const router = Router()
+
+// ── Logs ───────────────────────────────────────────────────────
+router.get('/logs', requireAuth, (req, res) => {
+    const limit  = Number(req.query.limit)  || 100
+    const level  = (req.query.level  as string) || 'all'
+    const source = (req.query.source as string) || undefined
+    res.json({ entries: readLogs({ limit, level: level as any, source }), size: logsFileSize() })
+})
+
+router.post('/logs/clear', requireAuth, (_req, res) => {
+    clearLogs()
+    logger.info('api', 'Logs effacés')
+    res.json({ ok: true })
+})
+
+// ── Système ────────────────────────────────────────────────────
+router.get('/system/info', systemInfo)
+
+router.get('/system', requireAuth, (_req, res) => {
+    res.json({ isDocker: fs.existsSync('/.dockerenv') })
+})
+
+router.get('/version', (_req, res) => {
+    try {
+        const versionPath = path.join(BASE_DIR, 'version.txt')
+        const version = fs.existsSync(versionPath) ? fs.readFileSync(versionPath, 'utf-8').trim() : 'dev'
+        res.json({ version })
+    } catch {
+        res.json({ version: 'dev' })
+    }
+})
+
+// ── Parcours fichiers ──────────────────────────────────────────
+router.get('/browse', requireAuth, (req, res) => {
+    const dirPath = (req.query.path as string) || '/'
+    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 })
+    } 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' })
+    }
+})
+
+router.get('/browse-files', requireAuth, (req, res) => {
+    const dirPath = (req.query.path as string) || '/'
+    const VIDEO_EXTS = new Set(['.mkv', '.mp4', '.avi', '.m4v', '.mov', '.wmv'])
+    try {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true })
+            logger.info('api', `Dossier créé : ${dirPath}`)
+        }
+        const files: { name: string; path: string; size: number }[] = []
+        function walk(dir: string) {
+            let entries: fs.Dirent[]
+            try { entries = fs.readdirSync(dir, { withFileTypes: true }) }
+            catch { return }
+            for (const entry of entries) {
+                if (entry.name.startsWith('.')) continue
+                const full = path.join(dir, entry.name)
+                if (entry.isDirectory()) {
+                    walk(full)
+                } else if (entry.isFile() && VIDEO_EXTS.has(path.extname(entry.name).toLowerCase())) {
+                    try {
+                        const stat = fs.statSync(full)
+                        files.push({ name: entry.name, path: full, size: stat.size })
+                    } catch {}
+                }
+            }
+        }
+        walk(dirPath)
+        files.sort((a, b) => a.name.localeCompare(b.name, 'fr'))
+        res.json({ path: dirPath, files })
+    } catch (err) {
+        logger.warn('api', `browse-files "${dirPath}" : ${err instanceof Error ? err.message : err}`)
+        res.status(400).json({ error: err instanceof Error ? err.message : 'Erreur lecture dossier' })
+    }
+})
+
+// ── Catalogue ──────────────────────────────────────────────────
+router.get('/torrents/status', requireAuth, async (_req, res) => {
+    try {
+        const available = await readAvailable()
+        res.json({ exists: available.length > 0, count: available.length, empty: available.length === 0 })
+    } catch { res.json({ exists: false, count: 0, empty: true }) }
+})
+
+router.post('/update', requireAuth, async (_req, res) => {
+    try {
+        cacheClear()
+        logger.info('api', 'Cache GitHub vidé — rechargement forcé')
+        const availableIds = await readAvailable()
+        if (!Array.isArray(availableIds)) throw new Error('available.json invalide')
+        logger.info('api', `Catalogue rechargé — ${availableIds.length} séries disponibles`)
+        res.json({ ok: true, count: availableIds.length })
+    } catch (err) {
+        logger.error('api', `Mise à jour catalogue échouée : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+router.post('/scan', requireAuth, async (_req, res) => {
+    try {
+        const { mediaPath } = readSettings()
+        logger.info('api', 'Scan médiathèque manuel lancé')
+        const seriesData = await loadEnrichedSeriesData()
+        const result     = await scanMediaPath(mediaPath, path.join(DATA_DIR, 'organized.json'), seriesData)
+        res.json({ ok: true, ...result })
+    } catch (err) {
+        logger.error('api', `Scan médiathèque échoué : ${err instanceof Error ? err.message : err}`)
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+// ── Debug ──────────────────────────────────────────────────────
+router.get('/debug/stats', requireAuth, (req, res) => {
+    const { devMode } = readSettings()
+    if (!devMode) { res.status(403).json({ error: 'Dev mode désactivé' }); return }
+    const mem     = process.memoryUsage()
+    const uptimeS = Math.floor(process.uptime())
+    const h       = Math.floor(uptimeS / 3600)
+    const m       = Math.floor((uptimeS % 3600) / 60)
+    const s       = uptimeS % 60
+    let organizedCount = 0
+    try {
+        const orgPath = path.join(DATA_DIR, 'organized.json')
+        if (fs.existsSync(orgPath)) {
+            const org = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
+            organizedCount = Object.values(org).reduce((acc: number, episodes: any) => acc + Object.keys(episodes).length, 0)
+        }
+    } catch {}
+    res.json({
+        memory   : { heapUsed: Math.round(mem.heapUsed / 1024 / 1024), heapTotal: Math.round(mem.heapTotal / 1024 / 1024), rss: Math.round(mem.rss / 1024 / 1024) },
+        cache    : { entries: cacheSize(), ttlHours: 6 },
+        uptime   : `${h}h ${m}m ${s}s`,
+        uptimeSeconds: uptimeS,
+        worker   : { running: workerRunning },
+        organized: { trackedFiles: organizedCount },
+        requests : { notifs: recentOrganized.length },
+    })
+})
+
+export default router
@@ -0,0 +1,86 @@
+import { Router } from 'express'
+import { requireAuth } from '../auth.js'
+import {
+    getDriver, getAvailableClients,
+    listClients, addClient, removeClient, getClient,
+    sanitizeClient, updateClient,
+} from '../torrent-clients/index.js'
+
+const router = Router()
+
+router.get('/torrent-clients/available', requireAuth, (_req, res) => {
+    res.json(getAvailableClients())
+})
+
+router.get('/torrent-clients', requireAuth, (_req, res) => {
+    res.json(listClients().map((c: any) => sanitizeClient(c)))
+})
+
+router.post('/torrent-clients', requireAuth, (req, res) => {
+    const { name, type, config } = req.body
+    if (!name || !type || !config) { res.status(400).json({ error: 'name, type et config requis' }); return }
+    if (!getDriver(type))          { res.status(400).json({ error: `Type inconnu : ${type}` }); return }
+    res.json(sanitizeClient(addClient(name, type, config)))
+})
+
+router.delete('/torrent-clients/:uuid', requireAuth, (req, res) => {
+    const ok = removeClient(String(req.params.uuid))
+    if (!ok) { res.status(404).json({ error: 'Client introuvable' }); return }
+    res.json({ ok: true })
+})
+
+router.put('/torrent-clients/:uuid', requireAuth, (req, res) => {
+    const { name, type, config } = req.body
+    if (!name || !type || !config) { res.status(400).json({ error: 'name, type et config requis' }); return }
+    if (!getDriver(type))          { res.status(400).json({ error: `Type inconnu : ${type}` }); return }
+    const oldClient = getClient(String(req.params.uuid))
+    if (oldClient) {
+        const driver = getDriver(type)
+        if (driver) {
+            for (const field of driver.definition.fields) {
+                if (field.type === 'password' && config[field.key] === '••••••••') {
+                    config[field.key] = oldClient.config[field.key]
+                }
+            }
+        }
+    }
+    const updated = updateClient(String(req.params.uuid), name, type, config)
+    if (!updated) { res.status(404).json({ error: 'Client introuvable' }); return }
+    res.json(sanitizeClient(updated))
+})
+
+router.post('/torrent-clients/test-config', requireAuth, async (req, res) => {
+    const { type, config, uuid } = req.body
+    if (!type || !config) { res.status(400).json({ error: 'type et config requis' }); return }
+    const driver = getDriver(type)
+    if (!driver) { res.status(400).json({ error: `Type inconnu : ${type}` }); return }
+    if (uuid) {
+        const oldClient = getClient(uuid)
+        if (oldClient) {
+            for (const field of driver.definition.fields) {
+                if (field.type === 'password' && config[field.key] === '••••••••') {
+                    config[field.key] = oldClient.config[field.key]
+                }
+            }
+        }
+    }
+    res.json(await driver.test(config))
+})
+
+router.post('/torrent-clients/:uuid/test', requireAuth, async (req, res) => {
+    const client = getClient(String(req.params.uuid))
+    if (!client) { res.status(404).json({ error: 'Client introuvable' }); return }
+    const driver = getDriver(client.type)
+    if (!driver) { res.status(400).json({ error: 'Driver introuvable' }); return }
+    res.json(await driver.test(client.config))
+})
+
+router.get('/torrent-clients/:uuid/healthcheck', requireAuth, async (req, res) => {
+    const client = getClient(String(req.params.uuid))
+    if (!client) { res.status(404).json({ error: 'Client introuvable' }); return }
+    const driver = getDriver(client.type)
+    if (!driver) { res.status(400).json({ error: 'Driver introuvable' }); return }
+    res.json(await driver.healthcheck(client.config))
+})
+
+export default router
@@ -5,13 +5,14 @@ import { DATA_DIR } from './config.js'
 const DATA_PATH = path.join(DATA_DIR, 'settings.json')

 export interface Settings {
-    mediaPath    : string
-    completePath : string
-    organizeMode : 'hardlink' | 'move'
-    category     : string
-    nfoSupport   : boolean
-    autoImport   : boolean
-    devMode      : boolean
+    mediaPath           : string
+    completePath        : string
+    organizeMode        : 'hardlink' | 'copy' | 'move'  // ← ajouter 'copy'
+    category            : string
+    nfoSupport          : boolean
+    autoImport          : boolean
+    devMode             : boolean
+    deleteTorrentOnMove : boolean  // ← ajouter
 }

 const defaults: Settings = {
@@ -22,6 +23,7 @@ const defaults: Settings = {
    nfoSupport  : false,
    autoImport  : true,
    devMode     : false,
+    deleteTorrentOnMove: false,
 }

 export function readSettings(): Settings {
@@ -41,7 +41,10 @@ export interface TorrentInfo {
    progress  : number
    size      : number
    downloaded: number
+    uploaded  : number
+    ratio     : number
    speed     : number
+    upspeed   : number
    eta       : number
    save_path : string
    category  : string
@@ -53,6 +56,7 @@ export interface TorrentClientDriver {
    healthcheck : (config: Record<string, string | number>) => Promise<{ online: boolean; version?: string }>
    add         : (config: Record<string, string | number>, url: string) => Promise<void>
    list        : (config: Record<string, string | number>, category?: string) => Promise<TorrentInfo[]>
+    remove      : (config: Record<string, string | number>, hash: string, deleteFiles?: boolean) => Promise<void>
 }

 // ─── Registry ─────────────────────────────────────────────────────────────────
@@ -235,17 +239,47 @@ export async function dispatchDownload(url: string): Promise<{ uuid: string; nam
    return results
 }

-// ─── Dispatch list ─────────────────────────────────────────────────────────────
+// ─── Dispatch remove ───────────────────────────────────────────────────────────

-export async function dispatchList(category?: string): Promise<(TorrentInfo & { client_uuid: string; client_name: string })[]> {
+export async function dispatchRemove(hash: string, deleteFiles = false): Promise<{ ok: boolean; error?: string }> {
    const clients = loadClients()
+    let found = false
+    for (const client of clients) {
+        const driver = getDriver(client.type)
+        if (!driver) continue
+        try {
+            await driver.remove(client.config, hash, deleteFiles)
+            logger.info('torrent-clients', `Torrent ${hash.slice(0, 8)}… supprimé de "${client.name}"${deleteFiles ? ' (avec fichiers)' : ''}`)
+            found = true
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
+            logger.warn('torrent-clients', `Impossible de supprimer le torrent de "${client.name}" : ${msg}`)
+        }
+    }
+    return found ? { ok: true } : { ok: false, error: 'Torrent introuvable dans les clients' }
+}
+
+// Map inversée : titre normalisé → infohash (pour matcher les torrents Synology)
+function buildTitleIndex(infohashMap: Record<string, string>): Map<string, string> {
+    const index = new Map<string, string>()
+    for (const [hash, title] of Object.entries(infohashMap)) {
+        index.set(title.toLowerCase().trim(), hash.toLowerCase())
+    }
+    return index
+}
+
+export async function dispatchList(
+    category?    : string,
+    infohashMap? : Record<string, string>,
+): Promise<(TorrentInfo & { client_uuid: string; client_name: string })[]> {
+    const clients    = loadClients()
    const results: (TorrentInfo & { client_uuid: string; client_name: string })[] = []
+    const titleIndex = infohashMap ? buildTitleIndex(infohashMap) : null

    for (const client of clients) {
        const driver = getDriver(client.type)
        if (!driver) continue

-        // Skip si le client est en cooldown suite à des échecs d'auth
        if (isInCooldown(client.uuid)) {
            const remaining = cooldownRemaining(client.uuid)
            logger.debug('torrent-clients', `Client "${client.name}" en cooldown — retry dans ${remaining}`)
@@ -266,12 +300,23 @@ export async function dispatchList(category?: string): Promise<(TorrentInfo & {
                const save_path = hasRemap
                    ? remapSavePath(t.save_path, remotePath, localPath)
                    : t.save_path
-                results.push({ ...t, save_path, client_uuid: client.uuid, client_name: client.name })
+
+                // Pour Synology (hash = dbid_xxx), on essaie de résoudre le vrai infohash
+                // en matchant le titre du torrent dans la infohashMap
+                let hash = t.hash
+                if (titleIndex && t.hash.startsWith('dbid_')) {
+                    const resolved = titleIndex.get(t.name.toLowerCase().trim())
+                    if (resolved) {
+                        logger.debug('torrent-clients', `Synology hash résolu : "${t.name}" → ${resolved.slice(0, 8)}…`)
+                        hash = resolved
+                    }
+                }
+
+                results.push({ ...t, hash, save_path, client_uuid: client.uuid, client_name: client.name })
            }
        } catch (err) {
            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
            logger.error('torrent-clients', `Impossible de récupérer la liste depuis "${client.name}" : ${msg}`)
-            // Déclencher le backoff si c'est une erreur d'auth
            const isAuthError = msg.toLowerCase().includes('login') ||
                msg.toLowerCase().includes('auth') ||
                msg.toLowerCase().includes('ban') ||
@@ -93,7 +93,10 @@ const QB: TorrentClientDriver = {
            progress  : Math.round(t.progress * 100),
            size      : t.size,
            downloaded: t.downloaded,
+            uploaded  : t.uploaded ?? 0,
+            ratio     : Math.round((t.ratio ?? 0) * 100) / 100,
            speed     : t.dlspeed,
+            upspeed   : t.upspeed ?? 0,
            eta       : t.eta ?? -1,
            save_path : t.save_path,
            category  : t.category ?? '',
@@ -115,6 +118,20 @@ const QB: TorrentClientDriver = {
        if (text !== 'Ok.') throw new Error(`Ajout échoué : ${text}`)
        logger.info('qbittorrent', `Torrent ajouté avec succès (catégorie: ${config.category ?? 'aucune'}${config.savePath ? `, dossier: ${config.savePath}` : ''})`)
    },
+
+    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 res = await fetch(`${config.url}/api/v2/torrents/delete`, {
+            method : 'POST',
+            body   : form,
+            headers: { Cookie: `SID=${sid}` },
+        })
+        if (!res.ok) throw new Error(`Suppression échouée : ${res.status}`)
+        logger.info('qbittorrent', `Torrent ${hash.slice(0, 8)}… supprimé${deleteFiles ? ' (avec fichiers)' : ''}`)
+    },
 }

 export default QB
@@ -178,11 +178,13 @@ const RT: TorrentClientDriver = {
            'd.complete',
            'd.size_bytes',
            'd.bytes_done',
+            'd.up.total',    // total uploadé
+            'd.ratio',       // ratio x1000
            'd.down.rate',
+            'd.up.rate',
            'd.left_bytes',
-            'd.down.rate',
            'd.directory',
-            'd.custom1',  // label rTorrent
+            'd.custom1',
        ]

        const rows = await d_multicall(config, 'main', methods)
@@ -190,10 +192,11 @@ const RT: TorrentClientDriver = {
        return rows
            .map(r => {
                const [hash, name, isOpen, isActive, isChecking, isComplete,
-                    size, downloaded, speed, leftBytes, , directory, label] = r
+                    size, downloaded, uploadedTotal, ratioRaw,
+                    dlSpeed, ulSpeed, leftBytes, directory, label] = r

                const progress = size > 0 ? Math.min(100, Math.round(((size - leftBytes) / size) * 100)) : 0
-                const eta      = speed > 0 && leftBytes > 0 ? Math.round(leftBytes / speed) : -1
+                const eta      = Number(dlSpeed) > 0 && Number(leftBytes) > 0 ? Math.round(Number(leftBytes) / Number(dlSpeed)) : -1

                return {
                    hash      : String(hash).toLowerCase(),
@@ -202,7 +205,10 @@ const RT: TorrentClientDriver = {
                    progress,
                    size      : Number(size),
                    downloaded: Number(downloaded),
-                    speed     : Number(speed),
+                    uploaded  : Number(uploadedTotal ?? 0),
+                    ratio     : Math.round((Number(ratioRaw ?? 0) / 1000) * 100) / 100,
+                    speed     : Number(dlSpeed),
+                    upspeed   : Number(ulSpeed ?? 0),
                    eta,
                    save_path : String(directory),
                    category  : String(label ?? ''),
@@ -230,6 +236,18 @@ const RT: TorrentClientDriver = {
        await rpcCall(config, method, args)
        logger.info('rtorrent', `Torrent ajouté avec succès${config.savePath ? ` (dossier: ${config.savePath})` : ''}`)
    },
+
+    async remove(config, hash, deleteFiles = false) {
+        const h = hash.toUpperCase()
+        if (deleteFiles) {
+            // Supprimer les fichiers puis effacer
+            await rpcCall(config, 'd.delete_tied', [h])
+            await rpcCall(config, 'd.erase', [h])
+        } else {
+            await rpcCall(config, 'd.erase', [h])
+        }
+        logger.info('rtorrent', `Torrent ${hash.slice(0, 8)}… supprimé${deleteFiles ? ' (avec fichiers)' : ''}`)
+    },
 }

 export default RT
@@ -108,11 +108,6 @@ const DS: TorrentClientDriver = {
        const tasks: any[] = data?.tasks ?? []

        return tasks
-            .filter(t => {
-                if (!category) return true
-                // Synology n'a pas de labels natifs — on filtre par destination si elle contient la catégorie
-                return (t.additional?.detail?.destination as string)?.includes(String(category))
-            })
            .map(t => {
                const transfer = t.additional?.transfer ?? {}
                const size     = t.size ?? 0
@@ -124,10 +119,13 @@ const DS: TorrentClientDriver = {
                    progress  : size > 0 ? Math.min(100, Math.round((dl / size) * 100)) : 0,
                    size,
                    downloaded: dl,
+                    uploaded  : transfer.size_uploaded ?? 0,
+                    ratio     : size > 0 ? Math.round(((transfer.size_uploaded ?? 0) / size) * 100) / 100 : 0,
                    speed     : transfer.speed_download ?? 0,
+                    upspeed   : transfer.speed_upload ?? 0,
                    eta       : -1,
                    save_path : t.additional?.detail?.destination ?? '',
-                    category  : '',
+                    category  : category ?? '',
                } satisfies TorrentInfo
            })
    },
@@ -153,6 +151,27 @@ const DS: TorrentClientDriver = {

        logger.info('synology-ds', `Torrent ajouté avec succès${config.savePath ? ` (dossier: ${config.savePath})` : ''}`)
    },
+
+    async remove(config, hash, deleteFiles = false) {
+        const sid = await dsLogin(config)
+        // Synology utilise son ID interne — on cherche via la liste
+        const data = await dsRequest(config, 'SYNO.DownloadStation.Task', 'list', '1', { additional: 'detail' }, sid)
+        const tasks: any[] = data?.tasks ?? []
+        // Matcher par hash si résolu, sinon par id
+        const found = tasks.find(t => t.id?.toLowerCase() === hash.toLowerCase())
+        if (!found) throw new Error(`Torrent ${hash.slice(0, 8)}… introuvable`)
+        const params = new URLSearchParams({
+            api    : 'SYNO.DownloadStation.Task',
+            version: '1',
+            method : 'delete',
+            id     : found.id,
+            force_complete: deleteFiles ? 'false' : 'false',
+            _sid   : sid,
+        })
+        const res = await fetch(`${config.url}/webapi/DownloadStation/task.cgi?${params}`)
+        if (!res.ok) throw new Error(`HTTP ${res.status}`)
+        logger.info('synology-ds', `Torrent ${found.id} supprimé`)
+    },
 }

 export default DS
@@ -94,7 +94,8 @@ const TR: TorrentClientDriver = {
    async list(config, category) {
        const fields = [
            'hashString', 'name', 'status', 'percentDone', 'totalSize',
-            'downloadedEver', 'rateDownload', 'eta', 'downloadDir', 'labels',
+            'downloadedEver', 'uploadedEver', 'uploadRatio',
+            'rateDownload', 'rateUpload', 'eta', 'downloadDir', 'labels',
        ]
        const data = await trRequest(config, 'torrent-get', { fields })
        const torrents: any[] = data.arguments?.torrents ?? []
@@ -111,7 +112,10 @@ const TR: TorrentClientDriver = {
                progress  : Math.round(t.percentDone * 100),
                size      : t.totalSize,
                downloaded: t.downloadedEver,
+                uploaded  : t.uploadedEver ?? 0,
+                ratio     : Math.round((t.uploadRatio ?? 0) * 100) / 100,
                speed     : t.rateDownload,
+                upspeed   : t.rateUpload ?? 0,
                eta       : t.eta ?? -1,
                save_path : t.downloadDir,
                category  : t.labels?.[0] ?? '',
@@ -132,6 +136,16 @@ const TR: TorrentClientDriver = {
        await trRequest(config, 'torrent-add', args)
        logger.info('transmission', `Torrent ajouté avec succès (catégorie: ${config.category ?? 'aucune'}${config.savePath ? `, dossier: ${config.savePath}` : ''})`)
    },
+
+    async remove(config, hash, deleteFiles = false) {
+        // Transmission identifie les torrents par ID numérique — on cherche via la liste
+        const data = await trRequest(config, 'torrent-get', { fields: ['hashString', 'id'] })
+        const torrents: any[] = data.arguments?.torrents ?? []
+        const found = torrents.find(t => t.hashString?.toLowerCase() === hash.toLowerCase())
+        if (!found) throw new Error(`Torrent ${hash.slice(0, 8)}… introuvable`)
+        await trRequest(config, 'torrent-remove', { ids: [found.id], 'delete-local-data': deleteFiles })
+        logger.info('transmission', `Torrent ${hash.slice(0, 8)}… supprimé${deleteFiles ? ' (avec fichiers)' : ''}`)
+    },
 }

 export default TR
@@ -62,7 +62,7 @@ function mapTorrent(t: any[]): TorrentInfo {
    // [hash, status, name, size, progress, downloaded, uploaded, ratio,
    //  ul_speed, dl_speed, eta, label, peers_connected, peers_swarm,
    //  seeds_connected, seeds_swarm, availability, queue_order, remaining]
-    const [hash, status, name, size, progress, downloaded, , , , dlSpeed, eta, label] = t
+    const [hash, status, name, size, progress, downloaded, uploaded, ratio, ulSpeed, dlSpeed, eta, label] = t
    return {
        hash      : hash.toLowerCase(),
        name,
@@ -70,9 +70,12 @@ function mapTorrent(t: any[]): TorrentInfo {
        progress  : Math.min(100, Math.round(progress / 10)),
        size,
        downloaded,
+        uploaded  : uploaded ?? 0,
+        ratio     : Math.round(((ratio ?? 0) / 1000) * 100) / 100, // uTorrent ratio est x1000
        speed     : dlSpeed ?? 0,
+        upspeed   : ulSpeed ?? 0,
        eta       : eta ?? -1,
-        save_path : '',   // récupéré séparément via torrent properties si besoin
+        save_path : '',
        category  : label ?? '',
    }
 }
@@ -152,7 +155,6 @@ const UT: TorrentClientDriver = {
        })

        if (config.savePath) {
-            qs.set('download_dir', '1')
            qs.set('path', String(config.savePath))
        }

@@ -191,6 +193,15 @@ const UT: TorrentClientDriver = {

        logger.info('utorrent', `Torrent ajouté avec succès (catégorie: ${config.category ?? 'aucune'}${config.savePath ? `, dossier: ${config.savePath}` : ''})`)
    },
+
+    async remove(config, hash, deleteFiles = false) {
+        const s = await utGetSession(config)
+        await utRequest(config, {
+            action: deleteFiles ? 'removedata' : 'remove',
+            hash  : hash.toUpperCase(),
+        }, s)
+        logger.info('utorrent', `Torrent ${hash.slice(0, 8)}… supprimé${deleteFiles ? ' (avec fichiers)' : ''}`)
+    },
 }

 export default UT
@@ -7,70 +7,79 @@
        <div class="flex items-center justify-between px-6 py-4 border-b border-border shrink-0">
          <div>
            <h3 class="text-sm font-semibold text-primary">Import manuel — {{ serieName }}</h3>
-            <p class="text-xs text-muted mt-0.5">Associez vos fichiers existants aux épisodes du catalogue</p>
+            <p class="text-xs text-muted font-mono mt-0.5 truncate">{{ serieFolder }}</p>
          </div>
          <button @click="$emit('close')" class="text-muted hover:text-primary transition-colors text-lg leading-none">✕</button>
        </div>

-        <!-- Étape 1 : Choisir un dossier -->
-        <div v-if="step === 'folder'" class="flex flex-col gap-4 px-6 py-5">
-          <p class="text-sm text-secondary">Sélectionnez le dossier contenant vos fichiers vidéo :</p>
-          <button
-              @click="pickerOpen = true"
-              class="settings-input text-left font-mono truncate"
-              :class="selectedFolder ? 'text-primary' : 'text-muted'"
-          >
-            {{ selectedFolder || 'Choisir un dossier…' }}
-          </button>
-          <div class="flex gap-2">
-            <button @click="scanFolder" :disabled="!selectedFolder || scanning" class="btn-primary">
-              {{ scanning ? 'Scan…' : 'Scanner ce dossier' }}
-            </button>
-            <button @click="$emit('close')" class="btn-secondary">Annuler</button>
-          </div>
+        <!-- Loading -->
+        <div v-if="scanning" class="flex flex-col items-center justify-center gap-3 py-16 text-muted">
+          <div class="w-5 h-5 border border-border border-t-accent rounded-full animate-spin" />
+          <p class="text-sm">Scan du dossier…</p>
        </div>

-        <!-- Étape 2 : Matcher les fichiers -->
-        <template v-else-if="step === 'match'">
+        <!-- Dossier vide / introuvable -->
+        <div v-else-if="!scanning && items.length === 0 && !scanError" class="flex flex-col items-center gap-3 py-16 text-center px-6">
+          <p class="text-sm text-muted">Aucun fichier vidéo trouvé dans ce dossier.</p>
+          <p class="text-xs text-muted">Placez vos fichiers dans <span class="font-mono text-primary">{{ serieFolder }}</span> puis réessayez.</p>
+          <button @click="scan" class="btn-secondary mt-2">Rescanner</button>
+        </div>
+
+        <!-- Erreur -->
+        <div v-else-if="scanError" class="flex flex-col items-center gap-3 py-16 text-center px-6">
+          <p class="text-sm text-red-400">{{ scanError }}</p>
+          <button @click="scan" class="btn-secondary">Réessayer</button>
+        </div>
+
+        <!-- Liste fichiers -->
+        <template v-else-if="items.length > 0">

          <!-- Toolbar -->
          <div class="flex items-center justify-between px-6 py-3 border-b border-border shrink-0 gap-3">
            <p class="text-xs text-muted">
-              <span class="text-primary font-medium">{{ files.length }}</span> fichier{{ files.length > 1 ? 's' : '' }} trouvé{{ files.length > 1 ? 's' : '' }}
-              · <span class="text-green-400">{{ matchedCount }} matché{{ matchedCount > 1 ? 's' : '' }}</span>
-              <span v-if="unmatchedCount > 0"> · <span class="text-yellow-500">{{ unmatchedCount }} non matché{{ unmatchedCount > 1 ? 's' : '' }}</span></span>
+              <span class="text-primary font-medium">{{ items.length }}</span> fichier{{ items.length > 1 ? 's' : '' }}
+              <span v-if="alreadyImportedCount > 0"> · <span class="text-blue-400">{{ alreadyImportedCount }} déjà importé{{ alreadyImportedCount > 1 ? 's' : '' }}</span></span>
+              · <span class="text-green-400">{{ newMatchedCount }} nouveau{{ newMatchedCount > 1 ? 'x' : '' }}</span>
+              <span v-if="unmatchedCount > 0"> · <span class="text-yellow-500">{{ unmatchedCount }} non associé{{ unmatchedCount > 1 ? 's' : '' }}</span></span>
            </p>
-            <button @click="step = 'folder'" class="text-xs text-muted hover:text-primary transition-colors">← Changer de dossier</button>
+            <button @click="scan" class="text-xs text-muted hover:text-primary transition-colors">↺ Rescanner</button>
          </div>

-          <!-- Liste fichiers -->
+          <!-- Fichiers -->
          <div class="overflow-y-auto flex-1 px-6 py-3 flex flex-col gap-2">
            <div
                v-for="(item, i) in items"
                :key="item.file.path"
                class="flex items-center gap-3 p-3 rounded-lg border transition-colors"
-                :class="item.episode_id
-                  ? 'border-green-500/20 bg-green-500/5'
-                  : 'border-border bg-shell'"
+                :class="item.alreadyImported
+                  ? 'border-blue-500/20 bg-blue-500/5'
+                  : item.episode_id
+                    ? 'border-green-500/20 bg-green-500/5'
+                    : 'border-border bg-shell'"
            >
-              <!-- Icône état -->
+              <!-- Icône -->
              <div class="w-5 h-5 rounded-md flex items-center justify-center shrink-0"
-                   :class="item.episode_id ? 'bg-green-500/15 text-green-400' : 'bg-border text-muted'">
-                <svg v-if="item.episode_id" width="10" height="10" viewBox="0 0 12 12" stroke="currentColor" stroke-width="2.5" fill="none"><polyline points="2 6 5 9 10 3"/></svg>
+                   :class="item.alreadyImported ? 'bg-blue-500/15 text-blue-400' :
+                           item.episode_id ? 'bg-green-500/15 text-green-400' : 'bg-border text-muted'">
+                <svg v-if="item.alreadyImported || item.episode_id" width="10" height="10" viewBox="0 0 12 12" stroke="currentColor" stroke-width="2.5" fill="none"><polyline points="2 6 5 9 10 3"/></svg>
                <svg v-else width="10" height="10" viewBox="0 0 12 12" stroke="currentColor" stroke-width="2" fill="none"><line x1="6" y1="2" x2="6" y2="7"/><circle cx="6" cy="9.5" r="0.5" fill="currentColor"/></svg>
              </div>

-              <!-- Nom fichier -->
+              <!-- Nom + taille -->
              <div class="flex-1 min-w-0">
                <p class="text-xs text-primary font-mono truncate">{{ item.file.name }}</p>
-                <p class="text-[11px] text-muted mt-0.5">{{ formatSize(item.file.size) }}</p>
+                <p class="text-[11px] text-muted mt-0.5">
+                  {{ formatSize(item.file.size) }}
+                  <span v-if="item.alreadyImported" class="text-blue-400 ml-1">— déjà importé</span>
+                  <span v-else-if="item.willRename" class="text-accent ml-1">— sera renommé</span>
+                </p>
              </div>

              <!-- Sélecteur épisode -->
              <select
                  v-model="items[i].episode_id"
                  class="settings-input text-xs py-1 max-w-[260px] shrink-0"
-                  @change="items[i].hash = getHashForEpisode(Number(items[i].episode_id))"
+                  @change="onEpisodeChange(i)"
              >
                <option :value="null">— Non associé —</option>
                <optgroup v-for="season in seasons" :key="season.id" :label="season.season_number === 0 ? 'Spéciaux' : `Saison ${season.season_number}`">
@@ -93,23 +102,23 @@
          <div class="flex items-center justify-between px-6 py-4 border-t border-border shrink-0">
            <p v-if="importError" class="text-xs text-red-400">{{ importError }}</p>
            <p v-else class="text-xs text-muted">
-              Seuls les fichiers associés à un épisode seront importés.
+              Les fichiers dans ce dossier seront <span class="text-accent">renommés sur place</span>.
            </p>
            <div class="flex gap-2">
              <button @click="$emit('close')" class="btn-secondary">Annuler</button>
              <button
                  @click="doImport"
-                  :disabled="matchedCount === 0 || importing"
+                  :disabled="newMatchedCount === 0 || importing"
                  class="btn-primary"
              >
-                {{ importing ? 'Import…' : `Importer ${matchedCount} fichier${matchedCount > 1 ? 's' : ''}` }}
+                {{ importing ? 'Import…' : `Importer ${newMatchedCount} fichier${newMatchedCount > 1 ? 's' : ''}` }}
              </button>
            </div>
          </div>

        </template>

-        <!-- Étape 3 : Résultat -->
+        <!-- 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>
@@ -134,29 +143,21 @@

      </div>
    </div>
-
-    <!-- Folder Picker -->
-    <FolderPicker
-        v-if="pickerOpen"
-        :initial-path="selectedFolder || '/'"
-        @select="onFolderSelect"
-        @cancel="pickerOpen = false"
-    />
  </Teleport>
 </template>

 <script setup lang="ts">
-import { ref, computed } from 'vue'
-import FolderPicker from '@/components/FolderPicker.vue'
+import { ref, computed, onMounted } from 'vue'
 import { useToast } from '@/composables/useToast'

 const { add: toast } = useToast()

 const props = defineProps<{
-  serieId  : number
-  serieName: string
-  seasons  : any[]
-  organized: Record<string, any>  // episode_id → entry
+  serieId    : number
+  serieName  : string
+  seasons    : any[]
+  organized  : Record<string, any>
+  initialPath: string
 }>()

 const emit = defineEmits<{
@@ -165,26 +166,33 @@ const emit = defineEmits<{
 }>()

 // ─── State ────────────────────────────────────────────────────
-const step          = ref<'folder' | 'match' | 'done'>('folder')
-const pickerOpen    = ref(false)
-const selectedFolder = ref('')
-const scanning      = ref(false)
-const importing     = ref(false)
-const importError   = ref('')
-const importResult  = ref({ done: 0, errors: [] as { file: string; error: string }[] })
+const step        = ref<'list' | 'done'>('list')
+const scanning    = ref(false)
+const importing   = ref(false)
+const importError = ref('')
+const scanError   = ref('')
+const importResult = ref({ done: 0, errors: [] as { file: string; error: string }[] })
+
+// Dossier de la série dans la médiathèque
+const serieTitle  = computed(() =>
+    props.serieName.replace(/:/g, ' -').replace(/[<>"/\\|?*]/g, '').replace(/\s+/g, ' ').trim()
+)
+const serieFolder = computed(() => `${props.initialPath}/${serieTitle.value}`)

 interface FileItem {
-  file      : { name: string; path: string; size: number }
-  episode_id: number | null
-  hash      : string | null
+  file           : { name: string; path: string; size: number }
+  episode_id     : number | null
+  hash           : string | null
+  alreadyImported: boolean
+  willRename     : boolean
 }

-const files = ref<{ name: string; path: string; size: number }[]>([])
 const items = ref<FileItem[]>([])

-// ─── Computed ─────────────────────────────────────────────────
-const matchedCount   = computed(() => items.value.filter(i => i.episode_id !== null).length)
-const unmatchedCount = computed(() => items.value.filter(i => i.episode_id === null).length)
+// ─── Computed ──────────────────────────────────────────────────
+const alreadyImportedCount = computed(() => items.value.filter(i => i.alreadyImported).length)
+const newMatchedCount      = computed(() => items.value.filter(i => i.episode_id !== null && !i.alreadyImported).length)
+const unmatchedCount       = computed(() => items.value.filter(i => i.episode_id === null).length)

 // ─── Helpers ──────────────────────────────────────────────────
 function isEpisodeOrganized(epId: number): boolean {
@@ -207,36 +215,38 @@ function getHashForEpisode(episodeId: number): string | null {
  return null
 }

-// Auto-match : on essaie de matcher par original_filename, nfo_filename, formatted_name
+function buildOrganizedByPath(): Map<string, number> {
+  const index = new Map<string, number>()
+  for (const [epIdStr, entry] of Object.entries(props.organized)) {
+    if (entry?.dest_path) index.set(entry.dest_path, Number(epIdStr))
+  }
+  return index
+}
+
 function autoMatch(filename: string): { episode_id: number | null; hash: string | null } {
-  const lower = filename.toLowerCase()
+  const nameNoExt = filename.replace(/\.[^.]+$/, '').toLowerCase()

  for (const season of props.seasons) {
    for (const ep of season.episodes) {
      const candidates = [
        ep.original_filename,
-        ep.nfo_filename?.replace(/\.nfo$/, '.mkv'),
-        ep.formatted_name ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '') + '.mkv' : null,
-      ].filter(Boolean).map((s: string) => s.toLowerCase())
+        ep.nfo_filename?.replace(/\.nfo$/, ''),
+        ep.formatted_name?.replace(/[<>:"/\\|?*]/g, '').trim(),
+      ].filter(Boolean).map((s: string) => s.toLowerCase().replace(/\.[^.]+$/, ''))

-      if (candidates.some(c => c === lower || lower.includes(c.replace(/\.mkv$/, '')))) {
-        const hash = getHashForEpisode(ep.id)
-        return { episode_id: ep.id, hash }
+      if (candidates.some(c => c === nameNoExt || nameNoExt.startsWith(c + '.'))) {
+        return { episode_id: ep.id, hash: getHashForEpisode(ep.id) }
      }
    }
  }

-  // Fallback : match par numéro d'épisode dans le nom de fichier
-  const numMatch = filename.match(/(?:e|ep|episode|épisode)[.\s_-]?0*(\d+)/i)
-      ?? filename.match(/\b0*(\d{1,3})\b/)
+  // Fallback numéro d'épisode
+  const numMatch = filename.match(/[.\s_-]0*(\d{1,3})[.\s_-]/i)
  if (numMatch) {
    const num = parseInt(numMatch[1], 10)
    for (const season of props.seasons) {
      const ep = season.episodes.find((e: any) => e.episode_number === num)
-      if (ep) {
-        const hash = getHashForEpisode(ep.id)
-        return { episode_id: ep.id, hash }
-      }
+      if (ep) return { episode_id: ep.id, hash: getHashForEpisode(ep.id) }
    }
  }

@@ -250,45 +260,59 @@ function formatSize(bytes: number): string {
  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`
 }

-// ─── Actions ──────────────────────────────────────────────────
-function onFolderSelect(p: string) {
-  selectedFolder.value = p
-  pickerOpen.value     = false
+function onEpisodeChange(i: number) {
+  items.value[i].hash           = getHashForEpisode(Number(items.value[i].episode_id))
+  items.value[i].alreadyImported = false
 }

-async function scanFolder() {
-  if (!selectedFolder.value) return
-  scanning.value = true
+// ─── Actions ──────────────────────────────────────────────────
+async function scan() {
+  scanning.value  = true
+  scanError.value = ''
+  items.value     = []
+
  try {
-    const res = await fetch(`/api/browse-files?path=${encodeURIComponent(selectedFolder.value)}`, { credentials: 'include' })
-    if (!res.ok) { toast('Erreur lors du scan', 'error'); return }
+    const res = await fetch(`/api/browse-files?path=${encodeURIComponent(serieFolder.value)}`, { credentials: 'include' })
+    if (!res.ok) {
+      const data = await res.json()
+      scanError.value = data.error ?? 'Erreur lors du scan'
+      return
+    }
    const data = await res.json()
-    files.value = data.files ?? []
+    const files: { name: string; path: string; size: number }[] = data.files ?? []
+
+    const organizedByPath = buildOrganizedByPath()
+
+    items.value = files.map(f => {
+      // 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 }
+      }

-    items.value = files.value.map(f => {
      const match = autoMatch(f.name)
-      return { file: f, ...match }
+      return { file: f, ...match, alreadyImported: false, willRename: match.episode_id !== null }
    })
-
-    step.value = 'match'
  } catch {
-    toast('Impossible de contacter le serveur', 'error')
+    scanError.value = 'Impossible de contacter le serveur'
  } finally {
    scanning.value = false
  }
 }

 async function doImport() {
-  importing.value  = true
+  importing.value   = true
  importError.value = ''

  const payload = items.value
-      .filter(i => i.episode_id !== null)
-      .map(i => ({
-        file_path  : i.file.path,
-        episode_id : i.episode_id,
-        hash       : i.hash,
-      }))
+      .filter(i => i.episode_id !== null && !i.alreadyImported)
+      .map(i => ({ file_path: i.file.path, episode_id: i.episode_id, hash: i.hash }))
+
+  if (payload.length === 0) {
+    importError.value = 'Aucun nouveau fichier à importer'
+    importing.value   = false
+    return
+  }

  try {
    const res = await fetch('/api/manual-import', {
@@ -297,10 +321,8 @@ async function doImport() {
      credentials: 'include',
      body       : JSON.stringify({ serie_id: props.serieId, items: payload }),
    })
-
    const data = await res.json()
    if (!res.ok) { importError.value = data.error ?? 'Erreur inconnue'; return }
-
    importResult.value = { done: data.done, errors: data.errors ?? [] }
    step.value = 'done'
  } catch {
@@ -309,4 +331,6 @@ async function doImport() {
    importing.value = false
  }
 }
+
+onMounted(scan)
 </script>
@@ -0,0 +1,122 @@
+<template>
+  <div>
+    <!-- Barre search + tri + colonnes -->
+    <div class="flex items-center gap-2 mb-4">
+      <div class="relative flex-1 max-w-xs">
+        <Search class="absolute left-3 top-1/2 -translate-y-1/2 text-muted pointer-events-none" :size="14" />
+        <input
+            :value="search"
+            @input="emit('update:search', ($event.target as HTMLInputElement).value)"
+            type="text" placeholder="Rechercher..."
+            class="settings-input pl-9 w-full py-1.5 text-sm"
+        />
+      </div>
+
+      <!-- Tri -->
+      <div class="relative shrink-0" ref="sortRef">
+        <button @click="sortOpen = !sortOpen" class="btn-secondary flex items-center gap-1.5 py-1.5 px-2.5" :class="activeSort !== 'none' ? 'border-accent text-accent' : ''">
+          <ArrowUpDown :size="14" />
+          <span class="hidden md:inline text-xs">Trier</span>
+          <span v-if="activeSort !== 'none'" class="absolute -top-1 -right-1 w-2 h-2 rounded-full bg-accent" />
+        </button>
+        <div v-if="sortOpen" class="absolute top-full right-0 mt-1 bg-card border border-border rounded-xl p-2 z-20 w-48 flex flex-col gap-0.5 shadow-xl">
+          <button v-for="s in sortOptions" :key="s.value" @click="handleSort(s.value)"
+                  class="flex items-center justify-between px-3 py-2 rounded-lg text-xs transition-colors"
+                  :class="activeSort === s.value ? 'bg-active text-primary' : 'text-secondary hover:bg-hover'">
+            {{ s.label }}
+            <span v-if="activeSort === s.value && sortDir === 'asc'">↑</span>
+            <span v-else-if="activeSort === s.value && sortDir === 'desc'">↓</span>
+          </button>
+        </div>
+      </div>
+
+      <!-- Colonnes -->
+      <div class="relative shrink-0" ref="colRef">
+        <button @click="colOpen = !colOpen" class="btn-secondary flex items-center gap-1.5 py-1.5 px-2.5" :class="colOpen ? 'border-accent text-accent' : ''">
+          <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+            <circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"/>
+          </svg>
+          <span class="hidden md:inline text-xs">Colonnes</span>
+        </button>
+        <div v-if="colOpen" class="absolute top-full right-0 mt-1 bg-card border border-border rounded-xl p-2 z-20 w-52 flex flex-col gap-0.5 shadow-xl">
+          <p class="text-[10px] text-muted px-3 py-1">Colonnes affichées</p>
+          <label v-for="col in columnOptions" :key="col.key" class="flex items-center gap-2.5 px-3 py-2 rounded-lg text-xs cursor-pointer hover:bg-hover transition-colors">
+            <input type="checkbox" :checked="columns[col.key]" @change="emit('toggle-col', col.key)" class="accent-accent" />
+            {{ col.label }}
+          </label>
+        </div>
+      </div>
+    </div>
+
+    <!-- Onglets + filtres -->
+    <div class="flex items-center justify-between mb-4">
+      <div class="flex gap-1 bg-shell rounded-lg p-1 border border-border">
+        <button @click="emit('update:activeTab', 'active')" class="px-4 py-1.5 text-xs rounded-md transition-colors" :class="activeTab === 'active' ? 'bg-active text-primary' : 'text-muted hover:text-primary'">
+          En cours
+          <span v-if="activeCount > 0" class="ml-1.5 text-[10px] text-accent">{{ activeCount }}</span>
+        </button>
+        <button @click="emit('update:activeTab', 'done')" class="px-4 py-1.5 text-xs rounded-md transition-colors" :class="activeTab === 'done' ? 'bg-active text-primary' : 'text-muted hover:text-primary'">
+          Terminés
+          <span v-if="doneCount > 0" class="ml-1.5 text-[10px] text-accent">{{ doneCount }}</span>
+        </button>
+      </div>
+
+      <div v-if="activeTab === 'done'" class="flex items-center gap-3">
+        <label class="flex items-center gap-1.5 cursor-pointer">
+          <span class="text-xs text-muted">Seeds uniquement</span>
+          <button @click="emit('update:seedingOnly', !seedingOnly)" class="relative shrink-0 w-10 h-[22px] rounded-full transition-colors duration-200" :class="seedingOnly ? 'bg-green-500' : 'bg-border'">
+            <span class="absolute top-[3px] left-[3px] w-4 h-4 rounded-full bg-white transition-transform duration-200" :class="seedingOnly ? 'translate-x-[18px]' : 'translate-x-0'" />
+          </button>
+        </label>
+        <label class="flex items-center gap-1.5 cursor-pointer">
+          <span class="text-xs text-muted">Masquer importés</span>
+          <button @click="emit('update:hideImported', !hideImported)" class="relative shrink-0 w-10 h-[22px] rounded-full transition-colors duration-200" :class="hideImported ? 'bg-accent' : 'bg-border'">
+            <span class="absolute top-[3px] left-[3px] w-4 h-4 rounded-full bg-white transition-transform duration-200" :class="hideImported ? 'translate-x-[18px]' : 'translate-x-0'" />
+          </button>
+        </label>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { Search, ArrowUpDown } from 'lucide-vue-next'
+import { onClickOutside } from '@vueuse/core'
+
+const props = defineProps<{
+  search      : string
+  activeSort  : string
+  sortDir     : 'asc' | 'desc'
+  activeTab   : 'active' | 'done'
+  seedingOnly : boolean
+  hideImported: boolean
+  columns     : Record<string, boolean>
+  activeCount : number
+  doneCount   : number
+  columnOptions: { key: string; label: string }[]
+  sortOptions  : { label: string; value: string }[]
+}>()
+
+const emit = defineEmits<{
+  'update:search'     : [value: string]
+  'update:activeTab'  : [value: 'active' | 'done']
+  'update:seedingOnly': [value: boolean]
+  'update:hideImported': [value: boolean]
+  'sort'              : [value: string]
+  'toggle-col'        : [key: string]
+}>()
+
+const sortOpen = ref(false)
+const colOpen  = ref(false)
+const sortRef  = ref<HTMLElement | null>(null)
+const colRef   = ref<HTMLElement | null>(null)
+
+onClickOutside(sortRef, () => { sortOpen.value = false })
+onClickOutside(colRef,  () => { colOpen.value  = false })
+
+function handleSort(val: string) {
+  emit('sort', val)
+  sortOpen.value = false
+}
+</script>
@@ -0,0 +1,157 @@
+<template>
+  <div class="settings-card flex flex-col gap-3">
+
+    <!-- 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>
+        <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>
+        </div>
+      </div>
+      <div class="text-right shrink-0">
+        <p class="text-sm font-semibold text-primary">{{ clampedProgress }}%</p>
+        <p v-if="columns.size" class="text-xs text-muted mt-0.5">{{ formatSize(torrent.downloaded) }} / {{ formatSize(torrent.size) }}</p>
+      </div>
+    </div>
+
+    <!-- Barre de progression -->
+    <div class="h-1 bg-border rounded-full overflow-hidden">
+      <div class="h-full rounded-full transition-all duration-500"
+           :class="torrent.state === 'seeding' || torrent.state === 'unknown' ? 'bg-green-500' : torrent.state === 'error' ? 'bg-red-500' : torrent.state === 'paused' ? 'bg-muted' : 'bg-accent'"
+           :style="{ width: `${clampedProgress}%` }" />
+    </div>
+
+    <!-- Infos + actions -->
+    <div class="flex items-center justify-between">
+      <div class="flex items-center gap-3 text-xs text-muted">
+        <span v-if="torrent.state === 'downloading'">↓ {{ formatSpeed(torrent.speed) }}</span>
+        <span v-if="torrent.state === 'downloading' && torrent.eta > 0">ETA {{ formatEta(torrent.eta) }}</span>
+        <template v-if="torrent.state === 'seeding'">
+          <span class="text-green-500">Complété</span>
+          <span v-if="columns.ratio" class="font-mono" :class="torrent.ratio >= 1 ? 'text-green-400' : torrent.ratio >= 0.5 ? 'text-yellow-500' : 'text-muted'">R {{ torrent.ratio?.toFixed(2) ?? '0.00' }}</span>
+          <span v-if="columns.uploaded">↑ {{ formatSize(torrent.uploaded ?? 0) }}</span>
+          <span v-if="columns.upspeed && torrent.upspeed > 0">{{ formatSpeed(torrent.upspeed) }}</span>
+        </template>
+        <span v-if="torrent.state === 'unknown'" class="text-yellow-500">État non remonté par le client</span>
+      </div>
+
+      <div class="flex items-center gap-2">
+
+        <!-- Actions terminés -->
+        <template v-if="torrent.state === 'seeding' || torrent.state === 'unknown'">
+          <!-- Erreurs -->
+          <div v-if="torrent.errorFiles?.length > 0" class="relative group/err">
+            <span class="text-xs px-2 py-0.5 rounded border border-red-500/40 text-red-400 cursor-default">{{ torrent.errorFiles.length }} erreur{{ torrent.errorFiles.length > 1 ? 's' : '' }}</span>
+            <div class="absolute bottom-full right-0 mb-2 hidden group-hover/err:block z-10 w-80">
+              <div class="bg-card border border-red-500/30 rounded-lg p-3 text-xs shadow-xl">
+                <p class="text-red-400 mb-2 font-medium">Fichiers en erreur</p>
+                <div v-for="e in torrent.errorFiles" :key="e.file" class="mb-1.5 last:mb-0">
+                  <p class="text-primary truncate">{{ e.file }}</p>
+                  <p class="text-muted">{{ e.error }}</p>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          <!-- Badge import -->
+          <span class="text-xs px-2 py-0.5 rounded border"
+                :class="torrent.organizeState === 'done' ? 'border-green-500/40 text-green-500' : torrent.organizeState === 'partial' ? 'border-yellow-500/40 text-yellow-500' : 'border-border text-muted'">
+            {{ torrent.organizeState === 'done'
+              ? `Importé (${torrent.organizeProgress?.done}/${torrent.organizeProgress?.total})`
+              : torrent.organizeState === 'partial'
+                ? `En cours (${torrent.organizeProgress?.done}/${torrent.organizeProgress?.total})`
+                : '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>
+        </template>
+
+        <!-- Bouton supprimer -->
+        <div class="relative">
+          <button
+              @click="emit('toggle-confirm', torrent.hash)"
+              :disabled="deleting"
+              class="w-7 h-7 flex items-center justify-center rounded-lg border border-border text-muted hover:border-red-500/40 hover:text-red-400 transition-colors"
+          >
+            <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+              <polyline points="3 6 5 6 21 6"/>
+              <path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/>
+              <path d="M10 11v6M14 11v6M9 6V4h6v2"/>
+            </svg>
+          </button>
+          <div v-if="showConfirmDelete" class="absolute bottom-full right-0 mb-2 bg-card border border-border rounded-xl p-3 z-10 w-52 shadow-xl">
+            <p class="text-xs text-primary font-medium mb-2">
+              {{ tab === 'active' ? 'Annuler ce téléchargement ?' : 'Supprimer ce torrent ?' }}
+            </p>
+            <label class="flex items-center gap-2 text-xs text-muted mb-3 cursor-pointer">
+              <input type="checkbox" v-model="withFiles" class="accent-red-500" />
+              Supprimer aussi les fichiers
+            </label>
+            <div class="flex gap-1.5">
+              <button @click="emit('delete', torrent, withFiles)" :disabled="deleting" class="flex-1 text-xs py-1 px-2 rounded-lg bg-red-500/10 text-red-400 border border-red-500/30 hover:bg-red-500/20 transition-colors">
+                {{ deleting ? '...' : 'Confirmer' }}
+              </button>
+              <button @click="emit('toggle-confirm', null)" class="flex-1 text-xs py-1 px-2 rounded-lg border border-border text-muted hover:text-primary transition-colors">
+                Annuler
+              </button>
+            </div>
+          </div>
+        </div>
+
+      </div>
+    </div>
+
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed } from 'vue'
+
+const props = defineProps<{
+  torrent         : any
+  tab             : 'active' | 'done'
+  columns         : Record<string, boolean>
+  importing       : boolean
+  deleting        : boolean
+  showConfirmDelete: boolean
+}>()
+
+const emit = defineEmits<{
+  import        : [torrent: any]
+  delete        : [torrent: any, withFiles: boolean]
+  'toggle-confirm': [hash: string | null]
+}>()
+
+const withFiles = ref(false)
+
+const clampedProgress = computed(() => Math.min(100, Math.max(0, props.torrent.progress ?? 0)))
+
+function stateBadge(state: string) {
+  return ({
+    downloading: { label: 'Téléchargement', class: 'border-accent/40 text-accent' },
+    seeding    : { label: 'Complété',       class: 'border-green-500/40 text-green-500' },
+    paused     : { label: 'En pause',       class: 'border-border text-muted' },
+    checking   : { label: 'Vérification',   class: 'border-yellow-500/40 text-yellow-500' },
+    error      : { label: 'Erreur',         class: 'border-red-500/40 text-red-400' },
+    unknown    : { label: 'État inconnu',   class: 'border-yellow-500/40 text-yellow-500' },
+  } as Record<string, any>)[state] ?? { label: 'Inconnu', class: 'border-border text-muted' }
+}
+function formatSize(bytes: number): string {
+  if (!bytes) return '0 B'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`
+}
+function formatSpeed(bps: number) { return `${formatSize(bps)}/s` }
+function formatEta(seconds: number): string {
+  if (seconds < 0 || seconds > 86400 * 7) return '∞'
+  const h = Math.floor(seconds / 3600), m = Math.floor((seconds % 3600) / 60), s = seconds % 60
+  if (h > 0) return `${h}h${m.toString().padStart(2, '0')}m`
+  if (m > 0) return `${m}m${s.toString().padStart(2, '0')}s`
+  return `${s}s`
+}
+</script>
@@ -27,6 +27,32 @@
      </template>
    </nav>

+    <!-- Nouvelle version disponible -->
+    <a
+        v-if="updateAvailable"
+        :href="latestReleaseUrl"
+        target="_blank"
+        rel="noopener"
+        class="mx-2 mb-2 flex items-center gap-2.5 px-3 py-2.5 rounded-lg border border-accent/30 bg-accent/5 hover:bg-accent/10 transition-colors group"
+    >
+      <div class="w-1.5 h-1.5 rounded-full bg-accent animate-pulse shrink-0" />
+      <div class="flex-1 min-w-0">
+        <p class="text-xs font-medium text-accent">Mise à jour disponible</p>
+        <p class="text-[11px] text-muted truncate">{{ latestVersion }} est disponible</p>
+      </div>
+      <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"
+           class="shrink-0 text-muted group-hover:text-accent transition-colors">
+        <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/>
+        <polyline points="15 3 21 3 21 9"/>
+        <line x1="10" y1="14" x2="21" y2="3"/>
+      </svg>
+    </a>
+
+    <!-- Version actuelle -->
+    <div class="px-3 pb-1 pt-0.5">
+      <p class="text-[10px] text-muted/50 font-mono">{{ currentVersion }}</p>
+    </div>
+
    <!-- Thème -->
    <ThemeSwitcher />

@@ -34,6 +60,7 @@
 </template>

 <script setup lang="ts">
+import { ref, onMounted } from 'vue'
 import { useRouter, RouterLink } from 'vue-router'
 import { LogOut } from 'lucide-vue-next'
 import { useAuthStore } from '@/stores/auth'
@@ -46,8 +73,66 @@ defineProps<{ items: NavItem[] }>()
 const router = useRouter()
 const auth   = useAuthStore()

+const currentVersion = ref(
+    import.meta.env.DEV ? 'dev' : ''
+)
+const latestVersion     = ref('')
+const latestReleaseUrl  = ref('https://github.com/masutayunikon/FanKarr/releases/latest')
+const updateAvailable   = ref(false)
+
+const GITHUB_REPO = 'masutayunikon/FanKarr'
+
+function parseVersion(v: string): number[] {
+  return v.replace(/^v/, '').split('.').map(n => parseInt(n, 10) || 0)
+}
+
+function isNewer(latest: string, current: string): boolean {
+  if (current === 'dev') return false
+  const l = parseVersion(latest)
+  const c = parseVersion(current)
+  for (let i = 0; i < Math.max(l.length, c.length); i++) {
+    const lv = l[i] ?? 0
+    const cv = c[i] ?? 0
+    if (lv > cv) return true
+    if (lv < cv) return false
+  }
+  return false
+}
+
+async function checkForUpdates() {
+  try {
+    // Version locale
+    const vRes = await fetch('/api/version', { credentials: 'include' })
+    if (vRes.ok) {
+      const { version } = await vRes.json()
+      currentVersion.value = version
+    }
+
+    if (currentVersion.value === 'dev') return
+
+    // Dernière release GitHub
+    const gRes = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+      headers: { Accept: 'application/vnd.github.v3+json' },
+    })
+    if (!gRes.ok) return
+    const release = await gRes.json()
+    latestVersion.value    = release.tag_name ?? ''
+    latestReleaseUrl.value = release.html_url ?? latestReleaseUrl.value
+
+    if (isNewer(latestVersion.value, currentVersion.value)) {
+      updateAvailable.value = true
+    }
+  } catch {}
+}
+
 async function logout() {
  await auth.logout()
  router.push('/auth')
 }
+
+onMounted(() => {
+  checkForUpdates()
+  // Revérifier toutes les 6h
+  setInterval(checkForUpdates, 6 * 60 * 60 * 1000)
+})
 </script>
@@ -0,0 +1,176 @@
+<template>
+  <div class="relative">
+    <div v-if="serie.fanart_image" class="absolute inset-0 h-64 overflow-hidden pointer-events-none">
+      <img
+          :src="serie.fanart_image"
+          class="w-full h-full object-cover opacity-15"
+          @error="(e) => ((e.target as HTMLElement).closest('div') as HTMLElement).style.display = 'none'"
+      />
+      <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]">
+      <!-- Poster -->
+      <div class="shrink-0 w-32 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" />
+        </div>
+      </div>
+
+      <!-- Infos -->
+      <div class="flex flex-col gap-3 justify-end min-w-0">
+        <RouterLink to="/series" class="inline-flex items-center gap-1.5 text-xs text-muted hover:text-primary transition-colors w-fit">
+          <ArrowLeft :size="13" />
+          Séries
+        </RouterLink>
+
+        <!-- Titre + boutons actions -->
+        <div class="flex items-center gap-3 flex-wrap">
+          <h1 class="text-2xl font-bold text-primary tracking-tight">{{ serie.title }}</h1>
+
+          <button
+              @click="emit('openManualImport')"
+              class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border border-border text-muted hover:text-primary hover:border-secondary transition shrink-0"
+          >
+            <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+              <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+              <polyline points="17 8 12 3 7 8"/>
+              <line x1="12" y1="3" x2="12" y2="15"/>
+            </svg>
+            Import manuel
+          </button>
+
+          <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 rounded-lg border border-border text-muted hover:text-red-400 hover:border-red-500/40 transition shrink-0"
+            >
+              <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="emit('unimport', 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="emit('unimport', 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>
+        </div>
+
+        <!-- Métadonnées -->
+        <div class="flex flex-wrap items-center gap-2">
+          <span v-if="serie.year" class="text-sm text-muted">{{ serie.year }}</span>
+          <span
+              v-if="serie.status"
+              class="text-xs px-2 py-0.5 rounded-full border"
+              :class="serie.status.toLowerCase() === 'continuing'
+              ? 'bg-green-500/15 text-green-400 border-green-500/20'
+              : 'bg-hover text-muted border-border'"
+          >{{ serie.status }}</span>
+        </div>
+
+        <p v-if="serie.plot" class="text-sm text-secondary leading-relaxed max-w-2xl line-clamp-3">
+          {{ serie.plot }}
+        </p>
+
+        <!-- Boutons intégrale / tout télécharger -->
+        <div class="flex flex-wrap gap-2 mt-1">
+          <button
+              v-if="hasDownloadableTorrents"
+              @click="emit('downloadAll')"
+              :disabled="downloadingAll"
+              class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium rounded-lg bg-accent text-white hover:bg-accent-hover transition"
+              :class="downloadingAll ? 'opacity-50 cursor-not-allowed' : ''"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none" :class="downloadingAll ? 'animate-spin' : ''">
+              <path v-if="!downloadingAll" d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline v-if="!downloadingAll" points="7 10 12 15 17 10"/><line v-if="!downloadingAll" x1="12" y1="15" x2="12" y2="3"/>
+              <path v-else d="M21 12a9 9 0 0 1-9 9 9 9 0 0 1-6.36-2.64M3 12a9 9 0 0 1 9-9 9 9 0 0 1 6.36 2.64"/>
+            </svg>
+            {{ downloadingAll ? 'Envoi…' : 'Tout télécharger' }}
+          </button>
+
+          <button
+              v-for="(t, i) in torrentsIntegrale"
+              :key="i"
+              :title="t.raw"
+              class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium rounded-lg transition"
+              :class="[
+              t.label === 'Intégrale'
+                ? 'bg-accent text-white hover:bg-accent-hover'
+                : 'bg-accent-muted text-accent border border-accent/20 hover:bg-accent/20',
+              (isAlreadyQueued(t) || isDownloaded(`integrale-${i}`))
+                ? 'opacity-50 cursor-not-allowed' : ''
+            ]"
+              :disabled="isAlreadyQueued(t) || isDownloaded(`integrale-${i}`)"
+              @click="emit('download', `integrale-${i}`, t.torrent_url, t.magnet)"
+          >
+            <component :is="btnIcon(`integrale-${i}`, t)" />
+            {{ isAlreadyQueued(t) ? 'Déjà ajouté' : isDownloaded(`integrale-${i}`) ? 'Envoyé ✓' : t.label }}
+          </button>
+        </div>
+
+        <!-- Progression intégrale -->
+        <template v-for="(t, i) in torrentsIntegrale" :key="`prog-${i}`">
+          <div v-if="torrentProgress(extractHash(t)) && torrentProgress(extractHash(t))!.progress < 100" class="h-0.5 bg-border rounded-full overflow-hidden">
+            <div class="h-full bg-accent rounded-full transition-all duration-500" :style="{ width: `${torrentProgress(extractHash(t))!.progress}%` }" />
+          </div>
+        </template>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, h } from 'vue'
+import { RouterLink } from 'vue-router'
+import { ArrowLeft, Tv, Download, Loader, Check } from 'lucide-vue-next'
+
+interface ActiveTorrent { hash: string; progress: number; state: string }
+
+const props = defineProps<{
+  serie               : any
+  torrentsIntegrale   : any[]
+  organizedByEpisode  : Record<string, any>
+  hasDownloadableTorrents: boolean
+  downloadingAll      : boolean
+  activeTorrents      : ActiveTorrent[]
+  downloading         : string[]
+  downloaded          : string[]
+}>()
+
+const emit = defineEmits<{
+  openManualImport: []
+  unimport        : [deleteFile: boolean]
+  downloadAll     : []
+  download        : [key: string, url: string | null, magnet: string | null]
+}>()
+
+const unimportMenuOpen = ref(false)
+
+function isDownloaded(key: string)  { return props.downloaded.includes(key) }
+function isAlreadyQueued(torrent: any): boolean {
+  const hash = extractHash(torrent)
+  if (!hash) return false
+  return props.activeTorrents.some(t => t.hash.toLowerCase() === hash.toLowerCase())
+}
+function extractHash(torrent: any): string | null {
+  if (!torrent?.magnet) return null
+  const m = torrent.magnet.match(/xt=urn:btih:([a-fA-F0-9]{40})/i)
+  return m ? m[1].toLowerCase() : null
+}
+function torrentProgress(hash: string | null | undefined): ActiveTorrent | null {
+  if (!hash) return null
+  return props.activeTorrents.find(t => t.hash.toLowerCase() === hash.toLowerCase()) ?? null
+}
+function btnIcon(key: string, torrent: any) {
+  if (isDownloaded(key) || isAlreadyQueued(torrent)) return h(Check, { size: 14 })
+  return h(Download, { size: 14 })
+}
+
+defineExpose({ closeUnimportMenu: () => { unimportMenuOpen.value = false } })
+</script>
@@ -0,0 +1,283 @@
+<template>
+  <div class="bg-card border border-border rounded-xl overflow-hidden">
+    <!-- Header saison -->
+    <div class="flex items-center justify-between px-5 py-3.5 border-b border-border">
+      <div class="flex items-center gap-3">
+        <button class="text-muted hover:text-primary transition-colors" @click="emit('toggle', season.id)">
+          <ChevronUp :size="15" class="transition-transform duration-200" :class="collapsed ? 'rotate-180' : ''" />
+        </button>
+        <div>
+          <h2 class="text-sm font-semibold text-primary">
+            {{ season.season_number === 0 ? 'Spéciaux' : `Saison ${season.season_number}` }}
+            <span v-if="season.title && season.title !== `Saison ${season.season_number}`" class="text-muted font-normal ml-1">
+              — {{ season.title }}
+            </span>
+          </h2>
+          <p class="text-xs text-muted mt-0.5">
+            {{ season.episodes.length }} épisode{{ season.episodes.length > 1 ? 's' : '' }}
+            <template v-if="availableCount > 0"> · {{ availableCount }}/{{ season.episodes.length }} dispo</template>
+            <span
+                v-if="season.organized_state !== 'none'"
+                class="ml-1.5 px-1.5 py-0.5 rounded text-[10px]"
+                :class="season.organized_state === 'complete' ? 'bg-green-500/10 text-green-400' : 'bg-yellow-500/10 text-yellow-500'"
+            >
+              {{ season.organized_state === 'complete'
+                ? `✓ ${season.organized_count} importé${season.organized_count > 1 ? 's' : ''}`
+                : `${season.organized_count}/${availableCount || season.episodes.length} importés` }}
+            </span>
+          </p>
+        </div>
+      </div>
+
+      <!-- Boutons saison -->
+      <div class="flex items-center gap-2">
+        <button
+            v-if="!season.torrent && hasDownloadable"
+            @click="emit('downloadSeason', season)"
+            :disabled="downloadingSeason"
+            class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border bg-accent-muted text-accent border-accent/20 hover:bg-accent/20 transition"
+        >
+          <component :is="downloadingSeason ? loaderIcon : downloadIcon" />
+          {{ downloadingSeason ? 'Envoi…' : 'Tout télécharger' }}
+        </button>
+
+        <button
+            class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border transition"
+            :class="canDownloadSeason
+            ? 'bg-accent-muted text-accent border-accent/20 hover:bg-accent/20'
+            : 'text-muted border-border cursor-not-allowed opacity-50'"
+            :disabled="!canDownloadSeason"
+            @click="canDownloadSeason && emit('download', `season-${season.id}`, season.torrent.torrent_url, season.torrent.magnet)"
+        >
+          <component :is="seasonBtnIcon" />
+          {{ seasonBtnLabel }}
+        </button>
+      </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
+          v-for="ep in season.episodes"
+          :key="ep.id"
+          class="px-5 py-3 hover:bg-hover/50 transition-colors"
+          :class="{ 'opacity-40': !ep.available && !ep.organized }"
+      >
+        <div class="flex items-center gap-3">
+          <!-- Thumbnail -->
+          <div class="shrink-0 w-20 aspect-video rounded-md overflow-hidden bg-shell hidden sm:flex items-center justify-center text-muted text-xs font-mono">
+            <img v-if="ep.thumb_image" :src="ep.thumb_image" class="w-full h-full object-cover" loading="lazy" />
+            <span v-else>{{ season.season_number === 0 ? 'SP' : `E${ep.episode_number}` }}</span>
+          </div>
+
+          <!-- Infos épisode -->
+          <div class="flex-1 min-w-0">
+            <div class="flex items-center gap-2">
+              <span class="text-xs text-muted shrink-0 font-mono">
+                {{ season.season_number === 0 ? 'SP' : `E${String(ep.episode_number).padStart(2, '0')}` }}
+              </span>
+              <span class="text-sm text-primary truncate">{{ ep.title || `Épisode ${ep.episode_number}` }}</span>
+              <span
+                  v-if="ep.fankai === false || ep.torrent?.fankai === false"
+                  class="shrink-0 text-[10px] px-1.5 py-0.5 rounded border bg-purple-500/10 text-purple-400 border-purple-500/20"
+                  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">
+              <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>
+            </div>
+          </div>
+
+          <!-- Bouton état épisode -->
+          <button
+              class="shrink-0 w-8 h-8 rounded-lg border flex items-center justify-center transition-colors"
+              :class="epBtnClass(ep)"
+              :disabled="!ep.torrent || ep.organized || isAlreadyQueued(ep.torrent)"
+              @click="ep.torrent && !ep.organized && !isAlreadyQueued(ep.torrent) && emit('download', `ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet)"
+          >
+            <component :is="epStateIcon(ep)" />
+          </button>
+
+          <!-- Actions épisode importé -->
+          <template v-if="ep.organized && organizedByEpisode[String(ep.id)]">
+            <span
+                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"
+                :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>
+          </template>
+        </div>
+
+        <!-- Barre progression épisode -->
+        <div v-if="epProgress(ep) && epProgress(ep)!.progress < 100" class="mt-1.5 sm:pl-[92px]">
+          <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: `${epProgress(ep)!.progress}%` }" />
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, h } from 'vue'
+import { ChevronUp, Download, Loader, Check, X } from 'lucide-vue-next'
+
+interface ActiveTorrent { hash: string; progress: number; state: string }
+
+const props = defineProps<{
+  season            : any
+  collapsed         : boolean
+  activeTorrents    : ActiveTorrent[]
+  downloading       : string[]
+  downloaded        : string[]
+  organizedByEpisode: Record<string, any>
+  epActionLoading   : Record<number, boolean>
+  downloadingSeason ?: boolean
+  nfoSupport        ?: boolean
+}>()
+
+const emit = defineEmits<{
+  toggle         : [id: number]
+  download       : [key: string, url: string | null, magnet: string | null]
+  downloadSeason : [season: any]
+  renameEpisode  : [ep: any, season: any]
+  unimportEpisode: [ep: any, season: any, deleteFile: boolean]
+}>()
+
+const epMenuOpen = ref<number | null>(null)
+const downloadIcon = h(Download, { size: 12 })
+const loaderIcon   = h(Loader, { size: 12, class: 'animate-spin' })
+
+// ── Helpers hash / progress ────────────────────────────────────
+function extractHash(torrent: any): string | null {
+  if (!torrent?.magnet) return null
+  const m = torrent.magnet.match(/xt=urn:btih:([a-fA-F0-9]{40})/i)
+  return m ? m[1].toLowerCase() : null
+}
+function torrentProgress(hash: string | null | undefined): ActiveTorrent | null {
+  if (!hash) return null
+  return props.activeTorrents.find(t => t.hash.toLowerCase() === hash.toLowerCase()) ?? null
+}
+function isDownloading(key: string) { return props.downloading.includes(key) }
+function isDownloaded(key: string)  { return props.downloaded.includes(key) }
+function isAlreadyQueued(torrent: any): boolean {
+  const hash = extractHash(torrent)
+  if (!hash) return false
+  return props.activeTorrents.some(t => t.hash.toLowerCase() === hash.toLowerCase())
+}
+
+// ── Computed saison ────────────────────────────────────────────
+const availableCount = computed(() => props.season.episodes.filter((e: any) => e.available).length)
+const seasonProgress = computed(() => torrentProgress(extractHash(props.season.torrent)))
+const hasDownloadable = computed(() =>
+    props.season.episodes.some((ep: any) =>
+        ep.torrent && ep.available && !ep.organized && !isAlreadyQueued(ep.torrent) && !isDownloaded(`ep-${ep.id}`)
+    )
+)
+const canDownloadSeason = computed(() =>
+    !!props.season.torrent && !isDownloading(`season-${props.season.id}`) && !isDownloaded(`season-${props.season.id}`) && !isAlreadyQueued(props.season.torrent) && props.season.organized_state !== 'complete'
+)
+const seasonBtnLabel = computed(() => {
+  if (props.season.organized_state === 'complete') return 'Importé'
+  if (isAlreadyQueued(props.season.torrent)) return 'Déjà ajouté'
+  if (isDownloaded(`season-${props.season.id}`)) return 'Envoyé'
+  return 'Saison entière'
+})
+const seasonBtnIcon = computed(() => {
+  if (props.season.organized_state === 'complete' || isDownloaded(`season-${props.season.id}`) || isAlreadyQueued(props.season.torrent)) return h(Check, { size: 12 })
+  if (isDownloading(`season-${props.season.id}`)) return h(Loader, { size: 12, class: 'animate-spin' })
+  if (!props.season.torrent) return h(X, { size: 12 })
+  return h(Download, { size: 12 })
+})
+
+// ── État épisode ───────────────────────────────────────────────
+function epProgress(ep: any) { return torrentProgress(extractHash(ep.torrent)) }
+
+function epState(ep: any): 'idle' | 'loading' | 'done' | 'unavailable' {
+  if (ep.organized || isDownloaded(`ep-${ep.id}`) || isAlreadyQueued(ep.torrent)) return 'done'
+  const prog = epProgress(ep)
+  if (prog && prog.progress < 100) return 'loading'
+  if (!ep.torrent || !ep.available) return 'unavailable'
+  if (isDownloading(`ep-${ep.id}`)) return 'loading'
+  return 'idle'
+}
+function epStateIcon(ep: any) {
+  const state = epState(ep)
+  if (state === 'done')        return h(Check,    { size: 14 })
+  if (state === 'loading')     return h(Loader,   { size: 14, class: 'animate-spin' })
+  if (state === 'unavailable') return h(X,        { size: 14 })
+  return h(Download, { size: 14 })
+}
+function epBtnClass(ep: any): string {
+  const state = epState(ep)
+  if (state === 'done')        return 'border-green-500/30 text-green-500 bg-green-500/10 cursor-default'
+  if (state === 'loading')     return 'border-accent/30 text-accent bg-accent-muted cursor-default'
+  if (state === 'unavailable') return 'border-border text-muted opacity-40 cursor-not-allowed'
+  return 'border-border text-muted hover:border-accent hover:text-accent cursor-pointer'
+}
+
+// ── Rename helpers ─────────────────────────────────────────────
+function epExpectedName(ep: any): string {
+  const entry = props.organizedByEpisode[String(ep.id)]
+  if (!entry) return ''
+  const srcExt = entry.dest_filename ? '.' + entry.dest_filename.split('.').pop() : '.mkv'
+  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
+  }
+}
+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
+}
+
+function formatDate(d: string): string {
+  if (!d) return ''
+  return new Date(d).toLocaleDateString('fr-FR', { year: 'numeric', month: 'short', day: 'numeric' })
+}
+function formatDuration(seconds: number): string {
+  if (!seconds || seconds <= 0) return ''
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  if (h > 0) return m > 0 ? `${h}h ${m}min` : `${h}h`
+  return `${m} min`
+}
+
+defineExpose({ closeEpMenu: () => { epMenuOpen.value = null } })
+</script>
@@ -0,0 +1,152 @@
+<template>
+  <div>
+    <!-- Toolbar -->
+    <div class="shrink-0 px-4 md:px-6 py-3 border-b border-border flex flex-col gap-2">
+
+      <!-- Ligne 1 : recherche + filtres -->
+      <div class="flex items-center gap-2">
+
+        <div class="relative flex-1">
+          <Search class="absolute left-3 top-1/2 -translate-y-1/2 text-muted pointer-events-none" :size="14" />
+          <input
+              :value="search"
+              @input="emit('update:search', ($event.target as HTMLInputElement).value)"
+              type="text"
+              placeholder="Rechercher…"
+              class="settings-input pl-9 w-full py-1.5 text-sm"
+          />
+        </div>
+
+        <!-- Filtres -->
+        <div class="relative shrink-0" ref="filterRef">
+          <button
+              @click="filterOpen = !filterOpen"
+              class="btn-secondary flex items-center gap-1.5 py-1.5 px-2.5 relative"
+              :class="hasActiveFilter ? 'border-accent text-accent' : ''"
+              title="Filtres"
+          >
+            <SlidersHorizontal :size="15" />
+            <span class="hidden md:inline text-xs">Filtres</span>
+            <ChevronDown class="hidden md:inline transition-transform" :size="12" :class="filterOpen ? 'rotate-180' : ''" />
+            <span v-if="hasActiveFilter" class="absolute -top-1 -right-1 w-2 h-2 rounded-full bg-accent" />
+          </button>
+
+          <div
+              v-if="filterOpen"
+              class="absolute top-full right-0 mt-1 bg-card border border-border rounded-xl p-3 z-20 w-52 flex flex-col gap-3 shadow-xl"
+          >
+            <div>
+              <p class="text-xs text-muted mb-1.5">Disponibilité</p>
+              <div class="flex flex-col gap-1">
+                <button
+                    v-for="f in filtersDisponibilite" :key="f.value"
+                    @click="emit('update:activeFilter', f.value)"
+                    class="flex items-center justify-between px-2 py-1.5 rounded-lg text-xs transition-colors"
+                    :class="activeFilter === f.value ? 'bg-active text-primary' : 'text-secondary hover:bg-hover'"
+                >
+                  {{ f.label }}
+                  <span v-if="activeFilter === f.value" class="w-1.5 h-1.5 rounded-full bg-accent" />
+                </button>
+              </div>
+            </div>
+            <div class="border-t border-border pt-3">
+              <p class="text-xs text-muted mb-1.5">État import</p>
+              <div class="flex flex-col gap-1">
+                <button
+                    v-for="f in filtersImport" :key="f.value"
+                    @click="emit('update:activeFilter', f.value)"
+                    class="flex items-center justify-between px-2 py-1.5 rounded-lg text-xs transition-colors"
+                    :class="activeFilter === f.value ? 'bg-active text-primary' : 'text-secondary hover:bg-hover'"
+                >
+                  <div class="flex items-center gap-2">
+                    <span class="w-2 h-2 rounded-full shrink-0" :style="{ background: f.color }" />
+                    {{ f.label }}
+                  </div>
+                  <span v-if="activeFilter === f.value" class="w-1.5 h-1.5 rounded-full bg-accent" />
+                </button>
+              </div>
+            </div>
+            <button
+                v-if="hasActiveFilter"
+                @click="emit('update:activeFilter', 'all')"
+                class="text-xs text-muted hover:text-primary transition-colors text-left pt-1 border-t border-border"
+            >
+              Effacer les filtres
+            </button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Ligne 2 : tri + taille + count -->
+      <div class="flex items-center gap-2 flex-wrap">
+        <div class="flex items-center gap-1">
+          <button
+              v-for="s in sortOptions" :key="s.value"
+              @click="emit('update:activeSort', s.value)"
+              class="px-2.5 py-1 text-xs rounded-lg border transition-colors"
+              :class="activeSort === s.value
+              ? 'border-accent text-accent bg-accent-muted'
+              : 'border-border text-muted hover:border-secondary'"
+          >
+            {{ s.label }}
+          </button>
+        </div>
+
+        <div class="flex items-center gap-1 border-l border-border pl-2 ml-auto">
+          <button
+              v-for="(_, size) in posterSizes" :key="size"
+              @click="emit('update:posterSize', size)"
+              class="w-7 h-7 text-[10px] rounded-md border transition-colors flex items-center justify-center"
+              :class="posterSize === size
+              ? 'border-accent text-accent bg-accent-muted'
+              : 'border-border text-muted hover:border-secondary'"
+          >
+            {{ size }}
+          </button>
+        </div>
+
+        <span class="text-xs text-muted">{{ count }} série{{ count > 1 ? 's' : '' }}</span>
+      </div>
+    </div>
+
+    <!-- Légende barres -->
+    <div class="shrink-0 px-4 md:px-6 py-2 flex items-center gap-4 border-b border-border">
+      <div v-for="l in legend" :key="l.label" class="flex items-center gap-1.5">
+        <span class="w-3 h-1.5 rounded-full" :style="{ background: l.color }" />
+        <span class="text-[11px] text-muted">{{ l.label }}</span>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { Search, SlidersHorizontal, ChevronDown } from 'lucide-vue-next'
+import { onClickOutside } from '@vueuse/core'
+
+defineProps<{
+  search              : string
+  activeFilter        : string
+  activeSort          : string
+  posterSize          : string
+  posterSizes         : Record<string, string>
+  count               : number
+  hasActiveFilter     : boolean
+  filtersDisponibilite: { label: string; value: string }[]
+  filtersImport       : { label: string; value: string; color: string }[]
+  sortOptions         : { label: string; value: string }[]
+  legend              : { label: string; color: string }[]
+}>()
+
+const emit = defineEmits<{
+  'update:search'      : [value: string]
+  'update:activeFilter': [value: string]
+  'update:activeSort'  : [value: string]
+  'update:posterSize'  : [value: string]
+}>()
+
+const filterOpen = ref(false)
+const filterRef  = ref<HTMLElement | null>(null)
+
+onClickOutside(filterRef, () => { filterOpen.value = false })
+</script>
@@ -0,0 +1,304 @@
+<template>
+  <Teleport to="body">
+    <div class="fixed inset-0 bg-black/60 flex items-center justify-center z-50 px-4" @click.self="emit('close')">
+      <div class="bg-card border border-border rounded-xl w-full max-w-lg flex flex-col" style="max-height: 85vh">
+
+        <!-- Header -->
+        <div class="flex items-center justify-between px-6 py-4 border-b border-border shrink-0">
+          <div>
+            <h3 class="text-sm font-semibold text-primary">Configuration Plex</h3>
+            <p class="text-xs text-muted mt-0.5">
+              {{ plexStep === 'auth'    ? 'Connectez votre compte Plex'   :
+                plexStep === 'server'  ? 'Choisissez votre serveur Plex' :
+                    plexStep === 'library' ? 'Créez la bibliothèque Fankai'  :
+                        plexStep === 'done'    ? 'Configuration terminée'        :
+                            'Erreur' }}
+            </p>
+          </div>
+          <button @click="emit('close')" class="text-muted hover:text-primary text-lg leading-none">✕</button>
+        </div>
+
+        <!-- Étape 1 : Auth -->
+        <div v-if="plexStep === 'auth'" class="flex flex-col gap-4 px-6 py-5">
+          <div v-if="!plexAuthMethod" class="flex flex-col gap-3">
+            <button
+                @click="startOAuth" :disabled="plexLoading"
+                class="flex items-center gap-3 p-4 rounded-lg border border-border hover:border-accent hover:bg-accent-muted transition-colors text-left"
+            >
+              <div class="w-8 h-8 rounded-lg bg-accent/10 flex items-center justify-center shrink-0">
+                <svg width="16" height="16" viewBox="0 0 24 24" fill="none">
+                  <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z" fill="#E5A50A" opacity=".2"/>
+                  <path d="M12 6v6l4 2" stroke="#E5A50A" stroke-width="2" stroke-linecap="round"/>
+                </svg>
+              </div>
+              <div>
+                <p class="text-sm font-medium text-primary">{{ plexLoading ? 'Ouverture…' : 'Connexion via Plex' }}</p>
+                <p class="text-xs text-muted">Google, Apple, ou compte Plex</p>
+              </div>
+            </button>
+
+            <button
+                @click="plexAuthMethod = 'credentials'"
+                class="flex items-center gap-3 p-4 rounded-lg border border-border hover:border-secondary transition-colors text-left"
+            >
+              <div class="w-8 h-8 rounded-lg bg-hover flex items-center justify-center shrink-0">
+                <svg width="16" height="16" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+                  <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/>
+                </svg>
+              </div>
+              <div>
+                <p class="text-sm font-medium text-primary">Email / Mot de passe</p>
+                <p class="text-xs text-muted">Connexion directe avec vos identifiants</p>
+              </div>
+            </button>
+          </div>
+
+          <!-- OAuth en attente -->
+          <div v-else-if="plexAuthMethod === 'oauth'" class="flex flex-col items-center gap-4 py-4 text-center">
+            <div class="w-10 h-10 border-2 border-border border-t-accent rounded-full animate-spin" />
+            <div>
+              <p class="text-sm text-primary font-medium">En attente de la connexion Plex…</p>
+              <p class="text-xs text-muted mt-1">Connectez-vous sur la page Plex qui s'est ouverte dans votre navigateur</p>
+            </div>
+            <button @click="cancelOAuth" class="text-xs text-muted hover:text-primary transition-colors">Annuler</button>
+          </div>
+
+          <!-- Formulaire credentials -->
+          <template v-else-if="plexAuthMethod === 'credentials'">
+            <div>
+              <label class="settings-label mb-1 block">Adresse e-mail Plex</label>
+              <input v-model="plexForm.username" type="email" class="settings-input w-full" placeholder="email@example.com" />
+            </div>
+            <div>
+              <label class="settings-label mb-1 block">Mot de passe</label>
+              <input v-model="plexForm.password" type="password" class="settings-input w-full" placeholder="••••••••" @keyup.enter="plexConnect" />
+            </div>
+            <div v-if="plexNeeds2FA">
+              <label class="settings-label mb-1 block">Code 2FA</label>
+              <input v-model="plexForm.code" type="text" class="settings-input w-full" placeholder="123456" maxlength="6" @keyup.enter="plexConnect" />
+            </div>
+            <p v-if="plexError" class="text-xs text-red-400">{{ plexError }}</p>
+            <div class="flex gap-2">
+              <button @click="plexConnect" :disabled="plexLoading || !plexForm.username || !plexForm.password" class="btn-primary">
+                {{ plexLoading ? 'Connexion…' : 'Se connecter' }}
+              </button>
+              <button @click="plexAuthMethod = null" class="btn-secondary">Retour</button>
+            </div>
+          </template>
+
+          <p v-if="plexError && !plexAuthMethod" class="text-xs text-red-400">{{ plexError }}</p>
+          <button v-if="!plexAuthMethod" @click="emit('close')" class="btn-secondary self-start">Annuler</button>
+        </div>
+
+        <!-- Étape 2 : Choix serveur -->
+        <div v-else-if="plexStep === 'server'" class="flex flex-col gap-3 px-6 py-5">
+          <p class="text-xs text-muted">{{ plexServers.length }} serveur{{ plexServers.length > 1 ? 's' : '' }} trouvé{{ plexServers.length > 1 ? 's' : '' }}</p>
+          <div
+              v-for="(server, i) in plexServers" :key="i"
+              @click="selectServer(server)"
+              class="flex items-center justify-between p-3 rounded-lg border cursor-pointer transition-colors"
+              :class="plexSelectedServer === server ? 'border-accent bg-accent-muted' : 'border-border hover:border-secondary'"
+          >
+            <div>
+              <p class="text-sm text-primary font-medium">{{ server.name }}</p>
+              <p class="text-xs text-muted">{{ server.owned ? 'Propriétaire' : 'Partagé' }} · {{ server.connections.length }} connexion{{ server.connections.length > 1 ? 's' : '' }}</p>
+            </div>
+            <svg v-if="plexSelectedServer === server" width="14" height="14" viewBox="0 0 24 24" stroke="#e5a50a" stroke-width="2.5" fill="none"><polyline points="20 6 9 17 4 12"/></svg>
+          </div>
+          <p v-if="plexError" class="text-xs text-red-400">{{ plexError }}</p>
+          <div class="flex gap-2 mt-1">
+            <button @click="plexConnectServer" :disabled="!plexSelectedServer || plexLoading" class="btn-primary">
+              {{ plexLoading ? 'Connexion…' : 'Continuer' }}
+            </button>
+            <button @click="plexStep = 'auth'" class="btn-secondary">Retour</button>
+          </div>
+        </div>
+
+        <!-- Étape 3 : Bibliothèque -->
+        <div v-else-if="plexStep === 'library'" class="flex flex-col gap-4 px-6 py-5">
+          <div>
+            <label class="settings-label mb-1 block">Nom de la bibliothèque</label>
+            <input v-model="plexForm.libraryName" type="text" class="settings-input w-full" placeholder="Fankai" />
+          </div>
+          <div>
+            <label class="settings-label mb-1 block">Chemin de la médiathèque</label>
+            <p class="text-xs text-muted mb-1.5">Chemin tel que vu par votre serveur Plex</p>
+            <input v-model="plexForm.libraryPath" type="text" class="settings-input w-full font-mono" placeholder="/data/media/fankai" />
+          </div>
+          <p v-if="plexError" class="text-xs text-red-400">{{ plexError }}</p>
+          <div class="flex gap-2">
+            <button @click="plexSetup" :disabled="plexLoading || !plexForm.libraryName || !plexForm.libraryPath" class="btn-primary">
+              {{ plexLoading ? 'Création…' : 'Créer la bibliothèque' }}
+            </button>
+            <button @click="plexStep = 'server'" class="btn-secondary">Retour</button>
+          </div>
+        </div>
+
+        <!-- Étape 4 : Résultat -->
+        <div v-else-if="plexStep === 'done'" class="flex flex-col gap-4 px-6 py-5">
+          <div class="flex flex-col gap-2">
+            <div v-for="s in plexSteps" :key="s.step" class="flex items-center gap-2.5">
+              <div class="w-5 h-5 rounded-full flex items-center justify-center shrink-0"
+                   :class="s.ok ? 'bg-green-500/15 text-green-400' : 'bg-red-500/15 text-red-400'">
+                <svg v-if="s.ok" width="10" height="10" viewBox="0 0 12 12" stroke="currentColor" stroke-width="2.5" fill="none"><polyline points="2 6 5 9 10 3"/></svg>
+                <svg v-else width="10" height="10" viewBox="0 0 12 12" stroke="currentColor" stroke-width="2" fill="none"><line x1="3" y1="3" x2="9" y2="9"/><line x1="9" y1="3" x2="3" y2="9"/></svg>
+              </div>
+              <p class="text-xs" :class="s.ok ? 'text-primary' : 'text-red-400'">{{ s.message }}</p>
+            </div>
+          </div>
+
+          <div v-if="plexManualSetup" class="bg-yellow-500/10 border border-yellow-500/20 rounded-lg p-3">
+            <p class="text-xs text-yellow-400 font-medium mb-2">⚠ Configuration manuelle de l'agent requise (Plex &lt; 1.43)</p>
+            <ol class="text-xs text-muted space-y-1 list-decimal list-inside">
+              <li>Rendez-vous sur la page <span class="text-primary">Metadata Agent</span> de Plex</li>
+              <li>Dans <span class="text-primary">Metadata Provider</span>, ajoutez : <code class="bg-hover px-1 rounded">https://metadata.fankai.fr/plex</code></li>
+              <li>Dans <span class="text-primary">Metadata Agent</span>, créez un agent avec ce provider</li>
+              <li>Dans votre bibliothèque → ⋯ → <span class="text-primary">Manage Library → Edit → Advanced → Agent</span>, sélectionnez l'agent Fankai</li>
+              <li>Rafraîchissez les métadonnées</li>
+            </ol>
+          </div>
+
+          <button @click="emit('close')" class="btn-primary">Fermer</button>
+        </div>
+
+      </div>
+    </div>
+  </Teleport>
+</template>
+
+<script setup lang="ts">
+import { ref, onUnmounted } from 'vue'
+
+const props = defineProps<{ mediaPath: string }>()
+const emit  = defineEmits<{ close: [] }>()
+
+const plexStep           = ref<'auth' | 'server' | 'library' | 'done'>('auth')
+const plexLoading        = ref(false)
+const plexError          = ref('')
+const plexNeeds2FA       = ref(false)
+const plexToken          = ref('')
+const plexServers        = ref<any[]>([])
+const plexSelectedServer = ref<any>(null)
+const plexServerUrl      = ref('')
+const plexManualSetup    = ref(false)
+const plexSteps          = ref<{ step: string; ok: boolean; message: string }[]>([])
+const plexAuthMethod     = ref<'oauth' | 'credentials' | null>(null)
+const plexOAuthPinId     = ref<string | null>(null)
+let   plexOAuthTimer: ReturnType<typeof setInterval> | null = null
+
+const plexForm = ref({
+  username   : '',
+  password   : '',
+  code       : '',
+  libraryName: 'Fankai',
+  libraryPath: props.mediaPath,
+})
+
+// ── OAuth ─────────────────────────────────────────────────────
+async function startOAuth() {
+  plexError.value   = ''
+  plexLoading.value = true
+  try {
+    const res  = await fetch('/api/plex/oauth/start', { method: 'POST', credentials: 'include' })
+    const data = await res.json()
+    if (!res.ok) { plexError.value = data.error ?? 'Erreur OAuth'; return }
+    plexOAuthPinId.value = String(data.pinId)
+    plexAuthMethod.value = 'oauth'
+    window.open(data.authUrl, '_blank')
+    let attempts = 0
+    plexOAuthTimer = setInterval(async () => {
+      attempts++
+      if (attempts > 150) { cancelOAuth(); plexError.value = 'Délai expiré — réessayez'; return }
+      try {
+        const r = await fetch(`/api/plex/oauth/poll/${plexOAuthPinId.value}`, { credentials: 'include' })
+        const d = await r.json()
+        if (d.ok && !d.pending) {
+          cancelOAuth()
+          plexToken.value   = d.token
+          plexServers.value = d.servers
+          if (d.servers.length === 1) { plexSelectedServer.value = d.servers[0]; await plexConnectServer() }
+          else plexStep.value = 'server'
+        }
+      } catch {}
+    }, 2000)
+  } catch {
+    plexError.value = "Impossible de démarrer l'authentification"
+  } finally {
+    plexLoading.value = false
+  }
+}
+
+function cancelOAuth() {
+  if (plexOAuthTimer) { clearInterval(plexOAuthTimer); plexOAuthTimer = null }
+  plexOAuthPinId.value = null
+  if (plexAuthMethod.value === 'oauth') plexAuthMethod.value = null
+}
+
+// ── Credentials ───────────────────────────────────────────────
+async function plexConnect() {
+  plexError.value   = ''
+  plexLoading.value = true
+  try {
+    const res  = await fetch('/api/plex/connect', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+      body: JSON.stringify({ username: plexForm.value.username, password: plexForm.value.password, code: plexForm.value.code || undefined }),
+    })
+    const data = await res.json()
+    if (!res.ok) {
+      if (data.requires2FA) { plexNeeds2FA.value = true; plexError.value = 'Entrez votre code 2FA' }
+      else plexError.value = data.error ?? 'Erreur de connexion'
+      return
+    }
+    plexToken.value   = data.token
+    plexServers.value = data.servers
+    if (data.servers.length === 1) { plexSelectedServer.value = data.servers[0]; await plexConnectServer() }
+    else plexStep.value = 'server'
+  } catch {
+    plexError.value = 'Impossible de contacter le serveur'
+  } finally {
+    plexLoading.value = false
+  }
+}
+
+function selectServer(server: any) { plexSelectedServer.value = server }
+
+async function plexConnectServer() {
+  if (!plexSelectedServer.value) return
+  plexError.value   = ''
+  plexLoading.value = true
+  try {
+    const conns = plexSelectedServer.value.connections ?? []
+    const conn  = conns.find((c: any) => c.local && !c.relay) ?? conns.find((c: any) => !c.local && !c.relay) ?? conns.find((c: any) => c.relay)
+    plexServerUrl.value = conn?.uri ?? ''
+    if (!plexServerUrl.value) throw new Error('Aucune URL de connexion disponible')
+    plexForm.value.libraryPath = props.mediaPath
+    plexStep.value = 'library'
+  } catch (err) {
+    plexError.value = err instanceof Error ? err.message : 'Erreur'
+  } finally {
+    plexLoading.value = false
+  }
+}
+
+async function plexSetup() {
+  plexError.value   = ''
+  plexLoading.value = true
+  try {
+    const res  = await fetch('/api/plex/setup', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+      body: JSON.stringify({ token: plexToken.value, serverUrl: plexServerUrl.value, libraryName: plexForm.value.libraryName, libraryPath: plexForm.value.libraryPath }),
+    })
+    const data = await res.json()
+    plexSteps.value       = data.steps ?? []
+    plexManualSetup.value = data.manualSetup ?? false
+    plexStep.value        = 'done'
+    if (!data.ok) plexError.value = data.error ?? 'Erreur lors du setup'
+  } catch {
+    plexError.value = 'Impossible de contacter le serveur'
+  } finally {
+    plexLoading.value = false
+  }
+}
+
+onUnmounted(() => cancelOAuth())
+</script>
@@ -72,6 +72,7 @@ const navItems = computed<NavItem[]>(() => [
    children: [
      { label: 'Clients de téléchargement', to: '/settings/download-client' },
      { label: 'Gestion des médias',        to: '/settings/media-management' },
+      { label: 'Management des séries',       to: '/settings/import-management' },
      { label: 'Catalogue Fankai',          to: '/settings/catalogue' },
      { label: 'Journaux',                  to: '/settings/logs' },
      { label: 'Avancé',                    to: '/settings/advanced' },
@@ -63,6 +63,11 @@ const router = createRouter({
                            name: 'settings-media',
                            component: () => import('@/views/settings/MediaManagementView.vue'),
                        },
+                        {
+                            path: 'import-management',
+                            name: 'setting-import',
+                            component: () => import('@/views/settings/ImportManagementView.vue'),
+                        },
                        {
                            path: 'catalogue',
                            name: 'settings-catalogue',
@@ -7,27 +7,19 @@
        <div class="flex items-center gap-3">
          <h1 class="text-lg font-semibold text-primary">Activité</h1>
          <div class="flex items-center gap-1.5">
-            <span
-                class="w-1.5 h-1.5 rounded-full transition-colors"
-                :class="polling ? 'bg-green-500 animate-pulse' : 'bg-border'"
-            />
+            <span class="w-1.5 h-1.5 rounded-full transition-colors" :class="polling ? 'bg-green-500 animate-pulse' : 'bg-border'" />
            <span class="text-xs text-muted">{{ polling ? 'En direct' : 'Pause' }}</span>
          </div>
        </div>
        <div class="flex items-center gap-2">
-          <button @click="importAll" :disabled="importingAll" class="btn-primary">
-            {{ importingAll ? '...' : 'Importer tout' }}
-          </button>
+          <button @click="importAll" :disabled="importingAll" class="btn-primary">{{ importingAll ? '...' : 'Importer tout' }}</button>
          <button @click="fetchTorrents" :disabled="loading" class="btn-secondary">
-            <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"
-                 :class="loading ? 'animate-spin' : ''">
+            <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none" :class="loading ? 'animate-spin' : ''">
              <path d="M21 12a9 9 0 0 1-9 9 9 9 0 0 1-6.36-2.64M3 12a9 9 0 0 1 9-9 9 9 0 0 1 6.36 2.64"/>
              <polyline points="16 5 21 5 21 10"/>
            </svg>
          </button>
-          <button @click="togglePolling" class="btn-secondary">
-            {{ polling ? 'Pause' : 'Reprendre' }}
-          </button>
+          <button @click="togglePolling" class="btn-secondary">{{ polling ? 'Pause' : 'Reprendre' }}</button>
        </div>
      </div>

@@ -39,100 +31,30 @@
        </div>
      </div>

-      <!-- Toolbar : recherche + tri -->
-      <div class="flex items-center gap-2 mb-4">
-        <div class="relative flex-1 max-w-xs">
-          <Search class="absolute left-3 top-1/2 -translate-y-1/2 text-muted pointer-events-none" :size="14" />
-          <input
-              v-model="search"
-              type="text"
-              placeholder="Rechercher..."
-              class="settings-input pl-9 w-full py-1.5 text-sm"
-          />
-        </div>
-
-        <div class="relative shrink-0" ref="sortRef">
-          <button
-              @click="sortOpen = !sortOpen"
-              class="btn-secondary flex items-center gap-1.5 py-1.5 px-2.5"
-              :class="activeSort !== 'none' ? 'border-accent text-accent' : ''"
-          >
-            <ArrowUpDown :size="14" />
-            <span class="hidden md:inline text-xs">Trier</span>
-            <span v-if="activeSort !== 'none'" class="absolute -top-1 -right-1 w-2 h-2 rounded-full bg-accent" />
-          </button>
-
-          <div
-              v-if="sortOpen"
-              class="absolute top-full right-0 mt-1 bg-card border border-border rounded-xl p-2 z-20 w-48 flex flex-col gap-0.5 shadow-xl"
-          >
-            <button
-                v-for="s in sortOptions" :key="s.value"
-                @click="setSort(s.value)"
-                class="flex items-center justify-between px-3 py-2 rounded-lg text-xs transition-colors"
-                :class="activeSort === s.value ? 'bg-active text-primary' : 'text-secondary hover:bg-hover'"
-            >
-              {{ s.label }}
-              <span v-if="activeSort === s.value && sortDir === 'asc'">↑</span>
-              <span v-else-if="activeSort === s.value && sortDir === 'desc'">↓</span>
-            </button>
-          </div>
-        </div>
-      </div>
-
-      <!-- Onglets + filtre -->
-      <div class="flex items-center justify-between mb-4">
-        <div class="flex gap-1 bg-shell rounded-lg p-1 border border-border">
-          <button
-              @click="activeTab = 'active'"
-              class="px-4 py-1.5 text-xs rounded-md transition-colors"
-              :class="activeTab === 'active'
-              ? 'bg-active text-primary'
-              : 'text-muted hover:text-primary'"
-          >
-            En cours
-            <span v-if="activeTorrents.length > 0" class="ml-1.5 text-[10px] text-accent">
-              {{ activeTorrents.length }}
-            </span>
-          </button>
-          <button
-              @click="activeTab = 'done'"
-              class="px-4 py-1.5 text-xs rounded-md transition-colors"
-              :class="activeTab === 'done'
-              ? 'bg-active text-primary'
-              : 'text-muted hover:text-primary'"
-          >
-            Terminés
-            <span v-if="doneTorrents.length > 0" class="ml-1.5 text-[10px] text-accent">
-              {{ doneTorrents.length }}
-            </span>
-          </button>
-        </div>
-
-        <div v-if="activeTab === 'done'" class="flex items-center gap-2">
-          <span class="text-xs text-muted">Masquer importés</span>
-          <button
-              @click="hideImported = !hideImported"
-              class="relative shrink-0 w-10 h-[22px] rounded-full transition-colors duration-200"
-              :class="hideImported ? 'bg-accent' : 'bg-border'"
-          >
-            <span
-                class="absolute top-[3px] left-[3px] w-4 h-4 rounded-full bg-white transition-transform duration-200"
-                :class="hideImported ? 'translate-x-[18px]' : 'translate-x-0'"
-            />
-          </button>
-        </div>
-      </div>
+      <!-- Toolbar + Tabs -->
+      <DownloadsToolbar
+          v-model:search="search"
+          v-model:active-tab="activeTab"
+          v-model:seeding-only="seedingOnly"
+          v-model:hide-imported="hideImported"
+          :active-sort="activeSort"
+          :sort-dir="sortDir"
+          :columns="columns"
+          :active-count="activeTorrents.length"
+          :done-count="doneTorrents.length"
+          :column-options="columnOptions"
+          :sort-options="sortOptions"
+          @sort="setSort"
+          @toggle-col="(key) => (columns as any)[key] = !(columns as any)[key]"
+      />

      <!-- Pas de clients -->
      <div v-if="noClients" class="settings-card flex flex-col items-center gap-3 py-16 text-center">
        <p class="text-sm text-muted">Aucun client torrent configuré</p>
-        <RouterLink to="/settings/download-client" class="text-xs text-accent hover:underline">
-          Configurer un client →
-        </RouterLink>
+        <RouterLink to="/settings/download-client" class="text-xs text-accent hover:underline">Configurer un client →</RouterLink>
      </div>

-      <!-- Loading initial -->
+      <!-- Loading -->
      <div v-else-if="loading && torrents.length === 0" class="flex items-center justify-center gap-2 py-16 text-muted text-sm">
        <div class="w-4 h-4 border border-border border-t-accent rounded-full animate-spin" />
        Chargement...
@@ -140,99 +62,25 @@

      <!-- Vide -->
      <div v-else-if="!loading && visibleTorrents.length === 0" class="settings-card flex flex-col items-center gap-2 py-16 text-center">
-        <p class="text-sm text-muted">
-          {{ activeTab === 'active' ? 'Aucun téléchargement en cours' : 'Aucun torrent terminé' }}
-        </p>
-        <p class="text-xs text-muted">
-          {{ activeTab === 'active'
-            ? 'Les torrents avec la catégorie « fankai » apparaîtront ici'
-            : hideImported ? 'Tous les torrents terminés sont importés' : '' }}
-        </p>
+        <p class="text-sm text-muted">{{ activeTab === 'active' ? 'Aucun téléchargement en cours' : 'Aucun torrent terminé' }}</p>
+        <p class="text-xs text-muted">{{ activeTab === 'active' ? 'Les torrents avec la catégorie « fankai » apparaîtront ici' : hideImported ? 'Tous les torrents terminés sont importés' : '' }}</p>
      </div>

      <!-- Liste torrents -->
      <div v-else class="flex flex-col gap-2">
-        <div v-for="t in visibleTorrents" :key="t.hash" class="settings-card flex flex-col gap-3">
-
-          <!-- Nom + état + progression -->
-          <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">{{ t.name }}</p>
-              <div class="flex items-center gap-2 mt-1">
-                <span class="text-[10px] px-2 py-0.5 rounded border" :class="stateBadge(t.state).class">
-                  {{ stateBadge(t.state).label }}
-                </span>
-                <span class="text-xs text-muted">{{ t.client_name }}</span>
-              </div>
-            </div>
-            <div class="text-right shrink-0">
-              <p class="text-sm font-semibold text-primary">{{ clampedProgress(t) }}%</p>
-              <p class="text-xs text-muted mt-0.5">{{ formatSize(t.downloaded) }} / {{ formatSize(t.size) }}</p>
-            </div>
-          </div>
-
-          <!-- Barre de progression -->
-          <div class="h-1 bg-border rounded-full overflow-hidden">
-            <div
-                class="h-full rounded-full transition-all duration-500"
-                :class="t.state === 'seeding' || t.state === 'unknown' ? 'bg-green-500' :
-                      t.state === 'error'   ? 'bg-red-500'   :
-                      t.state === 'paused'  ? 'bg-muted'     : 'bg-accent'"
-                :style="{ width: `${clampedProgress(t)}%` }"
-            />
-          </div>
-
-          <!-- Infos bas + actions -->
-          <div class="flex items-center justify-between">
-            <div class="flex items-center gap-3 text-xs text-muted">
-              <span v-if="t.state === 'downloading'">↓ {{ formatSpeed(t.speed) }}</span>
-              <span v-if="t.state === 'downloading' && t.eta > 0">ETA {{ formatEta(t.eta) }}</span>
-              <span v-if="t.state === 'seeding'" class="text-green-500">Complété</span>
-              <span v-if="t.state === 'unknown'" class="text-yellow-500">État non remonté par le client</span>
-            </div>
-
-            <div v-if="t.state === 'seeding' || t.state === 'unknown'" class="flex items-center gap-2">
-
-              <!-- Erreurs fichiers -->
-              <div v-if="t.errorFiles?.length > 0" class="relative group/err">
-                <span class="text-xs px-2 py-0.5 rounded border border-red-500/40 text-red-400 cursor-default">
-                  {{ t.errorFiles.length }} erreur{{ t.errorFiles.length > 1 ? 's' : '' }}
-                </span>
-                <div class="absolute bottom-full right-0 mb-2 hidden group-hover/err:block z-10 w-80">
-                  <div class="bg-card border border-red-500/30 rounded-lg p-3 text-xs shadow-xl">
-                    <p class="text-red-400 mb-2 font-medium">Fichiers en erreur</p>
-                    <div v-for="e in t.errorFiles" :key="e.file" class="mb-1.5 last:mb-0">
-                      <p class="text-primary truncate">{{ e.file }}</p>
-                      <p class="text-muted">{{ e.error }}</p>
-                    </div>
-                  </div>
-                </div>
-              </div>
-
-              <!-- Badge import -->
-              <span
-                  class="text-xs px-2 py-0.5 rounded border"
-                  :class="t.organizeState === 'done'    ? 'border-green-500/40 text-green-500' :
-                        t.organizeState === 'partial'  ? 'border-yellow-500/40 text-yellow-500' :
-                                                         'border-border text-muted'"
-              >
-                {{ t.organizeState === 'done'   ? `Importé (${t.organizeProgress?.done}/${t.organizeProgress?.total})` :
-                  t.organizeState === 'partial' ? `En cours (${t.organizeProgress?.done}/${t.organizeProgress?.total})` :
-                      'Non importé' }}
-              </span>
-
-              <button
-                  v-if="t.organizeState !== 'done'"
-                  @click="importTorrent(t)"
-                  :disabled="importing[t.hash]"
-                  class="btn-secondary text-xs py-1"
-              >
-                {{ importing[t.hash] ? '...' : 'Importer' }}
-              </button>
-            </div>
-          </div>
-
-        </div>
+        <TorrentCard
+            v-for="t in visibleTorrents"
+            :key="t.hash"
+            :torrent="t"
+            :tab="activeTab"
+            :columns="columns"
+            :importing="!!importing[t.hash]"
+            :deleting="!!deleting[t.hash]"
+            :show-confirm-delete="confirmDelete === t.hash"
+            @import="importTorrent"
+            @delete="(torrent, withFiles) => deleteTorrent(torrent, withFiles)"
+            @toggle-confirm="(hash) => { confirmDelete = hash }"
+        />
      </div>

    </div>
@@ -242,70 +90,61 @@
 <script setup lang="ts">
 import { ref, computed, onMounted, onUnmounted } from 'vue'
 import { RouterLink } from 'vue-router'
-import { Search, ArrowUpDown } from 'lucide-vue-next'
-import { onClickOutside } from '@vueuse/core'
 import { useToast } from '@/composables/useToast'
+import TorrentCard from '@/components/downloads/TorrentCard.vue'
+import DownloadsToolbar from '@/components/downloads/DownloadsToolbar.vue'

 const { add: toast } = useToast()

-const torrents     = ref<any[]>([])
-const loading      = ref(true)
-const polling      = ref(true)
-const noClients    = ref(false)
-const importing    = ref<Record<string, boolean>>({})
-const importingAll = ref(false)
-const activeTab    = ref<'active' | 'done'>('active')
-const hideImported = ref(false)
-const search    = ref('')
-const sortOpen  = ref(false)
-const activeSort = ref<'none' | 'name' | 'size' | 'progress' | 'state'>('none')
-const sortDir   = ref<'asc' | 'desc'>('asc')
-const sortRef   = ref<HTMLElement | null>(null)
+const torrents        = ref<any[]>([])
+const loading         = ref(true)
+const polling         = ref(true)
+const noClients       = ref(false)
+const importing       = ref<Record<string, boolean>>({})
+const importingAll    = ref(false)
+const confirmDelete   = ref<string | null>(null)
+const deleting        = ref<Record<string, boolean>>({})
+const activeTab       = ref<'active' | 'done'>('active')
+const hideImported    = ref(false)
+const seedingOnly     = ref(false)
+const search          = ref('')
+const activeSort      = ref<'none' | 'name' | 'size' | 'progress' | 'state' | 'ratio'>('none')
+const sortDir         = ref<'asc' | 'desc'>('asc')

-onClickOutside(sortRef, () => { sortOpen.value = false })
-
-const sortOptions = [
-  { label: 'Nom',        value: 'name'     },
-  { label: 'Taille',     value: 'size'     },
-  { label: 'Progression', value: 'progress' },
-  { label: 'État',       value: 'state'    },
+const columns = ref({ client: true, size: true, ratio: true, uploaded: true, upspeed: true })
+const columnOptions = [
+  { key: 'client',   label: 'Client' },
+  { key: 'size',     label: 'Taille / Téléchargé' },
+  { key: 'ratio',    label: 'Ratio' },
+  { key: 'uploaded', label: 'Uploadé (total)' },
+  { key: 'upspeed',  label: 'Vitesse upload' },
+]
+const sortOptions = [
+  { label: 'Nom',         value: 'name'     },
+  { label: 'Taille',      value: 'size'     },
+  { label: 'Progression', value: 'progress' },
+  { label: 'État',        value: 'state'    },
+  { label: 'Ratio',       value: 'ratio'    },
 ]
-
-function setSort(val: typeof activeSort.value) {
-  if (activeSort.value === val) {
-    sortDir.value = sortDir.value === 'asc' ? 'desc' : 'asc'
-  } else {
-    activeSort.value = val
-    sortDir.value = 'asc'
-  }
-  sortOpen.value = false
-}

 let pollInterval: ReturnType<typeof setInterval> | null = null

-// FIX : unknown retiré de activeTorrents, ajouté dans doneTorrents
 const activeTorrents = computed(() =>
    torrents.value.filter(t => ['downloading', 'paused', 'checking', 'error'].includes(t.state))
 )
-
 const doneTorrents = computed(() =>
    torrents.value.filter(t => t.state === 'seeding' || t.state === 'unknown')
 )
-
 const visibleTorrents = computed(() => {
-  let list = activeTab.value === 'active'
-      ? activeTorrents.value
-      : hideImported.value
-          ? doneTorrents.value.filter(t => t.organizeState !== 'done')
-          : doneTorrents.value
-
-  // Recherche
+  let list = activeTab.value === 'active' ? activeTorrents.value : doneTorrents.value
+  if (activeTab.value === 'done') {
+    if (seedingOnly.value)  list = list.filter(t => t.state === 'seeding')
+    if (hideImported.value) list = list.filter(t => t.organizeState !== 'done')
+  }
  if (search.value.trim()) {
    const q = search.value.toLowerCase()
    list = list.filter(t => t.name.toLowerCase().includes(q))
  }
-
-  // Tri
  if (activeSort.value !== 'none') {
    const dir = sortDir.value === 'asc' ? 1 : -1
    list = [...list].sort((a, b) => {
@@ -314,14 +153,13 @@ const visibleTorrents = computed(() => {
        case 'size'    : return (a.size - b.size) * dir
        case 'progress': return (a.progress - b.progress) * dir
        case 'state'   : return a.state.localeCompare(b.state) * dir
+        case 'ratio'   : return ((a.ratio ?? 0) - (b.ratio ?? 0)) * dir
        default        : return 0
      }
    })
  }
-
  return list
 })
-
 const stats = computed(() => [
  { label: 'En cours',  value: torrents.value.filter(t => t.state === 'downloading').length },
  { label: 'Complétés', value: torrents.value.filter(t => t.state === 'seeding').length },
@@ -329,9 +167,9 @@ const stats = computed(() => [
  { label: 'Erreurs',   value: torrents.value.filter(t => t.state === 'error').length },
 ])

-// FIX : progress cappé à 100 pour éviter "278.2 GB / 278.1 GB" → 100%
-function clampedProgress(t: any): number {
-  return Math.min(100, Math.max(0, t.progress ?? 0))
+function setSort(val: string) {
+  if (activeSort.value === val) sortDir.value = sortDir.value === 'asc' ? 'desc' : 'asc'
+  else { activeSort.value = val as typeof activeSort.value; sortDir.value = 'asc' }
 }

 async function fetchTorrents() {
@@ -341,107 +179,55 @@ async function fetchTorrents() {
    if (!res.ok) return
    torrents.value  = await res.json()
    noClients.value = false
-  } catch {
-  } finally {
-    loading.value = false
-  }
+  } catch {} finally { loading.value = false }
 }

-function startPolling() {
-  fetchTorrents()
-  pollInterval = setInterval(fetchTorrents, 60_000)
-}
-
-function stopPolling() {
-  if (pollInterval) { clearInterval(pollInterval); pollInterval = null }
-}
-
-function togglePolling() {
-  polling.value = !polling.value
-  polling.value ? startPolling() : stopPolling()
-}
-
-onMounted(startPolling)
-onUnmounted(stopPolling)
+function startPolling() { fetchTorrents(); pollInterval = setInterval(fetchTorrents, 60_000) }
+function stopPolling()  { if (pollInterval) { clearInterval(pollInterval); pollInterval = null } }
+function togglePolling() { polling.value = !polling.value; polling.value ? startPolling() : stopPolling() }

 async function importTorrent(torrent: any) {
  importing.value[torrent.hash] = true
  try {
    const res = await fetch('/api/organize', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      credentials: 'include',
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
      body: JSON.stringify({ hash: torrent.hash, save_path: torrent.save_path, name: torrent.name }),
    })
-    if (res.ok) {
-      toast(`${torrent.name} importé ✓`, 'success')
-      await fetchTorrents()
-    } else {
-      const { error } = await res.json()
-      toast(error ?? "Erreur lors de l'import", 'error')
-    }
-  } catch {
-    toast('Impossible de contacter le serveur', 'error')
-  } finally {
-    importing.value[torrent.hash] = false
-  }
+    if (res.ok) { toast(`${torrent.name} importé ✓`, 'success'); await fetchTorrents() }
+    else { const { error } = await res.json(); toast(error ?? "Erreur lors de l'import", 'error') }
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+  finally { importing.value[torrent.hash] = false }
 }

 async function importAll() {
  const toImport = doneTorrents.value.filter(t => t.organizeState !== 'done')
  if (toImport.length === 0) { toast('Tous les torrents sont déjà importés', 'success'); return }
-
  importingAll.value = true
  let done = 0, errors = 0
-
  for (const t of toImport) {
    try {
      const res = await fetch('/api/organize', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        credentials: 'include',
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
        body: JSON.stringify({ hash: t.hash, save_path: t.save_path, name: t.name }),
      })
      res.ok ? done++ : errors++
    } catch { errors++ }
  }
-
  importingAll.value = false
  await fetchTorrents()
-  errors === 0
-      ? toast(`${done} torrent(s) importé(s) ✓`, 'success')
-      : toast(`${done} OK, ${errors} erreur(s)`, 'error')
+  errors === 0 ? toast(`${done} torrent(s) importé(s) ✓`, 'success') : toast(`${done} OK, ${errors} erreur(s)`, 'error')
 }

-function stateBadge(state: string) {
-  const map: Record<string, { label: string; class: string }> = {
-    downloading: { label: 'Téléchargement', class: 'border-accent/40 text-accent' },
-    seeding    : { label: 'Complété',       class: 'border-green-500/40 text-green-500' },
-    paused     : { label: 'En pause',       class: 'border-border text-muted' },
-    checking   : { label: 'Vérification',   class: 'border-yellow-500/40 text-yellow-500' },
-    error      : { label: 'Erreur',         class: 'border-red-500/40 text-red-400' },
-    // FIX : badge jaune pour signaler état dégradé sans alarmer
-    unknown    : { label: 'État inconnu',   class: 'border-yellow-500/40 text-yellow-500' },
-  }
-  return map[state] ?? map.unknown
+async function deleteTorrent(torrent: any, withFiles: boolean) {
+  deleting.value[torrent.hash] = true
+  try {
+    const res = await fetch(`/api/torrent/${torrent.hash}?deleteFiles=${withFiles}`, { method: 'DELETE', credentials: 'include' })
+    if (res.ok) { toast(`"${torrent.name}" supprimé ✓`, 'success'); confirmDelete.value = null; await fetchTorrents() }
+    else toast('Erreur lors de la suppression', 'error')
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+  finally { deleting.value[torrent.hash] = false }
 }

-function formatSize(bytes: number): string {
-  if (bytes === 0) return '0 B'
-  const units = ['B', 'KB', 'MB', 'GB', 'TB']
-  const i = Math.floor(Math.log(bytes) / Math.log(1024))
-  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`
-}
-
-function formatSpeed(bps: number): string { return `${formatSize(bps)}/s` }
-
-function formatEta(seconds: number): string {
-  if (seconds < 0 || seconds > 86400 * 7) return '∞'
-  const h = Math.floor(seconds / 3600)
-  const m = Math.floor((seconds % 3600) / 60)
-  const s = seconds % 60
-  if (h > 0) return `${h}h${m.toString().padStart(2, '0')}m`
-  if (m > 0) return `${m}m${s.toString().padStart(2, '0')}s`
-  return `${s}s`
-}
-</script>
+onMounted(startPolling)
+onUnmounted(stopPolling)
+</script>
@@ -14,301 +14,85 @@
    </div>

    <template v-else-if="data">
-
-      <!-- Hero avec fanart -->
-      <div class="relative">
-        <div v-if="data.serie.fanart_image" class="absolute inset-0 h-64 overflow-hidden pointer-events-none">
-          <img
-              :src="data.serie.fanart_image"
-              class="w-full h-full object-cover opacity-15"
-              @error="(e) => ((e.target as HTMLElement).closest('div') as HTMLElement).style.display = 'none'"
-          />
-          <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]">
-          <!-- Poster -->
-          <div class="shrink-0 w-32 rounded-xl overflow-hidden border border-border shadow-xl hidden sm:block">
-            <img v-if="data.serie.poster_image" :src="data.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" />
-            </div>
-          </div>
-
-          <!-- Infos -->
-          <div class="flex flex-col gap-3 justify-end min-w-0">
-            <!-- Retour -->
-            <RouterLink to="/series" class="inline-flex items-center gap-1.5 text-xs text-muted hover:text-primary transition-colors w-fit">
-              <ArrowLeft :size="13" />
-              Séries
-            </RouterLink>
-
-            <h1 class="text-2xl font-bold text-primary tracking-tight">{{ data.serie.title }}</h1>
-
-            <div class="flex flex-wrap items-center gap-2">
-              <span v-if="data.serie.year" class="text-sm text-muted">{{ data.serie.year }}</span>
-              <span
-                  v-if="data.serie.status"
-                  class="text-xs px-2 py-0.5 rounded-full border"
-                  :class="data.serie.status.toLowerCase() === 'continuing'
-                  ? 'bg-green-500/15 text-green-400 border-green-500/20'
-                  : 'bg-hover text-muted border-border'"
-              >
-                {{ data.serie.status }}
-              </span>
-            </div>
-
-            <p v-if="data.serie.plot" class="text-sm text-secondary leading-relaxed max-w-2xl line-clamp-3">
-              {{ data.serie.plot }}
-            </p>
-<!--
-            <button
-                @click="manualImportOpen = true"
-                class="inline-flex items-center gap-2 px-4 py-2 text-sm rounded-lg border border-border text-muted hover:text-primary hover:border-secondary transition"
-            >
-              Import manuel
-            </button>
-
-
-            <ManualImportModal
-                v-if="manualImportOpen && data"
-                :serie-id="Number(route.params.id)"
-                :serie-name="data.serie.title"
-                :seasons="data.seasons"
-                :organized="organizedByEpisode"
-                @close="manualImportOpen = false"
-                @imported="load(); manualImportOpen = false"
-            />
-->
-            <!-- Boutons intégrale -->
-            <div class="flex flex-wrap gap-2 mt-1">
-              <button
-                  v-for="(t, i) in data.torrents_integrale"
-                  :key="i"
-                  :title="t.raw"
-                  class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium rounded-lg transition"
-                  :class="[
-                  t.label === 'Intégrale'
-                    ? 'bg-accent text-white hover:bg-accent-hover'
-                    : 'bg-accent-muted text-accent border border-accent/20 hover:bg-accent/20',
-                  (isDownloading(`integrale-${i}`) || isDownloaded(`integrale-${i}`) || isAlreadyQueued(t))
-                    ? 'opacity-50 cursor-not-allowed' : ''
-                ]"
-                  :disabled="isDownloading(`integrale-${i}`) || isDownloaded(`integrale-${i}`) || isAlreadyQueued(t)"
-                  @click="download(`integrale-${i}`, t.torrent_url, t.magnet)"
-              >
-                <EpStateIcon :state="epBtnState(`integrale-${i}`, t)" />
-                {{ isAlreadyQueued(t) ? 'Déjà ajouté' : isDownloaded(`integrale-${i}`) ? 'Envoyé ✓' : t.label }}
-              </button>
-            </div>
-
-            <!-- Progression intégrale -->
-            <template v-for="(t, i) in data.torrents_integrale" :key="`prog-${i}`">
-              <ProgressBar :progress="torrentProgress(extractHash(t))?.progress" />
-            </template>
-          </div>
-        </div>
-      </div>
+      <!-- Hero -->
+      <SerieHero
+          :serie="data.serie"
+          :torrents-integrale="data.torrents_integrale"
+          :organized-by-episode="organizedByEpisode"
+          :has-downloadable-torrents="hasDownloadableTorrents"
+          :downloading-all="downloadingAll"
+          :active-torrents="activeTorrents"
+          :downloading="downloading"
+          :downloaded="downloaded"
+          @open-manual-import="openManualImport"
+          @unimport="(del) => unimportSerie(del)"
+          @download-all="downloadAll"
+          @download="(key, url, magnet) => download(key, url, magnet)"
+      />

      <!-- Saisons -->
      <div class="px-4 md:px-8 pb-16 flex flex-col gap-4">
-        <div
+        <SerieSeasonCard
            v-for="season in data.seasons"
            :key="season.id"
-            class="bg-card border border-border rounded-xl overflow-hidden"
-        >
-          <!-- Header saison -->
-          <div class="flex items-center justify-between px-5 py-3.5 border-b border-border">
-            <div class="flex items-center gap-3">
-              <button class="text-muted hover:text-primary transition-colors" @click="toggleSeason(season.id)">
-                <ChevronUp
-                    :size="15"
-                    class="transition-transform duration-200"
-                    :class="collapsedSeasons.has(season.id) ? 'rotate-180' : ''"
-                />
-              </button>
-              <div>
-                <h2 class="text-sm font-semibold text-primary">
-                  {{ season.season_number === 0 ? 'Spéciaux' : `Saison ${season.season_number}` }}
-                  <span
-                      v-if="season.title && season.title !== `Saison ${season.season_number}`"
-                      class="text-muted font-normal ml-1"
-                  >
-                    — {{ season.title }}
-                  </span>
-                </h2>
-                <p class="text-xs text-muted mt-0.5">
-                  {{ season.episodes.length }} épisode{{ season.episodes.length > 1 ? 's' : '' }}
-                  · {{ seasonAvailableCount(season) }}/{{ season.episodes.length }} dispo
-                  <span
-                      v-if="season.organized_state !== 'none'"
-                      class="ml-1.5 px-1.5 py-0.5 rounded text-[10px]"
-                      :class="season.organized_state === 'complete'
-                      ? 'bg-green-500/10 text-green-400'
-                      : 'bg-yellow-500/10 text-yellow-500'"
-                  >
-                    {{ season.organized_state === 'complete'
-                      ? `✓ ${season.organized_count} importé${season.organized_count > 1 ? 's' : ''}`
-                      : `${season.organized_count}/${seasonAvailableCount(season)} importés` }}
-                  </span>
-                </p>
-              </div>
-            </div>
-
-            <!-- Bouton pack saison -->
-            <button
-                class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border transition"
-                :class="season.torrent && !isDownloaded(`season-${season.id}`) && !isAlreadyQueued(season.torrent) && season.organized_state !== 'complete'
-                ? 'bg-accent-muted text-accent border-accent/20 hover:bg-accent/20'
-                : 'text-muted border-border cursor-not-allowed opacity-50'"
-                :disabled="!season.torrent || isDownloading(`season-${season.id}`) || isDownloaded(`season-${season.id}`) || isAlreadyQueued(season.torrent) || season.organized_state === 'complete'"
-                @click="season.torrent && download(`season-${season.id}`, season.torrent.torrent_url, season.torrent.magnet)"
-            >
-              <EpStateIcon :state="seasonBtnState(season)" :size="12" />
-              {{ season.organized_state === 'complete' ? 'Importé' : isAlreadyQueued(season.torrent) ? 'Déjà ajouté' : isDownloaded(`season-${season.id}`) ? 'Envoyé' : 'Saison entière' }}
-            </button>
-          </div>
-
-          <!-- Progression saison — dans le header, sous les contrôles -->
-          <div
-              v-if="torrentProgress(extractHash(season.torrent)) && torrentProgress(extractHash(season.torrent))!.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: `${torrentProgress(extractHash(season.torrent))!.progress}%` }"
-              />
-            </div>
-            <p class="text-[11px] text-muted mt-1">{{ torrentProgress(extractHash(season.torrent))!.progress }}%</p>
-          </div>
-
-          <!-- Épisodes -->
-          <div v-if="!collapsedSeasons.has(season.id)" class="divide-y divide-border/50">
-            <div
-                v-for="ep in season.episodes"
-                :key="ep.id"
-                class="px-5 py-3 hover:bg-hover/50 transition-colors"
-                :class="{ 'opacity-40': !ep.available && !ep.organized }"
-            >
-              <div class="flex items-center gap-3">
-
-                <!-- Thumbnail -->
-                <div class="shrink-0 w-20 aspect-video rounded-md overflow-hidden bg-shell hidden sm:flex items-center justify-center text-muted text-xs font-mono">
-                  <img v-if="ep.thumb_image" :src="ep.thumb_image" class="w-full h-full object-cover" loading="lazy" />
-                  <span v-else>{{ season.season_number === 0 ? 'SP' : `E${ep.episode_number}` }}</span>
-                </div>
-
-                <!-- Infos épisode -->
-                <div class="flex-1 min-w-0">
-                  <div class="flex items-center gap-2">
-                    <span class="text-xs text-muted shrink-0 font-mono">
-                      {{ season.season_number === 0 ? 'SP' : `E${String(ep.episode_number).padStart(2, '0')}` }}
-                    </span>
-                    <span class="text-sm text-primary truncate">{{ ep.title || `Épisode ${ep.episode_number}` }}</span>
-                    <!-- Badge Hors Fankai -->
-                    <span
-                        v-if="ep.fankai === false || ep.torrent?.fankai === false"
-                        class="shrink-0 text-[10px] px-1.5 py-0.5 rounded border bg-purple-500/10 text-purple-400 border-purple-500/20"
-                        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">
-                    <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>
-                  </div>
-                </div>
-
-                <!-- Bouton état unique -->
-                <button
-                    class="shrink-0 w-8 h-8 rounded-lg border flex items-center justify-center transition-colors"
-                    :class="epBtnClass(ep)"
-                    :disabled="!ep.torrent || ep.organized || isAlreadyQueued(ep.torrent)"
-                    @click="ep.torrent && !ep.organized && !isAlreadyQueued(ep.torrent) && download(`ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet)"
-                >
-                  <EpStateIcon :state="epState(ep)" :size="14" />
-                </button>
-
-              </div>
-
-              <!-- Barre progression épisode -->
-              <div
-                  v-if="torrentProgress(extractHash(ep.torrent)) && torrentProgress(extractHash(ep.torrent))!.progress < 100"
-                  class="mt-1.5 sm:pl-[92px]"
-              >
-                <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: `${torrentProgress(extractHash(ep.torrent))!.progress}%` }"
-                  />
-                </div>
-              </div>
-
-            </div>
-          </div>
-        </div>
+            :season="season"
+            :collapsed="collapsedSeasons.has(season.id)"
+            :active-torrents="activeTorrents"
+            :downloading="downloading"
+            :downloaded="downloaded"
+            :organized-by-episode="organizedByEpisode"
+            :ep-action-loading="epActionLoading"
+            :downloading-season="!!downloadingSeason[season.id]"
+            :nfo-support="nfoSupport"
+            @toggle="toggleSeason"
+            @download="(key, url, magnet) => download(key, url, magnet)"
+            @download-season="downloadSeason"
+            @rename-episode="(ep, s) => renameEpisode(ep, s)"
+            @unimport-episode="(ep, s, del) => unimportEpisode(ep, s, del)"
+        />
      </div>
    </template>
+
+    <!-- Modal import manuel -->
+    <ManualImportModal
+        v-if="manualImportOpen && data"
+        :serie-id="Number(route.params.id)"
+        :serie-name="data.serie.title"
+        :seasons="data.seasons"
+        :organized="organizedByEpisode"
+        :initial-path="mediaPath"
+        @close="manualImportOpen = false"
+        @imported="load(); fetchOrganized(); manualImportOpen = false"
+    />
+
  </div>
 </template>

 <script setup lang="ts">
-import { ref, computed, onMounted, onUnmounted, defineComponent, h } from 'vue'
-import { RouterLink, useRoute } from 'vue-router'
-import { ArrowLeft, Tv, ChevronUp, Download, Loader, Check, X } from 'lucide-vue-next'
+import { ref, computed, onMounted, onUnmounted } from 'vue'
+import { useRoute } from 'vue-router'
 import { useSeriesStore } from '@/stores/series'
 import { useToast } from '@/composables/useToast'
+import ManualImportModal from '@/components/ManualImportModal.vue'
+import SerieHero from '@/components/serie/SerieHero.vue'
+import SerieSeasonCard from '@/components/serie/SerieSeasonCard.vue'
 import type { Season } from '@/stores/series'
-import ManualImportModal from "@/components/ManualImportModal.vue";
-
-// ── Icône d'état du bouton ────────────────────────────────────
-// states: 'idle' | 'loading' | 'done' | 'unavailable'
-const EpStateIcon = defineComponent({
-  props: {
-    state: { type: String, default: 'idle' },
-    size : { type: Number, default: 14 },
-  },
-  setup(props) {
-    return () => {
-      if (props.state === 'loading')     return h(Loader,   { size: props.size, class: 'animate-spin' })
-      if (props.state === 'done')        return h(Check,    { size: props.size })
-      if (props.state === 'unavailable') return h(X,        { size: props.size })
-      return h(Download, { size: props.size })
-    }
-  },
-})
-
-// ── Barre de progression ──────────────────────────────────────
-const ProgressBar = defineComponent({
-  props: { progress: { type: Number, default: null } },
-  setup(props) {
-    return () => {
-      if (props.progress == null || props.progress >= 100) return null
-      return h('div', { class: 'h-0.5 bg-border rounded-full overflow-hidden' }, [
-        h('div', {
-          class: 'h-full bg-accent rounded-full transition-all duration-500',
-          style: { width: `${props.progress}%` },
-        }),
-      ])
-    }
-  },
-})

 const route  = useRoute()
 const store  = useSeriesStore()
 const { add: toast } = useToast()

-const collapsedSeasons = ref<Set<number>>(new Set())
-const downloading = ref<string[]>([])
-const downloaded  = ref<string[]>([])
-
-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) }
+const collapsedSeasons   = ref<Set<number>>(new Set())
+const downloading        = ref<string[]>([])
+const downloaded         = ref<string[]>([])
+const manualImportOpen   = ref(false)
+const organizedByEpisode = ref<Record<string, any>>({})
+const mediaPath          = ref('/')
+const nfoSupport         = ref(false)
+const epActionLoading    = ref<Record<number, boolean>>({})
+const unimportMenuOpen   = ref(false)
+const downloadingAll     = ref(false)
+const downloadingSeason  = ref<Record<number, boolean>>({})

 interface ActiveTorrent { hash: string; progress: number; state: string }
 const activeTorrents = ref<ActiveTorrent[]>([])
@@ -316,134 +100,169 @@ let pollTimer: ReturnType<typeof setInterval> | null = null

 const data = computed(() => store.currentSerie)

-
-const manualImportOpen   = ref(false)
-const organizedByEpisode = ref<Record<string, any>>({})
-
-// Dans onMounted, après load() :
-async function fetchOrganized() {
-  try {
-    const res = await fetch('/api/organized', { credentials: 'include' })
-    if (res.ok) organizedByEpisode.value = await res.json()
-  } catch {}
-}
-// ── Polling downloads ─────────────────────────────────────────
-async function fetchActiveDownloads() {
-  try {
-    const res = await fetch('/api/downloads', { credentials: 'include' })
-    if (!res.ok) return
-    const list: any[] = await res.json()
-    activeTorrents.value = list.map(t => ({
-      hash    : t.hash,
-      progress: t.progress ?? 0,
-      state   : t.state,
-    }))
-  } catch {}
-}
-
-function torrentProgress(hash: string | null | undefined): ActiveTorrent | null {
-  if (!hash) return null
-  return activeTorrents.value.find(t => t.hash.toLowerCase() === hash.toLowerCase()) ?? null
-}
-
-function extractHash(torrent: { magnet?: string | null } | null | undefined): string | null {
+// ── Helpers d'état ────────────────────────────────────────────
+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 extractHash(torrent: any): string | null {
  if (!torrent?.magnet) return null
  const m = torrent.magnet.match(/xt=urn:btih:([a-fA-F0-9]{40})/i)
  return m ? m[1].toLowerCase() : null
 }
-
-function isAlreadyQueued(torrent: { magnet?: string | null } | null | undefined): boolean {
+function isAlreadyQueued(torrent: any): boolean {
  const hash = extractHash(torrent)
  if (!hash) return false
  return activeTorrents.value.some(t => t.hash.toLowerCase() === hash.toLowerCase())
 }

-// ── États boutons ─────────────────────────────────────────────
-type BtnState = 'idle' | 'loading' | 'done' | 'unavailable'
+// ── Fetch ─────────────────────────────────────────────────────
+function load() { store.fetchSerieDetail(Number(route.params.id)) }

-function epState(ep: any): BtnState {
-  if (ep.organized)                                          return 'done'
-  if (isDownloaded(`ep-${ep.id}`))                        return 'done'
-  if (isAlreadyQueued(ep.torrent))                           return 'done'
-  const prog = torrentProgress(extractHash(ep.torrent))
-  if (prog && prog.progress < 100)                           return 'loading'
-  if (!ep.torrent || !ep.available)                          return 'unavailable'
-  if (isDownloading(`ep-${ep.id}`))                        return 'loading'
-  return 'idle'
+async function fetchOrganized() {
+  try {
+    const res = await fetch(`/api/organized/${route.params.id}`, { credentials: 'include' })
+    if (res.ok) organizedByEpisode.value = await res.json()
+  } catch {}
 }

-function epBtnState(key: string, torrent: any): BtnState {
-  if (isDownloaded(key) || isAlreadyQueued(torrent))       return 'done'
-  if (isDownloading(key))                                  return 'loading'
-  return 'idle'
+async function fetchSettings() {
+  try {
+    const res = await fetch('/api/settings', { credentials: 'include' })
+    if (res.ok) { const s = await res.json(); mediaPath.value = s.mediaPath || '/'; nfoSupport.value = !!s.nfoSupport }
+  } catch {}
 }

-function seasonBtnState(season: any): BtnState {
-  if (season.organized_state === 'complete')                 return 'done'
-  if (isDownloaded(`season-${season.id}`))                 return 'done'
-  if (isAlreadyQueued(season.torrent))                       return 'done'
-  if (isDownloading(`season-${season.id}`))                return 'loading'
-  if (!season.torrent)                                       return 'unavailable'
-  return 'idle'
+async function fetchActiveDownloads() {
+  try {
+    const res = await fetch('/api/downloads', { credentials: 'include' })
+    if (!res.ok) return
+    const list: any[] = await res.json()
+    activeTorrents.value = list.map(t => ({ hash: t.hash, progress: t.progress ?? 0, state: t.state }))
+  } catch {}
 }

-function epBtnClass(ep: any): string {
-  const state = epState(ep)
-  if (state === 'done')        return 'border-green-500/30 text-green-500 bg-green-500/10 cursor-default'
-  if (state === 'loading')     return 'border-accent/30 text-accent bg-accent-muted cursor-default'
-  if (state === 'unavailable') return 'border-border text-muted opacity-40 cursor-not-allowed'
-  return 'border-border text-muted hover:border-accent hover:text-accent cursor-pointer'
-}
-
-// ── Actions ───────────────────────────────────────────────────
-function seasonAvailableCount(season: Season) {
-  return season.episodes.filter((e: any) => e.available).length
-}
-
-function toggleSeason(id: number) {
-  if (collapsedSeasons.value.has(id)) collapsedSeasons.value.delete(id)
-  else collapsedSeasons.value.add(id)
-}
+function openManualImport() { fetchOrganized(); manualImportOpen.value = true }

+// ── Download ──────────────────────────────────────────────────
 async function download(key: string, torrent_url: string | null, magnet: string | null) {
  if (isDownloading(key) || isDownloaded(key)) return
  addDownloading(key)
  const result = await store.download(torrent_url, magnet)
  removeDownloading(key)
-  if (result.success) {
-    addDownloaded(key)
-    toast('Téléchargement lancé ✓', 'success')
-    fetchActiveDownloads()
-  } else {
-    toast(result.error ?? 'Erreur inconnue', 'error')
+  if (result.success) { addDownloaded(key); toast('Téléchargement lancé ✓', 'success'); fetchActiveDownloads() }
+  else toast(result.error ?? 'Erreur inconnue', 'error')
+}
+
+function collectDownloadables() {
+  if (!data.value) return []
+  const result: { key: string; torrent_url: string | null; magnet: string | null }[] = []
+  const covered = new Set<number>()
+  data.value.torrents_integrale.forEach((t: any, i: number) => {
+    if (!isAlreadyQueued(t) && !isDownloaded(`integrale-${i}`)) {
+      result.push({ key: `integrale-${i}`, torrent_url: t.torrent_url, magnet: t.magnet })
+      for (const season of data.value!.seasons) for (const ep of season.episodes) covered.add(ep.id)
+    }
+  })
+  for (const season of data.value.seasons) {
+    if (!season.torrent || isAlreadyQueued(season.torrent) || isDownloaded(`season-${season.id}`) || season.organized_state === 'complete') continue
+    result.push({ key: `season-${season.id}`, torrent_url: season.torrent.torrent_url, magnet: season.torrent.magnet })
+    for (const ep of season.episodes) covered.add(ep.id)
  }
+  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 })
+    }
+  }
+  return result
 }

-function load() {
-  store.fetchSerieDetail(Number(route.params.id))
+const hasDownloadableTorrents = computed(() => collectDownloadables().length > 0)
+
+async function downloadAll() {
+  downloadingAll.value = true
+  const torrents = collectDownloadables()
+  let sent = 0
+  for (const t of torrents) {
+    try { const r = await store.download(t.torrent_url, t.magnet); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
+  }
+  downloadingAll.value = false
+  if (sent > 0) { toast(`${sent} torrent(s) envoyé(s) ✓`, 'success'); fetchActiveDownloads() }
+  else toast('Aucun nouveau torrent à télécharger', 'success')
 }

-function formatDate(d: string): string {
-  if (!d) return ''
-  return new Date(d).toLocaleDateString('fr-FR', { year: 'numeric', month: 'short', day: 'numeric' })
+async function downloadSeason(season: Season) {
+  downloadingSeason.value[season.id] = true
+  const torrents: { key: string; torrent_url: string | null; magnet: string | null }[] = []
+  if (season.torrent && !isAlreadyQueued(season.torrent) && !isDownloaded(`season-${season.id}`) && season.organized_state !== 'complete') {
+    torrents.push({ key: `season-${season.id}`, torrent_url: season.torrent.torrent_url, magnet: season.torrent.magnet })
+  } else {
+    for (const ep of (season as any).episodes ?? []) {
+      if (!ep.torrent || !ep.available || ep.organized || isAlreadyQueued(ep.torrent) || isDownloaded(`ep-${ep.id}`)) continue
+      torrents.push({ key: `ep-${ep.id}`, torrent_url: ep.torrent.torrent_url, magnet: ep.torrent.magnet })
+    }
+  }
+  let sent = 0
+  for (const t of torrents) {
+    try { const r = await store.download(t.torrent_url, t.magnet); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
+  }
+  downloadingSeason.value[season.id] = false
+  if (sent > 0) { toast(`${sent} torrent(s) envoyé(s) ✓`, 'success'); fetchActiveDownloads() }
+  else toast('Aucun nouveau torrent à télécharger pour cette saison', 'success')
 }

-function formatDuration(seconds: number): string {
-  if (!seconds || seconds <= 0) return ''
-  const h = Math.floor(seconds / 3600)
-  const m = Math.floor((seconds % 3600) / 60)
-  if (h > 0) return m > 0 ? `${h}h ${m}min` : `${h}h`
-  return `${m} min`
+// ── Actions ───────────────────────────────────────────────────
+function toggleSeason(id: number) {
+  if (collapsedSeasons.value.has(id)) collapsedSeasons.value.delete(id)
+  else collapsedSeasons.value.add(id)
+}
+
+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')
+    await fetchOrganized(); load()
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+}
+
+async function renameEpisode(ep: any, _season: any) {
+  epActionLoading.value[ep.id] = true
+  try {
+    const torrentHash = ep.paths?.[0]?.infohash ?? null
+    const res = await fetch('/api/rename-episode', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+      body: JSON.stringify({ serie_id: Number(route.params.id), episode_id: ep.id, torrent_hash: torrentHash }),
+    })
+    const d = await res.json()
+    if (!res.ok) { toast(d.error ?? 'Erreur rename', 'error'); return }
+    if (d.renamed) { toast(`Renommé : ${d.new_name}`, 'success'); await fetchOrganized() }
+    else toast(d.message ?? 'Nom déjà correct', 'success')
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+  finally { epActionLoading.value[ep.id] = false }
+}
+
+async function unimportEpisode(ep: any, _season: any, deleteFile: boolean) {
+  epActionLoading.value[ep.id] = true
+  try {
+    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')
+    await fetchOrganized(); load()
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+  finally { epActionLoading.value[ep.id] = false }
 }

 onMounted(() => {
-  load()
-  // fetchOrganized()
-  fetchActiveDownloads()
+  load(); fetchSettings(); fetchOrganized(); fetchActiveDownloads()
  pollTimer = setInterval(fetchActiveDownloads, 5000)
+  document.addEventListener('click', () => { unimportMenuOpen.value = false })
 })
-
 onUnmounted(() => {
  if (pollTimer) clearInterval(pollTimer)
+  document.removeEventListener('click', () => { unimportMenuOpen.value = false })
 })
-</script>
+</script>
@@ -1,121 +1,19 @@
 <template>
  <div class="flex flex-col">

-    <!-- Toolbar -->
-    <div class="shrink-0 px-4 md:px-6 py-3 border-b border-border flex flex-col gap-2">
-
-      <!-- Ligne 1 : recherche + filtres -->
-      <div class="flex items-center gap-2">
-
-        <div class="relative flex-1">
-          <Search class="absolute left-3 top-1/2 -translate-y-1/2 text-muted pointer-events-none" :size="14" />
-          <input
-              v-model="search"
-              type="text"
-              placeholder="Rechercher…"
-              class="settings-input pl-9 w-full py-1.5 text-sm"
-          />
-        </div>
-
-        <!-- Filtres : icône only sur mobile, texte sur desktop -->
-        <div class="relative shrink-0" ref="filterRef">
-          <button
-              @click="filterOpen = !filterOpen"
-              class="btn-secondary flex items-center gap-1.5 py-1.5 px-2.5 relative"
-              :class="hasActiveFilter ? 'border-accent text-accent' : ''"
-              title="Filtres"
-          >
-            <SlidersHorizontal :size="15" />
-            <span class="hidden md:inline text-xs">Filtres</span>
-            <ChevronDown class="hidden md:inline transition-transform" :size="12" :class="filterOpen ? 'rotate-180' : ''" />
-            <span v-if="hasActiveFilter" class="absolute -top-1 -right-1 w-2 h-2 rounded-full bg-accent" />
-          </button>
-
-          <div
-              v-if="filterOpen"
-              class="absolute top-full right-0 mt-1 bg-card border border-border rounded-xl p-3 z-20 w-52 flex flex-col gap-3 shadow-xl"
-          >
-            <div>
-              <p class="text-xs text-muted mb-1.5">Disponibilité</p>
-              <div class="flex flex-col gap-1">
-                <button
-                    v-for="f in filtersDisponibilite" :key="f.value"
-                    @click="activeFilter = f.value"
-                    class="flex items-center justify-between px-2 py-1.5 rounded-lg text-xs transition-colors"
-                    :class="activeFilter === f.value ? 'bg-active text-primary' : 'text-secondary hover:bg-hover'"
-                >
-                  {{ f.label }}
-                  <span v-if="activeFilter === f.value" class="w-1.5 h-1.5 rounded-full bg-accent" />
-                </button>
-              </div>
-            </div>
-            <div class="border-t border-border pt-3">
-              <p class="text-xs text-muted mb-1.5">État import</p>
-              <div class="flex flex-col gap-1">
-                <button
-                    v-for="f in filtersImport" :key="f.value"
-                    @click="activeFilter = f.value"
-                    class="flex items-center justify-between px-2 py-1.5 rounded-lg text-xs transition-colors"
-                    :class="activeFilter === f.value ? 'bg-active text-primary' : 'text-secondary hover:bg-hover'"
-                >
-                  <div class="flex items-center gap-2">
-                    <span class="w-2 h-2 rounded-full shrink-0" :style="{ background: f.color }" />
-                    {{ f.label }}
-                  </div>
-                  <span v-if="activeFilter === f.value" class="w-1.5 h-1.5 rounded-full bg-accent" />
-                </button>
-              </div>
-            </div>
-            <button
-                v-if="hasActiveFilter"
-                @click="activeFilter = 'all'"
-                class="text-xs text-muted hover:text-primary transition-colors text-left pt-1 border-t border-border"
-            >
-              Effacer les filtres
-            </button>
-          </div>
-        </div>
-      </div>
-
-      <!-- Ligne 2 : tri + taille + count -->
-      <div class="flex items-center gap-2 flex-wrap">
-        <div class="flex items-center gap-1">
-          <button
-              v-for="s in sortOptions" :key="s.value"
-              @click="activeSort = s.value"
-              class="px-2.5 py-1 text-xs rounded-lg border transition-colors"
-              :class="activeSort === s.value
-              ? 'border-accent text-accent bg-accent-muted'
-              : 'border-border text-muted hover:border-secondary'"
-          >
-            {{ s.label }}
-          </button>
-        </div>
-
-        <div class="flex items-center gap-1 border-l border-border pl-2 ml-auto">
-          <button
-              v-for="(_, size) in posterSizes" :key="size"
-              @click="posterSize = size"
-              class="w-7 h-7 text-[10px] rounded-md border transition-colors flex items-center justify-center"
-              :class="posterSize === size
-              ? 'border-accent text-accent bg-accent-muted'
-              : 'border-border text-muted hover:border-secondary'"
-          >
-            {{ size }}
-          </button>
-        </div>
-
-        <span class="text-xs text-muted">{{ filtered.length }} série{{ filtered.length > 1 ? 's' : '' }}</span>
-      </div>
-    </div>
-
-    <!-- Légende barres -->
-    <div class="shrink-0 px-4 md:px-6 py-2 flex items-center gap-4 border-b border-border">
-      <div v-for="l in legend" :key="l.label" class="flex items-center gap-1.5">
-        <span class="w-3 h-1.5 rounded-full" :style="{ background: l.color }" />
-        <span class="text-[11px] text-muted">{{ l.label }}</span>
-      </div>
-    </div>
+    <SeriesToolbar
+        v-model:search="search"
+        v-model:active-filter="activeFilter"
+        v-model:active-sort="activeSort"
+        v-model:poster-size="posterSize"
+        :poster-sizes="posterSizes"
+        :count="filtered.length"
+        :has-active-filter="hasActiveFilter"
+        :filters-disponibilite="filtersDisponibilite"
+        :filters-import="filtersImport"
+        :sort-options="sortOptions"
+        :legend="legend"
+    />

    <!-- Grille -->
    <div class="px-4 md:px-6 py-6">
@@ -140,7 +38,7 @@
            :key="serie.id"
            :to="`/series/${serie.id}`"
            class="group flex flex-col gap-1.5 transition-transform duration-200 hover:-translate-y-0.5"
-            :class="{ 'opacity-40': !serie.has_torrents }"
+            :class="{ 'opacity-40': !serie.has_torrents && serie.download_state === 'none' }"
        >
          <div class="relative aspect-[2/3] rounded-lg overflow-hidden bg-card border border-border">
            <img
@@ -189,12 +87,12 @@
 <script setup lang="ts">
 import { ref, computed, onMounted, onUnmounted, onActivated } from 'vue'
 import { RouterLink } from 'vue-router'
-import { Search, SlidersHorizontal, ChevronDown, Tv } from 'lucide-vue-next'
-import { onClickOutside } from '@vueuse/core'
+import { Tv } from 'lucide-vue-next'
 import { useSeriesStore } from '@/stores/series'
 import { useDownloadsStore } from '@/stores/downloads'
 import { useToast } from '@/composables/useToast'
 import { usePosterSize } from '@/composables/usePosterSize'
+import SeriesToolbar from '@/components/series/SeriesToolbar.vue'

 defineOptions({ name: 'SeriesView' })

@@ -206,10 +104,6 @@ const { current: posterSize, sizes: posterSizes } = usePosterSize()
 const search       = ref('')
 const activeFilter = ref('all')
 const activeSort   = ref('alpha')
-const filterOpen   = ref(false)
-const filterRef    = ref<HTMLElement | null>(null)
-
-onClickOutside(filterRef, () => { filterOpen.value = false })

 const filtersDisponibilite = [
  { label: 'Toutes',       value: 'all' },
@@ -320,4 +214,4 @@ onActivated(async () => {
 onUnmounted(() => {
  if (dlInterval) clearInterval(dlInterval)
 })
-</script>
+</script>
@@ -8,38 +8,47 @@
      </p>
    </div>

-    <!-- Bannière données manquantes -->
-    <div
-        v-if="status.empty"
-        class="border border-accent/30 bg-accent-muted rounded-lg p-4 flex items-center justify-between gap-4"
-    >
-      <div>
-        <p class="text-xs text-accent font-medium mb-1">Données manquantes</p>
-        <p class="text-sm text-secondary">
-          {{ status.exists ? 'Le catalogue est vide.' : 'Aucun catalogue trouvé.' }}
-          Téléchargez les données pour utiliser FanKarr.
+    <!-- Loading -->
+    <div v-if="!loaded" class="flex items-center justify-center gap-2 py-16 text-muted text-sm">
+      <div class="w-4 h-4 border border-border border-t-accent rounded-full animate-spin" />
+    </div>
+
+    <template v-else>
+
+      <!-- Bannière données manquantes -->
+      <div
+          v-if="status.empty"
+          class="border border-accent/30 bg-accent-muted rounded-lg p-4 flex items-center justify-between gap-4"
+      >
+        <div>
+          <p class="text-xs text-accent font-medium mb-1">Données manquantes</p>
+          <p class="text-sm text-secondary">
+            {{ status.exists ? 'Le catalogue est vide.' : 'Aucun catalogue trouvé.' }}
+            Téléchargez les données pour utiliser FanKarr.
+          </p>
+        </div>
+        <button @click="update" :disabled="updating" class="btn-primary whitespace-nowrap">
+          {{ updating ? 'Téléchargement...' : 'Télécharger' }}
+        </button>
+      </div>
+
+      <!-- Statut -->
+      <div class="settings-card">
+        <p class="text-xs text-muted mb-1">Statut</p>
+        <p class="text-sm text-primary font-medium">
+          {{ status.empty ? 'Aucune donnée chargée' : `${status.count} séries disponibles` }}
        </p>
      </div>
-      <button @click="update" :disabled="updating" class="btn-primary whitespace-nowrap">
-        {{ updating ? 'Téléchargement...' : 'Télécharger' }}
-      </button>
-    </div>

-    <!-- Statut -->
-    <div class="settings-card">
-      <p class="text-xs text-muted mb-1">Statut</p>
-      <p class="text-sm text-primary font-medium">
-        {{ status.empty ? 'Aucune donnée chargée' : `${status.count} séries disponibles` }}
-      </p>
-    </div>
+      <!-- Action -->
+      <div>
+        <button @click="update" :disabled="updating" class="btn-primary">
+          {{ updating ? 'Mise à jour...' : 'Mettre à jour maintenant' }}
+        </button>
+        <p class="text-xs text-muted mt-2">Force la synchronisation sans attendre le cache de 6h.</p>
+      </div>

-    <!-- Action -->
-    <div>
-      <button @click="update" :disabled="updating" class="btn-primary">
-        {{ updating ? 'Mise à jour...' : 'Mettre à jour maintenant' }}
-      </button>
-      <p class="text-xs text-muted mt-2">Force la synchronisation sans attendre le cache de 6h.</p>
-    </div>
+    </template>

  </div>
 </template>
@@ -51,11 +60,13 @@ import { useToast } from '@/composables/useToast'
 const { add: toast } = useToast()

 const updating = ref(false)
+const loaded   = ref(false)
 const status   = ref({ exists: false, count: 0, empty: true })

 onMounted(async () => {
  const res = await fetch('/api/torrents/status', { credentials: 'include' })
  if (res.ok) status.value = await res.json()
+  loaded.value = true
 })

 async function update() {
@@ -0,0 +1,287 @@
+<template>
+  <div class="flex flex-col gap-6 px-4 md:px-8 py-6 max-w-4xl">
+
+    <!-- Header -->
+    <div class="flex items-center justify-between">
+      <div>
+        <h2 class="text-base font-semibold text-primary">Gestion des imports</h2>
+        <p class="text-xs text-muted mt-0.5">
+          Visualisez et renommez vos fichiers importés selon le mode actuel
+          <span class="ml-1 px-1.5 py-0.5 rounded text-[10px]"
+                :class="nfoSupport ? 'bg-accent/10 text-accent' : 'bg-hover text-muted'">
+            {{ nfoSupport ? 'Mode NFO' : 'Mode Formaté' }}
+          </span>
+        </p>
+      </div>
+      <div class="flex items-center gap-2">
+        <button @click="load" :disabled="loading" class="btn-secondary">
+          <svg width="13" height="13" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"
+               :class="loading ? 'animate-spin' : ''">
+            <path d="M21 12a9 9 0 0 1-9 9 9 9 0 0 1-6.36-2.64M3 12a9 9 0 0 1 9-9 9 9 0 0 1 6.36 2.64"/>
+            <polyline points="16 5 21 5 21 10"/>
+          </svg>
+          Actualiser
+        </button>
+        <button
+            v-if="totalNeedsRename > 0"
+            @click="renameAll()"
+            :disabled="renamingAll"
+            class="btn-primary"
+        >
+          {{ renamingAll ? 'Renommage…' : `Tout renommer (${totalNeedsRename})` }}
+        </button>
+      </div>
+    </div>
+
+    <!-- Loading -->
+    <div v-if="loading" class="flex items-center justify-center gap-2 py-16 text-muted text-sm">
+      <div class="w-4 h-4 border border-border border-t-accent rounded-full animate-spin" />
+      Chargement…
+    </div>
+
+    <!-- Vide -->
+    <div v-else-if="series.length === 0" class="settings-card flex flex-col items-center gap-2 py-16 text-center">
+      <p class="text-sm text-muted">Aucune série importée</p>
+      <p class="text-xs text-muted">Importez des séries depuis la page Activité ou via l'import manuel.</p>
+    </div>
+
+    <!-- Résultat rename all -->
+    <div v-if="renameResult" class="settings-card flex items-center justify-between gap-3">
+      <p class="text-xs" :class="renameResult.errors.length > 0 ? 'text-yellow-500' : 'text-green-400'">
+        {{ renameResult.done }} fichier{{ renameResult.done > 1 ? 's' : '' }} renommé{{ renameResult.done > 1 ? 's' : '' }}
+        <span v-if="renameResult.errors.length > 0"> · {{ renameResult.errors.length }} erreur{{ renameResult.errors.length > 1 ? 's' : '' }}</span>
+      </p>
+      <button @click="renameResult = null" class="text-xs text-muted hover:text-primary">✕</button>
+    </div>
+
+    <!-- Liste séries -->
+    <div v-else class="flex flex-col gap-3">
+      <div
+          v-for="serie in filteredSeries"
+          :key="serie.serie_id"
+          class="settings-card flex flex-col gap-0"
+      >
+        <!-- Header série -->
+        <div class="flex items-center justify-between py-1">
+          <div class="flex items-center gap-2.5">
+            <button @click="toggleSerie(serie.serie_id)" class="text-muted hover:text-primary transition-colors">
+              <svg width="13" height="13" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"
+                   class="transition-transform" :class="collapsed.has(serie.serie_id) ? '' : 'rotate-180'">
+                <polyline points="18 15 12 9 6 15"/>
+              </svg>
+            </button>
+            <p class="text-sm font-medium text-primary">{{ serie.serie_title }}</p>
+            <span class="text-xs text-muted">{{ serie.total }} épisode{{ serie.total > 1 ? 's' : '' }}</span>
+            <span v-if="serie.needs_rename > 0"
+                  class="text-[10px] px-1.5 py-0.5 rounded bg-yellow-500/10 text-yellow-400 border border-yellow-500/20">
+              {{ serie.needs_rename }} à renommer
+            </span>
+            <span v-if="serie.episodes.filter((e: any) => !e.file_exists).length > 0"
+                  class="text-[10px] px-1.5 py-0.5 rounded bg-red-500/10 text-red-400 border border-red-500/20">
+              {{ serie.episodes.filter((e: any) => !e.file_exists).length }} introuvable{{ serie.episodes.filter((e: any) => !e.file_exists).length > 1 ? 's' : '' }}
+            </span>
+            <span v-else-if="serie.needs_rename === 0" class="text-[10px] px-1.5 py-0.5 rounded bg-green-500/10 text-green-400 border border-green-500/20">
+              ✓ À jour
+            </span>
+          </div>
+          <div class="flex items-center gap-2">
+            <button v-if="serie.needs_rename > 0" @click="renameAll(serie.serie_id)" :disabled="renamingAll" class="text-xs text-accent hover:underline">
+              Tout renommer
+            </button>
+            <button @click="unimportSerie(serie, false)" :disabled="renamingAll" class="text-xs text-muted hover:text-primary transition-colors">
+              Désimporter
+            </button>
+            <button @click="unimportSerie(serie, true)" :disabled="renamingAll" class="text-xs text-red-400 hover:text-red-300 transition-colors">
+              Supprimer fichiers
+            </button>
+          </div>
+        </div>
+
+        <!-- Liste épisodes -->
+        <div v-if="!collapsed.has(serie.serie_id)" class="flex flex-col divide-y divide-border/50 mt-2 -mx-4 px-4">
+          <div
+              v-for="ep in serie.episodes"
+              :key="ep.episode_id"
+              class="flex items-center gap-3 py-2.5"
+          >
+            <!-- Numéro -->
+            <span class="text-xs text-muted font-mono shrink-0 w-14">
+              S{{ String(ep.season_number).padStart(2,'0') }}E{{ String(ep.episode_number).padStart(2,'0') }}
+            </span>
+
+            <!-- Noms -->
+            <div class="flex-1 min-w-0">
+              <p class="text-xs text-primary truncate">{{ ep.title }}</p>
+              <div class="flex items-center gap-1.5 mt-0.5">
+                <span class="text-[11px] font-mono text-muted truncate max-w-xs">{{ ep.current_name }}</span>
+                <template v-if="ep.needs_rename">
+                  <svg width="10" height="10" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none" class="shrink-0 text-yellow-400">
+                    <line x1="5" y1="12" x2="19" y2="12"/><polyline points="12 5 19 12 12 19"/>
+                  </svg>
+                  <span class="text-[11px] font-mono text-yellow-400 truncate max-w-xs">{{ ep.expected_name }}</span>
+                </template>
+              </div>
+            </div>
+
+            <!-- Actions -->
+            <div class="flex items-center gap-2 shrink-0">
+              <span v-if="!ep.file_exists" class="text-[10px] px-1.5 py-0.5 rounded bg-red-500/10 text-red-400 border border-red-500/20">Introuvable</span>
+              <span v-else-if="!ep.needs_rename" class="text-[10px] text-green-400">✓</span>
+              <button
+                  v-else
+                  @click="renameSingle(ep)"
+                  :disabled="renamingEp[ep.episode_id]"
+                  class="text-xs px-2 py-1 rounded-lg border border-yellow-500/30 text-yellow-400 hover:bg-yellow-500/10 transition-colors"
+              >
+                {{ renamingEp[ep.episode_id] ? '…' : 'Renommer' }}
+              </button>
+              <button
+                  @click="unimportEp(ep, false)"
+                  :disabled="renamingEp[ep.episode_id]"
+                  class="text-xs px-2 py-1 rounded-lg border border-border text-muted hover:text-primary transition-colors"
+              >
+                Désimporter
+              </button>
+              <button
+                  @click="unimportEp(ep, true)"
+                  :disabled="renamingEp[ep.episode_id]"
+                  class="text-xs px-2 py-1 rounded-lg border border-red-500/20 text-red-400 hover:bg-red-500/10 transition-colors"
+              >
+                Supprimer
+              </button>
+            </div>
+          </div>
+        </div>
+
+      </div>
+    </div>
+
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted } from 'vue'
+import { useToast } from '@/composables/useToast'
+
+const { add: toast } = useToast()
+
+// ─── State ────────────────────────────────────────────────────
+const loading     = ref(true)
+const renamingAll = ref(false)
+const series      = ref<any[]>([])
+const nfoSupport  = ref(false)
+const collapsed   = ref<Set<number>>(new Set())
+const renamingEp  = ref<Record<number, boolean>>({})
+const renameResult = ref<{ done: number; errors: any[] } | null>(null)
+const showOnlyNeedsRename = ref(false)
+
+// ─── Computed ──────────────────────────────────────────────────
+const totalNeedsRename = computed(() => series.value.reduce((acc, s) => acc + s.needs_rename, 0))
+
+const filteredSeries = computed(() =>
+    showOnlyNeedsRename.value ? series.value.filter(s => s.needs_rename > 0) : series.value
+)
+
+// ─── Actions ──────────────────────────────────────────────────
+async function load() {
+  loading.value = true
+  try {
+    const res = await fetch('/api/organized-summary', { credentials: 'include' })
+    if (!res.ok) { toast('Erreur chargement', 'error'); return }
+    const data = await res.json()
+    series.value     = data.series ?? []
+    nfoSupport.value = data.nfo_support ?? false
+    // Replier les séries sans rename par défaut
+    collapsed.value = new Set(series.value.filter(s => s.needs_rename === 0).map((s: any) => s.serie_id))
+  } finally {
+    loading.value = false
+  }
+}
+
+function toggleSerie(id: number) {
+  if (collapsed.value.has(id)) collapsed.value.delete(id)
+  else collapsed.value.add(id)
+  // Forcer la réactivité
+  collapsed.value = new Set(collapsed.value)
+}
+
+async function renameAll(serieId?: number) {
+  renamingAll.value = true
+  renameResult.value = null
+  try {
+    const res = await fetch('/api/rename-all', {
+      method     : 'POST',
+      headers    : { 'Content-Type': 'application/json' },
+      credentials: 'include',
+      body       : JSON.stringify(serieId ? { serie_id: serieId } : {}),
+    })
+    const data = await res.json()
+    renameResult.value = { done: data.done, errors: data.errors ?? [] }
+    if (data.done > 0) await load()
+  } catch {
+    toast('Impossible de contacter le serveur', 'error')
+  } finally {
+    renamingAll.value = false
+  }
+}
+
+async function renameSingle(ep: any) {
+  renamingEp.value[ep.episode_id] = true
+  try {
+    const res = await fetch('/api/rename-episode', {
+      method     : 'POST',
+      headers    : { 'Content-Type': 'application/json' },
+      credentials: 'include',
+      body       : JSON.stringify({ episode_id: ep.episode_id, torrent_hash: ep.torrent_hash }),
+    })
+    const data = await res.json()
+    if (!res.ok) { toast(data.error ?? 'Erreur', 'error'); return }
+    toast(`Renommé : ${data.new_name}`, 'success')
+    await load()
+  } catch {
+    toast('Impossible de contacter le serveur', 'error')
+  } finally {
+    renamingEp.value[ep.episode_id] = false
+  }
+}
+
+async function unimportSerie(serie: any, deleteFile: boolean) {
+  if (!confirm(`Désimporter "${serie.serie_title}"${deleteFile ? ' et supprimer les fichiers' : ''} ?`)) return
+  renamingAll.value = true
+  try {
+    const res = await fetch(`/api/organized/${serie.serie_id}?deleteFile=${deleteFile}`, {
+      method: 'DELETE', credentials: 'include',
+    })
+    if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur', 'error'); return }
+    const data = await res.json()
+    toast(`${data.removed} épisode(s) désimporté(s) ✓`, 'success')
+    await load()
+  } catch {
+    toast('Impossible de contacter le serveur', 'error')
+  } finally {
+    renamingAll.value = false
+  }
+}
+
+async function unimportEp(ep: any, deleteFile: boolean) {
+  renamingEp.value[ep.episode_id] = true
+  try {
+    // On cherche le serie_id depuis la liste
+    const serie = series.value.find(s => s.episodes.some((e: any) => e.episode_id === ep.episode_id))
+    if (!serie) return
+    const res = await fetch(`/api/organized/${serie.serie_id}/${ep.episode_id}?deleteFile=${deleteFile}`, {
+      method     : 'DELETE',
+      credentials: 'include',
+    })
+    if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur', 'error'); return }
+    toast(deleteFile ? 'Fichier supprimé ✓' : 'Désimporté ✓', 'success')
+    await load()
+  } catch {
+    toast('Impossible de contacter le serveur', 'error')
+  } finally {
+    renamingEp.value[ep.episode_id] = false
+  }
+}
+
+onMounted(load)
+</script>
@@ -6,115 +6,130 @@
      <p class="text-sm text-muted mt-1">Configuration des dossiers et du comportement d'import.</p>
    </div>

-    <!-- Dossiers -->
-    <div class="settings-card flex flex-col gap-5">
-
-      <div>
-        <div class="flex items-center gap-2 mb-1.5">
-          <label class="settings-label">Dossier téléchargements</label>
-          <span v-if="isDocker" class="text-[10px] text-accent border border-accent/40 px-1.5 py-0.5 rounded">Docker</span>
-        </div>
-        <button @click="openPicker('completePath')" class="settings-input text-left font-mono truncate w-full"
-                :class="isRootPath(form.completePath) ? 'text-yellow-500 border-yellow-500/40' : form.completePath ? 'text-primary' : 'text-muted'">
-          {{ form.completePath || '/' }}
-        </button>
-        <p v-if="isRootPath(form.completePath)" class="text-xs text-yellow-500 mt-1.5 flex items-center gap-1">
-          <span>⚠</span> Chemin non configuré — cliquez pour sélectionner un dossier
-        </p>
-        <p v-else class="text-xs text-muted mt-1.5">Dossier où sont déposés les fichiers téléchargés</p>
-      </div>
-
-      <div>
-        <div class="flex items-center gap-2 mb-1.5">
-          <label class="settings-label">Médiathèque Fankai</label>
-          <span v-if="isDocker" class="text-[10px] text-accent border border-accent/40 px-1.5 py-0.5 rounded">Docker</span>
-        </div>
-        <button @click="openPicker('mediaPath')" class="settings-input text-left font-mono truncate w-full"
-                :class="isRootPath(form.mediaPath) ? 'text-yellow-500 border-yellow-500/40' : form.mediaPath ? 'text-primary' : 'text-muted'">
-          {{ form.mediaPath || '/' }}
-        </button>
-        <p v-if="isRootPath(form.mediaPath)" class="text-xs text-yellow-500 mt-1.5 flex items-center gap-1">
-          <span>⚠</span> Chemin non configuré — cliquez pour sélectionner un dossier
-        </p>
-        <p v-else class="text-xs text-muted mt-1.5">Dossier racine de votre médiathèque (Jellyfin, Kodi, Plex…)</p>
-      </div>
-
+    <!-- Loading -->
+    <div v-if="!loaded" class="flex items-center justify-center gap-2 py-16 text-muted text-sm">
+      <div class="w-4 h-4 border border-border border-t-accent rounded-full animate-spin" />
    </div>

-    <!-- Alerte globale si un des deux paths est sur / -->
-    <div v-if="hasUnconfiguredPaths" class="flex items-start gap-3 px-4 py-3 rounded-lg border border-yellow-500/40 bg-yellow-500/5">
-      <span class="text-yellow-500 text-sm mt-0.5">⚠</span>
-      <div class="flex flex-col gap-0.5">
-        <p class="text-sm text-yellow-500 font-medium">Chemins non configurés</p>
+    <template v-else>
+
+      <!-- Chemins -->
+      <div class="settings-card flex flex-col gap-5">
+        <div>
+          <div class="flex items-center gap-2 mb-1.5">
+            <label class="settings-label">Dossier téléchargements</label>
+            <span v-if="isDocker" class="text-[10px] text-accent border border-accent/40 px-1.5 py-0.5 rounded">Docker</span>
+          </div>
+          <button @click="openPicker('completePath')" class="settings-input text-left font-mono truncate w-full"
+                  :class="isRootPath(form.completePath) ? 'text-yellow-500 border-yellow-500/40' : form.completePath ? 'text-primary' : 'text-muted'">
+            {{ form.completePath || '/' }}
+          </button>
+          <p v-if="isRootPath(form.completePath)" class="text-xs text-yellow-500 mt-1.5 flex items-center gap-1">
+            <span>⚠</span> Chemin non configuré — cliquez pour sélectionner un dossier
+          </p>
+          <p v-else class="text-xs text-muted mt-1.5">Dossier où sont déposés les fichiers téléchargés</p>
+        </div>
+
+        <div>
+          <div class="flex items-center gap-2 mb-1.5">
+            <label class="settings-label">Médiathèque Fankai</label>
+            <span v-if="isDocker" class="text-[10px] text-accent border border-accent/40 px-1.5 py-0.5 rounded">Docker</span>
+          </div>
+          <button @click="openPicker('mediaPath')" class="settings-input text-left font-mono truncate w-full"
+                  :class="isRootPath(form.mediaPath) ? 'text-yellow-500 border-yellow-500/40' : form.mediaPath ? 'text-primary' : 'text-muted'">
+            {{ form.mediaPath || '/' }}
+          </button>
+          <p v-if="isRootPath(form.mediaPath)" class="text-xs text-yellow-500 mt-1.5 flex items-center gap-1">
+            <span>⚠</span> Chemin non configuré — cliquez pour sélectionner un dossier
+          </p>
+          <p v-else class="text-xs text-muted mt-1.5">Dossier racine de votre médiathèque (Jellyfin, Kodi, Plex…)</p>
+        </div>
+      </div>
+
+      <!-- Alerte chemins non configurés -->
+      <div v-if="hasUnconfiguredPaths" class="flex items-start gap-3 px-4 py-3 rounded-lg border border-yellow-500/40 bg-yellow-500/5">
+        <span class="text-yellow-500 text-sm mt-0.5">⚠</span>
+        <div class="flex flex-col gap-0.5">
+          <p class="text-sm text-yellow-500 font-medium">Chemins non configurés</p>
+          <p class="text-xs text-muted">
+            L'import automatique est désactivé tant que les dossiers ne sont pas configurés.
+            Configurez-les ci-dessus avant de sauvegarder.
+          </p>
+        </div>
+      </div>
+
+      <!-- Mode import -->
+      <div class="settings-card flex flex-col gap-2">
+        <label class="settings-label">Mode d'import</label>
+        <div class="flex gap-2">
+          <button
+              v-for="mode in (['hardlink', 'copy', 'move'] as const)"
+              :key="mode"
+              @click="form.organizeMode = mode"
+              class="px-4 py-2 text-xs rounded-lg border transition-colors capitalize"
+              :class="form.organizeMode === mode
+              ? 'border-accent text-accent bg-accent-muted'
+              : 'border-border text-muted hover:border-secondary'"
+          >
+            {{ mode === 'hardlink' ? 'Hardlink' : mode === 'copy' ? 'Copier' : 'Déplacer' }}
+          </button>
+        </div>
        <p class="text-xs text-muted">
-          L'import automatique est désactivé tant que les dossiers ne sont pas configurés.
-          Configurez-les ci-dessus avant de sauvegarder.
+          <span class="text-primary">Hardlink recommandé</span> — le fichier reste dans le client torrent pour le ratio
        </p>
      </div>
-    </div>

-    <!-- Mode import -->
-    <div class="settings-card flex flex-col gap-2">
-      <label class="settings-label">Mode d'import</label>
-      <div class="flex gap-2">
-        <button
-            @click="form.organizeMode = 'hardlink'"
-            class="px-4 py-2 text-xs rounded-lg border transition-colors"
-            :class="form.organizeMode === 'hardlink'
-            ? 'border-accent text-accent bg-accent-muted'
-            : 'border-border text-muted hover:border-secondary'"
-        >
-          Hardlink
-        </button>
-        <button
-            @click="form.organizeMode = 'move'"
-            class="px-4 py-2 text-xs rounded-lg border transition-colors"
-            :class="form.organizeMode === 'move'
-            ? 'border-accent text-accent bg-accent-muted'
-            : 'border-border text-muted hover:border-secondary'"
-        >
-          Déplacer
-        </button>
+      <!-- Toggles -->
+      <div class="settings-card flex flex-col gap-5">
+        <SettingsToggle
+            v-model="form.autoImport"
+            label="Import automatique"
+            description="Importer automatiquement dès qu'un téléchargement est terminé. Vérifie toutes les 5 minutes."
+        />
+        <SettingsToggle
+            v-model="form.nfoSupport"
+            label="NFO / Métadonnées"
+            description="Télécharge les NFO et images depuis GitLab lors de l'import (Kodi, Infuse, etc.)."
+        />
+        <SettingsToggle
+            v-if="form.organizeMode === 'move'"
+            v-model="form.deleteTorrentOnMove"
+            label="Supprimer le torrent après déplacement"
+            description="Supprime automatiquement le torrent du client après un import en mode Déplacer."
+        />
+        <SettingsToggle
+            v-model="form.autoUnimportMissing"
+            label="Désimporter si fichier manquant"
+            description="Si un fichier importé n'est plus trouvé sur le disque lors du scan, il est automatiquement retiré de la bibliothèque."
+        />
      </div>
-      <p class="text-xs text-muted">
-        <span class="text-primary">Hardlink recommandé</span> — le fichier reste dans le client torrent pour le ratio
-      </p>
-    </div>

-    <!-- Toggles -->
-    <div class="settings-card flex flex-col gap-5">
+      <!-- Plex -->
+      <div class="settings-card flex items-center justify-between gap-4">
+        <div>
+          <p class="settings-label">Plex</p>
+          <p class="text-xs text-muted mt-0.5">
+            Créez une bibliothèque Plex connectée à l'agent de métadonnées Fankai.
+            Requiert Plex Media Server 1.43+ pour la configuration automatique de l'agent.
+          </p>
+        </div>
+        <button @click="plexOpen = true" class="btn-secondary shrink-0">Configurer Plex</button>
+      </div>

-      <SettingsToggle
-          v-model="form.autoImport"
-          label="Import automatique"
-          description="Importer automatiquement dès qu'un téléchargement est terminé. Vérifie toutes les 5 minutes."
-      />
-
-      <SettingsToggle
-          v-model="form.nfoSupport"
-          label="NFO / Métadonnées"
-          description="Télécharge les NFO et images depuis GitLab lors de l'import (Kodi, Infuse, etc.)."
-      />
-
-    </div>
-
-    <!-- Actions -->
-    <div class="flex items-center gap-3">
-      <button @click="save" :disabled="saving" class="btn-primary">
-        {{ saving ? '...' : 'Sauvegarder' }}
-      </button>
-      <button @click="scan" :disabled="scanning" class="btn-secondary">
-        {{ scanning ? 'Scan...' : 'Analyser médiathèque' }}
-      </button>
-      <span
-          v-if="scanResult"
-          class="text-xs"
-          :class="scanResult.added > 0 ? 'text-green-400' : 'text-muted'"
-      >
-        {{ scanResult.found }} fichiers · {{ scanResult.added }} ajoutés
-      </span>
-    </div>
+      <!-- Actions -->
+      <div class="flex items-center gap-3">
+        <button @click="save" :disabled="saving" class="btn-primary">
+          {{ saving ? '...' : 'Sauvegarder' }}
+        </button>
+        <button @click="scan" :disabled="scanning" class="btn-secondary">
+          {{ scanning ? 'Scan...' : 'Analyser médiathèque' }}
+        </button>
+        <span v-if="scanResult" class="text-xs" :class="scanResult.added > 0 ? 'text-green-400' : 'text-muted'">
+          {{ scanResult.found }} fichiers · {{ scanResult.added }} ajoutés
+        </span>
+      </div>

+    </template>
  </div>

  <!-- Folder Picker -->
@@ -124,6 +139,13 @@
      @select="onPickerSelect"
      @cancel="picker.open = false"
  />
+
+  <!-- Plex Wizard -->
+  <PlexWizard
+      v-if="plexOpen"
+      :media-path="form.mediaPath"
+      @close="plexOpen = false"
+  />
 </template>

 <script setup lang="ts">
@@ -131,32 +153,32 @@ import { ref, computed, onMounted } from 'vue'
 import { useToast } from '@/composables/useToast'
 import FolderPicker from '@/components/FolderPicker.vue'
 import SettingsToggle from '@/components/settings/SettingsToggle.vue'
+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 form = ref({
-  mediaPath    : '',
-  completePath : '',
-  organizeMode : 'hardlink' as 'hardlink' | 'move',
-  nfoSupport   : false,
-  autoImport   : true,
+  mediaPath           : '',
+  completePath        : '',
+  organizeMode        : 'hardlink' as 'hardlink' | 'copy' | 'move',
+  nfoSupport          : false,
+  autoImport          : true,
+  deleteTorrentOnMove : false,
+  autoUnimportMissing : false,
 })

 const picker = ref<{ open: boolean; field: 'completePath' | 'mediaPath'; currentPath: string }>({
-  open: false,
-  field: 'completePath',
-  currentPath: '/',
+  open: false, field: 'completePath', currentPath: '/',
 })

-// FIX : détection path non configuré (vide ou racine /)
-function isRootPath(p: string): boolean {
-  return !p || p === '/'
-}
+function isRootPath(p: string): boolean { return !p || p === '/' }

 const hasUnconfiguredPaths = computed(() =>
    isRootPath(form.value.completePath) || isRootPath(form.value.mediaPath)
@@ -171,17 +193,6 @@ function onPickerSelect(path: string) {
  picker.value.open = false
 }

-onMounted(async () => {
-  const [settingsRes, systemRes, infoRes] = await Promise.all([
-    fetch('/api/settings', { credentials: 'include' }),
-    fetch('/api/system',   { credentials: 'include' }),
-    fetch('/api/system/info', { credentials: 'include' }),
-  ])
-  if (settingsRes.ok) Object.assign(form.value, await settingsRes.json())
-  if (systemRes.ok)   isDocker.value = (await systemRes.json()).isDocker
-  if (infoRes.ok) picker.value.currentPath = (await infoRes.json()).defaultPath ?? '/'
-})
-
 async function save() {
  saving.value = true
  try {
@@ -197,19 +208,14 @@ async function save() {
 }

 async function scan() {
-  scanning.value  = true
+  scanning.value   = true
  scanResult.value = null
  try {
    const res = await fetch('/api/scan', { method: 'POST', credentials: 'include' })
    if (res.ok) {
      const data = await res.json()
      scanResult.value = { found: data.found, added: data.added }
-      toast(
-          data.added > 0
-              ? `${data.found} fichiers analysés — ${data.added} ajoutés`
-              : `${data.found} fichiers analysés — rien de nouveau`,
-          'success'
-      )
+      toast(data.added > 0 ? `${data.found} fichiers analysés — ${data.added} ajoutés` : `${data.found} fichiers analysés — rien de nouveau`, 'success')
    } else {
      toast("Erreur lors de l'analyse", 'error')
    }
@@ -219,4 +225,16 @@ async function scan() {
    scanning.value = false
  }
 }
-</script>
+
+onMounted(async () => {
+  const [settingsRes, systemRes, infoRes] = await Promise.all([
+    fetch('/api/settings',     { credentials: 'include' }),
+    fetch('/api/system',       { credentials: 'include' }),
+    fetch('/api/system/info',  { credentials: 'include' }),
+  ])
+  if (settingsRes.ok) Object.assign(form.value, await settingsRes.json())
+  if (systemRes.ok)   isDocker.value = (await systemRes.json()).isDocker
+  if (infoRes.ok)     picker.value.currentPath = (await infoRes.json()).defaultPath ?? '/'
+  loaded.value = true
+})
+</script>
@@ -0,0 +1 @@
+3.9.1
Author	SHA1	Message	Date
MasutaYunikon	f5127637ca	Merge pull request #87 from Masutayunikon/release-please--branches--main chore(main): release 3.9.1	2026-04-16 09:38:44 +02:00
MasutaYunikon	f995fd14a6	chore(main): release 3.9.1	2026-04-16 09:22:08 +02:00
MasutaYunikon	9296d64571	Merge remote-tracking branch 'origin/main'	2026-04-16 09:21:35 +02:00
MasutaYunikon	f00556ab51	fix: le badge de rename utilise la meme logique que coté serveur et n'apparait plus sur les vue series si il ne devrais pas	2026-04-16 09:21:26 +02:00
github-actions[bot]	1c88e13a97	chore: update version.txt to v3.9.0	2026-04-15 07:21:09 +00:00
MasutaYunikon	5fed1d523d	Merge pull request #86 from Masutayunikon/release-please--branches--main chore(main): release 3.9.0	2026-04-15 09:20:42 +02:00
MasutaYunikon	c963847c31	chore(main): release 3.9.0	2026-04-15 09:17:33 +02:00
MasutaYunikon	bb21addebb	fix: move plex settings en haut des boutons	2026-04-15 09:17:00 +02:00
MasutaYunikon	bf2274b761	refactor: refactor sur server et les pages qui commencer à faire beaucoup trop de ligne	2026-04-15 09:11:33 +02:00
MasutaYunikon	609ddc777f	fix: plex catcher	2026-04-14 20:57:57 +02:00
MasutaYunikon	353bd009ed	fix: Deux corrections : oauth/start — X-Plex-Client-Identifier ajouté dans le body du POST (Plex l'exige dans le body pour la création du pin, pas juste dans les headers). forwardUrl pointe maintenant vers https://plex.tv au lieu d'être vide — sans ça Plex ne valide pas le pin côté serveur. oauth/poll — X-Plex-Client-Identifier=fankarr passé en query param sur l'URL du GET. Plex exige que le même clientID que celui utilisé lors de la création soit présent pour récupérer le token.	2026-04-14 20:55:53 +02:00
MasutaYunikon	2070c1113d	feat: ajout setup plex	2026-04-14 20:48:21 +02:00
MasutaYunikon	203df7576c	fix: ajout d'un loader sur certaines pages pour pas avoir des trucs par default qui s'affiche	2026-04-14 20:30:18 +02:00
MasutaYunikon	4e8487967c	fix: le bouton tout telecharger apparait sur les packs de saisons et les integrals + autres et pas que sur les series avec des episodes telechargable	2026-04-14 20:23:27 +02:00
MasutaYunikon	1b1dbd3ec8	fix: utorrent prend desormais le dossier cible correctement	2026-04-14 20:16:13 +02:00
MasutaYunikon	7f0e363cfe	fix: wrong file copy	2026-04-14 19:06:48 +02:00
MasutaYunikon	d6f4433541	feat: ajout du bouton suppresion de torrent en cours feat: ajout d'un bouton supprimé l'importation dans le menu d'importation d'une serie feat: ajout de badge quand le fichier est introuvable feat: suppression des series supprimé feat: bouton tous télécharger sur les saisons et series	2026-04-14 19:05:11 +02:00
MasutaYunikon	5e79699ed9	fix: suppression de dest_filename du fichier d'organisation qui est faux et ne sert à rien	2026-04-14 18:37:54 +02:00
MasutaYunikon	e41edd2f5e	fix: ajout de la page management dans le layout	2026-04-14 17:40:27 +02:00
MasutaYunikon	b881fdd557	fix: cast string	2026-04-14 17:36:43 +02:00
MasutaYunikon	e648a81245	Merge remote-tracking branch 'origin/main'	2026-04-14 17:29:10 +02:00
MasutaYunikon	699c130edd	feat: ajout de la possibilité de renommer des imports dans le bon format	2026-04-14 17:29:01 +02:00
github-actions[bot]	acf802e7e1	chore: update version.txt to v3.8.1	2026-04-11 11:35:22 +00:00
MasutaYunikon	f40e8c37e7	Merge pull request #85 from Masutayunikon/release-please--branches--main chore(main): release 3.8.1	2026-04-11 13:35:04 +02:00
MasutaYunikon	2d2043d7ae	chore(main): release 3.8.1	2026-04-11 13:34:39 +02:00
MasutaYunikon	788878ca6c	Merge remote-tracking branch 'origin/main'	2026-04-11 13:34:12 +02:00
MasutaYunikon	f96565a301	fix: la version dev se met uniquement en dev	2026-04-11 13:34:04 +02:00
github-actions[bot]	462ec87e89	chore: update version.txt to v3.8.0	2026-04-11 11:27:30 +00:00
MasutaYunikon	e4b1971532	Merge pull request #84 from Masutayunikon/release-please--branches--main chore(main): release 3.8.0	2026-04-11 13:27:12 +02:00
MasutaYunikon	8a888930e3	chore(main): release 3.8.0	2026-04-11 13:25:29 +02:00
MasutaYunikon	963436aa4a	Merge branch 'main' of github.com:Masutayunikon/FanKarr	2026-04-11 13:24:53 +02:00
MasutaYunikon	a3a1088c14	feat: force release for test	2026-04-11 13:24:43 +02:00
github-actions[bot]	590c310553	chore: update version.txt to v3.7.1	2026-04-11 11:18:21 +00:00
MasutaYunikon	6dd282e6ca	Merge pull request #83 from Masutayunikon/release-please--branches--main chore(main): release 3.7.1	2026-04-11 13:18:00 +02:00
MasutaYunikon	6150b4aea3	chore(main): release 3.7.1	2026-04-11 13:16:02 +02:00
MasutaYunikon	c41f8c76cf	Merge remote-tracking branch 'origin/main'	2026-04-11 13:15:36 +02:00
MasutaYunikon	f593288b73	fix: ajout de la copy dans le worker	2026-04-11 13:13:19 +02:00
github-actions[bot]	a4528aeb0c	chore: update version.txt to v3.7.0	2026-04-11 11:11:15 +00:00
MasutaYunikon	0453ce44fb	Merge pull request #82 from Masutayunikon/release-please--branches--main chore(main): release 3.7.0	2026-04-11 13:10:52 +02:00
MasutaYunikon	1a6b08757b	chore(main): release 3.7.0	2026-04-11 13:03:29 +02:00
MasutaYunikon	8c2d61de06	fix: type	2026-04-11 13:02:55 +02:00
MasutaYunikon	87fd964374	fix: type	2026-04-11 13:01:49 +02:00
MasutaYunikon	271fc14386	fix: settings	2026-04-11 12:59:24 +02:00
MasutaYunikon	176dfed0af	fix: formatage	2026-04-11 12:58:24 +02:00
MasutaYunikon	34057638ca	fix: formatage	2026-04-11 12:56:19 +02:00
MasutaYunikon	bb29f02000	fix: ajout de l'option de suppresion dans l'interface settings.ts	2026-04-11 12:53:19 +02:00
MasutaYunikon	392f736925	feat: ajout du bouton copie feat: ajout de l'option supprimé le torrent si l'option déplacer est activé feat: ajout de la suppression des torrents depuis l'interface	2026-04-11 12:51:31 +02:00
MasutaYunikon	73b401f3e7	fix: l'import a le meme comportement que radarr/sonarr en ouvrant l'import dans le dossier de la serie attendu directement	2026-04-11 12:40:28 +02:00
MasutaYunikon	f7c21f5fd1	feat: edit d'episodes importer dans le menu d'importation	2026-04-11 12:33:25 +02:00
MasutaYunikon	6078aac714	fix: vue des series importer	2026-04-11 12:21:48 +02:00
MasutaYunikon	c61bd05f75	fix: vue des series importer	2026-04-11 12:19:46 +02:00
MasutaYunikon	89f225b980	fix: les series sans torrents sont bien organiser si importé manuellement	2026-04-11 12:15:35 +02:00
MasutaYunikon	66b0313ae9	fix: les series sans torrents sont bien organiser si importé manuellement	2026-04-11 12:12:31 +02:00
MasutaYunikon	e02650d1cc	fix: les series sans torrent et non ajoutées manuellement sont bien grisé	2026-04-11 12:10:03 +02:00
MasutaYunikon	45bf17c48f	fix: les series sans torrent et non ajoutées manuellement sont bien grisé	2026-04-11 11:56:43 +02:00
MasutaYunikon	854839b16a	fix: ajout des series non disponible pour pouvoir les add manuellement	2026-04-11 11:43:31 +02:00
MasutaYunikon	08c4122d5e	fix: log	2026-04-10 21:06:55 +02:00
MasutaYunikon	ef23a7119e	fix: ajout de logs lors de non match	2026-04-10 21:03:57 +02:00
MasutaYunikon	21bcb2ba23	fix: organisation utilise l'extension du fichier au lieu de tester si ça existe	2026-04-10 21:00:24 +02:00
MasutaYunikon	c94ff7da3f	feat: ajout d'une "notification" dans la navbar si une nouvelle versions est disponible feat: activation de l'import manuel	2026-04-10 18:05:47 +02:00
MasutaYunikon	71961eb998	feat: ajout du ratio, upload speed, etc dans les activités	2026-04-10 17:50:00 +02:00
MasutaYunikon	9b4dc4f782	feat: ajout d'une hashmap pour matcher les titres sur synologie et ajouter les hash de torrent manuellement	2026-04-10 17:37:49 +02:00
MasutaYunikon	bb6d094383	Merge remote-tracking branch 'origin/main'	2026-04-10 12:46:05 +02:00
MasutaYunikon	ea7ed597de	fix: changer le noms de build arm64 et windows legacy pour une meilleur comprehension	2026-04-10 12:45:56 +02:00
MasutaYunikon	ba736a6fe1	Merge pull request #81 from Masutayunikon/release-please--branches--main chore(main): release 3.6.1	2026-04-10 12:39:53 +02:00
MasutaYunikon	ceb18cef3c	chore(main): release 3.6.1	2026-04-10 12:38:59 +02:00
MasutaYunikon	327cd66dcc	Merge remote-tracking branch 'origin/main'	2026-04-10 12:38:30 +02:00
MasutaYunikon	31779d8f7e	fix: windows baseline	2026-04-10 12:38:21 +02:00