v1.2.8 - fix url links, tab indent, todo state, graph rework, collapsible sections, nav history, page breaks, folder/tag display

README.md

@@ -1,11 +1,16 @@
 # HelixNotes
 
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://codeberg.org/ArkHost/HelixNotes/src/branch/main/LICENSE)
+[![Latest Release](https://img.shields.io/badge/release-v1.2.7-green)](https://codeberg.org/ArkHost/HelixNotes/releases)
+[![Website](https://img.shields.io/badge/web-helixnotes.com-purple)](https://helixnotes.com)
+[![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20Windows%20%7C%20macOS%20%7C%20Android-lightgrey)]()
+
 A local markdown note-taking app built with Tauri, SvelteKit, and Rust.
 
 Your notes are stored as standard Markdown files on your local filesystem.
 No cloud, no lock-in.
 
-## Download (v1.2.1)
+## Download (v1.2.7)
 
 ### Linux
 
@@ -23,23 +28,23 @@ curl -fsSL https://repo.arkhost.com/gpg.key | sudo gpg --dearmor -o /usr/share/k
 
 #### AppImage (Arch, Fedora 43+, openSUSE Tumbleweed)
 
-[Download AppImage](https://download.helixnotes.com/releases/v1.2.1/HelixNotes_1.2.1_amd64.AppImage)
+[Download AppImage](https://download.helixnotes.com/releases/v1.2.7/HelixNotes_1.2.7_amd64.AppImage)
 
 #### .deb (manual)
 
-[Download .deb](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.1/HelixNotes_1.2.1_amd64.deb) (Ubuntu 22.04+)
+[Download .deb](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.7/HelixNotes_1.2.7_amd64.deb) (Ubuntu 22.04+)
 
 ### Windows
 
-[Download Installer](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.1/HelixNotes_1.2.1_x64-setup.exe) (Windows 10/11)
+[Download Installer](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.7/HelixNotes_1.2.7_x64-setup.exe) (Windows 10/11)
 
 ### macOS
 
-[Download .dmg](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.1/HelixNotes_1.2.1_x64.dmg) (Intel, runs on Apple Silicon via Rosetta)
+[Download .dmg](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.7/HelixNotes_1.2.7_x64.dmg) (Intel, runs on Apple Silicon via Rosetta)
 
 ### Android
 
-[Download APK](https://download.helixnotes.com/releases/v1.2.1/HelixNotes_1.2.1_android.apk)
+[Download APK](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.7/HelixNotes_1.2.7_android.apk)
 
 ---
 
@@ -50,7 +55,7 @@ All releases: [codeberg.org/ArkHost/HelixNotes/releases](https://codeberg.org/Ar
 - Markdown editor with toolbar, slash commands, source mode, code highlighting
 - `[[Wiki-links]]` and graph view
 - Full-text search (Tantivy)
-- Outline panel, daily notes, tags, drag-and-drop
+- Outline panel, daily notes with calendar view, tags, drag-and-drop
 - Math (KaTeX), PDF preview, Obsidian import
 - AI writing tools (Ollama / Anthropic / OpenAI)
 - Version history with diffs, automatic backups

package.json

@@ -2,7 +2,7 @@
   "name": "helixnotes",
   "private": true,
   "license": "AGPL-3.0-or-later",
-  "version": "1.2.2",
+  "version": "1.2.8",
   "type": "module",
   "scripts": {
     "dev": "vite dev",

src-tauri/Cargo.lock

@@ -1850,7 +1850,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "helixnotes"
-version = "1.2.2"
+version = "1.2.8"
 dependencies = [
  "arboard",
  "chrono",
@@ -3938,6 +3938,7 @@ checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
 dependencies = [
  "base64 0.22.1",
  "bytes",
+ "futures-channel",
  "futures-core",
  "futures-util",
  "http",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "helixnotes"
-version = "1.2.2"
+version = "1.2.8"
 description = "Local markdown note-taking app"
 authors = ["HelixNotes"]
 license = "AGPL-3.0-or-later"
@@ -35,7 +35,7 @@ tokio = { version = "1", features = ["full"] }
 dirs = "6"
 regex = "1"
 zip = { version = "2", default-features = false, features = ["deflate"] }
-reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls", "blocking"] }
 futures = "0.3"
 rayon = "1"
 rustls = { version = "0.23", default-features = false, features = ["ring", "logging", "std", "tls12"] }

src-tauri/capabilities/default.json

@@ -12,6 +12,8 @@
     "core:window:allow-close",
     "core:window:allow-is-maximized",
     "core:window:allow-set-decorations",
+    "core:window:allow-is-fullscreen",
+    "core:window:allow-set-fullscreen",
     "core:window:allow-set-title",
     "core:webview:allow-create-webview-window",
     "dialog:default",

src-tauri/src/commands.rs

@@ -112,6 +112,13 @@ pub fn get_notebooks(state: State<'_, AppState>) -> Result<Vec<NotebookEntry>, S
     operations::scan_notebooks(vault_path)
 }
 
+#[tauri::command]
+pub fn count_root_notes(state: State<'_, AppState>) -> Result<usize, String> {
+    let config = state.config.lock().map_err(|e| e.to_string())?;
+    let vault_path = config.active_vault.as_ref().ok_or("No active vault")?;
+    operations::count_root_notes(vault_path)
+}
+
 #[tauri::command]
 pub fn create_notebook(
     state: State<'_, AppState>,
@@ -201,9 +208,11 @@ pub fn move_notebook(
 
 #[tauri::command]
 pub fn delete_notebook(state: State<'_, AppState>, path: String) -> Result<(), String> {
+    let vault_path = {
         let config = state.config.lock().map_err(|e| e.to_string())?;
-    let vault_path = config.active_vault.as_ref().ok_or("No active vault")?;
-    operations::delete_notebook(vault_path, &path)
+        config.active_vault.as_ref().ok_or("No active vault")?.clone()
+    };
+    operations::delete_notebook(&vault_path, &path)
 }
 
 // ── Notes ──
@@ -248,6 +257,14 @@ pub fn save_note(
     drop(config);
 
     operations::save_note(&path, &meta, &body)?;
+
+    // Re-index note so search picks up changes immediately
+    if let Ok(search_guard) = state.search_index.lock() {
+        if let Some(ref search) = *search_guard {
+            let _ = search.index_note(&path);
+        }
+    }
+
     Ok(())
 }
 
@@ -272,10 +289,10 @@ pub fn create_note(
 }
 
 #[tauri::command]
-pub fn create_daily_note(state: State<'_, AppState>) -> Result<NoteEntry, String> {
+pub fn create_daily_note(state: State<'_, AppState>, date: Option<String>) -> Result<NoteEntry, String> {
     let config = state.config.lock().map_err(|e| e.to_string())?;
     let vault_path = config.active_vault.as_ref().ok_or("No active vault")?;
-    let entry = operations::create_daily_note(vault_path)?;
+    let entry = operations::create_daily_note(vault_path, date.as_deref())?;
 
     if let Ok(search_guard) = state.search_index.lock() {
         if let Some(ref search) = *search_guard {
@@ -287,8 +304,11 @@ pub fn create_daily_note(state: State<'_, AppState>) -> Result<NoteEntry, String
 }
 
 #[tauri::command]
-pub fn rename_note(path: String, new_title: String) -> Result<String, String> {
-    operations::rename_note(&path, &new_title)
+pub fn rename_note(state: State<'_, AppState>, path: String, new_title: String) -> Result<String, String> {
+    let config = state.config.lock().map_err(|e| e.to_string())?;
+    let vault_path = config.active_vault.as_ref().ok_or("No active vault")?.clone();
+    drop(config);
+    operations::rename_note(&path, &new_title, &vault_path)
 }
 
 #[tauri::command]
@@ -410,9 +430,14 @@ pub fn get_graph_data(state: State<'_, AppState>) -> Result<crate::types::GraphD
     let vault_path = config.active_vault.as_ref().ok_or("No active vault")?;
     let vault = std::path::Path::new(vault_path);
 
-    // Pass 1: collect all notes with titles (fast title extraction, no YAML parsing)
+    // Pass 1: collect ALL notes as nodes (no title deduplication — every note must appear)
     let mut graph_nodes = Vec::new();
-    let mut title_to_idx: HashMap<String, usize> = HashMap::new();
+    // title → list of node indices (one title can map to multiple notes in different folders)
+    let mut title_to_idxs: HashMap<String, Vec<usize>> = HashMap::new();
+    // vault-relative path without extension → idx (for [[subfolder/note]] style links)
+    let mut relpath_to_idx: HashMap<String, usize> = HashMap::new();
+    // absolute path → idx (for fast active-note lookup)
+    let mut path_to_idx: HashMap<String, usize> = HashMap::new();
     let mut seen_paths: HashSet<String> = HashSet::new();
     let mut contents: Vec<String> = Vec::new();
 
@@ -442,12 +467,18 @@ pub fn get_graph_data(state: State<'_, AppState>) -> Result<crate::types::GraphD
             path.file_stem().unwrap_or_default().to_string_lossy().to_string()
         });
 
-        // Deduplicate by title — skip if we already have a node with this title
-        let title_lower = title.to_lowercase();
-        if title_to_idx.contains_key(&title_lower) { continue; }
-
         let idx = graph_nodes.len();
-        title_to_idx.insert(title_lower, idx);
+        let title_lower = title.to_lowercase();
+        title_to_idxs.entry(title_lower).or_default().push(idx);
+        path_to_idx.insert(path_str.clone(), idx);
+
+        // Also index by vault-relative path without extension (e.g. "subfolder/note name")
+        if let Ok(rel) = path.strip_prefix(vault) {
+            let rel_no_ext = rel.with_extension("");
+            let rel_lower = rel_no_ext.to_string_lossy().to_lowercase();
+            relpath_to_idx.entry(rel_lower).or_insert(idx);
+        }
+
         graph_nodes.push(crate::types::GraphNode {
             title,
             path: path_str,
@@ -456,8 +487,22 @@ pub fn get_graph_data(state: State<'_, AppState>) -> Result<crate::types::GraphD
     }
 
     // Pass 2: extract edges from wiki-links (inline scan, no regex)
-    let mut edges = Vec::new();
-    let mut edge_set: HashSet<(usize, usize)> = HashSet::new();
+    // edge_map: (src, tgt) → index in edges vec, used to detect reverse links
+    let mut edges: Vec<crate::types::GraphEdge> = Vec::new();
+    let mut edge_map: HashMap<(usize, usize), usize> = HashMap::new();
+
+    let add_edge = |edges: &mut Vec<crate::types::GraphEdge>, edge_map: &mut HashMap<(usize, usize), usize>, src: usize, tgt: usize| {
+        if src == tgt { return; }
+        if edge_map.contains_key(&(src, tgt)) { return; } // exact duplicate
+        if let Some(&rev_idx) = edge_map.get(&(tgt, src)) {
+            // Reverse direction already exists — mark it as bidirectional
+            edges[rev_idx].bidirectional = true;
+        } else {
+            let idx = edges.len();
+            edge_map.insert((src, tgt), idx);
+            edges.push(crate::types::GraphEdge { source: src, target: tgt, bidirectional: false });
+        }
+    };
 
     for (source_idx, body) in contents.iter().enumerate() {
         let bytes = body.as_bytes();
@@ -478,11 +523,21 @@ pub fn get_graph_data(state: State<'_, AppState>) -> Result<crate::types::GraphD
                     let link = link.split('^').next().unwrap_or(link);
                     let link = link.trim().to_lowercase();
 
-                    if let Some(&target_idx) = title_to_idx.get(&link) {
-                        if target_idx != source_idx {
-                            let key = if source_idx < target_idx { (source_idx, target_idx) } else { (target_idx, source_idx) };
-                            if edge_set.insert(key) {
-                                edges.push(crate::types::GraphEdge { source: source_idx, target: target_idx });
+                    // 1. Try vault-relative path match (e.g. "arkhost/note name")
+                    if let Some(&target_idx) = relpath_to_idx.get(&link) {
+                        add_edge(&mut edges, &mut edge_map, source_idx, target_idx);
+                    } else if let Some(targets) = title_to_idxs.get(&link) {
+                        // 2. Title match — connect to all notes with this title
+                        for &target_idx in targets {
+                            add_edge(&mut edges, &mut edge_map, source_idx, target_idx);
+                        }
+                    } else if link.contains('/') {
+                        // 3. Path-based ref: try last segment as title fallback
+                        if let Some(seg) = link.rsplit('/').next() {
+                            if let Some(targets) = title_to_idxs.get(seg) {
+                                for &target_idx in targets {
+                                    add_edge(&mut edges, &mut edge_map, source_idx, target_idx);
+                                }
                             }
                         }
                     }
@@ -551,10 +606,10 @@ pub fn reindex(state: State<'_, AppState>) -> Result<(), String> {
 // ── Trash ──
 
 #[tauri::command]
-pub fn get_trash(state: State<'_, AppState>) -> Result<Vec<NoteEntry>, String> {
+pub fn get_trash(state: State<'_, AppState>) -> Result<TrashContents, String> {
     let config = state.config.lock().map_err(|e| e.to_string())?;
     let vault_path = config.active_vault.as_ref().ok_or("No active vault")?;
-    operations::get_trash_notes(vault_path)
+    operations::get_trash_contents(vault_path)
 }
 
 #[tauri::command]
@@ -563,14 +618,29 @@ pub fn restore_note(
     trash_path: String,
     dest_notebook: Option<String>,
 ) -> Result<String, String> {
+    let vault_path = {
         let config = state.config.lock().map_err(|e| e.to_string())?;
-    let vault_path = config.active_vault.as_ref().ok_or("No active vault")?;
-    operations::restore_note(vault_path, &trash_path, dest_notebook.as_deref())
+        config.active_vault.as_ref().ok_or("No active vault")?.clone()
+    };
+    operations::restore_note(&vault_path, &trash_path, dest_notebook.as_deref())
 }
 
 #[tauri::command]
-pub fn permanent_delete(path: String) -> Result<(), String> {
-    operations::permanent_delete(&path)
+pub fn restore_notebook(state: State<'_, AppState>, trash_path: String) -> Result<String, String> {
+    let vault_path = {
+        let config = state.config.lock().map_err(|e| e.to_string())?;
+        config.active_vault.as_ref().ok_or("No active vault")?.clone()
+    };
+    operations::restore_notebook(&vault_path, &trash_path)
+}
+
+#[tauri::command]
+pub fn permanent_delete(state: State<'_, AppState>, path: String) -> Result<(), String> {
+    let vault_path = {
+        let config = state.config.lock().map_err(|e| e.to_string())?;
+        config.active_vault.as_ref().ok_or("No active vault")?.clone()
+    };
+    operations::permanent_delete(&vault_path, &path)
 }
 
 #[tauri::command]
@@ -1335,34 +1405,54 @@ fn resolve_wiki_ref(
     reference.to_string()
 }
 
-// ── Open file with system default handler ──
+// ── Open file/URL with system default handler ──
 
-#[tauri::command]
-pub fn open_file(path: String) -> Result<(), String> {
+fn xdg_open(arg: &str) -> Result<(), String> {
     #[cfg(target_os = "linux")]
     {
-        std::process::Command::new("xdg-open")
-            .arg(&path)
-            .spawn()
-            .map_err(|e| format!("Failed to open {}: {}", path, e))?;
+        let mut cmd = std::process::Command::new("xdg-open");
+        cmd.arg(arg);
+        // Clear AppImage environment so child processes find host binaries
+        // (e.g. gio-launch-desktop on GNOME)
+        if std::env::var("APPIMAGE").is_ok() {
+            cmd.env_remove("LD_LIBRARY_PATH")
+                .env_remove("LD_PRELOAD")
+                .env_remove("GIO_LAUNCHED_DESKTOP_FILE")
+                .env_remove("GIO_LAUNCHED_DESKTOP_FILE_PID");
+            if let Ok(original_path) = std::env::var("PATH_ORIG") {
+                cmd.env("PATH", original_path);
+            }
+        }
+        cmd.spawn()
+            .map_err(|e| format!("Failed to open {}: {}", arg, e))?;
     }
     #[cfg(target_os = "macos")]
     {
         std::process::Command::new("open")
-            .arg(&path)
+            .arg(arg)
             .spawn()
-            .map_err(|e| format!("Failed to open {}: {}", path, e))?;
+            .map_err(|e| format!("Failed to open {}: {}", arg, e))?;
     }
     #[cfg(target_os = "windows")]
     {
         std::process::Command::new("cmd")
-            .args(["/C", "start", "", &path])
+            .args(["/C", "start", "", arg])
             .spawn()
-            .map_err(|e| format!("Failed to open {}: {}", path, e))?;
+            .map_err(|e| format!("Failed to open {}: {}", arg, e))?;
     }
     Ok(())
 }
 
+#[tauri::command]
+pub fn open_file(path: String) -> Result<(), String> {
+    xdg_open(&path)
+}
+
+#[tauri::command]
+pub fn open_url(url: String) -> Result<(), String> {
+    xdg_open(&url)
+}
+
 #[tauri::command]
 pub fn copy_file_to(source: String, destination: String) -> Result<(), String> {
     std::fs::copy(&source, &destination).map_err(|e| format!("Failed to copy file: {}", e))?;

src-tauri/src/lib.rs

@@ -98,6 +98,7 @@ pub fn run() {
             commands::set_font_family,
             commands::set_line_height,
             commands::get_notebooks,
+            commands::count_root_notes,
             commands::create_notebook,
             commands::rename_notebook,
             commands::delete_notebook,
@@ -117,6 +118,7 @@ pub fn run() {
             commands::reindex,
             commands::get_trash,
             commands::restore_note,
+            commands::restore_notebook,
             commands::permanent_delete,
             commands::empty_trash,
             commands::load_vault_state,
@@ -135,6 +137,7 @@ pub fn run() {
             commands::get_vault_stats,
             commands::import_obsidian,
             commands::open_file,
+            commands::open_url,
             commands::copy_file_to,
             commands::create_backup,
             commands::list_backups,
@@ -149,7 +152,80 @@ pub fn run() {
             commands::ai_ask,
             commands::get_install_type,
             commands::get_pending_open_file,
-        ]);
+        ])
+        .register_asynchronous_uri_scheme_protocol("imgproxy", |_ctx, request, responder| {
+            let path = request.uri().path().to_string();
+            std::thread::spawn(move || {
+                let encoded = path.strip_prefix('/').unwrap_or(&path);
+                let external_url = percent_decode(encoded);
+
+                if !external_url.starts_with("http://") && !external_url.starts_with("https://") {
+                    let _ = responder.respond(
+                        tauri::http::Response::builder()
+                            .status(400)
+                            .body(Vec::new())
+                            .unwrap(),
+                    );
+                    return;
+                }
+
+                let client = match reqwest::blocking::Client::builder()
+                    .timeout(std::time::Duration::from_secs(30))
+                    .build()
+                {
+                    Ok(c) => c,
+                    Err(_) => {
+                        let _ = responder.respond(
+                            tauri::http::Response::builder()
+                                .status(502)
+                                .body(Vec::new())
+                                .unwrap(),
+                        );
+                        return;
+                    }
+                };
+
+                match client.get(&external_url).send() {
+                    Ok(resp) => {
+                        let content_type = resp
+                            .headers()
+                            .get("content-type")
+                            .and_then(|h| h.to_str().ok())
+                            .unwrap_or("application/octet-stream")
+                            .to_string();
+                        let status = resp.status().as_u16();
+                        match resp.bytes() {
+                            Ok(bytes) => {
+                                let _ = responder.respond(
+                                    tauri::http::Response::builder()
+                                        .status(status)
+                                        .header("Content-Type", &content_type)
+                                        .header("Access-Control-Allow-Origin", "*")
+                                        .body(bytes.to_vec())
+                                        .unwrap(),
+                                );
+                            }
+                            Err(_) => {
+                                let _ = responder.respond(
+                                    tauri::http::Response::builder()
+                                        .status(502)
+                                        .body(Vec::new())
+                                        .unwrap(),
+                                );
+                            }
+                        }
+                    }
+                    Err(_) => {
+                        let _ = responder.respond(
+                            tauri::http::Response::builder()
+                                .status(502)
+                                .body(Vec::new())
+                                .unwrap(),
+                        );
+                    }
+                }
+            });
+        });
 
     #[cfg(not(target_os = "android"))]
     {
@@ -251,3 +327,23 @@ fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+fn percent_decode(input: &str) -> String {
+    let mut output = Vec::with_capacity(input.len());
+    let bytes = input.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'%' && i + 2 < bytes.len() {
+            if let Ok(decoded) =
+                u8::from_str_radix(std::str::from_utf8(&bytes[i + 1..i + 3]).unwrap_or(""), 16)
+            {
+                output.push(decoded);
+                i += 3;
+                continue;
+            }
+        }
+        output.push(bytes[i]);
+        i += 1;
+    }
+    String::from_utf8_lossy(&output).to_string()
+}

src-tauri/src/search/mod.rs

@@ -9,9 +9,9 @@ use tantivy::collector::TopDocs;
 use tantivy::directory::MmapDirectory;
 #[cfg(target_os = "android")]
 use tantivy::directory::RamDirectory;
-use tantivy::query::QueryParser;
+use tantivy::query::{BooleanQuery, FuzzyTermQuery, Occur, PhrasePrefixQuery, Query};
 use tantivy::schema::*;
-use tantivy::{Index, IndexWriter, TantivyDocument};
+use tantivy::{Index, IndexWriter, TantivyDocument, Term};
 use walkdir::WalkDir;
 
 pub struct SearchIndex {
@@ -152,14 +152,37 @@ impl SearchIndex {
         let reader = self.index.reader().map_err(|e| e.to_string())?;
         let searcher = reader.searcher();
 
-        let query_parser = QueryParser::for_index(
-            &self.index,
-            vec![self.title_field, self.body_field, self.tags_field],
-        );
+        let fields = vec![self.title_field, self.body_field, self.tags_field];
+        let terms: Vec<String> = query_str
+            .split_whitespace()
+            .map(|t| t.to_lowercase())
+            .collect();
 
-        let query = query_parser
-            .parse_query(query_str)
-            .map_err(|e| e.to_string())?;
+        // For each search term, create prefix + fuzzy queries across all fields (OR),
+        // then AND all terms together
+        let term_queries: Vec<(Occur, Box<dyn Query>)> = terms
+            .iter()
+            .map(|term| {
+                let field_queries: Vec<(Occur, Box<dyn Query>)> = fields
+                    .iter()
+                    .flat_map(|&field| {
+                        let prefix: Box<dyn Query> = Box::new(PhrasePrefixQuery::new(
+                            vec![Term::from_field_text(field, term)],
+                        ));
+                        let fuzzy: Box<dyn Query> = Box::new(FuzzyTermQuery::new(
+                            Term::from_field_text(field, term),
+                            1,
+                            true,
+                        ));
+                        vec![(Occur::Should, prefix), (Occur::Should, fuzzy)]
+                    })
+                    .collect();
+                let combined: Box<dyn Query> = Box::new(BooleanQuery::new(field_queries));
+                (Occur::Must, combined)
+            })
+            .collect();
+
+        let query = BooleanQuery::new(term_queries);
 
         let top_docs = searcher
             .search(&query, &TopDocs::with_limit(limit))

src-tauri/src/types.rs

@@ -19,6 +19,20 @@ pub struct NoteEntry {
     pub preview: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TrashContents {
+    pub notes: Vec<NoteEntry>,
+    pub notebooks: Vec<TrashNotebookEntry>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TrashNotebookEntry {
+    pub name: String,
+    pub path: String,
+    pub note_count: usize,
+    pub modified: DateTime<Utc>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct NotebookEntry {
     pub name: String,
@@ -271,4 +285,5 @@ pub struct GraphNode {
 pub struct GraphEdge {
     pub source: usize,
     pub target: usize,
+    pub bidirectional: bool,
 }

src-tauri/src/vault/operations.rs

@@ -1,6 +1,6 @@
-use crate::types::{NoteContent, NoteEntry, NoteMeta, NotebookEntry, VaultState};
+use crate::types::{NoteContent, NoteEntry, NoteMeta, NotebookEntry, TrashContents, TrashNotebookEntry, VaultState};
 use crate::vault::frontmatter;
-use chrono::{Local, Locale, Utc};
+use chrono::{DateTime, Local, Locale, Utc};
 use rayon::prelude::*;
 use std::fs;
 use std::io::Read;
@@ -63,7 +63,9 @@ fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
     let mut dirs: Vec<_> = read_dir
         .filter_map(|e| e.ok())
         .filter(|e| {
-            e.file_type().map(|ft| ft.is_dir()).unwrap_or(false) && !is_hidden(&e.path())
+            e.file_type().map(|ft| ft.is_dir()).unwrap_or(false)
+                && !is_hidden(&e.path())
+                && e.file_name().to_string_lossy() != "Daily"
         })
         .collect();
 
@@ -165,6 +167,22 @@ fn is_hidden(path: &Path) -> bool {
         .unwrap_or(false)
 }
 
+pub fn count_root_notes(vault_path: &str) -> Result<usize, String> {
+    let root = Path::new(vault_path);
+    if !root.exists() {
+        return Err("Vault path does not exist".to_string());
+    }
+    let count = fs::read_dir(root)
+        .map_err(|e| e.to_string())?
+        .filter_map(|e| e.ok())
+        .filter(|e| {
+            e.file_type().map(|ft| ft.is_file()).unwrap_or(false)
+                && e.path().extension().and_then(|x| x.to_str()) == Some("md")
+        })
+        .count();
+    Ok(count)
+}
+
 pub fn scan_notes(vault_path: &str, notebook_path: Option<&str>) -> Result<Vec<NoteEntry>, String> {
     let scan_path = notebook_path.unwrap_or(vault_path);
     let root = Path::new(scan_path);
@@ -276,7 +294,7 @@ fn read_note_entry_metadata_only(path: &Path, vault_root: &Path) -> Result<NoteE
         .to_string_lossy()
         .to_string();
 
-    let (mut meta, _content) = frontmatter::parse_note(&raw, &filename);
+    let (mut meta, content) = frontmatter::parse_note(&raw, &filename);
 
     // Always use filesystem timestamps on Android (faster than parsing date strings)
     if let Ok(fs_meta) = fs::metadata(path) {
@@ -294,11 +312,13 @@ fn read_note_entry_metadata_only(path: &Path, vault_root: &Path) -> Result<NoteE
         .to_string_lossy()
         .to_string();
 
+    let preview = frontmatter::extract_preview(&content, 120);
+
     Ok(NoteEntry {
         path: path.to_string_lossy().to_string(),
         relative_path: relative,
         meta,
-        preview: String::new(),
+        preview,
     })
 }
 
@@ -500,11 +520,15 @@ fn get_system_locale() -> Locale {
     }
 }
 
-pub fn create_daily_note(vault_path: &str) -> Result<NoteEntry, String> {
-    let today = Local::now();
-    let date_str = today.format("%Y-%m-%d").to_string();
+pub fn create_daily_note(vault_path: &str, date: Option<&str>) -> Result<NoteEntry, String> {
+    let target_date = match date {
+        Some(d) => chrono::NaiveDate::parse_from_str(d, "%Y-%m-%d")
+            .map_err(|e| format!("Invalid date: {}", e))?,
+        None => Local::now().date_naive(),
+    };
+    let date_str = target_date.format("%Y-%m-%d").to_string();
     let locale = get_system_locale();
-    let title = today.format_localized("%B %d, %Y", locale).to_string();
+    let title = target_date.format_localized("%B %d, %Y", locale).to_string();
 
     let dir = Path::new(vault_path).join("Daily");
     fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
@@ -619,17 +643,26 @@ pub fn delete_notebook(vault_path: &str, notebook_path: &str) -> Result<(), Stri
     let trash_name = format!("{}_{}", timestamp, dirname);
     let dest = trash_dir.join(&trash_name);
 
+    // Save original relative path in a sidecar .meta file for restore
+    let relative = src
+        .strip_prefix(vault_path)
+        .unwrap_or(src)
+        .to_string_lossy()
+        .to_string();
+    let meta_path = trash_dir.join(format!("{}.meta", trash_name));
+    let _ = fs::write(&meta_path, &relative);
+
     fs::rename(src, dest).map_err(|e| e.to_string())?;
     Ok(())
 }
 
-pub fn rename_note(path: &str, new_title: &str) -> Result<String, String> {
+pub fn rename_note(path: &str, new_title: &str, vault_path: &str) -> Result<String, String> {
     let src = Path::new(path);
     if !src.exists() {
         return Err("Note does not exist".to_string());
     }
 
-    // Update frontmatter
+    // Read old title before renaming
     let raw = fs::read_to_string(src).map_err(|e| e.to_string())?;
     let filename = src
         .file_name()
@@ -637,6 +670,10 @@ pub fn rename_note(path: &str, new_title: &str) -> Result<String, String> {
         .to_string_lossy()
         .to_string();
     let (mut meta, content) = frontmatter::parse_note(&raw, &filename);
+    let old_title = meta.title.clone();
+    let old_path_str = src.to_string_lossy().to_string();
+
+    // Update frontmatter
     meta.title = new_title.to_string();
     meta.modified = Utc::now();
     if meta.id.is_empty() {
@@ -653,7 +690,134 @@ pub fn rename_note(path: &str, new_title: &str) -> Result<String, String> {
         fs::rename(src, &new_path).map_err(|e| e.to_string())?;
     }
 
-    Ok(new_path.to_string_lossy().to_string())
+    let new_path_str = new_path.to_string_lossy().to_string();
+
+    // Update wikilinks in other notes that reference this note
+    update_wikilinks_after_rename(vault_path, &old_path_str, &new_path_str, &old_title, new_title);
+
+    Ok(new_path_str)
+}
+
+/// Walk all .md files in the vault and update wikilink references after a note rename.
+/// Updates both HTML data-attributes (data-path, data-title) and raw [[old_title]] references.
+fn update_wikilinks_after_rename(
+    vault_path: &str,
+    old_path: &str,
+    new_path: &str,
+    old_title: &str,
+    new_title: &str,
+) {
+    let vault = Path::new(vault_path);
+    let vault_prefix = format!("{}/", vault_path);
+
+    // Compute vault-relative path refs (without .md) for path-based wikilink refs
+    let old_rel_ref = old_path.strip_prefix(&vault_prefix)
+        .unwrap_or(old_path)
+        .strip_suffix(".md")
+        .unwrap_or(old_path);
+    let new_rel_ref = new_path.strip_prefix(&vault_prefix)
+        .unwrap_or(new_path)
+        .strip_suffix(".md")
+        .unwrap_or(new_path);
+
+    // Check if another note with the same old_title exists in the vault.
+    // If so, title-based replacements (rules 1-3) are ambiguous and must be skipped,
+    // because we can't tell which [[Old Title]] ref points to the renamed note
+    // vs. the other note with the same title.
+    let title_is_unique = !WalkDir::new(vault)
+        .into_iter()
+        .filter_map(|e| e.ok())
+        .any(|e| {
+            let p = e.path();
+            if !p.is_file() || p.to_string_lossy().as_ref() == new_path {
+                return false;
+            }
+            if p.extension().and_then(|ext| ext.to_str()) != Some("md") {
+                return false;
+            }
+            let p_str = p.to_string_lossy();
+            if p_str.contains("/.helixnotes/") || p_str.contains("/.trash/") {
+                return false;
+            }
+            // Check if this note's filename (without .md) matches the old title
+            p.file_stem()
+                .and_then(|s| s.to_str())
+                .map(|s| s.eq_ignore_ascii_case(old_title))
+                .unwrap_or(false)
+        });
+
+    for entry in WalkDir::new(vault)
+        .into_iter()
+        .filter_map(|e| e.ok())
+    {
+        let path = entry.path();
+        if !path.is_file() { continue; }
+        let path_str = path.to_string_lossy();
+        if path_str.contains("/.helixnotes/") || path_str.contains("/.trash/") { continue; }
+        if path.extension().and_then(|e| e.to_str()) != Some("md") { continue; }
+        // Skip the renamed note itself
+        if *path_str == *new_path { continue; }
+
+        let content = match fs::read_to_string(path) {
+            Ok(c) => c,
+            Err(_) => continue,
+        };
+
+        let mut result = content.clone();
+
+        // Notes are saved as markdown with [[ref]] or [[ref|display]] syntax.
+        // Update all wikilink forms that reference the renamed note:
+
+        // Title-based rules only apply when the old title is unique in the vault.
+        // If another note shares the same title, these would be ambiguous.
+        if old_title != new_title && title_is_unique {
+            // 1. Short title ref: [[Old Title]] → [[New Title]]
+            result = result.replace(
+                &format!("[[{}]]", old_title),
+                &format!("[[{}]]", new_title),
+            );
+
+            // 2. Short title with alias: [[Old Title|display]] → [[New Title|display]]
+            result = result.replace(
+                &format!("[[{}|", old_title),
+                &format!("[[{}|", new_title),
+            );
+
+            // 3. Short title as alias display: [[ref|Old Title]] → [[ref|New Title]]
+            result = result.replace(
+                &format!("|{}]]", old_title),
+                &format!("|{}]]", new_title),
+            );
+        }
+
+        // Path-based rules are always safe (paths are unique).
+        if old_rel_ref != new_rel_ref {
+            // 4. Path-based ref: [[folder/Old Name]] → [[folder/New Name]]
+            result = result.replace(
+                &format!("[[{}]]", old_rel_ref),
+                &format!("[[{}]]", new_rel_ref),
+            );
+
+            // 5. Path-based ref with alias: [[folder/Old Name|display]] → [[folder/New Name|display]]
+            //    Also update the alias if it matches the old title.
+            //    e.g. [[folder/Old Name|Old Title]] → [[folder/New Name|New Title]]
+            if old_title != new_title {
+                result = result.replace(
+                    &format!("[[{}|{}]]", old_rel_ref, old_title),
+                    &format!("[[{}|{}]]", new_rel_ref, new_title),
+                );
+            }
+            // For aliases that DON'T match the old title, just update the ref part
+            result = result.replace(
+                &format!("[[{}|", old_rel_ref),
+                &format!("[[{}|", new_rel_ref),
+            );
+        }
+
+        if result != content {
+            let _ = fs::write(path, &result);
+        }
+    }
 }
 
 pub fn rename_notebook(path: &str, new_name: &str) -> Result<String, String> {
@@ -721,14 +885,29 @@ pub fn move_notebook(notebook_path: &str, dest_parent: &str) -> Result<String, S
     Ok(dest.to_string_lossy().to_string())
 }
 
-pub fn get_trash_notes(vault_path: &str) -> Result<Vec<NoteEntry>, String> {
+/// Remove a directory inside trash if it's empty (after restoring/deleting its last note).
+fn cleanup_empty_trash_dir(vault_path: &str, dir: Option<&Path>) {
+    let trash_dir = helixnotes_dir(vault_path).join("trash");
+    if let Some(d) = dir {
+        if d != trash_dir && d.starts_with(&trash_dir) {
+            if let Ok(mut entries) = fs::read_dir(d) {
+                if entries.next().is_none() {
+                    let _ = fs::remove_dir(d);
+                }
+            }
+        }
+    }
+}
+
+pub fn get_trash_contents(vault_path: &str) -> Result<TrashContents, String> {
     let trash_dir = helixnotes_dir(vault_path).join("trash");
     if !trash_dir.exists() {
-        return Ok(Vec::new());
+        return Ok(TrashContents { notes: Vec::new(), notebooks: Vec::new() });
     }
 
     let vault_root = Path::new(vault_path);
     let mut notes = Vec::new();
+    let mut notebooks = Vec::new();
 
     for entry in fs::read_dir(&trash_dir).map_err(|e| e.to_string())? {
         let entry = entry.map_err(|e| e.to_string())?;
@@ -737,11 +916,39 @@ pub fn get_trash_notes(vault_path: &str) -> Result<Vec<NoteEntry>, String> {
             if let Ok(note) = read_note_entry(&path, vault_root) {
                 notes.push(note);
             }
+        } else if path.is_dir() {
+            // Deleted notebook — count .md files inside
+            let note_count = WalkDir::new(&path)
+                .min_depth(1)
+                .into_iter()
+                .filter_map(|e| e.ok())
+                .filter(|e| e.path().is_file() && e.path().extension().and_then(|x| x.to_str()) == Some("md"))
+                .count();
+            let dirname = path.file_name().unwrap_or_default().to_string_lossy();
+            // Strip timestamp prefix to get original notebook name
+            let name = if dirname.len() > 18 && dirname.chars().nth(17) == Some('_') {
+                dirname[18..].to_string()
+            } else if dirname.len() > 15 && dirname.chars().nth(14) == Some('_') {
+                dirname[15..].to_string()
+            } else {
+                dirname.to_string()
+            };
+            let modified = fs::metadata(&path)
+                .and_then(|m| m.modified())
+                .map(|t| DateTime::<Utc>::from(t))
+                .unwrap_or_else(|_| Utc::now());
+            notebooks.push(TrashNotebookEntry {
+                name,
+                path: path.to_string_lossy().to_string(),
+                note_count,
+                modified,
+            });
         }
     }
 
     notes.sort_by(|a, b| b.meta.modified.cmp(&a.meta.modified));
-    Ok(notes)
+    notebooks.sort_by(|a, b| b.modified.cmp(&a.modified));
+    Ok(TrashContents { notes, notebooks })
 }
 
 pub fn restore_note(
@@ -769,18 +976,66 @@ pub fn restore_note(
         &filename
     };
 
+    let parent = src.parent().map(|p| p.to_path_buf());
     let dest = dest_dir.join(original_name);
     fs::rename(src, &dest).map_err(|e| e.to_string())?;
+
+    // Clean up empty parent directory (deleted notebook folder) in trash
+    cleanup_empty_trash_dir(vault_path, parent.as_deref());
+
     Ok(dest.to_string_lossy().to_string())
 }
 
-pub fn permanent_delete(path: &str) -> Result<(), String> {
+pub fn restore_notebook(vault_path: &str, trash_path: &str) -> Result<String, String> {
+    let src = Path::new(trash_path);
+    if !src.exists() || !src.is_dir() {
+        return Err("Trashed notebook does not exist".to_string());
+    }
+
+    let dirname = src.file_name().unwrap_or_default().to_string_lossy();
+
+    // Try to read original path from sidecar .meta file
+    let meta_path = src.with_extension("").with_file_name(format!("{}.meta", dirname));
+    let relative = if let Ok(original) = fs::read_to_string(&meta_path) {
+        original
+    } else {
+        // Fallback for notebooks trashed before .meta files existed:
+        // strip timestamp prefix to get notebook name, restore to root
+        let name = if dirname.len() > 18 && dirname.chars().nth(17) == Some('_') {
+            &dirname[18..]
+        } else if dirname.len() > 15 && dirname.chars().nth(14) == Some('_') {
+            &dirname[15..]
+        } else {
+            &dirname
+        };
+        name.to_string()
+    };
+
+    let dest = Path::new(vault_path).join(&relative);
+
+    // Recreate parent directories if needed
+    if let Some(parent) = dest.parent() {
+        fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+
+    fs::rename(src, &dest).map_err(|e| e.to_string())?;
+    // Clean up .meta file
+    let _ = fs::remove_file(&meta_path);
+    Ok(dest.to_string_lossy().to_string())
+}
+
+pub fn permanent_delete(vault_path: &str, path: &str) -> Result<(), String> {
     let p = Path::new(path);
+    let parent = p.parent().map(|pp| pp.to_path_buf());
     if p.is_dir() {
         fs::remove_dir_all(p).map_err(|e| e.to_string())?;
     } else {
         fs::remove_file(p).map_err(|e| e.to_string())?;
     }
+
+    // Clean up empty parent directory (deleted notebook folder) in trash
+    cleanup_empty_trash_dir(vault_path, parent.as_deref());
+
     Ok(())
 }
 

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "productName": "HelixNotes",
-  "version": "1.2.2",
+  "version": "1.2.8",
   "identifier": "com.helixnotes.app",
   "build": {
     "frontendDist": "../build",
@@ -24,7 +24,7 @@
       }
     ],
     "security": {
-      "csp": "default-src 'self' 'unsafe-inline' 'unsafe-eval'; img-src 'self' asset: http://asset.localhost https: blob: data:; font-src 'self' data:; style-src 'self' 'unsafe-inline'; frame-src 'self' asset: http://asset.localhost",
+      "csp": "default-src 'self' 'unsafe-inline' 'unsafe-eval'; img-src 'self' asset: http://asset.localhost imgproxy: http://imgproxy.localhost https: blob: data:; font-src 'self' data:; style-src 'self' 'unsafe-inline'; frame-src 'self' asset: http://asset.localhost",
       "assetProtocol": {
         "enable": true,
         "scope": ["**/*", "/**", "**/.helixnotes/**"]

src/lib/api.ts

@@ -7,6 +7,7 @@ import type {
   NotebookEntry,
   NoteTitleEntry,
   SearchResult,
+  TrashContents,
   VaultState,
   VaultStats,
   ImportResult,
@@ -46,6 +47,10 @@ export async function getNotebooks(): Promise<NotebookEntry[]> {
   return invoke("get_notebooks");
 }
 
+export async function countRootNotes(): Promise<number> {
+  return invoke("count_root_notes");
+}
+
 export async function createNotebook(
   parentRelative: string | null,
   name: string,
@@ -96,8 +101,8 @@ export async function createNote(
   return invoke("create_note", { notebookRelative, title });
 }
 
-export async function createDailyNote(): Promise<NoteEntry> {
-  return invoke("create_daily_note");
+export async function createDailyNote(date?: string): Promise<NoteEntry> {
+  return invoke("create_daily_note", { date: date ?? null });
 }
 
 export async function renameNote(
@@ -141,7 +146,7 @@ export async function reindex(): Promise<void> {
   return invoke("reindex");
 }
 
-export async function getTrash(): Promise<NoteEntry[]> {
+export async function getTrash(): Promise<TrashContents> {
   return invoke("get_trash");
 }
 
@@ -152,6 +157,10 @@ export async function restoreNote(
   return invoke("restore_note", { trashPath, destNotebook });
 }
 
+export async function restoreNotebook(trashPath: string): Promise<string> {
+  return invoke("restore_notebook", { trashPath });
+}
+
 export async function permanentDelete(path: string): Promise<void> {
   return invoke("permanent_delete", { path });
 }
@@ -258,6 +267,10 @@ export async function openFile(path: string): Promise<void> {
   return invoke("open_file", { path });
 }
 
+export async function openUrl(url: string): Promise<void> {
+  return invoke("open_url", { url });
+}
+
 export async function copyFileTo(
   source: string,
   destination: string,

src/lib/components/AppLayout.svelte

@@ -33,14 +33,17 @@
 		quickAccessPaths,
 		tags,
 		notes,
+		viewMode,
+		activeTag,
 		updateAvailable as globalUpdateAvailable,
-		settingsTab
+		settingsTab,
+		navHistory
 	} from '$lib/stores/app';
 
 	const appWindow = getCurrentWindow();
 	const isMac = navigator.platform.startsWith('Mac');
 	const isMobile = /android|ios/i.test(navigator.userAgent);
-	import { loadVaultState, saveVaultState, readNote, createDailyNote, createBackup, getPendingOpenFile, addQuickAccess, removeQuickAccess, getQuickAccess } from '$lib/api';
+	import { loadVaultState, saveVaultState, readNote, createDailyNote, createBackup, getPendingOpenFile, addQuickAccess, removeQuickAccess, getQuickAccess, setTheme } from '$lib/api';
 	import { debounce } from '$lib/utils/debounce';
 	import { openNoteWindow } from '$lib/utils/window';
 	import { get } from 'svelte/store';
@@ -57,9 +60,7 @@
 	let isQuickAccess = $derived(noteRelativePath ? $quickAccessPaths.includes(noteRelativePath) : false);
 	let backupInterval: ReturnType<typeof setInterval> | null = null;
 
-	let navigatingFromHistory = false;
-	let noteHistory: string[] = [];
-	let noteHistoryIndex = -1;
+
 
 	function parseFrequencyMs(freq: string): number {
 		switch (freq) {
@@ -90,32 +91,19 @@
 	// Track note navigation in history stack
 	$effect(() => {
 		const path = $activeNotePath;
-		if (navigatingFromHistory) {
-			navigatingFromHistory = false;
-			return;
-		}
-		if (path) {
-			// Trim forward history and push
-			noteHistory = [...noteHistory.slice(0, noteHistoryIndex + 1), path];
-			noteHistoryIndex = noteHistory.length - 1;
-		}
+		if (path) navHistory.push(path);
 	});
 
 	function navigateHistory(direction: -1 | 1) {
-		const newIndex = noteHistoryIndex + direction;
-		if (newIndex < 0 || newIndex >= noteHistory.length) return;
-		const path = noteHistory[newIndex];
-		noteHistoryIndex = newIndex;
-		navigatingFromHistory = true;
+		const path = navHistory.go(direction);
+		if (!path) return;
 		readNote(path).then((content) => {
 			editor?.flushSave();
 			$activeNote = content;
 			$activeNotePath = path;
 			$editorDirty = false;
 			editor?.loadNote(path, content.content);
-		}).catch(() => {
-			// Note may have been deleted, ignore
-		});
+		}).catch(() => {});
 	}
 
 	async function handleOpenFile(filePath: string) {
@@ -183,7 +171,8 @@
 			$activeNotePath = entry.path;
 			$editorDirty = false;
 			editor?.loadNote(entry.path, content.content);
-			noteList?.refresh();
+			$viewMode = 'daily';
+			noteList?.refresh(true);
 			sidebar?.refresh();
 			if (isMobile) $mobileView = 'editor';
 		} catch (e) {
@@ -250,6 +239,7 @@
 
 	function handleKeydown(e: KeyboardEvent) {
 		const mod = e.ctrlKey || e.metaKey;
+		const code = e.code;
 		if (e.altKey && e.key === 'ArrowLeft') {
 			e.preventDefault();
 			navigateHistory(-1);
@@ -260,19 +250,25 @@
 			navigateHistory(1);
 			return;
 		}
-		if (mod && !e.shiftKey && e.key === 'n') {
+		if (mod && !e.shiftKey && code === 'KeyN') {
 			e.preventDefault();
 			createAndFocusNote();
+			return;
 		}
-		if (mod && e.shiftKey && e.key === 'N') {
+		if (mod && e.shiftKey && code === 'KeyN') {
 			e.preventDefault();
+			const isDark = $theme === 'dark' || ($theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+			const next = isDark ? 'light' : 'dark';
+			$theme = next;
+			setTheme(next);
+			return;
 		}
-		if (mod && e.shiftKey && e.key === 'F') {
+		if (mod && e.shiftKey && code === 'KeyF') {
 			e.preventDefault();
 			$showSearch = true;
 			return;
 		}
-		if (mod && !e.shiftKey && e.key === 'f') {
+		if (mod && !e.shiftKey && code === 'KeyF') {
 			e.preventDefault();
 			if ($activeNotePath) {
 				editor?.openNoteSearch();
@@ -281,28 +277,50 @@
 			}
 			return;
 		}
-		if (mod && e.key === 'p') {
+		if (mod && !e.shiftKey && code === 'KeyP') {
 			e.preventDefault();
 			$showCommandPalette = true;
+			return;
 		}
-		if (mod && e.key === 's') {
+		if (mod && !e.shiftKey && code === 'KeyS') {
 			e.preventDefault();
 			editor?.forceSave();
+			return;
 		}
-		if (mod && e.key === 'k' && !e.shiftKey && $activeNotePath && !$sourceMode) {
+		if (mod && code === 'KeyK' && !e.shiftKey && $activeNotePath && !$sourceMode) {
 			e.preventDefault();
 			editor?.addLinkFromToolbar();
 		}
-		if (mod && e.shiftKey && e.key === 'M') {
+		if (mod && e.shiftKey && code === 'KeyM') {
 			e.preventDefault();
 			$sourceMode = !$sourceMode;
 		}
-		if (mod && e.shiftKey && e.key === 'W') {
+		if (mod && e.shiftKey && code === 'KeyW') {
 			e.preventDefault();
 			if ($activeNotePath && $activeNote) {
 				openNoteWindow($activeNotePath, $activeNote.meta.title);
 			}
 		}
+		if (mod && e.key === '\\') {
+			e.preventDefault();
+			$sidebarCollapsed = !$sidebarCollapsed;
+			return;
+		}
+		if (mod && e.shiftKey && code === 'KeyE') {
+			e.preventDefault();
+			$focusMode = !$focusMode;
+			return;
+		}
+		if (mod && e.shiftKey && code === 'KeyR') {
+			e.preventDefault();
+			$readOnly = !$readOnly;
+			return;
+		}
+		if (e.key === 'F11') {
+			e.preventDefault();
+			appWindow.isFullscreen().then(fs => appWindow.setFullscreen(!fs));
+			return;
+		}
 		if (e.key === 'Escape') {
 			if ($showSettings) $showSettings = false;
 			else if ($showInfo) $showInfo = false;
@@ -402,9 +420,11 @@
 				debouncedRefresh();
 			});
 		} else {
-			unlistenFileChange = await listen<FileEvent>('file-changed', async () => {
-				await sidebar?.refresh();
-				await noteList?.refresh(true);
+			const debouncedDesktopRefresh = debounce(async () => {
+				await Promise.all([sidebar?.refresh(), noteList?.refresh(true)]);
+			}, 300);
+			unlistenFileChange = await listen<FileEvent>('file-changed', () => {
+				debouncedDesktopRefresh();
 			});
 		}
 
@@ -460,7 +480,7 @@
 					{#if $mobileView === 'sidebar'}
 						HelixNotes
 					{:else}
-						{$activeNotebook?.name || 'All Notes'}
+						{#if $viewMode === 'notebook'}{$activeNotebook?.name ?? 'Notebook'}{:else if $viewMode === 'tag'}#{$activeTag}{:else if $viewMode === 'quickaccess'}Quick Access{:else if $viewMode === 'daily'}Daily Notes{:else if $viewMode === 'trash'}Trash{:else}All Notes{/if}
 					{/if}
 				</span>
 				{#if $globalUpdateAvailable && $mobileView === 'sidebar'}
@@ -564,7 +584,7 @@
 				<Sidebar bind:this={sidebar} onViewChanged={handleViewChanged} />
 			</div>
 			<div class="mobile-panel" class:active={$mobileView === 'notelist'}>
-				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} />
+				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => editor?.focusTitle()} />
 				<button class="mobile-fab" onclick={createAndFocusNote} title="New Note">
 					<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round">
 						<path d="M12 5v14M5 12h14" />
@@ -629,7 +649,7 @@
 				{/if}
 
 				<div class="notelist-panel" style="width: {$notelistWidth}px">
-					<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} />
+					<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => editor?.focusTitle()} />
 				</div>
 
 				<ResizeHandle onResize={handleNotelistResize} />

src/lib/components/InfoPanel.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { showInfo, appConfig } from '$lib/stores/app';
 	import { getVaultStats } from '$lib/api';
-	import { openUrl } from '@tauri-apps/plugin-opener';
+	import { openUrl } from '$lib/api';
 	import { getVersion } from '@tauri-apps/api/app';
 	import type { VaultStats } from '$lib/types';
 
@@ -116,22 +116,37 @@
 					</div>
 				{:else}
 					<div class="shortcuts-section">
-						<h4 class="shortcuts-group-title">Keyboard Shortcuts</h4>
+						<h4 class="shortcuts-group-title">General</h4>
 						<div class="shortcut-row"><span class="shortcut-desc">New note</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>N</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Save</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>S</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Quick open</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>P</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Find in note</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>F</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Search vault</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>F</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Save</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>S</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Open note in new window</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>W</kbd></span></div>
+
+						<h4 class="shortcuts-group-title">Interface</h4>
+						<div class="shortcut-row"><span class="shortcut-desc">Toggle sidebar</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>\</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Toggle dark / light theme</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>N</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Toggle focus mode</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>E</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Toggle read-only</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>R</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Toggle source / WYSIWYG</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>M</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Toggle fullscreen</span><span class="shortcut-keys"><kbd>F11</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Close panel / exit focus</span><span class="shortcut-keys"><kbd>Esc</kbd></span></div>
+
+						<h4 class="shortcuts-group-title">Navigation</h4>
+						<div class="shortcut-row"><span class="shortcut-desc">Go back</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>←</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Go forward</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>→</kbd></span></div>
+
+						<h4 class="shortcuts-group-title">Formatting</h4>
 						<div class="shortcut-row"><span class="shortcut-desc">Bold</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>B</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Italic</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>I</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Underline</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>U</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Strikethrough</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>X</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Code</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>E</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Link</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>K</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Undo</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Z</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Redo</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Go back</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>←</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Go forward</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>→</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Toggle source mode</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>M</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Open note in new window</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>W</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Exit focus mode</span><span class="shortcut-keys"><kbd>Esc</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Move line up / down</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>↑↓</kbd></span></div>
 
 						<h4 class="shortcuts-group-title">Editor Commands</h4>
 						<div class="shortcut-row"><span class="shortcut-desc">Slash commands</span><span class="shortcut-keys"><kbd>/</kbd></span></div>

src/lib/components/NoteList.svelte

@@ -24,26 +24,92 @@
 		saveNote,
 		getTrash,
 		restoreNote,
+		restoreNotebook,
 		permanentDelete,
 		getQuickAccess,
 		addQuickAccess,
 		removeQuickAccess,
 		reorderQuickAccess,
 		moveNote,
-		getAllTags
+		getAllTags,
+		createDailyNote
 	} from '$lib/api';
 	import { formatRelativeTime } from '$lib/utils/time';
 	import { openNoteWindow } from '$lib/utils/window';
-	import type { NoteEntry, SortMode } from '$lib/types';
+	import type { NoteEntry, TrashNotebookEntry, SortMode } from '$lib/types';
 
-	let { onNoteSelected = (_path: string, _content: string) => {}, onNoteMoved = () => {}, onBeforeNoteSwitch = () => {} }: {
+	let { onNoteSelected = (_path: string, _content: string) => {}, onNoteMoved = () => {}, onBeforeNoteSwitch = () => {}, onNoteCreated = () => {} }: {
 		onNoteSelected?: (path: string, content: string) => void;
 		onNoteMoved?: () => void;
 		onBeforeNoteSwitch?: () => void;
+		onNoteCreated?: () => void;
 	} = $props();
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
 	const isMobile = /android|ios/i.test(navigator.userAgent);
+	const isAndroid = /android/i.test(navigator.userAgent);
+	let multiSelectMode = $state(false);
+	let trashNotebooks = $state<TrashNotebookEntry[]>([]);
+	let trashBusy = $state<string | null>(null);
+
+	// Calendar state for daily notes view
+	let calMonth = $state(new Date().getMonth());
+	let calYear = $state(new Date().getFullYear());
+	let dailyDates = $state<Set<string>>(new Set());
+
+	const calMonthNames = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+	const calDayNames = ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'];
+
+	function calDays(): Array<{ day: number; date: string; current: boolean }> {
+		const first = new Date(calYear, calMonth, 1);
+		const lastDay = new Date(calYear, calMonth + 1, 0).getDate();
+		// Monday=0 offset
+		let startDow = first.getDay() - 1;
+		if (startDow < 0) startDow = 6;
+		const cells: Array<{ day: number; date: string; current: boolean }> = [];
+		for (let i = 0; i < startDow; i++) cells.push({ day: 0, date: '', current: false });
+		for (let d = 1; d <= lastDay; d++) {
+			const mm = String(calMonth + 1).padStart(2, '0');
+			const dd = String(d).padStart(2, '0');
+			const date = `${calYear}-${mm}-${dd}`;
+			const now = new Date();
+			const current = d === now.getDate() && calMonth === now.getMonth() && calYear === now.getFullYear();
+			cells.push({ day: d, date, current });
+		}
+		return cells;
+	}
+
+	function calPrev() {
+		if (calMonth === 0) { calMonth = 11; calYear--; }
+		else calMonth--;
+	}
+	function calNext() {
+		if (calMonth === 11) { calMonth = 0; calYear++; }
+		else calMonth++;
+	}
+	function calToday() {
+		const now = new Date();
+		calMonth = now.getMonth();
+		calYear = now.getFullYear();
+	}
+
+	async function handleDayClick(date: string) {
+		try {
+			const entry = await createDailyNote(date);
+			const content = await readNote(entry.path);
+			onBeforeNoteSwitch();
+			$activeNote = content;
+			$activeNotePath = entry.path;
+			onNoteSelected(entry.path, content.content);
+			if (!dailyDates.has(date)) {
+				dailyDates = new Set([...dailyDates, date]);
+			}
+			noteCache.clear();
+			await refresh();
+		} catch (e) {
+			console.error('Failed to open daily note:', e);
+		}
+	}
 
 	/** Derive tags from current $notes store (avoids re-scanning files on mobile) */
 	function deriveTagsFromNotes() {
@@ -154,6 +220,7 @@
 		selectedPaths = new Set();
 		lastClickedPath = null;
 		batchMovePicker = false;
+		multiSelectMode = false;
 	}
 
 	// Clear selection and reset scroll when view/notebook changes
@@ -164,6 +231,15 @@
 		if (listContainer) listContainer.scrollTop = 0;
 	});
 
+	// Invalidate quickaccess cache when starred notes change (e.g. from Editor star toggle)
+	$effect(() => {
+		$quickAccessPaths;
+		noteCache.delete('quickaccess');
+		if ($viewMode === 'quickaccess') {
+			refresh();
+		}
+	});
+
 	// Track container height via ResizeObserver
 	$effect(() => {
 		if (!listContainer) return;
@@ -202,6 +278,7 @@
 		if ($viewMode === 'notebook') return $activeNotebook?.name ?? 'Notebook';
 		if ($viewMode === 'tag') return `#${$activeTag}`;
 		if ($viewMode === 'quickaccess') return 'Quick Access';
+		if ($viewMode === 'daily') return 'Daily Notes';
 		if ($viewMode === 'trash') return 'Trash';
 		return 'Notes';
 	});
@@ -211,6 +288,7 @@
 
 	function cacheKey(): string {
 		if ($viewMode === 'trash') return 'trash';
+		if ($viewMode === 'daily') return 'daily';
 		if ($viewMode === 'quickaccess') return 'quickaccess';
 		if ($viewMode === 'tag' && $activeTag) return `tag:${$activeTag}`;
 		if ($viewMode === 'notebook' && $activeNotebook) return `nb:${$activeNotebook.path}`;
@@ -231,7 +309,24 @@
 
 		try {
 			if ($viewMode === 'trash') {
-				$notes = await getTrash();
+				const trash = await getTrash();
+				$notes = trash.notes;
+				trashNotebooks = trash.notebooks;
+			} else if ($viewMode === 'daily') {
+				const vault = $appConfig?.active_vault;
+				if (vault) {
+					$notes = await getNotes(`${vault}/Daily`);
+					// Build set of dates from filenames (YYYY-MM-DD.md)
+					const dates = new Set<string>();
+					for (const n of $notes) {
+						const fname = n.path.split('/').pop() ?? '';
+						const m = fname.match(/^(\d{4}-\d{2}-\d{2})\.md$/);
+						if (m) dates.add(m[1]);
+					}
+					dailyDates = dates;
+				} else {
+					$notes = [];
+				}
 			} else if ($viewMode === 'quickaccess') {
 				$notes = await getQuickAccess();
 			} else if ($viewMode === 'tag' && $activeTag) {
@@ -270,12 +365,21 @@
 	}
 
 	export async function handleCreateNote() {
+		if ($viewMode === 'daily') {
+			const today = new Date();
+			const date = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
+			await handleDayClick(date);
+			calMonth = today.getMonth();
+			calYear = today.getFullYear();
+			return;
+		}
 		const nbRelative = $viewMode === 'notebook' ? $activeNotebook?.relative_path ?? null : null;
 		try {
 			const entry = await createNote(nbRelative, 'Untitled');
 			noteCache.clear();
 			await refresh();
 			await selectNote(entry);
+			onNoteCreated();
 		} catch (e) {
 			console.error('Failed to create note:', e);
 		}
@@ -348,6 +452,32 @@
 		}
 	}
 
+	async function handleRestoreNotebook(nb: TrashNotebookEntry) {
+		trashBusy = nb.path;
+		try {
+			await restoreNotebook(nb.path);
+			noteCache.clear();
+			await refresh();
+		} catch (e) {
+			console.error('Failed to restore notebook:', e);
+		} finally {
+			trashBusy = null;
+		}
+	}
+
+	async function handleDeleteNotebook(nb: TrashNotebookEntry) {
+		trashBusy = nb.path;
+		try {
+			await permanentDelete(nb.path);
+			noteCache.clear();
+			trashNotebooks = trashNotebooks.filter(n => n.path !== nb.path);
+		} catch (e) {
+			console.error('Failed to delete notebook permanently:', e);
+		} finally {
+			trashBusy = null;
+		}
+	}
+
 	async function handleTogglePin(note: NoteEntry) {
 		contextMenu = null;
 		try {
@@ -556,8 +686,8 @@
 			e.preventDefault();
 			return;
 		}
-		// Mobile: if in selection mode, tap toggles selection
-		if (isMobile && selectedPaths.size > 0) {
+		// Mobile: if in selection mode (or Android multi-select mode), tap toggles selection
+		if (isMobile && (selectedPaths.size > 0 || multiSelectMode)) {
 			const next = new Set(selectedPaths);
 			if (next.has(note.path)) {
 				next.delete(note.path);
@@ -693,6 +823,13 @@
 	<div class="list-header">
 		<span class="list-title">{viewTitle}</span>
 		<div class="list-actions">
+			{#if isAndroid}
+				<button class="icon-btn" class:active-toggle={multiSelectMode} onclick={() => { multiSelectMode = !multiSelectMode; if (!multiSelectMode) clearSelection(); }} title="Multi-select">
+					<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+						<rect x="3" y="3" width="7" height="7" rx="1" /><rect x="3" y="14" width="7" height="7" rx="1" />{#if multiSelectMode}<polyline points="6 6.5 7 7.5 9 5.5" stroke-width="2" /><polyline points="6 17.5 7 18.5 9 16.5" stroke-width="2" />{/if}<line x1="14" y1="6.5" x2="21" y2="6.5" /><line x1="14" y1="17.5" x2="21" y2="17.5" />
+					</svg>
+				</button>
+			{/if}
 			<button class="icon-btn" onclick={openSortMenu} title="Sort: {$sortMode}">
 				<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 					<line x1="4" y1="6" x2="11" y2="6" /><line x1="4" y1="12" x2="15" y2="12" /><line x1="4" y1="18" x2="20" y2="18" />
@@ -717,6 +854,7 @@
 					<button class="selection-action danger" onclick={handleBatchPermanentDelete}>Delete</button>
 				{:else}
 					<button class="selection-action" onclick={() => { batchMovePicker = true; }}>Move</button>
+					<button class="selection-action" onclick={() => openBatchTagEdit()}>Tag</button>
 					<button class="selection-action danger" onclick={handleBatchDelete}>Delete</button>
 				{/if}
 				<button class="selection-close" onclick={clearSelection} title="Clear selection">
@@ -755,8 +893,86 @@
 		</div>
 	{/if}
 
+	{#if batchTagEdit && !contextMenu}
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<div class="batch-move-overlay" onclick={() => batchTagEdit = false}>
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+			<div class="batch-move-picker" onclick={(e) => e.stopPropagation()}>
+				<div class="batch-move-header">
+					<span>Tags for {selectedPaths.size} notes</span>
+					<button class="selection-close" onclick={() => batchTagEdit = false}>
+						<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+					</button>
+				</div>
+				<div class="tag-edit-section">
+					<div class="tag-edit-input-row">
+						<input
+							type="text"
+							class="tag-edit-input"
+							placeholder="Add tag to all..."
+							bind:value={tagEditValue}
+							onkeydown={(e) => {
+								if (e.key === 'Enter') { e.preventDefault(); addTagToBatch(tagEditValue); }
+								if (e.key === 'Escape') { e.preventDefault(); batchTagEdit = false; }
+							}}
+							autofocus
+						/>
+					</div>
+					{#if tagEditTags.length > 0}
+						<div class="tag-edit-list">
+							{#each tagEditTags as tag}
+								<div class="tag-edit-item">
+									<span class="tag-edit-name">#{tag}</span>
+									<button class="tag-edit-remove" onclick={() => removeTagFromBatch(tag)} title="Remove from all">
+										<svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+									</button>
+								</div>
+							{/each}
+						</div>
+					{:else}
+						<div class="context-empty">No common tags</div>
+					{/if}
+				</div>
+			</div>
+		</div>
+	{/if}
+
 	<div class="list-content" bind:this={listContainer} onscroll={onListScroll}>
-		{#if $sortedNotes.length === 0}
+		{#if $viewMode === 'daily'}
+			<div class="cal">
+				<div class="cal-nav">
+					<button class="cal-nav-btn" onclick={calPrev} title="Previous month">
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="15 18 9 12 15 6"/></svg>
+					</button>
+					<button class="cal-title" onclick={calToday}>{calMonthNames[calMonth]} {calYear}</button>
+					<button class="cal-nav-btn" onclick={calNext} title="Next month">
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"/></svg>
+					</button>
+				</div>
+				<div class="cal-grid">
+					{#each calDayNames as name}
+						<div class="cal-head">{name}</div>
+					{/each}
+					{#each calDays() as cell}
+						{#if cell.day === 0}
+							<div class="cal-cell empty"></div>
+						{:else}
+							<button
+								class="cal-cell"
+								class:today={cell.current}
+								class:has-note={dailyDates.has(cell.date)}
+								class:active={$activeNotePath?.endsWith(`${cell.date}.md`) ?? false}
+								onclick={() => handleDayClick(cell.date)}
+							>
+								{cell.day}
+							</button>
+						{/if}
+					{/each}
+				</div>
+			</div>
+		{/if}
+
+		{#if $sortedNotes.length === 0 && $viewMode !== 'daily' && (!($viewMode === 'trash') || trashNotebooks.length === 0)}
 			<div class="empty-state">
 				{#if $viewMode === 'trash'}
 					<p>Trash is empty</p>
@@ -767,6 +983,37 @@
 			</div>
 		{/if}
 
+		{#if $viewMode === 'trash' && trashNotebooks.length > 0}
+			{#each trashNotebooks as nb (nb.path)}
+				<div class="note-item trash-notebook" class:busy={trashBusy === nb.path}>
+					<div class="note-title">
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="flex-shrink:0;opacity:0.6">
+							<path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z"/>
+						</svg>
+						{nb.name}
+					</div>
+					{#if trashBusy === nb.path}
+						<div class="note-preview trash-busy">
+							<svg class="spinner" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><path d="M12 2a10 10 0 0 1 10 10"/></svg>
+							Working...
+						</div>
+					{:else}
+						<div class="note-preview">{nb.note_count} {nb.note_count === 1 ? 'note' : 'notes'}</div>
+						<div class="trash-notebook-actions">
+							<button class="trash-nb-btn restore" onclick={() => handleRestoreNotebook(nb)} title="Restore notebook">
+								<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="1 4 1 10 7 10"/><path d="M3.51 15a9 9 0 105.64-11.36L1 10"/></svg>
+								Restore
+							</button>
+							<button class="trash-nb-btn delete" onclick={() => handleDeleteNotebook(nb)} title="Delete permanently">
+								<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-1 14H6L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/><path d="M9 6V4h6v2"/></svg>
+								Delete
+							</button>
+						</div>
+					{/if}
+				</div>
+			{/each}
+		{/if}
+
 		<div style="height: {topPad}px"></div>
 		{#each visibleNotes as note, i (note.path)}
 			{@const noteIndex = startIndex + i}
@@ -793,10 +1040,10 @@
 					class:qa-drag-above={$viewMode === 'quickaccess' && qaDragOver === noteIndex && qaDragFrom !== null && qaDragHalf === 'top'}
 					class:qa-drag-below={$viewMode === 'quickaccess' && qaDragOver === noteIndex && qaDragFrom !== null && qaDragHalf === 'bottom'}
 					onclick={(e) => handleNoteClick(e, note)}
-					ontouchstart={(e) => { if (isMobile) handleTouchStart(e, note); }}
-					ontouchmove={(e) => { if (isMobile) handleTouchMove(e); }}
-					ontouchend={() => { if (isMobile) handleTouchEnd(); }}
-					ontouchcancel={() => { if (isMobile) handleTouchEnd(); }}
+					ontouchstart={(e) => { if (isMobile && !isAndroid) handleTouchStart(e, note); }}
+					ontouchmove={(e) => { if (isMobile && !isAndroid) handleTouchMove(e); }}
+					ontouchend={() => { if (isMobile && !isAndroid) handleTouchEnd(); }}
+					ontouchcancel={() => { if (isMobile && !isAndroid) handleTouchEnd(); }}
 					oncontextmenu={(e) => {
 						e.preventDefault();
 						const pos = clampMenu(e.clientX, e.clientY);
@@ -846,13 +1093,6 @@
 					}}
 					ondragend={() => { qaDragFrom = null; qaDragOver = null; }}
 				>
-					{#if isMobile && selectedPaths.size > 0}
-						<div class="mobile-select-check" class:checked={selectedPaths.has(note.path)}>
-							{#if selectedPaths.has(note.path)}
-								<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"><polyline points="20 6 9 17 4 12"/></svg>
-							{/if}
-						</div>
-					{/if}
 					{#if compact}
 						<div class="note-compact-row" title={getNotebookPath(note) ? `${getNotebookPath(note)}/${note.meta.title}` : note.meta.title}>
 							<span class="note-title">
@@ -1172,12 +1412,30 @@
 		color: var(--text-primary);
 	}
 
+	.icon-btn.active-toggle {
+		color: var(--accent);
+		background: color-mix(in srgb, var(--accent) 15%, transparent);
+	}
+
 	.list-content {
 		flex: 1;
 		overflow-y: auto;
 		padding: 4px;
 	}
 
+	.list-content::-webkit-scrollbar {
+		width: 8px;
+	}
+
+	.list-content::-webkit-scrollbar-thumb {
+		background: var(--text-tertiary);
+		border-radius: 4px;
+	}
+
+	.list-content::-webkit-scrollbar-thumb:hover {
+		background: var(--text-secondary);
+	}
+
 	.note-item {
 		display: block;
 		width: 100%;
@@ -1721,6 +1979,9 @@
 
 	.note-list.mobile .selection-bar {
 		padding: 8px 16px;
+		border-radius: 12px;
+		margin: 4px 8px;
+		border-bottom: none;
 	}
 
 	.note-list.mobile .selection-count {
@@ -1731,6 +1992,7 @@
 		padding: 6px 14px;
 		font-size: 13px;
 		min-height: 36px;
+		border-radius: 10px;
 	}
 
 	.note-list.mobile .context-menu {
@@ -1814,4 +2076,165 @@
 	.mobile-create-btn:active {
 		opacity: 0.8;
 	}
+
+	.trash-notebook .note-title {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+	}
+
+	.trash-notebook-actions {
+		display: flex;
+		gap: 6px;
+		margin-top: 6px;
+	}
+
+	.trash-nb-btn {
+		display: inline-flex;
+		align-items: center;
+		gap: 4px;
+		padding: 3px 8px;
+		border: none;
+		border-radius: 4px;
+		font-size: 0.75rem;
+		cursor: pointer;
+		background: var(--bg-hover);
+		color: var(--text-secondary);
+	}
+
+	.trash-nb-btn:hover {
+		background: var(--bg-active);
+	}
+
+	.trash-nb-btn.delete:hover {
+		background: color-mix(in srgb, #ef4444 15%, transparent);
+		color: #ef4444;
+	}
+
+	.trash-notebook.busy {
+		opacity: 0.6;
+		pointer-events: none;
+	}
+
+	.trash-busy {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+	}
+
+	.spinner {
+		animation: spin 0.8s linear infinite;
+	}
+
+	@keyframes spin {
+		to { transform: rotate(360deg); }
+	}
+
+	/* Calendar */
+	.cal {
+		padding: 8px 10px;
+		border-bottom: 1px solid var(--border);
+	}
+
+	.cal-nav {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		margin-bottom: 6px;
+	}
+
+	.cal-nav-btn {
+		background: none;
+		border: none;
+		cursor: pointer;
+		color: var(--text-secondary);
+		padding: 4px;
+		border-radius: 4px;
+		display: flex;
+		align-items: center;
+	}
+
+	.cal-nav-btn:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
+	.cal-title {
+		font-size: 0.8rem;
+		font-weight: 600;
+		color: var(--text-primary);
+		background: none;
+		border: none;
+		cursor: pointer;
+		padding: 2px 8px;
+		border-radius: 4px;
+	}
+
+	.cal-title:hover {
+		background: var(--bg-hover);
+	}
+
+	.cal-grid {
+		display: grid;
+		grid-template-columns: repeat(7, 1fr);
+		gap: 4px 2px;
+		padding: 0 2px;
+	}
+
+	.cal-head {
+		font-size: 0.65rem;
+		color: var(--text-secondary);
+		text-align: center;
+		padding: 2px 0;
+		font-weight: 500;
+	}
+
+	.cal-cell {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		font-size: 0.72rem;
+		width: 28px;
+		height: 28px;
+		border-radius: 50%;
+		border: none;
+		background: none;
+		color: var(--text-secondary);
+		cursor: pointer;
+		padding: 0;
+		margin: 0 auto;
+	}
+
+	.cal-cell.empty {
+		cursor: default;
+	}
+
+	.cal-cell:not(.empty):hover {
+		background: var(--bg-hover);
+	}
+
+	.cal-cell.today {
+		color: var(--accent);
+		font-weight: 700;
+	}
+
+	.cal-cell.has-note {
+		background: color-mix(in srgb, var(--accent) 15%, transparent);
+		color: var(--text-primary);
+		font-weight: 600;
+	}
+
+	.cal-cell.has-note:hover {
+		background: color-mix(in srgb, var(--accent) 25%, transparent);
+	}
+
+	.cal-cell.active {
+		background: var(--accent);
+		color: white;
+		font-weight: 600;
+	}
+
+	.cal-cell.active:hover {
+		background: var(--accent);
+	}
 </style>

src/lib/components/NoteWindow.svelte

@@ -67,11 +67,12 @@
 
 	function handleKeydown(e: KeyboardEvent) {
 		const mod = e.ctrlKey || e.metaKey;
-		if (mod && e.key === 's') {
+		if (mod && !e.shiftKey && e.code === 'KeyS') {
 			e.preventDefault();
 			editor?.forceSave();
+			return;
 		}
-		if (mod && e.shiftKey && e.key === 'M') {
+		if (mod && e.shiftKey && e.code === 'KeyM') {
 			e.preventDefault();
 			$sourceMode = !$sourceMode;
 		}

src/lib/components/SettingsPanel.svelte

@@ -4,7 +4,7 @@
 	import { open as openDialog } from '@tauri-apps/plugin-dialog';
 	import { listen } from '@tauri-apps/api/event';
 	import { getVersion } from '@tauri-apps/api/app';
-	import { openUrl } from '@tauri-apps/plugin-opener';
+	import { openUrl } from '$lib/api';
 	import type { ImportResult, BackupEntry } from '$lib/types';
 
 	const isMobile = /android|ios/i.test(navigator.userAgent);

src/lib/components/Sidebar.svelte

@@ -15,9 +15,10 @@
 		notebookIcons,
 		appConfig,
 		quickAccessPaths,
-		collapsedNotebooks
+		collapsedNotebooks,
+		rootNoteCount
 	} from '$lib/stores/app';
-	import { getNotebooks, getAllTags, createNotebook, deleteNotebook, renameNotebook, moveNotebook, getNotebookIcons, setNotebookIcon, saveAttachment, getQuickAccess, addQuickAccess, removeQuickAccess, emptyTrash, moveNote, readNote, getNotes } from '$lib/api';
+	import { getNotebooks, getAllTags, createNotebook, deleteNotebook, renameNotebook, moveNotebook, getNotebookIcons, setNotebookIcon, saveAttachment, getQuickAccess, addQuickAccess, removeQuickAccess, emptyTrash, moveNote, readNote, getNotes, countRootNotes } from '$lib/api';
 	import { open as openDialog } from '@tauri-apps/plugin-dialog';
 	import { readFile } from '@tauri-apps/plugin-fs';
 	import { convertFileSrc } from '@tauri-apps/api/core';
@@ -49,20 +50,25 @@
 		}
 	}
 
+
 	export async function refresh() {
 		try {
 			if (isMobile) {
 				// On mobile, parallelize and skip getAllTags (derive from $notes instead)
-				const [nbs, icons, qaNotes] = await Promise.all([
+				const [nbs, icons, qaNotes, rootCount] = await Promise.all([
 					getNotebooks(),
 					getNotebookIcons(),
 					getQuickAccess(),
+					countRootNotes(),
 				]);
 				$notebooks = nbs;
 				$notebookIcons = icons;
 				$quickAccessPaths = qaNotes.map(n => n.relative_path);
+				$rootNoteCount = rootCount;
 			} else {
-				$notebooks = await getNotebooks();
+				const [nbs, rootCount] = await Promise.all([getNotebooks(), countRootNotes()]);
+				$notebooks = nbs;
+				$rootNoteCount = rootCount;
 				$tags = await getAllTags();
 				$notebookIcons = await getNotebookIcons();
 				const qaNotes = await getQuickAccess();
@@ -80,6 +86,19 @@
 		onViewChanged();
 	}
 
+	function selectUnfiled() {
+		const vault = $appConfig?.active_vault;
+		if (!vault) return;
+		if ($viewMode === 'notebook' && $activeNotebook?.relative_path === '') {
+			selectAllNotes();
+			return;
+		}
+		$viewMode = 'notebook';
+		$activeNotebook = { name: 'Unfiled Notes', path: vault, relative_path: '', children: [], note_count: $rootNoteCount };
+		$activeTag = null;
+		onViewChanged();
+	}
+
 	function selectNotebook(nb: NotebookEntry) {
 		// Deselect if clicking the already-active notebook
 		if ($viewMode === 'notebook' && $activeNotebook?.path === nb.path) {
@@ -106,6 +125,13 @@
 		onViewChanged();
 	}
 
+	function selectDaily() {
+		$viewMode = 'daily';
+		$activeNotebook = null;
+		$activeTag = null;
+		onViewChanged();
+	}
+
 	function selectTrash() {
 		$viewMode = 'trash';
 		$activeNotebook = null;
@@ -379,6 +405,20 @@
 				<span>Quick Access</span>
 			</button>
 
+			<button
+				class="nav-item"
+				class:active={$viewMode === 'daily'}
+				onclick={selectDaily}
+			>
+				<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+					<rect x="3" y="4" width="18" height="18" rx="2" ry="2" />
+					<line x1="16" y1="2" x2="16" y2="6" />
+					<line x1="8" y1="2" x2="8" y2="6" />
+					<line x1="3" y1="10" x2="21" y2="10" />
+				</svg>
+				<span>Daily Notes</span>
+			</button>
+
 			<button
 				class="nav-item"
 				class:active={$viewMode === 'trash'}
@@ -445,6 +485,20 @@
 			{/if}
 
 			<div class="notebook-list">
+				{#if $rootNoteCount > 0}
+					<button
+						class="notebook-item"
+						class:active={$viewMode === 'notebook' && $activeNotebook?.relative_path === ''}
+						onclick={selectUnfiled}
+					>
+						<span style="width:13px;flex-shrink:0"></span>
+						<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="flex-shrink:0;opacity:0.6">
+							<path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z" />
+							<polyline points="14 2 14 8 20 8" />
+						</svg>
+						<span class="notebook-name">Unfiled Notes <span class="notebook-count">{$rootNoteCount}</span></span>
+					</button>
+				{/if}
 				{#each $notebooks as nb (nb.path)}
 					{@render notebookItem(nb, 0)}
 				{/each}

src/lib/components/TitleBar.svelte

@@ -221,6 +221,7 @@
 		color: var(--text-primary);
 	}
 
+
 	.switch-vault-btn.active {
 		background: color-mix(in srgb, var(--accent) 18%, transparent);
 		color: var(--accent);

src/lib/stores/app.ts

@@ -1,4 +1,4 @@
-import { writable, derived } from "svelte/store";
+import { writable, derived, get } from "svelte/store";
 import type {
   AppConfig,
   NoteEntry,
@@ -31,6 +31,7 @@ export const collapsedNotebooks = writable<string[]>([]);
 
 // Data
 export const notebooks = writable<NotebookEntry[]>([]);
+export const rootNoteCount = writable<number>(0);
 export const notes = writable<NoteEntry[]>([]);
 export const tags = writable<[string, number][]>([]);
 export const activeNote = writable<NoteContent | null>(null);
@@ -105,6 +106,35 @@ export async function checkForUpdateMobile() {
   }
 }
 
+// Note navigation history
+interface NavHistoryState { stack: string[]; index: number; skipping: boolean; }
+function createNavHistory() {
+  const store = writable<NavHistoryState>({ stack: [], index: -1, skipping: false });
+  return {
+    subscribe: store.subscribe,
+    push(path: string) {
+      store.update(s => {
+        if (s.skipping) return { ...s, skipping: false };
+        const trimmed = s.stack.slice(0, s.index + 1);
+        return { stack: [...trimmed, path], index: trimmed.length, skipping: false };
+      });
+    },
+    go(direction: -1 | 1): string | null {
+      let target: string | null = null;
+      store.update(s => {
+        const newIdx = s.index + direction;
+        if (newIdx < 0 || newIdx >= s.stack.length) return s;
+        target = s.stack[newIdx];
+        return { ...s, index: newIdx, skipping: true };
+      });
+      return target;
+    },
+  };
+}
+export const navHistory = createNavHistory();
+export const canGoBack = derived(navHistory, $h => $h.index > 0);
+export const canGoForward = derived(navHistory, $h => $h.index < $h.stack.length - 1);
+
 // Derived
 export const sortedNotes = derived(
   [notes, sortMode, viewMode],

src/lib/types.ts

@@ -14,6 +14,18 @@ export interface NoteEntry {
   preview: string;
 }
 
+export interface TrashNotebookEntry {
+  name: string;
+  path: string;
+  note_count: number;
+  modified: string;
+}
+
+export interface TrashContents {
+  notes: NoteEntry[];
+  notebooks: TrashNotebookEntry[];
+}
+
 export interface NotebookEntry {
   name: string;
   path: string;
@@ -131,4 +143,5 @@ export type ViewMode =
   | "tag"
   | "trash"
   | "search"
-  | "quickaccess";
+  | "quickaccess"
+  | "daily";

src/routes/+layout.svelte

@@ -2,8 +2,7 @@
 	import { onMount } from 'svelte';
 	import '../app.css';
 	import { theme, appConfig, activeNote, activeNotePath, installType, checkForUpdate, checkForUpdateMobile } from '$lib/stores/app';
-	import { openUrl } from '@tauri-apps/plugin-opener';
-	import { openFile, readNote, getInstallType } from '$lib/api';
+	import { openFile, openUrl, readNote, getInstallType } from '$lib/api';
 	import { get } from 'svelte/store';
 
 	let { children } = $props();
@@ -33,6 +32,19 @@
 		return resolved.join('/');
 	}
 
+	const isAndroid = /android/i.test(navigator.userAgent);
+
+	function openLocalFile(path: string) {
+		if (isAndroid) {
+			const bridge = (window as any).Android;
+			if (bridge && typeof bridge.openFile === 'function') {
+				bridge.openFile(path);
+			}
+		} else {
+			openFile(path).catch((err) => console.error('Failed to open file:', err));
+		}
+	}
+
 	function resolveAndHandleLink(href: string) {
 		if (href.startsWith('http://') || href.startsWith('https://') || href.startsWith('mailto:')) {
 			openUrl(href).catch((err) => console.error('Failed to open URL:', err));
@@ -42,6 +54,10 @@
 			const vaultRoot = config?.active_vault;
 			let absPath = decoded;
 			if (!decoded.startsWith('/') && vaultRoot) {
+				// .helixnotes/ paths are always relative to vault root, not the note's directory
+				if (decoded.startsWith('.helixnotes/')) {
+					absPath = normalizePath(`${vaultRoot}/${decoded}`);
+				} else {
 					const notePath = get(activeNotePath);
 					if (notePath) {
 						const noteDir = notePath.substring(0, notePath.lastIndexOf('/'));
@@ -50,6 +66,7 @@
 						absPath = normalizePath(`${vaultRoot}/${decoded}`);
 					}
 				}
+			}
 			// Internal .md note link — navigate within the app
 			if (absPath.endsWith('.md')) {
 				readNote(absPath).then((content) => {
@@ -57,7 +74,7 @@
 					activeNotePath.set(absPath);
 				}).catch((err) => console.error('Failed to navigate to note:', err));
 			} else {
-				openFile(absPath).catch((err) => console.error('Failed to open file:', err));
+				openLocalFile(absPath);
 			}
 		}
 	}
@@ -76,7 +93,17 @@
 	// Intercept all link clicks in capture phase to prevent webview navigation
 	onMount(() => {
 		function handleLinkClick(e: MouseEvent) {
-			const target = (e.target as HTMLElement)?.closest('a');
+			const el = e.target as HTMLElement;
+			// PDF/attachment embeds: check for data-open-file on target or ancestors
+			const fileTarget = el?.closest('[data-open-file]') as HTMLElement | null;
+			if (fileTarget) {
+				e.preventDefault();
+				e.stopPropagation();
+				e.stopImmediatePropagation();
+				openLocalFile(fileTarget.getAttribute('data-open-file')!);
+				return;
+			}
+			const target = el?.closest('a');
 			if (!target) return;
 			const href = target.getAttribute('href');
 			if (!href) return;
@@ -97,10 +124,22 @@
 			touchStartY = e.touches[0]?.clientY ?? 0;
 		}
 		function handleTouchEnd(e: TouchEvent) {
-			const endY = e.changedTouches[0]?.clientY ?? 0;
+			const touch = e.changedTouches[0];
+			if (!touch) return;
+			const endY = touch.clientY;
 			// If the finger moved > 10px, it's a scroll, not a tap
 			if (Math.abs(endY - touchStartY) > 10) return;
-			const target = (e.target as HTMLElement)?.closest('a');
+			// Android WebView may report e.target as the editor root for elements
+			// inside contenteditable="false" blocks; use elementFromPoint instead
+			const el = (document.elementFromPoint(touch.clientX, touch.clientY) ?? e.target) as HTMLElement;
+			// PDF/attachment embeds: check for data-open-file on target or ancestors
+			const fileTarget = el?.closest('[data-open-file]') as HTMLElement | null;
+			if (fileTarget) {
+				e.preventDefault();
+				openLocalFile(fileTarget.getAttribute('data-open-file')!);
+				return;
+			}
+			const target = el?.closest('a');
 			if (!target) return;
 			const href = target.getAttribute('href');
 			if (!href) return;

tsconfig.json

@@ -10,8 +10,8 @@
     "skipLibCheck": true,
     "sourceMap": true,
     "strict": true,
-		"moduleResolution": "bundler"
-	}
+    "moduleResolution": "bundler",
+  },
   // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
   // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
   //