chore: bump version to 1.23.0

Use Telegram sendPhoto API for conversion and metadata-approved events
when a book thumbnail is available on disk. Falls back to text message
if photo upload fails.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Cargo.lock

@@ -64,7 +64,7 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "api"
-version = "1.21.1"
+version = "1.23.0"
 dependencies = [
  "anyhow",
  "argon2",
@@ -76,6 +76,7 @@ dependencies = [
  "image",
  "jpeg-decoder",
  "lru",
+ "notifications",
  "parsers",
  "rand 0.8.5",
  "regex",
@@ -1232,7 +1233,7 @@ dependencies = [
 
 [[package]]
 name = "indexer"
-version = "1.21.1"
+version = "1.23.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -1240,6 +1241,7 @@ dependencies = [
  "futures",
  "image",
  "jpeg-decoder",
+ "notifications",
  "num_cpus",
  "parsers",
  "reqwest",
@@ -1663,6 +1665,19 @@ dependencies = [
  "nom",
 ]
 
+[[package]]
+name = "notifications"
+version = "1.23.0"
+dependencies = [
+ "anyhow",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
@@ -1771,7 +1786,7 @@ dependencies = [
 
 [[package]]
 name = "parsers"
-version = "1.21.1"
+version = "1.23.0"
 dependencies = [
  "anyhow",
  "flate2",
@@ -2270,6 +2285,7 @@ dependencies = [
  "base64",
  "bytes",
  "futures-core",
+ "futures-util",
  "http",
  "http-body",
  "http-body-util",
@@ -2278,6 +2294,7 @@ dependencies = [
  "hyper-util",
  "js-sys",
  "log",
+ "mime_guess",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
@@ -2906,7 +2923,7 @@ dependencies = [
 
 [[package]]
 name = "stripstream-core"
-version = "1.21.1"
+version = "1.23.0"
 dependencies = [
  "anyhow",
  "serde",

Cargo.toml

@@ -3,13 +3,14 @@ members = [
   "apps/api",
   "apps/indexer",
   "crates/core",
+  "crates/notifications",
   "crates/parsers",
 ]
 resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "1.21.1"
+version = "1.23.0"
 license = "MIT"
 
 [workspace.dependencies]
@@ -22,7 +23,7 @@ image = { version = "0.25", default-features = false, features = ["jpeg", "png",
 jpeg-decoder = "0.3"
 lru = "0.12"
 rayon = "1.10"
-reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
+reqwest = { version = "0.12", default-features = false, features = ["json", "multipart", "rustls-tls"] }
 rand = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

README.md

@@ -81,28 +81,58 @@ The backoffice will be available at http://localhost:7082
 
 ## Features
 
-### Libraries Management
-- Create and manage multiple libraries
-- Configure automatic scanning schedules (hourly, daily, weekly)
-- Real-time file watcher for instant indexing
-- Full and incremental rebuild options
+> For the full feature list, business rules, and API details, see [docs/FEATURES.md](docs/FEATURES.md).
 
-### Books Management
-- Support for CBZ, CBR, and PDF formats
-- Automatic metadata extraction
-- Series and volume detection
-- Full-text search powered by PostgreSQL
+### Libraries
+- Multi-library management with per-library configuration
+- Incremental and full scanning, real-time filesystem watcher
+- Per-library metadata provider selection (Google Books, ComicVine, BedéThèque, AniList, Open Library)
 
-### Jobs Monitoring
-- Real-time job progress tracking
-- Detailed statistics (scanned, indexed, removed, errors)
-- Job history and logs
-- Cancel pending jobs
+### Books & Series
+- **Formats**: CBZ, CBR, PDF, EPUB
+- Automatic metadata extraction (title, series, volume, authors, page count) from filenames and directory structure
+- Series aggregation with missing volume detection
+- Thumbnail generation (WebP/JPEG/PNG) with lazy generation and bulk rebuild
+- CBR → CBZ conversion
 
-### Search
-- Full-text search across titles, authors, and series
-- Library filtering
-- Real-time suggestions
+### Reading Progress
+- Per-book tracking: unread / reading / read with current page
+- Series-level aggregated reading status
+- Bulk mark-as-read for series
+
+### Search & Discovery
+- Full-text search across titles, authors, and series (PostgreSQL `pg_trgm`)
+- Author listing with book/series counts
+- Filtering by reading status, series status, format, metadata provider
+
+### External Metadata
+- Search, match, approve/reject workflow with confidence scoring
+- Batch auto-matching and scheduled metadata refresh
+- Field locking to protect manual edits from sync
+
+### External Integrations
+- **Komga**: import reading progress
+- **Prowlarr**: search for missing volumes
+- **qBittorrent**: add torrents directly from search results
+
+### Background Jobs
+- Rebuild, rescan, thumbnail generation, metadata batch, CBR conversion
+- Real-time progress via Server-Sent Events (SSE)
+- Job history, error tracking, cancellation
+
+### Page Rendering
+- On-demand page extraction from all formats
+- Image processing (format, quality, max width, resampling filter)
+- LRU in-memory + disk cache
+
+### Security
+- Token-based auth (`admin` / `read` scopes) with Argon2 hashing
+- Rate limiting, token expiration and revocation
+
+### Web UI (Backoffice)
+- Dashboard with statistics, charts, and reading progress
+- Library, book, series, author management
+- Live job monitoring, metadata search modals, settings panel
 
 ## Environment Variables
 

apps/api/Cargo.toml

@@ -15,6 +15,7 @@ futures = "0.3"
 image.workspace = true
 jpeg-decoder.workspace = true
 lru.workspace = true
+notifications = { path = "../../crates/notifications" }
 stripstream-core = { path = "../../crates/core" }
 parsers = { path = "../../crates/parsers" }
 rand.workspace = true

apps/api/Dockerfile

@@ -6,13 +6,15 @@ COPY Cargo.toml ./
 COPY apps/api/Cargo.toml apps/api/Cargo.toml
 COPY apps/indexer/Cargo.toml apps/indexer/Cargo.toml
 COPY crates/core/Cargo.toml crates/core/Cargo.toml
+COPY crates/notifications/Cargo.toml crates/notifications/Cargo.toml
 COPY crates/parsers/Cargo.toml crates/parsers/Cargo.toml
 
-RUN mkdir -p apps/api/src apps/indexer/src crates/core/src crates/parsers/src && \
+RUN mkdir -p apps/api/src apps/indexer/src crates/core/src crates/notifications/src crates/parsers/src && \
     echo "fn main() {}" > apps/api/src/main.rs && \
     echo "fn main() {}" > apps/indexer/src/main.rs && \
     echo "" > apps/indexer/src/lib.rs && \
     echo "" > crates/core/src/lib.rs && \
+    echo "" > crates/notifications/src/lib.rs && \
     echo "" > crates/parsers/src/lib.rs
 
 # Build dependencies only (cached as long as Cargo.toml files don't change)
@@ -26,12 +28,13 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry \
 COPY apps/api/src apps/api/src
 COPY apps/indexer/src apps/indexer/src
 COPY crates/core/src crates/core/src
+COPY crates/notifications/src crates/notifications/src
 COPY crates/parsers/src crates/parsers/src
 
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/usr/local/cargo/git \
     --mount=type=cache,target=/app/target \
-    touch apps/api/src/main.rs crates/core/src/lib.rs crates/parsers/src/lib.rs && \
+    touch apps/api/src/main.rs crates/core/src/lib.rs crates/notifications/src/lib.rs crates/parsers/src/lib.rs && \
     cargo build --release -p api && \
     cp /app/target/release/api /usr/local/bin/api
 

apps/api/src/authors.rs

@@ -68,7 +68,7 @@ pub async fn list_authors(
         .filter(|s| !s.trim().is_empty())
         .map(|s| format!("%{s}%"));
 
-    // Aggregate unique authors from books.authors + books.author
+    // Aggregate unique authors from books.authors + books.author + series_metadata.authors
     let sql = format!(
         r#"
         WITH all_authors AS (
@@ -79,18 +79,21 @@ pub async fn list_authors(
                 )
             ) AS name
             FROM books
+            UNION
+            SELECT DISTINCT UNNEST(authors) AS name
+            FROM series_metadata
+            WHERE authors != '{{}}'
         ),
         filtered AS (
             SELECT name FROM all_authors
             WHERE ($1::text IS NULL OR name ILIKE $1)
         ),
-        counted AS (
+        book_counts AS (
             SELECT
-                f.name,
-                COUNT(DISTINCT b.id) AS book_count,
-                COUNT(DISTINCT NULLIF(b.series, '')) AS series_count
+                f.name AS author_name,
+                COUNT(DISTINCT b.id) AS book_count
             FROM filtered f
-            JOIN books b ON (
+            LEFT JOIN books b ON (
                 f.name = ANY(
                     COALESCE(
                         NULLIF(b.authors, '{{}}'),
@@ -99,9 +102,24 @@ pub async fn list_authors(
                 )
             )
             GROUP BY f.name
+        ),
+        series_counts AS (
+            SELECT
+                f.name AS author_name,
+                COUNT(DISTINCT (sm.library_id, sm.name)) AS series_count
+            FROM filtered f
+            LEFT JOIN series_metadata sm ON (
+                f.name = ANY(sm.authors) AND sm.authors != '{{}}'
+            )
+            GROUP BY f.name
         )
-        SELECT name, book_count, series_count
-        FROM counted
+        SELECT
+            f.name,
+            COALESCE(bc.book_count, 0) AS book_count,
+            COALESCE(sc.series_count, 0) AS series_count
+        FROM filtered f
+        LEFT JOIN book_counts bc ON bc.author_name = f.name
+        LEFT JOIN series_counts sc ON sc.author_name = f.name
         ORDER BY {order_clause}
         LIMIT $2 OFFSET $3
         "#
@@ -116,6 +134,10 @@ pub async fn list_authors(
                 )
             ) AS name
             FROM books
+            UNION
+            SELECT DISTINCT UNNEST(authors) AS name
+            FROM series_metadata
+            WHERE authors != '{}'
         )
         SELECT COUNT(*) AS total
         FROM all_authors

apps/api/src/libraries.rs

@@ -48,7 +48,6 @@ pub struct CreateLibraryRequest {
     responses(
         (status = 200, body = Vec<LibraryResponse>),
         (status = 401, description = "Unauthorized"),
-        (status = 403, description = "Forbidden - Admin scope required"),
     ),
     security(("Bearer" = []))
 )]
@@ -221,7 +220,6 @@ use crate::index_jobs::{IndexJobResponse, RebuildRequest};
         (status = 200, body = IndexJobResponse),
         (status = 404, description = "Library not found"),
         (status = 401, description = "Unauthorized"),
-        (status = 403, description = "Forbidden - Admin scope required"),
     ),
     security(("Bearer" = []))
 )]

apps/api/src/main.rs

@@ -17,9 +17,11 @@ mod prowlarr;
 mod qbittorrent;
 mod reading_progress;
 mod search;
+mod series;
 mod settings;
 mod state;
 mod stats;
+mod telegram;
 mod thumbnails;
 mod tokens;
 
@@ -86,14 +88,13 @@ async fn main() -> anyhow::Result<()> {
     };
 
     let admin_routes = Router::new()
-        .route("/libraries", get(libraries::list_libraries).post(libraries::create_library))
+        .route("/libraries", axum::routing::post(libraries::create_library))
         .route("/libraries/:id", delete(libraries::delete_library))
-        .route("/libraries/:id/scan", axum::routing::post(libraries::scan_library))
         .route("/libraries/:id/monitoring", axum::routing::patch(libraries::update_monitoring))
         .route("/libraries/:id/metadata-provider", axum::routing::patch(libraries::update_metadata_provider))
         .route("/books/:id", axum::routing::patch(books::update_book))
         .route("/books/:id/convert", axum::routing::post(books::convert_book))
-        .route("/libraries/:library_id/series/:name", axum::routing::patch(books::update_series))
+        .route("/libraries/:library_id/series/:name", axum::routing::patch(series::update_series))
         .route("/index/rebuild", axum::routing::post(index_jobs::enqueue_rebuild))
         .route("/index/thumbnails/rebuild", axum::routing::post(thumbnails::start_thumbnails_rebuild))
         .route("/index/thumbnails/regenerate", axum::routing::post(thumbnails::start_thumbnails_regenerate))
@@ -111,6 +112,7 @@ async fn main() -> anyhow::Result<()> {
         .route("/prowlarr/test", get(prowlarr::test_prowlarr))
         .route("/qbittorrent/add", axum::routing::post(qbittorrent::add_torrent))
         .route("/qbittorrent/test", get(qbittorrent::test_qbittorrent))
+        .route("/telegram/test", get(telegram::test_telegram))
         .route("/komga/sync", axum::routing::post(komga::sync_komga_read_books))
         .route("/komga/reports", get(komga::list_sync_reports))
         .route("/komga/reports/:id", get(komga::get_sync_report))
@@ -133,18 +135,20 @@ async fn main() -> anyhow::Result<()> {
         ));
 
     let read_routes = Router::new()
+        .route("/libraries", get(libraries::list_libraries))
+        .route("/libraries/:id/scan", axum::routing::post(libraries::scan_library))
         .route("/books", get(books::list_books))
-        .route("/books/ongoing", get(books::ongoing_books))
+        .route("/books/ongoing", get(series::ongoing_books))
         .route("/books/:id", get(books::get_book))
         .route("/books/:id/thumbnail", get(books::get_thumbnail))
         .route("/books/:id/pages/:n", get(pages::get_page))
         .route("/books/:id/progress", get(reading_progress::get_reading_progress).patch(reading_progress::update_reading_progress))
-        .route("/libraries/:library_id/series", get(books::list_series))
-        .route("/libraries/:library_id/series/:name/metadata", get(books::get_series_metadata))
-        .route("/series", get(books::list_all_series))
-        .route("/series/ongoing", get(books::ongoing_series))
-        .route("/series/statuses", get(books::series_statuses))
-        .route("/series/provider-statuses", get(books::provider_statuses))
+        .route("/libraries/:library_id/series", get(series::list_series))
+        .route("/libraries/:library_id/series/:name/metadata", get(series::get_series_metadata))
+        .route("/series", get(series::list_all_series))
+        .route("/series/ongoing", get(series::ongoing_series))
+        .route("/series/statuses", get(series::series_statuses))
+        .route("/series/provider-statuses", get(series::provider_statuses))
         .route("/series/mark-read", axum::routing::post(reading_progress::mark_series_read))
         .route("/authors", get(authors::list_authors))
         .route("/stats", get(stats::get_stats))

apps/api/src/metadata.rs

@@ -369,6 +369,26 @@ pub async fn approve_metadata(
             .await?;
     }
 
+    // Notify via Telegram (with first book thumbnail if available)
+    let provider_for_notif: String = row.get("provider");
+    let thumbnail_path: Option<String> = sqlx::query_scalar(
+        "SELECT thumbnail_path FROM books WHERE library_id = $1 AND series_name = $2 AND thumbnail_path IS NOT NULL ORDER BY sort_order LIMIT 1",
+    )
+    .bind(library_id)
+    .bind(&series_name)
+    .fetch_optional(&state.pool)
+    .await
+    .ok()
+    .flatten();
+    notifications::notify(
+        state.pool.clone(),
+        notifications::NotificationEvent::MetadataApproved {
+            series_name: series_name.clone(),
+            provider: provider_for_notif,
+            thumbnail_path,
+        },
+    );
+
     Ok(Json(ApproveResponse {
         status: "approved".to_string(),
         report,

apps/api/src/metadata_batch.rs

@@ -124,6 +124,12 @@ pub async fn start_batch(
 
     // Spawn the background processing task
     let pool = state.pool.clone();
+    let library_name: Option<String> = sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
+        .bind(library_id)
+        .fetch_optional(&state.pool)
+        .await
+        .ok()
+        .flatten();
     tokio::spawn(async move {
         if let Err(e) = process_metadata_batch(&pool, job_id, library_id).await {
             warn!("[METADATA_BATCH] job {job_id} failed: {e}");
@@ -134,6 +140,13 @@ pub async fn start_batch(
             .bind(e.to_string())
             .execute(&pool)
             .await;
+            notifications::notify(
+                pool.clone(),
+                notifications::NotificationEvent::MetadataBatchFailed {
+                    library_name,
+                    error: e.to_string(),
+                },
+            );
         }
     });
 
@@ -621,6 +634,21 @@ async fn process_metadata_batch(
 
     info!("[METADATA_BATCH] job={job_id} completed: {processed}/{total} series processed");
 
+    let library_name: Option<String> = sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
+        .bind(library_id)
+        .fetch_optional(pool)
+        .await
+        .ok()
+        .flatten();
+    notifications::notify(
+        pool.clone(),
+        notifications::NotificationEvent::MetadataBatchCompleted {
+            library_name,
+            total_series: total,
+            processed,
+        },
+    );
+
     Ok(())
 }
 

apps/api/src/metadata_refresh.rs

@@ -133,6 +133,12 @@ pub async fn start_refresh(
 
     // Spawn the background processing task
     let pool = state.pool.clone();
+    let library_name: Option<String> = sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
+        .bind(library_id)
+        .fetch_optional(&state.pool)
+        .await
+        .ok()
+        .flatten();
     tokio::spawn(async move {
         if let Err(e) = process_metadata_refresh(&pool, job_id, library_id).await {
             warn!("[METADATA_REFRESH] job {job_id} failed: {e}");
@@ -143,6 +149,13 @@ pub async fn start_refresh(
             .bind(e.to_string())
             .execute(&pool)
             .await;
+            notifications::notify(
+                pool.clone(),
+                notifications::NotificationEvent::MetadataRefreshFailed {
+                    library_name,
+                    error: e.to_string(),
+                },
+            );
         }
     });
 
@@ -319,6 +332,22 @@ async fn process_metadata_refresh(
 
     info!("[METADATA_REFRESH] job={job_id} completed: {refreshed} updated, {unchanged} unchanged, {errors} errors");
 
+    let library_name: Option<String> = sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
+        .bind(library_id)
+        .fetch_optional(pool)
+        .await
+        .ok()
+        .flatten();
+    notifications::notify(
+        pool.clone(),
+        notifications::NotificationEvent::MetadataRefreshCompleted {
+            library_name,
+            refreshed,
+            unchanged,
+            errors,
+        },
+    );
+
     Ok(())
 }
 

apps/api/src/openapi.rs

@@ -10,14 +10,14 @@ use utoipa::OpenApi;
         crate::reading_progress::update_reading_progress,
         crate::reading_progress::mark_series_read,
         crate::books::get_thumbnail,
-        crate::books::list_series,
-        crate::books::list_all_series,
-        crate::books::ongoing_series,
-        crate::books::ongoing_books,
+        crate::series::list_series,
+        crate::series::list_all_series,
+        crate::series::ongoing_series,
+        crate::series::ongoing_books,
         crate::books::convert_book,
         crate::books::update_book,
-        crate::books::get_series_metadata,
-        crate::books::update_series,
+        crate::series::get_series_metadata,
+        crate::series::update_series,
         crate::pages::get_page,
         crate::search::search_books,
         crate::index_jobs::enqueue_rebuild,
@@ -35,6 +35,7 @@ use utoipa::OpenApi;
         crate::libraries::delete_library,
         crate::libraries::scan_library,
         crate::libraries::update_monitoring,
+        crate::libraries::update_metadata_provider,
         crate::tokens::list_tokens,
         crate::tokens::create_token,
         crate::tokens::revoke_token,
@@ -54,8 +55,8 @@ use utoipa::OpenApi;
         crate::metadata::get_metadata_links,
         crate::metadata::get_missing_books,
         crate::metadata::delete_metadata_link,
-        crate::books::series_statuses,
-        crate::books::provider_statuses,
+        crate::series::series_statuses,
+        crate::series::provider_statuses,
         crate::settings::list_status_mappings,
         crate::settings::upsert_status_mapping,
         crate::settings::delete_status_mapping,
@@ -63,6 +64,14 @@ use utoipa::OpenApi;
         crate::prowlarr::test_prowlarr,
         crate::qbittorrent::add_torrent,
         crate::qbittorrent::test_qbittorrent,
+        crate::metadata_batch::start_batch,
+        crate::metadata_batch::get_batch_report,
+        crate::metadata_batch::get_batch_results,
+        crate::metadata_refresh::start_refresh,
+        crate::metadata_refresh::get_refresh_report,
+        crate::komga::sync_komga_read_books,
+        crate::komga::list_sync_reports,
+        crate::komga::get_sync_report,
     ),
     components(
         schemas(
@@ -74,14 +83,14 @@ use utoipa::OpenApi;
             crate::reading_progress::UpdateReadingProgressRequest,
             crate::reading_progress::MarkSeriesReadRequest,
             crate::reading_progress::MarkSeriesReadResponse,
-            crate::books::SeriesItem,
-            crate::books::SeriesPage,
-            crate::books::ListAllSeriesQuery,
-            crate::books::OngoingQuery,
+            crate::series::SeriesItem,
+            crate::series::SeriesPage,
+            crate::series::ListAllSeriesQuery,
+            crate::series::OngoingQuery,
             crate::books::UpdateBookRequest,
-            crate::books::SeriesMetadata,
-            crate::books::UpdateSeriesRequest,
-            crate::books::UpdateSeriesResponse,
+            crate::series::SeriesMetadata,
+            crate::series::UpdateSeriesRequest,
+            crate::series::UpdateSeriesResponse,
             crate::pages::PageQuery,
             crate::search::SearchQuery,
             crate::search::SearchResponse,
@@ -96,6 +105,7 @@ use utoipa::OpenApi;
             crate::libraries::LibraryResponse,
             crate::libraries::CreateLibraryRequest,
             crate::libraries::UpdateMonitoringRequest,
+            crate::libraries::UpdateMetadataProviderRequest,
             crate::tokens::CreateTokenRequest,
             crate::tokens::TokenResponse,
             crate::tokens::CreatedTokenResponse,
@@ -137,7 +147,16 @@ use utoipa::OpenApi;
             crate::prowlarr::ProwlarrRelease,
             crate::prowlarr::ProwlarrCategory,
             crate::prowlarr::ProwlarrSearchResponse,
+            crate::prowlarr::MissingVolumeInput,
             crate::prowlarr::ProwlarrTestResponse,
+            crate::metadata_batch::MetadataBatchRequest,
+            crate::metadata_batch::MetadataBatchReportDto,
+            crate::metadata_batch::MetadataBatchResultDto,
+            crate::metadata_refresh::MetadataRefreshRequest,
+            crate::metadata_refresh::MetadataRefreshReportDto,
+            crate::komga::KomgaSyncRequest,
+            crate::komga::KomgaSyncResponse,
+            crate::komga::KomgaSyncReportSummary,
             ErrorResponse,
         )
     ),
@@ -145,11 +164,16 @@ use utoipa::OpenApi;
         ("Bearer" = [])
     ),
     tags(
-        (name = "authors", description = "Author browsing and listing"),
-        (name = "books", description = "Read-only endpoints for browsing and searching books"),
+        (name = "books", description = "Book browsing, details and management"),
+        (name = "series", description = "Series browsing, filtering and management"),
+        (name = "search", description = "Full-text search across books and series"),
         (name = "reading-progress", description = "Reading progress tracking per book"),
-        (name = "libraries", description = "Library management endpoints (Admin only)"),
+        (name = "authors", description = "Author browsing and listing"),
+        (name = "stats", description = "Collection statistics and dashboard data"),
+        (name = "libraries", description = "Library listing, scanning, and management (create/delete/settings: Admin only)"),
         (name = "indexing", description = "Search index management and job control (Admin only)"),
+        (name = "metadata", description = "External metadata providers and matching (Admin only)"),
+        (name = "komga", description = "Komga read-status sync (Admin only)"),
         (name = "tokens", description = "API token management (Admin only)"),
         (name = "settings", description = "Application settings and cache management (Admin only)"),
         (name = "prowlarr", description = "Prowlarr indexer integration (Admin only)"),

apps/api/src/search.rs

@@ -43,7 +43,7 @@ pub struct SearchResponse {
 #[utoipa::path(
     get,
     path = "/search",
-    tag = "books",
+    tag = "search",
     params(
         ("q" = String, Query, description = "Search query (books + series via PostgreSQL full-text)"),
         ("library_id" = Option<String>, Query, description = "Filter by library ID"),

apps/api/src/stats.rs

@@ -90,7 +90,7 @@ pub struct StatsResponse {
 #[utoipa::path(
     get,
     path = "/stats",
-    tag = "books",
+    tag = "stats",
     responses(
         (status = 200, body = StatsResponse),
         (status = 401, description = "Unauthorized"),

apps/api/src/telegram.rs

@@ -0,0 +1,46 @@
+use axum::{extract::State, Json};
+use serde::Serialize;
+use utoipa::ToSchema;
+
+use crate::{error::ApiError, state::AppState};
+
+#[derive(Serialize, ToSchema)]
+pub struct TelegramTestResponse {
+    pub success: bool,
+    pub message: String,
+}
+
+/// Test Telegram connection by sending a test message
+#[utoipa::path(
+    get,
+    path = "/telegram/test",
+    tag = "notifications",
+    responses(
+        (status = 200, body = TelegramTestResponse),
+        (status = 400, description = "Telegram not configured"),
+        (status = 401, description = "Unauthorized"),
+    ),
+    security(("Bearer" = []))
+)]
+pub async fn test_telegram(
+    State(state): State<AppState>,
+) -> Result<Json<TelegramTestResponse>, ApiError> {
+    let config = notifications::load_telegram_config(&state.pool)
+        .await
+        .ok_or_else(|| {
+            ApiError::bad_request(
+                "Telegram is not configured or disabled. Set bot_token, chat_id, and enable it.",
+            )
+        })?;
+
+    match notifications::send_test_message(&config).await {
+        Ok(()) => Ok(Json(TelegramTestResponse {
+            success: true,
+            message: "Test message sent successfully".to_string(),
+        })),
+        Err(e) => Ok(Json(TelegramTestResponse {
+            success: false,
+            message: format!("Failed to send: {e}"),
+        })),
+    }
+}

apps/backoffice/app/api/telegram/test/route.ts

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { apiFetch } from "@/lib/api";
+
+export async function GET() {
+  try {
+    const data = await apiFetch("/telegram/test");
+    return NextResponse.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to test Telegram connection";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

apps/backoffice/app/authors/[name]/page.tsx

@@ -21,26 +21,19 @@ export default async function AuthorDetailPage({
   const page = typeof searchParamsAwaited.page === "string" ? parseInt(searchParamsAwaited.page) : 1;
   const limit = typeof searchParamsAwaited.limit === "string" ? parseInt(searchParamsAwaited.limit) : 20;
 
-  // Fetch books by this author (server-side filtering via API) and series
+  // Fetch books by this author (server-side filtering via API) and series by this author
   const [booksPage, seriesPage] = await Promise.all([
     fetchBooks(undefined, undefined, page, limit, undefined, undefined, authorName).catch(
       () => ({ items: [], total: 0, page: 1, limit }) as BooksPageDto
     ),
-    fetchAllSeries(undefined, undefined, undefined, 1, 200).catch(
+    fetchAllSeries(undefined, undefined, undefined, 1, 200, undefined, undefined, undefined, undefined, authorName).catch(
       () => ({ items: [], total: 0, page: 1, limit: 200 }) as SeriesPageDto
     ),
   ]);
 
   const totalPages = Math.ceil(booksPage.total / limit);
 
-  // Extract unique series names from this author's books
-  const authorSeriesNames = new Set(
-    booksPage.items
-      .map((b) => b.series)
-      .filter((s): s is string => s != null && s !== "")
-  );
-
-  const authorSeries = seriesPage.items.filter((s) => authorSeriesNames.has(s.name));
+  const authorSeries = seriesPage.items;
 
   return (
     <>

apps/backoffice/app/components/ui/Icon.tsx

@@ -34,7 +34,8 @@ type IconName =
   | "warning"
   | "tag"
   | "document"
-  | "authors";
+  | "authors"
+  | "bell";
 
 type IconSize = "sm" | "md" | "lg" | "xl";
 
@@ -88,6 +89,7 @@ const icons: Record<IconName, string> = {
   tag: "M7 7h.01M7 3h5a1.99 1.99 0 011.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A1.994 1.994 0 013 12V7a4 4 0 014-4z",
   document: "M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z",
   authors: "M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0zm6 3a2 2 0 11-4 0 2 2 0 014 0zM7 10a2 2 0 11-4 0 2 2 0 014 0z",
+  bell: "M15 17h5l-1.405-1.405A2.032 2.032 0 0118 14.158V11a6.002 6.002 0 00-4-5.659V5a2 2 0 10-4 0v.341C7.67 6.165 6 8.388 6 11v3.159c0 .538-.214 1.055-.595 1.436L4 17h5m6 0v1a3 3 0 11-6 0v-1m6 0H9",
 };
 
 const colorClasses: Partial<Record<IconName, string>> = {

apps/backoffice/app/settings/SettingsPage.tsx

@@ -150,11 +150,12 @@ export default function SettingsPage({ initialSettings, initialCacheStats, initi
     }
   }
 
-  const [activeTab, setActiveTab] = useState<"general" | "integrations">("general");
+  const [activeTab, setActiveTab] = useState<"general" | "integrations" | "notifications">("general");
 
   const tabs = [
     { id: "general" as const, label: t("settings.general"), icon: "settings" as const },
     { id: "integrations" as const, label: t("settings.integrations"), icon: "refresh" as const },
+    { id: "notifications" as const, label: t("settings.notifications"), icon: "bell" as const },
   ];
 
   return (
@@ -826,6 +827,11 @@ export default function SettingsPage({ initialSettings, initialCacheStats, initi
         </CardContent>
       </Card>
       </>)}
+
+      {activeTab === "notifications" && (<>
+      {/* Telegram Notifications */}
+      <TelegramCard handleUpdateSetting={handleUpdateSetting} />
+      </>)}
     </>
   );
 }
@@ -1480,3 +1486,254 @@ function QBittorrentCard({ handleUpdateSetting }: { handleUpdateSetting: (key: s
     </Card>
   );
 }
+
+// ---------------------------------------------------------------------------
+// Telegram Notifications sub-component
+// ---------------------------------------------------------------------------
+
+const DEFAULT_EVENTS = {
+  scan_completed: true,
+  scan_failed: true,
+  scan_cancelled: true,
+  thumbnail_completed: true,
+  thumbnail_failed: true,
+  conversion_completed: true,
+  conversion_failed: true,
+  metadata_approved: true,
+  metadata_batch_completed: true,
+  metadata_batch_failed: true,
+  metadata_refresh_completed: true,
+  metadata_refresh_failed: true,
+};
+
+function TelegramCard({ handleUpdateSetting }: { handleUpdateSetting: (key: string, value: unknown) => Promise<void> }) {
+  const { t } = useTranslation();
+  const [botToken, setBotToken] = useState("");
+  const [chatId, setChatId] = useState("");
+  const [enabled, setEnabled] = useState(false);
+  const [events, setEvents] = useState(DEFAULT_EVENTS);
+  const [isTesting, setIsTesting] = useState(false);
+  const [testResult, setTestResult] = useState<{ success: boolean; message: string } | null>(null);
+  const [showHelp, setShowHelp] = useState(false);
+
+  useEffect(() => {
+    fetch("/api/settings/telegram")
+      .then((r) => (r.ok ? r.json() : null))
+      .then((data) => {
+        if (data) {
+          if (data.bot_token) setBotToken(data.bot_token);
+          if (data.chat_id) setChatId(data.chat_id);
+          if (data.enabled !== undefined) setEnabled(data.enabled);
+          if (data.events) setEvents({ ...DEFAULT_EVENTS, ...data.events });
+        }
+      })
+      .catch(() => {});
+  }, []);
+
+  function saveTelegram(token?: string, chat?: string, en?: boolean, ev?: typeof events) {
+    handleUpdateSetting("telegram", {
+      bot_token: token ?? botToken,
+      chat_id: chat ?? chatId,
+      enabled: en ?? enabled,
+      events: ev ?? events,
+    });
+  }
+
+  async function handleTestConnection() {
+    setIsTesting(true);
+    setTestResult(null);
+    try {
+      const resp = await fetch("/api/telegram/test");
+      const data = await resp.json();
+      if (data.error) {
+        setTestResult({ success: false, message: data.error });
+      } else {
+        setTestResult(data);
+      }
+    } catch {
+      setTestResult({ success: false, message: "Failed to connect" });
+    } finally {
+      setIsTesting(false);
+    }
+  }
+
+  return (
+    <Card className="mb-6">
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2">
+          <Icon name="bell" size="md" />
+          {t("settings.telegram")}
+        </CardTitle>
+        <CardDescription>{t("settings.telegramDesc")}</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <div className="space-y-4">
+          {/* Setup guide */}
+          <div>
+            <button
+              type="button"
+              onClick={() => setShowHelp(!showHelp)}
+              className="text-sm text-primary hover:text-primary/80 flex items-center gap-1 transition-colors"
+            >
+              <Icon name={showHelp ? "chevronDown" : "chevronRight"} size="sm" />
+              {t("settings.telegramHelp")}
+            </button>
+            {showHelp && (
+              <div className="mt-3 p-4 rounded-lg bg-muted/30 space-y-3 text-sm text-foreground">
+                <div>
+                  <p className="font-medium mb-1">1. Bot Token</p>
+                  <p className="text-muted-foreground" dangerouslySetInnerHTML={{ __html: t("settings.telegramHelpBot") }} />
+                </div>
+                <div>
+                  <p className="font-medium mb-1">2. Chat ID</p>
+                  <p className="text-muted-foreground" dangerouslySetInnerHTML={{ __html: t("settings.telegramHelpChat") }} />
+                </div>
+                <div>
+                  <p className="font-medium mb-1">3. Group chat</p>
+                  <p className="text-muted-foreground" dangerouslySetInnerHTML={{ __html: t("settings.telegramHelpGroup") }} />
+                </div>
+              </div>
+            )}
+          </div>
+
+          <div className="flex items-center gap-3">
+            <label className="relative inline-flex items-center cursor-pointer">
+              <input
+                type="checkbox"
+                checked={enabled}
+                onChange={(e) => {
+                  setEnabled(e.target.checked);
+                  saveTelegram(undefined, undefined, e.target.checked);
+                }}
+                className="sr-only peer"
+              />
+              <div className="w-11 h-6 bg-muted rounded-full peer peer-checked:after:translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:border-gray-300 after:border after:rounded-full after:h-5 after:w-5 after:transition-all peer-checked:bg-primary"></div>
+            </label>
+            <span className="text-sm font-medium text-foreground">{t("settings.telegramEnabled")}</span>
+          </div>
+
+          <FormRow>
+            <FormField className="flex-1">
+              <label className="text-sm font-medium text-muted-foreground mb-1 block">{t("settings.botToken")}</label>
+              <FormInput
+                type="password"
+                placeholder={t("settings.botTokenPlaceholder")}
+                value={botToken}
+                onChange={(e) => setBotToken(e.target.value)}
+                onBlur={() => saveTelegram()}
+              />
+            </FormField>
+          </FormRow>
+          <FormRow>
+            <FormField className="flex-1">
+              <label className="text-sm font-medium text-muted-foreground mb-1 block">{t("settings.chatId")}</label>
+              <FormInput
+                type="text"
+                placeholder={t("settings.chatIdPlaceholder")}
+                value={chatId}
+                onChange={(e) => setChatId(e.target.value)}
+                onBlur={() => saveTelegram()}
+              />
+            </FormField>
+          </FormRow>
+
+          {/* Event toggles grouped by category */}
+          <div className="border-t border-border/50 pt-4">
+            <h4 className="text-sm font-medium text-foreground mb-4">{t("settings.telegramEvents")}</h4>
+            <div className="grid grid-cols-2 gap-x-6 gap-y-5">
+              {([
+                {
+                  category: t("settings.eventCategoryScan"),
+                  icon: "search" as const,
+                  items: [
+                    { key: "scan_completed" as const, label: t("settings.eventCompleted") },
+                    { key: "scan_failed" as const, label: t("settings.eventFailed") },
+                    { key: "scan_cancelled" as const, label: t("settings.eventCancelled") },
+                  ],
+                },
+                {
+                  category: t("settings.eventCategoryThumbnail"),
+                  icon: "image" as const,
+                  items: [
+                    { key: "thumbnail_completed" as const, label: t("settings.eventCompleted") },
+                    { key: "thumbnail_failed" as const, label: t("settings.eventFailed") },
+                  ],
+                },
+                {
+                  category: t("settings.eventCategoryConversion"),
+                  icon: "refresh" as const,
+                  items: [
+                    { key: "conversion_completed" as const, label: t("settings.eventCompleted") },
+                    { key: "conversion_failed" as const, label: t("settings.eventFailed") },
+                  ],
+                },
+                {
+                  category: t("settings.eventCategoryMetadata"),
+                  icon: "tag" as const,
+                  items: [
+                    { key: "metadata_approved" as const, label: t("settings.eventLinked") },
+                    { key: "metadata_batch_completed" as const, label: t("settings.eventBatchCompleted") },
+                    { key: "metadata_batch_failed" as const, label: t("settings.eventBatchFailed") },
+                    { key: "metadata_refresh_completed" as const, label: t("settings.eventRefreshCompleted") },
+                    { key: "metadata_refresh_failed" as const, label: t("settings.eventRefreshFailed") },
+                  ],
+                },
+              ]).map(({ category, icon, items }) => (
+                <div key={category}>
+                  <p className="text-xs font-medium text-muted-foreground uppercase tracking-wide mb-2 flex items-center gap-1.5">
+                    <Icon name={icon} size="sm" className="text-muted-foreground" />
+                    {category}
+                  </p>
+                  <div className="space-y-1">
+                    {items.map(({ key, label }) => (
+                      <label key={key} className="flex items-center justify-between py-1.5 cursor-pointer group">
+                        <span className="text-sm text-foreground group-hover:text-foreground/80">{label}</span>
+                        <div className="relative">
+                          <input
+                            type="checkbox"
+                            checked={events[key]}
+                            onChange={(e) => {
+                              const updated = { ...events, [key]: e.target.checked };
+                              setEvents(updated);
+                              saveTelegram(undefined, undefined, undefined, updated);
+                            }}
+                            className="sr-only peer"
+                          />
+                          <div className="w-9 h-5 bg-muted rounded-full peer peer-checked:after:translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:border-gray-300 after:border after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-primary" />
+                        </div>
+                      </label>
+                    ))}
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          <div className="flex items-center gap-3">
+            <Button
+              onClick={handleTestConnection}
+              disabled={isTesting || !botToken || !chatId || !enabled}
+            >
+              {isTesting ? (
+                <>
+                  <Icon name="spinner" size="sm" className="animate-spin -ml-1 mr-2" />
+                  {t("settings.testing")}
+                </>
+              ) : (
+                <>
+                  <Icon name="refresh" size="sm" className="mr-2" />
+                  {t("settings.testConnection")}
+                </>
+              )}
+            </Button>
+            {testResult && (
+              <span className={`text-sm font-medium ${testResult.success ? "text-success" : "text-destructive"}`}>
+                {testResult.message}
+              </span>
+            )}
+          </div>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}

apps/backoffice/lib/api.ts

@@ -342,6 +342,7 @@ export async function fetchAllSeries(
   seriesStatus?: string,
   hasMissing?: boolean,
   metadataProvider?: string,
+  author?: string,
 ): Promise<SeriesPageDto> {
   const params = new URLSearchParams();
   if (libraryId) params.set("library_id", libraryId);
@@ -351,6 +352,7 @@ export async function fetchAllSeries(
   if (seriesStatus) params.set("series_status", seriesStatus);
   if (hasMissing) params.set("has_missing", "true");
   if (metadataProvider) params.set("metadata_provider", metadataProvider);
+  if (author) params.set("author", author);
   params.set("page", page.toString());
   params.set("limit", limit.toString());
 

apps/backoffice/lib/i18n/en.ts

@@ -543,6 +543,33 @@ const en: Record<TranslationKey, string> = {
   "settings.qbittorrentUsername": "Username",
   "settings.qbittorrentPassword": "Password",
 
+  // Settings - Telegram Notifications
+  "settings.notifications": "Notifications",
+  "settings.telegram": "Telegram",
+  "settings.telegramDesc": "Receive Telegram notifications for scans, errors, and metadata linking.",
+  "settings.botToken": "Bot Token",
+  "settings.botTokenPlaceholder": "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11",
+  "settings.chatId": "Chat ID",
+  "settings.chatIdPlaceholder": "123456789",
+  "settings.telegramEnabled": "Enable Telegram notifications",
+  "settings.telegramEvents": "Events",
+  "settings.eventCategoryScan": "Scans",
+  "settings.eventCategoryThumbnail": "Thumbnails",
+  "settings.eventCategoryConversion": "CBR → CBZ Conversion",
+  "settings.eventCategoryMetadata": "Metadata",
+  "settings.eventCompleted": "Completed",
+  "settings.eventFailed": "Failed",
+  "settings.eventCancelled": "Cancelled",
+  "settings.eventLinked": "Linked",
+  "settings.eventBatchCompleted": "Batch completed",
+  "settings.eventBatchFailed": "Batch failed",
+  "settings.eventRefreshCompleted": "Refresh completed",
+  "settings.eventRefreshFailed": "Refresh failed",
+  "settings.telegramHelp": "How to get the required information?",
+  "settings.telegramHelpBot": "Open Telegram, search for <b>@BotFather</b>, send <code>/newbot</code> and follow the instructions. Copy the token it gives you.",
+  "settings.telegramHelpChat": "Send a message to your bot, then open <code>https://api.telegram.org/bot&lt;TOKEN&gt;/getUpdates</code> in your browser. The <b>chat id</b> is in <code>message.chat.id</code>.",
+  "settings.telegramHelpGroup": "For a group: add the bot to the group, send a message, then check the same URL. Group IDs are negative (e.g. <code>-123456789</code>).",
+
   // Settings - Language
   "settings.language": "Language",
   "settings.languageDesc": "Choose the interface language",

apps/backoffice/lib/i18n/fr.ts

@@ -541,6 +541,33 @@ const fr = {
   "settings.qbittorrentUsername": "Nom d'utilisateur",
   "settings.qbittorrentPassword": "Mot de passe",
 
+  // Settings - Telegram Notifications
+  "settings.notifications": "Notifications",
+  "settings.telegram": "Telegram",
+  "settings.telegramDesc": "Recevoir des notifications Telegram lors des scans, erreurs et liaisons de métadonnées.",
+  "settings.botToken": "Bot Token",
+  "settings.botTokenPlaceholder": "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11",
+  "settings.chatId": "Chat ID",
+  "settings.chatIdPlaceholder": "123456789",
+  "settings.telegramEnabled": "Activer les notifications Telegram",
+  "settings.telegramEvents": "Événements",
+  "settings.eventCategoryScan": "Scans",
+  "settings.eventCategoryThumbnail": "Miniatures",
+  "settings.eventCategoryConversion": "Conversion CBR → CBZ",
+  "settings.eventCategoryMetadata": "Métadonnées",
+  "settings.eventCompleted": "Terminé",
+  "settings.eventFailed": "Échoué",
+  "settings.eventCancelled": "Annulé",
+  "settings.eventLinked": "Liée",
+  "settings.eventBatchCompleted": "Batch terminé",
+  "settings.eventBatchFailed": "Batch échoué",
+  "settings.eventRefreshCompleted": "Rafraîchissement terminé",
+  "settings.eventRefreshFailed": "Rafraîchissement échoué",
+  "settings.telegramHelp": "Comment obtenir les informations ?",
+  "settings.telegramHelpBot": "Ouvrez Telegram, recherchez <b>@BotFather</b>, envoyez <code>/newbot</code> et suivez les instructions. Copiez le token fourni.",
+  "settings.telegramHelpChat": "Envoyez un message à votre bot, puis ouvrez <code>https://api.telegram.org/bot&lt;TOKEN&gt;/getUpdates</code> dans votre navigateur. Le <b>chat id</b> apparaît dans <code>message.chat.id</code>.",
+  "settings.telegramHelpGroup": "Pour un groupe : ajoutez le bot au groupe, envoyez un message, puis consultez la même URL. Les IDs de groupe sont négatifs (ex: <code>-123456789</code>).",
+
   // Settings - Language
   "settings.language": "Langue",
   "settings.languageDesc": "Choisir la langue de l'interface",

apps/backoffice/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stripstream-backoffice",
-  "version": "1.21.1",
+  "version": "1.23.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 7082",

apps/indexer/Cargo.toml

@@ -14,6 +14,7 @@ futures = "0.3"
 image.workspace = true
 jpeg-decoder.workspace = true
 num_cpus.workspace = true
+notifications = { path = "../../crates/notifications" }
 parsers = { path = "../../crates/parsers" }
 reqwest.workspace = true
 serde.workspace = true

apps/indexer/Dockerfile

@@ -6,13 +6,15 @@ COPY Cargo.toml ./
 COPY apps/api/Cargo.toml apps/api/Cargo.toml
 COPY apps/indexer/Cargo.toml apps/indexer/Cargo.toml
 COPY crates/core/Cargo.toml crates/core/Cargo.toml
+COPY crates/notifications/Cargo.toml crates/notifications/Cargo.toml
 COPY crates/parsers/Cargo.toml crates/parsers/Cargo.toml
 
-RUN mkdir -p apps/api/src apps/indexer/src crates/core/src crates/parsers/src && \
+RUN mkdir -p apps/api/src apps/indexer/src crates/core/src crates/notifications/src crates/parsers/src && \
     echo "fn main() {}" > apps/api/src/main.rs && \
     echo "fn main() {}" > apps/indexer/src/main.rs && \
     echo "" > apps/indexer/src/lib.rs && \
     echo "" > crates/core/src/lib.rs && \
+    echo "" > crates/notifications/src/lib.rs && \
     echo "" > crates/parsers/src/lib.rs
 
 # Build dependencies only (cached as long as Cargo.toml files don't change)
@@ -25,12 +27,13 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry \
 COPY apps/api/src apps/api/src
 COPY apps/indexer/src apps/indexer/src
 COPY crates/core/src crates/core/src
+COPY crates/notifications/src crates/notifications/src
 COPY crates/parsers/src crates/parsers/src
 
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/usr/local/cargo/git \
     --mount=type=cache,target=/app/target \
-    touch apps/indexer/src/main.rs crates/core/src/lib.rs crates/parsers/src/lib.rs && \
+    touch apps/indexer/src/main.rs crates/core/src/lib.rs crates/notifications/src/lib.rs crates/parsers/src/lib.rs && \
     cargo build --release -p indexer && \
     cp /app/target/release/indexer /usr/local/bin/indexer
 

apps/indexer/src/job.rs

@@ -328,6 +328,7 @@ pub async fn process_job(
         removed_files: 0,
         errors: 0,
         warnings: 0,
+        new_series: 0,
     };
 
     let mut total_processed_count = 0i32;

apps/indexer/src/scanner.rs

@@ -14,6 +14,7 @@ use crate::{
     utils,
     AppState,
 };
+use std::collections::HashSet;
 
 #[derive(Serialize)]
 pub struct JobStats {
@@ -22,6 +23,7 @@ pub struct JobStats {
     pub removed_files: usize,
     pub errors: usize,
     pub warnings: usize,
+    pub new_series: usize,
 }
 
 const BATCH_SIZE: usize = 100;
@@ -106,6 +108,18 @@ pub async fn scan_library_discovery(
         HashMap::new()
     };
 
+    // Track existing series names for new_series counting
+    let existing_series: HashSet<String> = sqlx::query_scalar(
+        "SELECT DISTINCT COALESCE(NULLIF(series, ''), 'unclassified') FROM books WHERE library_id = $1",
+    )
+    .bind(library_id)
+    .fetch_all(&state.pool)
+    .await
+    .unwrap_or_default()
+    .into_iter()
+    .collect();
+    let mut seen_new_series: HashSet<String> = HashSet::new();
+
     let mut seen: HashMap<String, bool> = HashMap::new();
     let mut library_processed_count = 0i32;
     let mut last_progress_update = std::time::Instant::now();
@@ -382,6 +396,12 @@ pub async fn scan_library_discovery(
         let book_id = Uuid::new_v4();
         let file_id = Uuid::new_v4();
 
+        // Track new series
+        let series_key = parsed.series.as_deref().unwrap_or("unclassified").to_string();
+        if !existing_series.contains(&series_key) && seen_new_series.insert(series_key) {
+            stats.new_series += 1;
+        }
+
         books_to_insert.push(BookInsert {
             book_id,
             library_id,

apps/indexer/src/worker.rs

@@ -1,10 +1,12 @@
 use std::time::Duration;
+use sqlx::Row;
 use tracing::{error, info, trace};
+use uuid::Uuid;
 use crate::{job, scheduler, watcher, AppState};
 
 pub async fn run_worker(state: AppState, interval_seconds: u64) {
     let wait = Duration::from_secs(interval_seconds.max(1));
-    
+
     // Cleanup stale jobs from previous runs
     if let Err(err) = job::cleanup_stale_jobs(&state.pool).await {
         error!("[CLEANUP] Failed to cleanup stale jobs: {}", err);
@@ -34,21 +36,183 @@ pub async fn run_worker(state: AppState, interval_seconds: u64) {
         }
     });
 
+    struct JobInfo {
+        job_type: String,
+        library_name: Option<String>,
+        book_title: Option<String>,
+        thumbnail_path: Option<String>,
+    }
+
+    async fn load_job_info(
+        pool: &sqlx::PgPool,
+        job_id: Uuid,
+        library_id: Option<Uuid>,
+    ) -> JobInfo {
+        let row = sqlx::query("SELECT type, book_id FROM index_jobs WHERE id = $1")
+            .bind(job_id)
+            .fetch_optional(pool)
+            .await
+            .ok()
+            .flatten();
+
+        let (job_type, book_id): (String, Option<Uuid>) = match row {
+            Some(r) => (r.get("type"), r.get("book_id")),
+            None => ("unknown".to_string(), None),
+        };
+
+        let library_name: Option<String> = if let Some(lib_id) = library_id {
+            sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
+                .bind(lib_id)
+                .fetch_optional(pool)
+                .await
+                .ok()
+                .flatten()
+        } else {
+            None
+        };
+
+        let (book_title, thumbnail_path): (Option<String>, Option<String>) = if let Some(bid) = book_id {
+            let row = sqlx::query("SELECT title, thumbnail_path FROM books WHERE id = $1")
+                .bind(bid)
+                .fetch_optional(pool)
+                .await
+                .ok()
+                .flatten();
+            match row {
+                Some(r) => (r.get("title"), r.get("thumbnail_path")),
+                None => (None, None),
+            }
+        } else {
+            (None, None)
+        };
+
+        JobInfo { job_type, library_name, book_title, thumbnail_path }
+    }
+
+    async fn load_scan_stats(pool: &sqlx::PgPool, job_id: Uuid) -> notifications::ScanStats {
+        let row = sqlx::query("SELECT stats_json FROM index_jobs WHERE id = $1")
+            .bind(job_id)
+            .fetch_optional(pool)
+            .await
+            .ok()
+            .flatten();
+
+        if let Some(row) = row {
+            if let Ok(val) = row.try_get::<serde_json::Value, _>("stats_json") {
+                return notifications::ScanStats {
+                    scanned_files: val.get("scanned_files").and_then(|v| v.as_u64()).unwrap_or(0) as usize,
+                    indexed_files: val.get("indexed_files").and_then(|v| v.as_u64()).unwrap_or(0) as usize,
+                    removed_files: val.get("removed_files").and_then(|v| v.as_u64()).unwrap_or(0) as usize,
+                    new_series: val.get("new_series").and_then(|v| v.as_u64()).unwrap_or(0) as usize,
+                    errors: val.get("errors").and_then(|v| v.as_u64()).unwrap_or(0) as usize,
+                };
+            }
+        }
+
+        notifications::ScanStats {
+            scanned_files: 0,
+            indexed_files: 0,
+            removed_files: 0,
+            new_series: 0,
+            errors: 0,
+        }
+    }
+
+    fn build_completed_event(
+        job_type: &str,
+        library_name: Option<String>,
+        book_title: Option<String>,
+        thumbnail_path: Option<String>,
+        stats: notifications::ScanStats,
+        duration_seconds: u64,
+    ) -> notifications::NotificationEvent {
+        match notifications::job_type_category(job_type) {
+            "thumbnail" => notifications::NotificationEvent::ThumbnailCompleted {
+                job_type: job_type.to_string(),
+                library_name,
+                duration_seconds,
+            },
+            "conversion" => notifications::NotificationEvent::ConversionCompleted {
+                library_name,
+                book_title,
+                thumbnail_path,
+            },
+            _ => notifications::NotificationEvent::ScanCompleted {
+                job_type: job_type.to_string(),
+                library_name,
+                stats,
+                duration_seconds,
+            },
+        }
+    }
+
+    fn build_failed_event(
+        job_type: &str,
+        library_name: Option<String>,
+        book_title: Option<String>,
+        thumbnail_path: Option<String>,
+        error: String,
+    ) -> notifications::NotificationEvent {
+        match notifications::job_type_category(job_type) {
+            "thumbnail" => notifications::NotificationEvent::ThumbnailFailed {
+                job_type: job_type.to_string(),
+                library_name,
+                error,
+            },
+            "conversion" => notifications::NotificationEvent::ConversionFailed {
+                library_name,
+                book_title,
+                thumbnail_path,
+                error,
+            },
+            _ => notifications::NotificationEvent::ScanFailed {
+                job_type: job_type.to_string(),
+                library_name,
+                error,
+            },
+        }
+    }
+
     loop {
         match job::claim_next_job(&state.pool).await {
             Ok(Some((job_id, library_id))) => {
                 info!("[INDEXER] Starting job {} library={:?}", job_id, library_id);
+                let started_at = std::time::Instant::now();
+                let info = load_job_info(&state.pool, job_id, library_id).await;
+
                 if let Err(err) = job::process_job(&state, job_id, library_id).await {
                     let err_str = err.to_string();
                     if err_str.contains("cancelled") || err_str.contains("Cancelled") {
                         info!("[INDEXER] Job {} was cancelled by user", job_id);
-                        // Status is already 'cancelled' in DB, don't change it
+                        notifications::notify(
+                            state.pool.clone(),
+                            notifications::NotificationEvent::ScanCancelled {
+                                job_type: info.job_type.clone(),
+                                library_name: info.library_name.clone(),
+                            },
+                        );
                     } else {
                         error!("[INDEXER] Job {} failed: {}", job_id, err);
                         let _ = job::fail_job(&state.pool, job_id, &err_str).await;
+                        notifications::notify(
+                            state.pool.clone(),
+                            build_failed_event(&info.job_type, info.library_name.clone(), info.book_title.clone(), info.thumbnail_path.clone(), err_str),
+                        );
                     }
                 } else {
                     info!("[INDEXER] Job {} completed", job_id);
+                    let stats = load_scan_stats(&state.pool, job_id).await;
+                    notifications::notify(
+                        state.pool.clone(),
+                        build_completed_event(
+                            &info.job_type,
+                            info.library_name.clone(),
+                            info.book_title.clone(),
+                            info.thumbnail_path.clone(),
+                            stats,
+                            started_at.elapsed().as_secs(),
+                        ),
+                    );
                 }
             }
             Ok(None) => {

crates/notifications/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "notifications"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sqlx.workspace = true
+tokio.workspace = true
+tracing.workspace = true

crates/notifications/src/lib.rs

@@ -0,0 +1,513 @@
+use anyhow::Result;
+use serde::Deserialize;
+use sqlx::PgPool;
+use tracing::{info, warn};
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Deserialize)]
+pub struct TelegramConfig {
+    pub bot_token: String,
+    pub chat_id: String,
+    #[serde(default)]
+    pub enabled: bool,
+    #[serde(default = "default_events")]
+    pub events: EventToggles,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct EventToggles {
+    #[serde(default = "default_true")]
+    pub scan_completed: bool,
+    #[serde(default = "default_true")]
+    pub scan_failed: bool,
+    #[serde(default = "default_true")]
+    pub scan_cancelled: bool,
+    #[serde(default = "default_true")]
+    pub thumbnail_completed: bool,
+    #[serde(default = "default_true")]
+    pub thumbnail_failed: bool,
+    #[serde(default = "default_true")]
+    pub conversion_completed: bool,
+    #[serde(default = "default_true")]
+    pub conversion_failed: bool,
+    #[serde(default = "default_true")]
+    pub metadata_approved: bool,
+    #[serde(default = "default_true")]
+    pub metadata_batch_completed: bool,
+    #[serde(default = "default_true")]
+    pub metadata_batch_failed: bool,
+    #[serde(default = "default_true")]
+    pub metadata_refresh_completed: bool,
+    #[serde(default = "default_true")]
+    pub metadata_refresh_failed: bool,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+fn default_events() -> EventToggles {
+    EventToggles {
+        scan_completed: true,
+        scan_failed: true,
+        scan_cancelled: true,
+        thumbnail_completed: true,
+        thumbnail_failed: true,
+        conversion_completed: true,
+        conversion_failed: true,
+        metadata_approved: true,
+        metadata_batch_completed: true,
+        metadata_batch_failed: true,
+        metadata_refresh_completed: true,
+        metadata_refresh_failed: true,
+    }
+}
+
+/// Load the Telegram config from `app_settings` (key = "telegram").
+/// Returns `None` when the row is missing, disabled, or has empty credentials.
+pub async fn load_telegram_config(pool: &PgPool) -> Option<TelegramConfig> {
+    let row = sqlx::query_scalar::<_, serde_json::Value>(
+        "SELECT value FROM app_settings WHERE key = 'telegram'",
+    )
+    .fetch_optional(pool)
+    .await
+    .ok()??;
+
+    let config: TelegramConfig = serde_json::from_value(row).ok()?;
+
+    if !config.enabled || config.bot_token.is_empty() || config.chat_id.is_empty() {
+        return None;
+    }
+
+    Some(config)
+}
+
+// ---------------------------------------------------------------------------
+// Telegram HTTP
+// ---------------------------------------------------------------------------
+
+fn build_client() -> Result<reqwest::Client> {
+    Ok(reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()?)
+}
+
+async fn send_telegram(config: &TelegramConfig, text: &str) -> Result<()> {
+    let url = format!(
+        "https://api.telegram.org/bot{}/sendMessage",
+        config.bot_token
+    );
+
+    let body = serde_json::json!({
+        "chat_id": config.chat_id,
+        "text": text,
+        "parse_mode": "HTML",
+    });
+
+    let resp = build_client()?.post(&url).json(&body).send().await?;
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let text = resp.text().await.unwrap_or_default();
+        anyhow::bail!("Telegram API returned {status}: {text}");
+    }
+
+    Ok(())
+}
+
+async fn send_telegram_photo(config: &TelegramConfig, caption: &str, photo_path: &str) -> Result<()> {
+    let url = format!(
+        "https://api.telegram.org/bot{}/sendPhoto",
+        config.bot_token
+    );
+
+    let photo_bytes = tokio::fs::read(photo_path).await?;
+    let filename = std::path::Path::new(photo_path)
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .to_string();
+    let mime = if filename.ends_with(".webp") {
+        "image/webp"
+    } else if filename.ends_with(".png") {
+        "image/png"
+    } else {
+        "image/jpeg"
+    };
+
+    let part = reqwest::multipart::Part::bytes(photo_bytes)
+        .file_name(filename)
+        .mime_str(mime)?;
+
+    let form = reqwest::multipart::Form::new()
+        .text("chat_id", config.chat_id.clone())
+        .text("caption", caption.to_string())
+        .text("parse_mode", "HTML")
+        .part("photo", part);
+
+    let resp = build_client()?.post(&url).multipart(form).send().await?;
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let text = resp.text().await.unwrap_or_default();
+        anyhow::bail!("Telegram API returned {status}: {text}");
+    }
+
+    Ok(())
+}
+
+/// Send a test message. Returns the result directly (not fire-and-forget).
+pub async fn send_test_message(config: &TelegramConfig) -> Result<()> {
+    send_telegram(config, "🔔 <b>Stripstream Librarian</b>\nTest notification — connection OK!").await
+}
+
+// ---------------------------------------------------------------------------
+// Notification events
+// ---------------------------------------------------------------------------
+
+pub struct ScanStats {
+    pub scanned_files: usize,
+    pub indexed_files: usize,
+    pub removed_files: usize,
+    pub new_series: usize,
+    pub errors: usize,
+}
+
+pub enum NotificationEvent {
+    // Scan jobs (rebuild, full_rebuild, rescan, scan)
+    ScanCompleted {
+        job_type: String,
+        library_name: Option<String>,
+        stats: ScanStats,
+        duration_seconds: u64,
+    },
+    ScanFailed {
+        job_type: String,
+        library_name: Option<String>,
+        error: String,
+    },
+    ScanCancelled {
+        job_type: String,
+        library_name: Option<String>,
+    },
+    // Thumbnail jobs (thumbnail_rebuild, thumbnail_regenerate)
+    ThumbnailCompleted {
+        job_type: String,
+        library_name: Option<String>,
+        duration_seconds: u64,
+    },
+    ThumbnailFailed {
+        job_type: String,
+        library_name: Option<String>,
+        error: String,
+    },
+    // CBR→CBZ conversion
+    ConversionCompleted {
+        library_name: Option<String>,
+        book_title: Option<String>,
+        thumbnail_path: Option<String>,
+    },
+    ConversionFailed {
+        library_name: Option<String>,
+        book_title: Option<String>,
+        thumbnail_path: Option<String>,
+        error: String,
+    },
+    // Metadata manual approve
+    MetadataApproved {
+        series_name: String,
+        provider: String,
+        thumbnail_path: Option<String>,
+    },
+    // Metadata batch (auto-match)
+    MetadataBatchCompleted {
+        library_name: Option<String>,
+        total_series: i32,
+        processed: i32,
+    },
+    MetadataBatchFailed {
+        library_name: Option<String>,
+        error: String,
+    },
+    // Metadata refresh
+    MetadataRefreshCompleted {
+        library_name: Option<String>,
+        refreshed: i32,
+        unchanged: i32,
+        errors: i32,
+    },
+    MetadataRefreshFailed {
+        library_name: Option<String>,
+        error: String,
+    },
+}
+
+/// Classify an indexer job_type string into the right event constructor category.
+/// Returns "scan", "thumbnail", or "conversion".
+pub fn job_type_category(job_type: &str) -> &'static str {
+    match job_type {
+        "thumbnail_rebuild" | "thumbnail_regenerate" => "thumbnail",
+        "cbr_to_cbz" => "conversion",
+        _ => "scan",
+    }
+}
+
+fn format_event(event: &NotificationEvent) -> String {
+    match event {
+        NotificationEvent::ScanCompleted {
+            job_type,
+            library_name,
+            stats,
+            duration_seconds,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            let duration = format_duration(*duration_seconds);
+            format!(
+                "📚 <b>Scan completed</b>\n\
+                 Library: {lib}\n\
+                 Type: {job_type}\n\
+                 New books: {}\n\
+                 New series: {}\n\
+                 Files scanned: {}\n\
+                 Removed: {}\n\
+                 Errors: {}\n\
+                 Duration: {duration}",
+                stats.indexed_files,
+                stats.new_series,
+                stats.scanned_files,
+                stats.removed_files,
+                stats.errors,
+            )
+        }
+        NotificationEvent::ScanFailed {
+            job_type,
+            library_name,
+            error,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            let err = truncate(error, 200);
+            format!(
+                "❌ <b>Scan failed</b>\n\
+                 Library: {lib}\n\
+                 Type: {job_type}\n\
+                 Error: {err}"
+            )
+        }
+        NotificationEvent::ScanCancelled {
+            job_type,
+            library_name,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            format!(
+                "⏹ <b>Scan cancelled</b>\n\
+                 Library: {lib}\n\
+                 Type: {job_type}"
+            )
+        }
+        NotificationEvent::ThumbnailCompleted {
+            job_type,
+            library_name,
+            duration_seconds,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            let duration = format_duration(*duration_seconds);
+            format!(
+                "🖼 <b>Thumbnails completed</b>\n\
+                 Library: {lib}\n\
+                 Type: {job_type}\n\
+                 Duration: {duration}"
+            )
+        }
+        NotificationEvent::ThumbnailFailed {
+            job_type,
+            library_name,
+            error,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            let err = truncate(error, 200);
+            format!(
+                "❌ <b>Thumbnails failed</b>\n\
+                 Library: {lib}\n\
+                 Type: {job_type}\n\
+                 Error: {err}"
+            )
+        }
+        NotificationEvent::ConversionCompleted {
+            library_name,
+            book_title,
+            ..
+        } => {
+            let lib = library_name.as_deref().unwrap_or("Unknown");
+            let title = book_title.as_deref().unwrap_or("Unknown");
+            format!(
+                "🔄 <b>CBR→CBZ conversion completed</b>\n\
+                 Library: {lib}\n\
+                 Book: {title}"
+            )
+        }
+        NotificationEvent::ConversionFailed {
+            library_name,
+            book_title,
+            error,
+            ..
+        } => {
+            let lib = library_name.as_deref().unwrap_or("Unknown");
+            let title = book_title.as_deref().unwrap_or("Unknown");
+            let err = truncate(error, 200);
+            format!(
+                "❌ <b>CBR→CBZ conversion failed</b>\n\
+                 Library: {lib}\n\
+                 Book: {title}\n\
+                 Error: {err}"
+            )
+        }
+        NotificationEvent::MetadataApproved {
+            series_name,
+            provider,
+            ..
+        } => {
+            format!(
+                "🔗 <b>Metadata linked</b>\n\
+                 Series: {series_name}\n\
+                 Provider: {provider}"
+            )
+        }
+        NotificationEvent::MetadataBatchCompleted {
+            library_name,
+            total_series,
+            processed,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            format!(
+                "🔍 <b>Metadata batch completed</b>\n\
+                 Library: {lib}\n\
+                 Series processed: {processed}/{total_series}"
+            )
+        }
+        NotificationEvent::MetadataBatchFailed {
+            library_name,
+            error,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            let err = truncate(error, 200);
+            format!(
+                "❌ <b>Metadata batch failed</b>\n\
+                 Library: {lib}\n\
+                 Error: {err}"
+            )
+        }
+        NotificationEvent::MetadataRefreshCompleted {
+            library_name,
+            refreshed,
+            unchanged,
+            errors,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            format!(
+                "🔄 <b>Metadata refresh completed</b>\n\
+                 Library: {lib}\n\
+                 Updated: {refreshed}\n\
+                 Unchanged: {unchanged}\n\
+                 Errors: {errors}"
+            )
+        }
+        NotificationEvent::MetadataRefreshFailed {
+            library_name,
+            error,
+        } => {
+            let lib = library_name.as_deref().unwrap_or("All libraries");
+            let err = truncate(error, 200);
+            format!(
+                "❌ <b>Metadata refresh failed</b>\n\
+                 Library: {lib}\n\
+                 Error: {err}"
+            )
+        }
+    }
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() > max {
+        format!("{}…", &s[..max])
+    } else {
+        s.to_string()
+    }
+}
+
+fn format_duration(secs: u64) -> String {
+    if secs < 60 {
+        format!("{secs}s")
+    } else {
+        let m = secs / 60;
+        let s = secs % 60;
+        format!("{m}m{s}s")
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Public entry point — fire & forget
+// ---------------------------------------------------------------------------
+
+/// Returns whether this event type is enabled in the config.
+fn is_event_enabled(config: &TelegramConfig, event: &NotificationEvent) -> bool {
+    match event {
+        NotificationEvent::ScanCompleted { .. } => config.events.scan_completed,
+        NotificationEvent::ScanFailed { .. } => config.events.scan_failed,
+        NotificationEvent::ScanCancelled { .. } => config.events.scan_cancelled,
+        NotificationEvent::ThumbnailCompleted { .. } => config.events.thumbnail_completed,
+        NotificationEvent::ThumbnailFailed { .. } => config.events.thumbnail_failed,
+        NotificationEvent::ConversionCompleted { .. } => config.events.conversion_completed,
+        NotificationEvent::ConversionFailed { .. } => config.events.conversion_failed,
+        NotificationEvent::MetadataApproved { .. } => config.events.metadata_approved,
+        NotificationEvent::MetadataBatchCompleted { .. } => config.events.metadata_batch_completed,
+        NotificationEvent::MetadataBatchFailed { .. } => config.events.metadata_batch_failed,
+        NotificationEvent::MetadataRefreshCompleted { .. } => config.events.metadata_refresh_completed,
+        NotificationEvent::MetadataRefreshFailed { .. } => config.events.metadata_refresh_failed,
+    }
+}
+
+/// Extract thumbnail path from event if present and file exists on disk.
+fn event_thumbnail(event: &NotificationEvent) -> Option<&str> {
+    let path = match event {
+        NotificationEvent::ConversionCompleted { thumbnail_path, .. } => thumbnail_path.as_deref(),
+        NotificationEvent::ConversionFailed { thumbnail_path, .. } => thumbnail_path.as_deref(),
+        NotificationEvent::MetadataApproved { thumbnail_path, .. } => thumbnail_path.as_deref(),
+        _ => None,
+    };
+    path.filter(|p| std::path::Path::new(p).exists())
+}
+
+/// Load config + format + send in a spawned task. Errors are only logged.
+pub fn notify(pool: PgPool, event: NotificationEvent) {
+    tokio::spawn(async move {
+        let config = match load_telegram_config(&pool).await {
+            Some(c) => c,
+            None => return, // disabled or not configured
+        };
+
+        if !is_event_enabled(&config, &event) {
+            return;
+        }
+
+        let text = format_event(&event);
+        let sent = if let Some(photo) = event_thumbnail(&event) {
+            match send_telegram_photo(&config, &text, photo).await {
+                Ok(()) => Ok(()),
+                Err(e) => {
+                    warn!("[TELEGRAM] Photo send failed, falling back to text: {e}");
+                    send_telegram(&config, &text).await
+                }
+            }
+        } else {
+            send_telegram(&config, &text).await
+        };
+
+        match sent {
+            Ok(()) => info!("[TELEGRAM] Notification sent"),
+            Err(e) => warn!("[TELEGRAM] Failed to send notification: {e}"),
+        }
+    });
+}

docs/FEATURES.md

@@ -0,0 +1,310 @@
+# Stripstream Librarian — Features & Business Rules
+
+## Libraries
+
+### Multi-Library Management
+- Create and manage multiple independent libraries, each with its own root path
+- Enable/disable libraries individually
+- Delete a library cascades to all its books, jobs, and metadata
+
+### Scanning & Indexing
+- **Incremental scan**: uses directory mtime tracking to skip unchanged directories
+- **Full rebuild**: force re-walk all directories, ignoring cached mtimes
+- **Rescan**: deep rescan to discover newly supported formats
+- **Two-phase pipeline**:
+  - Phase 1 (Discovery): fast filename-based metadata extraction (no archive I/O)
+  - Phase 2 (Analysis): extract page counts, first page image from archives
+
+### Real-Time Monitoring
+- **Automatic periodic scanning**: configurable interval (default 5 seconds)
+- **Filesystem watcher**: real-time detection of file changes for instant indexing
+- Each can be toggled per library (`monitor_enabled`, `watcher_enabled`)
+
+---
+
+## Books
+
+### Format Support
+- **CBZ** (ZIP-based comic archives)
+- **CBR** (RAR-based comic archives)
+- **PDF**
+- **EPUB**
+- Automatic format detection from file extension and magic bytes
+
+### Metadata Extraction
+- **Title**: derived from filename or external metadata
+- **Series**: derived from directory structure (first directory level under library root)
+- **Volume**: extracted from filename with pattern detection:
+  - `T##` (Tome) — most common for French comics
+  - `Vol.##`, `Vol ##`, `Volume ##`
+  - `###` (standalone number)
+  - `-## ` (dash-separated)
+- **Author(s)**: single scalar and array support
+- **Page count**: extracted from archive analysis
+- **Language**, **kind** (ebook, comic, bd)
+
+### Thumbnails
+- Generated from the first page of each archive
+- Output format configurable: WebP (default), JPEG, PNG
+- Configurable dimensions (default 300×400)
+- Lazy generation: created on first access if missing
+- Bulk operations: rebuild missing or regenerate all
+
+### CBR to CBZ Conversion
+- Convert RAR archives to ZIP format
+- Tracked as background job with progress
+
+---
+
+## Series
+
+### Automatic Aggregation
+- Series derived from directory structure during scanning
+- Books without series grouped as "unclassified"
+
+### Series Metadata
+- Description, publisher, start year, status (`ongoing`, `ended`, `completed`, `on_hold`, `hiatus`)
+- Total volume count (from external providers)
+- Authors (aggregated from books or metadata)
+
+### Filtering & Discovery
+- Filter by: series name (partial match), reading status, series status, metadata provider linkage
+- Sort by: name, reading status, book count
+- **Missing books detection**: identifies gaps in volume numbering within a series
+
+---
+
+## Reading Progress
+
+### Per-Book Tracking
+- Three states: `unread` (default), `reading`, `read`
+- Current page tracking when status is `reading`
+- `last_read_at` timestamp auto-updated
+
+### Series-Level Status
+- Calculated from book statuses:
+  - All read → series `read`
+  - None read → series `unread`
+  - Mixed → series `reading`
+
+### Bulk Operations
+- Mark entire series as read (updates all books)
+
+---
+
+## Search & Discovery
+
+### Full-Text Search
+- PostgreSQL-based (`ILIKE` + `pg_trgm`)
+- Searches across: book titles, series names, authors (scalar and array fields), series metadata authors
+- Case-insensitive partial matching
+- Library-scoped filtering
+
+### Results
+- Book hits: title, authors, series, volume, language, kind
+- Series hits: name, book count, read count, first book (for linking)
+- Processing time included in response
+
+---
+
+## Authors
+
+- Unique author aggregation from books and series metadata
+- Per-author book and series count
+- Searchable by name (partial match)
+- Sortable by name or book count
+
+---
+
+## External Metadata
+
+### Supported Providers
+| Provider | Focus |
+|----------|-------|
+| Google Books | General books (default fallback) |
+| ComicVine | Comics |
+| BedéThèque | Franco-Belgian comics |
+| AniList | Manga/anime |
+| Open Library | General books |
+
+### Provider Configuration
+- Global default provider with library-level override
+- Fallback provider if primary is unavailable
+
+### Matching Workflow
+1. **Search**: query a provider, get candidates with confidence scores
+2. **Match**: link a series to an external result (status `pending`)
+3. **Approve**: validate and sync metadata to series and books
+4. **Reject**: discard a match
+
+### Batch Processing
+- Auto-match all series in a library via `metadata_batch` job
+- Configurable confidence threshold
+- Result statuses: `auto_matched`, `no_results`, `too_many_results`, `low_confidence`, `already_linked`
+
+### Metadata Refresh
+- Update approved links with latest data from providers
+- Change tracking reports per series/book
+- Non-destructive: only updates when provider has new data
+
+### Field Locking
+- Individual book fields can be locked to prevent external sync from overwriting manual edits
+
+---
+
+## External Integrations
+
+### Komga Sync
+- Import reading progress from a Komga server
+- Matches local series/books by name
+- Detailed sync report: matched, already read, newly marked, unmatched
+
+### Prowlarr (Indexer Search)
+- Search Prowlarr for missing volumes in a series
+- Volume pattern matching against release titles
+- Results: title, size, seeders/leechers, download URL, matched missing volumes
+
+### qBittorrent
+- Add torrents directly from Prowlarr search results
+- Connection test endpoint
+
+---
+
+## Page Rendering & Caching
+
+### Page Extraction
+- Render any page from supported archive formats
+- 1-indexed page numbers
+
+### Image Processing
+- Output formats: original, JPEG, PNG, WebP
+- Quality parameter (1–100)
+- Max width parameter (1–2160 px)
+- Configurable resampling filter: lanczos3, nearest, triangle/bilinear
+- Concurrent render limit (default 8) with semaphore
+
+### Caching
+- **LRU in-memory cache**: 512 entries
+- **Disk cache**: SHA256-keyed, two-level directory structure
+- Cache key = hash(path + page + format + quality + width)
+- Configurable cache directory and max size
+- Manual cache clear via settings
+
+---
+
+## Background Jobs
+
+### Job Types
+| Type | Description |
+|------|-------------|
+| `rebuild` | Incremental scan |
+| `full_rebuild` | Full filesystem rescan |
+| `rescan` | Deep rescan for new formats |
+| `thumbnail_rebuild` | Generate missing thumbnails |
+| `thumbnail_regenerate` | Clear and regenerate all thumbnails |
+| `cbr_to_cbz` | Convert RAR to ZIP |
+| `metadata_batch` | Auto-match series to metadata |
+| `metadata_refresh` | Update approved metadata links |
+
+### Job Lifecycle
+- Status flow: `pending` → `running` → `success` | `failed` | `cancelled`
+- Intermediate statuses: `extracting_pages`, `generating_thumbnails`
+- Real-time progress via **Server-Sent Events** (SSE)
+- Per-file error tracking (non-fatal: job continues on errors)
+- Cancellation support for pending/running jobs
+
+### Progress Tracking
+- Percentage (0–100), current file, processed/total counts
+- Timing: started_at, finished_at, phase2_started_at
+- Stats JSON blob with job-specific metrics
+
+---
+
+## Authentication & Security
+
+### Token System
+- **Bootstrap token**: admin token via `API_BOOTSTRAP_TOKEN` env var
+- **API tokens**: create, list, revoke with scopes
+- Token format: `stl_{prefix}_{secret}` with Argon2 hashing
+- Expiration dates, last usage tracking, revocation
+
+### Access Control
+- **Two scopes**: `admin` (full access) and `read` (read-only)
+- Route-level middleware enforcement
+- Rate limiting: configurable sliding window (default 120 req/s)
+
+---
+
+## Backoffice (Web UI)
+
+### Dashboard
+- Statistics cards: books, series, authors, libraries
+- Donut charts: reading status breakdown, format distribution
+- Bar charts: books per language
+- Per-library reading progress bars
+- Top series by book/page count
+- Monthly addition timeline
+- Metadata coverage stats
+
+### Pages
+- **Libraries**: list, create, delete, configure monitoring and metadata provider
+- **Books**: global list with filtering/sorting, detail view with metadata and page rendering
+- **Series**: global list, per-library view, detail with metadata management
+- **Authors**: list with book/series counts, detail with author's books
+- **Jobs**: history, live progress via SSE, error details
+- **Tokens**: create, list, revoke API tokens
+- **Settings**: image processing, cache, thumbnails, external services (Prowlarr, qBittorrent)
+
+### Interactive Features
+- Real-time search with suggestions
+- Metadata search and matching modals
+- Prowlarr search modal for missing volumes
+- Folder browser/picker for library paths
+- Book/series editing forms
+- Quick reading status toggles
+- CBR to CBZ conversion trigger
+
+---
+
+## API
+
+### Documentation
+- OpenAPI/Swagger UI available at `/swagger-ui`
+- Health check (`/health`), readiness (`/ready`), Prometheus metrics (`/metrics`)
+
+### Public Endpoints (no auth)
+- `GET /health`, `GET /ready`, `GET /metrics`, `GET /swagger-ui`
+
+### Read Endpoints (read scope)
+- Libraries, books, series, authors listing and detail
+- Book pages and thumbnails
+- Reading progress get/update
+- Full-text search, collection statistics
+
+### Admin Endpoints (admin scope)
+- Library CRUD and configuration
+- Book metadata editing, CBR conversion
+- Series metadata editing
+- Indexing job management (trigger, cancel, stream)
+- API token management
+- Metadata operations (search, match, approve, reject, batch, refresh)
+- External integrations (Prowlarr, qBittorrent, Komga)
+- Application settings and cache management
+
+---
+
+## Database
+
+### Key Design Decisions
+- PostgreSQL with `pg_trgm` for full-text search (no external search engine)
+- All deletions cascade from libraries
+- Unique constraints: file paths, token prefixes, metadata links (library + series + provider)
+- Directory mtime caching for incremental scan optimization
+- Connection pool: 10 (API), 20 (indexer)
+
+### Archive Resilience
+- CBZ: fallback streaming reader if central directory corrupted
+- CBR: RAR extraction via system `unar`, fallback to CBZ parsing
+- PDF: `pdfinfo` for page count, `pdftoppm` for rendering
+- EPUB: ZIP-based extraction
+- FD exhaustion detection: aborts if too many consecutive IO errors

infra/migrations/0048_add_telegram_settings.sql

@@ -0,0 +1,3 @@
+INSERT INTO app_settings (key, value) VALUES
+    ('telegram', '{"bot_token": "", "chat_id": "", "enabled": false, "events": {"job_completed": true, "job_failed": true, "job_cancelled": true, "metadata_approved": true}}')
+ON CONFLICT DO NOTHING;

infra/migrations/0049_update_telegram_events.sql

@@ -0,0 +1,8 @@
+-- Update telegram events from 4 generic toggles to 12 granular toggles
+UPDATE app_settings
+SET value = jsonb_set(
+    value,
+    '{events}',
+    '{"scan_completed": true, "scan_failed": true, "scan_cancelled": true, "thumbnail_completed": true, "thumbnail_failed": true, "conversion_completed": true, "conversion_failed": true, "metadata_approved": true, "metadata_batch_completed": true, "metadata_batch_failed": true, "metadata_refresh_completed": true, "metadata_refresh_failed": true}'::jsonb
+)
+WHERE key = 'telegram';