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

chore(main): release 2.0.0
2026-03-23 04:05:16 +01:00 · 2026-03-23 04:04:52 +01:00 · 2026-03-23 04:04:23 +01:00 · 2026-03-23 04:04:12 +01:00 · 2026-03-21 08:01:19 +01:00 · 2026-03-21 07:59:16 +01:00
12 changed files with 871 additions and 577 deletions
@@ -1,5 +1,185 @@
 # Changelog

+## [2.0.0](https://github.com/Masutayunikon/FanKarr/compare/v1.14.0...v2.0.0) (2026-03-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* suppression de torrent_final.json au profit d'un système de fichiers par série (series/{id}.json) avec cache mémoire GitHub 6h. Version majeure — nécessite un nouveau scraper et une mise à jour complète.
+
+### Features
+
+* **api:** adaptation complète à la nouvelle structure API Fankai ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **api:** cache mémoire GitHub TTL 6h avec invalidation via /api/update ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **api:** matching torrents par hiérarchie série/saison/épisode ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* migration vers nouvelle architecture API et scraper par série ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **organize:** refonte complète sans torrent_final.json ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **scraper:** extraction nom bencode dans raw pour torrents locaux ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **series-view:** badge "Hors Fankai" sur épisodes de torrents manuels ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **series-view:** tooltip raw name sur boutons intégrale via :title ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+
+
+### Bug Fixes
+
+* **catalogue:** état download basé sur épisodes organisés vs torrents bruts ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **series:** boutons saison Yu-Gi-Oh via fallback season_number ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+
+## [1.14.0](https://github.com/Masutayunikon/FanKarr/compare/v1.13.0...v1.14.0) (2026-03-21)
+
+
+### Features
+
+* **scraper:** extraction du nom bencode pour les torrents locaux ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+* **series-view:** badge "Hors Fankai" sur les épisodes de torrents manuels ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+* **series-view:** tooltip avec le nom du torrent sur les boutons intégrale ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+
+
+### Bug Fixes
+
+* **catalogue:** état "partiel" incorrect quand l'intégrale est organisée ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+* **series:** résolution boutons de téléchargement saisons Yu-Gi-Oh et séries similaires ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+
+## [1.13.0](https://github.com/Masutayunikon/FanKarr/compare/v1.12.2...v1.13.0) (2026-03-21)
+
+
+### Features
+
+* add favicon ([dc4a2d4](https://github.com/Masutayunikon/FanKarr/commit/dc4a2d48f5c0cddd8e431ce33a69fc9146143fb6))
+* add README.md ([4eb487a](https://github.com/Masutayunikon/FanKarr/commit/4eb487a96beed8c82cb19d9a9b63c3b69d841386))
+* add windows / linux / macos binaries on build ([f17a73b](https://github.com/Masutayunikon/FanKarr/commit/f17a73b9591fb49a75bd5fcdadf1970585877dab))
+* **auth:** génération automatique du JWT secret au démarrage ([eaa52e9](https://github.com/Masutayunikon/FanKarr/commit/eaa52e90900ff0e198beae190d7ad0298a702482))
+* cache images ([da460de](https://github.com/Masutayunikon/FanKarr/commit/da460de60c4eec6851ea58ce0ae646a1208f6018))
+* fix worker for multiple series in integral (one piece fix ?) ([2c773f8](https://github.com/Masutayunikon/FanKarr/commit/2c773f83ffd76d82c77a50a9c5729f20ea22b450))
+* initial project ([eaf01cf](https://github.com/Masutayunikon/FanKarr/commit/eaf01cfc591dd72f9b093b533ced6c12a6c490a1))
+* make the organizer threaded to not consumme api main thread ([14c0e56](https://github.com/Masutayunikon/FanKarr/commit/14c0e567525e179da82c6b58d9886cc3d544a98d))
+* now rename episodes with original_filename from api ([9bdb21a](https://github.com/Masutayunikon/FanKarr/commit/9bdb21a673ebb9871548aea6691bafbd049554ce))
+* **organize:** scan initial mediaPath + logs fichier centralisés ([807f786](https://github.com/Masutayunikon/FanKarr/commit/807f786b038579ca9d7cd136998f759cecae2255))
+* **organize:** worker thread + badges statut + notifications ([b7242bc](https://github.com/Masutayunikon/FanKarr/commit/b7242bc95f59d259ab1a636aa304bf149f895041))
+* **serie:** badges état organisation sur épisodes et saisons ([4d3a6bd](https://github.com/Masutayunikon/FanKarr/commit/4d3a6bd276907f793452429d62693fafc1d804db))
+* **ui:** états catalogue + logs + badges erreurs downloads ([5326828](https://github.com/Masutayunikon/FanKarr/commit/5326828d89aa10a53bbe1ac4016a5eee4d5dbc97))
+* UX improvements, folder picker, download state & NFO support ([20771fc](https://github.com/Masutayunikon/FanKarr/commit/20771fc31c187fd1fea8aa9b07093b15621a5b85))
+
+
+### Bug Fixes
+
+* add config.ts with config variable (BASE_DIR...) ([a3eb67c](https://github.com/Masutayunikon/FanKarr/commit/a3eb67c9a0944500142a6636d57cae0acfd7543d))
+* add log for debug ([6876c5e](https://github.com/Masutayunikon/FanKarr/commit/6876c5ee6c7734e664a6da4e4bc721cc7c5abdf7))
+* add log for debug ([d8cdeae](https://github.com/Masutayunikon/FanKarr/commit/d8cdeae675bc73b5842d18d01eff9d5bb0e0a7e8))
+* add target node ([58b09f2](https://github.com/Masutayunikon/FanKarr/commit/58b09f2267345c60ed589c160f7e47698e9be9a4))
+* add target node ([6c629e0](https://github.com/Masutayunikon/FanKarr/commit/6c629e0f6b4d38453cfb22fd315e02d9e8750c45))
+* add user permissions when the scripts is launched ([501bbfc](https://github.com/Masutayunikon/FanKarr/commit/501bbfcf18c236f7ac382c50d90482b1f51244c1))
+* CatalogView.vue badge deleted ([d897192](https://github.com/Masutayunikon/FanKarr/commit/d8971920462efd8d1d99eb867016c96713dfef58))
+* config path /config/config to /config ([7518191](https://github.com/Masutayunikon/FanKarr/commit/75181910244621a8eca989067fd4777922914d8e))
+* docker errors ([2702764](https://github.com/Masutayunikon/FanKarr/commit/27027642eb55b75adb04446a88e5007e88f75948))
+* docker is able to change directory ([af08f7d](https://github.com/Masutayunikon/FanKarr/commit/af08f7d9d4fb2e23c5feac6d33b2ef495f9d91b2))
+* empty docker-compose.yml ([303dfd8](https://github.com/Masutayunikon/FanKarr/commit/303dfd85b5d033e2b247fd064ae1ae612fdb49e1))
+* entrypoint.sh config directory ([7e4b2fa](https://github.com/Masutayunikon/FanKarr/commit/7e4b2fa60a5946d3220618f13420a07fa57e8e1b))
+* export _isBunBinary ([3d43de3](https://github.com/Masutayunikon/FanKarr/commit/3d43de3eb223ec0338e0b9aebffff35e116e00a0))
+* improve torrent organization and cleanup logic ([1908cb3](https://github.com/Masutayunikon/FanKarr/commit/1908cb3e8c5b99e91e26735f7cfa3dcd23709df7))
+* logger third args ([5abac1e](https://github.com/Masutayunikon/FanKarr/commit/5abac1e11236ed1e8f7f0de7f0cff881d1b60f10))
+* nfo settings and add json file when not existing ([0b6bfa6](https://github.com/Masutayunikon/FanKarr/commit/0b6bfa6a81d99353be877ed6d99687ad3d55adbc))
+* organize file ([d6550e9](https://github.com/Masutayunikon/FanKarr/commit/d6550e9961789073be1583e03d599afb6d295004))
+* organize use torrent hash and not name ([61901f9](https://github.com/Masutayunikon/FanKarr/commit/61901f9014a759e2950311cd96266ea8201fa902))
+* path ([7ddd9ca](https://github.com/Masutayunikon/FanKarr/commit/7ddd9cad9271d79a258f45245bf405f13b9d764f))
+* path ([0329ee2](https://github.com/Masutayunikon/FanKarr/commit/0329ee27a34038456eb297f07b808de3157d88f4))
+* path ([314f817](https://github.com/Masutayunikon/FanKarr/commit/314f817280f39d10eb21c4784f2aea41b9a6d32c))
+* port 9898, /config volume, Kaï→Kai matching, NFO pagination GitLab, saison 0 specials, JoJo/Hokuto strict season resolve ([3a278ba](https://github.com/Masutayunikon/FanKarr/commit/3a278ba33388d6ff6f33413d7696d58d0172c953))
+* remove user creation in entrypoint.sh ([92d9fa6](https://github.com/Masutayunikon/FanKarr/commit/92d9fa6b01f1e2de1ceb13528afd309b21f9d4cb))
+* rename if the torrent name is not the same as the api ([b8fcf71](https://github.com/Masutayunikon/FanKarr/commit/b8fcf71f54ab14e5572a7553d8554b617b4981b7))
+* season 0 not clonficting anymore ([635082d](https://github.com/Masutayunikon/FanKarr/commit/635082de00bb42bdeaf20b1654f742ad1c4addbe))
+* season 0 resolved is no longer skipped in the worker ([c48ec76](https://github.com/Masutayunikon/FanKarr/commit/c48ec769ba7725327e657366e882498846d0c63f))
+* season fallback ([e9b5091](https://github.com/Masutayunikon/FanKarr/commit/e9b5091242d73be77bf6fb525ce2865554e336cc))
+* skip excluded folders ([edf806d](https://github.com/Masutayunikon/FanKarr/commit/edf806d9bc48d4de1c3609a4b0405442305d546e))
+* title readme align ([8ba3b37](https://github.com/Masutayunikon/FanKarr/commit/8ba3b370d1e2cd1565f9c2453be8706e3c198243))
+* use bcryptjs for compilation ([6a6981e](https://github.com/Masutayunikon/FanKarr/commit/6a6981e10a3a9019f49982d7680e562872ee95a5))
+* use season number from resolved episodes in priority ([dc48634](https://github.com/Masutayunikon/FanKarr/commit/dc486347193a8066a32d8f0106518abc2b04b7e2))
+* worker now work on multiple github files pages ([71784cd](https://github.com/Masutayunikon/FanKarr/commit/71784cd8bd8f3ea5dc7423687b080c1588d70854))
+* worker outside the exe ([c2ab58e](https://github.com/Masutayunikon/FanKarr/commit/c2ab58e7b2c34aae09b50dbdfde3277da4c276ff))
+* worker outside the exe ([a47c3a4](https://github.com/Masutayunikon/FanKarr/commit/a47c3a43fb5dbbedd87c9ac2d584c3290fcc6097))
+* worker path ([3df8def](https://github.com/Masutayunikon/FanKarr/commit/3df8defa5e46b09722a345c7c3a94e91aa16e4d8))
+* worker path ([360572b](https://github.com/Masutayunikon/FanKarr/commit/360572b8be64dafbb452dfcb849a40305bf1b8cf))
+* workflow directory ([baebd8f](https://github.com/Masutayunikon/FanKarr/commit/baebd8fae146db70ee1cce0c876d2d3bc0f9bf4e))
+* workflow directory ([d8405c1](https://github.com/Masutayunikon/FanKarr/commit/d8405c1589f277cd8fdd3e1fd15cc02d98834aa6))
+* workflow permmisions ([3620bfb](https://github.com/Masutayunikon/FanKarr/commit/3620bfb71d8c2774b23c097e5e01326099c2f180))
+
+## [1.12.2](https://github.com/Masutayunikon/FanKarr/compare/v1.12.1...v1.12.2) (2026-03-21)
+
+
+### Bug Fixes
+
+* use season number from resolved episodes in priority ([dc48634](https://github.com/Masutayunikon/FanKarr/commit/dc486347193a8066a32d8f0106518abc2b04b7e2))
+
+## [1.12.1](https://github.com/Masutayunikon/FanKarr/compare/v1.12.0...v1.12.1) (2026-03-21)
+
+
+### Bug Fixes
+
+* path ([7ddd9ca](https://github.com/Masutayunikon/FanKarr/commit/7ddd9cad9271d79a258f45245bf405f13b9d764f))
+
+## [1.12.0](https://github.com/Masutayunikon/FanKarr/compare/v1.11.10...v1.12.0) (2026-03-21)
+
+
+### Features
+
+* now rename episodes with original_filename from api ([9bdb21a](https://github.com/Masutayunikon/FanKarr/commit/9bdb21a673ebb9871548aea6691bafbd049554ce))
+
+## [1.11.10](https://github.com/Masutayunikon/FanKarr/compare/v1.11.9...v1.11.10) (2026-03-21)
+
+
+### Bug Fixes
+
+* improve torrent organization and cleanup logic ([1908cb3](https://github.com/Masutayunikon/FanKarr/commit/1908cb3e8c5b99e91e26735f7cfa3dcd23709df7))
+* season 0 not clonficting anymore ([635082d](https://github.com/Masutayunikon/FanKarr/commit/635082de00bb42bdeaf20b1654f742ad1c4addbe))
+
+## [1.11.9](https://github.com/Masutayunikon/FanKarr/compare/v1.11.8...v1.11.9) (2026-03-20)
+
+
+### Bug Fixes
+
+* season 0 resolved is no longer skipped in the worker ([c48ec76](https://github.com/Masutayunikon/FanKarr/commit/c48ec769ba7725327e657366e882498846d0c63f))
+
+## [1.11.8](https://github.com/Masutayunikon/FanKarr/compare/v1.11.7...v1.11.8) (2026-03-20)
+
+
+### Bug Fixes
+
+* config path /config/config to /config ([7518191](https://github.com/Masutayunikon/FanKarr/commit/75181910244621a8eca989067fd4777922914d8e))
+
+## [1.11.7](https://github.com/Masutayunikon/FanKarr/compare/v1.11.6...v1.11.7) (2026-03-20)
+
+
+### Bug Fixes
+
+* worker path ([3df8def](https://github.com/Masutayunikon/FanKarr/commit/3df8defa5e46b09722a345c7c3a94e91aa16e4d8))
+
+## [1.11.6](https://github.com/Masutayunikon/FanKarr/compare/v1.11.5...v1.11.6) (2026-03-20)
+
+
+### Bug Fixes
+
+* path ([0329ee2](https://github.com/Masutayunikon/FanKarr/commit/0329ee27a34038456eb297f07b808de3157d88f4))
+
+## [1.11.5](https://github.com/Masutayunikon/FanKarr/compare/v1.11.4...v1.11.5) (2026-03-20)
+
+
+### Bug Fixes
+
+* export _isBunBinary ([3d43de3](https://github.com/Masutayunikon/FanKarr/commit/3d43de3eb223ec0338e0b9aebffff35e116e00a0))
+
+## [1.11.4](https://github.com/Masutayunikon/FanKarr/compare/v1.11.3...v1.11.4) (2026-03-20)
+
+
+### Bug Fixes
+
+* add config.ts with config variable (BASE_DIR...) ([a3eb67c](https://github.com/Masutayunikon/FanKarr/commit/a3eb67c9a0944500142a6636d57cae0acfd7543d))
+
+## [1.11.3](https://github.com/Masutayunikon/FanKarr/compare/v1.11.2...v1.11.3) (2026-03-20)
+
+
+### Bug Fixes
+
+* entrypoint.sh config directory ([7e4b2fa](https://github.com/Masutayunikon/FanKarr/commit/7e4b2fa60a5946d3220618f13420a07fa57e8e1b))
+
 ## [1.11.2](https://github.com/Masutayunikon/FanKarr/compare/v1.11.1...v1.11.2) (2026-03-20)


@@ -7,6 +7,6 @@ PGID=${PGID:-1000}
 echo "[fankarr] Running as UID=${PUID} GID=${PGID}"

 # Corriger les permissions du dossier data
-chown -R "$PUID:$PGID" /app/data
+chown -R "$PUID:$PGID" /config

 exec gosu "$PUID:$PGID" node dist/server/index.js
@@ -4,8 +4,9 @@ import bcrypt from 'bcryptjs'
 import jwt from 'jsonwebtoken'
 import type { Request, Response, NextFunction } from 'express'
 import { JWT_SECRET } from './secret.js'
+import { DATA_DIR } from './config.js'

-const DATA_PATH = path.join(process.cwd(), 'config', 'auth.json')
+const DATA_PATH = path.join(DATA_DIR, 'auth.json')
 const SALT_ROUNDS = 10

 interface AuthData {
@@ -0,0 +1,13 @@
+import fs from 'fs'
+import path from 'path'
+
+export const _isBunBinary = typeof (globalThis as any).Bun !== 'undefined'
+    && path.dirname((process as any).execPath) !== process.cwd()
+
+export const BASE_DIR = _isBunBinary
+    ? path.dirname((process as any).execPath)
+    : process.cwd()
+
+export const DATA_DIR = fs.existsSync('/.dockerenv')
+    ? '/config'
+    : path.join(BASE_DIR, 'config')
@@ -12,29 +12,15 @@ import {
 import qbittorrentDriver from './torrent-clients/qbittorrent.js'
 import { organizeTorrent, autoOrganizeAll, scanMediaPath } from './organize.js'
 import { logger, readLogs, clearLogs, logsFileSize } from './logger.js'
+import { DATA_DIR, BASE_DIR }  from './config.js'

 registerDriver(qbittorrentDriver)

-// ── Base directory ─────────────────────────────────────────────
-// Binaire Bun compilé : data/ et public/ sont à côté de l'exécutable
-// Docker / dev        : relatif au cwd (comportement inchangé)
-const _isBunBinary = typeof (globalThis as any).Bun !== 'undefined'
-    && path.dirname((process as any).execPath) !== process.cwd()
-export const BASE_DIR = _isBunBinary
-    ? path.dirname((process as any).execPath)
-    : process.cwd()
-
-// DATA_DIR : /config
-export const DATA_DIR = fs.existsSync('/.dockerenv')
-    ? '/config'
-    : path.join(BASE_DIR, 'config')
-
 const app = express()
 const PORT = Number(process.env.PORT) || 9898
-const FANKAI_API    = 'https://metadata.fankai.fr'
-const TORRENTS_PATH = path.join(DATA_DIR, 'torrent_final.json')
-const GITHUB_RAW_URL = process.env.GITHUB_RAW_URL
-    ?? 'https://raw.githubusercontent.com/masutayunikon/fankarr-scraper/main/data/torrent_final.json'
+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())
@@ -100,88 +86,270 @@ app.get('/api/torrent-clients/:uuid/healthcheck', requireAuth, async (req, res)
    res.json(await driver.healthcheck(client.config))
 })

-// ── Helpers ────────────────────────────────────────────────────
-function readTorrents(): any[] {
+// ── Cache GitHub ───────────────────────────────────────────────
+
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000  // 6 heures
+
+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 key = urlPath
+    const cached = cacheGet(key)
+    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(key, data)
+    return data
+}
+
+async function readAvailable(): Promise<number[]> {
    try {
-        if (!fs.existsSync(TORRENTS_PATH)) return []
-        return JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8'))
+        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 }
+}
+
+// Extrait tous les torrents d'un series/{id}.json avec leur type et niveau hiérarchique
+// Retourne une liste plate compatible avec l'ancienne interface { infohash, torrent_url, magnet, raw, type, ... }
+function extractTorrentsFromSerieData(sd: any): any[] {
+    const result: any[] = []
+    if (!sd) return result
+
+    // Torrents au niveau série → pack_integrale (ou pack_saison si une seule saison)
+    for (const t of sd.torrents ?? []) {
+        result.push({
+            ...t,
+            raw       : t.title,
+            type      : 'pack_integrale',
+            serie_id  : sd.id,
+            serie_title: sd.title,
+            // episodes couverts : tous les épisodes de toutes les saisons qui ont paths[i]
+            _serieLevel: true,
+            _serieData : sd,
+            _torrentIdx: (sd.torrents ?? []).indexOf(t),
+        })
+    }
+
+    // Torrents au niveau saison → pack_saison
+    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),
+            })
+        }
+
+        // Torrents au niveau épisode → episode
+        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
+}
+
+// Construit resolved_episodes pour un torrent à partir des paths[torrentIdx]
+// paths[i] = chemin du fichier dans le torrent i → on extrait le filename
+function buildResolvedEpisodes(sd: any, torrentIdx: number, seasonFilter?: number): any[] {
+    const resolved: any[] = []
+    for (const season of sd.seasons ?? []) {
+        if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
+        for (const ep of season.episodes ?? []) {
+            const filePath = (ep.paths ?? [])[torrentIdx]
+            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, // sera enrichi depuis l'API si besoin
+            })
+        }
+    }
+    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 normalizeTitle(s: string): string {
    return s.toLowerCase()
        .normalize('NFD')
-        .replace(/[\u0300-\u036f]/g, '')  // strip accents (ï→i, é→e...)
+        .replace(/[\u0300-\u036f]/g, '')
        .replace(/[^a-z0-9]/g, ' ')
        .replace(/\s+/g, ' ')
        .trim()
 }

-function indexBySerie(torrents: any[]): Map<number, any[]> {
-    const map = new Map<number, any[]>()
-    for (const t of torrents) {
-        if (!t.serie_id) continue
-        if (!map.has(t.serie_id)) map.set(t.serie_id, [])
-        map.get(t.serie_id)!.push(t)
-    }
-    return map
+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 indexByNormalizedTitle(torrents: any[]): Map<string, any[]> {
-    const map = new Map<string, any[]>()
-    for (const t of torrents) {
-        const title = t.serie_title || t.show_title
-        if (!title) continue
-        const key = normalizeTitle(title)
-        if (!map.has(key)) map.set(key, [])
-        map.get(key)!.push(t)
+function normalizeSerie(serie: any): any {
+    const poster = serie.poster_image ?? serie.images?.poster ?? null
+    const fanart = serie.fanart_image ?? serie.images?.fanart  ?? null
+    return {
+        ...serie,
+        poster_image: imgProxy(poster, 300),
+        fanart_image: imgProxy(fanart, 1280, 60),
    }
-    return map
 }

-// ── Series ─────────────────────────────────────────────────────
+function normalizeSeason(season: any): any {
+    const poster = season.poster_image ?? season.images?.poster ?? null
+    return {
+        ...season,
+        poster_image: imgProxy(poster, 300),
+    }
+}
+
+function normalizeEpisode(ep: any): any {
+    const thumb = ep.thumb_image ?? ep.thumbnail ?? null
+    return {
+        ...ep,
+        thumb_image: imgProxy(thumb, 400),
+    }
+}
+
+// ── Enrichissement seriesData avec original_filename depuis l'API ──────────────
+// Fetche /seasons/{id}/episodes pour chaque saison et injecte original_filename
+// dans chaque épisode du serieData, indexé par episode_id
+async function enrichSeriesDataWithOriginalFilenames(seriesData: any[]): Promise<any[]> {
+    return Promise.all(seriesData.map(async (sd) => {
+        if (!sd) return sd
+        const enrichedSeasons = await Promise.all((sd.seasons ?? []).map(async (season: any) => {
+            let epsData: any[] = []
+            try {
+                const res = await fankaiGet(`/seasons/${season.id}/episodes`)
+                epsData = Array.isArray(res) ? res : (res.episodes ?? [])
+            } catch { return season }
+
+            // Index episode_id → original_filename
+            const origMap = new Map<number, string>()
+            for (const ep of epsData) {
+                if (ep.id && ep.original_filename) origMap.set(ep.id, ep.original_filename)
+            }
+
+            // Injecter dans les épisodes du serieData
+            const enrichedEpisodes = (season.episodes ?? []).map((ep: any) => ({
+                ...ep,
+                original_filename: origMap.get(ep.id) ?? null,
+            }))
+
+            return { ...season, episodes: enrichedEpisodes }
+        }))
+        return { ...sd, seasons: enrichedSeasons }
+    }))
+}
+
+// Helper réutilisable : charge + enrichit toutes les seriesData du cache
+async function loadEnrichedSeriesData(): Promise<any[]> {
+    const ids   = await readAvailable()
+    const allSd = await Promise.all(ids.map(id => readSerieData(id)))
+    const valid = allSd.filter(Boolean)
+    return enrichSeriesDataWithOriginalFilenames(valid)
+}

 function computeSerieDownloadState(
-    serieTorrents : any[],
+    serieData     : any | null,
    organized     : Record<string, Record<string, string>>,
-    activeTorrents: Set<string>  // hashes actuellement dans qB en downloading
+    activeTorrents: Set<string>
 ): 'none' | 'downloading' | 'partial' | 'complete' {
-    if (serieTorrents.length === 0) return 'none'
+    if (!serieData) return 'none'

-    // Un torrent de la série est en cours de téléchargement ?
-    const hasActive = serieTorrents.some(t => activeTorrents.has(t.infohash?.toLowerCase()))
+    const allTorrents = extractTorrentsFromSerieData(serieData)
+    if (allTorrents.length === 0) return 'none'
+
+    const hasActive = allTorrents.some(t => t.infohash && activeTorrents.has(t.infohash.toLowerCase()))
    if (hasActive) return 'downloading'

-    // Compter les fichiers attendus vs organisés
-    let totalFiles = 0
-    let doneFiles  = 0
-    for (const t of serieTorrents) {
-        const files: any[] = t.torrent_files ?? []
-        if (files.length === 0) {
-            // Fichier unique
-            totalFiles++
-            if (organized[t.infohash?.toLowerCase()]?.[t.raw]) doneFiles++
-        } else {
-            totalFiles += files.length
-            doneFiles  += files.filter((f: any) => organized[t.infohash?.toLowerCase()]?.[f.filename]).length
+    // Collecter tous les episode_id de la série et ceux organisés
+    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)
+            }
        }
    }

-    if (totalFiles === 0) return 'none'
-    if (doneFiles === 0)  return 'none'
-    if (doneFiles >= totalFiles) return 'complete'
+    // Vérifier via organized.json : si le filename du path est organisé
+    for (const t of allTorrents) {
+        const hash = t.infohash?.toLowerCase()
+        if (!hash) continue
+        const orgFiles = organized[hash] ?? {}
+        if (Object.keys(orgFiles).length === 0) continue
+        const resolved = buildResolvedEpisodes(serieData, t._torrentIdx, t.season_number)
+        for (const ep of resolved) {
+            if (orgFiles[ep.filename]) organizedEpisodeIds.add(ep.episode_id)
+        }
+    }
+
+    if (allEpisodeIds.size === 0) return 'none'
+    if (organizedEpisodeIds.size === 0) return 'none'
+    if (organizedEpisodeIds.size >= allEpisodeIds.size) return 'complete'
    return 'partial'
 }

 app.get('/api/series', requireAuth, async (_req, res) => {
    try {
-        const [apiData, torrents] = await Promise.all([fankaiGet('/series'), Promise.resolve(readTorrents())])
-        const byId        = indexBySerie(torrents)
-        const byNormTitle = indexByNormalizedTitle(torrents)
+        const [apiData, availableIds] = await Promise.all([
+            fankaiGet('/series'),
+            readAvailable(),
+        ])
+        const availableSet = new Set<number>(availableIds)

        // Charger organized.json
        let organized: Record<string, Record<string, string>> = {}
@@ -197,40 +365,31 @@ app.get('/api/series', requireAuth, async (_req, res) => {
            const { category } = readSettings()
            const active = await dispatchList(category ?? 'fankai')
            for (const t of active) {
-                if (t.state === 'downloading' && t.hash)
-                    activeTorrents.add(t.hash.toLowerCase())
+                if (t.hash) activeTorrents.add(t.hash.toLowerCase())
            }
        } catch {}

-        const seriesRaw = Array.isArray(apiData) ? apiData : (apiData.series ?? [])
+        const seriesRaw = (Array.isArray(apiData) ? apiData : (apiData.series ?? [])).map(normalizeSerie)

-        // Dédupliquer les séries Kaï/Kai — garder celle qui a des torrents, sinon la plus récente (ID le plus grand)
-        const seenTitles = new Map<string, any>()
-        for (const serie of seriesRaw) {
-            const key = normalizeTitle(serie.title ?? serie.show_title ?? '')
-            if (!seenTitles.has(key)) {
-                seenTitles.set(key, serie)
-            } else {
-                const existing = seenTitles.get(key)!
-                const existingHasTorrents = (byId.get(existing.id) ?? byNormTitle.get(key) ?? []).length > 0
-                const newHasTorrents      = (byId.get(serie.id)    ?? byNormTitle.get(key) ?? []).length > 0
-                // Préférer celle qui a des torrents, sinon la plus récente
-                if (!existingHasTorrents && newHasTorrents) seenTitles.set(key, serie)
-                else if (existingHasTorrents === newHasTorrents && serie.id > existing.id) seenTitles.set(key, serie)
-            }
-        }
-        const seriesList = [...seenTitles.values()]
+        // Charger les series data en parallèle uniquement pour celles qui ont des torrents
+        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: seriesList.map((serie: any) => {
-                // Fallback par titre normalisé si l'ID ne matche pas (Kaï→Kai migration)
-                const serieTorrents = byId.get(serie.id)
-                    ?? byNormTitle.get(normalizeTitle(serie.title ?? serie.show_title ?? ''))
-                    ?? []
+        res.json({ series: seriesRaw.map((serie: any) => {
+                const hasTorrents = availableSet.has(serie.id)
+                const serieData   = serieDataMap.get(serie.id) ?? null
                return {
                    ...serie,
-                    torrent_count : serieTorrents.length,
-                    has_torrents  : serieTorrents.length > 0,
-                    download_state: computeSerieDownloadState(serieTorrents, organized, activeTorrents),
+                    torrent_count : serieData ? extractTorrentsFromSerieData(serieData).length : 0,
+                    has_torrents  : hasTorrents,
+                    download_state: computeSerieDownloadState(serieData, organized, activeTorrents),
                }
            })})
    } catch (err) {
@@ -241,90 +400,22 @@ app.get('/api/series', requireAuth, async (_req, res) => {
 app.get('/api/series/:id', requireAuth, async (req, res) => {
    const id = Number(req.params.id)
    try {
-        const [serie, seasonsData] = await Promise.all([fankaiGet(`/series/${id}`), fankaiGet(`/series/${id}/seasons`)])
+        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 ?? [])
+
+        // Fetch épisodes depuis l'API Fankai (avec original_filename, thumb_image, etc.)
        const seasonsWithEpisodes = await Promise.all(seasons.map(async (season: any) => {
-            const epsData = await fankaiGet(`/seasons/${season.id}/episodes`)
-            return { ...season, episodes: Array.isArray(epsData) ? epsData : (epsData.episodes ?? []) }
+            const epsData  = await fankaiGet(`/seasons/${season.id}/episodes`)
+            const episodes = (Array.isArray(epsData) ? epsData : (epsData.episodes ?? [])).map(normalizeEpisode)
+            return { ...normalizeSeason(season), episodes }
        }))

-        const allTorrents  = readTorrents()
-        const serieMeta    = allTorrents.find(t => t.serie_id === id)
-        const normApiTitle = normalizeTitle(serie.title ?? serie.show_title ?? '')
-        const torrents     = allTorrents.filter(t =>
-            t.serie_id === id ||
-            normalizeTitle(t.serie_title ?? t.show_title ?? '') === normApiTitle
-        )
-        const allSeasonIds = new Set<number>(seasonsWithEpisodes.filter((s: any) => s.season_number !== 0).map((s: any) => s.id))
-        const availableEpisodeIds  = new Set<number>()
-        // Fallback par season_number+episode_number pour les séries migrées Kaï→Kai
-        const availableBySnEn      = new Set<string>()  // "sn:en"
-        const episodeTorrentMap: Record<number, any> = {}
-        const episodeTorrentMapBySnEn: Record<string, any> = {}
-        const seasonTorrentMap : Record<number, any> = {}
-        const integraleTorrents: any[] = []
-        const packEpisodesTorrents: any[] = []
-
-        for (const t of torrents) {
-            const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: t.type, raw: t.raw }
-            for (const ep of t.resolved_episodes ?? []) {
-                availableEpisodeIds.add(ep.episode_id)
-                const snEnKey = `${ep.season_number}:${ep.episode_number}`
-                availableBySnEn.add(snEnKey)
-                if (t.type === 'episode') {
-                    episodeTorrentMap[ep.episode_id] = ref
-                    episodeTorrentMapBySnEn[snEnKey] = ref
-                }
-            }
-            if (t.type === 'pack_saison') {
-                const rs: any[] = t.resolved_seasons ?? []
-                if (rs.length > 1) {
-                    packEpisodesTorrents.push(t)
-                } else {
-                    const sids = rs.length > 0 ? rs.map((r: any) => r.season_id) : [t.season_id]
-                    for (const sid of sids) { if (sid) seasonTorrentMap[sid] = ref }
-                }
-            } else if (t.type === 'pack_integrale') {
-                integraleTorrents.push(t)
-            } else if (t.type === 'pack_episodes') {
-                packEpisodesTorrents.push(t)
-            }
-        }
-
-        let promotedIntegrale: any = null
-        if (integraleTorrents.length === 0 && allSeasonIds.size > 0) {
-            for (const t of torrents.filter(t => t.type === 'pack_saison')) {
-                const rs: any[] = t.resolved_seasons ?? []
-                const tIds = new Set<number>(rs.length > 0 ? rs.map((r: any) => r.season_id) : t.season_id ? [t.season_id] : [])
-                if ([...allSeasonIds].every(sid => tIds.has(sid))) { promotedIntegrale = t; break }
-            }
-        }
-
-        if (integraleTorrents.length > 0 || promotedIntegrale) {
-            for (const key of Object.keys(seasonTorrentMap)) delete seasonTorrentMap[Number(key)]
-            if (promotedIntegrale) {
-                const idx = packEpisodesTorrents.indexOf(promotedIntegrale)
-                if (idx !== -1) packEpisodesTorrents.splice(idx, 1)
-            }
-        }
-
-        function packEpisodesLabel(t: any): string {
-            const eps: any[] = t.resolved_episodes ?? []
-            if (!eps.length) return t.raw
-            const bySeason = new Map<number, number[]>()
-            for (const ep of eps) {
-                const sn = ep.season_number ?? 0
-                if (!bySeason.has(sn)) bySeason.set(sn, [])
-                bySeason.get(sn)!.push(ep.episode_number)
-            }
-            return [...bySeason.entries()].sort(([a], [b]) => a - b).map(([sn, nums]) => {
-                const s = nums.sort((a, b) => a - b)
-                const label = sn === 0 ? 'S0' : `S${sn}`
-                return s[0] === s[s.length-1] ? `${label} Ep ${s[0]}` : `${label} Eps ${s[0]}-${s[s.length-1]}`
-            }).join(' · ')
-        }
-
-        // Charger organized.json pour les badges d'état
+        // Charger organized.json
        let organized: Record<string, Record<string, string>> = {}
        try {
            const orgPath = path.join(DATA_DIR, 'organized.json')
@@ -332,58 +423,104 @@ app.get('/api/series/:id', requireAuth, async (req, res) => {
                organized = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
        } catch {}

-        // Construire un set des episode_id organisés
-        // On croise resolved_episodes de chaque torrent avec organized.json
-        const organizedEpisodeIds = new Set<number>()
-        const organizedBySnEn     = new Set<string>()
-        for (const t of torrents) {
-            const hash  = t.infohash?.toLowerCase()
-            const files = t.torrent_files ?? []
-            const orgFiles = organized[hash] ?? {}
-            if (Object.keys(orgFiles).length === 0) continue
-            // Au moins un fichier organisé pour ce torrent → on marque les épisodes résolus
-            for (const ep of t.resolved_episodes ?? []) {
-                // Vérifier si le fichier de cet épisode est organisé
-                const epFile = files.find((f: any) =>
-                    f.episode_ids?.includes(ep.episode_id) || f.episode_number === ep.episode_number
-                )
-                if (epFile ? orgFiles[epFile.filename] : Object.keys(orgFiles).length > 0) {
-                    organizedEpisodeIds.add(ep.episode_id)
-                    organizedBySnEn.add(`${ep.season_number}:${ep.episode_number}`)
+        // ── Construire les maps torrent depuis series/{id}.json ───────────
+        const availableEpisodeIds   = new Set<number>()
+        const episodeTorrentMap     : Record<number, any> = {}  // episode_id → ref
+        const seasonTorrentMapBySn  : Record<number, any> = {}  // season_number → ref
+        const integraleTorrents     : any[] = []
+        const packEpisodesTorrents  : any[] = []
+        const organizedEpisodeIds   = new Set<number>()
+
+        if (serieData) {
+            // ── Torrents niveau série (pack_integrale) ──────────────────
+            for (const [i, t] of (serieData.torrents ?? []).entries()) {
+                const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'pack_integrale', raw: t.title, manual: t.manual ?? false }
+                integraleTorrents.push({ ...t, raw: t.title, _torrentIdx: i })
+
+                // Marquer les épisodes disponibles via paths[i]
+                const resolved = buildResolvedEpisodes(serieData, i)
+                for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
+
+                // Vérifier organisés
+                const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                for (const ep of resolved) {
+                    if (orgFiles[ep.filename]) organizedEpisodeIds.add(ep.episode_id)
                }
            }
+
+            // ── Torrents niveau saison (pack_saison) ────────────────────
+            for (const season of serieData.seasons ?? []) {
+                for (const [i, t] of (season.torrents ?? []).entries()) {
+                    const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'pack_saison', raw: t.title, manual: t.manual ?? false }
+                    seasonTorrentMapBySn[season.season_number] = ref
+
+                    const resolved = buildResolvedEpisodes(serieData, i, season.season_number)
+                    for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
+
+                    const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                    for (const ep of resolved) {
+                        if (orgFiles[ep.filename]) organizedEpisodeIds.add(ep.episode_id)
+                    }
+                }
+
+                // ── Torrents niveau épisode ─────────────────────────────
+                for (const ep of season.episodes ?? []) {
+                    for (const [i, t] of (ep.torrents ?? []).entries()) {
+                        const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'episode', raw: t.title, manual: t.manual ?? false }
+                        episodeTorrentMap[ep.id] = ref
+                        availableEpisodeIds.add(ep.id)
+
+                        const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                        const filename = (ep.paths ?? [])[i]?.split('/').pop()
+                        if (filename && orgFiles[filename]) organizedEpisodeIds.add(ep.id)
+                    }
+                }
+            }
+
+            // Pack_saison multi-saisons → packEpisodesTorrents si couvre plusieurs saisons
+            // (cas où un seul torrent couvre plusieurs saisons mais pas toutes → affiché en hero)
+            // Pour l'instant on le traite comme pack_integrale si au niveau série
        }

+        // ── Promotion intégrale ───────────────────────────────────────────
+        // Si pas de pack_integrale explicite mais un pack_saison couvre toutes les saisons
+        // → déjà géré car on met les torrents série en integraleTorrents directement
+
+        // ── Enrichissement des saisons API ───────────────────────────────
        const enrichedSeasons = seasonsWithEpisodes.map((season: any) => {
-            const eps = season.episodes.map((ep: any) => ({
-                ...ep,
-                available : availableEpisodeIds.has(ep.id)
-                    || availableBySnEn.has(`${season.season_number}:${ep.episode_number}`),
-                torrent   : episodeTorrentMap[ep.id]
-                    ?? episodeTorrentMapBySnEn[`${season.season_number}:${ep.episode_number}`]
-                    ?? null,
-                organized : organizedEpisodeIds.has(ep.id)
-                    || organizedBySnEn.has(`${season.season_number}:${ep.episode_number}`),
-            }))
-            // State saison : none / partial / complete
+            const eps = season.episodes.map((ep: any) => {
+                // Chercher le torrent : niveau épisode d'abord, sinon le torrent de saison/intégrale sert juste de disponibilité
+                const epTorrent = episodeTorrentMap[ep.id] ?? null
+                // original_filename vient de l'API Fankai directement
+                return {
+                    ...ep,
+                    available : availableEpisodeIds.has(ep.id),
+                    torrent   : epTorrent,
+                    organized : organizedEpisodeIds.has(ep.id),
+                }
+            })
            const total    = eps.filter((e: any) => e.available).length
            const orgCount = eps.filter((e: any) => e.organized).length
            const seasonOrganizedState =
-                orgCount === 0              ? 'none'     :
-                    orgCount >= total && total > 0 ? 'complete' : 'partial'
+                orgCount === 0                     ? 'none'     :
+                    orgCount >= total && total > 0     ? 'complete' : 'partial'
            return {
                ...season,
-                torrent              : seasonTorrentMap[season.id] ?? null,
-                organized_state      : seasonOrganizedState,
-                organized_count      : orgCount,
-                episodes             : eps,
+                torrent         : seasonTorrentMapBySn[season.season_number] ?? null,
+                organized_state : seasonOrganizedState,
+                organized_count : orgCount,
+                episodes        : eps,
            }
        })

+        // ── Hero bundles ──────────────────────────────────────────────────
+        function packEpisodesLabel(t: any): string {
+            return t.raw ?? t.title ?? 'Pack'
+        }
+
        const heroBundles: any[] = [
-            ...integraleTorrents.map(t => ({ label: 'Intégrale', torrent_url: t.torrent_url, magnet: t.magnet, raw: t.raw })),
-            ...(promotedIntegrale ? [{ label: 'Intégrale', torrent_url: promotedIntegrale.torrent_url, magnet: promotedIntegrale.magnet, raw: promotedIntegrale.raw }] : []),
-            ...packEpisodesTorrents.map(t => ({ label: packEpisodesLabel(t), torrent_url: t.torrent_url, magnet: t.magnet, raw: t.raw }))
+            ...integraleTorrents.map(t => ({ label: 'Intégrale', torrent_url: t.torrent_url, magnet: t.magnet, raw: t.title ?? t.raw })),
+            ...packEpisodesTorrents.map(t => ({ label: packEpisodesLabel(t), torrent_url: t.torrent_url, magnet: t.magnet, raw: t.title ?? t.raw }))
        ]

        res.json({ serie, seasons: enrichedSeasons, torrents_integrale: heroBundles })
@@ -406,7 +543,6 @@ app.get('/api/downloads', requireAuth, async (_req, res) => {
        const { category } = readSettings()
        const torrents = await dispatchList(category ?? 'fankai')

-        // Enrichir avec l'état d'organisation
        let organized: Record<string, Record<string, string>> = {}
        try {
            const orgPath = path.join(DATA_DIR, 'organized.json')
@@ -414,30 +550,34 @@ app.get('/api/downloads', requireAuth, async (_req, res) => {
                organized = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
        } catch {}

-        let torrentFinal: any[] = []
-        try {
-            const tfPath = path.join(process.cwd(), 'config', 'torrent_final.json')
-            if (fs.existsSync(tfPath))
-                torrentFinal = JSON.parse(fs.readFileSync(tfPath, 'utf-8'))
-        } catch {}
-
-        const enriched = torrents.map((t: any) => {
+        const enriched = await Promise.all(torrents.map(async (t: any) => {
            const orgFiles  = organized[t.hash] ?? {}
-            const meta      = torrentFinal.find((m: any) =>
-                m.infohash?.toLowerCase() === t.hash?.toLowerCase()
-            )
-            const totalFiles = (meta?.torrent_files?.length ?? 0) || 1
+            // Chercher les métadonnées via le cache GitHub
+            let totalFiles = 1
+            try {
+                const availableIds = await readAvailable()
+                for (const id of availableIds) {
+                    const sd = await readSerieData(id)
+                    if (!sd) continue
+                    const allT = extractTorrentsFromSerieData(sd)
+                    const match = allT.find((st: any) => st.infohash?.toLowerCase() === t.hash?.toLowerCase())
+                    if (match) {
+                        const resolved = buildResolvedEpisodes(sd, match._torrentIdx, match.season_number)
+                        totalFiles = resolved.length || 1
+                        break
+                    }
+                }
+            } catch {}
            const doneFiles  = Object.keys(orgFiles).length
            let organizeState: 'none' | 'partial' | 'done' = 'none'
            if (doneFiles >= totalFiles) organizeState = 'done'
            else if (doneFiles > 0)      organizeState = 'partial'

-            // Récupérer les erreurs depuis recentOrganized
            const notif = recentOrganized.find(n => n.hash === t.hash)
            const errorFiles = notif?.errorFiles ?? []

            return { ...t, organizeState, organizeProgress: { done: doneFiles, total: totalFiles }, errorFiles }
-        })
+        }))

        res.json(enriched)
    } catch (err) {
@@ -445,7 +585,7 @@ app.get('/api/downloads', requireAuth, async (_req, res) => {
    }
 })

-// ── Résultats d'organisation récents (pour notifications frontend) ──
+// ── Résultats d'organisation récents ──────────────────────────
 interface OrganizeNotif {
    hash       : string
    name       : string
@@ -467,13 +607,11 @@ app.get('/api/organize/recent', requireAuth, (_req, res) => {
    res.json(recentOrganized)
 })

-// Vider les notifs lues
 app.post('/api/organize/recent/clear', requireAuth, (_req, res) => {
    recentOrganized.length = 0
    res.json({ ok: true })
 })

-
 app.post('/api/organize', requireAuth, async (req, res) => {
    const { hash, name, save_path } = req.body
    if (!hash || !name || !save_path) {
@@ -481,14 +619,14 @@ app.post('/api/organize', requireAuth, async (req, res) => {
        return
    }
    try {
-        const result = await organizeTorrent(hash, name, save_path)
+        const seriesData = await loadEnrichedSeriesData()
+        const result     = await organizeTorrent(hash, name, save_path, seriesData)
        res.json(result)
    } catch (err) {
        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
    }
 })

-// ── Torrents status ────────────────────────────────────────────
 // ── Logs ──────────────────────────────────────────────────────
 app.get('/api/logs', requireAuth, (req, res) => {
    const limit  = Number(req.query.limit)  || 100
@@ -526,27 +664,21 @@ app.get('/api/browse', requireAuth, (req, res) => {
    }
 })

-app.get('/api/torrents/status', requireAuth, (_req, res) => {
+app.get('/api/torrents/status', requireAuth, async (_req, res) => {
    try {
-        if (!fs.existsSync(TORRENTS_PATH)) { res.json({ exists: false, count: 0, empty: true }); return }
-        const raw = fs.readFileSync(TORRENTS_PATH, 'utf-8').trim()
-        if (!raw || raw === '[]') { res.json({ exists: true, count: 0, empty: true }); return }
-        const data = JSON.parse(raw)
-        const count = Array.isArray(data) ? data.length : 0
-        res.json({ exists: true, count, empty: count === 0 })
+        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 }) }
 })

-// ── Update torrent_final.json ──────────────────────────────────
+// ── Update : vide le cache pour forcer le rechargement depuis GitHub ──────────
 app.post('/api/update', requireAuth, async (_req, res) => {
    try {
-        const response = await fetch(GITHUB_RAW_URL)
-        if (!response.ok) throw new Error(`GitHub a répondu ${response.status}`)
-        const data = await response.json() as unknown[]
-        if (!Array.isArray(data)) throw new Error('Format invalide')
-        fs.mkdirSync(path.dirname(TORRENTS_PATH), { recursive: true })
-        fs.writeFileSync(TORRENTS_PATH, JSON.stringify(data, null, 2), 'utf-8')
-        res.json({ ok: true, count: data.length })
+        cacheClear()
+        // Pré-charger available.json pour vérifier que GitHub répond
+        const availableIds = await readAvailable()
+        if (!Array.isArray(availableIds)) throw new Error('available.json invalide')
+        res.json({ ok: true, count: availableIds.length })
    } catch (err) {
        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
    }
@@ -556,7 +688,8 @@ app.post('/api/scan', requireAuth, async (_req, res) => {
    try {
        const { mediaPath } = readSettings()
        const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
-        const result = await scanMediaPath(mediaPath, TORRENTS_PATH, ORGANIZED_PATH)
+        const seriesData = await loadEnrichedSeriesData()
+        const result = await scanMediaPath(mediaPath, ORGANIZED_PATH, seriesData)
        logger.info('api', `Scan manuel: ${result.found} fichiers scannés, ${result.added} ajoutés`)
        res.json({ ok: true, ...result })
    } catch (err) {
@@ -564,7 +697,7 @@ app.post('/api/scan', requireAuth, async (_req, res) => {
    }
 })

-// ── SPA fallback (prod) — doit être après toutes les routes API ─
+// ── SPA fallback (prod) ────────────────────────────────────────
 if (fs.existsSync(PUBLIC_PATH)) {
    app.get('*path', (_req, res) => {
        res.sendFile(path.join(PUBLIC_PATH, 'index.html'))
@@ -573,43 +706,35 @@ if (fs.existsSync(PUBLIC_PATH)) {

 // ── Start ──────────────────────────────────────────────────────
 app.listen(PORT, async () => {
-    // Télécharger torrent_final.json si absent
-    if (!fs.existsSync(TORRENTS_PATH)) {
-        try {
-            console.log('[fankarr] torrent_final.json absent → téléchargement...')
-            const response = await fetch(GITHUB_RAW_URL)
-            if (!response.ok) throw new Error(`GitHub a répondu ${response.status}`)
-            const data = await response.json() as unknown[]
-            if (!Array.isArray(data)) throw new Error('Format invalide')
-            fs.mkdirSync(path.dirname(TORRENTS_PATH), { recursive: true })
-            fs.writeFileSync(TORRENTS_PATH, JSON.stringify(data, null, 2), 'utf-8')
-            console.log(`[fankarr] ${data.length} torrents téléchargés`)
-        } catch (err) {
-            console.warn(`[fankarr] ⚠ Téléchargement échoué: ${err instanceof Error ? err.message : err}`)
-        }
+    console.log(`[fankarr] Serveur sur http://localhost:${PORT}`)
+    console.log(`[fankarr] Cache GitHub TTL: 6h — premier fetch au démarrage...`)
+
+    // Pré-chauffer le cache available.json au démarrage
+    try {
+        const available = await readAvailable()
+        console.log(`[fankarr] ${available.length} séries disponibles (via GitHub)`)
+    } catch (err) {
+        console.warn(`[fankarr] ⚠ Impossible de charger available.json: ${err instanceof Error ? err.message : err}`)
    }

-    try {
-        const data  = JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8'))
-        const count = Array.isArray(data) ? data.length : 0
-        if (count === 0) console.warn('[fankarr] ⚠ torrent_final.json est vide')
-        else console.log(`[fankarr] ${count} torrents chargés`)
-    } catch { console.warn('[fankarr] ⚠ torrent_final.json introuvable ou illisible') }
-    console.log(`[fankarr] Serveur sur http://localhost:${PORT}`)
-
-    // Scan initial du mediaPath pour reconnaître les fichiers déjà présents
+    // Scan initial du mediaPath
    const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
    const { mediaPath } = readSettings()
-    scanMediaPath(mediaPath, TORRENTS_PATH, ORGANIZED_PATH).catch(err =>
+    loadEnrichedSeriesData().then(seriesData =>
+        scanMediaPath(mediaPath, ORGANIZED_PATH, seriesData)
+    ).catch(err =>
        logger.error('organize', `scanMediaPath échoué: ${err}`)
    )

-    // Auto-organise toutes les 30s
+    // Auto-organise — polling différentiel toutes les 5 minutes
+    // Le worker ne se lance que si un torrent vient de passer en seeding
    const autoOrganize = async () => {
        try {
            const { category } = readSettings()
+            const seriesData   = await loadEnrichedSeriesData()
            await autoOrganizeAll(
                () => dispatchList(category ?? 'fankai'),
+                seriesData,
                (result) => {
                    if (result.done > 0 || result.errors > 0) {
                        pushNotif({ ...result, at: new Date().toISOString() })
@@ -620,9 +745,9 @@ app.listen(PORT, async () => {
            console.error('[organize] Erreur auto-organise:', err)
        }
    }
-    // Premier run 30s après démarrage, puis toutes les 30s
+    // Premier run 10s après démarrage, puis toutes les 5 minutes
    setTimeout(() => {
        autoOrganize()
-        setInterval(autoOrganize, 30_000)
-    }, 30_000)
+        setInterval(autoOrganize, 5 * 60_000)
+    }, 10_000)
 })
@@ -8,6 +8,7 @@

 import fs   from 'fs'
 import path from 'path'
+import { DATA_DIR } from './config.js'

 export type LogLevel = 'debug' | 'info' | 'warn' | 'error'

@@ -19,7 +20,7 @@ export interface LogEntry {
    meta?   : Record<string, any>
 }

-const LOGS_PATH    = path.join(process.cwd(), 'config', 'logs.jsonl')
+const LOGS_PATH    = path.join(DATA_DIR, 'logs.jsonl')
 const MAX_LINES    = 2000   // rotation auto au-delà
 const IS_PROD      = process.env.NODE_ENV === 'production'

@@ -4,8 +4,8 @@
 * Worker thread dédié à l'organisation des fichiers.
 * Tourne dans un thread séparé pour ne pas bloquer le event loop Express.
 *
- * Messages reçus  (parentPort.on) : { type: 'run', torrents: TorrentInfo[] }
- * Messages envoyés (parentPort.postMessage) :
+ * Messages reçus  : { type: 'run', torrents: TorrentInfo[], seriesData: SerieData[] }
+ * Messages envoyés :
 *   { type: 'log',    level: 'info'|'warn'|'error', msg: string }
 *   { type: 'result', hash: string, name: string, done, skipped, errors }
 *   { type: 'done' }
@@ -15,38 +15,26 @@ import fs   from 'fs'
 import fsp  from 'fs/promises'
 import path from 'path'
 import { parentPort } from 'worker_threads'
+import { DATA_DIR } from './config.js'

-// Base directory : binaire Bun ou cwd (Docker/dev)
-const _isBunBinary = typeof (globalThis as any).Bun !== 'undefined'
-    && path.dirname((process as any).execPath) !== process.cwd()
-const BASE_DIR = _isBunBinary
-    ? path.dirname((process as any).execPath)
-    : process.cwd()
-
-const TORRENTS_PATH  = path.join(BASE_DIR, 'config', 'torrent_final.json')
-const ORGANIZED_PATH = path.join(BASE_DIR, 'config', 'organized.json')
+const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')

 // ─── Utils log ────────────────────────────────────────────────
-// Le worker tourne dans un thread séparé — il passe les logs au thread principal
-// qui les écrit dans le fichier via logger.ts
-
 function log(msg: string)   { parentPort?.postMessage({ type: 'log', level: 'info',  msg }) }
 function warn(msg: string)  { parentPort?.postMessage({ type: 'log', level: 'warn',  msg }) }
 function error(msg: string) { parentPort?.postMessage({ type: 'log', level: 'error', msg }) }
 function debug(msg: string) { parentPort?.postMessage({ type: 'log', level: 'debug', msg }) }

-// ─── Settings (lu directement, pas d'import circulaire) ──────
-
+// ─── Settings ─────────────────────────────────────────────────
 function readSettings(): { mediaPath: string; completePath: string; organizeMode: string; nfoSupport: boolean } {
    try {
-        const p = path.join(process.cwd(), 'config', 'settings.json')
+        const p = path.join(DATA_DIR, 'settings.json')
        if (!fs.existsSync(p)) return { mediaPath: '', completePath: '', organizeMode: 'hardlink', nfoSupport: false }
        return JSON.parse(fs.readFileSync(p, 'utf-8'))
    } catch { return { mediaPath: '', completePath: '', organizeMode: 'hardlink', nfoSupport: false } }
 }

 // ─── Organized log ────────────────────────────────────────────
-
 function loadOrganized(): Record<string, Record<string, string>> {
    try {
        if (!fs.existsSync(ORGANIZED_PATH)) return {}
@@ -65,18 +53,51 @@ function isOrganized(hash: string, filename: string): boolean {
    return !!loadOrganized()[hash]?.[filename]
 }

-// ─── Torrent lookup ───────────────────────────────────────────
-
-function findTorrentByHash(hash: string): any | null {
-    try {
-        if (!fs.existsSync(TORRENTS_PATH)) return null
-        const torrents = JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8'))
-        return torrents.find((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase()) ?? null
-    } catch { return null }
+// ─── Lookup torrent dans les seriesData passées via message ───
+function findTorrentByHash(hash: string, seriesData: any[]): { torrent: any; serieData: any } | null {
+    for (const sd of seriesData) {
+        // Niveau série
+        for (const t of sd.torrents ?? []) {
+            if (t.infohash?.toLowerCase() === hash.toLowerCase())
+                return { torrent: t, serieData: sd }
+        }
+        // Niveau saison
+        for (const season of sd.seasons ?? []) {
+            for (const t of season.torrents ?? []) {
+                if (t.infohash?.toLowerCase() === hash.toLowerCase())
+                    return { torrent: { ...t, _season: season }, serieData: sd }
+            }
+            // Niveau épisode
+            for (const ep of season.episodes ?? []) {
+                for (const t of ep.torrents ?? []) {
+                    if (t.infohash?.toLowerCase() === hash.toLowerCase())
+                        return { torrent: { ...t, _episode: ep, _season: season }, serieData: sd }
+                }
+            }
+        }
+    }
+    return null
 }

-// ─── Dossiers exclus (bonus, musique, images) ────────────────
+// Construit la map filename → { season_number, original_filename }
+// depuis les paths[] de la série en utilisant l'index du torrent
+function buildFileMap(serieData: any, torrentIdx: number, seasonFilter?: number): Map<string, { season_number: number; original_filename: string }> {
+    const map = new Map<string, { season_number: number; original_filename: string }>()
+    for (const season of serieData.seasons ?? []) {
+        if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
+        for (const ep of season.episodes ?? []) {
+            const filePath = (ep.paths ?? [])[torrentIdx]
+            if (!filePath) continue
+            const filename = filePath.split('/').pop() ?? filePath
+            // original_filename vient de l'API Fankai (passé dans ep directement si disponible)
+            const original = ep.original_filename ?? filename
+            map.set(filename, { season_number: season.season_number, original_filename: original })
+        }
+    }
+    return map
+}

+// ─── Dossiers exclus ─────────────────────────────────────────
 const EXCLUDED_FOLDERS = new Set([
    'endings', 'ending', 'openings', 'opening', 'ost', 'artworks', 'artwork',
    'bonus', 'extras', 'extra', 'specials', 'special', 'ncop', 'nced',
@@ -94,28 +115,7 @@ function isInExcludedFolder(filePath: string[]): boolean {
    return false
 }

-// ─── Map correction titres API → titres 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'

@@ -134,12 +134,9 @@ async function fetchBinary(url: string): Promise<Buffer> {
 }

 async function downloadGitlabFolder(serieTitle: string, destRoot: string): Promise<void> {
-    const gitlabTitle = getGitlabSerieTitle(serieTitle)
-    const folderPath  = `pack/${gitlabTitle}`
+    const folderPath = `pack/${serieTitle}`
+    log(`[nfo] Récupération dossier GitLab: ${serieTitle}`)

-    log(`[nfo] Récupération dossier GitLab: ${gitlabTitle}`)
-
-    // Lister récursivement tous les fichiers du dossier (pagination GitLab)
    let files: any[] = []
    try {
        let page = 1
@@ -153,31 +150,22 @@ async function downloadGitlabFolder(serieTitle: string, destRoot: string): Promi
            page++
        }
    } catch (err) {
-        warn(`[nfo] Dossier GitLab introuvable pour "${gitlabTitle}": ${err instanceof Error ? err.message : err}`)
+        warn(`[nfo] Dossier GitLab introuvable pour "${serieTitle}": ${err instanceof Error ? err.message : err}`)
        return
    }

-    if (files.length === 0) {
-        warn(`[nfo] Aucun fichier trouvé sur GitLab pour "${gitlabTitle}"`)
-        return
-    }
+    if (files.length === 0) { warn(`[nfo] Aucun fichier trouvé pour "${serieTitle}"`); return }

    const fileEntries = files.filter((f: any) => f.type === 'blob')
    log(`[nfo] ${fileEntries.length} fichiers à télécharger`)

    for (const entry of fileEntries) {
-        // entry.path = "pack/Black Lagoon Henshū/Saison 1/fichier.nfo"
-        // On retire le préfixe "pack/{gitlabTitle}/" pour obtenir le chemin relatif
-        const relativePath = entry.path.replace(`pack/${gitlabTitle}/`, '')
+        const relativePath = entry.path.replace(`pack/${serieTitle}/`, '')
        const destPath     = path.join(destRoot, relativePath)
-        const destDir      = path.dirname(destPath)
-
-        // Skip si déjà présent
        if (fs.existsSync(destPath)) continue
-
        try {
-            fs.mkdirSync(destDir, { recursive: true })
-            const rawUrl = `${GITLAB_RAW_BASE}/${encodeURIComponent(gitlabTitle)}/${relativePath.split('/').map(encodeURIComponent).join('/')}`
+            fs.mkdirSync(path.dirname(destPath), { recursive: true })
+            const rawUrl = `${GITLAB_RAW_BASE}/${encodeURIComponent(serieTitle)}/${relativePath.split('/').map(encodeURIComponent).join('/')}`
            const data   = await fetchBinary(rawUrl)
            fs.writeFileSync(destPath, data)
            log(`[nfo] ✓ ${relativePath}`)
@@ -185,15 +173,11 @@ async function downloadGitlabFolder(serieTitle: string, destRoot: string): Promi
            warn(`[nfo] ✗ ${relativePath}: ${err instanceof Error ? err.message : err}`)
        }
    }
-
-    log(`[nfo] Dossier GitLab synchronisé pour "${serieTitle}"`)
+    log(`[nfo] GitLab synchronisé pour "${serieTitle}"`)
 }

 // ─── Filesystem ops ───────────────────────────────────────────
-
-function seasonFolder(n: number): string {
-    return `Saison ${n}`
-}
+function seasonFolder(n: number): string { return `Saison ${n}` }

 function tryHardlink(src: string, dest: string): boolean {
    try { fs.linkSync(src, dest); return true }
@@ -204,74 +188,71 @@ function tryHardlink(src: string, dest: string): boolean {
 }

 // ─── Organise un torrent ──────────────────────────────────────
-
-async function organizeTorrent(hash: string, name: string, savePath: string) {
+async function organizeTorrent(hash: string, name: string, savePath: string, seriesData: any[]) {
    const { mediaPath, completePath, organizeMode, nfoSupport } = readSettings()
    const result = { total: 0, skipped: 0, done: 0, errors: [] as { file: string; error: string }[] }

    log(`[organize] ── ${name} ──`)
    log(`[organize] hash=${hash} save_path=${savePath} mode=${organizeMode}`)

-    const torrent = findTorrentByHash(hash)
-    if (!torrent) {
-        error(`[organize] ✗ Hash ${hash} introuvable dans torrent_final.json`)
+    const found = findTorrentByHash(hash, seriesData)
+    if (!found) {
+        error(`[organize] ✗ Hash ${hash} introuvable dans les données série`)
        throw new Error(`Torrent introuvable : ${hash}`)
    }
-    log(`[organize] ✓ Trouvé : ${torrent.raw}`)

-    const serieTitle   = torrent.serie_title || torrent.show_title || name
-    const torrentFiles: any[] = torrent.torrent_files ?? []
-    log(`[organize] serie=${serieTitle} fichiers=${torrentFiles.length}`)
+    const { torrent, serieData } = found
+    const serieTitle = serieData.title ?? serieData.show_title ?? name
+    log(`[organize] ✓ Trouvé : ${torrent.title ?? name} — série: ${serieTitle}`)

-    // ── Téléchargement NFO/images depuis GitLab ───────────────
-    if (nfoSupport) {
-        // Collecter tous les titres de séries distincts depuis resolved_episodes
-        // (un pack_integrale peut mélanger plusieurs séries, ex: One Piece Yabai + Kaï)
-        const serieTitlesMap = new Map<number, string>()
-
-        // Titre principal du torrent
-        serieTitlesMap.set(torrent.serie_id ?? 0, serieTitle)
-
-        // Titres alternatifs depuis resolved_episodes
-        // resolved_episodes n'a pas toujours serie_title → on cherche dans torrent_final.json
-        const allTorrents: any[] = (() => {
-            try { return JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8')) } catch { return [] }
-        })()
-        const serieIdToTitle = new Map<number, string>()
-        for (const t of allTorrents) {
-            if (t.serie_id && t.serie_title) serieIdToTitle.set(t.serie_id, t.serie_title)
-        }
-
-        for (const ep of torrent.resolved_episodes ?? []) {
-            if (ep.serie_id && !serieTitlesMap.has(ep.serie_id)) {
-                const title = ep.serie_title ?? serieIdToTitle.get(ep.serie_id)
-                if (title) serieTitlesMap.set(ep.serie_id, title)
-            }
-        }
-
-        // Télécharger NFO pour chaque série distincte
-        for (const title of serieTitlesMap.values()) {
-            const serieDestRoot = path.join(mediaPath, title)
-            await downloadGitlabFolder(title, serieDestRoot)
-        }
+    // Déterminer l'index du torrent dans sa hiérarchie
+    let torrentIdx = 0
+    let seasonFilter: number | undefined
+    if (torrent._episode) {
+        // Torrent niveau épisode : paths[0] est le seul fichier
+        torrentIdx    = (torrent._episode.torrents ?? []).findIndex((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase())
+        seasonFilter  = torrent._season?.season_number
+    } else if (torrent._season) {
+        torrentIdx    = (torrent._season.torrents ?? []).findIndex((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase())
+        seasonFilter  = torrent._season.season_number
+    } else {
+        torrentIdx    = (serieData.torrents ?? []).findIndex((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase())
    }

-    // ── Cas fichier unique ────────────────────────────────────
-    if (torrentFiles.length === 0) {
-        log(`[organize] torrent_files vide → tentative fichier unique`)
-        const candidates = [path.join(savePath, name), path.join(completePath, name)]
-        let src: string | null = null
-        for (const c of candidates) {
-            if (fs.existsSync(c)) log(`[organize]   ✓ source trouvée: ${c}`)
-            else debug(`[organize]   candidate absent: ${c}`)
-            if (fs.existsSync(c)) { src = c; break }
-        }
-        if (!src) throw new Error(`Source introuvable pour "${name}"`)
+    // Construire la map filename → { season_number, original_filename }
+    const fileMap = buildFileMap(serieData, torrentIdx, seasonFilter)

-        const seasonNum = torrent.resolved_episodes?.[0]?.season_number ?? 1
-        const destDir   = path.join(mediaPath, serieTitle, seasonFolder(seasonNum))
-        const dest      = path.join(destDir, name)
-        log(`[organize]   dest: ${dest}`)
+    // ── NFO/images depuis GitLab ──────────────────────────────
+    if (nfoSupport) {
+        const serieDestRoot = path.join(mediaPath, serieTitle)
+        await downloadGitlabFolder(serieTitle, serieDestRoot)
+    }
+
+    // ── Cas torrent épisode unique ────────────────────────────
+    if (torrent._episode) {
+        const ep       = torrent._episode
+        const season   = torrent._season
+        const filePath = (ep.paths ?? [])[torrentIdx]
+        const filename = filePath?.split('/').pop() ?? name
+        const original = ep.original_filename ?? filename
+        const destDir  = path.join(mediaPath, serieTitle, seasonFolder(season.season_number ?? 1))
+        const dest     = path.join(destDir, original)
+
+        if (isOrganized(hash, filename)) return { ...result, total: 1, skipped: 1 }
+
+        const candidates = [
+            path.join(savePath, name, filename),
+            path.join(savePath, filename),
+            path.join(completePath, name, filename),
+            path.join(completePath, filename),
+        ]
+        let src: string | null = null
+        for (const c of candidates) { if (fs.existsSync(c)) { src = c; break } }
+
+        if (!src) {
+            error(`[organize] ✗ ${filename} introuvable`)
+            return { ...result, total: 1, errors: [{ file: filename, error: 'Source introuvable' }] }
+        }

        if (!fs.existsSync(dest)) {
            fs.mkdirSync(destDir, { recursive: true })
@@ -281,84 +262,42 @@ async function organizeTorrent(hash: string, name: string, savePath: string) {
                await fsp.copyFile(src, dest)
                await fsp.unlink(src)
            }
-            log(`[organize]   ✓ ${organizeMode} OK`)
-        } else {
-            log(`[organize]   → dest existe déjà, skip`)
        }
-        markOrganized(hash, name)
+        markOrganized(hash, filename)
+        log(`[organize] ✓ ${original} → Saison ${season.season_number}`)
        return { ...result, total: 1, done: 1 }
    }

-    // ── Map filename → season ─────────────────────────────────
-    // Priorité : season_number dans torrent_files (packs multi-saisons)
-    // Fallback  : resolved_episodes matchés par episode_number (torrents individuels)
-    const filenameSeasonMap = new Map<string, number>()
-
-    // Index resolved_episodes par episode_number pour lookup rapide
-    const epByNum = new Map<number, number>()  // ep_number → season_number
-    for (const ep of torrent.resolved_episodes ?? []) {
-        if (ep.episode_number !== undefined && ep.season_number !== undefined)
-            epByNum.set(Number(ep.episode_number), ep.season_number)
+    // ── Pack saison / intégrale : itérer sur les fichiers ─────
+    if (fileMap.size === 0) {
+        warn(`[organize] Aucun fichier mappé pour ${name}`)
+        return result
    }

-    for (const tf of torrentFiles) {
-        const sn: number | null = tf.season_number != null ? Number(tf.season_number) : null
-        const tfNum = tf.num !== undefined ? Number(tf.num) : undefined
-        if (sn !== null) {
-            filenameSeasonMap.set(tf.filename, sn)
-        } else if (tfNum !== undefined && epByNum.has(tfNum)) {
-            filenameSeasonMap.set(tf.filename, epByNum.get(tfNum)!)
-        } else if (torrent.season_number !== undefined) {
-            filenameSeasonMap.set(tf.filename, torrent.season_number)
-        }
-    }
-
-    result.total = torrentFiles.length
-
-    for (const tf of torrentFiles) {
-        const filename = tf.filename
-        const filePath: string[] = tf.path
-
-        // Skip les fichiers dans des dossiers bonus/musique/images
-        if (isInExcludedFolder(filePath)) {
-            log(`[organize] skip bonus: ${filename}`)
-            result.skipped++
-            continue
-        }
+    result.total = fileMap.size

+    for (const [filename, { season_number, original_filename }] of fileMap) {
        if (isOrganized(hash, filename)) { result.skipped++; continue }

        const candidates = [
-            path.join(savePath, name, ...filePath.slice(0, -1), filename),
-            path.join(savePath, ...filePath.slice(0, -1), filename),
            path.join(savePath, name, filename),
            path.join(savePath, filename),
-            path.join(completePath, name, ...filePath.slice(0, -1), filename),
            path.join(completePath, name, filename),
            path.join(completePath, filename),
        ]
-
        let src: string | null = null
-        for (const c of candidates) {
-            if (fs.existsSync(c)) { src = c; break }
-        }
+        for (const c of candidates) { if (fs.existsSync(c)) { src = c; break } }

        if (!src) {
-            const tried = candidates.map(c => `  • ${c}`).join('\n')
-            error(`[organize] ✗ ${filename} introuvable:\n${tried}`)
+            error(`[organize] ✗ ${filename} introuvable`)
            result.errors.push({ file: filename, error: 'Source introuvable' })
            continue
        }

-        const seasonNum = filenameSeasonMap.get(filename) ?? 1
-        const destDir   = path.join(mediaPath, serieTitle, seasonFolder(seasonNum))
-        const dest      = path.join(destDir, filename)
+        const destDir = path.join(mediaPath, serieTitle, seasonFolder(season_number))
+        const dest    = path.join(destDir, original_filename)

-        if (fs.existsSync(dest)) {
-            markOrganized(hash, filename)
-            result.skipped++
-            continue
-        }
+        if (fs.existsSync(dest)) { markOrganized(hash, filename); result.skipped++; continue }

        try {
            fs.mkdirSync(destDir, { recursive: true })
@@ -370,7 +309,7 @@ async function organizeTorrent(hash: string, name: string, savePath: string) {
            }
            markOrganized(hash, filename)
            result.done++
-            log(`[organize] ✓ ${filename} → Saison ${String(seasonNum).padStart(3,'0')}`)
+            log(`[organize] ✓ ${original_filename} → Saison ${season_number}`)
        } catch (err) {
            const msg = err instanceof Error ? err.message : 'Erreur inconnue'
            error(`[organize] ✗ ${filename}: ${msg}`)
@@ -378,37 +317,39 @@ async function organizeTorrent(hash: string, name: string, savePath: string) {
        }
    }

-    log(`[organize] ── Résultat ${name}: ${result.done} OK, ${result.skipped} skippés, ${result.errors.length} erreurs`)
+    log(`[organize] ── ${name}: ${result.done} OK, ${result.skipped} skippés, ${result.errors.length} erreurs`)
    return result
 }

 // ─── Boucle principale du worker ─────────────────────────────
-
 parentPort?.on('message', async (msg: any) => {
    if (msg.type !== 'run') return

-    const torrents: any[] = msg.torrents
+    const torrents: any[]   = msg.torrents
+    const seriesData: any[] = msg.seriesData ?? []
    const organized = loadOrganized()

    for (const t of torrents) {
        if (t.state !== 'seeding') continue

-        const torrent = findTorrentByHash(t.hash)
-        if (!torrent) {
-            warn(`[organize] hash ${t.hash} (${t.name}) non trouvé`)
+        const found = findTorrentByHash(t.hash, seriesData)
+        if (!found) {
+            warn(`[organize] hash ${t.hash} (${t.name}) non trouvé dans les données série`)
            continue
        }

-        const files: any[] = torrent.torrent_files ?? []
-        // Pour fichier unique : vérifier via le name directement
-        const allDone = files.length > 0
-            ? files.every((f: any) => organized[t.hash]?.[f.filename])
+        // Vérifier si déjà tout organisé
+        const { serieData } = found
+        const torrentIdx = (serieData.torrents ?? []).findIndex((st: any) => st.infohash?.toLowerCase() === t.hash.toLowerCase())
+        const fileMap = buildFileMap(serieData, torrentIdx)
+        const allDone = fileMap.size > 0
+            ? [...fileMap.keys()].every(f => organized[t.hash]?.[f])
            : !!organized[t.hash]?.[t.name]

        if (allDone) continue

        try {
-            const result = await organizeTorrent(t.hash, t.name, t.save_path)
+            const result = await organizeTorrent(t.hash, t.name, t.save_path, seriesData)
            parentPort?.postMessage({ type: 'result', hash: t.hash, name: t.name, ...result })
        } catch (err) {
            error(`[organize] Erreur ${t.name}: ${err instanceof Error ? err.message : err}`)
@@ -2,24 +2,23 @@
 * organize.ts
 * ===========
 * Lance l'organizer dans un Worker Thread dédié pour ne pas bloquer Express.
- * Le worker gère tout le filesystem (copy, hardlink, move).
 */

 import fs     from 'fs'
 import path   from 'path'
 import { Worker } from 'worker_threads'
 import { logger } from './logger.js'
+import { DATA_DIR } from './config.js'
+
+const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')

 // Un seul worker à la fois
 let workerRunning = false

-// Résolution du chemin du worker
-// En binaire Bun compilé : le worker est à côté de l'exécutable
-// En Docker/dev : à côté du fichier courant
+// État précédent des torrents pour détecter les passages downloading → seeding
+const _prevStates = new Map<string, string>()
+
 function resolveWorkerPath(): string {
-    // Si Bun est présent → le worker est toujours à côté de l'exécutable
-    // (que ce soit un binaire compilé ou `bun run` en dev)
-    // En Node/tsx → on utilise import.meta.url
    if (typeof (globalThis as any).Bun !== 'undefined') {
        return path.join(path.dirname((process as any).execPath), 'organize-worker.js')
    }
@@ -35,13 +34,12 @@ export interface OrganizeResult {

 /**
 * Scan initial du mediaPath au démarrage.
- * Parcourt récursivement le dossier Jellyfin et marque dans organized.json
- * tous les fichiers déjà présents qui correspondent à un torrent connu.
+ * Construit l'index filename → infohash depuis les seriesData passées en paramètre.
 */
 export async function scanMediaPath(
-    mediaPath   : string,
-    torrentsPath: string,
-    organizedPath: string
+    mediaPath    : string,
+    organizedPath: string,
+    seriesData   : any[] = []
 ): Promise<{ found: number; added: number }> {
    const result = { found: 0, added: 0 }

@@ -50,27 +48,45 @@ export async function scanMediaPath(
        return result
    }

-    // Charger torrent_final.json
-    let torrents: any[] = []
-    try {
-        if (!fs.existsSync(torrentsPath)) return result
-        torrents = JSON.parse(fs.readFileSync(torrentsPath, 'utf-8'))
-    } catch {
-        logger.error('organize', 'scanMediaPath: impossible de lire torrent_final.json')
-        return result
-    }
-
-    // Construire un index filename → { hash, infohash }
+    // Construire index filename → infohash depuis les seriesData
    const filenameIndex = new Map<string, string>()  // filename → infohash
-    for (const t of torrents) {
-        const hash = t.infohash?.toLowerCase()
-        if (!hash) continue
-        for (const f of t.torrent_files ?? []) {
-            if (f.filename) filenameIndex.set(f.filename, hash)
+    for (const sd of seriesData) {
+        // Torrents niveau série
+        for (const [i, t] of (sd.torrents ?? []).entries()) {
+            const hash = t.infohash?.toLowerCase()
+            if (!hash) continue
+            for (const season of sd.seasons ?? []) {
+                for (const ep of season.episodes ?? []) {
+                    const filePath = (ep.paths ?? [])[i]
+                    if (!filePath) continue
+                    const filename = filePath.split('/').pop()
+                    if (filename) filenameIndex.set(filename, hash)
+                }
+            }
        }
-        // Fichier unique (torrent_files vide) → on indexe par raw name
-        if ((t.torrent_files ?? []).length === 0 && t.raw) {
-            filenameIndex.set(t.raw, hash)
+        // Torrents niveau saison
+        for (const season of sd.seasons ?? []) {
+            for (const [i, t] of (season.torrents ?? []).entries()) {
+                const hash = t.infohash?.toLowerCase()
+                if (!hash) continue
+                for (const ep of season.episodes ?? []) {
+                    const filePath = (ep.paths ?? [])[i]
+                    if (!filePath) continue
+                    const filename = filePath.split('/').pop()
+                    if (filename) filenameIndex.set(filename, hash)
+                }
+            }
+            // Torrents niveau épisode
+            for (const ep of season.episodes ?? []) {
+                for (const [i, t] of (ep.torrents ?? []).entries()) {
+                    const hash = t.infohash?.toLowerCase()
+                    if (!hash) continue
+                    const filePath = (ep.paths ?? [])[i]
+                    if (!filePath) continue
+                    const filename = filePath.split('/').pop()
+                    if (filename) filenameIndex.set(filename, hash)
+                }
+            }
        }
    }

@@ -81,7 +97,8 @@ export async function scanMediaPath(
            organized = JSON.parse(fs.readFileSync(organizedPath, 'utf-8'))
    } catch {}

-    // Parcourir récursivement mediaPath
+    const presentFiles = new Set<string>()
+
    function walk(dir: string) {
        let entries: fs.Dirent[]
        try { entries = fs.readdirSync(dir, { withFileTypes: true }) }
@@ -94,8 +111,8 @@ export async function scanMediaPath(
                result.found++
                const hash = filenameIndex.get(entry.name)
                if (!hash) continue
-                if (organized[hash]?.[entry.name]) continue  // déjà connu
-                // Marquer comme organisé
+                presentFiles.add(`${hash}:${entry.name}`)
+                if (organized[hash]?.[entry.name]) continue
                if (!organized[hash]) organized[hash] = {}
                organized[hash][entry.name] = new Date().toISOString()
                result.added++
@@ -105,9 +122,21 @@ export async function scanMediaPath(

    walk(mediaPath)

-    if (result.added > 0) {
+    // Nettoyer les entrées orphelines
+    let removed = 0
+    for (const [hash, files] of Object.entries(organized)) {
+        for (const filename of Object.keys(files)) {
+            if (!presentFiles.has(`${hash}:${filename}`) && filenameIndex.get(filename) === hash) {
+                delete organized[hash][filename]
+                removed++
+            }
+        }
+        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', `scanMediaPath: ${result.found} fichiers scannés, ${result.added} ajoutés à organized.json`)
+        logger.info('organize', `scanMediaPath: ${result.found} fichiers, ${result.added} ajoutés, ${removed} orphelins supprimés`)
    } else {
        logger.info('organize', `scanMediaPath: ${result.found} fichiers scannés, rien de nouveau`)
    }
@@ -116,13 +145,12 @@ export async function scanMediaPath(
 }

 /**
- * Lance l'auto-organisation dans un worker thread.
- * listFn est appelée dans le thread principal (accès qBittorrent),
- * puis les données sont passées au worker.
+ * Auto-organisation — appelée depuis index.ts avec les seriesData du cache GitHub.
 */
 export async function autoOrganizeAll(
-    listFn  : () => Promise<any[]>,
-    onResult?: (r: { hash: string; name: string; done: number; skipped: number; errors: number; errorFiles: { file: string; error: string }[] }) => void
+    listFn     : () => Promise<any[]>,
+    seriesData : any[],
+    onResult  ?: (r: { hash: string; name: string; done: number; skipped: number; errors: number; errorFiles: { file: string; error: string }[] }) => void
 ): Promise<void> {
    if (workerRunning) {
        console.log('[organize] Worker déjà en cours, skip')
@@ -139,15 +167,27 @@ export async function autoOrganizeAll(

    if (torrents.length === 0) return

+    const isFirstRun   = _prevStates.size === 0
    const seedingCount = torrents.filter(t => t.state === 'seeding').length
+
+    const newlySeeding = torrents.filter(t => {
+        const prev = _prevStates.get(t.hash)
+        return t.state === 'seeding' && (prev === undefined || prev !== 'seeding')
+    })
+
+    for (const t of torrents) _prevStates.set(t.hash, t.state)
+
+    if (!isFirstRun && newlySeeding.length === 0) return
    if (seedingCount === 0) return

-    console.log(`[organize] Lancement worker (${seedingCount} torrents en seeding)`)
+    if (newlySeeding.length > 0 && !isFirstRun) {
+        console.log(`[organize] ${newlySeeding.length} nouveau(x) torrent(s) terminé(s) → lancement worker`)
+    } else {
+        console.log(`[organize] Lancement worker (${seedingCount} torrents en seeding)`)
+    }
    workerRunning = true

-    const workerPath = resolveWorkerPath()
-
-    const worker = new Worker(workerPath)
+    const worker = new Worker(resolveWorkerPath())

    worker.on('message', (msg: any) => {
        if (msg.type === 'log') {
@@ -157,12 +197,12 @@ export async function autoOrganizeAll(
        } else if (msg.type === 'result') {
            console.log(`[organize] ${msg.name} → ${msg.done} OK, ${msg.skipped} skippés, ${msg.errors.length} erreurs`)
            onResult?.({
-                hash       : msg.hash,
-                name       : msg.name,
-                done       : msg.done,
-                skipped    : msg.skipped,
-                errors     : msg.errors.length,
-                errorFiles : msg.errors,
+                hash      : msg.hash,
+                name      : msg.name,
+                done      : msg.done,
+                skipped   : msg.skipped,
+                errors    : msg.errors.length,
+                errorFiles: msg.errors,
            })
        } else if (msg.type === 'done') {
            console.log('[organize] Worker terminé')
@@ -171,34 +211,23 @@ export async function autoOrganizeAll(
        }
    })

-    worker.on('error', (err) => {
-        console.error('[organize] Worker erreur:', err)
-        workerRunning = false
-    })
+    worker.on('error', (err) => { console.error('[organize] Worker erreur:', err); workerRunning = false })
+    worker.on('exit',  (code) => { if (code !== 0) console.error(`[organize] Worker exit ${code}`); workerRunning = false })

-    worker.on('exit', (code) => {
-        if (code !== 0) console.error(`[organize] Worker exit code ${code}`)
-        workerRunning = false
-    })
-
-    // Envoyer les torrents au worker
-    worker.postMessage({ type: 'run', torrents })
+    worker.postMessage({ type: 'run', torrents, seriesData })
 }

 /**
- * Organisation manuelle d'un torrent (appelée depuis l'API /organize).
- * Lance aussi dans un worker thread.
+ * Organisation manuelle d'un torrent.
 */
 export async function organizeTorrent(
-    hash    : string,
-    name    : string,
-    savePath: string
+    hash      : string,
+    name      : string,
+    savePath  : string,
+    seriesData: any[]
 ): Promise<OrganizeResult> {
    return new Promise((resolve, reject) => {
-        const workerPath = resolveWorkerPath()
-        const worker = new Worker(workerPath)
-
-        // On envoie un seul torrent "fictif seeding"
+        const worker      = new Worker(resolveWorkerPath())
        const fakeTorrent = { hash, name, save_path: savePath, state: 'seeding' }
        const result: OrganizeResult = { total: 0, skipped: 0, done: 0, errors: [] }

@@ -221,6 +250,6 @@ export async function organizeTorrent(
        worker.on('error', (err) => { worker.terminate(); reject(err) })
        worker.on('exit',  (code) => { if (code !== 0) reject(new Error(`Worker exit ${code}`)) })

-        worker.postMessage({ type: 'run', torrents: [fakeTorrent] })
+        worker.postMessage({ type: 'run', torrents: [fakeTorrent], seriesData })
    })
 }
@@ -9,8 +9,9 @@
 import fs       from 'fs'
 import path     from 'path'
 import crypto   from 'crypto'
+import { DATA_DIR } from './config.js'

-const SECRET_PATH = path.join(process.cwd(), 'config', 'secret.key')
+const SECRET_PATH = path.join(DATA_DIR, 'secret.key')

 function generateSecret(): string {
    return crypto.randomBytes(48).toString('hex')
@@ -1,12 +1,8 @@
 import fs from 'fs'
 import path from 'path'
+import { DATA_DIR } from './config.js'

-const _isBunBinary = typeof (globalThis as any).Bun !== 'undefined'
-    && path.dirname((process as any).execPath) !== process.cwd()
-const BASE_DIR = _isBunBinary
-    ? path.dirname((process as any).execPath)
-    : process.cwd()
-const DATA_PATH = path.join(BASE_DIR, 'config', 'settings.json')
+const DATA_PATH = path.join(DATA_DIR, 'settings.json')

 export interface Settings {
    mediaPath     : string
@@ -9,6 +9,7 @@
 import { randomUUID } from 'crypto'
 import fs from 'fs'
 import path from 'path'
+import { DATA_DIR } from '../config.js'

 // ─── Types ────────────────────────────────────────────────────────────────────

@@ -77,7 +78,7 @@ export function getAvailableClients(): TorrentClientDefinition[] {

 // ─── Persistence (clients enregistrés) ────────────────────────────────────────

-const CLIENTS_PATH = path.join(process.cwd(), 'config', 'torrent_clients.json')
+const CLIENTS_PATH = path.join(DATA_DIR, 'torrent_clients.json')

 function loadClients(): SavedClient[] {
    try {
@@ -27,7 +27,8 @@
      <!-- Hero -->
      <div class="relative">
        <div v-if="data.serie.fanart_image" class="absolute inset-0 h-72 overflow-hidden pointer-events-none">
-          <img :src="data.serie.fanart_image" class="w-full h-full object-cover opacity-20" />
+          <img :src="data.serie.fanart_image" class="w-full h-full object-cover opacity-20"
+               @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-zinc-950" />
        </div>

@@ -64,6 +65,7 @@
              <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'
@@ -81,12 +83,10 @@
            <!-- Barre progression intégrale -->
            <template v-for="(t, i) in data.torrents_integrale" :key="`prog-${i}`">
              <template v-if="torrentProgress(extractHash(t))">
-                <!-- Badge 100% -->
                <span v-if="torrentProgress(extractHash(t))!.progress === 100"
                      class="mt-2 inline-flex items-center gap-1.5 text-[10px] px-2.5 py-1 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
                  ✓ Téléchargé
                </span>
-                <!-- Barre en cours -->
                <div v-else class="mt-2 w-full max-w-sm">
                  <div class="flex items-center justify-between text-[10px] text-zinc-500 mb-1">
                    <span>Téléchargement</span>
@@ -160,16 +160,15 @@
              {{ season.organized_state === 'complete' ? 'Organisé ✓' : isAlreadyQueued(season.torrent) ? 'Déjà ajouté' : downloaded.has(`season-${season.id}`) ? 'Envoyé ✓' : 'Saison entière' }}
            </button>
          </div>
+
          <!-- Barre progression saison -->
          <template v-if="torrentProgress(extractHash(season.torrent))">
-            <!-- Badge 100% -->
            <div v-if="torrentProgress(extractHash(season.torrent))!.progress === 100"
                 class="px-5 py-2 border-b border-white/5">
              <span class="inline-flex items-center gap-1.5 text-[10px] px-2.5 py-1 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
                ✓ Téléchargé
              </span>
            </div>
-            <!-- Barre en cours -->
            <div v-else class="px-5 py-2 border-b border-white/5">
              <div class="flex items-center justify-between text-[10px] text-zinc-500 mb-1">
                <span>Téléchargement en cours</span>
@@ -202,9 +201,9 @@
                <!-- Info -->
                <div class="flex-1 min-w-0">
                  <div class="flex items-center gap-2">
-                  <span class="text-xs text-zinc-600 shrink-0 font-mono">
-                    {{ season.season_number === 0 ? 'SP' : `E${String(ep.episode_number).padStart(2,'0')}` }}
-                  </span>
+                    <span class="text-xs text-zinc-600 shrink-0 font-mono">
+                      {{ season.season_number === 0 ? 'SP' : `E${String(ep.episode_number).padStart(2,'0')}` }}
+                    </span>
                    <span class="text-sm font-medium truncate">{{ ep.title || `Épisode ${ep.episode_number}` }}</span>
                  </div>
                  <div class="flex items-center gap-3 mt-0.5">
@@ -213,38 +212,48 @@
                  </div>
                </div>

-                <!-- Bouton épisode (type episode uniquement) -->
+                <!-- Badges + bouton download -->
                <div class="shrink-0 flex items-center gap-2">
+
+                  <!-- Badge Hors Fankai (torrent manuel) -->
+                  <span
+                      v-if="ep.torrent?.manual"
+                      title="Ce fichier ne provient pas du catalogue Fan-Kai officiel"
+                      class="text-[10px] px-2 py-0.5 rounded-full border bg-purple-500/10 text-purple-400 border-purple-500/20"
+                  >
+                    Hors Fankai
+                  </span>
+
                  <!-- Badge organisé -->
                  <span v-if="ep.organized"
                        class="text-[10px] px-2 py-0.5 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
-                  ✓ organisé
-                </span>
+                    ✓ organisé
+                  </span>

                  <!-- Badge téléchargé à 100% -->
                  <span v-if="torrentProgress(extractHash(ep.torrent))?.progress === 100"
                        class="text-[10px] px-2 py-0.5 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
-                  ✓ téléchargé
-                </span>
+                    ✓ téléchargé
+                  </span>

                  <!-- Badge dispo/indispo -->
                  <span
                      class="inline-block text-[10px] px-2 py-0.5 rounded-full border"
                      :class="ep.available
-                    ? 'bg-blue-500/10 text-blue-400 border-blue-500/20'
-                    : 'bg-white/5 text-zinc-600 border-white/8'"
+                        ? 'bg-blue-500/10 text-blue-400 border-blue-500/20'
+                        : 'bg-white/5 text-zinc-600 border-white/8'"
                  >
-                  {{ ep.available ? 'dispo' : 'indispo' }}
-                </span>
+                    {{ ep.available ? 'dispo' : 'indispo' }}
+                  </span>

                  <!-- Bouton download -->
                  <button
                      class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border transition"
                      :class="[
-                    ep.torrent && !downloaded.has(`ep-${ep.id}`) && !isAlreadyQueued(ep.torrent) && !ep.organized
-                      ? 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border-orange-500/20'
-                      : 'bg-white/[0.03] text-zinc-600 border-white/8 cursor-not-allowed'
-                  ]"
+                        ep.torrent && !downloaded.has(`ep-${ep.id}`) && !isAlreadyQueued(ep.torrent) && !ep.organized
+                          ? 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border-orange-500/20'
+                          : 'bg-white/[0.03] text-zinc-600 border-white/8 cursor-not-allowed'
+                      ]"
                      :disabled="!ep.torrent || downloading.has(`ep-${ep.id}`) || downloaded.has(`ep-${ep.id}`) || isAlreadyQueued(ep.torrent) || ep.organized"
                      @click="ep.torrent && download(`ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet)"
                  >
@@ -317,7 +326,7 @@ const store = useSeriesStore()

 const collapsedSeasons = ref<Set<number>>(new Set())
 const downloading      = ref<Set<string>>(new Set())
-const downloaded       = ref<Set<string>>(new Set())  // envoyés avec succès → bloqués
+const downloaded       = ref<Set<string>>(new Set())
 const toast            = ref<{ type: 'success' | 'error'; message: string } | null>(null)

 // ── Progression downloads ──────────────────────────────────────
@@ -339,13 +348,11 @@ async function fetchActiveDownloads() {
  } catch {}
 }

-// Cherche si un torrent actif correspond à un hash donné
 function torrentProgress(hash: string | null | undefined): ActiveTorrent | null {
  if (!hash) return null
  return activeTorrents.value.find(t => t.hash.toLowerCase() === hash.toLowerCase()) ?? null
 }

-// Hash d'un torrent de saison ou d'épisode (extrait depuis magnet ou url)
 function extractHash(torrent: { magnet?: string | null; torrent_url?: string | null } | null | undefined): string | null {
  if (!torrent) return null
  const magnet = torrent.magnet ?? ''
@@ -375,7 +382,6 @@ function showToast(type: 'success' | 'error', message: string) {
  setTimeout(() => { toast.value = null }, 3500)
 }

-// Vérifie si un torrent est déjà en cours ou terminé dans qBittorrent
 function isAlreadyQueued(torrent: { magnet?: string | null; torrent_url?: string | null } | null | undefined): boolean {
  const hash = extractHash(torrent)
  if (!hash) return false
Author	SHA1	Message	Date
MasutaYunikon	17f7234b49	Merge pull request #48 from Masutayunikon/release-please--branches--main chore(main): release 2.0.0	2026-03-23 04:05:16 +01:00
MasutaYunikon	8e529d3845	chore(main): release 2.0.0	2026-03-23 04:04:52 +01:00
MasutaYunikon	a3f3539a27	Merge remote-tracking branch 'origin/main'	2026-03-23 04:04:23 +01:00
MasutaYunikon	d5c37e8f2c	feat!: migration vers nouvelle architecture API et scraper par série BREAKING CHANGE: suppression de torrent_final.json au profit d'un système de fichiers par série (series/{id}.json) avec cache mémoire GitHub 6h. Version majeure — nécessite un nouveau scraper et une mise à jour complète. feat(api): cache mémoire GitHub TTL 6h avec invalidation via /api/update Plus de fichiers locaux dans /config pour les torrents. Les données sont fetchées depuis GitHub (available.json + series/{id}.json) et mises en cache 6h. /api/update vide le cache pour forcer le rechargement. feat(api): adaptation complète à la nouvelle structure API Fankai - normalizeSerie/Season/Episode pour aplatir images.poster → poster_image - Proxy wsrv.nl pour redimensionner les images (poster 300px, fanart 1280px, thumbnail 400px) et réduire le temps de chargement - duration en secondes → affichage en minutes dans SerieView feat(organize): refonte complète sans torrent_final.json - organize-worker.ts reçoit seriesData via message au lieu de lire un fichier - buildFileMap construit filename→{season_number,original_filename} depuis paths[] - enrichSeriesDataWithOriginalFilenames fetche /seasons/{id}/episodes avant de passer les données au worker pour le renommage correct des fichiers - Suppression de SERIE_TITLE_GITLAB_MAP (Kaï→Kai résolu côté API) - scanMediaPath adapté : plus de torrentsPath, prend seriesData en paramètre feat(api): matching torrents par hiérarchie série/saison/épisode - Torrents niveau série → pack_integrale - Torrents niveau saison → pack_saison (indexé par season_number) - Torrents niveau épisode → episode - Matching via paths[torrentIdx] pour résoudre episode↔fichier feat(series-view): badge "Hors Fankai" sur épisodes de torrents manuels feat(series-view): tooltip raw name sur boutons intégrale via :title feat(scraper): extraction nom bencode dans raw pour torrents locaux fix(series): boutons saison Yu-Gi-Oh via fallback season_number fix(catalogue): état download basé sur épisodes organisés vs torrents bruts Release-As: 2.0.0	2026-03-23 04:04:12 +01:00
MasutaYunikon	a5f5dfb0da	Merge pull request #47 from Masutayunikon/release-please--branches--main chore(main): release 1.14.0	2026-03-21 08:01:19 +01:00
MasutaYunikon	08531c80f3	chore(main): release 1.14.0	2026-03-21 07:59:16 +01:00
MasutaYunikon	96ce207027	Merge remote-tracking branch 'origin/main'	2026-03-21 07:58:54 +01:00
MasutaYunikon	13f9a27af8	fix(series): résolution boutons de téléchargement saisons Yu-Gi-Oh et séries similaires Les boutons "Saison entière" n'apparaissaient pas pour les séries dont les season_id du scraper ne correspondent pas aux season_id de l'API Fankai. - Ajouter seasonTorrentMapBySn indexé par season_number en fallback - Utiliser season_number comme clé de secours dans enrichedSeasons fix(catalogue): état "partiel" incorrect quand l'intégrale est organisée Le badge partial s'affichait même quand tous les épisodes étaient organisés via un pack_integrale, car les torrents d'épisodes séparés faisaient baisser le ratio. La logique est maintenant basée sur les episode_id uniques. feat(series-view): badge "Hors Fankai" sur les épisodes de torrents manuels Les épisodes issus de MANUAL_TORRENTS (ex: MHA Film 4) sont maintenant marqués d'un badge violet "Hors Fankai" avec tooltip explicatif. - Propager manual: true du torrent dans le TorrentRef de l'épisode - Afficher le badge dans SerieView.vue si ep.torrent?.manual feat(series-view): tooltip avec le nom du torrent sur les boutons intégrale Quand plusieurs intégrales existent pour une série, survoler le bouton affiche le raw name du torrent via :title="t.raw". feat(scraper): extraction du nom bencode pour les torrents locaux Le champ raw des LOCAL_TORRENTS est maintenant renseigné depuis info.name extrait directement du fichier .torrent via bencode, au lieu d'utiliser la clé du dictionnaire LOCAL_TORRENTS. - fetch_torrent_files_from_local retourne maintenant (files, infohash, name) - torrent["raw"] est mis à jour avec le vrai nom bencode	2026-03-21 07:58:45 +01:00
MasutaYunikon	d0d40c02b5	Merge pull request #46 from Masutayunikon/release-please--branches--main chore(main): release 1.13.0	2026-03-21 04:21:36 +01:00
MasutaYunikon	0e541a19ba	chore(main): release 1.13.0	2026-03-21 04:21:09 +01:00
MasutaYunikon	1d71c40a2b	Merge pull request #45 from Masutayunikon/release-please--branches--main chore(main): release 1.12.2	2026-03-21 04:20:11 +01:00
MasutaYunikon	adc3e91122	chore(main): release 1.12.2	2026-03-21 04:18:31 +01:00
MasutaYunikon	b260208701	Merge remote-tracking branch 'origin/main'	2026-03-21 04:18:09 +01:00
MasutaYunikon	3dd517c37f	fix: use season number from resolved episodes in priority	2026-03-21 04:17:59 +01:00
MasutaYunikon	93397bee77	Merge pull request #44 from Masutayunikon/release-please--branches--main chore(main): release 1.12.1	2026-03-21 04:00:35 +01:00
MasutaYunikon	3f72c01911	chore(main): release 1.12.1	2026-03-21 03:59:32 +01:00
MasutaYunikon	77e6a2e38c	Merge remote-tracking branch 'origin/main'	2026-03-21 03:59:09 +01:00
MasutaYunikon	bef99183aa	fix: path	2026-03-21 03:58:55 +01:00
MasutaYunikon	7b84229510	Merge pull request #43 from Masutayunikon/release-please--branches--main chore(main): release 1.12.0	2026-03-21 03:45:31 +01:00
MasutaYunikon	23c46a621e	chore(main): release 1.12.0	2026-03-21 03:45:10 +01:00
MasutaYunikon	4dc7255bb0	Merge remote-tracking branch 'origin/main'	2026-03-21 03:44:46 +01:00
MasutaYunikon	180513c98a	feat: now rename episodes with original_filename from api	2026-03-21 03:44:37 +01:00
MasutaYunikon	00894bc069	Merge pull request #42 from Masutayunikon/release-please--branches--main chore(main): release 1.11.10	2026-03-21 03:18:52 +01:00
MasutaYunikon	a1b128640d	chore(main): release 1.11.10	2026-03-21 03:18:32 +01:00
MasutaYunikon	8bec4c62fa	fix: improve torrent organization and cleanup logic	2026-03-21 03:18:09 +01:00
MasutaYunikon	a7ba6a54a3	Merge remote-tracking branch 'origin/main'	2026-03-21 02:14:03 +01:00
MasutaYunikon	33d0b9a52d	fix: season 0 not clonficting anymore	2026-03-21 02:13:52 +01:00
MasutaYunikon	46546d0178	Merge pull request #41 from Masutayunikon/release-please--branches--main chore(main): release 1.11.9	2026-03-21 00:09:13 +01:00
MasutaYunikon	756ced0001	chore(main): release 1.11.9	2026-03-20 22:03:02 +01:00
MasutaYunikon	2addb39ba3	Merge remote-tracking branch 'origin/main'	2026-03-20 22:02:40 +01:00
MasutaYunikon	232ede4292	fix: season 0 resolved is no longer skipped in the worker	2026-03-20 22:02:17 +01:00
MasutaYunikon	f161e84a1d	Merge pull request #40 from Masutayunikon/release-please--branches--main chore(main): release 1.11.8	2026-03-20 20:31:54 +01:00
MasutaYunikon	4d4a8029f6	chore(main): release 1.11.8	2026-03-20 20:31:00 +01:00
MasutaYunikon	2a1dcddd90	Merge remote-tracking branch 'origin/main'	2026-03-20 20:30:33 +01:00
MasutaYunikon	4d319f97bc	fix: config path /config/config to /config	2026-03-20 20:30:23 +01:00
MasutaYunikon	3372d4cb40	Merge pull request #39 from Masutayunikon/release-please--branches--main chore(main): release 1.11.7	2026-03-20 20:18:44 +01:00
MasutaYunikon	eb22bb669f	chore(main): release 1.11.7	2026-03-20 20:18:19 +01:00
MasutaYunikon	0d64a66977	Merge remote-tracking branch 'origin/main'	2026-03-20 20:17:54 +01:00
MasutaYunikon	b0e81166e1	fix: worker path	2026-03-20 20:17:46 +01:00
MasutaYunikon	79d7aa7485	Merge pull request #38 from Masutayunikon/release-please--branches--main chore(main): release 1.11.6	2026-03-20 17:30:18 +01:00
MasutaYunikon	af995a84cb	chore(main): release 1.11.6	2026-03-20 17:29:09 +01:00
MasutaYunikon	5a71bdca3c	Merge remote-tracking branch 'origin/main'	2026-03-20 17:28:46 +01:00
MasutaYunikon	77d918fbe0	fix: path	2026-03-20 17:28:09 +01:00
MasutaYunikon	a0b255338d	Merge pull request #37 from Masutayunikon/release-please--branches--main chore(main): release 1.11.5	2026-03-20 17:01:44 +01:00
MasutaYunikon	e0b09c144f	chore(main): release 1.11.5	2026-03-20 17:00:37 +01:00
MasutaYunikon	418d09b07f	Merge remote-tracking branch 'origin/main'	2026-03-20 17:00:07 +01:00
MasutaYunikon	4c7936b019	fix: export _isBunBinary	2026-03-20 16:59:58 +01:00
MasutaYunikon	77f42b5b3e	Merge pull request #36 from Masutayunikon/release-please--branches--main chore(main): release 1.11.4	2026-03-20 16:57:17 +01:00
MasutaYunikon	bd69f7a730	chore(main): release 1.11.4	2026-03-20 16:55:47 +01:00
MasutaYunikon	3ce6523248	Merge remote-tracking branch 'origin/main'	2026-03-20 16:55:16 +01:00
MasutaYunikon	2efed9dcfc	fix: add config.ts with config variable (BASE_DIR...)	2026-03-20 16:55:03 +01:00
MasutaYunikon	88e2a0bc38	Merge pull request #35 from Masutayunikon/release-please--branches--main chore(main): release 1.11.3	2026-03-20 16:08:46 +01:00
MasutaYunikon	338e3f8547	chore(main): release 1.11.3	2026-03-20 15:41:14 +01:00
MasutaYunikon	d1ccc902da	Merge remote-tracking branch 'origin/main'	2026-03-20 15:40:40 +01:00
MasutaYunikon	5e54e24b60	fix: entrypoint.sh config directory	2026-03-20 15:40:28 +01:00