fix(analysis): emit Cancelled event + assert lock-release after cancel (0.87.13)

Two 0.87.4 follow-ups:

1. Cron tick: existing shutdown-on-cancel test now also asserts the
   advisory lock is re-acquirable after cancel-during-tick. Without
   this, a refactor moving `pg_advisory_unlock` under the cancel arm
   would ship green and break multi-replica safety.

2. Analysis worker: cancel-mid-dispatch left the dashboard banner stuck
   on the cancelled page until a later page overwrote it. Add a
   `Cancelled` AnalysisEvent variant, publish on the cancel-release
   branch, wire the analysis and admin overview dashboards to clear
   on it. Per-page chip rolls back from `analyzing` to `queued`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/Cargo.lock

@@ -1517,7 +1517,7 @@ checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
 [[package]]
 name = "mangalord"
-version = "0.87.12"
+version = "0.87.13"
 dependencies = [
  "anyhow",
  "argon2",

backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mangalord"
-version = "0.87.12"
+version = "0.87.13"
 edition = "2021"
 default-run = "mangalord"
 

backend/src/analysis/daemon.rs

@@ -276,7 +276,23 @@ impl WorkerContext {
             );
             let _ = jobs::release(&self.pool, lease.id).await;
             // Don't publish Failed (the page didn't actually fail) and
-            // don't write a duration row — neither outcome is true.
+            // don't write a duration row — neither outcome is true. DO
+            // publish Cancelled so the dashboard's "now analyzing" banner
+            // can clear the page we previously sent Started for. Without
+            // this the banner stuck on the cancelled page until a later
+            // page kicked off and overwrote it.
+            if let Some((manga_id, manga_title, chapter_id, chapter_number, page_number)) =
+                breadcrumb
+            {
+                self.events.publish(AnalysisEvent::Cancelled {
+                    page_id,
+                    manga_id,
+                    manga_title,
+                    chapter_id,
+                    chapter_number,
+                    page_number,
+                });
+            }
             return;
         };
 

backend/src/analysis/events.rs

@@ -54,6 +54,20 @@ pub enum AnalysisEvent {
         chapter_number: i32,
         page_number: i32,
     },
+    /// The worker cancelled an in-flight dispatch (daemon shutdown or
+    /// settings reload toggling analysis off). The lease was released,
+    /// not failed — but the dashboard banner already saw `Started` and
+    /// only clears on `Completed`/`Failed`/`Cancelled`. Without this
+    /// variant the banner stuck on the cancelled page forever (until a
+    /// later page kicked off and overwrote it).
+    Cancelled {
+        page_id: Uuid,
+        manga_id: Uuid,
+        manga_title: String,
+        chapter_id: Uuid,
+        chapter_number: i32,
+        page_number: i32,
+    },
 }
 
 /// Broadcaster shared on `AppState`. Cheap to clone via `Arc`. Publishing

backend/tests/crawler_daemon.rs

@@ -894,4 +894,27 @@ async fn cron_shutdown_does_not_block_on_in_flight_metadata_pass(pool: PgPool) {
         started.elapsed() < Duration::from_secs(5),
         "shutdown took too long; cancel didn't propagate into the cron tick body"
     );
+
+    // The advisory lock must be released so another replica's cron can
+    // pick up the slot. Without this assertion, a refactor that moved
+    // the `pg_advisory_unlock` under the cancel arm (instead of running
+    // unconditionally below the select!) would ship green — only to
+    // wedge multi-replica deployments where the second replica's cron
+    // would block on `pg_try_advisory_lock` forever. `pg_try_advisory_lock`
+    // returns true iff the lock is free, so we use it as the probe.
+    let acquired: bool = sqlx::query_scalar("SELECT pg_try_advisory_lock($1)")
+        .bind(CRON_LOCK_KEY)
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert!(
+        acquired,
+        "advisory lock must be released after cancel-during-tick \
+         (otherwise multi-replica safety breaks)"
+    );
+    // Be a good citizen for whatever sqlx test runs next.
+    let _ = sqlx::query("SELECT pg_advisory_unlock($1)")
+        .bind(CRON_LOCK_KEY)
+        .execute(&pool)
+        .await;
 }