diff --git a/Cargo.lock b/Cargo.lock
index b22a85b..44e5990 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -635,6 +635,7 @@ dependencies = [
  "glib 0.21.5",
  "gtk",
  "iced",
+ "image",
  "inotify",
  "log",
  "lz4_flex",
@@ -2679,6 +2680,19 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png 0.18.1",
+]
+
 [[package]]
 name = "image-webp"
 version = "0.2.4"
@@ -3189,6 +3203,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
 [[package]]
 name = "muda"
 version = "0.17.1"
@@ -3205,7 +3229,7 @@ dependencies = [
  "objc2-core-foundation",
  "objc2-foundation 0.3.2",
  "once_cell",
- "png",
+ "png 0.17.16",
  "thiserror 2.0.18",
  "windows-sys 0.60.2",
 ]
@@ -3966,6 +3990,19 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.0",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "polling"
 version = "3.11.0"
@@ -4100,6 +4137,12 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773"
 
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
 [[package]]
 name = "quick-error"
 version = "2.0.1"
@@ -5207,7 +5250,7 @@ dependencies = [
  "bytemuck",
  "cfg-if",
  "log",
- "png",
+ "png 0.17.16",
  "tiny-skia-path",
 ]
 
@@ -5519,7 +5562,7 @@ dependencies = [
  "objc2-core-graphics",
  "objc2-foundation 0.3.2",
  "once_cell",
- "png",
+ "png 0.17.16",
  "thiserror 2.0.18",
  "windows-sys 0.60.2",
 ]
diff --git a/config.toml b/config.toml
index bdc4d25..45ab9a1 100644
--- a/config.toml
+++ b/config.toml
@@ -173,6 +173,21 @@ bind_addr = "0.0.0.0:7878"
 # Authentication: server validates clients via the framework UserStore.
 # No extra config needed for the server.  Clients set auth_token below.
 
+# Trash settings
+# ──────────────
+# When a file is deleted it is moved into .bh_filesync/trash/ under the root,
+# mirroring the original folder structure.  An index.json inside the trash
+# directory records metadata (original path, deletion time, size, …) for
+# every entry so files can be listed and restored via the API.
+#
+# trash_expiry_days — automatically purge entries older than N days.
+#   0 or omitted → keep forever (manual purge only).
+# trash_expiry_days = 30
+
+# full_scan_interval_secs — how often to do a full filesystem re-scan to
+#   catch changes that inotify may have missed.  Default: 900 (15 minutes).
+# full_scan_interval_secs = 900
+
 exclude_patterns = [
     # ── Python ────────────────────────────────────────────────
     "**/venv/**",
diff --git a/crates/core/assets/bytehive_icon_128x128.png b/crates/core/assets/bytehive_icon_128x128.png
new file mode 100644
index 0000000..401b439
Binary files /dev/null and b/crates/core/assets/bytehive_icon_128x128.png differ
diff --git a/crates/core/assets/bytehive_icon_256x256.png b/crates/core/assets/bytehive_icon_256x256.png
new file mode 100644
index 0000000..108b1b2
Binary files /dev/null and b/crates/core/assets/bytehive_icon_256x256.png differ
diff --git a/crates/core/assets/bytehive_icon_32x32.png b/crates/core/assets/bytehive_icon_32x32.png
new file mode 100644
index 0000000..681e3dc
Binary files /dev/null and b/crates/core/assets/bytehive_icon_32x32.png differ
diff --git a/crates/core/assets/bytehive_icon_64x64.png b/crates/core/assets/bytehive_icon_64x64.png
new file mode 100644
index 0000000..6871ecf
Binary files /dev/null and b/crates/core/assets/bytehive_icon_64x64.png differ
diff --git a/crates/core/assets/bytehive_icon_96x96.png b/crates/core/assets/bytehive_icon_96x96.png
new file mode 100644
index 0000000..70b238e
Binary files /dev/null and b/crates/core/assets/bytehive_icon_96x96.png differ
diff --git a/crates/core/assets/dashboard.html b/crates/core/assets/dashboard.html
index 52ea85d..0a77735 100644
--- a/crates/core/assets/dashboard.html
+++ b/crates/core/assets/dashboard.html
@@ -3,6 +3,13 @@
     <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="/bytehive-icon.svg" />
+        <link
+            rel="icon"
+            type="image/png"
+            sizes="32x32"
+            href="/bytehive_icon_32x32.png"
+        />
         <title>Bytehive — Ops</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
diff --git a/crates/core/assets/filebrowser.html b/crates/core/assets/filebrowser.html
index 9efb9cb..5d5f08d 100644
--- a/crates/core/assets/filebrowser.html
+++ b/crates/core/assets/filebrowser.html
@@ -3,6 +3,13 @@
     <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="/bytehive-icon.svg" />
+        <link
+            rel="icon"
+            type="image/png"
+            sizes="32x32"
+            href="/bytehive_icon_32x32.png"
+        />
         <title>Files — Bytehive</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
diff --git a/crates/core/assets/password_share.html b/crates/core/assets/password_share.html
index 91cee03..980310d 100644
--- a/crates/core/assets/password_share.html
+++ b/crates/core/assets/password_share.html
@@ -3,6 +3,13 @@
     <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="/bytehive-icon.svg" />
+        <link
+            rel="icon"
+            type="image/png"
+            sizes="32x32"
+            href="/bytehive_icon_32x32.png"
+        />
         <title>Protected Share — Bytehive</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
diff --git a/crates/core/assets/portal.html b/crates/core/assets/portal.html
index 5b17051..6ee2956 100644
--- a/crates/core/assets/portal.html
+++ b/crates/core/assets/portal.html
@@ -3,6 +3,13 @@
     <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="/bytehive-icon.svg" />
+        <link
+            rel="icon"
+            type="image/png"
+            sizes="32x32"
+            href="/bytehive_icon_32x32.png"
+        />
         <title>Bytehive</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
@@ -688,7 +695,10 @@
                             id="inp-user"
                             autocomplete="username"
                             placeholder="username"
-                            onkeydown="if(event.key==='Enter')document.getElementById('inp-pass').focus()"
+                            onkeydown="
+                                if (event.key === 'Enter')
+                                    document.getElementById('inp-pass').focus();
+                            "
                         />
                     </div>
                     <div class="lfield">
@@ -698,7 +708,7 @@
                             id="inp-pass"
                             autocomplete="current-password"
                             placeholder="••••••••"
-                            onkeydown="if(event.key==='Enter')doLogin()"
+                            onkeydown="if (event.key === 'Enter') doLogin();"
                         />
                     </div>
                     <button
@@ -920,8 +930,9 @@
                 const r = document.getElementById("sb-role");
                 r.textContent = grps.length ? grps.join(", ") : "(no groups)";
                 r.className = "sb-user-role " + topGroup;
-                document.getElementById("sb-admin-link").style.display =
-                    isAdmin ? "block" : "none";
+                document.getElementById("sb-admin-link").style.display = isAdmin
+                    ? "block"
+                    : "none";
             }
 
             async function loadNav() {
diff --git a/crates/core/assets/setup.html b/crates/core/assets/setup.html
index 4e63222..b301d7b 100644
--- a/crates/core/assets/setup.html
+++ b/crates/core/assets/setup.html
@@ -3,6 +3,13 @@
     <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="/bytehive-icon.svg" />
+        <link
+            rel="icon"
+            type="image/png"
+            sizes="32x32"
+            href="/bytehive_icon_32x32.png"
+        />
         <title>Bytehive — First Run Setup</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
diff --git a/crates/core/assets/share_error.html b/crates/core/assets/share_error.html
index 608ccd6..aa3bc6b 100644
--- a/crates/core/assets/share_error.html
+++ b/crates/core/assets/share_error.html
@@ -3,6 +3,13 @@
     <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="/bytehive-icon.svg" />
+        <link
+            rel="icon"
+            type="image/png"
+            sizes="32x32"
+            href="/bytehive_icon_32x32.png"
+        />
         <title>Link Error — Bytehive</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
diff --git a/crates/core/src/html.rs b/crates/core/src/html.rs
index 4b13c05..abadd99 100644
--- a/crates/core/src/html.rs
+++ b/crates/core/src/html.rs
@@ -25,3 +25,6 @@ pub const SHARE_ERROR: &str = include_str!("../assets/share_error.html");
 pub const PASSWORD_SHARE_ERROR: &str = r#"<p class="err">Incorrect password — try again.</p>"#;
 
 pub const PASSWORD_SHARE: &str = include_str!("../assets/password_share.html");
+
+pub const BYTEHIVE_ICON_32_PNG: &[u8] = include_bytes!("../assets/bytehive_icon_32x32.png");
+pub const BYTEHIVE_ICON_64_PNG: &[u8] = include_bytes!("../assets/bytehive_icon_64x64.png");
diff --git a/crates/core/src/http.rs b/crates/core/src/http.rs
index abf3afc..ffdc80e 100644
--- a/crates/core/src/http.rs
+++ b/crates/core/src/http.rs
@@ -1,6 +1,8 @@
 use crate::auth::Auth;
 use crate::bus::{BusMessage, MessageBus};
-use crate::html::{ADMIN_DASHBOARD_HTML, PORTAL_HTML, SETUP_HTML};
+use crate::html::{
+    ADMIN_DASHBOARD_HTML, BYTEHIVE_ICON_32_PNG, BYTEHIVE_ICON_64_PNG, PORTAL_HTML, SETUP_HTML,
+};
 use crate::registry::AppRegistry;
 use crate::users::{AuthContext, AuthMethod, Group, UserEntry, UserStore};
 
@@ -270,6 +272,8 @@ fn build_router(state: ApiState) -> Router {
         .route("/", get(portal_handler))
         .route("/bytehive-icon.svg", get(bytehive_icon_handler))
         .route("/bytehive-logo-full.svg", get(bytehive_logo_full_handler))
+        .route("/bytehive_icon_32x32.png", get(bytehive_icon_32_handler))
+        .route("/bytehive_icon_64x64.png", get(bytehive_icon_64_handler))
         .route("/web/*path", get(static_handler))
         .route("/s/:token", get(share_handler).post(share_handler))
         .nest("/api/auth", public_auth.merge(authenticated_auth))
@@ -633,6 +637,20 @@ async fn bytehive_logo_full_handler() -> impl IntoResponse {
     )
 }
 
+async fn bytehive_icon_32_handler() -> impl IntoResponse {
+    (
+        [(axum::http::header::CONTENT_TYPE, "image/png")],
+        BYTEHIVE_ICON_32_PNG,
+    )
+}
+
+async fn bytehive_icon_64_handler() -> impl IntoResponse {
+    (
+        [(axum::http::header::CONTENT_TYPE, "image/png")],
+        BYTEHIVE_ICON_64_PNG,
+    )
+}
+
 async fn static_handler(State(s): State<ApiState>, Path(rel): Path<String>) -> impl IntoResponse {
     if s.web_root.is_empty() {
         return (StatusCode::NOT_FOUND, "no web_root configured").into_response();
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
index 4e6b73c..a659725 100644
--- a/crates/core/src/lib.rs
+++ b/crates/core/src/lib.rs
@@ -6,6 +6,7 @@ pub mod error;
 pub mod html;
 pub mod http;
 pub mod registry;
+pub mod trash;
 pub mod users;
 
 pub use app::{App, AppContext, AppManifest};
@@ -15,6 +16,7 @@ pub use config::{AppConfig, FrameworkConfig};
 pub use error::CoreError;
 pub use http::{ApiServer, HttpRequest, HttpResponse};
 pub use registry::{AppInfo, AppRegistry, AppStatus};
+pub use trash::{TrashEntry, TrashManager};
 pub use users::{
     ApiKey, ApiKeyInfo, AuthContext, AuthMethod, Group, Session, UserEntry, UserInfo, UserStore,
     GROUP_ADMIN, GROUP_USER,
diff --git a/crates/core/src/trash.rs b/crates/core/src/trash.rs
new file mode 100644
index 0000000..356a0bf
--- /dev/null
+++ b/crates/core/src/trash.rs
@@ -0,0 +1,336 @@
+//! Shared trash-bin management used by both the filesync server and the
+//! filebrowser.  Both apps write to the same `.bh_filesync/trash/` directory
+//! under the sync root.
+
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use std::path::{Component, Path, PathBuf};
+use std::sync::Arc;
+use std::time::SystemTime;
+
+/// Path of the trash directory relative to the sync root.
+pub const TRASH_DIR: &str = ".bh_filesync/trash";
+/// Filename for the JSON metadata index inside the trash directory.
+pub const TRASH_INDEX_FILE: &str = "index.json";
+
+/// Metadata for a single item that has been moved to the trash.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TrashEntry {
+    /// Unique identifier for this deletion event.
+    pub id: String,
+    /// Original path relative to the sync root.
+    pub original_path: PathBuf,
+    /// Path relative to the trash directory: `{id}/{original_path}`.
+    pub trash_rel_path: PathBuf,
+    /// Unix millisecond timestamp of deletion.
+    pub deleted_at_ms: u64,
+    /// File size in bytes (0 for directories).
+    pub size: u64,
+    /// True when this entry is a directory.
+    pub is_dir: bool,
+    /// Label of the component or user that performed the deletion.
+    pub deleted_by: String,
+}
+
+/// Thread-safe manager for the `.bh_filesync/trash` directory.
+///
+/// All mutations are protected by an internal `Mutex` and use an atomic
+/// rename-on-write strategy for the index file to prevent partial writes.
+pub struct TrashManager {
+    root: PathBuf,
+    lock: Mutex<()>,
+    pub expiry_days: Option<u64>,
+}
+
+impl TrashManager {
+    pub fn new(root: PathBuf, expiry_days: Option<u64>) -> Arc<Self> {
+        Arc::new(Self {
+            root,
+            lock: Mutex::new(()),
+            expiry_days,
+        })
+    }
+
+    fn trash_dir(&self) -> PathBuf {
+        self.root.join(TRASH_DIR)
+    }
+
+    fn load_index(&self) -> Vec<TrashEntry> {
+        let path = self.trash_dir().join(TRASH_INDEX_FILE);
+        let Ok(data) = std::fs::read_to_string(&path) else {
+            return Vec::new();
+        };
+        serde_json::from_str::<Vec<TrashEntry>>(&data).unwrap_or_else(|e| {
+            log::warn!("trash: failed to parse index: {e}; treating as empty");
+            Vec::new()
+        })
+    }
+
+    fn save_index(&self, index: &[TrashEntry]) {
+        let trash_dir = self.trash_dir();
+        if let Err(e) = std::fs::create_dir_all(&trash_dir) {
+            log::warn!("trash: cannot create trash dir: {e}");
+            return;
+        }
+        let path = trash_dir.join(TRASH_INDEX_FILE);
+        let tmp = trash_dir.join("index.json.tmp");
+        match serde_json::to_string_pretty(index) {
+            Ok(json) => {
+                if std::fs::write(&tmp, json.as_bytes()).is_ok() {
+                    if let Err(e) = std::fs::rename(&tmp, &path) {
+                        log::warn!("trash: atomic index write failed: {e}");
+                        let _ = std::fs::remove_file(&tmp);
+                    }
+                }
+            }
+            Err(e) => log::warn!("trash: failed to serialize index: {e}"),
+        }
+    }
+
+    /// Move `full_path` (at relative path `rel` inside the root) into the
+    /// trash, preserving the original folder structure.
+    ///
+    /// Falls back to a hard delete when the move fails.
+    pub fn move_to_trash(&self, full_path: &Path, rel: &Path, deleted_by: &str) {
+        if !full_path.exists() {
+            return;
+        }
+        let id = trash_id();
+        let trash_dir = self.trash_dir();
+        let entry_dir = trash_dir.join(&id);
+
+        // Mirror folder structure: trash/<id>/<original/relative/path>
+        let dest = entry_dir.join(rel);
+        let dest_parent = dest
+            .parent()
+            .filter(|p| !p.as_os_str().is_empty())
+            .unwrap_or(&entry_dir);
+
+        if let Err(e) = std::fs::create_dir_all(dest_parent) {
+            log::warn!("trash: cannot create entry dir for {rel:?}: {e}; hard-deleting");
+            hard_delete(full_path);
+            return;
+        }
+
+        let size = if full_path.is_dir() {
+            0u64
+        } else {
+            std::fs::metadata(full_path).map(|m| m.len()).unwrap_or(0)
+        };
+        let is_dir = full_path.is_dir();
+
+        let moved = if std::fs::rename(full_path, &dest).is_ok() {
+            true
+        } else if is_dir {
+            copy_dir_all(full_path, &dest).is_ok() && {
+                let _ = std::fs::remove_dir_all(full_path);
+                true
+            }
+        } else {
+            std::fs::copy(full_path, &dest).is_ok() && {
+                let _ = std::fs::remove_file(full_path);
+                true
+            }
+        };
+
+        if !moved {
+            log::warn!("trash: move failed for {rel:?}; hard-deleting");
+            hard_delete(full_path);
+            let _ = std::fs::remove_dir_all(&entry_dir);
+            return;
+        }
+
+        let unix_ms = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_millis() as u64;
+
+        let entry = TrashEntry {
+            id: id.clone(),
+            original_path: rel.to_path_buf(),
+            trash_rel_path: PathBuf::from(&id).join(rel),
+            deleted_at_ms: unix_ms,
+            size,
+            is_dir,
+            deleted_by: deleted_by.to_string(),
+        };
+
+        let _guard = self.lock.lock();
+        let mut index = self.load_index();
+        index.push(entry);
+        self.save_index(&index);
+    }
+
+    /// List all entries currently in the trash.
+    pub fn list_trash(&self) -> Vec<TrashEntry> {
+        let _guard = self.lock.lock();
+        self.load_index()
+    }
+
+    /// Move the entry identified by `id` back to its original location.
+    pub fn restore_entry(&self, id: &str) -> Result<(), String> {
+        let _guard = self.lock.lock();
+        let mut index = self.load_index();
+
+        let pos = index
+            .iter()
+            .position(|e| e.id == id)
+            .ok_or_else(|| format!("no trash entry with id {id:?}"))?;
+
+        let entry = index[pos].clone();
+
+        // Reject unsafe paths
+        for component in entry.original_path.components() {
+            match component {
+                Component::ParentDir | Component::Prefix(_) | Component::RootDir => {
+                    return Err("unsafe original_path in trash entry".into());
+                }
+                _ => {}
+            }
+        }
+
+        let trash_dir = self.trash_dir();
+        let trash_full = trash_dir.join(&entry.trash_rel_path);
+        let original_full = self.root.join(&entry.original_path);
+
+        if original_full.exists() {
+            return Err(format!(
+                "destination already exists: {:?}",
+                entry.original_path
+            ));
+        }
+
+        if let Some(parent) = original_full.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| format!("create parent dirs: {e}"))?;
+        }
+
+        std::fs::rename(&trash_full, &original_full).map_err(|e| format!("restore failed: {e}"))?;
+
+        let entry_dir = trash_dir.join(&entry.id);
+        let _ = std::fs::remove_dir_all(&entry_dir);
+
+        index.remove(pos);
+        self.save_index(&index);
+        Ok(())
+    }
+
+    /// Permanently delete the trash entry identified by `id`.
+    pub fn purge_entry(&self, id: &str) -> Result<(), String> {
+        let _guard = self.lock.lock();
+        let mut index = self.load_index();
+
+        let pos = index
+            .iter()
+            .position(|e| e.id == id)
+            .ok_or_else(|| format!("no trash entry with id {id:?}"))?;
+
+        let entry_dir = self.trash_dir().join(&index[pos].id);
+        if let Err(e) = std::fs::remove_dir_all(&entry_dir) {
+            if e.kind() != std::io::ErrorKind::NotFound {
+                return Err(format!("delete failed: {e}"));
+            }
+        }
+
+        index.remove(pos);
+        self.save_index(&index);
+        Ok(())
+    }
+
+    /// Remove all entries older than `expiry_days`. Returns the count removed.
+    /// Does nothing when `expiry_days` is `None` or `0`.
+    pub fn purge_expired(&self) -> usize {
+        let expiry_days = match self.expiry_days {
+            Some(d) if d > 0 => d,
+            _ => return 0,
+        };
+
+        let now_ms = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_millis() as u64;
+
+        let cutoff_ms = now_ms.saturating_sub(expiry_days * 24 * 3600 * 1000);
+
+        let _guard = self.lock.lock();
+        let mut index = self.load_index();
+        let trash_dir = self.trash_dir();
+        let mut count = 0usize;
+
+        index.retain(|e| {
+            if e.deleted_at_ms < cutoff_ms {
+                let entry_dir = trash_dir.join(&e.id);
+                if let Err(err) = std::fs::remove_dir_all(&entry_dir) {
+                    if err.kind() != std::io::ErrorKind::NotFound {
+                        log::warn!("trash: failed to purge {entry_dir:?}: {err}");
+                    }
+                }
+                count += 1;
+                false
+            } else {
+                true
+            }
+        });
+
+        if count > 0 {
+            self.save_index(&index);
+            log::info!("trash: purged {count} expired entry/entries");
+        }
+        count
+    }
+
+    /// Permanently delete **all** items in the trash. Returns count removed.
+    pub fn empty(&self) -> usize {
+        let _guard = self.lock.lock();
+        let mut index = self.load_index();
+        let trash_dir = self.trash_dir();
+        let count = index.len();
+        for e in &index {
+            let entry_dir = trash_dir.join(&e.id);
+            if let Err(err) = std::fs::remove_dir_all(&entry_dir) {
+                if err.kind() != std::io::ErrorKind::NotFound {
+                    log::warn!("trash: failed to remove {entry_dir:?}: {err}");
+                }
+            }
+        }
+        index.clear();
+        self.save_index(&index);
+        count
+    }
+}
+
+// ── Private helpers ──────────────────────────────────────────────────────────
+
+/// Generate a unique ID for a trash entry using nanosecond time + an atomic
+/// counter so two calls within the same nanosecond produce distinct IDs.
+fn trash_id() -> String {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static COUNTER: AtomicU64 = AtomicU64::new(0);
+    let ns = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos() as u64;
+    let seq = COUNTER.fetch_add(1, Ordering::Relaxed);
+    format!("{ns:020}_{seq:06}")
+}
+
+fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
+    std::fs::create_dir_all(dst)?;
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let dst_path = dst.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir_all(&entry.path(), &dst_path)?;
+        } else {
+            std::fs::copy(entry.path(), &dst_path)?;
+        }
+    }
+    Ok(())
+}
+
+fn hard_delete(path: &Path) {
+    if path.is_dir() {
+        let _ = std::fs::remove_dir_all(path);
+    } else {
+        let _ = std::fs::remove_file(path);
+    }
+}
diff --git a/crates/filebrowser/src/app.rs b/crates/filebrowser/src/app.rs
index 5cbc202..3296da0 100644
--- a/crates/filebrowser/src/app.rs
+++ b/crates/filebrowser/src/app.rs
@@ -13,6 +13,7 @@ pub struct Inner {
     pub root: PathBuf,
     pub max_upload_bytes: u64,
     pub allow_delete: bool,
+    pub trash_manager: std::sync::Arc<bytehive_core::TrashManager>,
 }
 
 pub struct FileBrowserApp {
@@ -20,21 +21,30 @@ pub struct FileBrowserApp {
 
     pub shares: Arc<RwLock<HashMap<String, Share>>>,
     filesync_root: Option<PathBuf>,
+    /// Inherited from [apps.filesync] trash_expiry_days so both apps share
+    /// one setting.
+    filesync_trash_expiry_days: Option<u64>,
 }
 
 impl FileBrowserApp {
     pub fn new(fw_config: &FrameworkConfig) -> Arc<Self> {
-        let filesync_root = fw_config
-            .apps
-            .get("filesync")
+        let filesync_cfg = fw_config.apps.get("filesync");
+
+        let filesync_root = filesync_cfg
             .and_then(|v| v.get("root"))
             .and_then(|v| v.as_str())
             .map(PathBuf::from);
 
+        let filesync_trash_expiry_days = filesync_cfg
+            .and_then(|v| v.get("trash_expiry_days"))
+            .and_then(|v| v.as_integer())
+            .map(|v| v as u64);
+
         Arc::new(Self {
             inner: RwLock::new(None),
             shares: Arc::new(RwLock::new(HashMap::new())),
             filesync_root,
+            filesync_trash_expiry_days,
         })
     }
 
@@ -78,10 +88,14 @@ impl App for FileBrowserApp {
             std::fs::create_dir_all(&root).map_err(CoreError::Io)?;
         }
 
+        let trash_manager =
+            bytehive_core::TrashManager::new(root.clone(), self.filesync_trash_expiry_days);
+
         *self.inner.write() = Some(Inner {
             root,
             max_upload_bytes: cfg.max_upload_mb * 1024 * 1024,
             allow_delete: cfg.allow_delete,
+            trash_manager: trash_manager.clone(),
         });
 
         let shares_arc = Arc::clone(&self.shares);
@@ -100,6 +114,27 @@ impl App for FileBrowserApp {
             })
             .map_err(CoreError::Io)?;
 
+        if self
+            .filesync_trash_expiry_days
+            .map(|d| d > 0)
+            .unwrap_or(false)
+        {
+            let tm = trash_manager.clone();
+            let shutdown2 = ctx.shutdown.clone();
+            std::thread::Builder::new()
+                .name("filebrowser-trash-gc".into())
+                .spawn(move || loop {
+                    if shutdown2
+                        .recv_timeout(std::time::Duration::from_secs(3600))
+                        .is_ok()
+                    {
+                        break;
+                    }
+                    tm.purge_expired();
+                })
+                .map_err(CoreError::Io)?;
+        }
+
         log::info!(
             "filebrowser started, root = {:?}",
             self.inner.read().as_ref().map(|i| &i.root)
@@ -201,6 +236,35 @@ impl App for FileBrowserApp {
             ("GET", "/search") => Some(self.handle_search(req)),
             ("GET", "/thumb") => Some(self.handle_thumb(req)),
             ("GET", "/detect") => Some(self.handle_detect(req)),
+            ("GET", "/trash") => Some(self.handle_trash_list()),
+            ("POST", sub) if sub.starts_with("/trash/") && sub.ends_with("/restore") => {
+                if is_readonly {
+                    return Some(HttpResponse::unauthorized());
+                }
+                let id = sub
+                    .trim_start_matches("/trash/")
+                    .trim_end_matches("/restore");
+                Some(self.handle_trash_restore(id))
+            }
+            ("DELETE", sub) if sub.starts_with("/trash/") => {
+                if is_readonly {
+                    return Some(HttpResponse::unauthorized());
+                }
+                let id = sub.trim_start_matches("/trash/");
+                Some(self.handle_trash_purge_entry(id))
+            }
+            ("DELETE", "/trash") => {
+                if is_readonly {
+                    return Some(HttpResponse::unauthorized());
+                }
+                Some(self.handle_trash_empty())
+            }
+            ("POST", "/trash/purge-expired") => {
+                if is_readonly {
+                    return Some(HttpResponse::unauthorized());
+                }
+                Some(self.handle_trash_purge_expired())
+            }
             _ => None,
         }
     }
diff --git a/crates/filebrowser/src/fs_util.rs b/crates/filebrowser/src/fs_util.rs
index c7948a3..2253531 100644
--- a/crates/filebrowser/src/fs_util.rs
+++ b/crates/filebrowser/src/fs_util.rs
@@ -159,37 +159,6 @@ pub fn zip_directory(abs: &Path, _rel: &str) -> HttpResponse {
     }
 }
 
-/// Move `abs` into `.bh_filesync/trash` inside `root`.
-/// The item is stored as `<unix_ms>_<original_name>` in the trash folder.
-/// Falls back to copy+delete if a cross-device rename fails.
-pub fn move_to_bh_trash(root: &Path, abs: &Path) -> Result<(), String> {
-    let trash_dir = root.join(".bh_filesync").join("trash");
-    std::fs::create_dir_all(&trash_dir).map_err(|e| e.to_string())?;
-
-    let file_name = abs
-        .file_name()
-        .unwrap_or_else(|| std::ffi::OsStr::new("unknown"))
-        .to_string_lossy();
-    let unix_ms = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_millis();
-    let trash_dest = trash_dir.join(format!("{unix_ms}_{file_name}"));
-
-    if std::fs::rename(abs, &trash_dest).is_err() {
-        // Cross-device or other issue — fall back to copy then delete
-        if abs.is_dir() {
-            copy_dir_all(abs, &trash_dest)?;
-            std::fs::remove_dir_all(abs).map_err(|e| e.to_string())?;
-        } else {
-            std::fs::copy(abs, &trash_dest).map_err(|e| e.to_string())?;
-            std::fs::remove_file(abs).map_err(|e| e.to_string())?;
-        }
-    }
-
-    Ok(())
-}
-
 pub fn extension(name: &str) -> &str {
     Path::new(name)
         .extension()
diff --git a/crates/filebrowser/src/handlers.rs b/crates/filebrowser/src/handlers.rs
index 9cb4c01..ee540f6 100644
--- a/crates/filebrowser/src/handlers.rs
+++ b/crates/filebrowser/src/handlers.rs
@@ -237,10 +237,9 @@ impl FileBrowserApp {
             Err(e) => return HttpResponse::bad_request(e),
         };
 
-        match crate::fs_util::move_to_bh_trash(&inner.root, &abs) {
-            Ok(()) => HttpResponse::ok_json(json!({"ok": true})),
-            Err(e) => HttpResponse::internal_error(e),
-        }
+        let rel = abs.strip_prefix(&inner.root).unwrap_or(&abs).to_path_buf();
+        inner.trash_manager.move_to_trash(&abs, &rel, "filebrowser");
+        HttpResponse::ok_json(json!({"ok": true}))
     }
 
     pub fn handle_rename(&self, req: &HttpRequest) -> HttpResponse {
@@ -717,4 +716,72 @@ impl FileBrowserApp {
             "is_dir":       is_dir,
         }))
     }
+
+    pub fn handle_trash_list(&self) -> HttpResponse {
+        let guard = self.inner.read();
+        let inner = match guard.as_ref() {
+            Some(i) => i,
+            None => return HttpResponse::internal_error("not running"),
+        };
+        let entries: Vec<_> = inner
+            .trash_manager
+            .list_trash()
+            .into_iter()
+            .map(|e| {
+                json!({
+                    "id":            e.id,
+                    "original_path": e.original_path,
+                    "deleted_at_ms": e.deleted_at_ms,
+                    "size":          e.size,
+                    "is_dir":        e.is_dir,
+                    "deleted_by":    e.deleted_by,
+                })
+            })
+            .collect();
+        HttpResponse::ok_json(json!({ "entries": entries }))
+    }
+
+    pub fn handle_trash_restore(&self, id: &str) -> HttpResponse {
+        let guard = self.inner.read();
+        let inner = match guard.as_ref() {
+            Some(i) => i,
+            None => return HttpResponse::internal_error("not running"),
+        };
+        match inner.trash_manager.restore_entry(id) {
+            Ok(()) => HttpResponse::ok_json(json!({ "ok": true })),
+            Err(e) => HttpResponse::bad_request(e),
+        }
+    }
+
+    pub fn handle_trash_purge_entry(&self, id: &str) -> HttpResponse {
+        let guard = self.inner.read();
+        let inner = match guard.as_ref() {
+            Some(i) => i,
+            None => return HttpResponse::internal_error("not running"),
+        };
+        match inner.trash_manager.purge_entry(id) {
+            Ok(()) => HttpResponse::ok_json(json!({ "ok": true })),
+            Err(e) => HttpResponse::not_found(e),
+        }
+    }
+
+    pub fn handle_trash_empty(&self) -> HttpResponse {
+        let guard = self.inner.read();
+        let inner = match guard.as_ref() {
+            Some(i) => i,
+            None => return HttpResponse::internal_error("not running"),
+        };
+        let count = inner.trash_manager.empty();
+        HttpResponse::ok_json(json!({ "ok": true, "purged": count }))
+    }
+
+    pub fn handle_trash_purge_expired(&self) -> HttpResponse {
+        let guard = self.inner.read();
+        let inner = match guard.as_ref() {
+            Some(i) => i,
+            None => return HttpResponse::internal_error("not running"),
+        };
+        let count = inner.trash_manager.purge_expired();
+        HttpResponse::ok_json(json!({ "ok": true, "purged": count }))
+    }
 }
diff --git a/crates/filebrowser/tests/test_app.rs b/crates/filebrowser/tests/test_app.rs
index 2233f8b..5f4a047 100644
--- a/crates/filebrowser/tests/test_app.rs
+++ b/crates/filebrowser/tests/test_app.rs
@@ -21,6 +21,7 @@ fn make_app(tmp: &TempDir, allow_delete: bool) -> std::sync::Arc<FileBrowserApp>
         root: tmp.path().to_path_buf(),
         max_upload_bytes: 10 * 1024 * 1024,
         allow_delete,
+        trash_manager: bytehive_core::TrashManager::new(tmp.path().to_path_buf(), None),
     });
     app
 }
diff --git a/crates/filebrowser/tests/test_handlers.rs b/crates/filebrowser/tests/test_handlers.rs
index 67a1462..0e74842 100644
--- a/crates/filebrowser/tests/test_handlers.rs
+++ b/crates/filebrowser/tests/test_handlers.rs
@@ -29,6 +29,7 @@ fn make_app_with_limit(
         root: tmp.path().to_path_buf(),
         max_upload_bytes,
         allow_delete,
+        trash_manager: bytehive_core::TrashManager::new(tmp.path().to_path_buf(), None),
     });
     app
 }
diff --git a/crates/filesync/Cargo.toml b/crates/filesync/Cargo.toml
index 2aa4f75..ca0a397 100644
--- a/crates/filesync/Cargo.toml
+++ b/crates/filesync/Cargo.toml
@@ -37,6 +37,7 @@ toml.workspace = true
 tray-icon = "0.21.3"
 iced = { version = "0.14.0", features = ["tokio", "svg"] }
 glib = "0.21.5"
+image = { version = "0.25", default-features = false, features = ["png"] }
 
 clap        = { workspace = true }
 
diff --git a/crates/filesync/src/app.rs b/crates/filesync/src/app.rs
index 3037bef..dd863ce 100644
--- a/crates/filesync/src/app.rs
+++ b/crates/filesync/src/app.rs
@@ -2,7 +2,7 @@ use crate::client::Client;
 use crate::exclusions::{ExclusionConfig, Exclusions};
 use crate::known_hosts::{ClientStatus, KnownClients};
 use crate::server::Server;
-use crate::sync_engine::SyncEngine;
+use crate::sync_engine::{SyncEngine, SyncEngineConfig};
 use crate::{cert_fingerprint, timestamp_id};
 
 use bytehive_core::{
@@ -44,6 +44,16 @@ pub struct FileSyncConfig {
 
     #[serde(default)]
     pub exclude_regex: Vec<String>,
+
+    /// Automatically purge trash entries older than this many days.
+    /// Set to 0 or omit to disable automatic purging.
+    #[serde(default)]
+    pub trash_expiry_days: Option<u64>,
+
+    /// Override for the periodic full-rescan interval in seconds.
+    /// Defaults to 900 seconds (15 minutes) when not set.
+    #[serde(default)]
+    pub full_scan_interval_secs: Option<u64>,
 }
 
 impl FileSyncConfig {
@@ -147,7 +157,15 @@ impl App for FileSyncApp {
             exclusions.rule_count()
         );
 
-        let engine = Arc::new(SyncEngine::new(cfg.root.clone(), node_id, exclusions));
+        let engine = Arc::new(SyncEngine::new_configured(
+            cfg.root.clone(),
+            node_id,
+            exclusions,
+            SyncEngineConfig {
+                trash_expiry_days: cfg.trash_expiry_days,
+                full_scan_interval_secs: cfg.full_scan_interval_secs,
+            },
+        ));
 
         {
             let eng = Arc::clone(&engine);
@@ -167,6 +185,18 @@ impl App for FileSyncApp {
                 .map_err(CoreError::Io)?;
         }
 
+        // Spawn trash GC thread if expiry is configured
+        if cfg.trash_expiry_days.map(|d| d > 0).unwrap_or(false) {
+            let eng = Arc::clone(&engine);
+            thread::Builder::new()
+                .name("filesync-trash-gc".into())
+                .spawn(move || loop {
+                    thread::sleep(Duration::from_secs(3600));
+                    eng.purge_expired_trash();
+                })
+                .map_err(CoreError::Io)?;
+        }
+
         match cfg.mode.as_str() {
             "server" => {
                 let bind = cfg.bind_addr.clone().ok_or_else(|| {
@@ -478,6 +508,58 @@ impl App for FileSyncApp {
                 }
             }
 
+            // ── trash management ──────────────────────────────────────────────────
+            ("GET", "/trash") => {
+                let entries: Vec<_> = state
+                    .engine
+                    .list_trash()
+                    .into_iter()
+                    .map(|e| {
+                        json!({
+                            "id":             e.id,
+                            "original_path":  e.original_path,
+                            "deleted_at_ms":  e.deleted_at_ms,
+                            "size":           e.size,
+                            "is_dir":         e.is_dir,
+                            "deleted_by":     e.deleted_by,
+                        })
+                    })
+                    .collect();
+                Some(HttpResponse::ok_json(json!({ "entries": entries })))
+            }
+
+            ("POST", sub) if sub.starts_with("/trash/") && sub.ends_with("/restore") => {
+                let id = sub
+                    .trim_start_matches("/trash/")
+                    .trim_end_matches("/restore");
+                match state.engine.restore_trash_entry(id) {
+                    Ok(()) => Some(HttpResponse::ok_json(json!({ "ok": true }))),
+                    Err(e) => Some(HttpResponse::bad_request(e)),
+                }
+            }
+
+            ("DELETE", sub) if sub.starts_with("/trash/") => {
+                let id = sub.trim_start_matches("/trash/");
+                match state.engine.purge_trash_entry(id) {
+                    Ok(()) => Some(HttpResponse::ok_json(json!({ "ok": true }))),
+                    Err(e) => Some(HttpResponse::not_found(e)),
+                }
+            }
+
+            ("DELETE", "/trash") => {
+                let count = state.engine.empty_trash();
+                Some(HttpResponse::ok_json(
+                    json!({ "ok": true, "purged": count }),
+                ))
+            }
+
+            ("POST", "/trash/purge-expired") => {
+                let count = state.engine.purge_expired_trash();
+                Some(HttpResponse::ok_json(
+                    json!({ "ok": true, "purged": count }),
+                ))
+            }
+
             _ => None,
         }
     }
diff --git a/crates/filesync/src/common.rs b/crates/filesync/src/common.rs
index b23d439..4219c31 100644
--- a/crates/filesync/src/common.rs
+++ b/crates/filesync/src/common.rs
@@ -139,7 +139,7 @@ impl PendingChanges {
     /// since the last one.  Any newly-discovered changes or deletions are
     /// folded into the pending sets.
     pub fn periodic_rescan(&mut self, engine: &SyncEngine, label: &str) {
-        if self.last_full_scan.elapsed().as_secs() < FULL_SCAN_INTERVAL_SECS {
+        if self.last_full_scan.elapsed().as_secs() < engine.full_scan_interval_secs() {
             return;
         }
         info!("{label}: periodic full re-scan starting …");
diff --git a/crates/filesync/src/gui/app.rs b/crates/filesync/src/gui/app.rs
index d7e220e..34cc397 100644
--- a/crates/filesync/src/gui/app.rs
+++ b/crates/filesync/src/gui/app.rs
@@ -11,8 +11,8 @@ use crate::gui::tray::{TrayEvent, TrayHandle};
 use crate::gui::{components, theme};
 
 use iced::{
-    widget::{button, column, container, row, text, text_input, Space},
-    window, Alignment, Background, Element, Length, Size, Subscription, Task, Theme,
+    widget::{button, column, container, row, text, text_editor, text_input, Space},
+    window, Alignment, Background, Element, Font, Length, Size, Subscription, Task, Theme,
 };
 
 use std::collections::HashMap;
@@ -38,27 +38,58 @@ pub fn run(tray: TrayHandle) -> iced::Result {
         resizable: true,
         decorations: true,
         exit_on_close_request: false,
+        icon: load_window_icon(),
         ..Default::default()
     })
     .run()
 }
 
+fn load_window_icon() -> Option<window::Icon> {
+    const ICON_PNG: &[u8] =
+        include_bytes!("../../../core/assets/bytehive_icon_128x128.png");
+    let img = image::load_from_memory(ICON_PNG)
+        .ok()?
+        .into_rgba8();
+    let (w, h) = img.dimensions();
+    window::icon::from_rgba(img.into_raw(), w, h).ok()
+}
+
 // ─── State ────────────────────────────────────────────────────────────────────
 
-#[derive(Default)]
 struct SetupState {
     step: SetupStep,
     folder_input: String,
     server_input: String,
     token_input: String,
+    // ── Step 3: Configure ────────────────────────────────────────────────────
+    /// Raw TOML text being edited by the user.
+    config_editor: text_editor::Content,
+    /// Validated config produced when the user clicks Next on the Configure step.
+    parsed_config: Option<GuiConfig>,
     error: Option<String>,
 }
 
+impl Default for SetupState {
+    fn default() -> Self {
+        Self {
+            step: SetupStep::default(),
+            folder_input: String::new(),
+            server_input: String::new(),
+            token_input: String::new(),
+            config_editor: text_editor::Content::new(),
+            parsed_config: None,
+            error: None,
+        }
+    }
+}
+
 #[derive(Debug, Default, Clone, PartialEq)]
 enum SetupStep {
     #[default]
     Folder,
     Server,
+    /// Step 3: exclusions and any future per-install settings.
+    Configure,
     Review,
 }
 
@@ -94,6 +125,8 @@ pub enum Message {
     FolderPicked(Option<PathBuf>),
     ServerInput(String),
     TokenInput(String),
+    // Configure step
+    ConfigEditorAction(text_editor::Action),
     SetupNext,
     SetupBack,
     SetupConnect,
@@ -202,6 +235,13 @@ impl FileSyncGui {
                 Task::none()
             }
 
+            Message::ConfigEditorAction(action) => {
+                if let Screen::Setup(s) = &mut self.screen {
+                    s.config_editor.perform(action);
+                }
+                Task::none()
+            }
+
             Message::SetupNext => {
                 if let Screen::Setup(s) = &mut self.screen {
                     match s.step {
@@ -220,7 +260,34 @@ impl FileSyncGui {
                                 s.error = Some("Please enter your auth token.".into());
                             } else {
                                 s.error = None;
-                                s.step = SetupStep::Review;
+                                // Regenerate the TOML template from the latest inputs every
+                                // time the user advances to the Configure step so that edits
+                                // to folder / server / token are always reflected.
+                                let toml = config_toml_template(
+                                    s.folder_input.trim(),
+                                    s.server_input.trim(),
+                                    s.token_input.trim(),
+                                );
+                                s.config_editor = text_editor::Content::with_text(&toml);
+                                s.step = SetupStep::Configure;
+                            }
+                        }
+                        SetupStep::Configure => {
+                            let raw = s.config_editor.text();
+                            match toml::from_str::<GuiConfig>(&raw) {
+                                Ok(cfg) if cfg.is_complete() => {
+                                    s.parsed_config = Some(cfg);
+                                    s.error = None;
+                                    s.step = SetupStep::Review;
+                                }
+                                Ok(_) => {
+                                    s.error = Some(
+                                        "Config is incomplete — server_addr, sync_root and auth_token are required.".into(),
+                                    );
+                                }
+                                Err(e) => {
+                                    s.error = Some(format!("Invalid TOML: {e}"));
+                                }
                             }
                         }
                         SetupStep::Review => {}
@@ -233,7 +300,8 @@ impl FileSyncGui {
                 if let Screen::Setup(s) = &mut self.screen {
                     match s.step {
                         SetupStep::Server => s.step = SetupStep::Folder,
-                        SetupStep::Review => s.step = SetupStep::Server,
+                        SetupStep::Configure => s.step = SetupStep::Server,
+                        SetupStep::Review => s.step = SetupStep::Configure,
                         _ => {}
                     }
                     s.error = None;
@@ -243,11 +311,9 @@ impl FileSyncGui {
 
             Message::SetupConnect => {
                 if let Screen::Setup(s) = &mut self.screen {
-                    let cfg = GuiConfig {
-                        sync_root: PathBuf::from(s.folder_input.trim()),
-                        server_addr: s.server_input.trim().to_string(),
-                        auth_token: s.token_input.trim().to_string(),
-                        ..Default::default()
+                    let cfg = match s.parsed_config.clone() {
+                        Some(c) => c,
+                        None => return Task::none(),
                     };
                     if let Err(e) = cfg.save() {
                         s.error = Some(format!("Failed to save config: {e}"));
@@ -455,7 +521,8 @@ fn view_setup(s: &SetupState) -> Element<'_, Message> {
     let step_num = match s.step {
         SetupStep::Folder => 1u8,
         SetupStep::Server => 2,
-        SetupStep::Review => 3,
+        SetupStep::Configure => 3,
+        SetupStep::Review => 4,
     };
 
     let header = column![
@@ -465,7 +532,7 @@ fn view_setup(s: &SetupState) -> Element<'_, Message> {
                 color: Some(theme::TEXT_PRIMARY),
             }),
         vspace(4),
-        text(format!("Setup  \u{2014}  Step {step_num} of 3"))
+        text(format!("Setup  \u{2014}  Step {step_num} of 4"))
             .size(14)
             .style(theme::secondary),
         vspace(16),
@@ -476,6 +543,7 @@ fn view_setup(s: &SetupState) -> Element<'_, Message> {
     let body: Element<Message> = match s.step {
         SetupStep::Folder => view_setup_folder(s),
         SetupStep::Server => view_setup_server(s),
+        SetupStep::Configure => view_setup_configure(s),
         SetupStep::Review => view_setup_review(s),
     };
 
@@ -492,7 +560,7 @@ fn view_setup(s: &SetupState) -> Element<'_, Message> {
 }
 
 fn step_dots(active: u8) -> Element<'static, Message> {
-    let dots: Vec<Element<Message>> = (1u8..=3)
+    let dots: Vec<Element<Message>> = (1u8..=4)
         .map(|i| {
             let colour = if i <= active {
                 theme::AMBER
@@ -615,7 +683,82 @@ fn view_setup_server(s: &SetupState) -> Element<'_, Message> {
     setup_card(inner.into())
 }
 
+fn view_setup_configure(s: &SetupState) -> Element<'_, Message> {
+    let editor = text_editor(&s.config_editor)
+        .on_action(Message::ConfigEditorAction)
+        .font(Font::MONOSPACE)
+        .size(13)
+        .padding(12)
+        .height(Length::Fill);
+
+    let mut content = column![
+        text("Configure Settings")
+            .size(18)
+            .style(|_: &Theme| iced::widget::text::Style {
+                color: Some(theme::TEXT_PRIMARY),
+            }),
+        vspace(6),
+        text(
+            "Edit the full configuration that will be saved to disk. \
+             The TOML is pre-filled from your earlier inputs — \
+             adjust exclusions, log level, or any other field before continuing."
+        )
+        .size(13)
+        .style(theme::secondary),
+        vspace(16),
+        editor,
+    ]
+    .spacing(0)
+    .height(Length::Fill);
+
+    if let Some(e) = &s.error {
+        content = content
+            .push(vspace(8))
+            .push(text(e.as_str()).size(13).style(theme::red_text));
+    }
+    content = content.push(vspace(16)).push(row![
+        button("\u{2190} Back")
+            .on_press(Message::SetupBack)
+            .padding([10, 18])
+            .style(theme::btn_ghost),
+        hspace_fill(),
+        button("Next \u{2192}")
+            .on_press(Message::SetupNext)
+            .padding([10, 24])
+            .style(theme::btn_primary),
+    ]);
+
+    container(content)
+        .width(Length::Fill)
+        .height(Length::Fill)
+        .padding(20)
+        .style(theme::panel)
+        .into()
+}
+
 fn view_setup_review(s: &SetupState) -> Element<'_, Message> {
+    // Read the validated config produced by the Configure step.
+    let cfg = match &s.parsed_config {
+        Some(c) => c,
+        None => return text("No configuration available.").into(),
+    };
+
+    let excl_glob = if cfg.exclude_patterns.is_empty() {
+        "None".to_string()
+    } else {
+        cfg.exclude_patterns.join(", ")
+    };
+    let excl_regex = if cfg.exclude_regex.is_empty() {
+        "None".to_string()
+    } else {
+        cfg.exclude_regex.join(", ")
+    };
+    let log_level = cfg
+        .log_level
+        .as_deref()
+        .unwrap_or("info (default)")
+        .to_string();
+
     let mut inner = column![
         text("Review & Connect")
             .size(18)
@@ -627,14 +770,20 @@ fn view_setup_review(s: &SetupState) -> Element<'_, Message> {
             .size(13)
             .style(theme::secondary),
         vspace(20),
-        review_row("Sync folder", s.folder_input.clone()),
+        review_row("Sync folder", cfg.sync_root.to_string_lossy().into_owned()),
         vspace(10),
-        review_row("Server", s.server_input.clone()),
+        review_row("Server", cfg.server_addr.clone()),
         vspace(10),
         review_row(
             "Auth token",
             "\u{25CF}\u{25CF}\u{25CF}\u{25CF}\u{25CF}\u{25CF}\u{25CF}\u{25CF}".to_owned()
         ),
+        vspace(10),
+        review_row("Glob exclusions", excl_glob),
+        vspace(10),
+        review_row("Regex exclusions", excl_regex),
+        vspace(10),
+        review_row("Log level", log_level),
         vspace(16),
         thin_rule(),
     ]
@@ -836,6 +985,46 @@ fn refresh_file_tree(old_tree: &[FileNode], root: &std::path::Path) -> Vec<FileN
     new_tree
 }
 
+// ─── Config template ─────────────────────────────────────────────────────────
+
+/// Escapes a bare string value for embedding inside a TOML double-quoted string.
+fn toml_escape(s: &str) -> String {
+    s.replace('\\', "\\\\").replace('"', "\\\"")
+}
+
+/// Generates the pre-filled, commented TOML template shown in the Configure step.
+fn config_toml_template(folder: &str, server: &str, token: &str) -> String {
+    format!(
+        r#"# ByteHive FileSync — client configuration
+# Edit any value below, then click Next to validate and continue.
+
+server_addr = "{server}"
+sync_root   = "{folder}"
+auth_token  = "{token}"
+
+# ── Exclusions ──────────────────────────────────────────────────────────────
+# Glob patterns — files and folders matching these will be skipped during sync.
+# Each pattern is matched against the relative path inside the sync root.
+# Segments: *  matches anything within one path segment.
+#           ** matches across directory boundaries.
+# Examples: "*.tmp", "node_modules", "build/**", ".git", "**/.DS_Store"
+exclude_patterns = []
+
+# Raw regular expressions for more precise exclusion rules.
+# Matched against the forward-slash-separated relative path.
+# Examples: "\\.pyc$", "^\\.DS_Store$", "^__pycache__"
+exclude_regex = []
+
+# ── Advanced ───────────────────────────────────────────────────────────────
+# Minimum log verbosity.  One of: "error", "warn", "info", "debug", "trace"
+# log_level = "info"
+"#,
+        server = toml_escape(server),
+        folder = toml_escape(folder),
+        token = toml_escape(token),
+    )
+}
+
 // ─── Setup helpers ────────────────────────────────────────────────────────────
 
 fn setup_card(content: Element<Message>) -> Element<Message> {
diff --git a/crates/filesync/src/gui/tray.rs b/crates/filesync/src/gui/tray.rs
index bf7296a..dae1e91 100644
--- a/crates/filesync/src/gui/tray.rs
+++ b/crates/filesync/src/gui/tray.rs
@@ -72,41 +72,10 @@ pub fn setup_tray() -> TrayHandle {
 }
 
 fn make_icon() -> Icon {
-    const SIZE: usize = 22;
-    let mut px = vec![0u8; SIZE * SIZE * 4];
-
-    for y in 0..SIZE {
-        for x in 0..SIZE {
-            let dx = x as f32 - 10.5;
-            let dy = y as f32 - 10.5;
-            let r = (dx * dx + dy * dy).sqrt();
-
-            let i = (y * SIZE + x) * 4;
-
-            if r > 10.2 {
-                continue;
-            }
-
-            px[i] = 0x3B;
-            px[i + 1] = 0x82;
-            px[i + 2] = 0xF6;
-            px[i + 3] = 255;
-
-            let angle = dy.atan2(dx);
-            let in_arc =
-                !(angle > std::f32::consts::FRAC_PI_4 && angle < std::f32::consts::FRAC_PI_2 * 1.5);
-            if r > 5.5 && r < 8.0 && in_arc {
-                px[i] = 255;
-                px[i + 1] = 255;
-                px[i + 2] = 255;
-            }
-
-            if dx > 0.5 && dy > -2.0 && dy < 2.0 && r < 8.0 && r > 4.0 {
-                px[i] = 255;
-                px[i + 1] = 255;
-                px[i + 2] = 255;
-            }
-        }
-    }
-    Icon::from_rgba(px, SIZE as u32, SIZE as u32).expect("create tray icon pixels")
+    const ICON_PNG: &[u8] = include_bytes!("../../../core/assets/bytehive_icon_32x32.png");
+    let img = image::load_from_memory(ICON_PNG)
+        .expect("decode tray icon PNG")
+        .into_rgba8();
+    let (w, h) = img.dimensions();
+    Icon::from_rgba(img.into_raw(), w, h).expect("create tray icon")
 }
diff --git a/crates/filesync/src/protocol.rs b/crates/filesync/src/protocol.rs
index a36bf43..ce824eb 100644
--- a/crates/filesync/src/protocol.rs
+++ b/crates/filesync/src/protocol.rs
@@ -19,6 +19,7 @@ pub const READ_THREADS: usize = 4;
 pub const BH_DIR: &str = ".bh_filesync";
 pub const TMP_DIR: &str = ".bh_filesync/transfers";
 pub const TRASH_DIR: &str = ".bh_filesync/trash";
+pub const TRASH_INDEX_FILE: &str = "index.json";
 pub const FULL_SCAN_INTERVAL_SECS: u64 = 900; // 15 minutes
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/filesync/src/sync_engine.rs b/crates/filesync/src/sync_engine.rs
index b14a78c..956353b 100644
--- a/crates/filesync/src/sync_engine.rs
+++ b/crates/filesync/src/sync_engine.rs
@@ -4,6 +4,7 @@ use crate::manifest;
 use crate::protocol::FILE_STABILITY_MS;
 use crate::protocol::*;
 use crate::transport::Connection;
+use bytehive_core::TrashManager;
 use crossbeam_channel::bounded;
 use log::warn;
 use parking_lot::RwLock;
@@ -63,6 +64,17 @@ struct LargeFileAssembly {
     final_hash_pending: Option<[u8; 32]>,
 }
 
+/// Optional configuration overrides for a [`SyncEngine`] instance.
+#[derive(Debug, Default, Clone)]
+pub struct SyncEngineConfig {
+    /// Automatically purge trash entries older than this many days.
+    /// `None` or `0` disables automatic purging.
+    pub trash_expiry_days: Option<u64>,
+    /// Override for the periodic full-rescan interval in seconds.
+    /// Defaults to `FULL_SCAN_INTERVAL_SECS` (900) when `None`.
+    pub full_scan_interval_secs: Option<u64>,
+}
+
 pub struct SyncEngine {
     root: PathBuf,
     node_id: String,
@@ -75,6 +87,8 @@ pub struct SyncEngine {
     in_progress: RwLock<HashMap<PathBuf, LargeFileAssembly>>,
 
     exclusions: Arc<Exclusions>,
+    trash_manager: Arc<TrashManager>,
+    full_scan_interval_secs: u64,
 }
 
 /// Returns the path that a conflict copy of `rel_path` should use.
@@ -115,45 +129,6 @@ fn hash_file(path: &Path) -> Option<[u8; 32]> {
     Some(hasher.finalize().into())
 }
 
-/// Move a file or directory into the `.bh_filesync/trash` folder.
-/// The item is renamed to `<unix_ms>_<original_name>` inside the trash dir.
-/// If rename fails (e.g. cross-device), falls back to a hard delete.
-fn move_to_trash(root: &Path, full_path: &Path, rel: &Path) {
-    if !full_path.exists() {
-        return;
-    }
-    let trash_dir = root.join(crate::protocol::TRASH_DIR);
-    if fs::create_dir_all(&trash_dir).is_err() {
-        // Can't create trash — fall back to hard delete
-        if full_path.is_dir() {
-            let _ = fs::remove_dir_all(full_path);
-        } else {
-            let _ = fs::remove_file(full_path);
-        }
-        return;
-    }
-
-    let file_name = rel
-        .file_name()
-        .unwrap_or_else(|| std::ffi::OsStr::new("unknown"))
-        .to_string_lossy();
-    let unix_ms = SystemTime::now()
-        .duration_since(SystemTime::UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_millis();
-    let trash_dest = trash_dir.join(format!("{unix_ms}_{file_name}"));
-
-    if fs::rename(full_path, &trash_dest).is_err() {
-        // Cross-device or permission issue — fall back to hard delete
-        warn!("trash rename failed for {rel:?}; falling back to delete");
-        if full_path.is_dir() {
-            let _ = fs::remove_dir_all(full_path);
-        } else {
-            let _ = fs::remove_file(full_path);
-        }
-    }
-}
-
 /// Remove empty intermediate directories left behind inside the transfers
 /// folder after a large-file tmp file has been consumed or deleted.
 /// Walks upward from `tmp_path`'s parent, removing directories that are
@@ -175,10 +150,23 @@ fn cleanup_transfer_dirs(root: &Path, tmp_path: &Path) {
 
 impl SyncEngine {
     pub fn new(root: PathBuf, node_id: String, exclusions: Arc<Exclusions>) -> Self {
+        Self::new_configured(root, node_id, exclusions, SyncEngineConfig::default())
+    }
+
+    pub fn new_configured(
+        root: PathBuf,
+        node_id: String,
+        exclusions: Arc<Exclusions>,
+        config: SyncEngineConfig,
+    ) -> Self {
         log::debug!(
             "SyncEngine: {} active exclusion rule(s)",
             exclusions.rule_count()
         );
+        let full_scan_interval_secs = config
+            .full_scan_interval_secs
+            .unwrap_or(FULL_SCAN_INTERVAL_SECS);
+        let trash_manager = TrashManager::new(root.clone(), config.trash_expiry_days);
         Self {
             manifest: RwLock::new(Manifest {
                 files: HashMap::new(),
@@ -190,6 +178,8 @@ impl SyncEngine {
             suppressed_deletes: Arc::new(RwLock::new(HashSet::new())),
             in_progress: RwLock::new(HashMap::new()),
             exclusions,
+            trash_manager,
+            full_scan_interval_secs,
         }
     }
 
@@ -241,6 +231,41 @@ impl SyncEngine {
         age_ms >= FILE_STABILITY_MS
     }
 
+    /// Returns the configured full-rescan interval in seconds.
+    pub fn full_scan_interval_secs(&self) -> u64 {
+        self.full_scan_interval_secs
+    }
+
+    /// Returns a reference to the shared trash manager.
+    pub fn trash_manager(&self) -> &Arc<TrashManager> {
+        &self.trash_manager
+    }
+
+    /// List all entries currently in the trash.
+    pub fn list_trash(&self) -> Vec<bytehive_core::TrashEntry> {
+        self.trash_manager.list_trash()
+    }
+
+    /// Restore a trashed entry by its ID back to its original location.
+    pub fn restore_trash_entry(&self, id: &str) -> Result<(), String> {
+        self.trash_manager.restore_entry(id)
+    }
+
+    /// Permanently delete a single trash entry by its ID.
+    pub fn purge_trash_entry(&self, id: &str) -> Result<(), String> {
+        self.trash_manager.purge_entry(id)
+    }
+
+    /// Purge all entries that exceed the configured expiry age.
+    pub fn purge_expired_trash(&self) -> usize {
+        self.trash_manager.purge_expired()
+    }
+
+    /// Empty the entire trash bin. Returns the number of entries removed.
+    pub fn empty_trash(&self) -> usize {
+        self.trash_manager.empty()
+    }
+
     pub fn scan(&self) -> std::io::Result<Manifest> {
         let m = manifest::build_manifest(&self.root, &self.node_id, &self.exclusions)?;
         *self.manifest.write() = m.clone();
@@ -704,7 +729,7 @@ impl SyncEngine {
 
             let full = self.root.join(rel);
             if full.is_dir() {
-                move_to_trash(&self.root, &full, rel);
+                self.trash_manager.move_to_trash(&full, rel, &self.node_id);
                 let children: Vec<PathBuf> = self
                     .manifest
                     .read()
@@ -719,7 +744,7 @@ impl SyncEngine {
                 }
                 m.files.remove(rel);
             } else {
-                move_to_trash(&self.root, &full, rel);
+                self.trash_manager.move_to_trash(&full, rel, &self.node_id);
                 self.manifest.write().files.remove(rel);
             }
             count += 1;
diff --git a/crates/filesync/tests/test_app.rs b/crates/filesync/tests/test_app.rs
index e7942bf..f5308e1 100644
--- a/crates/filesync/tests/test_app.rs
+++ b/crates/filesync/tests/test_app.rs
@@ -91,6 +91,8 @@ fn filesync_config_exclusions_compiles_glob_rules() {
         auth_token: None,
         exclude_patterns: vec!["*.log".to_string(), "build/**".to_string()],
         exclude_regex: vec![],
+        trash_expiry_days: None,
+        full_scan_interval_secs: None,
     };
     let ex = cfg.exclusions();
     assert_eq!(ex.rule_count(), 4); // 2 explicit + 2 default rules
@@ -109,6 +111,8 @@ fn filesync_config_exclusions_compiles_regex_rules() {
         auth_token: None,
         exclude_patterns: vec![],
         exclude_regex: vec![r".*\.(tmp|bak)$".to_string()],
+        trash_expiry_days: None,
+        full_scan_interval_secs: None,
     };
     let ex = cfg.exclusions();
     assert_eq!(ex.rule_count(), 3); // 1 explicit + 2 default rules
@@ -127,6 +131,8 @@ fn filesync_config_empty_exclusions() {
         auth_token: None,
         exclude_patterns: vec![],
         exclude_regex: vec![],
+        trash_expiry_days: None,
+        full_scan_interval_secs: None,
     };
     let ex = cfg.exclusions();
     assert_eq!(ex.rule_count(), 2); // 2 default rules