diff --git a/client/src-tauri/src/android_bg.rs b/client/src-tauri/src/android_bg.rs
new file mode 100644
index 00000000..69e647b4
--- /dev/null
+++ b/client/src-tauri/src/android_bg.rs
@@ -0,0 +1,138 @@
+//! Android side of the background watcher (`bg_activity`): drives
+//! `com.phantomptr.ps5upload.TransferService`, the foreground service that keeps the process
+//! (and with it the in-process engine) alive while a transfer runs with the app in the
+//! background, and posts the complete / failed notifications. The Kotlin class is written into
+//! `gen/android` by `scripts/release/android-postinit-patch.sh`.
+//!
+//! Every call is best-effort: a failure is logged and the transfer carries on without the
+//! service, as it did before it existed.
+
+use jni::objects::{GlobalRef, JClass, JObject, JValue};
+use jni::JNIEnv;
+use std::sync::OnceLock;
+
+use crate::android_jni::{app_class, app_context, vm};
+
+const SERVICE_CLASS: &str = "com.phantomptr.ps5upload.TransferService";
+
+/// The service class, looked up once through the app's class loader.
+static CLASS: OnceLock<GlobalRef> = OnceLock::new();
+
+fn with_service(
+    what: &str,
+    f: impl for<'a> FnOnce(&mut JNIEnv<'a>, &JClass<'a>, &JObject<'a>) -> jni::errors::Result<()>,
+) {
+    let result = (|| -> Result<(), String> {
+        let mut env = vm()?
+            .attach_current_thread()
+            .map_err(|e| format!("attach: {e}"))?;
+        let out = (|| {
+            let context = app_context(&mut env)?;
+            let global = match CLASS.get() {
+                Some(g) => g,
+                None => {
+                    let class = app_class(&mut env, &context, SERVICE_CLASS)?;
+                    let g = env
+                        .new_global_ref(class)
+                        .map_err(|e| format!("global ref: {e}"))?;
+                    CLASS.get_or_init(|| g)
+                }
+            };
+            let local = env
+                .new_local_ref(global.as_obj())
+                .map_err(|e| format!("local ref: {e}"))?;
+            let class = JClass::from(local);
+            f(&mut env, &class, &context).map_err(|e| e.to_string())
+        })();
+        // Never hand the thread back with a pending exception.
+        if env.exception_check().unwrap_or(false) {
+            let _ = env.exception_describe();
+            let _ = env.exception_clear();
+        }
+        out
+    })();
+    if let Err(e) = result {
+        eprintln!("[bg] TransferService.{what}: {e}");
+    }
+}
+
+/// Start the foreground service with its first progress line. `percent` < 0 = indeterminate.
+pub fn start(title: &str, text: &str, percent: i32, channel: &str) {
+    with_service("start", |env, class, ctx| {
+        let (t, x, c) = (
+            env.new_string(title)?,
+            env.new_string(text)?,
+            env.new_string(channel)?,
+        );
+        env.call_static_method(
+            class,
+            "start",
+            "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;)V",
+            &[
+                JValue::Object(ctx),
+                JValue::Object(&t),
+                JValue::Object(&x),
+                JValue::Int(percent),
+                JValue::Object(&c),
+            ],
+        )?;
+        Ok(())
+    });
+}
+
+/// Refresh the ongoing progress notification.
+pub fn update(title: &str, text: &str, percent: i32) {
+    with_service("update", |env, class, ctx| {
+        let (t, x) = (env.new_string(title)?, env.new_string(text)?);
+        env.call_static_method(
+            class,
+            "update",
+            "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;I)V",
+            &[
+                JValue::Object(ctx),
+                JValue::Object(&t),
+                JValue::Object(&x),
+                JValue::Int(percent),
+            ],
+        )?;
+        Ok(())
+    });
+}
+
+/// Post a complete / failed notification on the results channel. `id` keeps one per job.
+pub fn finished(id: i32, title: &str, text: &str, ok: bool, channel: &str) {
+    with_service("finished", |env, class, ctx| {
+        let (t, x, c) = (
+            env.new_string(title)?,
+            env.new_string(text)?,
+            env.new_string(channel)?,
+        );
+        env.call_static_method(
+            class,
+            "finished",
+            "(Landroid/content/Context;ILjava/lang/String;Ljava/lang/String;ZLjava/lang/String;)V",
+            &[
+                JValue::Object(ctx),
+                JValue::Int(id),
+                JValue::Object(&t),
+                JValue::Object(&x),
+                JValue::Bool(ok as u8),
+                JValue::Object(&c),
+            ],
+        )?;
+        Ok(())
+    });
+}
+
+/// Stop the service and remove its progress notification.
+pub fn stop() {
+    with_service("stop", |env, class, ctx| {
+        env.call_static_method(
+            class,
+            "stop",
+            "(Landroid/content/Context;)V",
+            &[JValue::Object(ctx)],
+        )?;
+        Ok(())
+    });
+}
diff --git a/client/src-tauri/src/android_jni.rs b/client/src-tauri/src/android_jni.rs
new file mode 100644
index 00000000..bffc4f8d
--- /dev/null
+++ b/client/src-tauri/src/android_jni.rs
@@ -0,0 +1,88 @@
+//! The JavaVM and Application context every Android JNI caller in this crate shares
+//! (`commands::local_fs`, `android_bg`). `JNI_OnLoad` may be defined once per library, so it
+//! lives here rather than with any one caller.
+
+use jni::objects::{JClass, JObject, JValue};
+use jni::{JNIEnv, JavaVM};
+use std::ffi::c_void;
+use std::sync::OnceLock;
+
+/// JavaVM captured at native-library load.
+///
+/// Tauri 2's Android backend (a Kotlin WryActivity that `loadLibrary`s
+/// this `.so`) does NOT initialize the `ndk_context` crate's global —
+/// tao carries its own internal glue and never calls
+/// `ndk_context::initialize_android_context`. So the old
+/// `ndk_context::android_context()` here always hit an uninitialized
+/// global and aborted the whole app on first use ("android context was
+/// not initialized"). We capture the VM ourselves in `JNI_OnLoad`
+/// instead — the runtime calls it once when the library loads, before
+/// any Tauri command can run, and neither wry nor tao defines it.
+static JVM: OnceLock<JavaVM> = OnceLock::new();
+
+/// Android runtime entry point, invoked on `System.loadLibrary`.
+#[no_mangle]
+pub extern "system" fn JNI_OnLoad(
+    vm: *mut jni::sys::JavaVM,
+    _reserved: *mut c_void,
+) -> jni::sys::jint {
+    if let Ok(vm) = unsafe { JavaVM::from_raw(vm) } {
+        let _ = JVM.set(vm);
+    }
+    jni::sys::JNI_VERSION_1_6
+}
+
+pub(crate) fn vm() -> Result<&'static JavaVM, String> {
+    JVM.get()
+        .ok_or_else(|| "Android JavaVM unavailable (JNI_OnLoad not run)".to_string())
+}
+
+/// The app's Application context — a `Context` we can use for
+/// `getSystemService` and `startActivity(FLAG_ACTIVITY_NEW_TASK)`.
+/// Fetched via `ActivityThread.currentApplication()` so we don't need a
+/// captured Activity (or the unavailable `ndk_context`).
+pub(crate) fn app_context<'local>(env: &mut JNIEnv<'local>) -> Result<JObject<'local>, String> {
+    let app = env
+        .call_static_method(
+            "android/app/ActivityThread",
+            "currentApplication",
+            "()Landroid/app/Application;",
+            &[],
+        )
+        .map_err(|e| format!("currentApplication: {e}"))?
+        .l()
+        .map_err(|e| format!("application obj: {e}"))?;
+    if app.is_null() {
+        return Err("currentApplication() returned null".into());
+    }
+    Ok(app)
+}
+
+/// One of the app's own classes (`com.phantomptr.ps5upload.…`). `FindClass` on a thread Rust
+/// attached searches the system class loader, which does not have them; the context's loader
+/// does. `name` is dotted (`com.example.Foo`).
+pub(crate) fn app_class<'local>(
+    env: &mut JNIEnv<'local>,
+    context: &JObject,
+    name: &str,
+) -> Result<JClass<'local>, String> {
+    let loader = env
+        .call_method(context, "getClassLoader", "()Ljava/lang/ClassLoader;", &[])
+        .map_err(|e| format!("getClassLoader: {e}"))?
+        .l()
+        .map_err(|e| format!("loader obj: {e}"))?;
+    let jname = env
+        .new_string(name)
+        .map_err(|e| format!("class name: {e}"))?;
+    let class = env
+        .call_method(
+            &loader,
+            "loadClass",
+            "(Ljava/lang/String;)Ljava/lang/Class;",
+            &[JValue::Object(&jname)],
+        )
+        .map_err(|e| format!("loadClass {name}: {e}"))?
+        .l()
+        .map_err(|e| format!("class obj: {e}"))?;
+    Ok(JClass::from(class))
+}
diff --git a/client/src-tauri/src/bg_activity.rs b/client/src-tauri/src/bg_activity.rs
new file mode 100644
index 00000000..79212ce2
--- /dev/null
+++ b/client/src-tauri/src/bg_activity.rs
@@ -0,0 +1,860 @@
+//! Background watcher (#457): notices from the host, not the WebView, that work is running or
+//! has just ended.
+//!
+//! A hidden window throttles the renderer's timers (WebView2, WebKitGTK, a hidden WKWebView can
+//! be suspended) and Android freezes a backgrounded app's process outright, so the renderer is
+//! the wrong place to decide "a job finished, tell the person and start the next one". This
+//! task polls the engine's `GET /api/activity` every second instead and:
+//!
+//! - on Android, runs a foreground service (`android_bg`) while anything is active, which keeps
+//!   the process and the in-process engine alive, with an ongoing progress notification;
+//! - posts a complete / failed notification when the app is in the background;
+//! - emits `bg-job-finished` (and a `bg-tick` heartbeat while work runs) so the renderer's queue
+//!   advances without waiting on a throttled timer.
+//!
+//! "Active" is an engine job running, or a renderer hold (queued items waiting their turn)
+//! refreshed within the last 5 minutes; the service stops 30 s after nothing is active.
+//! The decisions live in [`step`], which is pure and unit-tested.
+
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Mutex, OnceLock, RwLock};
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Emitter, Runtime};
+
+const POLL: Duration = Duration::from_secs(1);
+/// A renderer hold counts this long after its last refresh (the renderer refreshes every 60 s):
+/// a frozen renderer cannot keep the service up forever.
+const HOLD_TTL_MS: u64 = 5 * 60 * 1000;
+/// Nothing active for this long stops the service. Covers the gap between queue items.
+const IDLE_GRACE_MS: u64 = 30 * 1000;
+/// Weight of the newest sample in the speed average.
+const EMA_ALPHA: f64 = 0.3;
+
+// ── Engine snapshot ──────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+pub struct ActiveJob {
+    pub id: String,
+    #[serde(default)]
+    pub kind: String,
+    #[serde(default)]
+    pub label: String,
+    #[serde(default)]
+    pub bytes_done: u64,
+    #[serde(default)]
+    pub bytes_total: u64,
+}
+
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
+pub struct FinishedJob {
+    pub seq: u64,
+    pub id: String,
+    #[serde(default)]
+    pub kind: String,
+    #[serde(default)]
+    pub label: String,
+    #[serde(default)]
+    pub ok: bool,
+    #[serde(default)]
+    pub cancelled: bool,
+    #[serde(default)]
+    pub error: Option<String>,
+    #[serde(default)]
+    pub bytes: u64,
+    #[serde(default)]
+    pub elapsed_ms: u64,
+}
+
+#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+pub struct Snapshot {
+    pub seq: u64,
+    #[serde(default)]
+    pub active: Vec<ActiveJob>,
+    #[serde(default)]
+    pub finished: Vec<FinishedJob>,
+}
+
+// ── Strings (the renderer sends its language's; English until it does) ──────
+
+#[derive(Debug, Clone, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct BgStrings {
+    pub uploading: String,
+    pub downloading: String,
+    pub installing: String,
+    pub working: String,
+    pub jobs_running: String,
+    pub waiting: String,
+    pub progress_of: String,
+    pub done_upload: String,
+    pub done_download: String,
+    pub done_install: String,
+    pub done_job: String,
+    pub failed_upload: String,
+    pub failed_download: String,
+    pub failed_install: String,
+    pub failed_job: String,
+    pub channel_progress: String,
+    pub channel_results: String,
+}
+
+impl Default for BgStrings {
+    fn default() -> Self {
+        let s = |v: &str| v.to_string();
+        Self {
+            uploading: s("Uploading {name}"),
+            downloading: s("Downloading {name}"),
+            installing: s("Installing {name}"),
+            working: s("Working on {name}"),
+            jobs_running: s("{n} jobs running"),
+            waiting: s("Waiting for the next item"),
+            progress_of: s("{done} of {total}"),
+            done_upload: s("Upload complete"),
+            done_download: s("Download complete"),
+            done_install: s("Installed"),
+            done_job: s("Finished"),
+            failed_upload: s("Upload failed"),
+            failed_download: s("Download failed"),
+            failed_install: s("Install failed"),
+            failed_job: s("Failed"),
+            channel_progress: s("Transfers in progress"),
+            channel_results: s("Finished transfers"),
+        }
+    }
+}
+
+// ── The pure core ────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Progress {
+    pub title: String,
+    pub text: String,
+    /// `None` when the total is unknown (indeterminate bar).
+    pub percent: Option<u8>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Action {
+    StartFg(Progress),
+    Update(Progress),
+    Finished(FinishedJob),
+    StopFg,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
+pub struct Rate {
+    bytes: u64,
+    at_ms: u64,
+    bps: f64,
+}
+
+#[derive(Debug, Default)]
+pub struct State {
+    /// The engine seq already seen; `None` until the first poll.
+    pub seq: Option<u64>,
+    /// The service (and progress notification) is up.
+    pub fg: bool,
+    idle_since_ms: Option<u64>,
+    last: Option<Progress>,
+    rates: HashMap<String, Rate>,
+    pub strings: BgStrings,
+}
+
+/// One poll's decisions. The first poll only records `seq`, so a launch never re-announces
+/// endings from before it; a `seq` lower than the one seen means the engine restarted, and
+/// counting starts again from its value.
+pub fn step(state: &mut State, snap: &Snapshot, hold: bool, now_ms: u64) -> Vec<Action> {
+    let mut out = Vec::new();
+    match state.seq {
+        Some(seen) if snap.seq >= seen => {
+            for f in snap.finished.iter().filter(|f| f.seq > seen) {
+                out.push(Action::Finished(f.clone()));
+            }
+        }
+        _ => {}
+    }
+    state.seq = Some(snap.seq);
+
+    update_rates(&mut state.rates, &snap.active, now_ms);
+    let active = !snap.active.is_empty() || hold;
+    if active {
+        state.idle_since_ms = None;
+        let p = format_progress(&snap.active, &state.rates, &state.strings);
+        if !state.fg {
+            state.fg = true;
+            out.push(Action::StartFg(p.clone()));
+            state.last = Some(p);
+        } else if state.last.as_ref() != Some(&p) {
+            out.push(Action::Update(p.clone()));
+            state.last = Some(p);
+        }
+    } else if state.fg {
+        match state.idle_since_ms {
+            None => {
+                state.idle_since_ms = Some(now_ms);
+                // The last job's 99% would otherwise sit there through the grace period.
+                let p = format_progress(&[], &state.rates, &state.strings);
+                if state.last.as_ref() != Some(&p) {
+                    out.push(Action::Update(p.clone()));
+                    state.last = Some(p);
+                }
+            }
+            Some(t) if now_ms.saturating_sub(t) >= IDLE_GRACE_MS => {
+                state.fg = false;
+                state.idle_since_ms = None;
+                state.last = None;
+                out.push(Action::StopFg);
+            }
+            Some(_) => {}
+        }
+    }
+    out
+}
+
+/// Per-job speed, an exponential moving average of bytes over time between polls. Jobs that
+/// are no longer running are forgotten.
+fn update_rates(rates: &mut HashMap<String, Rate>, active: &[ActiveJob], now_ms: u64) {
+    rates.retain(|id, _| active.iter().any(|j| &j.id == id));
+    for j in active {
+        match rates.get_mut(&j.id) {
+            None => {
+                rates.insert(
+                    j.id.clone(),
+                    Rate {
+                        bytes: j.bytes_done,
+                        at_ms: now_ms,
+                        bps: 0.0,
+                    },
+                );
+            }
+            Some(r) => {
+                let dt = now_ms.saturating_sub(r.at_ms);
+                if dt == 0 {
+                    continue;
+                }
+                let sample = j.bytes_done.saturating_sub(r.bytes) as f64 * 1000.0 / dt as f64;
+                r.bps = if r.bps == 0.0 {
+                    sample
+                } else {
+                    EMA_ALPHA * sample + (1.0 - EMA_ALPHA) * r.bps
+                };
+                r.bytes = j.bytes_done;
+                r.at_ms = now_ms;
+            }
+        }
+    }
+}
+
+/// `1.2 GB`, `38 MB`: SI units like the engine's MB/s, one decimal below 10.
+pub fn fmt_bytes(n: f64) -> String {
+    const UNITS: [&str; 5] = ["B", "kB", "MB", "GB", "TB"];
+    let mut v = n.max(0.0);
+    let mut u = 0;
+    while v >= 1000.0 && u < UNITS.len() - 1 {
+        v /= 1000.0;
+        u += 1;
+    }
+    if u == 0 || v >= 10.0 {
+        format!("{v:.0} {}", UNITS[u])
+    } else {
+        format!("{v:.1} {}", UNITS[u])
+    }
+}
+
+/// The progress notification: "Uploading <label>" / "42% · 1.2 GB of 2.9 GB · 38 MB/s" for
+/// one job, "<n> jobs running" with the summed progress for several, "Waiting for the next
+/// item" while only a renderer hold is active.
+pub fn format_progress(
+    active: &[ActiveJob],
+    rates: &HashMap<String, Rate>,
+    s: &BgStrings,
+) -> Progress {
+    let title = match active {
+        [] => s.waiting.clone(),
+        [one] => {
+            let tmpl = match one.kind.as_str() {
+                "upload" => &s.uploading,
+                "download" => &s.downloading,
+                "install" => &s.installing,
+                _ => &s.working,
+            };
+            tmpl.replace("{name}", one.label.trim()).trim().to_string()
+        }
+        many => s.jobs_running.replace("{n}", &many.len().to_string()),
+    };
+    if active.is_empty() {
+        return Progress {
+            title,
+            text: String::new(),
+            percent: None,
+        };
+    }
+    let done: u64 = active.iter().map(|j| j.bytes_done).sum();
+    // A job with no known total makes the sum meaningless as a fraction.
+    let total: Option<u64> = active
+        .iter()
+        .map(|j| (j.bytes_total > 0).then_some(j.bytes_total))
+        .sum();
+    let bps: f64 = active
+        .iter()
+        .filter_map(|j| rates.get(&j.id))
+        .map(|r| r.bps)
+        .sum();
+    let percent = total.map(|t| ((done.min(t) as f64 / t as f64) * 100.0).floor() as u8);
+    let mut parts = Vec::new();
+    if let Some(p) = percent {
+        parts.push(format!("{p}%"));
+    }
+    match total {
+        Some(t) => parts.push(
+            s.progress_of
+                .replace("{done}", &fmt_bytes(done as f64))
+                .replace("{total}", &fmt_bytes(t as f64)),
+        ),
+        None if done > 0 => parts.push(fmt_bytes(done as f64)),
+        None => {}
+    }
+    if bps >= 1.0 {
+        parts.push(format!("{}/s", fmt_bytes(bps)));
+    }
+    Progress {
+        title,
+        text: parts.join(" · "),
+        percent,
+    }
+}
+
+/// Whether a job's ending is worth a notification: not one the person stopped, and not an
+/// unnamed job (the client names everything it started; the rest is the app's own plumbing).
+pub fn should_notify(f: &FinishedJob) -> bool {
+    !f.cancelled && !f.label.trim().is_empty()
+}
+
+/// Title and body of a complete / failed notification.
+pub fn finished_text(f: &FinishedJob, s: &BgStrings) -> (String, String) {
+    let title = match (f.ok, f.kind.as_str()) {
+        (true, "upload") => &s.done_upload,
+        (true, "download") => &s.done_download,
+        (true, "install") => &s.done_install,
+        (true, _) => &s.done_job,
+        (false, "upload") => &s.failed_upload,
+        (false, "download") => &s.failed_download,
+        (false, "install") => &s.failed_install,
+        (false, _) => &s.failed_job,
+    };
+    let mut body = f.label.trim().to_string();
+    if let Some(e) = f.error.as_deref().filter(|e| !f.ok && !e.is_empty()) {
+        body = format!("{body}\n{e}");
+    }
+    (title.clone(), body)
+}
+
+// ── Renderer inputs ──────────────────────────────────────────────────────────
+
+/// When the renderer last said work is queued or running (ms), `None` = released.
+static HOLD: Mutex<Option<u64>> = Mutex::new(None);
+/// The page is showing (renderer `visibilitychange`). Android's only foreground signal.
+static VISIBLE: AtomicBool = AtomicBool::new(true);
+/// The person's "Mirror notifications to the system" setting.
+static NOTIFY: AtomicBool = AtomicBool::new(true);
+static STRINGS: OnceLock<RwLock<BgStrings>> = OnceLock::new();
+
+fn strings() -> BgStrings {
+    STRINGS
+        .get_or_init(|| RwLock::new(BgStrings::default()))
+        .read()
+        .map(|g| g.clone())
+        .unwrap_or_default()
+}
+
+fn now_ms() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis() as u64)
+        .unwrap_or(0)
+}
+
+fn hold_active(now: u64) -> bool {
+    HOLD.lock()
+        .map(|g| g.is_some_and(|t| now.saturating_sub(t) < HOLD_TTL_MS))
+        .unwrap_or(false)
+}
+
+/// The renderer has work queued or running (`true`, refreshed while it lasts) or none.
+#[tauri::command]
+pub fn bg_work_hold(active: bool) {
+    if let Ok(mut g) = HOLD.lock() {
+        *g = active.then(now_ms);
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BgConfig {
+    #[serde(default)]
+    pub visible: Option<bool>,
+    #[serde(default)]
+    pub notify: Option<bool>,
+    #[serde(default)]
+    pub strings: Option<BgStrings>,
+}
+
+/// The page's visibility, the notification setting and the notification texts in the
+/// person's language. Each field is optional; absent ones are left as they were.
+#[tauri::command]
+pub fn bg_configure(config: BgConfig) {
+    if let Some(v) = config.visible {
+        VISIBLE.store(v, Ordering::Relaxed);
+    }
+    if let Some(n) = config.notify {
+        NOTIFY.store(n, Ordering::Relaxed);
+    }
+    if let Some(s) = config.strings {
+        if let Ok(mut g) = STRINGS
+            .get_or_init(|| RwLock::new(BgStrings::default()))
+            .write()
+        {
+            *g = s;
+        }
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct BgCapabilities {
+    /// The host posts job complete / failed notifications itself; the renderer must not
+    /// mirror the same ones.
+    pub native_job_notify: bool,
+}
+
+#[tauri::command]
+pub fn bg_capabilities() -> BgCapabilities {
+    BgCapabilities {
+        native_job_notify: WATCHING.load(Ordering::Relaxed),
+    }
+}
+
+// ── The task ─────────────────────────────────────────────────────────────────
+
+static STARTED: OnceLock<()> = OnceLock::new();
+/// The engine has answered `/api/activity`: endings will be seen and announced here. An
+/// engine without the route (a remote one on an older version) leaves the page announcing them.
+static WATCHING: AtomicBool = AtomicBool::new(false);
+
+/// Start the watcher once per process. Android can run setup again when its Activity is
+/// recreated; the second call is a no-op.
+pub fn spawn<R: Runtime>(app: &AppHandle<R>) {
+    if STARTED.set(()).is_err() {
+        return;
+    }
+    let app = app.clone();
+    tauri::async_runtime::spawn(async move {
+        let client = match crate::engine_http::engine_client_builder()
+            .timeout(Duration::from_secs(3))
+            .build()
+        {
+            Ok(c) => c,
+            Err(e) => {
+                eprintln!("[bg] no HTTP client: {e}");
+                return;
+            }
+        };
+        let mut state = State::default();
+        let mut ticker = tokio::time::interval(POLL);
+        ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+        loop {
+            ticker.tick().await;
+            let url = format!(
+                "{}/api/activity?since={}",
+                crate::engine::url(),
+                state.seq.unwrap_or(0)
+            );
+            let snap = match client.get(&url).send().await {
+                Ok(r) if r.status().is_success() => r.json::<Snapshot>().await.ok(),
+                // An engine without the route (a remote one on an older version) or one that
+                // is down: nothing to report this round.
+                _ => None,
+            };
+            let Some(snap) = snap else { continue };
+            WATCHING.store(true, Ordering::Relaxed);
+            state.strings = strings();
+            let now = now_ms();
+            let actions = step(&mut state, &snap, hold_active(now), now);
+            for a in &actions {
+                dispatch(&app, a, &state.strings);
+            }
+            if state.fg {
+                let _ = app.emit("bg-tick", ());
+            }
+        }
+    });
+}
+
+fn dispatch<R: Runtime>(app: &AppHandle<R>, action: &Action, s: &BgStrings) {
+    match action {
+        Action::Finished(f) => {
+            let _ = app.emit("bg-job-finished", f);
+            if should_notify(f) && NOTIFY.load(Ordering::Relaxed) && !app_in_foreground(app) {
+                let (title, body) = finished_text(f, s);
+                notify_finished(app, f, &title, &body, s);
+            }
+        }
+        #[cfg(target_os = "android")]
+        Action::StartFg(p) => crate::android_bg::start(
+            &p.title,
+            &p.text,
+            p.percent.map_or(-1, i32::from),
+            &s.channel_progress,
+        ),
+        #[cfg(target_os = "android")]
+        Action::Update(p) => {
+            crate::android_bg::update(&p.title, &p.text, p.percent.map_or(-1, i32::from))
+        }
+        #[cfg(target_os = "android")]
+        Action::StopFg => crate::android_bg::stop(),
+        // Desktop has no service to run: the engine is its own process and keep_awake.rs holds
+        // the machine awake. Progress stays in the window.
+        #[cfg(not(target_os = "android"))]
+        Action::StartFg(_) | Action::Update(_) | Action::StopFg => {}
+    }
+}
+
+/// Whether the person is looking at the app, so an OS notification would only repeat the
+/// in-app one. Desktop asks the window; a phone has one app on screen, and the page reports it.
+#[cfg(desktop)]
+fn app_in_foreground<R: Runtime>(app: &AppHandle<R>) -> bool {
+    use tauri::Manager;
+    app.get_webview_window("main").is_some_and(|w| {
+        w.is_visible().unwrap_or(false)
+            && !w.is_minimized().unwrap_or(false)
+            && w.is_focused().unwrap_or(false)
+    })
+}
+
+#[cfg(mobile)]
+fn app_in_foreground<R: Runtime>(_app: &AppHandle<R>) -> bool {
+    VISIBLE.load(Ordering::Relaxed)
+}
+
+#[cfg(target_os = "android")]
+fn notify_finished<R: Runtime>(
+    _app: &AppHandle<R>,
+    f: &FinishedJob,
+    title: &str,
+    body: &str,
+    s: &BgStrings,
+) {
+    crate::android_bg::finished(notif_id(&f.id), title, body, f.ok, &s.channel_results);
+}
+
+#[cfg(not(target_os = "android"))]
+fn notify_finished<R: Runtime>(
+    app: &AppHandle<R>,
+    _f: &FinishedJob,
+    title: &str,
+    body: &str,
+    _s: &BgStrings,
+) {
+    use tauri_plugin_notification::NotificationExt;
+    if let Err(e) = app.notification().builder().title(title).body(body).show() {
+        eprintln!("[bg] notification: {e}");
+    }
+}
+
+/// A stable notification id per job, so a repeat replaces rather than stacks.
+#[cfg(target_os = "android")]
+fn notif_id(job: &str) -> i32 {
+    let h = job.bytes().fold(0x811c_9dc5_u32, |h, b| {
+        (h ^ b as u32).wrapping_mul(0x0100_0193)
+    });
+    // Clear of the service's own id (1).
+    (h & 0x3fff_ffff) as i32 + 2
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn job(id: &str, kind: &str, label: &str, done: u64, total: u64) -> ActiveJob {
+        ActiveJob {
+            id: id.into(),
+            kind: kind.into(),
+            label: label.into(),
+            bytes_done: done,
+            bytes_total: total,
+        }
+    }
+
+    fn fin(seq: u64, id: &str) -> FinishedJob {
+        FinishedJob {
+            seq,
+            id: id.into(),
+            kind: "upload".into(),
+            label: "Game".into(),
+            ok: true,
+            ..FinishedJob::default()
+        }
+    }
+
+    fn snap(seq: u64, active: Vec<ActiveJob>, finished: Vec<FinishedJob>) -> Snapshot {
+        Snapshot {
+            seq,
+            active,
+            finished,
+        }
+    }
+
+    fn finished_ids(a: &[Action]) -> Vec<String> {
+        a.iter()
+            .filter_map(|a| match a {
+                Action::Finished(f) => Some(f.id.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn the_first_poll_only_records_seq() {
+        let mut st = State::default();
+        let a = step(&mut st, &snap(5, vec![], vec![fin(5, "old")]), false, 0);
+        assert!(a.is_empty(), "{a:?}");
+        assert_eq!(st.seq, Some(5));
+    }
+
+    #[test]
+    fn later_endings_are_reported_once() {
+        let mut st = State::default();
+        step(&mut st, &snap(5, vec![], vec![]), false, 0);
+        let a = step(
+            &mut st,
+            &snap(7, vec![], vec![fin(6, "a"), fin(7, "b")]),
+            false,
+            1000,
+        );
+        assert_eq!(finished_ids(&a), vec!["a", "b"]);
+        // The same entries again (a poll raced the since) are not news.
+        let a = step(
+            &mut st,
+            &snap(7, vec![], vec![fin(6, "a"), fin(7, "b")]),
+            false,
+            2000,
+        );
+        assert!(finished_ids(&a).is_empty());
+    }
+
+    #[test]
+    fn an_engine_restart_resets_the_seq() {
+        let mut st = State::default();
+        step(&mut st, &snap(50, vec![], vec![]), false, 0);
+        let a = step(
+            &mut st,
+            &snap(2, vec![], vec![fin(1, "x"), fin(2, "y")]),
+            false,
+            1000,
+        );
+        assert!(finished_ids(&a).is_empty());
+        assert_eq!(st.seq, Some(2));
+        let a = step(&mut st, &snap(3, vec![], vec![fin(3, "z")]), false, 2000);
+        assert_eq!(finished_ids(&a), vec!["z"]);
+    }
+
+    #[test]
+    fn a_running_job_starts_then_updates_the_service() {
+        let mut st = State::default();
+        let a = step(
+            &mut st,
+            &snap(0, vec![job("j", "upload", "Game", 0, 100)], vec![]),
+            false,
+            0,
+        );
+        assert!(matches!(a.as_slice(), [Action::StartFg(p)] if p.title == "Uploading Game"));
+        // Unchanged progress: nothing to send.
+        let a = step(
+            &mut st,
+            &snap(0, vec![job("j", "upload", "Game", 0, 100)], vec![]),
+            false,
+            1000,
+        );
+        assert!(a.is_empty(), "{a:?}");
+        let a = step(
+            &mut st,
+            &snap(0, vec![job("j", "upload", "Game", 50, 100)], vec![]),
+            false,
+            2000,
+        );
+        assert!(matches!(a.as_slice(), [Action::Update(p)] if p.percent == Some(50)));
+    }
+
+    #[test]
+    fn a_renderer_hold_alone_keeps_the_service_up() {
+        let mut st = State::default();
+        let a = step(&mut st, &snap(0, vec![], vec![]), true, 0);
+        assert!(
+            matches!(a.as_slice(), [Action::StartFg(p)] if p.title == "Waiting for the next item")
+        );
+        let a = step(&mut st, &snap(0, vec![], vec![]), true, 60_000);
+        assert!(a.is_empty());
+        assert!(st.fg);
+    }
+
+    #[test]
+    fn the_service_stops_after_the_grace_period_not_before() {
+        let mut st = State::default();
+        step(
+            &mut st,
+            &snap(0, vec![job("j", "upload", "Game", 1, 2)], vec![]),
+            false,
+            0,
+        );
+        let a = step(&mut st, &snap(1, vec![], vec![fin(1, "j")]), false, 1_000);
+        assert_eq!(finished_ids(&a), vec!["j"]);
+        assert!(a
+            .iter()
+            .any(|a| matches!(a, Action::Update(p) if p.percent.is_none())));
+        assert!(step(&mut st, &snap(1, vec![], vec![]), false, 30_999).is_empty());
+        let a = step(&mut st, &snap(1, vec![], vec![]), false, 31_000);
+        assert_eq!(a, vec![Action::StopFg]);
+        assert!(!st.fg);
+        // Idle and stopped: nothing more.
+        assert!(step(&mut st, &snap(1, vec![], vec![]), false, 90_000).is_empty());
+    }
+
+    #[test]
+    fn work_returning_in_the_grace_period_keeps_the_service() {
+        let mut st = State::default();
+        step(
+            &mut st,
+            &snap(0, vec![job("a", "upload", "A", 1, 2)], vec![]),
+            false,
+            0,
+        );
+        step(&mut st, &snap(0, vec![], vec![]), false, 1_000);
+        let a = step(
+            &mut st,
+            &snap(0, vec![job("b", "install", "B", 0, 0)], vec![]),
+            false,
+            20_000,
+        );
+        assert!(matches!(a.as_slice(), [Action::Update(p)] if p.title == "Installing B"));
+        // The idle clock restarted: 30 s after the first idle poll is not a stop.
+        assert!(!step(&mut st, &snap(0, vec![], vec![]), false, 32_000).contains(&Action::StopFg));
+    }
+
+    #[test]
+    fn progress_text_for_one_job_has_percent_bytes_and_speed() {
+        let mut rates = HashMap::new();
+        let j0 = job("j", "upload", "Astro Bot", 1_180_000_000, 2_900_000_000);
+        update_rates(&mut rates, &[j0], 0);
+        let j1 = job("j", "upload", "Astro Bot", 1_218_000_000, 2_900_000_000);
+        update_rates(&mut rates, std::slice::from_ref(&j1), 1000);
+        let p = format_progress(&[j1], &rates, &BgStrings::default());
+        assert_eq!(p.title, "Uploading Astro Bot");
+        assert_eq!(p.percent, Some(42));
+        assert_eq!(p.text, "42% · 1.2 GB of 2.9 GB · 38 MB/s");
+    }
+
+    #[test]
+    fn speed_is_a_moving_average() {
+        let mut rates = HashMap::new();
+        update_rates(&mut rates, &[job("j", "upload", "", 0, 0)], 0);
+        update_rates(&mut rates, &[job("j", "upload", "", 10_000_000, 0)], 1000);
+        update_rates(&mut rates, &[job("j", "upload", "", 10_000_000, 0)], 2000);
+        // 10 MB/s, then a stalled second: 0.3 * 0 + 0.7 * 10 MB/s.
+        assert!((rates["j"].bps - 7_000_000.0).abs() < 1.0);
+        update_rates(&mut rates, &[], 3000);
+        assert!(rates.is_empty(), "finished jobs are forgotten");
+    }
+
+    #[test]
+    fn several_jobs_sum_and_an_unknown_total_is_indeterminate() {
+        let rates = HashMap::new();
+        let s = BgStrings::default();
+        let p = format_progress(
+            &[
+                job("a", "upload", "A", 1_000_000, 4_000_000),
+                job("b", "download", "B", 1_000_000, 4_000_000),
+            ],
+            &rates,
+            &s,
+        );
+        assert_eq!(p.title, "2 jobs running");
+        assert_eq!(p.percent, Some(25));
+        assert_eq!(p.text, "25% · 2.0 MB of 8.0 MB");
+        let p = format_progress(&[job("a", "job", "", 5_000, 0)], &rates, &s);
+        assert_eq!(p.title, "Working on");
+        assert_eq!(p.percent, None);
+        assert_eq!(p.text, "5.0 kB");
+        let p = format_progress(&[job("a", "install", "X", 0, 0)], &rates, &s);
+        assert_eq!(p.text, "");
+    }
+
+    #[test]
+    fn the_strings_follow_the_language_sent() {
+        let s = BgStrings {
+            uploading: "{name} wird hochgeladen".into(),
+            progress_of: "{done} von {total}".into(),
+            ..BgStrings::default()
+        };
+        let p = format_progress(&[job("a", "upload", "Spiel", 1, 2)], &HashMap::new(), &s);
+        assert_eq!(p.title, "Spiel wird hochgeladen");
+        assert_eq!(p.text, "50% · 1 B von 2 B");
+    }
+
+    #[test]
+    fn bytes_read_naturally() {
+        assert_eq!(fmt_bytes(0.0), "0 B");
+        assert_eq!(fmt_bytes(999.0), "999 B");
+        assert_eq!(fmt_bytes(1_500.0), "1.5 kB");
+        assert_eq!(fmt_bytes(38_000_000.0), "38 MB");
+        assert_eq!(fmt_bytes(2_900_000_000.0), "2.9 GB");
+        assert_eq!(fmt_bytes(12_000_000_000_000.0), "12 TB");
+    }
+
+    #[test]
+    fn cancelled_and_unnamed_jobs_are_not_announced() {
+        let mut f = fin(1, "a");
+        assert!(should_notify(&f));
+        f.cancelled = true;
+        assert!(!should_notify(&f));
+        let mut g = fin(2, "b");
+        g.label = "  ".into();
+        assert!(!should_notify(&g));
+    }
+
+    #[test]
+    fn the_notification_names_the_outcome_and_the_error() {
+        let s = BgStrings::default();
+        let mut f = fin(1, "a");
+        assert_eq!(
+            finished_text(&f, &s),
+            ("Upload complete".into(), "Game".into())
+        );
+        f.ok = false;
+        f.kind = "install".into();
+        f.error = Some("The PS5 refused it".into());
+        assert_eq!(
+            finished_text(&f, &s),
+            ("Install failed".into(), "Game\nThe PS5 refused it".into())
+        );
+        f.kind = "relay".into();
+        assert_eq!(finished_text(&f, &s).0, "Failed");
+    }
+
+    #[test]
+    fn missing_strings_fall_back_to_english() {
+        let s: BgStrings = serde_json::from_str(r#"{"uploading":"Envoi de {name}"}"#).unwrap();
+        assert_eq!(s.uploading, "Envoi de {name}");
+        assert_eq!(s.done_install, "Installed");
+    }
+
+    #[test]
+    fn a_hold_expires_without_refresh() {
+        bg_work_hold(true);
+        let now = now_ms();
+        assert!(hold_active(now));
+        assert!(!hold_active(now + HOLD_TTL_MS));
+        bg_work_hold(false);
+        assert!(!hold_active(now));
+    }
+}
diff --git a/client/src-tauri/src/commands/local_fs.rs b/client/src-tauri/src/commands/local_fs.rs
index f9d56b03..91166016 100644
--- a/client/src-tauri/src/commands/local_fs.rs
+++ b/client/src-tauri/src/commands/local_fs.rs
@@ -200,61 +200,9 @@ mod tests {
 
 #[cfg(target_os = "android")]
 mod android {
+    use crate::android_jni::{app_context, vm};
     use jni::objects::{GlobalRef, JObject, JString, JValue};
-    use jni::{JNIEnv, JavaVM};
-    use std::ffi::c_void;
-    use std::sync::{Mutex, OnceLock};
-
-    /// JavaVM captured at native-library load.
-    ///
-    /// Tauri 2's Android backend (a Kotlin WryActivity that `loadLibrary`s
-    /// this `.so`) does NOT initialize the `ndk_context` crate's global —
-    /// tao carries its own internal glue and never calls
-    /// `ndk_context::initialize_android_context`. So the old
-    /// `ndk_context::android_context()` here always hit an uninitialized
-    /// global and aborted the whole app on first use ("android context was
-    /// not initialized"). We capture the VM ourselves in `JNI_OnLoad`
-    /// instead — the runtime calls it once when the library loads, before
-    /// any Tauri command can run, and neither wry nor tao defines it.
-    static JVM: OnceLock<JavaVM> = OnceLock::new();
-
-    /// Android runtime entry point, invoked on `System.loadLibrary`.
-    #[no_mangle]
-    pub extern "system" fn JNI_OnLoad(
-        vm: *mut jni::sys::JavaVM,
-        _reserved: *mut c_void,
-    ) -> jni::sys::jint {
-        if let Ok(vm) = unsafe { JavaVM::from_raw(vm) } {
-            let _ = JVM.set(vm);
-        }
-        jni::sys::JNI_VERSION_1_6
-    }
-
-    fn vm() -> Result<&'static JavaVM, String> {
-        JVM.get()
-            .ok_or_else(|| "Android JavaVM unavailable (JNI_OnLoad not run)".to_string())
-    }
-
-    /// The app's Application context — a `Context` we can use for
-    /// `getSystemService` and `startActivity(FLAG_ACTIVITY_NEW_TASK)`.
-    /// Fetched via `ActivityThread.currentApplication()` so we don't need a
-    /// captured Activity (or the unavailable `ndk_context`).
-    fn app_context<'local>(env: &mut JNIEnv<'local>) -> Result<JObject<'local>, String> {
-        let app = env
-            .call_static_method(
-                "android/app/ActivityThread",
-                "currentApplication",
-                "()Landroid/app/Application;",
-                &[],
-            )
-            .map_err(|e| format!("currentApplication: {e}"))?
-            .l()
-            .map_err(|e| format!("application obj: {e}"))?;
-        if app.is_null() {
-            return Err("currentApplication() returned null".into());
-        }
-        Ok(app)
-    }
+    use std::sync::Mutex;
 
     fn sdk_int(env: &mut jni::JNIEnv) -> Result<i32, String> {
         env.get_static_field("android/os/Build$VERSION", "SDK_INT", "I")
diff --git a/client/src-tauri/src/engine_mobile.rs b/client/src-tauri/src/engine_mobile.rs
index 2189e6dc..460d23f1 100644
--- a/client/src-tauri/src/engine_mobile.rs
+++ b/client/src-tauri/src/engine_mobile.rs
@@ -37,6 +37,13 @@ const BIND: &str = "0.0.0.0:19113";
 /// The renderer's engine-status tick tolerates the brief startup race
 /// (it retries), matching how the desktop readiness probe is advisory.
 pub async fn start(app: &AppHandle) -> Result<&'static str> {
+    // Android can run setup again when its Activity is recreated while the process lives on;
+    // the engine from the first run still holds the port, and a second bind would only fail
+    // and tell the renderer the engine did not start.
+    static STARTED: std::sync::OnceLock<()> = std::sync::OnceLock::new();
+    if STARTED.set(()).is_err() {
+        return Ok(DEFAULT_ENGINE_URL);
+    }
     point_engine_at_app_data(app);
     let app = app.clone();
     tokio::spawn(async move {
diff --git a/client/src-tauri/src/lib.rs b/client/src-tauri/src/lib.rs
index 0610d19f..51edf89b 100644
--- a/client/src-tauri/src/lib.rs
+++ b/client/src-tauri/src/lib.rs
@@ -43,6 +43,13 @@ mod mgmt_forward;
 // One-time 6.0 upgrade clean-up of the app's data folder (see the module doc).
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
 mod migrate_6;
+// Background watcher: job notifications and, on Android, the transfer service (#457).
+#[cfg(target_os = "android")]
+mod android_bg;
+mod bg_activity;
+// The JavaVM / Application context every Android JNI caller shares.
+#[cfg(target_os = "android")]
+mod android_jni;
 
 /// Build and run the Tauri application. The desktop `main.rs` calls this
 /// directly; on mobile the `tauri::mobile_entry_point` macro generates
@@ -196,6 +203,9 @@ pub fn run() {
                         // something was squatting it.
                         use tauri::Emitter;
                         let _ = handle.emit("ps5upload-engine-ready", &url);
+                        // Watches the engine for running and finished jobs from here on,
+                        // whatever the WebView is doing.
+                        bg_activity::spawn(&handle);
                     }
                     Err(e) => {
                         let message = format!("engine failed to start: {e:#}");
@@ -554,6 +564,12 @@ pub fn run() {
             commands::local_storage_roots,
             commands::storage_access_granted,
             commands::request_storage_access,
+            // ── Background work (#457) ──────────────────────────────
+            // The renderer's queued-work hold, its visibility / language,
+            // and whether the host posts job notifications itself.
+            bg_activity::bg_work_hold,
+            bg_activity::bg_configure,
+            bg_activity::bg_capabilities,
         ])
         .build(tauri::generate_context!())
         .expect("tauri runtime failed to build");
diff --git a/client/src-tauri/tauri.conf.json b/client/src-tauri/tauri.conf.json
index b7456e31..c736222a 100644
--- a/client/src-tauri/tauri.conf.json
+++ b/client/src-tauri/tauri.conf.json
@@ -23,7 +23,8 @@
         "fullscreen": false,
         "center": true,
         "decorations": true,
-        "transparent": false
+        "transparent": false,
+        "backgroundThrottling": "disabled"
       }
     ],
     "security": {
diff --git a/client/src/i18n/locales/ar.ts b/client/src/i18n/locales/ar.ts
index 3d96266a..ceacc4a8 100644
--- a/client/src/i18n/locales/ar.ts
+++ b/client/src/i18n/locales/ar.ts
@@ -3937,6 +3937,24 @@ pm_update_available: "{tag} متاح",
 pm_update_tooltip: "ينزّل الإصدار الأحدث ويخزّنه في Payload Manager مكان هذا، مع الإبقاء على ترتيبه في قائمة الإقلاع.",
 pm_updated: "تم تحديث {name} إلى {tag}",
 pm_update_failed: "تعذّر تحديث {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "جارٍ رفع {name}",
+bg_downloading: "جارٍ تنزيل {name}",
+bg_installing: "جارٍ تثبيت {name}",
+bg_working: "جارٍ معالجة {name}",
+bg_jobs_running: "{n} مهام قيد التشغيل",
+bg_waiting: "في انتظار العنصر التالي",
+bg_progress_of: "{done} من {total}",
+bg_done_upload: "اكتمل الرفع",
+bg_done_download: "اكتمل التنزيل",
+bg_done_install: "تم التثبيت",
+bg_done_job: "اكتمل",
+bg_failed_upload: "فشل الرفع",
+bg_failed_download: "فشل التنزيل",
+bg_failed_install: "فشل التثبيت",
+bg_failed_job: "فشل",
+bg_channel_progress: "عمليات نقل جارية",
+bg_channel_results: "عمليات نقل مكتملة",
 };
 
 export default ar;
diff --git a/client/src/i18n/locales/bn.ts b/client/src/i18n/locales/bn.ts
index cccbed5d..931c8db1 100644
--- a/client/src/i18n/locales/bn.ts
+++ b/client/src/i18n/locales/bn.ts
@@ -3937,6 +3937,24 @@ pm_update_available: "{tag} পাওয়া যাচ্ছে",
 pm_update_tooltip: "নতুন রিলিজ ডাউনলোড করে এটির জায়গায় Payload Manager-এ রাখে, বুট তালিকায় এর জায়গা বজায় রেখে।",
 pm_updated: "{name} {tag}-এ আপডেট হয়েছে",
 pm_update_failed: "{name} আপডেট করা যায়নি",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} আপলোড হচ্ছে",
+bg_downloading: "{name} ডাউনলোড হচ্ছে",
+bg_installing: "{name} ইনস্টল হচ্ছে",
+bg_working: "{name} প্রক্রিয়া করা হচ্ছে",
+bg_jobs_running: "{n}টি কাজ চলছে",
+bg_waiting: "পরের আইটেমের অপেক্ষায়",
+bg_progress_of: "{total}-এর মধ্যে {done}",
+bg_done_upload: "আপলোড সম্পন্ন",
+bg_done_download: "ডাউনলোড সম্পন্ন",
+bg_done_install: "ইনস্টল হয়েছে",
+bg_done_job: "সম্পন্ন",
+bg_failed_upload: "আপলোড ব্যর্থ",
+bg_failed_download: "ডাউনলোড ব্যর্থ",
+bg_failed_install: "ইনস্টল ব্যর্থ",
+bg_failed_job: "ব্যর্থ",
+bg_channel_progress: "চলমান স্থানান্তর",
+bg_channel_results: "সম্পন্ন স্থানান্তর",
 };
 
 export default bn;
diff --git a/client/src/i18n/locales/de.ts b/client/src/i18n/locales/de.ts
index 6850a2dc..0507ec83 100644
--- a/client/src/i18n/locales/de.ts
+++ b/client/src/i18n/locales/de.ts
@@ -3945,6 +3945,24 @@ pm_update_available: "{tag} verfügbar",
 pm_update_tooltip: "Lädt die neuere Version herunter und legt sie anstelle dieser in Payload Manager ab; ihr Platz in der Startliste bleibt.",
 pm_updated: "{name} auf {tag} aktualisiert",
 pm_update_failed: "{name} konnte nicht aktualisiert werden",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} wird hochgeladen",
+bg_downloading: "{name} wird heruntergeladen",
+bg_installing: "{name} wird installiert",
+bg_working: "{name} wird verarbeitet",
+bg_jobs_running: "{n} Aufträge laufen",
+bg_waiting: "Warten auf das nächste Element",
+bg_progress_of: "{done} von {total}",
+bg_done_upload: "Upload abgeschlossen",
+bg_done_download: "Download abgeschlossen",
+bg_done_install: "Installiert",
+bg_done_job: "Fertig",
+bg_failed_upload: "Upload fehlgeschlagen",
+bg_failed_download: "Download fehlgeschlagen",
+bg_failed_install: "Installation fehlgeschlagen",
+bg_failed_job: "Fehlgeschlagen",
+bg_channel_progress: "Laufende Übertragungen",
+bg_channel_results: "Abgeschlossene Übertragungen",
 };
 
 export default de;
diff --git a/client/src/i18n/locales/en.ts b/client/src/i18n/locales/en.ts
index 77592642..11be25af 100644
--- a/client/src/i18n/locales/en.ts
+++ b/client/src/i18n/locales/en.ts
@@ -4260,6 +4260,24 @@ pm_update_available: "{tag} available",
 pm_update_tooltip: "Downloads the newer release and stores it in Payload Manager in place of this one, keeping its place in the boot list.",
 pm_updated: "Updated {name} to {tag}",
 pm_update_failed: "Couldn't update {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Uploading {name}",
+bg_downloading: "Downloading {name}",
+bg_installing: "Installing {name}",
+bg_working: "Working on {name}",
+bg_jobs_running: "{n} jobs running",
+bg_waiting: "Waiting for the next item",
+bg_progress_of: "{done} of {total}",
+bg_done_upload: "Upload complete",
+bg_done_download: "Download complete",
+bg_done_install: "Installed",
+bg_done_job: "Finished",
+bg_failed_upload: "Upload failed",
+bg_failed_download: "Download failed",
+bg_failed_install: "Install failed",
+bg_failed_job: "Failed",
+bg_channel_progress: "Transfers in progress",
+bg_channel_results: "Finished transfers",
 };
 
 export default en;
diff --git a/client/src/i18n/locales/es.ts b/client/src/i18n/locales/es.ts
index b508e4a7..b4931d4f 100644
--- a/client/src/i18n/locales/es.ts
+++ b/client/src/i18n/locales/es.ts
@@ -3887,6 +3887,24 @@ pm_update_available: "{tag} disponible",
 pm_update_tooltip: "Descarga la versión más nueva y la guarda en Payload Manager en lugar de esta, manteniendo su lugar en la lista de arranque.",
 pm_updated: "{name} actualizado a {tag}",
 pm_update_failed: "No se pudo actualizar {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Subiendo {name}",
+bg_downloading: "Descargando {name}",
+bg_installing: "Instalando {name}",
+bg_working: "Procesando {name}",
+bg_jobs_running: "{n} tareas en curso",
+bg_waiting: "Esperando el siguiente elemento",
+bg_progress_of: "{done} de {total}",
+bg_done_upload: "Subida completada",
+bg_done_download: "Descarga completada",
+bg_done_install: "Instalado",
+bg_done_job: "Terminado",
+bg_failed_upload: "Error al subir",
+bg_failed_download: "Error al descargar",
+bg_failed_install: "Error al instalar",
+bg_failed_job: "Error",
+bg_channel_progress: "Transferencias en curso",
+bg_channel_results: "Transferencias terminadas",
 };
 
 export default es;
diff --git a/client/src/i18n/locales/fa.ts b/client/src/i18n/locales/fa.ts
index f454900a..683cfe00 100644
--- a/client/src/i18n/locales/fa.ts
+++ b/client/src/i18n/locales/fa.ts
@@ -4238,6 +4238,24 @@ pm_update_available: "{tag} موجود است",
 pm_update_tooltip: "نسخهٔ جدیدتر را دانلود و به‌جای این یکی در Payload Manager ذخیره می‌کند و جایش را در فهرست بوت نگه می‌دارد.",
 pm_updated: "{name} به {tag} به‌روزرسانی شد",
 pm_update_failed: "به‌روزرسانی {name} ممکن نشد",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "در حال بارگذاری {name}",
+bg_downloading: "در حال دانلود {name}",
+bg_installing: "در حال نصب {name}",
+bg_working: "در حال پردازش {name}",
+bg_jobs_running: "{n} کار در حال اجرا",
+bg_waiting: "در انتظار مورد بعدی",
+bg_progress_of: "{done} از {total}",
+bg_done_upload: "بارگذاری کامل شد",
+bg_done_download: "دانلود کامل شد",
+bg_done_install: "نصب شد",
+bg_done_job: "تمام شد",
+bg_failed_upload: "بارگذاری ناموفق بود",
+bg_failed_download: "دانلود ناموفق بود",
+bg_failed_install: "نصب ناموفق بود",
+bg_failed_job: "ناموفق",
+bg_channel_progress: "انتقال‌های در حال انجام",
+bg_channel_results: "انتقال‌های تمام‌شده",
 };
 
 export default fa;
diff --git a/client/src/i18n/locales/fr.ts b/client/src/i18n/locales/fr.ts
index da8b2c87..70737183 100644
--- a/client/src/i18n/locales/fr.ts
+++ b/client/src/i18n/locales/fr.ts
@@ -3955,6 +3955,24 @@ pm_update_available: "{tag} disponible",
 pm_update_tooltip: "Télécharge la version plus récente et la stocke dans Payload Manager à la place de celle-ci, en gardant sa place dans la liste de démarrage.",
 pm_updated: "{name} mis à jour en {tag}",
 pm_update_failed: "Impossible de mettre à jour {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Envoi de {name}",
+bg_downloading: "Téléchargement de {name}",
+bg_installing: "Installation de {name}",
+bg_working: "Traitement de {name}",
+bg_jobs_running: "{n} tâches en cours",
+bg_waiting: "En attente de l’élément suivant",
+bg_progress_of: "{done} sur {total}",
+bg_done_upload: "Envoi terminé",
+bg_done_download: "Téléchargement terminé",
+bg_done_install: "Installé",
+bg_done_job: "Terminé",
+bg_failed_upload: "Échec de l’envoi",
+bg_failed_download: "Échec du téléchargement",
+bg_failed_install: "Échec de l’installation",
+bg_failed_job: "Échec",
+bg_channel_progress: "Transferts en cours",
+bg_channel_results: "Transferts terminés",
 };
 
 export default fr;
diff --git a/client/src/i18n/locales/hi.ts b/client/src/i18n/locales/hi.ts
index 41788b33..e7b5c0da 100644
--- a/client/src/i18n/locales/hi.ts
+++ b/client/src/i18n/locales/hi.ts
@@ -3953,6 +3953,24 @@ pm_update_available: "{tag} उपलब्ध",
 pm_update_tooltip: "नया रिलीज़ डाउनलोड करके इसकी जगह Payload Manager में रखता है, बूट सूची में इसकी जगह बनाए रखते हुए।",
 pm_updated: "{name} को {tag} पर अपडेट किया गया",
 pm_update_failed: "{name} अपडेट नहीं हो सका",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} अपलोड हो रहा है",
+bg_downloading: "{name} डाउनलोड हो रहा है",
+bg_installing: "{name} इंस्टॉल हो रहा है",
+bg_working: "{name} पर काम चल रहा है",
+bg_jobs_running: "{n} काम चल रहे हैं",
+bg_waiting: "अगले आइटम की प्रतीक्षा",
+bg_progress_of: "{total} में से {done}",
+bg_done_upload: "अपलोड पूरा हुआ",
+bg_done_download: "डाउनलोड पूरा हुआ",
+bg_done_install: "इंस्टॉल हो गया",
+bg_done_job: "पूरा हुआ",
+bg_failed_upload: "अपलोड विफल",
+bg_failed_download: "डाउनलोड विफल",
+bg_failed_install: "इंस्टॉल विफल",
+bg_failed_job: "विफल",
+bg_channel_progress: "चल रहे ट्रांसफ़र",
+bg_channel_results: "पूरे हुए ट्रांसफ़र",
 };
 
 export default hi;
diff --git a/client/src/i18n/locales/hu.ts b/client/src/i18n/locales/hu.ts
index cd3ac746..8f201825 100644
--- a/client/src/i18n/locales/hu.ts
+++ b/client/src/i18n/locales/hu.ts
@@ -4252,6 +4252,24 @@ pm_update_available: "{tag} elérhető",
 pm_update_tooltip: "Letölti az újabb kiadást, és ennek helyére teszi a Payload Managerben, megtartva a helyét az indítási listában.",
 pm_updated: "{name} frissítve erre: {tag}",
 pm_update_failed: "{name} frissítése nem sikerült",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} feltöltése",
+bg_downloading: "{name} letöltése",
+bg_installing: "{name} telepítése",
+bg_working: "{name} feldolgozása",
+bg_jobs_running: "{n} feladat fut",
+bg_waiting: "Várakozás a következő elemre",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "Feltöltés kész",
+bg_done_download: "Letöltés kész",
+bg_done_install: "Telepítve",
+bg_done_job: "Kész",
+bg_failed_upload: "A feltöltés sikertelen",
+bg_failed_download: "A letöltés sikertelen",
+bg_failed_install: "A telepítés sikertelen",
+bg_failed_job: "Sikertelen",
+bg_channel_progress: "Folyamatban lévő átvitelek",
+bg_channel_results: "Befejezett átvitelek",
 };
 
 export default hu;
diff --git a/client/src/i18n/locales/id.ts b/client/src/i18n/locales/id.ts
index 84847589..234cd89f 100644
--- a/client/src/i18n/locales/id.ts
+++ b/client/src/i18n/locales/id.ts
@@ -3946,6 +3946,24 @@ pm_update_available: "{tag} tersedia",
 pm_update_tooltip: "Mengunduh rilis yang lebih baru dan menyimpannya di Payload Manager menggantikan yang ini, dengan tetap di urutan boot yang sama.",
 pm_updated: "{name} diperbarui ke {tag}",
 pm_update_failed: "Tidak bisa memperbarui {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Mengunggah {name}",
+bg_downloading: "Mengunduh {name}",
+bg_installing: "Memasang {name}",
+bg_working: "Memproses {name}",
+bg_jobs_running: "{n} tugas berjalan",
+bg_waiting: "Menunggu item berikutnya",
+bg_progress_of: "{done} dari {total}",
+bg_done_upload: "Unggahan selesai",
+bg_done_download: "Unduhan selesai",
+bg_done_install: "Terpasang",
+bg_done_job: "Selesai",
+bg_failed_upload: "Unggahan gagal",
+bg_failed_download: "Unduhan gagal",
+bg_failed_install: "Pemasangan gagal",
+bg_failed_job: "Gagal",
+bg_channel_progress: "Transfer berjalan",
+bg_channel_results: "Transfer selesai",
 };
 
 export default id;
diff --git a/client/src/i18n/locales/it.ts b/client/src/i18n/locales/it.ts
index 15af5f80..db07a4ca 100644
--- a/client/src/i18n/locales/it.ts
+++ b/client/src/i18n/locales/it.ts
@@ -3887,6 +3887,24 @@ pm_update_available: "{tag} disponibile",
 pm_update_tooltip: "Scarica la versione più recente e la salva in Payload Manager al posto di questa, mantenendo il suo posto nella lista di avvio.",
 pm_updated: "{name} aggiornato a {tag}",
 pm_update_failed: "Impossibile aggiornare {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Caricamento di {name}",
+bg_downloading: "Download di {name}",
+bg_installing: "Installazione di {name}",
+bg_working: "Elaborazione di {name}",
+bg_jobs_running: "{n} attività in corso",
+bg_waiting: "In attesa del prossimo elemento",
+bg_progress_of: "{done} di {total}",
+bg_done_upload: "Caricamento completato",
+bg_done_download: "Download completato",
+bg_done_install: "Installato",
+bg_done_job: "Completato",
+bg_failed_upload: "Caricamento non riuscito",
+bg_failed_download: "Download non riuscito",
+bg_failed_install: "Installazione non riuscita",
+bg_failed_job: "Non riuscito",
+bg_channel_progress: "Trasferimenti in corso",
+bg_channel_results: "Trasferimenti completati",
 };
 
 export default it;
diff --git a/client/src/i18n/locales/ja.ts b/client/src/i18n/locales/ja.ts
index 98f0b45f..0a8f41f4 100644
--- a/client/src/i18n/locales/ja.ts
+++ b/client/src/i18n/locales/ja.ts
@@ -3958,6 +3958,24 @@ pm_update_available: "{tag} があります",
 pm_update_tooltip: "新しいリリースをダウンロードし、これと置き換えて Payload Manager に保存します。起動リストでの順番はそのままです。",
 pm_updated: "{name} を {tag} に更新しました",
 pm_update_failed: "{name} を更新できませんでした",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} をアップロード中",
+bg_downloading: "{name} をダウンロード中",
+bg_installing: "{name} をインストール中",
+bg_working: "{name} を処理中",
+bg_jobs_running: "{n} 件のジョブを実行中",
+bg_waiting: "次の項目を待っています",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "アップロード完了",
+bg_done_download: "ダウンロード完了",
+bg_done_install: "インストール完了",
+bg_done_job: "完了",
+bg_failed_upload: "アップロード失敗",
+bg_failed_download: "ダウンロード失敗",
+bg_failed_install: "インストール失敗",
+bg_failed_job: "失敗",
+bg_channel_progress: "進行中の転送",
+bg_channel_results: "完了した転送",
 };
 
 export default ja;
diff --git a/client/src/i18n/locales/ko.ts b/client/src/i18n/locales/ko.ts
index 1a220687..424d658a 100644
--- a/client/src/i18n/locales/ko.ts
+++ b/client/src/i18n/locales/ko.ts
@@ -3956,6 +3956,24 @@ pm_update_available: "{tag} 사용 가능",
 pm_update_tooltip: "새 릴리스를 내려받아 이것 대신 Payload Manager에 저장하며, 부팅 목록의 순서는 그대로 둡니다.",
 pm_updated: "{name}을(를) {tag}(으)로 업데이트했습니다",
 pm_update_failed: "{name}을(를) 업데이트하지 못했습니다",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} 업로드 중",
+bg_downloading: "{name} 다운로드 중",
+bg_installing: "{name} 설치 중",
+bg_working: "{name} 처리 중",
+bg_jobs_running: "작업 {n}개 진행 중",
+bg_waiting: "다음 항목 대기 중",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "업로드 완료",
+bg_done_download: "다운로드 완료",
+bg_done_install: "설치됨",
+bg_done_job: "완료",
+bg_failed_upload: "업로드 실패",
+bg_failed_download: "다운로드 실패",
+bg_failed_install: "설치 실패",
+bg_failed_job: "실패",
+bg_channel_progress: "진행 중인 전송",
+bg_channel_results: "완료된 전송",
 };
 
 export default ko;
diff --git a/client/src/i18n/locales/pl.ts b/client/src/i18n/locales/pl.ts
index 51f1ae52..2df94250 100644
--- a/client/src/i18n/locales/pl.ts
+++ b/client/src/i18n/locales/pl.ts
@@ -4192,6 +4192,24 @@ pm_update_available: "Dostępna {tag}",
 pm_update_tooltip: "Pobiera nowsze wydanie i zapisuje je w Payload Manager zamiast tego, zachowując jego miejsce na liście startowej.",
 pm_updated: "Zaktualizowano {name} do {tag}",
 pm_update_failed: "Nie udało się zaktualizować {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Wysyłanie: {name}",
+bg_downloading: "Pobieranie: {name}",
+bg_installing: "Instalowanie: {name}",
+bg_working: "Przetwarzanie: {name}",
+bg_jobs_running: "Uruchomione zadania: {n}",
+bg_waiting: "Oczekiwanie na następny element",
+bg_progress_of: "{done} z {total}",
+bg_done_upload: "Wysyłanie zakończone",
+bg_done_download: "Pobieranie zakończone",
+bg_done_install: "Zainstalowano",
+bg_done_job: "Zakończono",
+bg_failed_upload: "Wysyłanie nie powiodło się",
+bg_failed_download: "Pobieranie nie powiodło się",
+bg_failed_install: "Instalacja nie powiodła się",
+bg_failed_job: "Niepowodzenie",
+bg_channel_progress: "Trwające transfery",
+bg_channel_results: "Zakończone transfery",
 };
 
 export default pl;
diff --git a/client/src/i18n/locales/pt-BR.ts b/client/src/i18n/locales/pt-BR.ts
index db22d373..eb8e2e36 100644
--- a/client/src/i18n/locales/pt-BR.ts
+++ b/client/src/i18n/locales/pt-BR.ts
@@ -3954,6 +3954,24 @@ pm_update_available: "{tag} disponível",
 pm_update_tooltip: "Baixa a versão mais nova e a guarda no Payload Manager no lugar desta, mantendo a posição na lista de inicialização.",
 pm_updated: "{name} atualizado para {tag}",
 pm_update_failed: "Não foi possível atualizar {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Enviando {name}",
+bg_downloading: "Baixando {name}",
+bg_installing: "Instalando {name}",
+bg_working: "Processando {name}",
+bg_jobs_running: "{n} tarefas em andamento",
+bg_waiting: "Aguardando o próximo item",
+bg_progress_of: "{done} de {total}",
+bg_done_upload: "Envio concluído",
+bg_done_download: "Download concluído",
+bg_done_install: "Instalado",
+bg_done_job: "Concluído",
+bg_failed_upload: "Falha no envio",
+bg_failed_download: "Falha no download",
+bg_failed_install: "Falha na instalação",
+bg_failed_job: "Falhou",
+bg_channel_progress: "Transferências em andamento",
+bg_channel_results: "Transferências concluídas",
 };
 
 export default pt_BR;
diff --git a/client/src/i18n/locales/ru.ts b/client/src/i18n/locales/ru.ts
index 3457ac53..9bf4b58d 100644
--- a/client/src/i18n/locales/ru.ts
+++ b/client/src/i18n/locales/ru.ts
@@ -3887,6 +3887,24 @@ pm_update_available: "Доступна {tag}",
 pm_update_tooltip: "Скачивает более новый выпуск и сохраняет его в Payload Manager вместо этого, сохраняя место в списке загрузки.",
 pm_updated: "{name} обновлён до {tag}",
 pm_update_failed: "Не удалось обновить {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Отправка: {name}",
+bg_downloading: "Скачивание: {name}",
+bg_installing: "Установка: {name}",
+bg_working: "Обработка: {name}",
+bg_jobs_running: "Выполняется задач: {n}",
+bg_waiting: "Ожидание следующего элемента",
+bg_progress_of: "{done} из {total}",
+bg_done_upload: "Отправка завершена",
+bg_done_download: "Скачивание завершено",
+bg_done_install: "Установлено",
+bg_done_job: "Готово",
+bg_failed_upload: "Не удалось отправить",
+bg_failed_download: "Не удалось скачать",
+bg_failed_install: "Не удалось установить",
+bg_failed_job: "Ошибка",
+bg_channel_progress: "Активные передачи",
+bg_channel_results: "Завершённые передачи",
 };
 
 export default ru;
diff --git a/client/src/i18n/locales/th.ts b/client/src/i18n/locales/th.ts
index 8fe7d11c..27120b92 100644
--- a/client/src/i18n/locales/th.ts
+++ b/client/src/i18n/locales/th.ts
@@ -3946,6 +3946,24 @@ pm_update_available: "มี {tag} แล้ว",
 pm_update_tooltip: "ดาวน์โหลดรุ่นที่ใหม่กว่าและเก็บใน Payload Manager แทนตัวนี้ โดยคงลำดับในรายการบูตไว้",
 pm_updated: "อัปเดต {name} เป็น {tag} แล้ว",
 pm_update_failed: "อัปเดต {name} ไม่ได้",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "กำลังอัปโหลด {name}",
+bg_downloading: "กำลังดาวน์โหลด {name}",
+bg_installing: "กำลังติดตั้ง {name}",
+bg_working: "กำลังดำเนินการ {name}",
+bg_jobs_running: "มี {n} งานที่กำลังทำ",
+bg_waiting: "กำลังรอรายการถัดไป",
+bg_progress_of: "{done} จาก {total}",
+bg_done_upload: "อัปโหลดเสร็จแล้ว",
+bg_done_download: "ดาวน์โหลดเสร็จแล้ว",
+bg_done_install: "ติดตั้งแล้ว",
+bg_done_job: "เสร็จแล้ว",
+bg_failed_upload: "อัปโหลดไม่สำเร็จ",
+bg_failed_download: "ดาวน์โหลดไม่สำเร็จ",
+bg_failed_install: "ติดตั้งไม่สำเร็จ",
+bg_failed_job: "ไม่สำเร็จ",
+bg_channel_progress: "การถ่ายโอนที่กำลังดำเนินอยู่",
+bg_channel_results: "การถ่ายโอนที่เสร็จแล้ว",
 };
 
 export default th;
diff --git a/client/src/i18n/locales/tr.ts b/client/src/i18n/locales/tr.ts
index 81a1244a..de287e2c 100644
--- a/client/src/i18n/locales/tr.ts
+++ b/client/src/i18n/locales/tr.ts
@@ -3944,6 +3944,24 @@ pm_update_available: "{tag} mevcut",
 pm_update_tooltip: "Daha yeni sürümü indirir ve bunun yerine Payload Manager'a kaydeder; açılış listesindeki yeri korunur.",
 pm_updated: "{name}, {tag} sürümüne güncellendi",
 pm_update_failed: "{name} güncellenemedi",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "{name} yükleniyor",
+bg_downloading: "{name} indiriliyor",
+bg_installing: "{name} kuruluyor",
+bg_working: "{name} işleniyor",
+bg_jobs_running: "{n} iş çalışıyor",
+bg_waiting: "Sıradaki öğe bekleniyor",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "Yükleme tamamlandı",
+bg_done_download: "İndirme tamamlandı",
+bg_done_install: "Kuruldu",
+bg_done_job: "Bitti",
+bg_failed_upload: "Yükleme başarısız",
+bg_failed_download: "İndirme başarısız",
+bg_failed_install: "Kurulum başarısız",
+bg_failed_job: "Başarısız",
+bg_channel_progress: "Süren aktarımlar",
+bg_channel_results: "Biten aktarımlar",
 };
 
 export default tr;
diff --git a/client/src/i18n/locales/vi.ts b/client/src/i18n/locales/vi.ts
index 75fe87b0..3c7a8a81 100644
--- a/client/src/i18n/locales/vi.ts
+++ b/client/src/i18n/locales/vi.ts
@@ -3939,6 +3939,24 @@ pm_update_available: "Có {tag}",
 pm_update_tooltip: "Tải bản phát hành mới hơn và lưu vào Payload Manager thay cho bản này, giữ nguyên vị trí trong danh sách khởi động.",
 pm_updated: "Đã cập nhật {name} lên {tag}",
 pm_update_failed: "Không cập nhật được {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "Đang tải lên {name}",
+bg_downloading: "Đang tải xuống {name}",
+bg_installing: "Đang cài đặt {name}",
+bg_working: "Đang xử lý {name}",
+bg_jobs_running: "{n} tác vụ đang chạy",
+bg_waiting: "Đang chờ mục tiếp theo",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "Tải lên hoàn tất",
+bg_done_download: "Tải xuống hoàn tất",
+bg_done_install: "Đã cài đặt",
+bg_done_job: "Hoàn tất",
+bg_failed_upload: "Tải lên thất bại",
+bg_failed_download: "Tải xuống thất bại",
+bg_failed_install: "Cài đặt thất bại",
+bg_failed_job: "Thất bại",
+bg_channel_progress: "Đang truyền",
+bg_channel_results: "Đã truyền xong",
 };
 
 export default vi;
diff --git a/client/src/i18n/locales/zh-CN.ts b/client/src/i18n/locales/zh-CN.ts
index bf672380..0d9d356b 100644
--- a/client/src/i18n/locales/zh-CN.ts
+++ b/client/src/i18n/locales/zh-CN.ts
@@ -3893,6 +3893,24 @@ pm_update_available: "有 {tag}",
 pm_update_tooltip: "下载较新的版本并替换此项存入 Payload Manager，开机列表中的位置不变。",
 pm_updated: "已将 {name} 更新到 {tag}",
 pm_update_failed: "无法更新 {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "正在上传 {name}",
+bg_downloading: "正在下载 {name}",
+bg_installing: "正在安装 {name}",
+bg_working: "正在处理 {name}",
+bg_jobs_running: "{n} 个任务进行中",
+bg_waiting: "等待下一项",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "上传完成",
+bg_done_download: "下载完成",
+bg_done_install: "已安装",
+bg_done_job: "已完成",
+bg_failed_upload: "上传失败",
+bg_failed_download: "下载失败",
+bg_failed_install: "安装失败",
+bg_failed_job: "失败",
+bg_channel_progress: "进行中的传输",
+bg_channel_results: "已完成的传输",
 };
 
 export default zh_CN;
diff --git a/client/src/i18n/locales/zh-TW.ts b/client/src/i18n/locales/zh-TW.ts
index e3603fe7..ee44cbbc 100644
--- a/client/src/i18n/locales/zh-TW.ts
+++ b/client/src/i18n/locales/zh-TW.ts
@@ -3887,6 +3887,24 @@ pm_update_available: "有 {tag}",
 pm_update_tooltip: "下載較新的版本並取代此項存入 Payload Manager，開機清單中的位置不變。",
 pm_updated: "已將 {name} 更新到 {tag}",
 pm_update_failed: "無法更新 {name}",
+// Background transfers: the host's notifications (#457)
+bg_uploading: "正在上傳 {name}",
+bg_downloading: "正在下載 {name}",
+bg_installing: "正在安裝 {name}",
+bg_working: "正在處理 {name}",
+bg_jobs_running: "{n} 個工作進行中",
+bg_waiting: "等待下一項",
+bg_progress_of: "{done} / {total}",
+bg_done_upload: "上傳完成",
+bg_done_download: "下載完成",
+bg_done_install: "已安裝",
+bg_done_job: "已完成",
+bg_failed_upload: "上傳失敗",
+bg_failed_download: "下載失敗",
+bg_failed_install: "安裝失敗",
+bg_failed_job: "失敗",
+bg_channel_progress: "進行中的傳輸",
+bg_channel_results: "已完成的傳輸",
 };
 
 export default zh_TW;
diff --git a/client/src/layout/AppShell.tsx b/client/src/layout/AppShell.tsx
index 56107696..b6263b37 100644
--- a/client/src/layout/AppShell.tsx
+++ b/client/src/layout/AppShell.tsx
@@ -39,6 +39,7 @@ import { engineApi } from "../api/engine";
 import { fetchHwPower, payloadCheck, portCheck, procListGet } from "../api/ps5";
 import { sessionNeedsAttention } from "../lib/consoleSession";
 import { installActivityWiring } from "../state/activityWiring";
+import { installBgWork } from "../lib/bgWork";
 import { installTaskWiring } from "../state/taskWiring";
 import {
   ensureRosterMigrated,
@@ -1369,6 +1370,9 @@ export default function AppShell() {
   // call on every render because installActivityWiring is idempotent.
   useEffect(() => {
     installActivityWiring();
+    // The host's background watcher: job names, page visibility, notification
+    // texts, and its wake-ups for the queue (#457). Idempotent; no-op in a browser.
+    installBgWork();
     // Subscribe-once: wires the same per-feature stores into the
     // unified Task store (v5 §10). Idempotent — safe to call repeatedly.
     installTaskWiring();
diff --git a/client/src/lib/bgNotify.ts b/client/src/lib/bgNotify.ts
new file mode 100644
index 00000000..a15765f4
--- /dev/null
+++ b/client/src/lib/bgNotify.ts
@@ -0,0 +1,39 @@
+// Whether the host posts job complete / failed notifications itself (#457).
+//
+// The desktop and Android hosts watch the engine from Rust (bg_activity.rs) and
+// notify when a job ends, whatever the WebView is doing. When they do, the
+// renderer must not mirror its own notification for the same ending, or the
+// person gets two. The browser build has no host: false, the old behaviour.
+//
+// Kept apart from lib/bgWork.ts so state/notifications.ts can use it without an
+// import cycle; uses the raw Tauri invoke for the same reason (invokeLogged pulls
+// in the log and session stores).
+
+import { invoke } from "@tauri-apps/api/core";
+import { isTauriEnv } from "./tauriEnv";
+
+let known: boolean | null = null;
+let pending: Promise<boolean> | null = null;
+
+/** True once the host reports its watcher running. A false answer is asked again
+ *  next time: the watcher starts after the engine, which can be after the first ask. */
+export function nativeJobNotify(): Promise<boolean> {
+  if (known) return Promise.resolve(true);
+  if (!isTauriEnv()) return Promise.resolve(false);
+  pending ??= invoke<{ native_job_notify?: boolean }>("bg_capabilities")
+    .then((c) => {
+      known = c?.native_job_notify === true;
+      return known;
+    })
+    .catch(() => false)
+    .finally(() => {
+      pending = null;
+    });
+  return pending;
+}
+
+/** Test hook: forget the cached answer. */
+export function resetNativeJobNotifyForTests(): void {
+  known = null;
+  pending = null;
+}
diff --git a/client/src/lib/bgWork.test.ts b/client/src/lib/bgWork.test.ts
new file mode 100644
index 00000000..20d55435
--- /dev/null
+++ b/client/src/lib/bgWork.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("./tauriEnv", () => ({ isTauriEnv: () => false }));
+
+import { bgStrings, labelEngineJob } from "./bgWork";
+
+describe("bgWork", () => {
+  it("sends exactly the texts the host's BgStrings reads", () => {
+    // bg_activity.rs ignores unknown keys and falls back to English for missing
+    // ones, so a renamed field would silently stop translating.
+    // Read through Vite: the client tsconfig ships no node types.
+    const rs = (
+      import.meta.glob("../../src-tauri/src/bg_activity.rs", {
+        query: "?raw",
+        import: "default",
+        eager: true,
+      }) as Record<string, string>
+    )["../../src-tauri/src/bg_activity.rs"];
+    const body = rs.slice(rs.indexOf("pub struct BgStrings {"));
+    const fields = [...body.slice(0, body.indexOf("}")).matchAll(/pub (\w+): String/g)].map(
+      (m) => m[1],
+    );
+    expect(fields.length).toBeGreaterThan(10);
+    expect(Object.keys(bgStrings()).sort()).toEqual([...fields].sort());
+  });
+
+  it("keeps the placeholders the host fills in", () => {
+    const s = bgStrings();
+    expect(s.uploading).toContain("{name}");
+    expect(s.jobs_running).toContain("{n}");
+    expect(s.progress_of).toContain("{done}");
+    expect(s.progress_of).toContain("{total}");
+  });
+
+  it("names no job outside Tauri (the web UI has no host)", () => {
+    const fetchSpy = vi.spyOn(globalThis, "fetch");
+    labelEngineJob("job-1", "upload", "Astro Bot");
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+});
diff --git a/client/src/lib/bgWork.ts b/client/src/lib/bgWork.ts
new file mode 100644
index 00000000..655f20e2
--- /dev/null
+++ b/client/src/lib/bgWork.ts
@@ -0,0 +1,94 @@
+// The renderer's half of background work (#457).
+//
+// The desktop / Android host watches the engine from Rust (src-tauri/src/bg_activity.rs):
+// it keeps the app running while jobs run, shows their progress (Android) and posts
+// complete / failed notifications. This module gives it what only the page knows:
+//
+//   * a readable name for each job the page starts (`labelEngineJob`), sent to the
+//     engine so the host's notification says "Uploading Astro Bot", not a job id;
+//   * whether the page is showing, the person's notification setting, and the
+//     notification texts in their language (`bg_configure`);
+//   * and it passes the host's `bg-tick` / `bg-job-finished` events to the queue's
+//     sleeps (lib/wakeableSleep), so the queue moves on while the window is hidden.
+//
+// Outside Tauri (the self-hosted web UI) there is no host: everything here no-ops.
+
+import { listen } from "@tauri-apps/api/event";
+
+import { invoke } from "./invokeLogged";
+import { isTauriEnv } from "./tauriEnv";
+import { trStatic } from "./trStatic";
+import { wakeSleepers } from "./wakeableSleep";
+import { getEngineUrl } from "../state/engine";
+import { useLangStore } from "../state/lang";
+import { subscribeLocaleLoaded } from "../i18n";
+import { useNotificationsStore } from "../state/notifications";
+
+export type BgJobKind = "upload" | "download" | "install";
+
+/** Name an engine job for the host's notifications. Fire-and-forget: a job without
+ *  a name still runs; it just goes unannounced. */
+export function labelEngineJob(jobId: string | null | undefined, kind: BgJobKind, label: string): void {
+  if (!isTauriEnv() || !jobId || !label.trim()) return;
+  void fetch(`${getEngineUrl()}/api/activity/label`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ job_id: jobId, kind, label }),
+  }).catch(() => {
+    /* an older or unreachable engine: no name, nothing else lost */
+  });
+}
+
+/** The notification texts, keyed as bg_activity.rs's `BgStrings`. */
+export function bgStrings(): Record<string, string> {
+  return {
+    uploading: trStatic("bg_uploading", "Uploading {name}"),
+    downloading: trStatic("bg_downloading", "Downloading {name}"),
+    installing: trStatic("bg_installing", "Installing {name}"),
+    working: trStatic("bg_working", "Working on {name}"),
+    jobs_running: trStatic("bg_jobs_running", "{n} jobs running"),
+    waiting: trStatic("bg_waiting", "Waiting for the next item"),
+    progress_of: trStatic("bg_progress_of", "{done} of {total}"),
+    done_upload: trStatic("bg_done_upload", "Upload complete"),
+    done_download: trStatic("bg_done_download", "Download complete"),
+    done_install: trStatic("bg_done_install", "Installed"),
+    done_job: trStatic("bg_done_job", "Finished"),
+    failed_upload: trStatic("bg_failed_upload", "Upload failed"),
+    failed_download: trStatic("bg_failed_download", "Download failed"),
+    failed_install: trStatic("bg_failed_install", "Install failed"),
+    failed_job: trStatic("bg_failed_job", "Failed"),
+    channel_progress: trStatic("bg_channel_progress", "Transfers in progress"),
+    channel_results: trStatic("bg_channel_results", "Finished transfers"),
+  };
+}
+
+function configure(config: { visible?: boolean; notify?: boolean; strings?: Record<string, string> }): void {
+  invoke("bg_configure", { config }).catch(() => {
+    /* older host without the command */
+  });
+}
+
+let installed = false;
+
+/** Wire the page to the host's background watcher. Idempotent. */
+export function installBgWork(): void {
+  if (installed || !isTauriEnv()) return;
+  installed = true;
+
+  void listen("bg-tick", () => wakeSleepers()).catch(() => {});
+  void listen("bg-job-finished", () => wakeSleepers({ polls: true })).catch(() => {});
+
+  const visible = () => document.visibilityState !== "hidden";
+  configure({
+    visible: visible(),
+    notify: useNotificationsStore.getState().osNotifyEnabled,
+    strings: bgStrings(),
+  });
+  document.addEventListener("visibilitychange", () => configure({ visible: visible() }));
+  useNotificationsStore.subscribe((s, prev) => {
+    if (s.osNotifyEnabled !== prev.osNotifyEnabled) configure({ notify: s.osNotifyEnabled });
+  });
+  // A language's texts arrive after its chunk loads, not when it is picked.
+  useLangStore.subscribe(() => configure({ strings: bgStrings() }));
+  subscribeLocaleLoaded(() => configure({ strings: bgStrings() }));
+}
diff --git a/client/src/lib/keepAwakeHold.browser.test.ts b/client/src/lib/keepAwakeHold.browser.test.ts
index 2f19f552..f15f5c58 100644
--- a/client/src/lib/keepAwakeHold.browser.test.ts
+++ b/client/src/lib/keepAwakeHold.browser.test.ts
@@ -13,7 +13,7 @@ vi.mock("@tauri-apps/api/core", () => ({
 }));
 vi.mock("./tauriEnv", () => ({ isTauriEnv: () => false }));
 
-import { setTransferKeepAwake } from "./keepAwakeHold";
+import { setBackgroundWorkHold, setTransferKeepAwake } from "./keepAwakeHold";
 
 const flush = () => new Promise((r) => setTimeout(r, 0));
 
@@ -23,6 +23,10 @@ describe("setTransferKeepAwake in a browser", () => {
     await flush();
     setTransferKeepAwake(false);
     await flush();
+    setBackgroundWorkHold(true);
+    await flush();
+    setBackgroundWorkHold(false);
+    await flush();
     expect(calls).toEqual([]);
   });
 });
diff --git a/client/src/lib/keepAwakeHold.test.ts b/client/src/lib/keepAwakeHold.test.ts
index a9ddb5ac..541fef9a 100644
--- a/client/src/lib/keepAwakeHold.test.ts
+++ b/client/src/lib/keepAwakeHold.test.ts
@@ -14,7 +14,7 @@ vi.mock("@tauri-apps/api/core", () => ({
 // the mocked Tauri invoke above; force the Tauri path so this mock is used.
 vi.mock("./tauriEnv", () => ({ isTauriEnv: () => true }));
 
-import { setTransferKeepAwake } from "./keepAwakeHold";
+import { setBackgroundWorkHold, setTransferKeepAwake } from "./keepAwakeHold";
 
 const flush = () => new Promise((r) => setTimeout(r, 0));
 
@@ -53,3 +53,31 @@ describe("setTransferKeepAwake", () => {
     ]);
   });
 });
+
+describe("setBackgroundWorkHold", () => {
+  it("tells the host on each edge and refreshes every minute while held", async () => {
+    vi.useFakeTimers();
+    try {
+      calls.length = 0;
+      const holds = () => calls.filter((c) => c.cmd === "bg_work_hold");
+      setBackgroundWorkHold(true);
+      setBackgroundWorkHold(true); // steady state: no repeat
+      await vi.advanceTimersByTimeAsync(0);
+      expect(holds()).toEqual([{ cmd: "bg_work_hold", args: { active: true } }]);
+      // The host forgets a hold after 5 minutes without a refresh.
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(holds()).toHaveLength(2);
+      await vi.advanceTimersByTimeAsync(120_000);
+      expect(holds()).toHaveLength(4);
+      setBackgroundWorkHold(false);
+      await vi.advanceTimersByTimeAsync(0);
+      expect(holds()[holds().length - 1]).toEqual({ cmd: "bg_work_hold", args: { active: false } });
+      // Released: the refresh stops.
+      const n = holds().length;
+      await vi.advanceTimersByTimeAsync(300_000);
+      expect(holds()).toHaveLength(n);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
diff --git a/client/src/lib/keepAwakeHold.ts b/client/src/lib/keepAwakeHold.ts
index a5cb4dec..6ed59ed3 100644
--- a/client/src/lib/keepAwakeHold.ts
+++ b/client/src/lib/keepAwakeHold.ts
@@ -71,3 +71,36 @@ export function setTransferKeepAwake(active: boolean): void {
     }
   });
 }
+
+// ── Background-work hold (#457) ─────────────────────────────────────────
+// The host's background watcher (src-tauri/src/bg_activity.rs) keeps the app
+// running — on Android, a foreground service — while the engine has a job, and
+// also while this hold says work is queued between jobs (an upload queue
+// settling before its next item), when the engine has nothing running. The host
+// drops a hold not refreshed for 5 minutes, so a renderer frozen while holding
+// cannot keep the service up forever: refresh it every minute while held.
+
+const BG_REFRESH_MS = 60_000;
+let bgHeld = false;
+let bgRefresh: ReturnType<typeof setInterval> | null = null;
+
+function sendBgHold(active: boolean): void {
+  // Native command only; the self-hosted web UI has no host (see above).
+  if (!isTauriEnv()) return;
+  invoke("bg_work_hold", { active }).catch(() => {
+    // Best-effort, like the keep-awake hold.
+  });
+}
+
+/** Hold (`true`) or release the host's background-work hold. Edge-only, plus a
+ *  refresh every minute while held. */
+export function setBackgroundWorkHold(active: boolean): void {
+  if (active === bgHeld) return;
+  bgHeld = active;
+  if (bgRefresh !== null) {
+    clearInterval(bgRefresh);
+    bgRefresh = null;
+  }
+  sendBgHold(active);
+  if (active) bgRefresh = setInterval(() => sendBgHold(true), BG_REFRESH_MS);
+}
diff --git a/client/src/lib/wakeableSleep.test.ts b/client/src/lib/wakeableSleep.test.ts
new file mode 100644
index 00000000..efa8c610
--- /dev/null
+++ b/client/src/lib/wakeableSleep.test.ts
@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { sleep, wakeSleepers } from "./wakeableSleep";
+
+describe("wakeableSleep", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("resolves on its own timer like a plain sleep", async () => {
+    vi.useFakeTimers();
+    let done = false;
+    void sleep(500).then(() => (done = true));
+    await vi.advanceTimersByTimeAsync(499);
+    expect(done).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(done).toBe(true);
+  });
+
+  it("a host tick ends a sleep whose time is up even when its timer is held back", async () => {
+    // A hidden window's timer can fire a minute late; the host's clock stands in.
+    let done = false;
+    void sleep(500).then(() => (done = true));
+    wakeSleepers(undefined, Date.now() + 100);
+    await Promise.resolve();
+    expect(done).toBe(false);
+    wakeSleepers(undefined, Date.now() + 600);
+    await Promise.resolve();
+    expect(done).toBe(true);
+  });
+
+  it("a finished job ends poll sleeps at once and leaves settle delays alone", async () => {
+    let poll = false;
+    let settle = false;
+    void sleep(500, { poll: true }).then(() => (poll = true));
+    void sleep(1500).then(() => (settle = true));
+    wakeSleepers({ polls: true });
+    await Promise.resolve();
+    expect(poll).toBe(true);
+    expect(settle).toBe(false);
+    wakeSleepers(undefined, Date.now() + 2000);
+    await Promise.resolve();
+    expect(settle).toBe(true);
+  });
+});
diff --git a/client/src/lib/wakeableSleep.ts b/client/src/lib/wakeableSleep.ts
new file mode 100644
index 00000000..89adab47
--- /dev/null
+++ b/client/src/lib/wakeableSleep.ts
@@ -0,0 +1,45 @@
+// A sleep the desktop/Android host can end (#457).
+//
+// A hidden window throttles setTimeout (Chromium clamps it to once a minute after
+// a while; a hidden WKWebView can be suspended), so a queue waiting 500 ms between
+// status polls could sit for a minute while the app is in the background. The host
+// watcher (src-tauri/src/bg_activity.rs) sends `bg-tick` every second while work
+// runs and `bg-job-finished` when an engine job ends; lib/bgWork.ts forwards those
+// here. A tick ends every sleep whose time is up, so the host's clock stands in for
+// the throttled timer; a finished job also ends the sleeps marked `poll`, so the
+// next status poll sees the ending at once. Nothing ever ends early otherwise: a
+// settle delay between jobs still waits its full time.
+
+interface Sleeper {
+  due: number;
+  poll: boolean;
+  done: () => void;
+}
+
+const sleepers = new Set<Sleeper>();
+
+/** Resolve after `ms`, or sooner when the host says so (see the module comment).
+ *  `poll`: this sleep only spaces out status polls, so a job ending may cut it short. */
+export function sleep(ms: number, opts?: { poll?: boolean }): Promise<void> {
+  return new Promise((resolve) => {
+    const s: Sleeper = {
+      due: Date.now() + ms,
+      poll: opts?.poll ?? false,
+      done: () => {
+        sleepers.delete(s);
+        clearTimeout(timer);
+        resolve();
+      },
+    };
+    const timer = setTimeout(s.done, ms);
+    sleepers.add(s);
+  });
+}
+
+/** End every sleep whose time is up (`bg-tick`), and with `polls` every poll sleep too
+ *  (`bg-job-finished`). */
+export function wakeSleepers(opts?: { polls?: boolean }, now = Date.now()): void {
+  for (const s of [...sleepers]) {
+    if (s.due <= now || (opts?.polls && s.poll)) s.done();
+  }
+}
diff --git a/client/src/screens/FileSystem/index.tsx b/client/src/screens/FileSystem/index.tsx
index a328efb6..9f800065 100644
--- a/client/src/screens/FileSystem/index.tsx
+++ b/client/src/screens/FileSystem/index.tsx
@@ -201,6 +201,7 @@ import {
   withConsolePrefix,
 } from "../../state/roster";
 import { useStaleHostGuard } from "../../lib/staleHostGuard";
+import { labelEngineJob } from "../../lib/bgWork";
 
 function parent(p: string): string {
   if (p === "/" || p === "") return "/";
@@ -803,14 +804,15 @@ export default function FileSystemScreen() {
                   undefined,
                   "The install registered, but the title may not launch. Check it on the Games screen.",
                 ),
+                jobOutcome: true,
               }
-            : undefined,
+            : { jobOutcome: true },
         );
       } else {
         pushNotification(
           "error",
           tr("fs_install_failed", { name: entry.name }, `Install failed`),
-          { body: r.message },
+          { body: r.message, jobOutcome: true },
         );
       }
     } finally {
@@ -2216,6 +2218,7 @@ export default function FileSystemScreen() {
       fsDownload.end(friendly);
       return;
     }
+    labelEngineJob(jobId, "download", rootName);
     const myRunId = fsDownload.begin({
       jobId,
       rootName,
@@ -2240,7 +2243,7 @@ export default function FileSystemScreen() {
           host,
           tr("notif_fs_download_failed", undefined, "Download failed"),
         ),
-        { body: friendly },
+        { body: friendly, jobOutcome: true },
       );
       fsDownload.end(friendly);
     };
diff --git a/client/src/state/activityWiring.ts b/client/src/state/activityWiring.ts
index ce9ef09d..87e62c0a 100644
--- a/client/src/state/activityWiring.ts
+++ b/client/src/state/activityWiring.ts
@@ -11,7 +11,7 @@ import {
   type ActivityKind,
   type ActivityPhase,
 } from "./activityHistory";
-import { setTransferKeepAwake } from "../lib/keepAwakeHold";
+import { setBackgroundWorkHold, setTransferKeepAwake } from "../lib/keepAwakeHold";
 import { anyAwakeWork } from "../lib/awakeWork";
 import { useTaskStore } from "./tasks";
 
@@ -68,7 +68,15 @@ export function installActivityWiring() {
     if (anyAwakeWork(useTaskStore.getState().tasks)) return true;
     return false;
   };
-  const reconcileKeepAwake = () => setTransferKeepAwake(anyTransferActive());
+  // The host's background-work hold (#457) also covers a queue between items: its
+  // drain loop is running but no item is, for the settle delay before the next.
+  const queueDraining = (): boolean =>
+    Object.values(useUploadQueueStore.getState().runningHosts).some(Boolean);
+  const reconcileKeepAwake = () => {
+    const active = anyTransferActive();
+    setTransferKeepAwake(active);
+    setBackgroundWorkHold(active || queueDraining());
+  };
   useTaskStore.subscribe(reconcileKeepAwake);
   useTransferStore.subscribe(reconcileKeepAwake);
   useFsDownloadOpStore.subscribe(reconcileKeepAwake);
diff --git a/client/src/state/fpkgConversion.ts b/client/src/state/fpkgConversion.ts
index 1c18fa97..a0eb8be8 100644
--- a/client/src/state/fpkgConversion.ts
+++ b/client/src/state/fpkgConversion.ts
@@ -252,6 +252,8 @@ function fail(stage: PipelineStage, message: string, packagePath: string | null)
   // An install-stage failure links to the install-route matrix entry for its
   // error; a build failure has no such page, so it goes back to Convert.
   pushNotification("error", `${what} failed`, {
+    // The install stage's failure is an engine job's ending, which the host announces.
+    jobOutcome: stage === "install",
     body: message,
     link: stage === "install" ? installErrorLink(message) : "/convert",
   });
@@ -374,7 +376,11 @@ async function runInstall(packagePath: string, host: string | null, method: Inst
     const cur = running()!;
     const convertMs = cur.mode === "install" ? 0 : startedMs - cur.startedMs;
     installDone(packagePath, convertMs, Date.now() - startedMs);
-    pushNotification("success", "Installed on the PS5", { body: packagePath, link: "/convert" });
+    pushNotification("success", "Installed on the PS5", {
+      body: packagePath,
+      link: "/convert",
+      jobOutcome: true,
+    });
   } else {
     fail("install", r.message ?? "The install did not finish.", packagePath);
   }
diff --git a/client/src/state/notifications.test.ts b/client/src/state/notifications.test.ts
index f798f594..d6a48a9c 100644
--- a/client/src/state/notifications.test.ts
+++ b/client/src/state/notifications.test.ts
@@ -5,7 +5,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 // so the vi.mock factory can reference it.
 const { mockSend, state } = vi.hoisted(() => ({
   mockSend: vi.fn(),
-  state: { foreground: true },
+  state: { foreground: true, native: false },
 }));
 
 vi.mock("../lib/osNotify", () => ({
@@ -14,12 +14,20 @@ vi.mock("../lib/osNotify", () => ({
   ensureOsNotificationPermission: vi.fn(async () => false),
 }));
 
+// Whether the host posts job outcomes itself (desktop / Android watcher).
+vi.mock("../lib/bgNotify", () => ({
+  nativeJobNotify: () => Promise.resolve(state.native),
+}));
+
 import { useNotificationsStore } from "./notifications";
 
+const flush = () => new Promise((r) => setTimeout(r, 0));
+
 describe("notifications → OS notification mirror", () => {
   beforeEach(() => {
     mockSend.mockClear();
     state.foreground = true;
+    state.native = false;
     useNotificationsStore.setState({ entries: [], osNotifyEnabled: true });
   });
 
@@ -57,4 +65,29 @@ describe("notifications → OS notification mirror", () => {
     expect(entries[0]?.title).toBe("Done");
     expect(entries[0]?.level).toBe("success");
   });
+
+  it("leaves a job outcome to the host when the host notifies job endings", async () => {
+    state.foreground = false;
+    state.native = true;
+    useNotificationsStore
+      .getState()
+      .push("success", "Upload complete", { body: "Astro Bot", jobOutcome: true });
+    await flush();
+    expect(mockSend).not.toHaveBeenCalled();
+    // Still in the inbox.
+    expect(useNotificationsStore.getState().entries[0]?.title).toBe("Upload complete");
+    // Anything else is still mirrored.
+    useNotificationsStore.getState().push("warning", "Low space");
+    expect(mockSend).toHaveBeenCalledTimes(1);
+  });
+
+  it("mirrors a job outcome itself where no host notifies (browser, older host)", async () => {
+    state.foreground = false;
+    state.native = false;
+    useNotificationsStore
+      .getState()
+      .push("error", "Install failed", { body: "refused", jobOutcome: true });
+    await flush();
+    expect(mockSend).toHaveBeenCalledWith("error", "Install failed", "refused");
+  });
 });
diff --git a/client/src/state/notifications.ts b/client/src/state/notifications.ts
index 85af1cae..aeed9065 100644
--- a/client/src/state/notifications.ts
+++ b/client/src/state/notifications.ts
@@ -1,6 +1,7 @@
 import { create } from "zustand";
 
 import { appIsForeground, sendOsNotification } from "../lib/osNotify";
+import { nativeJobNotify } from "../lib/bgNotify";
 import { safeGetItem, safeSetItem } from "../lib/safeStorage";
 import { recordAppEvent } from "../lib/appJournal";
 
@@ -40,13 +41,19 @@ export interface Notification {
   read: boolean;
 }
 
+/** Optional parts of a notification. */
+export interface NotificationExtras {
+  body?: string;
+  link?: string;
+  /** The outcome of an engine job (an upload, download or install finishing or
+   *  failing). The desktop / Android host notifies those itself when it watches the
+   *  engine (lib/bgNotify.ts), so the OS mirror skips them there. */
+  jobOutcome?: boolean;
+}
+
 interface NotificationsState {
   entries: Notification[];
-  push: (
-    level: NotificationLevel,
-    title: string,
-    extras?: { body?: string; link?: string },
-  ) => string;
+  push: (level: NotificationLevel, title: string, extras?: NotificationExtras) => string;
   markAllRead: () => void;
   clear: () => void;
   remove: (id: string) => void;
@@ -125,8 +132,15 @@ export const useNotificationsStore = create<NotificationsState>((set, get) => ({
     // when the app isn't in the foreground, so the user doesn't get a
     // redundant system banner while looking at the in-app inbox.
     // Fire-and-forget: osNotify no-ops outside Tauri and swallows errors.
+    // A job's outcome is left to the host when it posts those itself.
     if (get().osNotifyEnabled && !appIsForeground()) {
-      void sendOsNotification(level, title, extras?.body);
+      if (extras?.jobOutcome) {
+        void nativeJobNotify().then((native) => {
+          if (!native) void sendOsNotification(level, title, extras?.body);
+        });
+      } else {
+        void sendOsNotification(level, title, extras?.body);
+      }
     }
     return entry.id;
   },
@@ -168,7 +182,7 @@ export const useNotificationsStore = create<NotificationsState>((set, get) => ({
 export function pushNotification(
   level: NotificationLevel,
   title: string,
-  extras?: { body?: string; link?: string },
+  extras?: NotificationExtras,
 ): string {
   // What the user was told went wrong is in the bug-report journal, and an error's "Jump to"
   // opens the report with that event pinned (unless the caller links somewhere already).
diff --git a/client/src/state/pkgLibrary.ts b/client/src/state/pkgLibrary.ts
index 839c0144..34f947d8 100644
--- a/client/src/state/pkgLibrary.ts
+++ b/client/src/state/pkgLibrary.ts
@@ -64,6 +64,8 @@ import { useInstallSettingsStore } from "./installSettings";
 import { useConnectionStore } from "./connection";
 import { log } from "./logs";
 import { pushNotification } from "./notifications";
+import { sleep as wakeableSleep } from "../lib/wakeableSleep";
+import { labelEngineJob } from "../lib/bgWork";
 import { installErrorLink } from "../lib/installErrorDoc";
 import { useActivityHistoryStore } from "./activityHistory";
 import {
@@ -1191,7 +1193,8 @@ function mergeListing(prev: PkgEntry[], listed: PkgEntry[]): PkgEntry[] {
   );
 }
 
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+// Ended by the host's clock while the window is hidden (see lib/wakeableSleep).
+const sleep = wakeableSleep;
 
 /** Delete a staged pkg with a few retries on a transient payload failure. Right
  *  after an install the staged file can be momentarily busy (Sony's installer
@@ -1664,6 +1667,7 @@ export async function finalizePkgInstallSuccess(args: {
   // play). Surfaces in the bell even if the user navigated away while a
   // large title finished, which is exactly when a heads-up is wanted.
   pushNotification(mayNotLaunch ? "warning" : "success", `${label} installed`, {
+    jobOutcome: true,
     body: mayNotLaunch
       ? PKG_MAY_NOT_LAUNCH_MESSAGE
       : "Installed on the PS5 and ready to play.",
@@ -1928,6 +1932,8 @@ async function driveUnifiedInstall(
   host: string,
   source: InstallSource,
   meta: {
+    /** The game's name for the host's notifications (#457). */
+    label?: string;
     contentId?: string | null;
     titleId?: string | null;
     packageAppVer?: string | null;
@@ -1969,6 +1975,7 @@ async function driveUnifiedInstall(
   }
   const job = start.job;
   reportInstallJob(host, job);
+  labelEngineJob(job, "install", meta.label || meta.titleId || meta.contentId || "");
   // Poll until the engine's state machine is terminal. There is NO client-side
   // deadline: a large install writes for as long as it needs, and the engine
   // reports "done" only when its own verify agrees (the size-blind client timer
@@ -1991,7 +1998,7 @@ async function driveUnifiedInstall(
     const line = describeInstallSample(sample).detail;
     if (line) onStatus?.(line);
     if (st.phase === "done" || st.phase === "failed") return st;
-    await sleep(PKG_VERIFY_POLL_MS);
+    await sleep(PKG_VERIFY_POLL_MS, { poll: true });
   }
 }
 
@@ -2100,6 +2107,7 @@ export async function runPkgInstall(
       host,
       { console_path: localPs5Path },
       {
+        label: name,
         contentId,
         titleId: titleIdFromContentId(contentId ?? "") ?? null,
         packageAppVer: packageAppVer ?? null,
@@ -2821,6 +2829,7 @@ const makePkgLibraryStore = () =>
           // Without this a failed item — an update or DLC especially — was silent
           // if the user navigated away from the Library tab mid-install.
           pushNotification("error", `${label} install failed`, {
+            jobOutcome: true,
             body: mainErr || "The PS5 didn’t confirm the install. Try again.",
             link: installErrorLink(mainErr),
           });
@@ -3204,6 +3213,7 @@ const makePkgLibraryStore = () =>
         });
         try {
           const terminal = await driveUnifiedInstall(host, { url: trimmed }, {
+            label: name,
             contentId: "",
             options: {},
           });
@@ -3471,6 +3481,7 @@ const makePkgLibraryStore = () =>
             host,
             installSource,
             {
+              label,
               contentId: contentId || "",
               titleId: titleIdFromContentId(contentId ?? "") ?? null,
               // The probe's package_type/category; ends in gd/gp/ac like a
@@ -3554,6 +3565,7 @@ const makePkgLibraryStore = () =>
         const outcome = statusToOutcome(terminal);
         if (outcome.installed) {
           pushNotification("success", `Installed ${label}`, {
+            jobOutcome: true,
             body: remoteUrl
               ? "Link install complete. The package was downloaded from the link and fed straight to the console — nothing was staged."
               : "Stream-install complete. The pkg was fetched over HTTP — nothing was staged on the PS5.",
diff --git a/client/src/state/transfer.ts b/client/src/state/transfer.ts
index 37a07e27..b010fc79 100644
--- a/client/src/state/transfer.ts
+++ b/client/src/state/transfer.ts
@@ -37,6 +37,7 @@ import { useUploadSettingsStore } from "./uploadSettings";
 import { useRecentHostMetricsStore } from "./recentHostMetrics";
 import { jobLiveFromSnapshot, type JobLive } from "../lib/jobLive";
 import { pushNotification } from "./notifications";
+import { labelEngineJob } from "../lib/bgWork";
 import { withConsolePrefix } from "./roster";
 import { trStatic } from "../lib/trStatic";
 
@@ -458,6 +459,7 @@ export const useTransferStore = create<TransferState>((set) => {
         return;
       }
 
+      labelEngineJob(jobId, "upload", uploadName);
       const startedAtMs = Date.now();
       setPhase(key, {
         kind: "running",
diff --git a/client/src/state/uploadQueue.ts b/client/src/state/uploadQueue.ts
index 98d3845b..9639a3d3 100644
--- a/client/src/state/uploadQueue.ts
+++ b/client/src/state/uploadQueue.ts
@@ -60,6 +60,8 @@ import type { UploadStrategy } from "./transfer";
 import { useUploadSettingsStore } from "./uploadSettings";
 import { useRecentHostMetricsStore } from "./recentHostMetrics";
 import { pushNotification } from "./notifications";
+import { sleep } from "../lib/wakeableSleep";
+import { labelEngineJob } from "../lib/bgWork";
 import { withConsolePrefix } from "./roster";
 import { hostOf, mgmtAddr } from "../lib/addr";
 import { log } from "./logs";
@@ -1179,6 +1181,7 @@ export const useUploadQueueStore = create<QueueState>((set, get) => {
     // staleness is harmless — cancelling a finished job is a server no-op).
     runningJobByHost.set(hostOf(item.addr), jobId);
     set((s) => ({ items: patchItem(s.items, item.id, { jobId }) }));
+    labelEngineJob(jobId, "upload", item.displayName);
 
     // Trailing-window samples for the live bytes/sec readout. Closure-
     // scoped so a Stop + restart of the same item resets cleanly: the
@@ -1602,7 +1605,7 @@ export const useUploadQueueStore = create<QueueState>((set, get) => {
           live: jobLiveFromSnapshot(snap),
         }),
       }));
-      await sleep(POLL_INTERVAL_MS);
+      await sleep(POLL_INTERVAL_MS, { poll: true });
     }
     throw new Error("queue stopped");
   };
@@ -2631,6 +2634,3 @@ async function fw12InstallSettle(host: string): Promise<void> {
   if (!ready) await sleep(3000);
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
diff --git a/engine/crates/ps5upload-engine/src/activity.rs b/engine/crates/ps5upload-engine/src/activity.rs
new file mode 100644
index 00000000..9ec26948
--- /dev/null
+++ b/engine/crates/ps5upload-engine/src/activity.rs
@@ -0,0 +1,448 @@
+//! What the engine is working on and what just ended, for the app's background watcher (#457).
+//!
+//! The renderer used to be the only thing that noticed a job finish, and a hidden or frozen
+//! WebView notices nothing. The Tauri host polls `GET /api/activity` instead: running jobs
+//! (transfers and installs) with their progress, plus a ring of recently finished ones with a
+//! monotonic `seq` so a poller sees each ending once. Labels ("Astro Bot", a folder name) come
+//! from the client through `POST /api/activity/label`; the engine only knows ids and paths.
+
+use std::collections::{HashMap, VecDeque};
+use std::sync::{Mutex, OnceLock};
+
+use serde::{Deserialize, Serialize};
+
+/// Finished entries kept for pollers. A poller one second behind needs a handful; 64 covers a
+/// watcher that was paused for a while without growing with the session.
+pub const RING_CAP: usize = 64;
+/// Labels for jobs that never reported an ending (a label posted for an unknown id).
+const LABELS_CAP: usize = 256;
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct Active {
+    pub id: String,
+    pub kind: String,
+    pub label: String,
+    pub bytes_done: u64,
+    pub bytes_total: u64,
+    pub started_at_ms: u64,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct Finished {
+    pub seq: u64,
+    pub id: String,
+    pub kind: String,
+    pub label: String,
+    pub ok: bool,
+    /// The user stopped it: nothing to tell them.
+    pub cancelled: bool,
+    pub error: Option<String>,
+    pub bytes: u64,
+    pub elapsed_ms: u64,
+}
+
+#[derive(Debug, Clone, Default)]
+struct Tag {
+    kind: Option<String>,
+    label: Option<String>,
+    /// Insertion order, for dropping the oldest past `LABELS_CAP`.
+    at: u64,
+}
+
+#[derive(Default)]
+struct Hub {
+    seq: u64,
+    tags: HashMap<String, Tag>,
+    tag_counter: u64,
+    ring: VecDeque<Finished>,
+}
+
+impl Hub {
+    fn tag_mut(&mut self, id: &str) -> &mut Tag {
+        if !self.tags.contains_key(id) && self.tags.len() >= LABELS_CAP {
+            if let Some(oldest) = self
+                .tags
+                .iter()
+                .min_by_key(|(_, t)| t.at)
+                .map(|(k, _)| k.clone())
+            {
+                self.tags.remove(&oldest);
+            }
+        }
+        self.tag_counter += 1;
+        let at = self.tag_counter;
+        self.tags.entry(id.to_string()).or_insert(Tag {
+            at,
+            ..Tag::default()
+        })
+    }
+
+    fn kind_label(&self, id: &str, default_kind: &str) -> (String, String) {
+        let t = self.tags.get(id);
+        (
+            t.and_then(|t| t.kind.clone())
+                .unwrap_or_else(|| default_kind.to_string()),
+            t.and_then(|t| t.label.clone()).unwrap_or_default(),
+        )
+    }
+
+    fn set_kind(&mut self, id: &str, kind: &str) {
+        let t = self.tag_mut(id);
+        if t.kind.is_none() {
+            t.kind = Some(kind.to_string());
+        }
+    }
+
+    fn set_label(&mut self, id: &str, kind: Option<&str>, label: &str) {
+        // The job may have ended before the label arrived (a tiny upload): name its entry.
+        if let Some(e) = self.ring.iter_mut().find(|e| e.id == id) {
+            e.label = label.to_string();
+            return;
+        }
+        let t = self.tag_mut(id);
+        t.label = Some(label.to_string());
+        if let Some(k) = kind.filter(|k| !k.is_empty()) {
+            t.kind = Some(k.to_string());
+        }
+    }
+
+    fn snapshot(&self, since: u64, active: Vec<Active>) -> serde_json::Value {
+        let finished: Vec<&Finished> = self.ring.iter().filter(|e| e.seq > since).collect();
+        serde_json::json!({ "seq": self.seq, "active": active, "finished": finished })
+    }
+
+    fn finish(&mut self, mut f: Finished) {
+        // A job can be written terminal twice (a late ticker, a retry of the final write);
+        // a poller must see its ending once.
+        if self.ring.iter().any(|e| e.id == f.id) {
+            return;
+        }
+        let (kind, label) = self.kind_label(&f.id, &f.kind);
+        self.tags.remove(&f.id);
+        self.seq += 1;
+        f.seq = self.seq;
+        f.kind = kind;
+        // The client's name beats the engine's fallback (an install's title id).
+        if !label.is_empty() {
+            f.label = label;
+        }
+        if self.ring.len() >= RING_CAP {
+            self.ring.pop_front();
+        }
+        self.ring.push_back(f);
+    }
+}
+
+fn hub() -> &'static Mutex<Hub> {
+    static H: OnceLock<Mutex<Hub>> = OnceLock::new();
+    H.get_or_init(|| Mutex::new(Hub::default()))
+}
+
+fn lock() -> std::sync::MutexGuard<'static, Hub> {
+    hub().lock().unwrap_or_else(|e| e.into_inner())
+}
+
+/// The kind a transfer's telemetry shape (`file`, `dir`, `download`, …) is shown as.
+pub fn kind_of_shape(shape: &str) -> &'static str {
+    match shape {
+        "download" | "link_download" => "download",
+        _ => "upload",
+    }
+}
+
+/// Records what kind of job `id` is, unless the client already said.
+pub(crate) fn set_kind(id: &str, kind: &str) {
+    lock().set_kind(id, kind);
+}
+
+/// A readable name for a job, from the client. `kind` overrides the engine's guess.
+pub fn set_label(id: &str, kind: Option<&str>, label: &str) {
+    lock().set_label(id, kind, label);
+}
+
+/// A transfer (or any `JobState` job) reached `done` / `failed`; `state` is its snapshot.
+pub(crate) fn transfer_ended(id: &str, state: &serde_json::Value) {
+    if let Some(f) = transfer_finished(id, state) {
+        lock().finish(f);
+    }
+}
+
+/// An install job ended (the unified install's finish path).
+pub(crate) fn install_ended(st: &crate::install::status::InstallStatus) {
+    lock().finish(install_finished(st));
+}
+
+/// The ending a terminal job snapshot describes; `None` for any other state.
+fn transfer_finished(id: &str, state: &serde_json::Value) -> Option<Finished> {
+    let status = state.get("status").and_then(|v| v.as_str()).unwrap_or("");
+    let ok = status == "done";
+    if !ok && status != "failed" {
+        return None;
+    }
+    let error = state
+        .get("error")
+        .and_then(|v| v.as_str())
+        .map(str::to_string);
+    let reason = state
+        .get("error_reason")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let err = error.as_deref().unwrap_or("");
+    // Same rule as the job summaries (telemetry::result_of).
+    let cancelled = !ok
+        && (reason.contains("cancel") || err.contains("transfer_cancelled") || err == "cancelled");
+    let num = |k: &str| state.get(k).and_then(|v| v.as_u64()).unwrap_or(0);
+    Some(Finished {
+        seq: 0,
+        id: id.to_string(),
+        kind: "job".into(),
+        label: String::new(),
+        ok,
+        cancelled,
+        error: if ok { None } else { error },
+        bytes: num("bytes_sent"),
+        elapsed_ms: num("elapsed_ms"),
+    })
+}
+
+fn install_finished(st: &crate::install::status::InstallStatus) -> Finished {
+    use crate::install::status::{FailReason, Phase, Verdict};
+    let ok = st.phase == Phase::Done && st.verdict != Some(Verdict::Failed);
+    Finished {
+        seq: 0,
+        id: st.job.clone(),
+        kind: "install".into(),
+        label: st.title_id.clone().unwrap_or_else(|| st.content_id.clone()),
+        ok,
+        cancelled: st.reason == Some(FailReason::Cancelled),
+        error: if ok {
+            None
+        } else {
+            Some(st.hint.clone().unwrap_or_else(|| "install failed".into()))
+        },
+        bytes: st.metrics.served_bytes,
+        elapsed_ms: st.updated_at.saturating_sub(st.started_at) * 1000,
+    }
+}
+
+/// The running install `st`, as an activity entry.
+pub(crate) fn install_active(st: &crate::install::status::InstallStatus) -> Active {
+    let (kind, label) = lock().kind_label(&st.job, "install");
+    Active {
+        id: st.job.clone(),
+        kind,
+        label: if label.is_empty() {
+            st.title_id.clone().unwrap_or_else(|| st.content_id.clone())
+        } else {
+            label
+        },
+        bytes_done: st.metrics.served_bytes,
+        bytes_total: st.metrics.total_bytes,
+        started_at_ms: st.started_at * 1000,
+    }
+}
+
+/// The running transfer `id` with its progress, as an activity entry.
+pub(crate) fn transfer_active(id: &str, done: u64, total: u64, started_at_ms: u64) -> Active {
+    let (kind, label) = lock().kind_label(id, "job");
+    Active {
+        id: id.to_string(),
+        kind,
+        label,
+        bytes_done: done,
+        bytes_total: total,
+        started_at_ms,
+    }
+}
+
+/// `{seq, active, finished}`: entries finished after `since`, oldest first.
+pub fn snapshot(since: u64, active: Vec<Active>) -> serde_json::Value {
+    lock().snapshot(since, active)
+}
+
+#[derive(Debug, Deserialize)]
+pub struct SinceQuery {
+    #[serde(default)]
+    pub since: u64,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct LabelReq {
+    pub job_id: String,
+    #[serde(default)]
+    pub kind: Option<String>,
+    pub label: String,
+}
+
+/// `POST /api/activity/label {job_id, kind?, label}`.
+pub async fn label_handler(axum::Json(req): axum::Json<LabelReq>) -> axum::response::Response {
+    use axum::response::IntoResponse;
+    if req.job_id.is_empty() {
+        return (
+            axum::http::StatusCode::BAD_REQUEST,
+            axum::Json(serde_json::json!({"ok": false, "error": "job_id is required"})),
+        )
+            .into_response();
+    }
+    // A name for a notification, not a document: keep it short.
+    let label: String = req.label.trim().chars().take(120).collect();
+    set_label(&req.job_id, req.kind.as_deref(), &label);
+    axum::Json(serde_json::json!({"ok": true})).into_response()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn end(h: &mut Hub, id: &str, state: serde_json::Value) {
+        if let Some(f) = transfer_finished(id, &state) {
+            h.finish(f);
+        }
+    }
+
+    #[test]
+    fn a_finished_job_is_listed_once_with_its_label_and_kind() {
+        let mut h = Hub::default();
+        h.set_kind("a", "upload");
+        h.set_label("a", None, "Astro Bot");
+        end(
+            &mut h,
+            "a",
+            json!({"status":"done","bytes_sent":10,"elapsed_ms":5}),
+        );
+        end(
+            &mut h,
+            "a",
+            json!({"status":"done","bytes_sent":10,"elapsed_ms":5}),
+        );
+        let v = h.snapshot(0, vec![]);
+        assert_eq!(v["seq"], 1);
+        let f = v["finished"].as_array().unwrap();
+        assert_eq!(f.len(), 1);
+        assert_eq!(f[0]["label"], "Astro Bot");
+        assert_eq!(f[0]["kind"], "upload");
+        assert_eq!(f[0]["ok"], true);
+        assert_eq!(f[0]["bytes"], 10);
+        assert!(h.tags.is_empty(), "the label is dropped with the ending");
+        // Nothing new after the seq a poller already has.
+        assert!(h.snapshot(1, vec![])["finished"]
+            .as_array()
+            .unwrap()
+            .is_empty());
+    }
+
+    #[test]
+    fn the_client_kind_wins_and_a_late_label_names_the_entry() {
+        let mut h = Hub::default();
+        h.set_label("b", Some("download"), "Saves");
+        h.set_kind("b", "upload");
+        end(
+            &mut h,
+            "b",
+            json!({"status":"failed","error":"transfer_cancelled"}),
+        );
+        end(&mut h, "c", json!({"status":"failed","error":"boom"}));
+        h.set_label("c", None, "Late");
+        let v = h.snapshot(0, vec![]);
+        let f = v["finished"].as_array().unwrap();
+        assert_eq!(f[0]["kind"], "download");
+        assert_eq!(f[0]["cancelled"], true);
+        assert_eq!(f[1]["kind"], "job");
+        assert_eq!(f[1]["label"], "Late");
+        assert_eq!(f[1]["ok"], false);
+        assert_eq!(f[1]["cancelled"], false);
+        assert_eq!(f[1]["error"], "boom");
+    }
+
+    #[test]
+    fn running_states_are_not_endings() {
+        assert!(transfer_finished("r", &json!({"status":"running"})).is_none());
+    }
+
+    #[test]
+    fn the_ring_keeps_the_newest_and_seq_keeps_climbing() {
+        let mut h = Hub::default();
+        for i in 0..(RING_CAP + 10) {
+            end(&mut h, &format!("j{i}"), json!({"status":"done"}));
+        }
+        let v = h.snapshot(0, vec![]);
+        let f = v["finished"].as_array().unwrap();
+        assert_eq!(f.len(), RING_CAP);
+        assert_eq!(v["seq"], (RING_CAP + 10) as u64);
+        assert_eq!(f[0]["seq"], 11);
+        assert_eq!(f[RING_CAP - 1]["id"], format!("j{}", RING_CAP + 9));
+    }
+
+    #[test]
+    fn labels_for_jobs_that_never_end_are_bounded() {
+        let mut h = Hub::default();
+        for i in 0..(LABELS_CAP + 5) {
+            h.set_label(&format!("x{i}"), None, "n");
+        }
+        assert_eq!(h.tags.len(), LABELS_CAP);
+        assert!(h.tags.contains_key(&format!("x{}", LABELS_CAP + 4)));
+        assert!(!h.tags.contains_key("x0"));
+    }
+
+    #[test]
+    fn an_install_ending_carries_its_verdict_and_the_clients_name() {
+        use crate::install::status::{FailReason, InstallStatus, Phase, Verdict};
+        let mut h = Hub::default();
+        let mut st = InstallStatus::new("1-1", "ps5", "UP0000-PPSA00000_00");
+        st.title_id = Some("PPSA00000".into());
+        st.phase = Phase::Done;
+        st.verdict = Some(Verdict::MayNotLaunch);
+        st.metrics.served_bytes = 7;
+        h.finish(install_finished(&st));
+        let mut st2 = InstallStatus::new("1-2", "ps5", "c");
+        st2.phase = Phase::Failed;
+        st2.verdict = Some(Verdict::Failed);
+        st2.reason = Some(FailReason::Cancelled);
+        h.set_label("1-2", None, "Jak X");
+        h.finish(install_finished(&st2));
+        let v = h.snapshot(0, vec![]);
+        let f = v["finished"].as_array().unwrap();
+        assert_eq!(f[0]["kind"], "install");
+        assert_eq!(f[0]["ok"], true);
+        assert_eq!(f[0]["label"], "PPSA00000");
+        assert_eq!(f[0]["bytes"], 7);
+        assert_eq!(f[1]["ok"], false);
+        assert_eq!(f[1]["cancelled"], true);
+        assert_eq!(f[1]["label"], "Jak X");
+    }
+
+    // The process-wide hub through the label route. Other tests end jobs concurrently, so this
+    // only looks for its own id.
+    #[tokio::test]
+    async fn the_label_route_names_a_job_the_activity_snapshot_reports() {
+        let id = format!("route-{}", uuid::Uuid::new_v4());
+        let r = label_handler(axum::Json(LabelReq {
+            job_id: id.clone(),
+            kind: Some("upload".into()),
+            label: format!("  {}  ", "x".repeat(200)),
+        }))
+        .await;
+        assert_eq!(r.status(), axum::http::StatusCode::OK);
+        let active = transfer_active(&id, 5, 10, 1);
+        assert_eq!(active.kind, "upload");
+        assert_eq!(active.label.chars().count(), 120);
+        transfer_ended(&id, &json!({"status":"done","bytes_sent":10}));
+        let v = snapshot(0, vec![]);
+        let mine: Vec<_> = v["finished"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter(|e| e["id"] == id.as_str())
+            .collect();
+        assert_eq!(mine.len(), 1);
+        assert_eq!(mine[0]["kind"], "upload");
+        let bad = label_handler(axum::Json(LabelReq {
+            job_id: String::new(),
+            kind: None,
+            label: "x".into(),
+        }))
+        .await;
+        assert_eq!(bad.status(), axum::http::StatusCode::BAD_REQUEST);
+    }
+}
diff --git a/engine/crates/ps5upload-engine/src/install/mod.rs b/engine/crates/ps5upload-engine/src/install/mod.rs
index d2f1d811..8ce4ebe7 100644
--- a/engine/crates/ps5upload-engine/src/install/mod.rs
+++ b/engine/crates/ps5upload-engine/src/install/mod.rs
@@ -83,22 +83,33 @@ impl JobStore {
         // Taken before the jobs lock: `begin` locks the slots first, then the jobs.
         let holding: std::collections::HashSet<String> =
             lock(&self.active).values().cloned().collect();
-        let cid = {
+        // Read before the prune, which may drop this very status.
+        let ended = {
             let mut jobs = lock(&self.jobs);
-            let cid = jobs.get(job).map(|st| slot_key(&st.ps5_addr));
+            let ended = jobs.get(job).cloned();
             prune_finished(&mut jobs, KEEP_FINISHED, &holding);
-            cid
+            ended
         };
         lock(&self.cancelled).remove(job);
-        if let Some(cid) = cid {
+        if let Some(st) = ended {
+            let cid = slot_key(&st.ps5_addr);
             let mut active = lock(&self.active);
             // only clear if this job still owns the slot
             if active.get(&cid).map(|j| j.as_str()) == Some(job) {
                 active.remove(&cid);
+                // Once per job: a second finish finds the slot already released.
+                crate::activity::install_ended(&st);
             }
         }
     }
 
+    /// Statuses of the installs still holding a console's slot.
+    pub fn running(&self) -> Vec<InstallStatus> {
+        let ids: Vec<String> = lock(&self.active).values().cloned().collect();
+        let jobs = lock(&self.jobs);
+        ids.iter().filter_map(|j| jobs.get(j).cloned()).collect()
+    }
+
     /// The install task ended without finishing the job (it panicked): a job still
     /// marked running is marked failed so the client stops waiting, and the slot is
     /// released. A job that finished normally was already released; nothing changes.
@@ -1936,6 +1947,17 @@ mod tests {
     }
 
     /// Finishing forgets the stop request and keeps only the newest finished statuses.
+    #[test]
+    fn running_lists_only_installs_holding_a_slot() {
+        let jobs = JobStore::new();
+        let a = jobs.begin("10.1.0.1").unwrap();
+        let b = jobs.begin("10.1.0.2").unwrap();
+        jobs.update(&b, |s| s.phase = Phase::Done);
+        jobs.finish(&b);
+        let running: Vec<String> = jobs.running().into_iter().map(|s| s.job).collect();
+        assert_eq!(running, vec![a]);
+    }
+
     #[test]
     fn finish_prunes_old_statuses_and_stop_requests() {
         let jobs = JobStore::new();
diff --git a/engine/crates/ps5upload-engine/src/lib.rs b/engine/crates/ps5upload-engine/src/lib.rs
index b26961d5..001b76d0 100644
--- a/engine/crates/ps5upload-engine/src/lib.rs
+++ b/engine/crates/ps5upload-engine/src/lib.rs
@@ -31,6 +31,7 @@
 //!   GET  /api/ps5/volumes             → list storage volumes detected by the payload
 //!   GET  /api/ps5/list-dir?path=...   → list immediate children of a directory on PS5
 
+mod activity;
 mod ampr_trace;
 mod ava1_api;
 mod bundled_payload;
@@ -1528,6 +1529,7 @@ pub(crate) fn set_job(
         }
     }
     if terminal {
+        activity::transfer_ended(&job_id.to_string(), &json);
         telemetry::on_state(job_id, &json);
         if let Some(e) = job_event(&job_id.to_string(), &json) {
             ps5upload_core::events::emit_event(e);
@@ -9660,6 +9662,36 @@ async fn engine_version() -> impl IntoResponse {
     )
 }
 
+/// GET /api/activity?since=<seq> — running jobs and the endings after `since`, for the app's
+/// background watcher (see `activity`).
+async fn activity_handler(
+    State(state): State<AppState>,
+    installs: pkg_install::PkgInstallStateHandle,
+    q: activity::SinceQuery,
+) -> impl IntoResponse {
+    let mut active: Vec<activity::Active> = {
+        let jobs = state.jobs.lock().unwrap_or_else(|e| e.into_inner());
+        jobs.iter()
+            .filter_map(|(id, s)| match s {
+                JobState::Running {
+                    started_at_ms,
+                    bytes_sent,
+                    total_bytes,
+                    ..
+                } => Some(activity::transfer_active(
+                    &id.to_string(),
+                    *bytes_sent,
+                    *total_bytes,
+                    *started_at_ms,
+                )),
+                _ => None,
+            })
+            .collect()
+    };
+    active.extend(installs.jobs.running().iter().map(activity::install_active));
+    Json(activity::snapshot(q.since, active))
+}
+
 /// GET /api/jobs
 async fn list_jobs(State(state): State<AppState>) -> impl IntoResponse {
     let jobs = state.jobs.lock().unwrap_or_else(|e| e.into_inner());
@@ -10070,8 +10102,18 @@ async fn run(cfg: EngineConfig) -> anyhow::Result<()> {
         }));
     }
 
+    let activity_installs = pkg_state.clone();
     let app = Router::new()
         .route("/", get(ui_handler))
+        .route(
+            "/api/activity",
+            get(
+                move |st: State<AppState>, Query(q): Query<activity::SinceQuery>| {
+                    activity_handler(st, activity_installs.clone(), q)
+                },
+            ),
+        )
+        .route("/api/activity/label", post(activity::label_handler))
         .route("/api/ps5/status", get(ps5_status))
         .route("/api/ps5/port-check", get(ps5_port_check))
         .route("/api/ps5/readiness", get(ps5_readiness))
diff --git a/engine/crates/ps5upload-engine/src/telemetry.rs b/engine/crates/ps5upload-engine/src/telemetry.rs
index ae615892..c35017e3 100644
--- a/engine/crates/ps5upload-engine/src/telemetry.rs
+++ b/engine/crates/ps5upload-engine/src/telemetry.rs
@@ -55,6 +55,7 @@ fn held() -> &'static Mutex<HashMap<Uuid, Held>> {
 /// Marks a job as one that gets a record when it ends. `kind` is the transfer's shape
 /// (`file`, `dir`, `zip`, `7z`, `rar`, `file_list`, `download`, `relay`, …).
 pub(crate) fn tag(job_id: Uuid, kind: &'static str) {
+    crate::activity::set_kind(&job_id.to_string(), crate::activity::kind_of_shape(kind));
     held()
         .lock()
         .unwrap_or_else(|e| e.into_inner())
diff --git a/scripts/release/android-postinit-patch.sh b/scripts/release/android-postinit-patch.sh
index 6099f4d3..21ea5ed7 100755
--- a/scripts/release/android-postinit-patch.sh
+++ b/scripts/release/android-postinit-patch.sh
@@ -45,6 +45,10 @@
 #    is handled in-app by the user-adjustable "Text size" setting
 #    (client/src/state/uiScale.ts), which rescales the rem root and so resizes
 #    the entire UI. The two fixes are complementary.
+#
+# 6) TransferService, the foreground service that keeps a transfer running
+#    with the app in the background (#457), its manifest entry, permissions
+#    and R8 keep rules. See step (6) below.
 
 set -euo pipefail
 
@@ -344,4 +348,271 @@ print("patched MainActivity.kt to request ACCESS_LOCAL_NETWORK (PS5UploadNet)")
 PY
 fi
 
+# --- (6) background transfers: TransferService (#457) ------------------
+# Android freezes a backgrounded app's process, and the engine runs inside it,
+# so a long upload stopped when the person switched apps. A foreground service
+# keeps the process running while a job is active; the Rust watcher
+# (src-tauri/src/bg_activity.rs → android_bg.rs) starts, updates and stops it
+# through the static methods below and posts complete / failed notifications
+# through it. Type connectedDevice (the PS5 is a device on the network; Android
+# 15 caps dataSync at 6 h a day), dataSync declared as the fallback. The class is
+# rewritten on every run so a change here always reaches the build.
+if [ -n "$mainactivity" ]; then
+  cat >"$(dirname "$mainactivity")/TransferService.kt" <<'KT'
+package com.phantomptr.ps5upload
+
+// Written by scripts/release/android-postinit-patch.sh; edit it there.
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.os.IBinder
+import android.os.PowerManager
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.ServiceCompat
+import androidx.core.content.ContextCompat
+
+/** Keeps the app (and the engine inside it) running while a transfer goes on in the
+ *  background. Driven from Rust (android_bg.rs); never started by anything else. */
+class TransferService : Service() {
+  private var wakeLock: PowerManager.WakeLock? = null
+  private var wifiLock: WifiManager.WifiLock? = null
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    if (!promote()) {
+      stopSelf()
+      return START_NOT_STICKY
+    }
+    instance = this
+    refreshLocks()
+    // Not sticky: a restarted process has a fresh engine with nothing to finish.
+    return START_NOT_STICKY
+  }
+
+  private fun promote(): Boolean {
+    val n = progressNotification(this)
+    val types = if (Build.VERSION.SDK_INT >= 29) {
+      intArrayOf(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+      )
+    } else {
+      intArrayOf(0)
+    }
+    for (type in types) {
+      try {
+        ServiceCompat.startForeground(this, PROGRESS_ID, n, type)
+        return true
+      } catch (e: Exception) {
+        Log.w(TAG, "startForeground type=$type: $e")
+      }
+    }
+    return false
+  }
+
+  // Held with a timeout and refreshed by every progress update, so a watcher that
+  // died without saying stop cannot keep the phone awake for long.
+  private fun refreshLocks() {
+    try {
+      val wl = wakeLock ?: (getSystemService(Context.POWER_SERVICE) as PowerManager)
+        .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ps5upload:transfer")
+        .also { it.setReferenceCounted(false); wakeLock = it }
+      wl.acquire(LOCK_MS)
+      val wf = wifiLock ?: (applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager)
+        .let {
+          @Suppress("DEPRECATION")
+          it.createWifiLock(WifiManager.WIFI_MODE_FULL_HIGH_PERF, "ps5upload:transfer")
+        }
+        .also { it.setReferenceCounted(false); wifiLock = it }
+      if (!wf.isHeld) wf.acquire()
+    } catch (e: Exception) {
+      Log.w(TAG, "locks: $e")
+    }
+  }
+
+  // Android 15+: the time limit for this service type ran out; stop rather than be killed.
+  override fun onTimeout(startId: Int, fgsType: Int) {
+    Log.w(TAG, "foreground time limit reached (type=$fgsType)")
+    stopSelf()
+  }
+
+  override fun onDestroy() {
+    instance = null
+    try { wakeLock?.takeIf { it.isHeld }?.release() } catch (_: Exception) {}
+    try { wifiLock?.takeIf { it.isHeld }?.release() } catch (_: Exception) {}
+    wakeLock = null
+    wifiLock = null
+    ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+    super.onDestroy()
+  }
+
+  companion object {
+    private const val TAG = "PS5UploadTransfer"
+    private const val PROGRESS_ID = 1
+    private const val CH_PROGRESS = "ps5upload_transfers"
+    private const val CH_RESULTS = "ps5upload_results"
+    private const val LOCK_MS = 10 * 60 * 1000L
+
+    @Volatile private var title = ""
+    @Volatile private var text = ""
+    @Volatile private var percent = -1
+    @Volatile private var instance: TransferService? = null
+
+    @JvmStatic
+    fun start(ctx: Context, title: String, text: String, percent: Int, channelName: String) {
+      set(title, text, percent)
+      channel(ctx, CH_PROGRESS, channelName, NotificationManager.IMPORTANCE_LOW)
+      try {
+        ContextCompat.startForegroundService(ctx, Intent(ctx, TransferService::class.java))
+      } catch (e: Exception) {
+        // Android 12+ refuses a start from the background
+        // (ForegroundServiceStartNotAllowedException): show the progress anyway.
+        Log.w(TAG, "start: $e")
+        post(ctx, PROGRESS_ID, progressNotification(ctx))
+      }
+    }
+
+    @JvmStatic
+    fun update(ctx: Context, title: String, text: String, percent: Int) {
+      set(title, text, percent)
+      post(ctx, PROGRESS_ID, progressNotification(ctx))
+      instance?.refreshLocks()
+    }
+
+    @JvmStatic
+    fun finished(ctx: Context, id: Int, title: String, text: String, ok: Boolean, channelName: String) {
+      channel(ctx, CH_RESULTS, channelName, NotificationManager.IMPORTANCE_DEFAULT)
+      val n = NotificationCompat.Builder(ctx, CH_RESULTS)
+        .setSmallIcon(if (ok) android.R.drawable.stat_sys_upload_done else android.R.drawable.stat_notify_error)
+        .setContentTitle(title)
+        .setContentText(text.lineSequence().firstOrNull() ?: "")
+        .setStyle(NotificationCompat.BigTextStyle().bigText(text))
+        .setCategory(if (ok) NotificationCompat.CATEGORY_STATUS else NotificationCompat.CATEGORY_ERROR)
+        .setContentIntent(openApp(ctx))
+        .setAutoCancel(true)
+        .build()
+      post(ctx, id, n)
+    }
+
+    @JvmStatic
+    fun stop(ctx: Context) {
+      try {
+        ctx.stopService(Intent(ctx, TransferService::class.java))
+      } catch (e: Exception) {
+        Log.w(TAG, "stop: $e")
+      }
+      NotificationManagerCompat.from(ctx).cancel(PROGRESS_ID)
+    }
+
+    private fun set(t: String, x: String, p: Int) {
+      title = t
+      text = x
+      percent = p
+    }
+
+    private fun progressNotification(ctx: Context): Notification {
+      val b = NotificationCompat.Builder(ctx, CH_PROGRESS)
+        .setSmallIcon(android.R.drawable.stat_sys_upload)
+        .setContentTitle(title)
+        .setContentText(text)
+        .setOngoing(true)
+        .setOnlyAlertOnce(true)
+        .setSilent(true)
+        .setCategory(NotificationCompat.CATEGORY_PROGRESS)
+        .setContentIntent(openApp(ctx))
+        .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+      if (percent >= 0) b.setProgress(100, percent, false) else b.setProgress(0, 0, true)
+      return b.build()
+    }
+
+    // A tap brings the running app forward, as its launcher icon would.
+    private fun openApp(ctx: Context): PendingIntent {
+      val i = Intent(ctx, MainActivity::class.java)
+        .setAction(Intent.ACTION_MAIN)
+        .addCategory(Intent.CATEGORY_LAUNCHER)
+        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      return PendingIntent.getActivity(
+        ctx, 0, i, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+      )
+    }
+
+    private fun channel(ctx: Context, id: String, name: String, importance: Int) {
+      if (Build.VERSION.SDK_INT < 26) return
+      // Creating an existing channel only renames it (the language may have changed).
+      ctx.getSystemService(NotificationManager::class.java)
+        ?.createNotificationChannel(NotificationChannel(id, name, importance))
+    }
+
+    // Without POST_NOTIFICATIONS (Android 13+, refused) the service still runs; only the
+    // notification is hidden.
+    private fun post(ctx: Context, id: Int, n: Notification) {
+      if (Build.VERSION.SDK_INT >= 33 &&
+        ctx.checkSelfPermission("android.permission.POST_NOTIFICATIONS") != PackageManager.PERMISSION_GRANTED
+      ) return
+      try {
+        NotificationManagerCompat.from(ctx).notify(id, n)
+      } catch (e: SecurityException) {
+        Log.w(TAG, "notify: $e")
+      }
+    }
+  }
+}
+KT
+  echo "wrote TransferService.kt"
+fi
+
+# R8 would rename or drop the static methods only JNI calls.
+cat >"$root/client/src-tauri/gen/android/app/ps5upload-transfer.pro" <<'PRO'
+# TransferService is driven from Rust over JNI (android_bg.rs); keep its names.
+-keep class com.phantomptr.ps5upload.TransferService { *; }
+-keep class com.phantomptr.ps5upload.TransferService$Companion { *; }
+PRO
+echo "wrote ps5upload-transfer.pro"
+
+python3 - "$manifest" <<'PY'
+import re, sys
+path = sys.argv[1]
+src = open(path, encoding="utf-8").read()
+perms = [
+    "android.permission.FOREGROUND_SERVICE",
+    "android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE",
+    "android.permission.FOREGROUND_SERVICE_DATA_SYNC",
+    "android.permission.WAKE_LOCK",
+]
+# Exact attribute match: FOREGROUND_SERVICE is a prefix of the typed ones.
+missing = [p for p in perms if f'android:name="{p}"' not in src]
+if missing:
+    block = "".join(f'\n    <uses-permission android:name="{p}" />' for p in missing)
+    new = re.sub(r"(<manifest\b[^>]*>)", r"\1" + block, src, count=1)
+    if new == src:
+        sys.exit("::error::could not find <manifest> tag to add the service permissions")
+    src = new
+    print("added permissions:", ", ".join(missing))
+else:
+    print("service permissions already present — skipping")
+if ".TransferService" in src:
+    print("TransferService already declared — skipping")
+else:
+    service = ('        <service android:name=".TransferService" android:exported="false"\n'
+               '            android:foregroundServiceType="connectedDevice|dataSync" />\n')
+    new = src.replace("    </application>", service + "    </application>", 1)
+    if new == src:
+        sys.exit("::error::could not find </application> to declare TransferService")
+    src = new
+    print("declared TransferService")
+open(path, "w", encoding="utf-8").write(src)
+PY
+
 echo "android post-init patches applied"