chore: bump version to 1.28.0

- Metadata refresh now skips series with ended/cancelled status
- Add xs size to Button component
- Unify view/cancel button sizes (h-7) with icons (eye & cross)

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

Cargo.lock

@@ -64,7 +64,7 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "api"
-version = "1.25.0"
+version = "1.28.0"
 dependencies = [
  "anyhow",
  "argon2",
@@ -1233,7 +1233,7 @@ dependencies = [
 
 [[package]]
 name = "indexer"
-version = "1.25.0"
+version = "1.28.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -1667,7 +1667,7 @@ dependencies = [
 
 [[package]]
 name = "notifications"
-version = "1.25.0"
+version = "1.28.0"
 dependencies = [
  "anyhow",
  "reqwest",
@@ -1786,7 +1786,7 @@ dependencies = [
 
 [[package]]
 name = "parsers"
-version = "1.25.0"
+version = "1.28.0"
 dependencies = [
  "anyhow",
  "flate2",
@@ -2923,7 +2923,7 @@ dependencies = [
 
 [[package]]
 name = "stripstream-core"
-version = "1.25.0"
+version = "1.28.0"
 dependencies = [
  "anyhow",
  "serde",

Cargo.toml

@@ -10,7 +10,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "1.25.0"
+version = "1.28.0"
 license = "MIT"
 
 [workspace.dependencies]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julien Froidefond
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -287,4 +287,4 @@ volumes:
 
 ## License
 
-[Your License Here]
+This project is licensed under the [MIT License](LICENSE).

apps/api/src/job_poller.rs

@@ -0,0 +1,134 @@
+use std::time::Duration;
+
+use sqlx::{PgPool, Row};
+use tracing::{error, info, trace};
+use uuid::Uuid;
+
+use crate::{metadata_batch, metadata_refresh};
+
+/// Poll for pending API-only jobs (`metadata_batch`, `metadata_refresh`) and process them.
+/// This mirrors the indexer's worker loop but for job types handled by the API.
+pub async fn run_job_poller(pool: PgPool, interval_seconds: u64) {
+    let wait = Duration::from_secs(interval_seconds.max(1));
+
+    loop {
+        match claim_next_api_job(&pool).await {
+            Ok(Some((job_id, job_type, library_id))) => {
+                info!("[JOB_POLLER] Claimed {job_type} job {job_id} library={library_id}");
+
+                let pool_clone = pool.clone();
+                let library_name: Option<String> =
+                    sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
+                        .bind(library_id)
+                        .fetch_optional(&pool)
+                        .await
+                        .ok()
+                        .flatten();
+
+                tokio::spawn(async move {
+                    let result = match job_type.as_str() {
+                        "metadata_refresh" => {
+                            metadata_refresh::process_metadata_refresh(
+                                &pool_clone,
+                                job_id,
+                                library_id,
+                            )
+                            .await
+                        }
+                        "metadata_batch" => {
+                            metadata_batch::process_metadata_batch(
+                                &pool_clone,
+                                job_id,
+                                library_id,
+                            )
+                            .await
+                        }
+                        _ => Err(format!("Unknown API job type: {job_type}")),
+                    };
+
+                    if let Err(e) = result {
+                        error!("[JOB_POLLER] {job_type} job {job_id} failed: {e}");
+                        let _ = sqlx::query(
+                            "UPDATE index_jobs SET status = 'failed', error_opt = $2, finished_at = NOW() WHERE id = $1",
+                        )
+                        .bind(job_id)
+                        .bind(e.to_string())
+                        .execute(&pool_clone)
+                        .await;
+
+                        match job_type.as_str() {
+                            "metadata_refresh" => {
+                                notifications::notify(
+                                    pool_clone,
+                                    notifications::NotificationEvent::MetadataRefreshFailed {
+                                        library_name,
+                                        error: e.to_string(),
+                                    },
+                                );
+                            }
+                            "metadata_batch" => {
+                                notifications::notify(
+                                    pool_clone,
+                                    notifications::NotificationEvent::MetadataBatchFailed {
+                                        library_name,
+                                        error: e.to_string(),
+                                    },
+                                );
+                            }
+                            _ => {}
+                        }
+                    }
+                });
+            }
+            Ok(None) => {
+                trace!("[JOB_POLLER] No pending API jobs, waiting...");
+                tokio::time::sleep(wait).await;
+            }
+            Err(err) => {
+                error!("[JOB_POLLER] Error claiming job: {err}");
+                tokio::time::sleep(wait).await;
+            }
+        }
+    }
+}
+
+const API_JOB_TYPES: &[&str] = &["metadata_batch", "metadata_refresh"];
+
+async fn claim_next_api_job(pool: &PgPool) -> Result<Option<(Uuid, String, Uuid)>, sqlx::Error> {
+    let mut tx = pool.begin().await?;
+
+    let row = sqlx::query(
+        r#"
+        SELECT id, type, library_id
+        FROM index_jobs
+        WHERE status = 'pending'
+          AND type = ANY($1)
+          AND library_id IS NOT NULL
+        ORDER BY created_at ASC
+        FOR UPDATE SKIP LOCKED
+        LIMIT 1
+        "#,
+    )
+    .bind(API_JOB_TYPES)
+    .fetch_optional(&mut *tx)
+    .await?;
+
+    let Some(row) = row else {
+        tx.commit().await?;
+        return Ok(None);
+    };
+
+    let id: Uuid = row.get("id");
+    let job_type: String = row.get("type");
+    let library_id: Uuid = row.get("library_id");
+
+    sqlx::query(
+        "UPDATE index_jobs SET status = 'running', started_at = NOW(), error_opt = NULL WHERE id = $1",
+    )
+    .bind(id)
+    .execute(&mut *tx)
+    .await?;
+
+    tx.commit().await?;
+    Ok(Some((id, job_type, library_id)))
+}

apps/api/src/main.rs

@@ -4,6 +4,7 @@ mod books;
 mod error;
 mod handlers;
 mod index_jobs;
+mod job_poller;
 mod komga;
 mod libraries;
 mod metadata;
@@ -159,6 +160,9 @@ async fn main() -> anyhow::Result<()> {
             auth::require_read,
         ));
 
+    // Clone pool before state is moved into the router
+    let poller_pool = state.pool.clone();
+
     let app = Router::new()
         .route("/health", get(handlers::health))
         .route("/ready", get(handlers::ready))
@@ -170,6 +174,11 @@ async fn main() -> anyhow::Result<()> {
         .layer(middleware::from_fn_with_state(state.clone(), api_middleware::request_counter))
         .with_state(state);
 
+    // Start background poller for API-only jobs (metadata_batch, metadata_refresh)
+    tokio::spawn(async move {
+        job_poller::run_job_poller(poller_pool, 5).await;
+    });
+
     let listener = tokio::net::TcpListener::bind(&config.listen_addr).await?;
     info!(addr = %config.listen_addr, "api listening");
     axum::serve(listener, app).await?;

apps/api/src/metadata_batch.rs

@@ -115,14 +115,14 @@ pub async fn start_batch(
 
     let job_id = Uuid::new_v4();
     sqlx::query(
-        "INSERT INTO index_jobs (id, library_id, type, status) VALUES ($1, $2, 'metadata_batch', 'pending')",
+        "INSERT INTO index_jobs (id, library_id, type, status, started_at) VALUES ($1, $2, 'metadata_batch', 'running', NOW())",
     )
     .bind(job_id)
     .bind(library_id)
     .execute(&state.pool)
     .await?;
 
-    // Spawn the background processing task
+    // Spawn the background processing task (status already 'running' to avoid poller race)
     let pool = state.pool.clone();
     let library_name: Option<String> = sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
         .bind(library_id)
@@ -313,7 +313,7 @@ pub async fn get_batch_results(
 // Background processing
 // ---------------------------------------------------------------------------
 
-async fn process_metadata_batch(
+pub(crate) async fn process_metadata_batch(
     pool: &PgPool,
     job_id: Uuid,
     library_id: Uuid,

apps/api/src/metadata_refresh.rs

@@ -110,9 +110,16 @@ pub async fn start_refresh(
         })));
     }
 
-    // Check there are approved links to refresh
+    // Check there are approved links to refresh (only ongoing series)
     let link_count: i64 = sqlx::query_scalar(
-        "SELECT COUNT(*) FROM external_metadata_links WHERE library_id = $1 AND status = 'approved'",
+        r#"
+        SELECT COUNT(*) FROM external_metadata_links eml
+        LEFT JOIN series_metadata sm
+            ON sm.library_id = eml.library_id AND sm.name = eml.series_name
+        WHERE eml.library_id = $1
+          AND eml.status = 'approved'
+          AND COALESCE(sm.status, 'ongoing') NOT IN ('ended', 'cancelled')
+        "#,
     )
     .bind(library_id)
     .fetch_one(&state.pool)
@@ -124,14 +131,14 @@ pub async fn start_refresh(
 
     let job_id = Uuid::new_v4();
     sqlx::query(
-        "INSERT INTO index_jobs (id, library_id, type, status) VALUES ($1, $2, 'metadata_refresh', 'pending')",
+        "INSERT INTO index_jobs (id, library_id, type, status, started_at) VALUES ($1, $2, 'metadata_refresh', 'running', NOW())",
     )
     .bind(job_id)
     .bind(library_id)
     .execute(&state.pool)
     .await?;
 
-    // Spawn the background processing task
+    // Spawn the background processing task (status already 'running' to avoid poller race)
     let pool = state.pool.clone();
     let library_name: Option<String> = sqlx::query_scalar("SELECT name FROM libraries WHERE id = $1")
         .bind(library_id)
@@ -222,7 +229,7 @@ pub async fn get_refresh_report(
 // Background processing
 // ---------------------------------------------------------------------------
 
-async fn process_metadata_refresh(
+pub(crate) async fn process_metadata_refresh(
     pool: &PgPool,
     job_id: Uuid,
     library_id: Uuid,
@@ -234,13 +241,17 @@ async fn process_metadata_refresh(
         .await
         .map_err(|e| e.to_string())?;
 
-    // Get all approved links for this library
+    // Get approved links for this library, only for ongoing series (not ended/cancelled)
     let links: Vec<(Uuid, String, String, String)> = sqlx::query_as(
         r#"
-        SELECT id, series_name, provider, external_id
-        FROM external_metadata_links
-        WHERE library_id = $1 AND status = 'approved'
-        ORDER BY series_name
+        SELECT eml.id, eml.series_name, eml.provider, eml.external_id
+        FROM external_metadata_links eml
+        LEFT JOIN series_metadata sm
+            ON sm.library_id = eml.library_id AND sm.name = eml.series_name
+        WHERE eml.library_id = $1
+          AND eml.status = 'approved'
+          AND COALESCE(sm.status, 'ongoing') NOT IN ('ended', 'cancelled')
+        ORDER BY eml.series_name
         "#,
     )
     .bind(library_id)

apps/api/src/stats.rs

@@ -1,10 +1,19 @@
-use axum::{extract::State, Json};
-use serde::Serialize;
+use axum::{
+    extract::{Query, State},
+    Json,
+};
+use serde::{Deserialize, Serialize};
 use sqlx::Row;
-use utoipa::ToSchema;
+use utoipa::{IntoParams, ToSchema};
 
 use crate::{error::ApiError, state::AppState};
 
+#[derive(Deserialize, IntoParams)]
+pub struct StatsQuery {
+    /// Granularity: "day", "week" or "month" (default: "month")
+    pub period: Option<String>,
+}
+
 #[derive(Serialize, ToSchema)]
 pub struct StatsOverview {
     pub total_books: i64,
@@ -97,6 +106,15 @@ pub struct MonthlyReading {
     pub books_read: i64,
 }
 
+#[derive(Serialize, ToSchema)]
+pub struct JobTimePoint {
+    pub label: String,
+    pub scan: i64,
+    pub rebuild: i64,
+    pub thumbnail: i64,
+    pub other: i64,
+}
+
 #[derive(Serialize, ToSchema)]
 pub struct StatsResponse {
     pub overview: StatsOverview,
@@ -109,6 +127,7 @@ pub struct StatsResponse {
     pub by_library: Vec<LibraryStats>,
     pub top_series: Vec<TopSeries>,
     pub additions_over_time: Vec<MonthlyAdditions>,
+    pub jobs_over_time: Vec<JobTimePoint>,
     pub metadata: MetadataStats,
 }
 
@@ -117,6 +136,7 @@ pub struct StatsResponse {
     get,
     path = "/stats",
     tag = "stats",
+    params(StatsQuery),
     responses(
         (status = 200, body = StatsResponse),
         (status = 401, description = "Unauthorized"),
@@ -125,7 +145,9 @@ pub struct StatsResponse {
 )]
 pub async fn get_stats(
     State(state): State<AppState>,
+    Query(query): Query<StatsQuery>,
 ) -> Result<Json<StatsResponse>, ApiError> {
+    let period = query.period.as_deref().unwrap_or("month");
     // Overview + reading status in one query
     let overview_row = sqlx::query(
         r#"
@@ -285,20 +307,74 @@ pub async fn get_stats(
         })
         .collect();
 
-    // Additions over time (last 12 months)
-    let additions_rows = sqlx::query(
-        r#"
-        SELECT
-            TO_CHAR(DATE_TRUNC('month', created_at), 'YYYY-MM') AS month,
-            COUNT(*) AS books_added
-        FROM books
-        WHERE created_at >= DATE_TRUNC('month', NOW()) - INTERVAL '11 months'
-        GROUP BY DATE_TRUNC('month', created_at)
-        ORDER BY month ASC
-        "#,
-    )
-    .fetch_all(&state.pool)
-    .await?;
+    // Additions over time (with gap filling)
+    let additions_rows = match period {
+        "day" => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM-DD') AS month,
+                    COALESCE(cnt.books_added, 0) AS books_added
+                FROM generate_series(CURRENT_DATE - INTERVAL '6 days', CURRENT_DATE, '1 day') AS d(dt)
+                LEFT JOIN (
+                    SELECT created_at::date AS dt, COUNT(*) AS books_added
+                    FROM books
+                    WHERE created_at >= CURRENT_DATE - INTERVAL '6 days'
+                    GROUP BY created_at::date
+                ) cnt ON cnt.dt = d.dt
+                ORDER BY month ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+        "week" => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM-DD') AS month,
+                    COALESCE(cnt.books_added, 0) AS books_added
+                FROM generate_series(
+                    DATE_TRUNC('week', NOW() - INTERVAL '2 months'),
+                    DATE_TRUNC('week', NOW()),
+                    '1 week'
+                ) AS d(dt)
+                LEFT JOIN (
+                    SELECT DATE_TRUNC('week', created_at) AS dt, COUNT(*) AS books_added
+                    FROM books
+                    WHERE created_at >= DATE_TRUNC('week', NOW() - INTERVAL '2 months')
+                    GROUP BY DATE_TRUNC('week', created_at)
+                ) cnt ON cnt.dt = d.dt
+                ORDER BY month ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+        _ => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM') AS month,
+                    COALESCE(cnt.books_added, 0) AS books_added
+                FROM generate_series(
+                    DATE_TRUNC('month', NOW()) - INTERVAL '11 months',
+                    DATE_TRUNC('month', NOW()),
+                    '1 month'
+                ) AS d(dt)
+                LEFT JOIN (
+                    SELECT DATE_TRUNC('month', created_at) AS dt, COUNT(*) AS books_added
+                    FROM books
+                    WHERE created_at >= DATE_TRUNC('month', NOW()) - INTERVAL '11 months'
+                    GROUP BY DATE_TRUNC('month', created_at)
+                ) cnt ON cnt.dt = d.dt
+                ORDER BY month ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+    };
 
     let additions_over_time: Vec<MonthlyAdditions> = additions_rows
         .iter()
@@ -409,21 +485,77 @@ pub async fn get_stats(
         })
         .collect();
 
-    // Reading activity over time (last 12 months)
-    let reading_time_rows = sqlx::query(
-        r#"
-        SELECT
-            TO_CHAR(DATE_TRUNC('month', brp.last_read_at), 'YYYY-MM') AS month,
-            COUNT(*) AS books_read
-        FROM book_reading_progress brp
-        WHERE brp.status = 'read'
-          AND brp.last_read_at >= DATE_TRUNC('month', NOW()) - INTERVAL '11 months'
-        GROUP BY DATE_TRUNC('month', brp.last_read_at)
-        ORDER BY month ASC
-        "#,
-    )
-    .fetch_all(&state.pool)
-    .await?;
+    // Reading activity over time (with gap filling)
+    let reading_time_rows = match period {
+        "day" => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM-DD') AS month,
+                    COALESCE(cnt.books_read, 0) AS books_read
+                FROM generate_series(CURRENT_DATE - INTERVAL '6 days', CURRENT_DATE, '1 day') AS d(dt)
+                LEFT JOIN (
+                    SELECT brp.last_read_at::date AS dt, COUNT(*) AS books_read
+                    FROM book_reading_progress brp
+                    WHERE brp.status = 'read'
+                      AND brp.last_read_at >= CURRENT_DATE - INTERVAL '6 days'
+                    GROUP BY brp.last_read_at::date
+                ) cnt ON cnt.dt = d.dt
+                ORDER BY month ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+        "week" => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM-DD') AS month,
+                    COALESCE(cnt.books_read, 0) AS books_read
+                FROM generate_series(
+                    DATE_TRUNC('week', NOW() - INTERVAL '2 months'),
+                    DATE_TRUNC('week', NOW()),
+                    '1 week'
+                ) AS d(dt)
+                LEFT JOIN (
+                    SELECT DATE_TRUNC('week', brp.last_read_at) AS dt, COUNT(*) AS books_read
+                    FROM book_reading_progress brp
+                    WHERE brp.status = 'read'
+                      AND brp.last_read_at >= DATE_TRUNC('week', NOW() - INTERVAL '2 months')
+                    GROUP BY DATE_TRUNC('week', brp.last_read_at)
+                ) cnt ON cnt.dt = d.dt
+                ORDER BY month ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+        _ => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM') AS month,
+                    COALESCE(cnt.books_read, 0) AS books_read
+                FROM generate_series(
+                    DATE_TRUNC('month', NOW()) - INTERVAL '11 months',
+                    DATE_TRUNC('month', NOW()),
+                    '1 month'
+                ) AS d(dt)
+                LEFT JOIN (
+                    SELECT DATE_TRUNC('month', brp.last_read_at) AS dt, COUNT(*) AS books_read
+                    FROM book_reading_progress brp
+                    WHERE brp.status = 'read'
+                      AND brp.last_read_at >= DATE_TRUNC('month', NOW()) - INTERVAL '11 months'
+                    GROUP BY DATE_TRUNC('month', brp.last_read_at)
+                ) cnt ON cnt.dt = d.dt
+                ORDER BY month ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+    };
 
     let reading_over_time: Vec<MonthlyReading> = reading_time_rows
         .iter()
@@ -433,6 +565,125 @@ pub async fn get_stats(
         })
         .collect();
 
+    // Jobs over time (with gap filling, grouped by type category)
+    let jobs_rows = match period {
+        "day" => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM-DD') AS label,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'scan'), 0)::BIGINT AS scan,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'rebuild'), 0)::BIGINT AS rebuild,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'thumbnail'), 0)::BIGINT AS thumbnail,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'other'), 0)::BIGINT AS other
+                FROM generate_series(CURRENT_DATE - INTERVAL '6 days', CURRENT_DATE, '1 day') AS d(dt)
+                LEFT JOIN (
+                    SELECT
+                        finished_at::date AS dt,
+                        CASE
+                            WHEN type = 'scan' THEN 'scan'
+                            WHEN type IN ('rebuild', 'full_rebuild', 'rescan') THEN 'rebuild'
+                            WHEN type IN ('thumbnail_rebuild', 'thumbnail_regenerate') THEN 'thumbnail'
+                            ELSE 'other'
+                        END AS cat,
+                        COUNT(*) AS c
+                    FROM index_jobs
+                    WHERE status IN ('success', 'failed')
+                      AND finished_at >= CURRENT_DATE - INTERVAL '6 days'
+                    GROUP BY finished_at::date, cat
+                ) cnt ON cnt.dt = d.dt
+                GROUP BY d.dt
+                ORDER BY label ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+        "week" => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM-DD') AS label,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'scan'), 0)::BIGINT AS scan,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'rebuild'), 0)::BIGINT AS rebuild,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'thumbnail'), 0)::BIGINT AS thumbnail,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'other'), 0)::BIGINT AS other
+                FROM generate_series(
+                    DATE_TRUNC('week', NOW() - INTERVAL '2 months'),
+                    DATE_TRUNC('week', NOW()),
+                    '1 week'
+                ) AS d(dt)
+                LEFT JOIN (
+                    SELECT
+                        DATE_TRUNC('week', finished_at) AS dt,
+                        CASE
+                            WHEN type = 'scan' THEN 'scan'
+                            WHEN type IN ('rebuild', 'full_rebuild', 'rescan') THEN 'rebuild'
+                            WHEN type IN ('thumbnail_rebuild', 'thumbnail_regenerate') THEN 'thumbnail'
+                            ELSE 'other'
+                        END AS cat,
+                        COUNT(*) AS c
+                    FROM index_jobs
+                    WHERE status IN ('success', 'failed')
+                      AND finished_at >= DATE_TRUNC('week', NOW() - INTERVAL '2 months')
+                    GROUP BY DATE_TRUNC('week', finished_at), cat
+                ) cnt ON cnt.dt = d.dt
+                GROUP BY d.dt
+                ORDER BY label ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+        _ => {
+            sqlx::query(
+                r#"
+                SELECT
+                    TO_CHAR(d.dt, 'YYYY-MM') AS label,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'scan'), 0)::BIGINT AS scan,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'rebuild'), 0)::BIGINT AS rebuild,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'thumbnail'), 0)::BIGINT AS thumbnail,
+                    COALESCE(SUM(cnt.c) FILTER (WHERE cnt.cat = 'other'), 0)::BIGINT AS other
+                FROM generate_series(
+                    DATE_TRUNC('month', NOW()) - INTERVAL '11 months',
+                    DATE_TRUNC('month', NOW()),
+                    '1 month'
+                ) AS d(dt)
+                LEFT JOIN (
+                    SELECT
+                        DATE_TRUNC('month', finished_at) AS dt,
+                        CASE
+                            WHEN type = 'scan' THEN 'scan'
+                            WHEN type IN ('rebuild', 'full_rebuild', 'rescan') THEN 'rebuild'
+                            WHEN type IN ('thumbnail_rebuild', 'thumbnail_regenerate') THEN 'thumbnail'
+                            ELSE 'other'
+                        END AS cat,
+                        COUNT(*) AS c
+                    FROM index_jobs
+                    WHERE status IN ('success', 'failed')
+                      AND finished_at >= DATE_TRUNC('month', NOW()) - INTERVAL '11 months'
+                    GROUP BY DATE_TRUNC('month', finished_at), cat
+                ) cnt ON cnt.dt = d.dt
+                GROUP BY d.dt
+                ORDER BY label ASC
+                "#,
+            )
+            .fetch_all(&state.pool)
+            .await?
+        }
+    };
+
+    let jobs_over_time: Vec<JobTimePoint> = jobs_rows
+        .iter()
+        .map(|r| JobTimePoint {
+            label: r.get("label"),
+            scan: r.get("scan"),
+            rebuild: r.get("rebuild"),
+            thumbnail: r.get("thumbnail"),
+            other: r.get("other"),
+        })
+        .collect();
+
     Ok(Json(StatsResponse {
         overview,
         reading_status,
@@ -444,6 +695,7 @@ pub async fn get_stats(
         by_library,
         top_series,
         additions_over_time,
+        jobs_over_time,
         metadata,
     }))
 }

apps/backoffice/app/components/DashboardCharts.tsx

@@ -3,7 +3,7 @@
 import {
   PieChart, Pie, Cell, ResponsiveContainer, Tooltip,
   BarChart, Bar, XAxis, YAxis, CartesianGrid,
-  AreaChart, Area,
+  AreaChart, Area, Line, LineChart,
   Legend,
 } from "recharts";
 
@@ -186,3 +186,46 @@ export function RcHorizontalBar({
     </ResponsiveContainer>
   );
 }
+
+// ---------------------------------------------------------------------------
+// Multi-line chart (jobs over time)
+// ---------------------------------------------------------------------------
+
+export function RcMultiLineChart({
+  data,
+  lines,
+  noDataLabel,
+}: {
+  data: Record<string, unknown>[];
+  lines: { key: string; label: string; color: string }[];
+  noDataLabel?: string;
+}) {
+  const hasData = data.some((d) => lines.some((l) => (d[l.key] as number) > 0));
+  if (data.length === 0 || !hasData)
+    return <p className="text-muted-foreground text-sm text-center py-8">{noDataLabel}</p>;
+
+  return (
+    <ResponsiveContainer width="100%" height={180}>
+      <LineChart data={data} margin={{ top: 5, right: 5, bottom: 0, left: -20 }}>
+        <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="var(--color-border)" opacity={0.3} />
+        <XAxis dataKey="label" tick={{ fontSize: 11, fill: "var(--color-muted-foreground)" }} axisLine={false} tickLine={false} />
+        <YAxis tick={{ fontSize: 11, fill: "var(--color-muted-foreground)" }} axisLine={false} tickLine={false} allowDecimals={false} />
+        <Tooltip
+          contentStyle={{ backgroundColor: "var(--color-card)", border: "1px solid var(--color-border)", borderRadius: 8, fontSize: 12 }}
+        />
+        <Legend wrapperStyle={{ fontSize: 11 }} />
+        {lines.map((l) => (
+          <Line
+            key={l.key}
+            type="monotone"
+            dataKey={l.key}
+            name={l.label}
+            stroke={l.color}
+            strokeWidth={2}
+            dot={{ r: 3, fill: l.color }}
+          />
+        ))}
+      </LineChart>
+    </ResponsiveContainer>
+  );
+}

apps/backoffice/app/components/JobRow.tsx

@@ -4,7 +4,7 @@ import { useState } from "react";
 import Link from "next/link";
 import { useTranslation } from "../../lib/i18n/context";
 import { JobProgress } from "./JobProgress";
-import { StatusBadge, JobTypeBadge, Button, MiniProgressBar, Icon } from "./ui";
+import { StatusBadge, JobTypeBadge, Button, MiniProgressBar, Icon, Tooltip } from "./ui";
 
 interface JobRowProps {
   job: {
@@ -21,6 +21,7 @@ interface JobRowProps {
       indexed_files: number;
       removed_files: number;
       errors: number;
+      refreshed?: number;
     } | null;
     progress_percent: number | null;
     processed_files: number | null;
@@ -117,49 +118,74 @@ export function JobRow({ job, libraryName, highlighted, onCancel, formatDate, fo
               <div className="flex items-center gap-3 text-xs">
                 {/* Files: indexed count */}
                 {indexed > 0 && (
-                  <span className="inline-flex items-center gap-1 text-success" title={t("jobRow.filesIndexed", { count: indexed })}>
-                    <Icon name="document" size="sm" />
-                    {indexed}
-                  </span>
+                  <Tooltip label={t("jobRow.filesIndexed", { count: indexed })}>
+                    <span className="inline-flex items-center gap-1 text-success">
+                      <Icon name="document" size="sm" />
+                      {indexed}
+                    </span>
+                  </Tooltip>
                 )}
                 {/* Removed files */}
                 {removed > 0 && (
-                  <span className="inline-flex items-center gap-1 text-warning" title={t("jobRow.filesRemoved", { count: removed })}>
-                    <Icon name="trash" size="sm" />
-                    {removed}
-                  </span>
+                  <Tooltip label={t("jobRow.filesRemoved", { count: removed })}>
+                    <span className="inline-flex items-center gap-1 text-warning">
+                      <Icon name="trash" size="sm" />
+                      {removed}
+                    </span>
+                  </Tooltip>
                 )}
                 {/* Thumbnails */}
                 {hasThumbnailPhase && job.total_files != null && job.total_files > 0 && (
-                  <span className="inline-flex items-center gap-1 text-primary" title={t("jobRow.thumbnailsGenerated", { count: job.total_files })}>
-                    <Icon name="image" size="sm" />
-                    {job.total_files}
-                  </span>
+                  <Tooltip label={t("jobRow.thumbnailsGenerated", { count: job.total_files })}>
+                    <span className="inline-flex items-center gap-1 text-primary">
+                      <Icon name="image" size="sm" />
+                      {job.total_files}
+                    </span>
+                  </Tooltip>
                 )}
                 {/* Metadata batch: series processed */}
                 {isMetadataBatch && job.total_files != null && job.total_files > 0 && (
-                  <span className="inline-flex items-center gap-1 text-info" title={t("jobRow.metadataProcessed", { count: job.total_files })}>
-                    <Icon name="tag" size="sm" />
-                    {job.total_files}
-                  </span>
+                  <Tooltip label={t("jobRow.metadataProcessed", { count: job.total_files })}>
+                    <span className="inline-flex items-center gap-1 text-info">
+                      <Icon name="tag" size="sm" />
+                      {job.total_files}
+                    </span>
+                  </Tooltip>
                 )}
-                {/* Metadata refresh: links refreshed */}
+                {/* Metadata refresh: total links + refreshed count */}
                 {isMetadataRefresh && job.total_files != null && job.total_files > 0 && (
-                  <span className="inline-flex items-center gap-1 text-info" title={t("jobRow.metadataRefreshed", { count: job.total_files })}>
-                    <Icon name="tag" size="sm" />
-                    {job.total_files}
-                  </span>
+                  <Tooltip label={t("jobRow.metadataLinks", { count: job.total_files })}>
+                    <span className="inline-flex items-center gap-1 text-info">
+                      <Icon name="tag" size="sm" />
+                      {job.total_files}
+                    </span>
+                  </Tooltip>
+                )}
+                {isMetadataRefresh && job.stats_json?.refreshed != null && job.stats_json.refreshed > 0 && (
+                  <Tooltip label={t("jobRow.metadataRefreshed", { count: job.stats_json.refreshed })}>
+                    <span className="inline-flex items-center gap-1 text-success">
+                      <Icon name="refresh" size="sm" />
+                      {job.stats_json.refreshed}
+                    </span>
+                  </Tooltip>
                 )}
                 {/* Errors */}
                 {errors > 0 && (
-                  <span className="inline-flex items-center gap-1 text-error" title={t("jobRow.errors", { count: errors })}>
-                    <Icon name="warning" size="sm" />
-                    {errors}
-                  </span>
+                  <Tooltip label={t("jobRow.errors", { count: errors })}>
+                    <span className="inline-flex items-center gap-1 text-error">
+                      <Icon name="warning" size="sm" />
+                      {errors}
+                    </span>
+                  </Tooltip>
                 )}
                 {/* Scanned only (no other stats) */}
                 {indexed === 0 && removed === 0 && errors === 0 && !hasThumbnailPhase && !isMetadataBatch && !isMetadataRefresh && scanned > 0 && (
-                  <span className="text-sm text-muted-foreground">{t("jobRow.scanned", { count: scanned })}</span>
+                  <Tooltip label={t("jobRow.scanned", { count: scanned })}>
+                    <span className="inline-flex items-center gap-1 text-muted-foreground">
+                      <Icon name="search" size="sm" />
+                      {scanned}
+                    </span>
+                  </Tooltip>
                 )}
                 {/* Nothing to show */}
                 {indexed === 0 && removed === 0 && errors === 0 && scanned === 0 && !hasThumbnailPhase && !isMetadataBatch && !isMetadataRefresh && (
@@ -177,18 +203,25 @@ export function JobRow({ job, libraryName, highlighted, onCancel, formatDate, fo
         </td>
         <td className="px-4 py-3">
           <div className="flex items-center gap-2">
-            <Link 
+            <Link
               href={`/jobs/${job.id}`}
-              className="inline-flex items-center px-3 py-1.5 text-xs font-medium rounded-lg bg-primary text-white hover:bg-primary/90 transition-colors"
+              className="inline-flex items-center justify-center gap-1.5 h-7 px-2.5 text-xs font-medium rounded-md bg-primary text-white hover:bg-primary/90 transition-colors"
             >
+              <svg className="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 12a3 3 0 11-6 0 3 3 0 016 0z" />
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z" />
+              </svg>
               {t("jobRow.view")}
             </Link>
             {(job.status === "pending" || job.status === "running" || job.status === "extracting_pages" || job.status === "generating_thumbnails") && (
-              <Button 
-                variant="danger" 
-                size="sm"
+              <Button
+                variant="danger"
+                size="xs"
                 onClick={() => onCancel(job.id)}
               >
+                <svg className="w-3.5 h-3.5 mr-1.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+                </svg>
                 {t("common.cancel")}
               </Button>
             )}

apps/backoffice/app/components/JobsList.tsx

@@ -18,6 +18,7 @@ interface Job {
     indexed_files: number;
     removed_files: number;
     errors: number;
+    refreshed?: number;
   } | null;
   progress_percent: number | null;
   processed_files: number | null;

apps/backoffice/app/components/PeriodToggle.tsx

@@ -0,0 +1,47 @@
+"use client";
+
+import { useRouter, useSearchParams } from "next/navigation";
+
+type Period = "day" | "week" | "month";
+
+export function PeriodToggle({
+  labels,
+}: {
+  labels: { day: string; week: string; month: string };
+}) {
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const raw = searchParams.get("period");
+  const current: Period = raw === "day" ? "day" : raw === "week" ? "week" : "month";
+
+  function setPeriod(period: Period) {
+    const params = new URLSearchParams(searchParams.toString());
+    if (period === "month") {
+      params.delete("period");
+    } else {
+      params.set("period", period);
+    }
+    const qs = params.toString();
+    router.push(qs ? `?${qs}` : "/", { scroll: false });
+  }
+
+  const options: Period[] = ["day", "week", "month"];
+
+  return (
+    <div className="flex gap-1 bg-muted rounded-lg p-0.5">
+      {options.map((p) => (
+        <button
+          key={p}
+          onClick={() => setPeriod(p)}
+          className={`px-2.5 py-1 text-xs font-medium rounded-md transition-colors ${
+            current === p
+              ? "bg-card text-foreground shadow-sm"
+              : "text-muted-foreground hover:text-foreground"
+          }`}
+        >
+          {labels[p]}
+        </button>
+      ))}
+    </div>
+  );
+}

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

@@ -14,7 +14,7 @@ type ButtonVariant =
 interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
   children: ReactNode;
   variant?: ButtonVariant;
-  size?: "sm" | "md" | "lg";
+  size?: "xs" | "sm" | "md" | "lg";
 }
 
 const variantStyles: Record<ButtonVariant, string> = {
@@ -33,6 +33,7 @@ const variantStyles: Record<ButtonVariant, string> = {
 };
 
 const sizeStyles: Record<string, string> = {
+  xs: "h-7 px-2.5 text-xs rounded-md",
   sm: "h-9 px-3 text-xs rounded-md",
   md: "h-10 px-4 py-2 text-sm rounded-md",
   lg: "h-11 px-8 text-base rounded-md",

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

@@ -4,6 +4,7 @@ interface StatBoxProps {
   value: ReactNode;
   label: string;
   variant?: "default" | "primary" | "success" | "warning" | "error";
+  icon?: ReactNode;
   className?: string;
 }
 
@@ -23,10 +24,13 @@ const valueVariantStyles: Record<string, string> = {
   error: "text-destructive",
 };
 
-export function StatBox({ value, label, variant = "default", className = "" }: StatBoxProps) {
+export function StatBox({ value, label, variant = "default", icon, className = "" }: StatBoxProps) {
   return (
     <div className={`text-center p-4 rounded-lg transition-colors duration-200 ${variantStyles[variant]} ${className}`}>
-      <span className={`block text-3xl font-bold ${valueVariantStyles[variant]}`}>{value}</span>
+      <div className={`flex items-center justify-center gap-1.5 ${valueVariantStyles[variant]}`}>
+        {icon && <span className="text-xl">{icon}</span>}
+        <span className="text-3xl font-bold">{value}</span>
+      </div>
       <span className={`text-xs text-muted-foreground`}>{label}</span>
     </div>
   );

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

@@ -0,0 +1,18 @@
+import { ReactNode } from "react";
+
+interface TooltipProps {
+  label: string;
+  children: ReactNode;
+  className?: string;
+}
+
+export function Tooltip({ label, children, className = "" }: TooltipProps) {
+  return (
+    <span className={`relative group/tooltip inline-flex ${className}`}>
+      {children}
+      <span className="pointer-events-none absolute bottom-full left-1/2 -translate-x-1/2 mb-2 px-2.5 py-1 text-xs text-popover-foreground bg-popover border border-border rounded-lg shadow-lg whitespace-nowrap opacity-0 scale-95 transition-all duration-150 group-hover/tooltip:opacity-100 group-hover/tooltip:scale-100 z-50">
+        {label}
+      </span>
+    </span>
+  );
+}

apps/backoffice/app/components/ui/index.ts

@@ -19,3 +19,4 @@ export {
 } from "./Form";
 export { PageIcon, NavIcon, Icon } from "./Icon";
 export { CursorPagination, OffsetPagination } from "./Pagination";
+export { Tooltip } from "./Tooltip";

apps/backoffice/app/jobs/[id]/page.tsx

@@ -587,7 +587,16 @@ export default async function JobDetailPage({ params }: JobDetailPageProps) {
             </CardHeader>
             <CardContent>
               <div className="grid grid-cols-2 sm:grid-cols-4 gap-4">
-                <StatBox value={refreshReport.refreshed} label={t("jobDetail.refreshed")} variant="success" />
+                <StatBox
+                  value={refreshReport.refreshed}
+                  label={t("jobDetail.refreshed")}
+                  variant="success"
+                  icon={
+                    <svg className="w-6 h-6 text-success" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                    </svg>
+                  }
+                />
                 <StatBox value={refreshReport.unchanged} label={t("jobDetail.unchanged")} />
                 <StatBox value={refreshReport.errors} label={t("jobDetail.errors")} variant={refreshReport.errors > 0 ? "error" : "default"} />
                 <StatBox value={refreshReport.total_links} label={t("jobDetail.total")} />

apps/backoffice/app/page.tsx

@@ -1,7 +1,8 @@
 import React from "react";
 import { fetchStats, StatsResponse, getBookCoverUrl } from "../lib/api";
 import { Card, CardContent, CardHeader, CardTitle } from "./components/ui";
-import { RcDonutChart, RcBarChart, RcAreaChart, RcStackedBar, RcHorizontalBar } from "./components/DashboardCharts";
+import { RcDonutChart, RcBarChart, RcAreaChart, RcStackedBar, RcHorizontalBar, RcMultiLineChart } from "./components/DashboardCharts";
+import { PeriodToggle } from "./components/PeriodToggle";
 import Image from "next/image";
 import Link from "next/link";
 import { getServerTranslations } from "../lib/i18n/server";
@@ -21,6 +22,24 @@ function formatNumber(n: number, locale: string): string {
   return n.toLocaleString(locale === "fr" ? "fr-FR" : "en-US");
 }
 
+function formatChartLabel(raw: string, period: "day" | "week" | "month", locale: string): string {
+  const loc = locale === "fr" ? "fr-FR" : "en-US";
+  if (period === "month") {
+    // raw = "YYYY-MM"
+    const [y, m] = raw.split("-");
+    const d = new Date(Number(y), Number(m) - 1, 1);
+    return d.toLocaleDateString(loc, { month: "short" });
+  }
+  if (period === "week") {
+    // raw = "YYYY-MM-DD" (Monday of the week)
+    const d = new Date(raw + "T00:00:00");
+    return d.toLocaleDateString(loc, { day: "numeric", month: "short" });
+  }
+  // day: raw = "YYYY-MM-DD"
+  const d = new Date(raw + "T00:00:00");
+  return d.toLocaleDateString(loc, { weekday: "short", day: "numeric" });
+}
+
 // Horizontal progress bar for metadata quality (stays server-rendered, no recharts needed)
 function HorizontalBar({ label, value, max, subLabel, color = "var(--color-primary)" }: { label: string; value: number; max: number; subLabel?: string; color?: string }) {
   const pct = max > 0 ? (value / max) * 100 : 0;
@@ -40,12 +59,19 @@ function HorizontalBar({ label, value, max, subLabel, color = "var(--color-prima
   );
 }
 
-export default async function DashboardPage() {
+export default async function DashboardPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
+}) {
+  const searchParamsAwaited = await searchParams;
+  const rawPeriod = searchParamsAwaited.period;
+  const period = rawPeriod === "day" ? "day" as const : rawPeriod === "week" ? "week" as const : "month" as const;
   const { t, locale } = await getServerTranslations();
 
   let stats: StatsResponse | null = null;
   try {
-    stats = await fetchStats();
+    stats = await fetchStats(period);
   } catch (e) {
     console.error("Failed to fetch stats:", e);
   }
@@ -62,7 +88,7 @@ export default async function DashboardPage() {
     );
   }
 
-  const { overview, reading_status, currently_reading = [], recently_read = [], reading_over_time = [], by_format, by_library, top_series, additions_over_time, metadata } = stats;
+  const { overview, reading_status, currently_reading = [], recently_read = [], reading_over_time = [], by_format, by_library, top_series, additions_over_time, jobs_over_time = [], metadata } = stats;
 
   const readingColors = ["hsl(220 13% 70%)", "hsl(45 93% 47%)", "hsl(142 60% 45%)"];
   const formatColors = [
@@ -110,7 +136,7 @@ export default async function DashboardPage() {
               {currently_reading.length === 0 ? (
                 <p className="text-muted-foreground text-sm text-center py-4">{t("dashboard.noCurrentlyReading")}</p>
               ) : (
-                <div className="space-y-3">
+                <div className="space-y-3 max-h-[216px] overflow-y-auto pr-1">
                   {currently_reading.slice(0, 8).map((book) => {
                     const pct = book.page_count > 0 ? Math.round((book.current_page / book.page_count) * 100) : 0;
                     return (
@@ -150,7 +176,7 @@ export default async function DashboardPage() {
               {recently_read.length === 0 ? (
                 <p className="text-muted-foreground text-sm text-center py-4">{t("dashboard.noRecentlyRead")}</p>
               ) : (
-                <div className="space-y-3">
+                <div className="space-y-3 max-h-[216px] overflow-y-auto pr-1">
                   {recently_read.map((book) => (
                     <Link key={book.book_id} href={`/books/${book.book_id}` as any} className="flex items-center gap-3 group">
                       <Image
@@ -175,20 +201,19 @@ export default async function DashboardPage() {
       )}
 
       {/* Reading activity line chart */}
-      {reading_over_time.length > 0 && (
-        <Card hover={false}>
-          <CardHeader>
-            <CardTitle className="text-base">{t("dashboard.readingActivity")}</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <RcAreaChart
-              noDataLabel={noDataLabel}
-              data={reading_over_time.map((m) => ({ label: m.month.slice(5), value: m.books_read }))}
-              color="hsl(142 60% 45%)"
-            />
-          </CardContent>
-        </Card>
-      )}
+      <Card hover={false}>
+        <CardHeader className="flex flex-row items-center justify-between space-y-0">
+          <CardTitle className="text-base">{t("dashboard.readingActivity")}</CardTitle>
+          <PeriodToggle labels={{ day: t("dashboard.periodDay"), week: t("dashboard.periodWeek"), month: t("dashboard.periodMonth") }} />
+        </CardHeader>
+        <CardContent>
+          <RcAreaChart
+            noDataLabel={noDataLabel}
+            data={reading_over_time.map((m) => ({ label: formatChartLabel(m.month, period, locale), value: m.books_read }))}
+            color="hsl(142 60% 45%)"
+          />
+        </CardContent>
+      </Card>
 
       {/* Charts row */}
       <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
@@ -351,20 +376,47 @@ export default async function DashboardPage() {
         </Card>
       </div>
 
-      {/* Monthly additions line chart – full width */}
+      {/* Additions line chart – full width */}
       <Card hover={false}>
-        <CardHeader>
+        <CardHeader className="flex flex-row items-center justify-between space-y-0">
           <CardTitle className="text-base">{t("dashboard.booksAdded")}</CardTitle>
+          <PeriodToggle labels={{ day: t("dashboard.periodDay"), week: t("dashboard.periodWeek"), month: t("dashboard.periodMonth") }} />
         </CardHeader>
         <CardContent>
           <RcAreaChart
             noDataLabel={noDataLabel}
-            data={additions_over_time.map((m) => ({ label: m.month.slice(5), value: m.books_added }))}
+            data={additions_over_time.map((m) => ({ label: formatChartLabel(m.month, period, locale), value: m.books_added }))}
             color="hsl(198 78% 37%)"
           />
         </CardContent>
       </Card>
 
+      {/* Jobs over time – multi-line chart */}
+      <Card hover={false}>
+        <CardHeader className="flex flex-row items-center justify-between space-y-0">
+          <CardTitle className="text-base">{t("dashboard.jobsOverTime")}</CardTitle>
+          <PeriodToggle labels={{ day: t("dashboard.periodDay"), week: t("dashboard.periodWeek"), month: t("dashboard.periodMonth") }} />
+        </CardHeader>
+        <CardContent>
+          <RcMultiLineChart
+            noDataLabel={noDataLabel}
+            data={jobs_over_time.map((j) => ({
+              label: formatChartLabel(j.label, period, locale),
+              scan: j.scan,
+              rebuild: j.rebuild,
+              thumbnail: j.thumbnail,
+              other: j.other,
+            }))}
+            lines={[
+              { key: "scan", label: t("dashboard.jobScan"), color: "hsl(198 78% 37%)" },
+              { key: "rebuild", label: t("dashboard.jobRebuild"), color: "hsl(142 60% 45%)" },
+              { key: "thumbnail", label: t("dashboard.jobThumbnail"), color: "hsl(45 93% 47%)" },
+              { key: "other", label: t("dashboard.jobOther"), color: "hsl(280 60% 50%)" },
+            ]}
+          />
+        </CardContent>
+      </Card>
+
       {/* Quick links */}
       <QuickLinks t={t} />
     </div>

apps/backoffice/lib/api.ts

@@ -32,6 +32,7 @@ export type IndexJobDto = {
     removed_files: number;
     errors: number;
     warnings: number;
+    refreshed?: number;
   } | null;
   progress_percent: number | null;
   processed_files: number | null;
@@ -570,6 +571,14 @@ export type MonthlyReading = {
   books_read: number;
 };
 
+export type JobTimePoint = {
+  label: string;
+  scan: number;
+  rebuild: number;
+  thumbnail: number;
+  other: number;
+};
+
 export type StatsResponse = {
   overview: StatsOverview;
   reading_status: ReadingStatusStats;
@@ -581,11 +590,13 @@ export type StatsResponse = {
   by_library: LibraryStatsItem[];
   top_series: TopSeriesItem[];
   additions_over_time: MonthlyAdditions[];
+  jobs_over_time: JobTimePoint[];
   metadata: MetadataStats;
 };
 
-export async function fetchStats() {
-  return apiFetch<StatsResponse>("/stats", { next: { revalidate: 30 } });
+export async function fetchStats(period?: "day" | "week" | "month") {
+  const params = period && period !== "month" ? `?period=${period}` : "";
+  return apiFetch<StatsResponse>(`/stats${params}`, { next: { revalidate: 30 } });
 }
 
 // ---------------------------------------------------------------------------

apps/backoffice/lib/i18n/en.ts

@@ -70,7 +70,15 @@ const en: Record<TranslationKey, string> = {
   "dashboard.readingStatus": "Reading status",
   "dashboard.byFormat": "By format",
   "dashboard.byLibrary": "By library",
-  "dashboard.booksAdded": "Books added (last 12 months)",
+  "dashboard.booksAdded": "Books added",
+  "dashboard.jobsOverTime": "Job runs",
+  "dashboard.jobScan": "Scan",
+  "dashboard.jobRebuild": "Rebuild",
+  "dashboard.jobThumbnail": "Thumbnails",
+  "dashboard.jobOther": "Other",
+  "dashboard.periodDay": "Day",
+  "dashboard.periodWeek": "Week",
+  "dashboard.periodMonth": "Month",
   "dashboard.popularSeries": "Popular series",
   "dashboard.noSeries": "No series yet",
   "dashboard.unknown": "Unknown",
@@ -84,7 +92,7 @@ const en: Record<TranslationKey, string> = {
   "dashboard.withIsbn": "With ISBN",
   "dashboard.currentlyReading": "Currently reading",
   "dashboard.recentlyRead": "Recently read",
-  "dashboard.readingActivity": "Reading activity (last 12 months)",
+  "dashboard.readingActivity": "Reading activity",
   "dashboard.pageProgress": "p. {{current}} / {{total}}",
   "dashboard.noCurrentlyReading": "No books in progress",
   "dashboard.noRecentlyRead": "No books read recently",
@@ -250,6 +258,7 @@ const en: Record<TranslationKey, string> = {
   "jobRow.thumbnailsGenerated": "{{count}} thumbnails generated",
   "jobRow.metadataProcessed": "{{count}} series processed",
   "jobRow.metadataRefreshed": "{{count}} series refreshed",
+  "jobRow.metadataLinks": "{{count}} links analyzed",
   "jobRow.errors": "{{count}} errors",
   "jobRow.view": "View",
 

apps/backoffice/lib/i18n/fr.ts

@@ -68,7 +68,15 @@ const fr = {
   "dashboard.readingStatus": "Statut de lecture",
   "dashboard.byFormat": "Par format",
   "dashboard.byLibrary": "Par bibliothèque",
-  "dashboard.booksAdded": "Livres ajoutés (12 derniers mois)",
+  "dashboard.booksAdded": "Livres ajoutés",
+  "dashboard.jobsOverTime": "Exécutions de jobs",
+  "dashboard.jobScan": "Scan",
+  "dashboard.jobRebuild": "Rebuild",
+  "dashboard.jobThumbnail": "Thumbnails",
+  "dashboard.jobOther": "Autre",
+  "dashboard.periodDay": "Jour",
+  "dashboard.periodWeek": "Semaine",
+  "dashboard.periodMonth": "Mois",
   "dashboard.popularSeries": "Séries populaires",
   "dashboard.noSeries": "Aucune série pour le moment",
   "dashboard.unknown": "Inconnu",
@@ -82,7 +90,7 @@ const fr = {
   "dashboard.withIsbn": "Avec ISBN",
   "dashboard.currentlyReading": "En cours de lecture",
   "dashboard.recentlyRead": "Derniers livres lus",
-  "dashboard.readingActivity": "Activité de lecture (12 derniers mois)",
+  "dashboard.readingActivity": "Activité de lecture",
   "dashboard.pageProgress": "p. {{current}} / {{total}}",
   "dashboard.noCurrentlyReading": "Aucun livre en cours",
   "dashboard.noRecentlyRead": "Aucun livre lu récemment",
@@ -248,6 +256,7 @@ const fr = {
   "jobRow.thumbnailsGenerated": "{{count}} miniatures générées",
   "jobRow.metadataProcessed": "{{count}} séries traitées",
   "jobRow.metadataRefreshed": "{{count}} séries rafraîchies",
+  "jobRow.metadataLinks": "{{count}} liens analysés",
   "jobRow.errors": "{{count}} erreurs",
   "jobRow.view": "Voir",
 

apps/backoffice/package.json

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

crates/notifications/src/lib.rs

@@ -161,7 +161,13 @@ async fn send_telegram_photo(config: &TelegramConfig, caption: &str, photo_path:
 
 /// 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
+    send_telegram(
+        config,
+        "🔔 <b>Stripstream Librarian</b>\n\
+         ━━━━━━━━━━━━━━━━━━━━\n\
+         ✅ Test notification — connection OK!",
+    )
+    .await
 }
 
 // ---------------------------------------------------------------------------
@@ -265,22 +271,23 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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,
-            )
+            let mut lines = vec![
+                format!("✅ <b>Scan completed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("🏷 <b>Type:</b> {job_type}"),
+                format!("⏱ <b>Duration:</b> {duration}"),
+                String::new(),
+                format!("📊 <b>Results</b>"),
+                format!("  📗 New books: <b>{}</b>", stats.indexed_files),
+                format!("  📚 New series: <b>{}</b>", stats.new_series),
+                format!("  🔎 Files scanned: <b>{}</b>", stats.scanned_files),
+                format!("  🗑 Removed: <b>{}</b>", stats.removed_files),
+            ];
+            if stats.errors > 0 {
+                lines.push(format!("  ⚠️ Errors: <b>{}</b>", stats.errors));
+            }
+            lines.join("\n")
         }
         NotificationEvent::ScanFailed {
             job_type,
@@ -289,23 +296,28 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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}"
-            )
+            [
+                format!("🚨 <b>Scan failed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("🏷 <b>Type:</b> {job_type}"),
+                String::new(),
+                format!("💬 <code>{err}</code>"),
+            ]
+            .join("\n")
         }
         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}"
-            )
+            [
+                format!("⏹ <b>Scan cancelled</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("🏷 <b>Type:</b> {job_type}"),
+            ]
+            .join("\n")
         }
         NotificationEvent::ThumbnailCompleted {
             job_type,
@@ -314,12 +326,14 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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}"
-            )
+            [
+                format!("✅ <b>Thumbnails completed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("🏷 <b>Type:</b> {job_type}"),
+                format!("⏱ <b>Duration:</b> {duration}"),
+            ]
+            .join("\n")
         }
         NotificationEvent::ThumbnailFailed {
             job_type,
@@ -328,12 +342,15 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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}"
-            )
+            [
+                format!("🚨 <b>Thumbnails failed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("🏷 <b>Type:</b> {job_type}"),
+                String::new(),
+                format!("💬 <code>{err}</code>"),
+            ]
+            .join("\n")
         }
         NotificationEvent::ConversionCompleted {
             library_name,
@@ -342,11 +359,13 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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}"
-            )
+            [
+                format!("✅ <b>CBR → CBZ conversion completed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("📖 <b>Book:</b> {title}"),
+            ]
+            .join("\n")
         }
         NotificationEvent::ConversionFailed {
             library_name,
@@ -357,23 +376,28 @@ fn format_event(event: &NotificationEvent) -> String {
             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}"
-            )
+            [
+                format!("🚨 <b>CBR → CBZ conversion failed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("📖 <b>Book:</b> {title}"),
+                String::new(),
+                format!("💬 <code>{err}</code>"),
+            ]
+            .join("\n")
         }
         NotificationEvent::MetadataApproved {
             series_name,
             provider,
             ..
         } => {
-            format!(
-                "🔗 <b>Metadata linked</b>\n\
-                 Series: {series_name}\n\
-                 Provider: {provider}"
-            )
+            [
+                format!("✅ <b>Metadata linked</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📚 <b>Series:</b> {series_name}"),
+                format!("🔗 <b>Provider:</b> {provider}"),
+            ]
+            .join("\n")
         }
         NotificationEvent::MetadataBatchCompleted {
             library_name,
@@ -381,11 +405,13 @@ fn format_event(event: &NotificationEvent) -> String {
             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}"
-            )
+            [
+                format!("✅ <b>Metadata batch completed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                format!("📊 <b>Processed:</b> {processed}/{total_series} series"),
+            ]
+            .join("\n")
         }
         NotificationEvent::MetadataBatchFailed {
             library_name,
@@ -393,11 +419,14 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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}"
-            )
+            [
+                format!("🚨 <b>Metadata batch failed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                String::new(),
+                format!("💬 <code>{err}</code>"),
+            ]
+            .join("\n")
         }
         NotificationEvent::MetadataRefreshCompleted {
             library_name,
@@ -406,13 +435,19 @@ fn format_event(event: &NotificationEvent) -> String {
             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}"
-            )
+            let mut lines = vec![
+                format!("✅ <b>Metadata refresh completed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                String::new(),
+                format!("📊 <b>Results</b>"),
+                format!("  🔄 Updated: <b>{refreshed}</b>"),
+                format!("  ▪️ Unchanged: <b>{unchanged}</b>"),
+            ];
+            if *errors > 0 {
+                lines.push(format!("  ⚠️ Errors: <b>{errors}</b>"));
+            }
+            lines.join("\n")
         }
         NotificationEvent::MetadataRefreshFailed {
             library_name,
@@ -420,11 +455,14 @@ fn format_event(event: &NotificationEvent) -> String {
         } => {
             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}"
-            )
+            [
+                format!("🚨 <b>Metadata refresh failed</b>"),
+                format!("━━━━━━━━━━━━━━━━━━━━"),
+                format!("📂 <b>Library:</b> {lib}"),
+                String::new(),
+                format!("💬 <code>{err}</code>"),
+            ]
+            .join("\n")
         }
     }
 }