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

- Hide asset folders (_res, _resources, _attachments, _assets, assets) from notebook listing
- Show notebook path in "All Notes" view
- Sub-notebook context menu + smart parent detection for nested notebook creation

README.md

@@ -1,39 +1,75 @@
 # HelixNotes
 
-A local-first markdown note-taking app built with Tauri, SvelteKit, and Rust.
+[![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)]()
 
-Your notes are stored as standard Markdown files on your local filesystem. No cloud, no lock-in.
+A local markdown note-taking app built with Tauri, SvelteKit, and Rust.
 
-## Download
+Your notes are stored as standard Markdown files on your local filesystem.
+No cloud, no lock-in.
 
-| Platform | Download |
-|----------|----------|
-| Linux | [HelixNotes_1.0.1_amd64.AppImage](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.0.1/HelixNotes_1.0.1_amd64.AppImage) |
-| Windows | [HelixNotes_1.0.1_x64-setup.exe](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.0.1/HelixNotes_1.0.1_x64-setup.exe) |
-| macOS | Coming soon |
+## Download (v1.2.7)
 
-See all releases: [codeberg.org/ArkHost/HelixNotes/releases](https://codeberg.org/ArkHost/HelixNotes/releases)
+### Linux
+
+#### Arch / Manjaro (AUR)
+
+```bash
+yay -S helixnotes-appimage-bin
+```
+
+#### Debian / Ubuntu / Mint (APT)
+
+```bash
+curl -fsSL https://repo.arkhost.com/gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/arkhost.gpg && echo "deb [signed-by=/usr/share/keyrings/arkhost.gpg arch=amd64] https://repo.arkhost.com stable main" | sudo tee /etc/apt/sources.list.d/helixnotes.list && sudo apt update && sudo apt install helix-notes
+```
+
+#### AppImage (Arch, Fedora 43+, openSUSE Tumbleweed)
+
+[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.7/HelixNotes_1.2.7_amd64.deb) (Ubuntu 22.04+)
+
+### Windows
+
+[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.7/HelixNotes_1.2.7_x64.dmg) (Intel, runs on Apple Silicon via Rosetta)
+
+### Android
+
+[Download APK](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.7/HelixNotes_1.2.7_android.apk)
+
+---
+
+All releases: [codeberg.org/ArkHost/HelixNotes/releases](https://codeberg.org/ArkHost/HelixNotes/releases)
 
 ## Features
 
-- **Markdown editor** with rich formatting toolbar, slash commands, and source mode
-- **Wiki-links** — link notes with `[[Note Title]]` syntax
-- **Graph view** — visualize connections between your notes
-- **Full-text search** powered by Tantivy
-- **AI writing tools** — improve, summarize, translate, and more (Anthropic / OpenAI)
-- **Version history** — per-note snapshots with diff view
-- **Backups** — automatic zip-based vault backups
-- **PDF preview** — inline rendering of embedded PDFs
-- **Obsidian import** — convert Obsidian wiki-links to standard markdown
-- **Themes** — light/dark mode with customizable accent colors and fonts
-- **Focus mode** — distraction-free writing
-- **Local-first** — everything stays on your machine
+- Markdown editor with toolbar, slash commands, source mode, code highlighting
+- `[[Wiki-links]]` and graph view
+- Full-text search (Tantivy)
+- 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
+- Multi-window, file associations, focus mode, view mode
+- Themes, accent colors, fonts
+- Local files, no cloud
+
+Full documentation: [helixnotes.com/docs](https://helixnotes.com/docs.html)
 
 ## Tech Stack
 
 - **Frontend**: SvelteKit (Svelte 5) + TailwindCSS v4 + TipTap v3
 - **Backend**: Rust (Tauri 2.0) + Tantivy (search) + Notify (file watcher)
-- **Platforms**: Linux (AppImage), Windows, macOS
+- **Platforms**: Linux (AppImage), Windows, macOS, Android
 
 ## Building from Source
 
@@ -57,6 +93,13 @@ pnpm tauri dev
 pnpm tauri build
 ```
 
+## Screenshots
+
+![Editor](https://cdn.helixnotes.com/assets/screenshots/screenshot-1.png)
+![Settings](https://cdn.helixnotes.com/assets/screenshots/screenshot-2.png)
+![Graph View](https://cdn.helixnotes.com/assets/screenshots/screenshot-3.png)
+![AI Actions](https://cdn.helixnotes.com/assets/screenshots/screenshot-4.png)
+
 ## License
 
-[AGPL-3.0](LICENSE)
+[AGPL-3.0](https://codeberg.org/ArkHost/HelixNotes/src/branch/main/LICENSE)

fastlane/metadata/android/en-US/changelogs/10201001.txt

@@ -0,0 +1,3 @@
+- Internal note links ([[wiki-links]] open the linked note)
+- Mobile UI improvements
+- Window state persistence (desktop)

fastlane/metadata/android/en-US/full_description.txt

@@ -0,0 +1,12 @@
+Markdown note-taking app built with Tauri and Rust. Your notes are stored as standard Markdown files on your device.
+
+Features:
+- Markdown editor with toolbar, slash commands, and code highlighting
+- [[Wiki-links]] and graph view
+- Full-text search
+- Outline panel, daily notes, tags
+- Math (KaTeX) and PDF preview
+- AI writing tools (Ollama, Anthropic, OpenAI)
+- Version history with diffs
+- Obsidian import
+- Themes, accent colors, fonts

fastlane/metadata/android/en-US/short_description.txt

@@ -0,0 +1 @@
+Local markdown note-taking app. No cloud, no lock-in.

fastlane/metadata/android/en-US/title.txt

@@ -0,0 +1 @@
+HelixNotes

package.json

@@ -2,7 +2,7 @@
   "name": "helixnotes",
   "private": true,
   "license": "AGPL-3.0-or-later",
-  "version": "1.0.1",
+  "version": "1.2.8",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
@@ -57,7 +57,9 @@
     "@tiptap/extension-underline": "^3.19.0",
     "@tiptap/pm": "^3.19.0",
     "@tiptap/starter-kit": "^3.19.0",
+    "@types/katex": "^0.16.8",
     "@types/markdown-it": "^14.1.2",
+    "katex": "^0.16.28",
     "lowlight": "^3.3.0",
     "markdown-it": "^14.1.0",
     "markdown-it-mark": "^4.0.0",

pnpm-lock.yaml

@@ -89,9 +89,15 @@ importers:
       '@tiptap/starter-kit':
         specifier: ^3.19.0
         version: 3.19.0
+      '@types/katex':
+        specifier: ^0.16.8
+        version: 0.16.8
       '@types/markdown-it':
         specifier: ^14.1.2
         version: 14.1.2
+      katex:
+        specifier: ^0.16.28
+        version: 0.16.28
       lowlight:
         specifier: ^3.3.0
         version: 3.3.0
@@ -936,6 +942,9 @@ packages:
   '@types/hast@3.0.4':
     resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
 
+  '@types/katex@0.16.8':
+    resolution: {integrity: sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg==}
+
   '@types/linkify-it@5.0.0':
     resolution: {integrity: sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==}
 
@@ -972,6 +981,10 @@ packages:
     resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
     engines: {node: '>=6'}
 
+  commander@8.3.0:
+    resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==}
+    engines: {node: '>= 12'}
+
   cookie@0.6.0:
     resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==}
     engines: {node: '>= 0.6'}
@@ -1048,6 +1061,10 @@ packages:
     resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
     hasBin: true
 
+  katex@0.16.28:
+    resolution: {integrity: sha512-YHzO7721WbmAL6Ov1uzN/l5mY5WWWhJBSW+jq4tkfZfsxmo1hu6frS0EOswvjBUnWE6NtjEs48SFn5CQESRLZg==}
+    hasBin: true
+
   kleur@4.1.5:
     resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
     engines: {node: '>=6'}
@@ -1972,6 +1989,8 @@ snapshots:
     dependencies:
       '@types/unist': 3.0.3
 
+  '@types/katex@0.16.8': {}
+
   '@types/linkify-it@5.0.0': {}
 
   '@types/markdown-it@14.1.2':
@@ -1997,6 +2016,8 @@ snapshots:
 
   clsx@2.1.1: {}
 
+  commander@8.3.0: {}
+
   cookie@0.6.0: {}
 
   crelt@1.0.6: {}
@@ -2074,6 +2095,10 @@ snapshots:
 
   jiti@2.6.1: {}
 
+  katex@0.16.28:
+    dependencies:
+      commander: 8.3.0
+
   kleur@4.1.5: {}
 
   lightningcss-android-arm64@1.30.2:

src-tauri/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "helixnotes"
-version = "1.0.1"
-description = "Local-first markdown note-taking app"
+version = "1.2.8"
+description = "Local markdown note-taking app"
 authors = ["HelixNotes"]
 license = "AGPL-3.0-or-later"
 edition = "2021"
@@ -20,14 +20,14 @@ tauri-plugin-log = "2"
 tauri-plugin-dialog = "2"
 tauri-plugin-fs = "2"
 tauri-plugin-opener = "2"
-tauri-plugin-updater = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
 log = "0.4"
 notify = "8"
 walkdir = "2"
-chrono = { version = "0.4", features = ["serde"] }
+chrono = { version = "0.4", features = ["serde", "unstable-locales"] }
+sys-locale = "0.3"
 uuid = { version = "1", features = ["v4"] }
 tantivy = "0.22"
 gray_matter = "0.2"
@@ -35,6 +35,14 @@ tokio = { version = "1", features = ["full"] }
 dirs = "6"
 regex = "1"
 zip = { version = "2", default-features = false, features = ["deflate"] }
-reqwest = { version = "0.12", features = ["json", "stream"] }
+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"] }
+[target.'cfg(not(target_os = "android"))'.dependencies]
+tauri-plugin-updater = "2"
+tauri-plugin-single-instance = "2"
+tauri-plugin-window-state = "2"
+arboard = { version = "3", features = ["image-data", "wayland-data-control"] }
+png = "0.17"
+image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif"] }

src-tauri/capabilities/default.json

@@ -2,7 +2,7 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "HelixNotes default capabilities",
-  "windows": ["main"],
+  "windows": ["main", "note-*"],
   "permissions": [
     "core:default",
     "core:window:default",
@@ -12,6 +12,10 @@
     "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",
     "dialog:allow-open",
     "dialog:allow-save",
@@ -44,7 +48,6 @@
         { "url": "mailto:*" }
       ]
     },
-    "opener:allow-reveal-item-in-dir",
-    "updater:default"
+    "opener:allow-reveal-item-in-dir"
   ]
 }

src-tauri/capabilities/desktop.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "desktop",
+  "description": "Desktop-only capabilities",
+  "platforms": ["linux", "macOS", "windows"],
+  "windows": ["main"],
+  "permissions": [
+    "updater:default",
+    "window-state:default"
+  ]
+}

src-tauri/src/ai.rs

@@ -6,6 +6,7 @@ use crate::types::AiStreamEvent;
 
 const ANTHROPIC_API_URL: &str = "https://api.anthropic.com/v1/messages";
 const OPENAI_API_URL: &str = "https://api.openai.com/v1/chat/completions";
+const OLLAMA_DEFAULT_URL: &str = "http://localhost:11434";
 
 pub fn ai_request(
     app: AppHandle,
@@ -15,6 +16,7 @@ pub fn ai_request(
     system_prompt: String,
     user_message: String,
     request_id: String,
+    base_url: Option<String>,
 ) {
     std::thread::spawn(move || {
         let rt = tokio::runtime::Runtime::new().unwrap();
@@ -23,7 +25,22 @@ pub fn ai_request(
                 "openai" => {
                     stream_openai(
                         &app,
-                        &api_key,
+                        OPENAI_API_URL,
+                        Some(&api_key),
+                        &model,
+                        &system_prompt,
+                        &user_message,
+                        &request_id,
+                    )
+                    .await
+                }
+                "ollama" => {
+                    let url = base_url.as_deref().unwrap_or(OLLAMA_DEFAULT_URL);
+                    let url = format!("{}/v1/chat/completions", url.trim_end_matches('/'));
+                    stream_openai(
+                        &app,
+                        &url,
+                        None,
                         &model,
                         &system_prompt,
                         &user_message,
@@ -188,7 +205,8 @@ async fn stream_anthropic(
 
 async fn stream_openai(
     app: &AppHandle,
-    api_key: &str,
+    url: &str,
+    api_key: Option<&str>,
     model: &str,
     system_prompt: &str,
     user_message: &str,
@@ -224,10 +242,15 @@ async fn stream_openai(
         body["temperature"] = json!(0.7);
     }
 
-    let response = client
-        .post(OPENAI_API_URL)
-        .header("Authorization", format!("Bearer {}", api_key))
-        .header("content-type", "application/json")
+    let mut req = client
+        .post(url)
+        .header("content-type", "application/json");
+
+    if let Some(key) = api_key {
+        req = req.header("Authorization", format!("Bearer {}", key));
+    }
+
+    let response = req
         .json(&body)
         .send()
         .await
@@ -325,9 +348,19 @@ async fn stream_openai(
     Ok(())
 }
 
-pub async fn test_connection(provider: &str, api_key: &str, model: &str) -> Result<String, String> {
+pub async fn test_connection(
+    provider: &str,
+    api_key: &str,
+    model: &str,
+    base_url: Option<&str>,
+) -> Result<String, String> {
     match provider {
-        "openai" => test_openai(api_key, model).await,
+        "openai" => test_openai(OPENAI_API_URL, Some(api_key), model).await,
+        "ollama" => {
+            let url = base_url.unwrap_or(OLLAMA_DEFAULT_URL);
+            let url = format!("{}/v1/chat/completions", url.trim_end_matches('/'));
+            test_openai(&url, None, model).await
+        }
         _ => test_anthropic(api_key, model).await,
     }
 }
@@ -365,19 +398,12 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
     }
 }
 
-async fn test_openai(api_key: &str, model: &str) -> Result<String, String> {
+async fn test_openai(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
     let client = Client::new();
 
-    let is_gpt5 = model.starts_with("gpt-5");
-    let token_key = if is_gpt5 {
-        "max_completion_tokens"
-    } else {
-        "max_tokens"
-    };
-
     let body = json!({
         "model": model,
-        token_key: 10,
+        "max_tokens": 10,
         "messages": [
             {
                 "role": "user",
@@ -386,10 +412,15 @@ async fn test_openai(api_key: &str, model: &str) -> Result<String, String> {
         ]
     });
 
-    let response = client
-        .post(OPENAI_API_URL)
-        .header("Authorization", format!("Bearer {}", api_key))
-        .header("content-type", "application/json")
+    let mut req = client
+        .post(url)
+        .header("content-type", "application/json");
+
+    if let Some(key) = api_key {
+        req = req.header("Authorization", format!("Bearer {}", key));
+    }
+
+    let response = req
         .json(&body)
         .send()
         .await

src-tauri/src/commands.rs

@@ -2,6 +2,7 @@ use crate::search::SearchIndex;
 use crate::state::AppState;
 use crate::types::*;
 use crate::vault::{operations, watcher};
+use std::path::Path;
 use tauri::{AppHandle, Manager, State};
 
 // ── Vault Management ──
@@ -10,9 +11,21 @@ use tauri::{AppHandle, Manager, State};
 pub fn open_vault(app: AppHandle, state: State<'_, AppState>, path: String) -> Result<(), String> {
     operations::ensure_vault_structure(&path)?;
 
-    // Initialize search index
-    let search = SearchIndex::new(&path)?;
-    search.rebuild(&path)?;
+    // Initialize search index — rebuild in background on Android (FUSE is slow)
+    let search = std::sync::Arc::new(SearchIndex::new(&path)?);
+    #[cfg(target_os = "android")]
+    {
+        let search_bg = search.clone();
+        let vault = path.clone();
+        std::thread::spawn(move || {
+            let _ = search_bg.rebuild(&vault);
+            log::info!("Android: search index rebuild complete");
+        });
+    }
+    #[cfg(not(target_os = "android"))]
+    {
+        search.rebuild(&path)?;
+    }
     *state.search_index.lock().map_err(|e| e.to_string())? = Some(search);
 
     // Start file watcher
@@ -44,6 +57,12 @@ pub fn get_app_config(state: State<'_, AppState>) -> Result<AppConfig, String> {
     Ok(config.clone())
 }
 
+#[tauri::command]
+pub fn get_pending_open_file(state: State<'_, AppState>) -> Result<Option<String>, String> {
+    let mut pending = state.pending_open_file.lock().map_err(|e| e.to_string())?;
+    Ok(pending.take())
+}
+
 #[tauri::command]
 pub fn set_theme(state: State<'_, AppState>, theme: String) -> Result<(), String> {
     let mut config = state.config.lock().map_err(|e| e.to_string())?;
@@ -76,6 +95,14 @@ pub fn set_font_family(state: State<'_, AppState>, family: String) -> Result<(),
     Ok(())
 }
 
+#[tauri::command]
+pub fn set_line_height(state: State<'_, AppState>, height: f64) -> Result<(), String> {
+    let mut config = state.config.lock().map_err(|e| e.to_string())?;
+    config.line_height = Some(height);
+    save_app_config(&config)?;
+    Ok(())
+}
+
 // ── Notebooks ──
 
 #[tauri::command]
@@ -85,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>,
@@ -102,10 +136,83 @@ pub fn rename_notebook(path: String, new_name: String) -> Result<String, String>
 }
 
 #[tauri::command]
-pub fn delete_notebook(state: State<'_, AppState>, path: String) -> Result<(), String> {
+pub fn move_notebook(
+    state: State<'_, AppState>,
+    notebook_path: String,
+    dest_parent: 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")?;
-    operations::delete_notebook(vault_path, &path)
+
+    let old_relative = Path::new(&notebook_path)
+        .strip_prefix(vault_path.as_str())
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_default();
+
+    let new_full_path = operations::move_notebook(&notebook_path, &dest_parent)?;
+
+    let new_relative = Path::new(&new_full_path)
+        .strip_prefix(vault_path.as_str())
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_default();
+
+    // Update Quick Access paths for all notes inside the moved notebook
+    if let Ok(mut qa) = operations::load_quick_access(vault_path) {
+        let old_prefix = format!("{}/", old_relative);
+        let mut changed = false;
+        for path in qa.iter_mut() {
+            if path.starts_with(&old_prefix) {
+                *path = format!("{}/{}", new_relative, &path[old_prefix.len()..]);
+                changed = true;
+            }
+        }
+        if changed {
+            let _ = operations::save_quick_access(vault_path, &qa);
+        }
+    }
+
+    // Update notebook icon mappings
+    if let Ok(icons) = operations::load_notebook_icons(vault_path) {
+        let old_prefix = format!("{}/", old_relative);
+        let mut new_icons = std::collections::HashMap::new();
+        let mut changed = false;
+        for (key, value) in &icons {
+            if *key == old_relative {
+                new_icons.insert(new_relative.clone(), value.clone());
+                changed = true;
+            } else if key.starts_with(&old_prefix) {
+                let new_key = format!("{}/{}", new_relative, &key[old_prefix.len()..]);
+                new_icons.insert(new_key, value.clone());
+                changed = true;
+            } else {
+                new_icons.insert(key.clone(), value.clone());
+            }
+        }
+        if changed {
+            let icons_path = operations::helixnotes_dir(vault_path).join("notebook_icons.json");
+            if let Ok(data) = serde_json::to_string_pretty(&new_icons) {
+                let _ = std::fs::write(&icons_path, data);
+            }
+        }
+    }
+
+    // Rebuild search index (paths changed for all contained notes)
+    if let Ok(search_guard) = state.search_index.lock() {
+        if let Some(ref search) = *search_guard {
+            let _ = search.rebuild(vault_path);
+        }
+    }
+
+    Ok(new_full_path)
+}
+
+#[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())?;
+        config.active_vault.as_ref().ok_or("No active vault")?.clone()
+    };
+    operations::delete_notebook(&vault_path, &path)
 }
 
 // ── Notes ──
@@ -150,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(())
 }
 
@@ -174,8 +289,26 @@ pub fn create_note(
 }
 
 #[tauri::command]
-pub fn rename_note(path: String, new_title: String) -> Result<String, String> {
-    operations::rename_note(&path, &new_title)
+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, date.as_deref())?;
+
+    if let Ok(search_guard) = state.search_index.lock() {
+        if let Some(ref search) = *search_guard {
+            let _ = search.index_note(&entry.path);
+        }
+    }
+
+    Ok(entry)
+}
+
+#[tauri::command]
+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]
@@ -195,8 +328,39 @@ pub fn delete_note(state: State<'_, AppState>, path: String) -> Result<(), Strin
 }
 
 #[tauri::command]
-pub fn move_note(note_path: String, dest_notebook: String) -> Result<String, String> {
-    operations::move_note(&note_path, &dest_notebook)
+pub fn move_note(
+    state: State<'_, AppState>,
+    note_path: String,
+    dest_notebook: 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")?;
+
+    // Compute old relative path before move
+    let old_relative = Path::new(&note_path)
+        .strip_prefix(vault_path)
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_default();
+
+    let new_full_path = operations::move_note(&note_path, &dest_notebook)?;
+
+    // Update quick access if the moved note was in it
+    if !old_relative.is_empty() {
+        if let Ok(mut qa) = operations::load_quick_access(vault_path) {
+            if let Some(pos) = qa.iter().position(|p| *p == old_relative) {
+                let new_relative = Path::new(&new_full_path)
+                    .strip_prefix(vault_path)
+                    .map(|p| p.to_string_lossy().to_string())
+                    .unwrap_or_default();
+                if !new_relative.is_empty() {
+                    qa[pos] = new_relative;
+                    let _ = operations::save_quick_access(vault_path, &qa);
+                }
+            }
+        }
+    }
+
+    Ok(new_full_path)
 }
 
 // ── Tags ──
@@ -256,6 +420,163 @@ pub fn get_all_note_titles(state: State<'_, AppState>) -> Result<Vec<NoteTitleEn
     Ok(entries)
 }
 
+// ── Graph ──
+
+#[tauri::command]
+pub fn get_graph_data(state: State<'_, AppState>) -> Result<crate::types::GraphData, String> {
+    use std::collections::{HashMap, HashSet};
+
+    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 vault = std::path::Path::new(vault_path);
+
+    // Pass 1: collect ALL notes as nodes (no title deduplication — every note must appear)
+    let mut graph_nodes = Vec::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();
+
+    for entry in walkdir::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().to_string();
+        if path_str.contains("/.helixnotes/") || path_str.contains("/.trash/")
+            || path_str.contains("/.stversions/") || path_str.contains("/.stfolder") { continue; }
+        if path.extension().and_then(|e| e.to_str()) != Some("md") { continue; }
+        // Skip Syncthing conflict files
+        if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+            if name.contains(".sync-conflict-") { continue; }
+        }
+        // Deduplicate by canonical path (handles symlinks)
+        let canonical = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
+        let canonical_str = canonical.to_string_lossy().to_string();
+        if !seen_paths.insert(canonical_str) { continue; }
+
+        let raw = std::fs::read_to_string(path).unwrap_or_default();
+
+        // Fast title extraction: scan for "title: " line in frontmatter without full YAML parse
+        let title = extract_title_fast(&raw).unwrap_or_else(|| {
+            path.file_stem().unwrap_or_default().to_string_lossy().to_string()
+        });
+
+        let idx = graph_nodes.len();
+        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,
+        });
+        contents.push(raw);
+    }
+
+    // Pass 2: extract edges from wiki-links (inline scan, no regex)
+    // 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();
+        let len = bytes.len();
+        let mut i = 0;
+        while i + 1 < len {
+            if bytes[i] == b'[' && bytes[i + 1] == b'[' {
+                i += 2;
+                let start = i;
+                while i + 1 < len && !(bytes[i] == b']' && bytes[i + 1] == b']') {
+                    i += 1;
+                }
+                if i + 1 < len {
+                    let link_raw = &body[start..i];
+                    // Strip |alias, #heading, ^block
+                    let link = link_raw.split('|').next().unwrap_or(link_raw);
+                    let link = link.split('#').next().unwrap_or(link);
+                    let link = link.split('^').next().unwrap_or(link);
+                    let link = link.trim().to_lowercase();
+
+                    // 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);
+                                }
+                            }
+                        }
+                    }
+                    i += 2;
+                }
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    Ok(crate::types::GraphData { nodes: graph_nodes, edges })
+}
+
+/// Fast title extraction from frontmatter without full YAML parsing.
+/// Scans for `title: ...` line within `---` fences.
+fn extract_title_fast(raw: &str) -> Option<String> {
+    let trimmed = raw.trim_start();
+    if !trimmed.starts_with("---") { return None; }
+    // Find the closing ---
+    let after_open = &trimmed[3..];
+    let end = after_open.find("\n---")?;
+    let frontmatter = &after_open[..end];
+    for line in frontmatter.lines() {
+        let line = line.trim();
+        if line.starts_with("title:") {
+            let val = line[6..].trim();
+            // Strip surrounding quotes
+            if (val.starts_with('"') && val.ends_with('"')) || (val.starts_with('\'') && val.ends_with('\'')) {
+                return Some(val[1..val.len()-1].to_string());
+            }
+            if !val.is_empty() {
+                return Some(val.to_string());
+            }
+        }
+    }
+    None
+}
+
 // ── Search ──
 
 #[tauri::command]
@@ -285,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]
@@ -297,14 +618,29 @@ pub fn restore_note(
     trash_path: String,
     dest_notebook: Option<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")?;
-    operations::restore_note(vault_path, &trash_path, dest_notebook.as_deref())
+    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_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]
@@ -330,6 +666,68 @@ pub fn save_vault_state(state: State<'_, AppState>, vault_state: VaultState) ->
     operations::save_vault_state(vault_path, &vault_state)
 }
 
+// ── Clipboard ──
+
+/// Read image from system clipboard (bypasses WebKitGTK clipboard bug).
+/// Returns PNG bytes as Vec<u8>, or error if no image on clipboard.
+#[cfg(not(target_os = "android"))]
+#[tauri::command]
+pub fn read_clipboard_image() -> Result<Vec<u8>, String> {
+    let mut clipboard =
+        arboard::Clipboard::new().map_err(|e| format!("Clipboard init failed: {}", e))?;
+    let img = clipboard
+        .get_image()
+        .map_err(|_| "No image on clipboard".to_string())?;
+    // Encode RGBA data to PNG
+    let mut buf: Vec<u8> = Vec::new();
+    {
+        let mut encoder =
+            png::Encoder::new(std::io::Cursor::new(&mut buf), img.width as u32, img.height as u32);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        let mut writer = encoder
+            .write_header()
+            .map_err(|e| format!("PNG header failed: {}", e))?;
+        writer
+            .write_image_data(&img.bytes)
+            .map_err(|e| format!("PNG encode failed: {}", e))?;
+    }
+    Ok(buf)
+}
+
+#[cfg(target_os = "android")]
+#[tauri::command]
+pub fn read_clipboard_image() -> Result<Vec<u8>, String> {
+    Err("Clipboard image reading not supported on Android".to_string())
+}
+
+/// Copy an image file to the system clipboard.
+#[cfg(not(target_os = "android"))]
+#[tauri::command]
+pub fn copy_image_to_clipboard(path: String) -> Result<(), String> {
+    let data = std::fs::read(&path).map_err(|e| format!("Failed to read image: {}", e))?;
+    let img = image::load_from_memory(&data)
+        .map_err(|e| format!("Failed to decode image: {}", e))?;
+    let rgba = img.to_rgba8();
+    let (w, h) = rgba.dimensions();
+    let img_data = arboard::ImageData {
+        width: w as usize,
+        height: h as usize,
+        bytes: std::borrow::Cow::Owned(rgba.into_raw()),
+    };
+    let mut clipboard = arboard::Clipboard::new()
+        .map_err(|e| format!("Clipboard init failed: {}", e))?;
+    clipboard.set_image(img_data)
+        .map_err(|e| format!("Failed to set clipboard image: {}", e))?;
+    Ok(())
+}
+
+#[cfg(target_os = "android")]
+#[tauri::command]
+pub fn copy_image_to_clipboard(_path: String) -> Result<(), String> {
+    Err("Clipboard image copy not supported on Android".to_string())
+}
+
 // ── Attachments ──
 
 #[tauri::command]
@@ -389,6 +787,7 @@ pub fn set_general_settings(
     pdf_height: u32,
     title_mode: String,
     hide_title_in_body: bool,
+    show_line_numbers: bool,
     default_view_mode: bool,
     show_tray_icon: bool,
     close_to_tray: bool,
@@ -403,6 +802,7 @@ pub fn set_general_settings(
     config.pdf_height = pdf_height;
     config.title_mode = title_mode;
     config.hide_title_in_body = hide_title_in_body;
+    config.show_line_numbers = show_line_numbers;
     config.default_view_mode = default_view_mode;
     config.show_tray_icon = show_tray_icon;
     config.close_to_tray = close_to_tray;
@@ -437,6 +837,13 @@ pub fn remove_quick_access(
     operations::remove_quick_access(vault_path, &note_relative)
 }
 
+#[tauri::command]
+pub fn reorder_quick_access(state: State<'_, AppState>, paths: Vec<String>) -> Result<(), 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::save_quick_access(vault_path, &paths)
+}
+
 #[tauri::command]
 pub fn get_vault_stats(state: State<'_, AppState>) -> Result<VaultStats, String> {
     let config = state.config.lock().map_err(|e| e.to_string())?;
@@ -972,6 +1379,9 @@ fn resolve_wiki_ref(
     reference: &str,
 ) -> String {
     let reference = reference.trim();
+    // Strip Obsidian heading anchors (#) and block references (^) before lookup
+    let reference = reference.split('#').next().unwrap_or(reference).trim();
+    let reference = reference.split('^').next().unwrap_or(reference).trim();
     // Direct match by filename
     if let Some(rel) = file_index.get(reference) {
         return rel.clone();
@@ -995,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))?;
@@ -1190,11 +1620,13 @@ pub fn set_ai_settings(
     api_key: Option<String>,
     model: String,
     writing_style: Option<String>,
+    base_url: Option<String>,
 ) -> Result<(), String> {
     let mut config = state.config.lock().map_err(|e| e.to_string())?;
     let key = api_key.filter(|k| !k.is_empty());
     match provider.as_deref() {
         Some("openai") => config.openai_api_key = key,
+        Some("ollama") => config.ollama_base_url = base_url.filter(|u| !u.trim().is_empty()),
         _ => config.ai_api_key = key,
     }
     config.ai_provider = provider;
@@ -1206,27 +1638,36 @@ pub fn set_ai_settings(
 
 #[tauri::command]
 pub fn test_ai_connection(app: AppHandle) -> Result<(), String> {
-    let (provider, api_key, model) = {
+    let (provider, api_key, model, base_url) = {
         let state = app.state::<AppState>();
         let config = state.config.lock().map_err(|e| e.to_string())?;
         let provider = config
             .ai_provider
             .clone()
             .unwrap_or_else(|| "anthropic".to_string());
-        let key = if provider == "openai" {
+        let key = if provider == "ollama" {
+            // Ollama doesn't require an API key
+            Some(String::new())
+        } else if provider == "openai" {
             config.openai_api_key.clone()
         } else {
             config.ai_api_key.clone()
         }
         .ok_or("No API key configured")?;
         let model = config.ai_model.clone();
-        (provider, key, model)
+        let base_url = config.ollama_base_url.clone();
+        (provider, key, model, base_url)
     };
 
     std::thread::spawn(move || {
         use tauri::Emitter;
         let rt = tokio::runtime::Runtime::new().unwrap();
-        let result = rt.block_on(crate::ai::test_connection(&provider, &api_key, &model));
+        let result = rt.block_on(crate::ai::test_connection(
+            &provider,
+            &api_key,
+            &model,
+            base_url.as_deref(),
+        ));
         match result {
             Ok(msg) => {
                 let _ = app.emit(
@@ -1253,14 +1694,16 @@ pub fn ai_ask(
     custom_prompt: Option<String>,
     request_id: String,
 ) -> Result<(), String> {
-    let (provider, api_key, model, writing_style) = {
+    let (provider, api_key, model, writing_style, base_url) = {
         let state = app.state::<AppState>();
         let config = state.config.lock().map_err(|e| e.to_string())?;
         let provider = config
             .ai_provider
             .clone()
             .unwrap_or_else(|| "anthropic".to_string());
-        let key = if provider == "openai" {
+        let key = if provider == "ollama" {
+            Some(String::new())
+        } else if provider == "openai" {
             config.openai_api_key.clone()
         } else {
             config.ai_api_key.clone()
@@ -1268,7 +1711,8 @@ pub fn ai_ask(
         .ok_or("No API key configured. Go to Settings > AI to set up your API key.")?;
         let model = config.ai_model.clone();
         let style = config.ai_writing_style.clone();
-        (provider, key, model, style)
+        let base_url = config.ollama_base_url.clone();
+        (provider, key, model, style, base_url)
     };
 
     let mut system_prompt = "You are a helpful writing assistant inside a note-taking app called HelixNotes. \
@@ -1314,15 +1758,27 @@ pub fn ai_ask(
         system_prompt,
         user_message,
         request_id,
+        base_url,
     );
     Ok(())
 }
 
 // ── Helpers ──
 
+static ANDROID_CONFIG_DIR: std::sync::OnceLock<std::path::PathBuf> = std::sync::OnceLock::new();
+
+pub fn set_android_config_dir(path: std::path::PathBuf) {
+    let _ = ANDROID_CONFIG_DIR.set(path);
+}
+
 fn app_config_path() -> Result<std::path::PathBuf, String> {
-    let config_dir = dirs::config_dir().ok_or("Cannot find config directory")?;
-    let app_dir = config_dir.join("helixnotes");
+    let app_dir = if let Some(config_dir) = dirs::config_dir() {
+        config_dir.join("helixnotes")
+    } else if let Some(android_dir) = ANDROID_CONFIG_DIR.get() {
+        android_dir.join("helixnotes")
+    } else {
+        return Err("Config directory not available yet".to_string());
+    };
     std::fs::create_dir_all(&app_dir).map_err(|e| e.to_string())?;
     Ok(app_dir.join("config.json"))
 }
@@ -1341,3 +1797,30 @@ fn save_app_config(config: &AppConfig) -> Result<(), String> {
     std::fs::write(path, data).map_err(|e| e.to_string())?;
     Ok(())
 }
+
+// ── Install Type Detection ──
+
+#[tauri::command]
+pub fn get_install_type() -> String {
+    if cfg!(target_os = "macos") {
+        "macos".to_string()
+    } else if cfg!(target_os = "windows") {
+        "windows".to_string()
+    } else if std::path::Path::new("/var/lib/dpkg/info/helix-notes.list").exists() {
+        "deb".to_string()
+    } else if std::path::Path::new("/var/lib/pacman/local").exists()
+        && ["helixnotes", "helixnotes-bin", "helixnotes-appimage-bin"].iter().any(|pkg| {
+            std::process::Command::new("pacman")
+                .args(["-Q", pkg])
+                .output()
+                .map(|o| o.status.success())
+                .unwrap_or(false)
+        })
+    {
+        "aur".to_string()
+    } else if std::env::var("APPIMAGE").is_ok() {
+        "appimage".to_string()
+    } else {
+        "native".to_string()
+    }
+}

src-tauri/src/lib.rs

@@ -8,17 +8,26 @@ mod types;
 mod vault;
 
 use state::AppState;
+#[allow(unused_imports)]
+use tauri::{Emitter, Manager};
+
+#[cfg(not(target_os = "android"))]
 use tauri::{
     image::Image,
     menu::{MenuBuilder, MenuItemBuilder},
     tray::TrayIconBuilder,
-    Manager,
 };
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    rustls::crypto::ring::default_provider()
+        .install_default()
+        .expect("Failed to install rustls crypto provider");
+
     let config = commands::load_app_config();
+    #[cfg(not(target_os = "android"))]
     let show_tray = config.show_tray_icon;
+    #[cfg(not(target_os = "android"))]
     let close_to_tray = config.close_to_tray && show_tray;
     let app_state = AppState::new(config);
 
@@ -26,7 +35,6 @@ pub fn run() {
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_opener::init())
-        .plugin(tauri_plugin_updater::Builder::new().build())
         .setup(move |app| {
             if cfg!(debug_assertions) {
                 app.handle().plugin(
@@ -36,10 +44,48 @@ pub fn run() {
                 )?;
             }
 
+            // On Android, set config dir from Tauri's path resolver, then reload config
+            #[cfg(target_os = "android")]
+            {
+                if let Ok(config_dir) = app.path().config_dir() {
+                    commands::set_android_config_dir(config_dir);
+                } else if let Ok(data_dir) = app.path().data_dir() {
+                    commands::set_android_config_dir(data_dir);
+                }
+                // Reload config now that the Android config dir is available
+                let reloaded = commands::load_app_config();
+                let _ = app.state::<AppState>().config.lock().map(|mut cfg| {
+                    *cfg = reloaded;
+                });
+            }
+
+            #[cfg(not(target_os = "android"))]
             if show_tray {
                 setup_tray(app)?;
             }
 
+            // Check CLI args for a .md file path on initial launch
+            #[cfg(not(target_os = "android"))]
+            {
+                let file_arg = std::env::args().skip(1).find(|a| {
+                    let a = a.trim();
+                    !a.starts_with('-') && a.ends_with(".md")
+                });
+                if let Some(path) = file_arg {
+                    let resolved = if std::path::Path::new(&path).is_absolute() {
+                        std::path::PathBuf::from(&path)
+                    } else {
+                        std::env::current_dir().unwrap_or_default().join(&path)
+                    };
+                    if let Some(resolved_str) = resolved.to_str() {
+                        let app_state = app.state::<AppState>();
+                        let _ = app_state.pending_open_file.lock().map(|mut p| {
+                            *p = Some(resolved_str.to_string());
+                        });
+                    }
+                }
+            }
+
             Ok(())
         })
         .manage(app_state)
@@ -50,27 +96,35 @@ pub fn run() {
             commands::set_accent_color,
             commands::set_font_size,
             commands::set_font_family,
+            commands::set_line_height,
             commands::get_notebooks,
+            commands::count_root_notes,
             commands::create_notebook,
             commands::rename_notebook,
             commands::delete_notebook,
+            commands::move_notebook,
             commands::get_notes,
             commands::read_note,
             commands::save_note,
             commands::create_note,
+            commands::create_daily_note,
             commands::rename_note,
             commands::delete_note,
             commands::move_note,
             commands::get_all_tags,
             commands::get_all_note_titles,
+            commands::get_graph_data,
             commands::search_notes,
             commands::reindex,
             commands::get_trash,
             commands::restore_note,
+            commands::restore_notebook,
             commands::permanent_delete,
             commands::empty_trash,
             commands::load_vault_state,
             commands::save_vault_state,
+            commands::read_clipboard_image,
+            commands::copy_image_to_clipboard,
             commands::save_image,
             commands::save_attachment,
             commands::get_notebook_icons,
@@ -79,9 +133,11 @@ pub fn run() {
             commands::get_quick_access,
             commands::add_quick_access,
             commands::remove_quick_access,
+            commands::reorder_quick_access,
             commands::get_vault_stats,
             commands::import_obsidian,
             commands::open_file,
+            commands::open_url,
             commands::copy_file_to,
             commands::create_backup,
             commands::list_backups,
@@ -94,13 +150,135 @@ pub fn run() {
             commands::set_ai_settings,
             commands::test_ai_connection,
             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 close_to_tray {
-        builder = builder.on_window_event(|window, event| {
-            if let tauri::WindowEvent::CloseRequested { api, .. } = event {
-                api.prevent_close();
-                let _ = window.hide();
+                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"))]
+    {
+        builder = builder.plugin(tauri_plugin_single_instance::init(|app, args, cwd| {
+            // Always show/focus the main window
+            if let Some(window) = app.get_webview_window("main") {
+                let _ = window.show();
+                let _ = window.unminimize();
+                let _ = window.set_focus();
+            }
+
+            // Extract .md file path from args (args[0] is the binary)
+            let file_path = args.iter().skip(1).find(|arg| {
+                let a = arg.trim();
+                !a.starts_with('-') && a.ends_with(".md")
+            });
+
+            if let Some(path) = file_path {
+                let resolved = if std::path::Path::new(path.as_str()).is_absolute() {
+                    std::path::PathBuf::from(path)
+                } else {
+                    std::path::Path::new(&cwd).join(path)
+                };
+                if let Some(resolved_str) = resolved.to_str() {
+                    let _ = app.emit("open-file", resolved_str.to_string());
+                }
+            }
+        }));
+
+        builder = builder.plugin(tauri_plugin_updater::Builder::new().build());
+        builder = builder.plugin(tauri_plugin_window_state::Builder::default().build());
+
+        builder = builder.on_window_event(move |window, event| {
+            match event {
+                tauri::WindowEvent::CloseRequested { api, .. } => {
+                    // Only hide to tray for the main window
+                    if close_to_tray && window.label() == "main" {
+                        api.prevent_close();
+                        let _ = window.hide();
+                    }
+                }
+                tauri::WindowEvent::Destroyed => {
+                    // When main window is destroyed, close all note windows
+                    if window.label() == "main" {
+                        let app = window.app_handle();
+                        for (label, win) in app.webview_windows() {
+                            if label.starts_with("note-") {
+                                let _ = win.close();
+                            }
+                        }
+                    }
+                }
+                _ => {}
             }
         });
     }
@@ -110,6 +288,7 @@ pub fn run() {
         .expect("error while running tauri application");
 }
 
+#[cfg(not(target_os = "android"))]
 fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
     let show = MenuItemBuilder::with_id("show", "Show HelixNotes").build(app)?;
     let quit = MenuItemBuilder::with_id("quit", "Quit").build(app)?;
@@ -148,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

@@ -5,10 +5,13 @@ use std::fs;
 use std::path::Path;
 use std::sync::Mutex;
 use tantivy::collector::TopDocs;
+#[cfg(not(target_os = "android"))]
 use tantivy::directory::MmapDirectory;
-use tantivy::query::QueryParser;
+#[cfg(target_os = "android")]
+use tantivy::directory::RamDirectory;
+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 {
@@ -24,9 +27,6 @@ pub struct SearchIndex {
 
 impl SearchIndex {
     pub fn new(vault_path: &str) -> Result<Self, String> {
-        let index_dir = helixnotes_dir(vault_path).join("search_index");
-        fs::create_dir_all(&index_dir).map_err(|e| e.to_string())?;
-
         let mut schema_builder = Schema::builder();
         let path_field = schema_builder.add_text_field("path", STRING | STORED);
         let title_field = schema_builder.add_text_field("title", TEXT | STORED);
@@ -34,12 +34,27 @@ impl SearchIndex {
         let tags_field = schema_builder.add_text_field("tags", TEXT | STORED);
         let schema = schema_builder.build();
 
-        let dir = MmapDirectory::open(&index_dir).map_err(|e| e.to_string())?;
-        let index = Index::open_or_create(dir, schema.clone()).map_err(|e| e.to_string())?;
+        // Android: use in-memory index (flock doesn't work on /storage/emulated FUSE filesystem)
+        // Desktop: use mmap directory for persistent index on disk
+        #[cfg(target_os = "android")]
+        let index = {
+            let dir = RamDirectory::create();
+            Index::open_or_create(dir, schema.clone()).map_err(|e| e.to_string())?
+        };
+        #[cfg(not(target_os = "android"))]
+        let index = {
+            let index_dir = helixnotes_dir(vault_path).join("search_index");
+            fs::create_dir_all(&index_dir).map_err(|e| e.to_string())?;
+            let dir = MmapDirectory::open(&index_dir).map_err(|e| e.to_string())?;
+            Index::open_or_create(dir, schema.clone()).map_err(|e| e.to_string())?
+        };
 
-        let writer = index
-            .writer(50_000_000)
-            .map_err(|e| e.to_string())?;
+        #[cfg(target_os = "android")]
+        let heap_size = 15_000_000;
+        #[cfg(not(target_os = "android"))]
+        let heap_size = 50_000_000;
+
+        let writer = index.writer(heap_size).map_err(|e| e.to_string())?;
 
         Ok(Self {
             index,
@@ -62,18 +77,20 @@ impl SearchIndex {
 
         for entry in WalkDir::new(vault_path)
             .into_iter()
-            .filter_map(|e| e.ok())
-            .filter(|e| {
+            .filter_entry(|e| {
                 let p = e.path();
-                p.is_file()
-                    && p.extension().and_then(|x| x.to_str()) == Some("md")
-                    && !p.starts_with(&hn_dir)
+                !p.starts_with(&hn_dir)
                     && !p
                         .file_name()
                         .and_then(|n| n.to_str())
                         .map(|n| n.starts_with('.'))
                         .unwrap_or(false)
             })
+            .filter_map(|e| e.ok())
+            .filter(|e| {
+                e.file_type().is_file()
+                    && e.path().extension().and_then(|x| x.to_str()) == Some("md")
+            })
         {
             if let Ok(raw) = fs::read_to_string(entry.path()) {
                 let filename = entry.file_name().to_string_lossy().to_string();
@@ -135,12 +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/state.rs

@@ -3,12 +3,14 @@ use crate::types::AppConfig;
 use notify::RecommendedWatcher;
 use std::sync::atomic::AtomicBool;
 use std::sync::Mutex;
+use std::sync::Arc;
 
 pub struct AppState {
     pub config: Mutex<AppConfig>,
-    pub search_index: Mutex<Option<SearchIndex>>,
+    pub search_index: Mutex<Option<Arc<SearchIndex>>>,
     pub watcher: Mutex<Option<RecommendedWatcher>>,
     pub importing: AtomicBool,
+    pub pending_open_file: Mutex<Option<String>>,
 }
 
 impl AppState {
@@ -18,6 +20,7 @@ impl AppState {
             search_index: Mutex::new(None),
             watcher: Mutex::new(None),
             importing: AtomicBool::new(false),
+            pending_open_file: Mutex::new(None),
         }
     }
 }

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,
@@ -54,6 +68,8 @@ pub struct AppConfig {
     #[serde(default)]
     pub font_family: Option<String>,
     #[serde(default)]
+    pub line_height: Option<f64>,
+    #[serde(default)]
     pub compact_notes: bool,
     #[serde(default)]
     pub time_format: String,
@@ -70,6 +86,8 @@ pub struct AppConfig {
     #[serde(default)]
     pub hide_title_in_body: bool,
     #[serde(default)]
+    pub show_line_numbers: bool,
+    #[serde(default)]
     pub backup_enabled: bool,
     #[serde(default = "default_backup_frequency")]
     pub backup_frequency: String,
@@ -89,6 +107,8 @@ pub struct AppConfig {
     pub ai_api_key: Option<String>,
     #[serde(default)]
     pub openai_api_key: Option<String>,
+    #[serde(default)]
+    pub ollama_base_url: Option<String>,
     #[serde(default = "default_ai_model")]
     pub ai_model: String,
     #[serde(default)]
@@ -128,7 +148,7 @@ fn default_max_versions() -> u32 {
 }
 
 fn default_ai_model() -> String {
-    "claude-sonnet-4-5-20250929".to_string()
+    "claude-sonnet-4-6".to_string()
 }
 
 impl Default for AppConfig {
@@ -140,6 +160,7 @@ impl Default for AppConfig {
             accent_color: None,
             font_size: None,
             font_family: None,
+            line_height: None,
             compact_notes: false,
             time_format: "relative".to_string(),
             gpu_acceleration: true,
@@ -148,6 +169,7 @@ impl Default for AppConfig {
             pdf_height: 600,
             title_mode: "input".to_string(),
             hide_title_in_body: false,
+            show_line_numbers: false,
             backup_enabled: false,
             backup_frequency: "24h".to_string(),
             backup_max_count: 10,
@@ -158,7 +180,8 @@ impl Default for AppConfig {
             ai_provider: None,
             ai_api_key: None,
             openai_api_key: None,
-            ai_model: "claude-sonnet-4-5-20250929".to_string(),
+            ollama_base_url: None,
+            ai_model: "claude-sonnet-4-6".to_string(),
             ai_writing_style: None,
             default_view_mode: false,
             show_tray_icon: false,
@@ -245,3 +268,22 @@ pub struct NoteTitleEntry {
     pub title: String,
     pub path: String,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GraphData {
+    pub nodes: Vec<GraphNode>,
+    pub edges: Vec<GraphEdge>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GraphNode {
+    pub title: String,
+    pub path: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GraphEdge {
+    pub source: usize,
+    pub target: usize,
+    pub bidirectional: bool,
+}

src-tauri/src/vault/frontmatter.rs

@@ -1,9 +1,8 @@
 use crate::types::NoteMeta;
-use chrono::Utc;
+use chrono::{NaiveDate, NaiveDateTime, Utc};
 use gray_matter::engine::YAML;
 use gray_matter::Matter;
 use serde::{Deserialize, Serialize};
-use uuid::Uuid;
 
 #[derive(Debug, Serialize, Deserialize, Default)]
 struct RawFrontmatter {
@@ -15,6 +14,32 @@ struct RawFrontmatter {
     modified: Option<String>,
 }
 
+/// Try to parse a date string in multiple common formats.
+fn parse_date_flexible(s: &str) -> Option<chrono::DateTime<Utc>> {
+    let s = s.trim();
+    // RFC 3339 / ISO 8601 with timezone (e.g. 2024-01-15T10:30:00+00:00)
+    if let Ok(dt) = s.parse::<chrono::DateTime<Utc>>() {
+        return Some(dt);
+    }
+    // Try parsing as DateTime with fixed offset then convert
+    if let Ok(dt) = chrono::DateTime::parse_from_rfc3339(s) {
+        return Some(dt.with_timezone(&Utc));
+    }
+    // YYYY-MM-DD HH:MM:SS (no timezone)
+    if let Ok(ndt) = NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S") {
+        return Some(ndt.and_utc());
+    }
+    // YYYY-MM-DDTHH:MM:SS (no timezone, with T separator)
+    if let Ok(ndt) = NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S") {
+        return Some(ndt.and_utc());
+    }
+    // YYYY-MM-DD (date only)
+    if let Ok(nd) = NaiveDate::parse_from_str(s, "%Y-%m-%d") {
+        return nd.and_hms_opt(0, 0, 0).map(|ndt| ndt.and_utc());
+    }
+    None
+}
+
 pub fn parse_note(raw: &str, filename: &str) -> (NoteMeta, String) {
     let matter = Matter::<YAML>::new();
     let result = matter.parse(raw);
@@ -28,15 +53,16 @@ pub fn parse_note(raw: &str, filename: &str) -> (NoteMeta, String) {
 
     let created = fm
         .created
-        .and_then(|s| s.parse().ok())
+        .and_then(|s| parse_date_flexible(&s))
         .unwrap_or_else(Utc::now);
 
     let modified = fm
         .modified
-        .and_then(|s| s.parse().ok())
+        .and_then(|s| parse_date_flexible(&s))
         .unwrap_or_else(Utc::now);
 
-    let id = fm.id.unwrap_or_else(|| Uuid::new_v4().to_string());
+    // Don't generate UUID on read — empty string signals "no ID yet"
+    let id = fm.id.unwrap_or_default();
 
     let meta = NoteMeta {
         id,
@@ -51,6 +77,29 @@ pub fn parse_note(raw: &str, filename: &str) -> (NoteMeta, String) {
     (meta, content)
 }
 
+/// Ensure the body starts with `# Title` heading for external app compatibility.
+/// If the body already starts with `# Title`, leave it as-is.
+fn ensure_title_heading(body: &str, title: &str) -> String {
+    let trimmed = body.trim_start();
+
+    // Check if body already starts with `# Title`
+    if let Some(rest) = trimmed.strip_prefix("# ") {
+        let first_line_end = rest.find('\n').unwrap_or(rest.len());
+        let heading_text = rest[..first_line_end].trim();
+        if heading_text.eq_ignore_ascii_case(title.trim()) {
+            return body.to_string();
+        }
+    }
+
+    // Don't add heading to empty notes (new/blank notes)
+    if trimmed.is_empty() {
+        return body.to_string();
+    }
+
+    // Prepend `# Title` heading
+    format!("# {}\n\n{}", title, body)
+}
+
 pub fn serialize_frontmatter(meta: &NoteMeta) -> String {
     let tags_str = if meta.tags.is_empty() {
         "[]".to_string()
@@ -78,7 +127,68 @@ pub fn serialize_frontmatter(meta: &NoteMeta) -> String {
 
 pub fn update_note_raw(meta: &NoteMeta, body: &str) -> String {
     let fm = serialize_frontmatter(meta);
-    format!("{}{}", fm, body)
+    let body_with_heading = ensure_title_heading(body, &meta.title);
+    format!("{}{}", fm, body_with_heading)
+}
+
+/// Merge NoteMeta fields into existing frontmatter, preserving unknown YAML keys.
+/// Falls back to serialize_frontmatter() if the original has no frontmatter.
+pub fn merge_frontmatter(original_raw: &str, meta: &NoteMeta, body: &str) -> String {
+    let matter = Matter::<YAML>::new();
+    let parsed = matter.parse(original_raw);
+
+    // If original had no frontmatter, use the simple serializer
+    if parsed.matter.trim().is_empty() {
+        return update_note_raw(meta, body);
+    }
+
+    // Parse existing YAML into a Mapping to preserve all keys
+    let mut mapping: serde_yaml::Mapping = match serde_yaml::from_str(&parsed.matter) {
+        Ok(m) => m,
+        Err(_) => return update_note_raw(meta, body), // unparseable YAML, fall back
+    };
+
+    // Update only our known fields
+    if !meta.id.is_empty() {
+        mapping.insert(
+            serde_yaml::Value::String("id".into()),
+            serde_yaml::Value::String(meta.id.clone()),
+        );
+    }
+    mapping.insert(
+        serde_yaml::Value::String("title".into()),
+        serde_yaml::Value::String(meta.title.clone()),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("tags".into()),
+        serde_yaml::Value::Sequence(
+            meta.tags
+                .iter()
+                .map(|t| serde_yaml::Value::String(t.clone()))
+                .collect(),
+        ),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("pinned".into()),
+        serde_yaml::Value::Bool(meta.pinned),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("created".into()),
+        serde_yaml::Value::String(meta.created.to_rfc3339()),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("modified".into()),
+        serde_yaml::Value::String(meta.modified.to_rfc3339()),
+    );
+
+    // Serialize the mapping back to YAML
+    let yaml_str = match serde_yaml::to_string(&serde_yaml::Value::Mapping(mapping)) {
+        Ok(s) => s,
+        Err(_) => return update_note_raw(meta, body),
+    };
+
+    let body_with_heading = ensure_title_heading(body, &meta.title);
+    format!("---\n{}---\n{}", yaml_str, body_with_heading)
 }
 
 fn filename_to_title(filename: &str) -> String {

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::Utc;
+use chrono::{DateTime, Local, Locale, Utc};
 use rayon::prelude::*;
 use std::fs;
 use std::io::Read;
@@ -59,11 +59,13 @@ fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
         return entries;
     };
 
+    // Collect subdirs (root level only lists directories, note counts come from scan_dir_with_count)
     let mut dirs: Vec<_> = read_dir
         .filter_map(|e| e.ok())
         .filter(|e| {
-            let path = e.path();
-            path.is_dir() && !is_hidden(&path)
+            e.file_type().map(|ft| ft.is_dir()).unwrap_or(false)
+                && !is_hidden(&e.path())
+                && e.file_name().to_string_lossy() != "Daily"
         })
         .collect();
 
@@ -74,6 +76,8 @@ fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
             .cmp(&b.file_name().to_string_lossy().to_lowercase())
     });
 
+    // Store note_count for the parent directory (used when this is the top-level call)
+    // Each directory pushes its own entry with its own note_count
     for dir_entry in dirs {
         let path = dir_entry.path();
         let name = dir_entry.file_name().to_string_lossy().to_string();
@@ -83,77 +87,189 @@ fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
             .to_string_lossy()
             .to_string();
 
-        let children = scan_dir_recursive(&path, vault_root);
-        let note_count = count_notes_in_dir(&path);
+        let (children, child_note_count) = scan_dir_with_count(&path, vault_root);
 
         entries.push(NotebookEntry {
             name,
             path: path.to_string_lossy().to_string(),
             relative_path: relative,
             children,
-            note_count,
+            note_count: child_note_count,
         });
     }
 
     entries
 }
 
-fn count_notes_in_dir(dir: &Path) -> usize {
-    fs::read_dir(dir)
-        .map(|rd| {
-            rd.filter_map(|e| e.ok())
-                .filter(|e| {
-                    let path = e.path();
-                    path.is_file() && path.extension().and_then(|x| x.to_str()) == Some("md")
-                })
-                .count()
-        })
-        .unwrap_or(0)
+/// Combined scan: returns (children, note_count) in a single read_dir pass.
+fn scan_dir_with_count(dir: &Path, vault_root: &str) -> (Vec<NotebookEntry>, usize) {
+    let root = Path::new(vault_root);
+
+    let Ok(read_dir) = fs::read_dir(dir) else {
+        return (Vec::new(), 0);
+    };
+
+    let mut subdirs = Vec::new();
+    let mut note_count = 0usize;
+    for entry in read_dir.filter_map(|e| e.ok()) {
+        let ft = match entry.file_type() {
+            Ok(ft) => ft,
+            Err(_) => continue,
+        };
+        if ft.is_dir() && !is_hidden(&entry.path()) {
+            subdirs.push(entry);
+        } else if ft.is_file() && entry.path().extension().and_then(|x| x.to_str()) == Some("md") {
+            note_count += 1;
+        }
+    }
+
+    subdirs.sort_by(|a, b| {
+        a.file_name()
+            .to_string_lossy()
+            .to_lowercase()
+            .cmp(&b.file_name().to_string_lossy().to_lowercase())
+    });
+
+    let mut entries = Vec::new();
+    for dir_entry in subdirs {
+        let path = dir_entry.path();
+        let name = dir_entry.file_name().to_string_lossy().to_string();
+        let relative = path
+            .strip_prefix(root)
+            .unwrap_or(&path)
+            .to_string_lossy()
+            .to_string();
+
+        let (children, child_note_count) = scan_dir_with_count(&path, vault_root);
+
+        entries.push(NotebookEntry {
+            name,
+            path: path.to_string_lossy().to_string(),
+            relative_path: relative,
+            children,
+            note_count: child_note_count,
+        });
+    }
+
+    (entries, note_count)
 }
 
 fn is_hidden(path: &Path) -> bool {
     path.file_name()
         .and_then(|n| n.to_str())
-        .map(|n| n.starts_with('.'))
+        .map(|n| {
+            n.starts_with('.')
+                || matches!(
+                    n,
+                    "_res" | "_resources" | "_attachments" | "_assets" | "assets" | "node_modules"
+                )
+        })
         .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);
     let vault_root = Path::new(vault_path);
 
+    log::info!("scan_notes: vault={}, scan={}, exists={}", vault_path, scan_path, root.exists());
+
     if !root.exists() {
         return Err("Path does not exist".to_string());
     }
 
-    let md_files: Vec<PathBuf> = if notebook_path.is_some() {
-        // Only direct children for a specific notebook
-        fs::read_dir(root)
-            .map_err(|e| e.to_string())?
-            .filter_map(|e| e.ok())
-            .map(|e| e.path())
-            .filter(|p| p.is_file() && p.extension().and_then(|x| x.to_str()) == Some("md"))
-            .collect()
-    } else {
-        // Recursive for "All Notes"
-        WalkDir::new(root)
-            .into_iter()
-            .filter_map(|e| e.ok())
-            .filter(|e| !is_hidden(e.path()) && !e.path().starts_with(&helixnotes_dir(vault_path)))
-            .map(|e| e.path().to_path_buf())
-            .filter(|p| p.is_file() && p.extension().and_then(|x| x.to_str()) == Some("md"))
-            .collect()
-    };
+    // On Android, use metadata-only scan (no file reads) for fast listing on FUSE
+    #[cfg(target_os = "android")]
+    {
+        let mut notes = Vec::new();
+        // Log what read_dir sees
+        if let Ok(rd) = fs::read_dir(root) {
+            let items: Vec<_> = rd.filter_map(|e| e.ok()).collect();
+            log::info!("scan_notes: read_dir found {} entries in {:?}", items.len(), root);
+            for (i, entry) in items.iter().enumerate().take(5) {
+                let ft = entry.file_type().map(|ft| if ft.is_file() { "file" } else if ft.is_dir() { "dir" } else { "other" }).unwrap_or("err");
+                log::info!("  [{}] {:?} type={}", i, entry.file_name(), ft);
+            }
+        } else {
+            log::info!("scan_notes: read_dir FAILED for {:?}", root);
+        }
 
-    // Process files in parallel with partial reads
-    let mut notes: Vec<NoteEntry> = md_files
-        .par_iter()
-        .filter_map(|path| read_note_entry_fast(path, vault_root).ok())
-        .collect();
+        if notebook_path.is_some() {
+            if let Ok(rd) = fs::read_dir(root) {
+                for entry in rd.filter_map(|e| e.ok()) {
+                    let is_file = entry.file_type().map(|ft| ft.is_file()).unwrap_or(false);
+                    if is_file && entry.path().extension().and_then(|x| x.to_str()) == Some("md") {
+                        if let Ok(note) = read_note_entry_metadata_only(&entry.path(), vault_root) {
+                            notes.push(note);
+                        }
+                    }
+                }
+            }
+        } else {
+            let hn_dir = helixnotes_dir(vault_path);
+            for entry in WalkDir::new(root)
+                .into_iter()
+                // filter_entry skips descending into hidden dirs (unlike filter)
+                .filter_entry(|e| !is_hidden(e.path()) && !e.path().starts_with(&hn_dir))
+                .filter_map(|e| e.ok())
+                .filter(|e| {
+                    e.file_type().is_file()
+                        && e.path().extension().and_then(|x| x.to_str()) == Some("md")
+                })
+            {
+                if let Ok(note) = read_note_entry_metadata_only(entry.path(), vault_root) {
+                    notes.push(note);
+                }
+            }
+        }
+        log::info!("scan_notes: Android scan found {} notes", notes.len());
+        notes.sort_by(|a, b| b.meta.modified.cmp(&a.meta.modified));
+        return Ok(notes);
+    }
 
-    notes.sort_by(|a, b| b.meta.modified.cmp(&a.meta.modified));
-    Ok(notes)
+    #[cfg(not(target_os = "android"))]
+    {
+        let md_files: Vec<PathBuf> = if notebook_path.is_some() {
+            fs::read_dir(root)
+                .map_err(|e| e.to_string())?
+                .filter_map(|e| e.ok())
+                .map(|e| e.path())
+                .filter(|p| p.is_file() && p.extension().and_then(|x| x.to_str()) == Some("md"))
+                .collect()
+        } else {
+            WalkDir::new(root)
+                .into_iter()
+                .filter_entry(|e| !is_hidden(e.path()) && !e.path().starts_with(&helixnotes_dir(vault_path)))
+                .filter_map(|e| e.ok())
+                .map(|e| e.path().to_path_buf())
+                .filter(|p| p.is_file() && p.extension().and_then(|x| x.to_str()) == Some("md"))
+                .collect()
+        };
+
+        let mut notes: Vec<NoteEntry> = md_files
+            .par_iter()
+            .filter_map(|path| read_note_entry_fast(path, vault_root).ok())
+            .collect();
+
+        notes.sort_by(|a, b| b.meta.modified.cmp(&a.meta.modified));
+        Ok(notes)
+    }
 }
 
 fn read_note_entry(path: &Path, vault_root: &Path) -> Result<NoteEntry, String> {
@@ -161,6 +277,51 @@ fn read_note_entry(path: &Path, vault_root: &Path) -> Result<NoteEntry, String>
     read_note_entry_from_str(&raw, path, vault_root)
 }
 
+/// Android-only: reads just the frontmatter (first 2KB) for tags/title/pinned,
+/// uses filesystem timestamps for dates. No preview text.
+#[cfg(target_os = "android")]
+fn read_note_entry_metadata_only(path: &Path, vault_root: &Path) -> Result<NoteEntry, String> {
+    // Read first 2KB — enough for frontmatter with tags, title, pinned
+    let mut file = fs::File::open(path).map_err(|e| e.to_string())?;
+    let mut buf = vec![0u8; 2048];
+    let bytes_read = file.read(&mut buf).map_err(|e| e.to_string())?;
+    buf.truncate(bytes_read);
+    let raw = String::from_utf8_lossy(&buf);
+
+    let filename = path
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .to_string();
+
+    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) {
+        if let Ok(m) = fs_meta.modified() {
+            meta.modified = m.into();
+        }
+        if let Ok(c) = fs_meta.created() {
+            meta.created = c.into();
+        }
+    }
+
+    let relative = path
+        .strip_prefix(vault_root)
+        .unwrap_or(path)
+        .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,
+    })
+}
+
 /// Fast version: reads only the first ~2KB of the file (enough for frontmatter + preview).
 fn read_note_entry_fast(path: &Path, vault_root: &Path) -> Result<NoteEntry, String> {
     let mut file = fs::File::open(path).map_err(|e| e.to_string())?;
@@ -184,13 +345,19 @@ fn read_note_entry_from_str(
 
     let (mut meta, content) = frontmatter::parse_note(raw, &filename);
 
-    // Use filesystem times if frontmatter didn't have them
+    // Use filesystem times only if frontmatter didn't have created/modified fields
+    let has_created = raw.contains("\ncreated:") || raw.starts_with("created:");
+    let has_modified = raw.contains("\nmodified:") || raw.starts_with("modified:");
     if let Ok(fs_meta) = fs::metadata(path) {
-        if let Ok(modified) = fs_meta.modified() {
-            meta.modified = modified.into();
+        if !has_modified {
+            if let Ok(modified) = fs_meta.modified() {
+                meta.modified = modified.into();
+            }
         }
-        if let Ok(created) = fs_meta.created() {
-            meta.created = created.into();
+        if !has_created {
+            if let Ok(created) = fs_meta.created() {
+                meta.created = created.into();
+            }
         }
     }
 
@@ -233,7 +400,19 @@ pub fn save_note(path: &str, meta: &NoteMeta, body: &str) -> Result<(), String>
     let mut updated_meta = meta.clone();
     updated_meta.modified = Utc::now();
 
-    let raw = frontmatter::update_note_raw(&updated_meta, body);
+    // Generate UUID on first save if note didn't have one
+    if updated_meta.id.is_empty() {
+        updated_meta.id = Uuid::new_v4().to_string();
+    }
+
+    // Read existing file to preserve unknown frontmatter fields
+    let existing = fs::read_to_string(path).unwrap_or_default();
+    let raw = if existing.is_empty() {
+        frontmatter::update_note_raw(&updated_meta, body)
+    } else {
+        frontmatter::merge_frontmatter(&existing, &updated_meta, body)
+    };
+
     fs::write(path, raw).map_err(|e| e.to_string())?;
     Ok(())
 }
@@ -290,6 +469,105 @@ pub fn create_note(
     })
 }
 
+fn get_system_locale() -> Locale {
+    let sys = sys_locale::get_locale().unwrap_or_else(|| "en-US".to_string());
+    let lang = sys.split(&['-', '_', '.'][..]).next().unwrap_or("en");
+    match lang {
+        "af" => Locale::af_ZA,
+        "ar" => Locale::ar_SA,
+        "be" => Locale::be_BY,
+        "bg" => Locale::bg_BG,
+        "ca" => Locale::ca_ES,
+        "cs" => Locale::cs_CZ,
+        "da" => Locale::da_DK,
+        "de" => Locale::de_DE,
+        "el" => Locale::el_GR,
+        "es" => Locale::es_ES,
+        "et" => Locale::et_EE,
+        "fi" => Locale::fi_FI,
+        "fr" => Locale::fr_FR,
+        "he" => Locale::he_IL,
+        "hi" => Locale::hi_IN,
+        "hr" => Locale::hr_HR,
+        "hu" => Locale::hu_HU,
+        "id" => Locale::id_ID,
+        "is" => Locale::is_IS,
+        "it" => Locale::it_IT,
+        "ja" => Locale::ja_JP,
+        "ka" => Locale::ka_GE,
+        "ko" => Locale::ko_KR,
+        "lt" => Locale::lt_LT,
+        "lv" => Locale::lv_LV,
+        "mk" => Locale::mk_MK,
+        "nb" | "no" => Locale::nb_NO,
+        "nl" => Locale::nl_NL,
+        "nn" => Locale::nn_NO,
+        "pl" => Locale::pl_PL,
+        "pt" => Locale::pt_BR,
+        "ro" => Locale::ro_RO,
+        "ru" => Locale::ru_RU,
+        "sk" => Locale::sk_SK,
+        "sl" => Locale::sl_SI,
+        "sq" => Locale::sq_AL,
+        "sr" => Locale::sr_RS,
+        "sv" => Locale::sv_SE,
+        "th" => Locale::th_TH,
+        "tr" => Locale::tr_TR,
+        "uk" => Locale::uk_UA,
+        "vi" => Locale::vi_VN,
+        "zh" => Locale::zh_CN,
+        _ => Locale::en_US,
+    }
+}
+
+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 = 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())?;
+
+    let file_path = dir.join(format!("{}.md", date_str));
+    let vault_root = Path::new(vault_path);
+
+    // If today's note already exists, return it
+    if file_path.exists() {
+        return read_note_entry(&file_path, vault_root);
+    }
+
+    let now = Utc::now();
+    let meta = NoteMeta {
+        id: Uuid::new_v4().to_string(),
+        title,
+        tags: vec!["daily".to_string()],
+        pinned: false,
+        created: now,
+        modified: now,
+    };
+
+    let raw = frontmatter::update_note_raw(&meta, "\n");
+    fs::write(&file_path, raw).map_err(|e| e.to_string())?;
+
+    let relative = file_path
+        .strip_prefix(vault_root)
+        .unwrap_or(&file_path)
+        .to_string_lossy()
+        .to_string();
+
+    Ok(NoteEntry {
+        path: file_path.to_string_lossy().to_string(),
+        relative_path: relative,
+        meta,
+        preview: String::new(),
+    })
+}
+
 pub fn create_notebook(
     vault_path: &str,
     parent_relative: Option<&str>,
@@ -365,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()
@@ -383,9 +670,16 @@ 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();
-    let updated = frontmatter::update_note_raw(&meta, &content);
+    if meta.id.is_empty() {
+        meta.id = Uuid::new_v4().to_string();
+    }
+    let updated = frontmatter::merge_frontmatter(&raw, &meta, &content);
 
     // Rename file
     let new_filename = sanitize_filename(new_title);
@@ -396,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> {
@@ -432,14 +853,61 @@ pub fn move_note(note_path: &str, dest_notebook: &str) -> Result<String, String>
     Ok(dest.to_string_lossy().to_string())
 }
 
-pub fn get_trash_notes(vault_path: &str) -> Result<Vec<NoteEntry>, String> {
+pub fn move_notebook(notebook_path: &str, dest_parent: &str) -> Result<String, String> {
+    let src = Path::new(notebook_path);
+    if !src.exists() || !src.is_dir() {
+        return Err("Notebook does not exist".to_string());
+    }
+
+    let dest_parent_path = Path::new(dest_parent);
+    if !dest_parent_path.is_dir() {
+        return Err("Destination does not exist".to_string());
+    }
+
+    // No-op if already in that parent
+    if src.parent() == Some(dest_parent_path) {
+        return Err("Notebook is already in that location".to_string());
+    }
+
+    let dir_name = src.file_name().unwrap_or_default();
+    let dest = dest_parent_path.join(dir_name);
+
+    // Prevent moving into itself or a descendant
+    if dest.starts_with(src) {
+        return Err("Cannot move a notebook into itself or its descendants".to_string());
+    }
+
+    if dest.exists() {
+        return Err("A notebook with that name already exists in the destination".to_string());
+    }
+
+    fs::rename(src, &dest).map_err(|e| e.to_string())?;
+    Ok(dest.to_string_lossy().to_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())?;
@@ -448,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(
@@ -480,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.0.1",
+  "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 blob: data:; font-src 'self' data:; style-src 'self' 'unsafe-inline'",
+      "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-tauri/tauri.macos.conf.json

@@ -0,0 +1,16 @@
+{
+  "app": {
+    "windows": [
+      {
+        "label": "main",
+        "decorations": true,
+        "titleBarStyle": "Overlay",
+        "hiddenTitle": true,
+        "trafficLightPosition": {
+          "x": 12,
+          "y": 10
+        }
+      }
+    ]
+  }
+}

src/app.css

@@ -31,7 +31,7 @@
     --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.12);
     --sidebar-width: 220px;
     --notelist-width: 280px;
-    --panel-resize-handle: 4px;
+    --panel-resize-handle: 3px;
 }
 
 :root.dark {
@@ -149,3 +149,124 @@ body {
 .resize-handle.active {
     background: var(--accent);
 }
+
+body.resizing .ProseMirror {
+    pointer-events: none;
+    contain: strict;
+}
+
+body.resizing {
+    user-select: none;
+}
+
+/* ── Mobile (Android/iOS) ── */
+@media (max-width: 768px) {
+    html,
+    body {
+        padding-top: env(safe-area-inset-top);
+        padding-bottom: env(safe-area-inset-bottom);
+        padding-left: env(safe-area-inset-left);
+        padding-right: env(safe-area-inset-right);
+        -webkit-tap-highlight-color: transparent;
+        touch-action: manipulation;
+    }
+
+    ::-webkit-scrollbar {
+        display: none;
+    }
+
+    .resize-handle {
+        display: none !important;
+    }
+}
+
+/* ── Print / Export PDF ── */
+@media print {
+    /* Hide everything except editor content */
+    .titlebar,
+    .sidebar-panel,
+    .notelist-panel,
+    .resize-handle,
+    .toolbar-actions,
+    .editor-body-wrapper .note-search-bar,
+    .formatting-toolbar,
+    .editor-formatting-bar,
+    .history-panel,
+    .outline-panel,
+    .graph-panel,
+    .ai-panel,
+    .link-context-menu,
+    .image-toolbar,
+    .selection-bar {
+        display: none !important;
+    }
+
+    /* Force light theme colors for PDF */
+    :root, :root.dark {
+        --bg-primary: #ffffff !important;
+        --bg-secondary: #f8f9fa !important;
+        --bg-tertiary: #f0f1f3 !important;
+        --bg-editor: #ffffff !important;
+        --text-primary: #1a1a2e !important;
+        --text-secondary: #495057 !important;
+        --text-tertiary: #868e96 !important;
+        --text-accent: #5b6abf !important;
+        --accent: #5b6abf !important;
+        --border-color: #e2e5e9 !important;
+        --border-light: #f0f1f3 !important;
+    }
+
+    html, body {
+        height: auto;
+        overflow: visible;
+        background: white !important;
+        color: #1a1a2e !important;
+        font-size: 12pt;
+        padding: 0;
+    }
+
+    /* Override all scoped height/overflow constraints for print flow */
+    * {
+        overflow: visible !important;
+        height: auto !important;
+        max-height: none !important;
+        min-height: 0 !important;
+    }
+
+    .app-layout {
+        display: block !important;
+    }
+
+    .editor-panel {
+        width: 100% !important;
+        min-width: 0 !important;
+    }
+
+    .ProseMirror {
+        padding: 0 !important;
+        max-width: 100% !important;
+        background: white !important;
+        color: #1a1a2e !important;
+    }
+
+    /* Ensure images fit within page */
+    .ProseMirror img {
+        max-width: 100% !important;
+        page-break-inside: avoid;
+    }
+
+    /* Avoid breaking inside these elements */
+    h1, h2, h3, h4, h5, h6 {
+        page-break-after: avoid;
+    }
+
+    pre, blockquote, table, figure {
+        page-break-inside: avoid;
+    }
+
+    /* Code blocks with light background */
+    .ProseMirror pre, .ProseMirror code {
+        background: #f8f9fa !important;
+        color: #1a1a2e !important;
+    }
+}

src/app.html

@@ -1,11 +1,14 @@
 <!doctype html>
 <html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		%sveltekit.head%
-	</head>
-	<body data-sveltekit-preload-data="hover">
-		<div style="display: contents">%sveltekit.body%</div>
-	</body>
+    <head>
+        <meta charset="utf-8" />
+        <meta
+            name="viewport"
+            content="width=device-width, initial-scale=1, viewport-fit=cover, user-scalable=no, maximum-scale=1"
+        />
+        %sveltekit.head%
+    </head>
+    <body data-sveltekit-preload-data="hover">
+        <div style="display: contents">%sveltekit.body%</div>
+    </body>
 </html>

src/lib/api.ts

@@ -7,6 +7,7 @@ import type {
   NotebookEntry,
   NoteTitleEntry,
   SearchResult,
+  TrashContents,
   VaultState,
   VaultStats,
   ImportResult,
@@ -38,10 +39,18 @@ export async function setFontFamily(family: string): Promise<void> {
   return invoke("set_font_family", { family });
 }
 
+export async function setLineHeight(height: number): Promise<void> {
+  return invoke("set_line_height", { height });
+}
+
 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,
@@ -60,6 +69,13 @@ export async function deleteNotebook(path: string): Promise<void> {
   return invoke("delete_notebook", { path });
 }
 
+export async function moveNotebook(
+  notebookPath: string,
+  destParent: string,
+): Promise<string> {
+  return invoke("move_notebook", { notebookPath, destParent });
+}
+
 export async function getNotes(
   notebookPath: string | null,
 ): Promise<NoteEntry[]> {
@@ -85,6 +101,10 @@ export async function createNote(
   return invoke("create_note", { notebookRelative, title });
 }
 
+export async function createDailyNote(date?: string): Promise<NoteEntry> {
+  return invoke("create_daily_note", { date: date ?? null });
+}
+
 export async function renameNote(
   path: string,
   newTitle: string,
@@ -111,6 +131,10 @@ export async function getAllNoteTitles(): Promise<NoteTitleEntry[]> {
   return invoke("get_all_note_titles");
 }
 
+export async function getGraphData(): Promise<{ nodes: { title: string; path: string }[]; edges: { source: number; target: number }[] }> {
+  return invoke("get_graph_data");
+}
+
 export async function searchNotes(
   query: string,
   limit?: number,
@@ -122,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");
 }
 
@@ -133,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 });
 }
@@ -149,6 +177,14 @@ export async function saveVaultState(vaultState: VaultState): Promise<void> {
   return invoke("save_vault_state", { vaultState });
 }
 
+export async function readClipboardImage(): Promise<number[]> {
+  return invoke("read_clipboard_image");
+}
+
+export async function copyImageToClipboard(path: string): Promise<void> {
+  return invoke("copy_image_to_clipboard", { path });
+}
+
 export async function saveImage(name: string, data: number[]): Promise<string> {
   return invoke("save_image", { name, data });
 }
@@ -180,6 +216,7 @@ export async function setGeneralSettings(
   pdfHeight: number,
   titleMode: string,
   hideTitleInBody: boolean,
+  showLineNumbers: boolean,
   defaultViewMode: boolean,
   showTrayIcon: boolean,
   closeToTray: boolean,
@@ -194,6 +231,7 @@ export async function setGeneralSettings(
     pdfHeight,
     titleMode,
     hideTitleInBody,
+    showLineNumbers,
     defaultViewMode,
     showTrayIcon,
     closeToTray,
@@ -213,6 +251,10 @@ export async function removeQuickAccess(noteRelative: string): Promise<void> {
   return invoke("remove_quick_access", { noteRelative });
 }
 
+export async function reorderQuickAccess(paths: string[]): Promise<void> {
+  return invoke("reorder_quick_access", { paths });
+}
+
 export async function getVaultStats(): Promise<VaultStats> {
   return invoke("get_vault_stats");
 }
@@ -225,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,
@@ -293,8 +339,9 @@ export async function setAiSettings(
   apiKey: string | null,
   model: string,
   writingStyle: string | null,
+  baseUrl: string | null = null,
 ): Promise<void> {
-  return invoke("set_ai_settings", { provider, apiKey, model, writingStyle });
+  return invoke("set_ai_settings", { provider, apiKey, model, writingStyle, baseUrl });
 }
 
 export async function testAiConnection(): Promise<void> {
@@ -309,3 +356,11 @@ export async function aiAsk(
 ): Promise<void> {
   return invoke("ai_ask", { action, text, customPrompt, requestId });
 }
+
+export async function getInstallType(): Promise<string> {
+  return invoke("get_install_type");
+}
+
+export async function getPendingOpenFile(): Promise<string | null> {
+  return invoke("get_pending_open_file");
+}

src/lib/components/AppLayout.svelte

@@ -20,22 +20,112 @@
 		showCommandPalette,
 		theme,
 		focusMode,
-		activeNote
+		readOnly,
+		activeNote,
+		activeNotePath,
+		activeNotebook,
+		editorDirty,
+		showInfo,
+		showSettings,
+		sourceMode,
+		mobileView,
+		appConfig,
+		quickAccessPaths,
+		tags,
+		notes,
+		viewMode,
+		activeTag,
+		updateAvailable as globalUpdateAvailable,
+		settingsTab,
+		navHistory
 	} from '$lib/stores/app';
 
 	const appWindow = getCurrentWindow();
-	import { loadVaultState, saveVaultState } from '$lib/api';
+	const isMac = navigator.platform.startsWith('Mac');
+	const isMobile = /android|ios/i.test(navigator.userAgent);
+	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';
 	import type { VaultState, FileEvent } from '$lib/types';
 
 	let sidebar: Sidebar;
 	let noteList: NoteList;
 	let editor: Editor;
 	let unlistenFileChange: (() => void) | null = null;
+	let unlistenOpenFile: (() => void) | null = null;
+
+	// Mobile editor header helpers
+	let noteRelativePath = $derived($activeNotePath && $appConfig?.active_vault ? $activeNotePath.replace($appConfig.active_vault + '/', '') : '');
+	let isQuickAccess = $derived(noteRelativePath ? $quickAccessPaths.includes(noteRelativePath) : false);
+	let backupInterval: ReturnType<typeof setInterval> | null = null;
+
+
+
+	function parseFrequencyMs(freq: string): number {
+		switch (freq) {
+			case '6h': return 6 * 60 * 60 * 1000;
+			case '12h': return 12 * 60 * 60 * 1000;
+			case '7d': return 7 * 24 * 60 * 60 * 1000;
+			case '24h': default: return 24 * 60 * 60 * 1000;
+		}
+	}
+
+	async function checkScheduledBackup() {
+		const config = get(appConfig);
+		if (!config?.backup_enabled) return;
+		const interval = parseFrequencyMs(config.backup_frequency);
+		const last = config.last_backup_time ? new Date(config.last_backup_time).getTime() : 0;
+		if (Date.now() - last >= interval) {
+			const unlisten = await listen('backup-done', (event: any) => {
+				if (event.payload?.success) {
+					const cur = get(appConfig);
+					if (cur) appConfig.set({ ...cur, last_backup_time: new Date().toISOString() });
+				}
+				unlisten();
+			});
+			try { await createBackup(); } catch (_) { unlisten(); }
+		}
+	}
+
+	// Track note navigation in history stack
+	$effect(() => {
+		const path = $activeNotePath;
+		if (path) navHistory.push(path);
+	});
+
+	function navigateHistory(direction: -1 | 1) {
+		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(() => {});
+	}
+
+	async function handleOpenFile(filePath: string) {
+		if (!filePath || !filePath.endsWith('.md')) return;
+		const config = get(appConfig);
+		const vaultRoot = config?.active_vault;
+		if (!vaultRoot || !filePath.startsWith(vaultRoot)) return;
+		try {
+			const content = await readNote(filePath);
+			editor?.flushSave();
+			$activeNote = content;
+			$activeNotePath = filePath;
+			$editorDirty = false;
+			editor?.loadNote(filePath, content.content);
+		} catch (e) {
+			console.error('Failed to open file:', e);
+		}
+	}
 
 	const persistState = debounce(async () => {
 		const state: VaultState = {
-			last_open_note: null,
+			last_open_note: $activeNotePath,
 			sidebar_width: $sidebarWidth,
 			notelist_width: $notelistWidth,
 			sidebar_collapsed: $sidebarCollapsed,
@@ -58,39 +148,183 @@
 
 	function handleNoteSelected(path: string, content: string) {
 		editor?.loadNote(path, content);
+		if (isMobile) $mobileView = 'editor';
 	}
 
 	function handleViewChanged() {
-		noteList?.refresh(true);
+		noteList?.refresh();
+		if (isMobile) $mobileView = 'notelist';
 	}
 
 	async function createAndFocusNote() {
 		await noteList?.handleCreateNote();
 		editor?.focusTitle();
+		if (isMobile) $mobileView = 'editor';
+	}
+
+	async function handleDailyNote() {
+		try {
+			const entry = await createDailyNote();
+			const content = await readNote(entry.path);
+			editor?.flushSave();
+			$activeNote = content;
+			$activeNotePath = entry.path;
+			$editorDirty = false;
+			editor?.loadNote(entry.path, content.content);
+			$viewMode = 'daily';
+			noteList?.refresh(true);
+			sidebar?.refresh();
+			if (isMobile) $mobileView = 'editor';
+		} catch (e) {
+			console.error('Failed to create/open daily note:', e);
+		}
+	}
+
+	// Android back gesture / hardware back button support
+	// We maintain a simple counter of how many views deep we are.
+	// sidebar=0, notelist=1, editor=2. Each forward nav pushes, back pops.
+	let historyDepth = 0;
+	let navFromPopstate = false;
+
+	if (isMobile) {
+		history.replaceState({ mobileView: 'sidebar', depth: 0 }, '');
+
+		$effect(() => {
+			const view = $mobileView;
+			if (navFromPopstate) {
+				navFromPopstate = false;
+				return;
+			}
+			const targetDepth = view === 'sidebar' ? 0 : view === 'notelist' ? 1 : 2;
+			if (targetDepth > historyDepth) {
+				// Forward navigation — push entries for each level skipped
+				for (let d = historyDepth + 1; d <= targetDepth; d++) {
+					const v = d === 1 ? 'notelist' : 'editor';
+					history.pushState({ mobileView: v, depth: d }, '');
+				}
+				historyDepth = targetDepth;
+			} else if (targetDepth < historyDepth) {
+				// Programmatic back (e.g. mobileBack button) — go back in history
+				const steps = historyDepth - targetDepth;
+				historyDepth = targetDepth;
+				navFromPopstate = true; // suppress the popstate that history.go triggers
+				history.go(-steps);
+			}
+		});
+
+		window.addEventListener('popstate', (e) => {
+			if (navFromPopstate) {
+				navFromPopstate = false;
+				return;
+			}
+			const state = e.state;
+			const targetDepth = state?.depth ?? 0;
+			historyDepth = targetDepth;
+			navFromPopstate = true;
+			if (targetDepth === 0) $mobileView = 'sidebar';
+			else if (targetDepth === 1) $mobileView = 'notelist';
+			else $mobileView = 'editor';
+		});
+	}
+
+	function mobileBack() {
+		if ($mobileView === 'editor') $mobileView = 'notelist';
+		else if ($mobileView === 'notelist') $mobileView = 'sidebar';
+	}
+
+	function handleMouseDown(e: MouseEvent) {
+		if (e.button === 3) { e.preventDefault(); navigateHistory(-1); }
+		if (e.button === 4) { e.preventDefault(); navigateHistory(1); }
 	}
 
 	function handleKeydown(e: KeyboardEvent) {
-		if (e.ctrlKey && !e.shiftKey && e.key === 'n') {
+		const mod = e.ctrlKey || e.metaKey;
+		const code = e.code;
+		if (e.altKey && e.key === 'ArrowLeft') {
+			e.preventDefault();
+			navigateHistory(-1);
+			return;
+		}
+		if (e.altKey && e.key === 'ArrowRight') {
+			e.preventDefault();
+			navigateHistory(1);
+			return;
+		}
+		if (mod && !e.shiftKey && code === 'KeyN') {
 			e.preventDefault();
 			createAndFocusNote();
+			return;
 		}
-		if (e.ctrlKey && 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 (e.ctrlKey && e.key === 'f') {
+		if (mod && e.shiftKey && code === 'KeyF') {
 			e.preventDefault();
 			$showSearch = true;
+			return;
 		}
-		if (e.ctrlKey && e.key === 'p') {
+		if (mod && !e.shiftKey && code === 'KeyF') {
+			e.preventDefault();
+			if ($activeNotePath) {
+				editor?.openNoteSearch();
+			} else {
+				$showSearch = true;
+			}
+			return;
+		}
+		if (mod && !e.shiftKey && code === 'KeyP') {
 			e.preventDefault();
 			$showCommandPalette = true;
+			return;
 		}
-		if (e.ctrlKey && e.key === 's') {
+		if (mod && !e.shiftKey && code === 'KeyS') {
 			e.preventDefault();
 			editor?.forceSave();
+			return;
+		}
+		if (mod && code === 'KeyK' && !e.shiftKey && $activeNotePath && !$sourceMode) {
+			e.preventDefault();
+			editor?.addLinkFromToolbar();
+		}
+		if (mod && e.shiftKey && code === 'KeyM') {
+			e.preventDefault();
+			$sourceMode = !$sourceMode;
+		}
+		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 ($focusMode) $focusMode = false;
+			if ($showSettings) $showSettings = false;
+			else if ($showInfo) $showInfo = false;
+			else if ($focusMode) $focusMode = false;
 			else if ($showSearch) $showSearch = false;
 			else if ($showCommandPalette) $showCommandPalette = false;
 		}
@@ -113,84 +347,320 @@
 		persistState();
 	});
 
+	$effect(() => {
+		$activeNotePath;
+		persistState();
+	});
+
 	onMount(async () => {
+		let lastNotePath: string | null = null;
 		try {
 			const state = await loadVaultState();
 			$sidebarWidth = state.sidebar_width;
 			$notelistWidth = state.notelist_width;
 			$sidebarCollapsed = state.sidebar_collapsed;
 			$collapsedNotebooks = state.collapsed_notebooks ?? [];
+			lastNotePath = state.last_open_note ?? null;
 		} catch (_) {}
 
+		// On mobile, prefetch last-opened note so first tap is instant
+		let prefetchPromise: Promise<any> | null = null;
+		if (isMobile && lastNotePath) {
+			prefetchPromise = readNote(lastNotePath).catch(() => null);
+		}
+
 		applyTheme($theme);
 
 		window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
 			if ($theme === 'system') applyTheme('system');
 		});
 
-		await sidebar?.refresh();
-		await noteList?.refresh();
+		// Run sidebar and note list refresh in parallel
+		await Promise.all([sidebar?.refresh(), noteList?.refresh()]);
 
-		unlistenFileChange = await listen<FileEvent>('file-changed', async () => {
-			await sidebar?.refresh();
-			await noteList?.refresh(true);
+		// On mobile, derive tags from the scanned notes (avoids a separate full-scan Rust call)
+		if (isMobile) {
+			const tagMap = new Map<string, number>();
+			for (const note of $notes) {
+				for (const tag of note.meta.tags) {
+					tagMap.set(tag, (tagMap.get(tag) ?? 0) + 1);
+				}
+			}
+			$tags = Array.from(tagMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+		}
+
+		// On mobile, auto-load the last-opened note so it's ready when the user taps it
+		if (isMobile && prefetchPromise) {
+			prefetchPromise.then((noteContent) => {
+				if (noteContent && lastNotePath && !$activeNotePath) {
+					$activeNote = noteContent;
+					$activeNotePath = lastNotePath;
+					$editorDirty = false;
+					editor?.loadNote(lastNotePath, noteContent.content);
+				}
+			});
+		}
+
+		if (isMobile) {
+			// Mobile: debounce file-changed heavily and skip when actively editing
+			// (our own saves trigger the watcher, causing expensive refreshes on FUSE)
+			const debouncedRefresh = debounce(async () => {
+				if (get(editorDirty)) return; // user is still typing, skip
+				await Promise.all([sidebar?.refresh(), noteList?.refresh(true)]);
+				// Re-derive tags from refreshed notes
+				const tagMap = new Map<string, number>();
+				for (const note of get(notes)) {
+					for (const tag of note.meta.tags) {
+						tagMap.set(tag, (tagMap.get(tag) ?? 0) + 1);
+					}
+				}
+				tags.set(Array.from(tagMap.entries()).sort((a, b) => a[0].localeCompare(b[0])));
+			}, 3000);
+			unlistenFileChange = await listen<FileEvent>('file-changed', () => {
+				debouncedRefresh();
+			});
+		} else {
+			const debouncedDesktopRefresh = debounce(async () => {
+				await Promise.all([sidebar?.refresh(), noteList?.refresh(true)]);
+			}, 300);
+			unlistenFileChange = await listen<FileEvent>('file-changed', () => {
+				debouncedDesktopRefresh();
+			});
+		}
+
+		// Listen for file open events (from single-instance or OS file associations)
+		unlistenOpenFile = await listen<string>('open-file', async (event) => {
+			await handleOpenFile(event.payload);
 		});
+
+		// Check for pending file from first-launch CLI args
+		try {
+			const pending = await getPendingOpenFile();
+			if (pending) await handleOpenFile(pending);
+		} catch (_) {}
+
+		// Scheduled backup: check on startup and every 5 minutes
+		checkScheduledBackup();
+		backupInterval = setInterval(checkScheduledBackup, 5 * 60 * 1000);
 	});
 
 	onDestroy(() => {
 		unlistenFileChange?.();
+		unlistenOpenFile?.();
+		if (backupInterval) clearInterval(backupInterval);
 	});
 </script>
 
-<svelte:window onkeydown={handleKeydown} />
+<svelte:window onkeydown={handleKeydown} onmousedown={isMobile ? undefined : handleMouseDown} />
 
-<div class="app-shell">
-	{#if $focusMode}
-		<!-- svelte-ignore a11y_no_static_element_interactions -->
-		<div class="focus-topbar" onmousedown={(e) => { if (!(e.target as HTMLElement).closest('button')) appWindow.startDragging(); }}>
-			<span class="focus-title">{$activeNote?.meta.title || 'Untitled'}</span>
-			<div class="focus-controls">
-				<button class="focus-btn focus-active" onclick={() => ($focusMode = false)} title="Exit focus mode (Escape)">
-					<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-						<path d="M8 3v3a2 2 0 01-2 2H3m18 0h-3a2 2 0 01-2-2V3m0 18v-3a2 2 0 012-2h3M3 16h3a2 2 0 012 2v3"/>
+{#if isMobile}
+	<!-- ═══ MOBILE LAYOUT ═══ -->
+	<div class="mobile-shell">
+		<!-- Mobile Header -->
+		<div class="mobile-header">
+			{#if $mobileView !== 'sidebar'}
+				<button class="mobile-header-btn" onclick={mobileBack}>
+					<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+						<path d="M15 18l-6-6 6-6"/>
 					</svg>
 				</button>
-				<button class="focus-btn" onmousedown={(e) => e.stopPropagation()} onclick={() => appWindow.minimize()} title="Minimize">
-					<svg width="10" height="10" viewBox="0 0 10 10"><line x1="1" y1="5" x2="9" y2="5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/></svg>
-				</button>
-				<button class="focus-btn" onmousedown={(e) => e.stopPropagation()} onclick={() => appWindow.toggleMaximize()} title="Maximize">
-					<svg width="10" height="10" viewBox="0 0 10 10"><rect x="1" y="1" width="8" height="8" rx="1" fill="none" stroke="currentColor" stroke-width="1.2"/></svg>
-				</button>
-				<button class="focus-btn focus-close" onmousedown={(e) => e.stopPropagation()} onclick={() => appWindow.close()} title="Close">
-					<svg width="10" height="10" viewBox="0 0 10 10"><line x1="1.5" y1="1.5" x2="8.5" y2="8.5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/><line x1="8.5" y1="1.5" x2="1.5" y2="8.5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/></svg>
-				</button>
+			{:else}
+				<div class="mobile-header-brand">
+					<svg width="22" height="22" viewBox="0 0 48 48" fill="none">
+						<rect width="48" height="48" rx="12" fill="var(--accent)" />
+						<circle cx="16" cy="16" r="3.5" fill="white" opacity="0.9" />
+						<circle cx="32" cy="16" r="3.5" fill="white" opacity="0.9" />
+						<circle cx="16" cy="32" r="3.5" fill="white" opacity="0.9" />
+						<circle cx="32" cy="32" r="3.5" fill="white" opacity="0.9" />
+					</svg>
+				</div>
+			{/if}
+			{#if $mobileView !== 'editor'}
+				<span class="mobile-header-title">
+					{#if $mobileView === 'sidebar'}
+						HelixNotes
+					{:else}
+						{#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'}
+					<button class="mobile-update-badge" onclick={() => { $settingsTab = 'updates'; $showSettings = true; }}>
+						v{$globalUpdateAvailable.version}
+					</button>
+				{/if}
+			{/if}
+			<div class="mobile-header-actions">
+				{#if $mobileView === 'editor'}
+					<button class="mobile-header-btn" class:active={$readOnly} onclick={() => ($readOnly = !$readOnly)} title={$readOnly ? 'Edit' : 'View'}>
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							{#if $readOnly}
+								<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" />
+								<circle cx="12" cy="12" r="3" />
+							{:else}
+								<path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7" />
+								<path d="M18.5 2.5a2.121 2.121 0 013 3L12 15l-4 1 1-4 9.5-9.5z" />
+							{/if}
+						</svg>
+					</button>
+					<button class="mobile-header-btn" onclick={() => editor?.openNoteSearch()} title="Find in note">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/>
+						</svg>
+					</button>
+					<button class="mobile-header-btn" class:active={$activeNote?.meta.pinned} onclick={() => { if ($activeNote) { $activeNote.meta.pinned = !$activeNote.meta.pinned; $editorDirty = true; } }} title="Pin">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<path d="M12 17v5"/><path d="M9 2h6l-1 7h4l-2 4H8l-2-4h4L9 2z"/>
+						</svg>
+					</button>
+					<button class="mobile-header-btn" class:active={isQuickAccess} onclick={async () => {
+						if (!noteRelativePath) return;
+						try {
+							if (isQuickAccess) { await removeQuickAccess(noteRelativePath); } else { await addQuickAccess(noteRelativePath); }
+							$quickAccessPaths = (await getQuickAccess()).map(n => n.relative_path);
+						} catch (e) { console.error('Quick access toggle failed:', e); }
+					}} title="Quick Access">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill={isQuickAccess ? 'currentColor' : 'none'} stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2" />
+						</svg>
+					</button>
+					<button class="mobile-header-btn" onclick={() => editor?.toggleOutlinePanel()} title="Outline">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<line x1="4" y1="6" x2="20" y2="6"/><line x1="8" y1="12" x2="20" y2="12"/><line x1="8" y1="18" x2="20" y2="18"/><circle cx="4" cy="12" r="1" fill="currentColor"/><circle cx="4" cy="18" r="1" fill="currentColor"/>
+						</svg>
+					</button>
+					<button class="mobile-header-btn" onclick={() => editor?.toggleHistoryPanel()} title="History">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/>
+						</svg>
+					</button>
+					{#if $appConfig?.enable_wiki_links}
+					<button class="mobile-header-btn" onclick={() => editor?.toggleGraphView()} title="Graph View">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<circle cx="6" cy="6" r="3"/><circle cx="18" cy="6" r="3"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="18" r="3"/>
+							<line x1="8.5" y1="7.5" x2="15.5" y2="16.5"/><line x1="15.5" y1="7.5" x2="8.5" y2="16.5"/>
+						</svg>
+					</button>
+					{/if}
+					{#if $appConfig?.ai_provider && ($appConfig?.ai_provider === 'ollama' || $appConfig?.ai_api_key || $appConfig?.openai_api_key)}
+					<button class="mobile-header-btn" onclick={() => editor?.triggerAiMenu()} title="AI Actions">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<path d="M12 8V4l-2-2"/><rect x="4" y="8" width="16" height="12" rx="2"/><path d="M2 14h2"/><path d="M20 14h2"/><path d="M9 13v2"/><path d="M15 13v2"/>
+						</svg>
+					</button>
+					{/if}
+					<button class="mobile-header-btn" class:active={$sourceMode} onclick={() => ($sourceMode = !$sourceMode)} title={$sourceMode ? 'Rich Editor' : 'Source Mode'}>
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<polyline points="16 18 22 12 16 6" /><polyline points="8 6 2 12 8 18" />
+						</svg>
+					</button>
+				{:else}
+					<button class="mobile-header-btn" onclick={() => ($showSearch = true)} title="Search">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<circle cx="11" cy="11" r="8" />
+							<line x1="21" y1="21" x2="16.65" y2="16.65" />
+						</svg>
+					</button>
+						<button class="mobile-header-btn" onclick={handleDailyNote} title="Daily Note">
+						<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>
+					</button>
+					<button class="mobile-header-btn" onclick={() => ($showSettings = true)} title="Settings">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<circle cx="12" cy="12" r="3" />
+							<path d="M19.4 15a1.65 1.65 0 00.33 1.82l.06.06a2 2 0 01-2.83 2.83l-.06-.06a1.65 1.65 0 00-1.82-.33 1.65 1.65 0 00-1 1.51V21a2 2 0 01-4 0v-.09A1.65 1.65 0 009 19.4a1.65 1.65 0 00-1.82.33l-.06.06a2 2 0 01-2.83-2.83l.06-.06A1.65 1.65 0 004.68 15a1.65 1.65 0 00-1.51-1H3a2 2 0 010-4h.09A1.65 1.65 0 004.6 9a1.65 1.65 0 00-.33-1.82l-.06-.06a2 2 0 012.83-2.83l.06.06A1.65 1.65 0 009 4.68a1.65 1.65 0 001-1.51V3a2 2 0 014 0v.09a1.65 1.65 0 001 1.51 1.65 1.65 0 001.82-.33l.06-.06a2 2 0 012.83 2.83l-.06.06A1.65 1.65 0 0019.4 9a1.65 1.65 0 001.51 1H21a2 2 0 010 4h-.09a1.65 1.65 0 00-1.51 1z" />
+						</svg>
+					</button>
+				{/if}
 			</div>
 		</div>
-	{:else}
-		<TitleBar onNewNote={createAndFocusNote} />
-	{/if}
-	<div class="app-layout">
-		{#if !$focusMode}
-			<div class="sidebar-panel" style="width: {$sidebarCollapsed ? 44 : $sidebarWidth}px">
+
+		<!-- Mobile Content -->
+		<div class="mobile-content">
+			<div class="mobile-panel" class:active={$mobileView === 'sidebar'}>
 				<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()} 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" />
+					</svg>
+				</button>
+			</div>
+			<div class="mobile-panel" class:active={$mobileView === 'editor'}>
+				<Editor bind:this={editor} />
+			</div>
+		</div>
 
-			{#if !$sidebarCollapsed}
-				<ResizeHandle onResize={handleSidebarResize} />
+	</div>
+{:else}
+	<!-- ═══ DESKTOP LAYOUT ═══ -->
+	<div class="app-shell">
+		{#if $focusMode}
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+			<div class="focus-topbar" class:macos={isMac} onmousedown={(e) => { if (!(e.target as HTMLElement).closest('button')) appWindow.startDragging(); }}>
+				<span class="focus-title">{$activeNote?.meta.title || 'Untitled'}</span>
+				<div class="focus-controls">
+					<button class="focus-btn focus-active" onclick={() => ($focusMode = false)} title="Exit focus mode (Escape)">
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<path d="M8 3v3a2 2 0 01-2 2H3m18 0h-3a2 2 0 01-2-2V3m0 18v-3a2 2 0 012-2h3M3 16h3a2 2 0 012 2v3"/>
+						</svg>
+					</button>
+					<button class="focus-btn" class:focus-active={$readOnly} onclick={() => ($readOnly = !$readOnly)} title={$readOnly ? 'Switch to Edit Mode' : 'Switch to View Mode'}>
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							{#if $readOnly}
+								<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" />
+								<circle cx="12" cy="12" r="3" />
+							{:else}
+								<path d="M17.94 17.94A10.07 10.07 0 0112 20c-7 0-11-8-11-8a18.45 18.45 0 015.06-5.94" />
+								<path d="M9.9 4.24A9.12 9.12 0 0112 4c7 0 11 8 11 8a18.5 18.5 0 01-2.16 3.19" />
+								<line x1="1" y1="1" x2="23" y2="23" />
+							{/if}
+						</svg>
+					</button>
+					{#if !isMac}
+					<button class="focus-btn" onmousedown={(e) => e.stopPropagation()} onclick={() => appWindow.minimize()} title="Minimize">
+						<svg width="10" height="10" viewBox="0 0 10 10"><line x1="1" y1="5" x2="9" y2="5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/></svg>
+					</button>
+					<button class="focus-btn" onmousedown={(e) => e.stopPropagation()} onclick={() => appWindow.toggleMaximize()} title="Maximize">
+						<svg width="10" height="10" viewBox="0 0 10 10"><rect x="1" y="1" width="8" height="8" rx="1" fill="none" stroke="currentColor" stroke-width="1.2"/></svg>
+					</button>
+					<button class="focus-btn focus-close" onmousedown={(e) => e.stopPropagation()} onclick={() => appWindow.close()} title="Close">
+						<svg width="10" height="10" viewBox="0 0 10 10"><line x1="1.5" y1="1.5" x2="8.5" y2="8.5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/><line x1="8.5" y1="1.5" x2="1.5" y2="8.5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/></svg>
+					</button>
+					{/if}
+				</div>
+			</div>
+		{:else}
+			<TitleBar onNewNote={createAndFocusNote} onDailyNote={handleDailyNote} />
+		{/if}
+		<div class="app-layout">
+			{#if !$focusMode}
+				<div class="sidebar-panel" style="width: {$sidebarCollapsed ? 44 : $sidebarWidth}px">
+					<Sidebar bind:this={sidebar} onViewChanged={handleViewChanged} />
+				</div>
+
+				{#if !$sidebarCollapsed}
+					<ResizeHandle onResize={handleSidebarResize} />
+				{/if}
+
+				<div class="notelist-panel" style="width: {$notelistWidth}px">
+					<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => editor?.focusTitle()} />
+				</div>
+
+				<ResizeHandle onResize={handleNotelistResize} />
 			{/if}
 
-			<div class="notelist-panel" style="width: {$notelistWidth}px">
-				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onNoteMoved={() => sidebar?.refresh()} />
+			<div class="editor-panel">
+				<Editor bind:this={editor} />
 			</div>
-
-			<ResizeHandle onResize={handleNotelistResize} />
-		{/if}
-
-		<div class="editor-panel">
-			<Editor bind:this={editor} />
 		</div>
 	</div>
-</div>
+{/if}
 
 <SearchPanel />
 <CommandPalette />
@@ -198,6 +668,7 @@
 <InfoPanel />
 
 <style>
+	/* ═══ DESKTOP STYLES ═══ */
 	.app-shell {
 		display: flex;
 		flex-direction: column;
@@ -285,4 +756,137 @@
 		background: #e81123;
 		color: white;
 	}
+
+	.focus-topbar.macos {
+		padding-left: 78px;
+	}
+
+	/* ═══ MOBILE STYLES ═══ */
+	.mobile-shell {
+		display: flex;
+		flex-direction: column;
+		height: 100vh;
+		overflow: hidden;
+		background: var(--bg-primary);
+	}
+
+	.mobile-header {
+		display: flex;
+		align-items: center;
+		height: 52px;
+		padding: 0 8px;
+		background: var(--bg-secondary);
+		border-bottom: 1px solid var(--border-color);
+		flex-shrink: 0;
+		gap: 4px;
+	}
+
+	.mobile-header-brand {
+		display: flex;
+		align-items: center;
+		padding: 0 8px;
+	}
+
+	.mobile-header-title {
+		flex: 1;
+		font-size: 17px;
+		font-weight: 600;
+		color: var(--text-primary);
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		padding: 0 4px;
+	}
+
+	.mobile-update-badge {
+		background: var(--accent);
+		color: white;
+		border: none;
+		border-radius: 10px;
+		padding: 2px 8px;
+		font-size: 11px;
+		font-weight: 600;
+		font-family: inherit;
+		cursor: pointer;
+		white-space: nowrap;
+		flex-shrink: 0;
+	}
+
+	.mobile-header-actions {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+		margin-left: auto;
+	}
+
+	.mobile-header-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 34px;
+		height: 34px;
+		border: none;
+		background: none;
+		color: var(--text-secondary);
+		border-radius: 8px;
+		cursor: pointer;
+	}
+
+	.mobile-header-btn svg {
+		width: 16px;
+		height: 16px;
+	}
+
+	.mobile-header-btn:active {
+		background: var(--bg-hover);
+	}
+
+	.mobile-header-btn.active {
+		color: var(--accent);
+	}
+
+	.mobile-content {
+		flex: 1;
+		overflow: hidden;
+		position: relative;
+	}
+
+	.mobile-panel {
+		position: absolute;
+		inset: 0;
+		overflow: hidden;
+		visibility: hidden;
+		pointer-events: none;
+		display: flex;
+		flex-direction: column;
+	}
+
+	.mobile-panel.active {
+		visibility: visible;
+		pointer-events: auto;
+	}
+
+	.mobile-fab {
+		position: absolute;
+		bottom: 24px;
+		right: 20px;
+		width: 56px;
+		height: 56px;
+		border-radius: 16px;
+		background: var(--accent);
+		color: white;
+		border: none;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		box-shadow: 0 4px 12px rgba(0, 0, 0, 0.25);
+		cursor: pointer;
+		z-index: 10;
+	}
+
+	.mobile-fab:active {
+		transform: scale(0.93);
+		box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+	}
+
 </style>

src/lib/components/CommandPalette.svelte

@@ -9,6 +9,8 @@
 		action: () => void;
 	}
 
+	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
+
 	let query = $state('');
 	let selectedIndex = $state(0);
 	let inputEl = $state<HTMLInputElement>(null!);
@@ -17,7 +19,7 @@
 		{
 			id: 'search',
 			label: 'Search Notes',
-			shortcut: 'Ctrl+F',
+			shortcut: `${modKey}+F`,
 			action: () => {
 				$showCommandPalette = false;
 				$showSearch = true;

src/lib/components/InfoPanel.svelte

@@ -1,12 +1,15 @@
 <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';
 
+	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
+	const isMobile = /android|ios/i.test(navigator.userAgent);
+
 	let stats = $state<VaultStats | null>(null);
-	let activeTab = $state<'about' | 'shortcuts'>('shortcuts');
+	let activeTab = $state<'about' | 'shortcuts'>(isMobile ? 'about' : 'shortcuts');
 	let appVersion = $state('...');
 
 	getVersion().then(v => appVersion = v).catch(() => appVersion = '0.0.0');
@@ -52,10 +55,12 @@
 			</div>
 
 			<div class="info-body">
+				{#if !isMobile}
 				<div class="info-tabs">
 					<button class="info-tab" class:active={activeTab === 'shortcuts'} onclick={() => activeTab = 'shortcuts'}>Shortcuts</button>
 					<button class="info-tab" class:active={activeTab === 'about'} onclick={() => activeTab = 'about'}>About</button>
 				</div>
+				{/if}
 
 				{#if activeTab === 'about'}
 					<div class="info-logo">
@@ -71,7 +76,7 @@
 					</div>
 					<h3 class="app-name">HelixNotes</h3>
 					<p class="app-version">v{appVersion}</p>
-					<p class="app-description">A local-first markdown note-taking app.</p>
+					<p class="app-description">A local markdown note-taking app.</p>
 
 					{#if stats}
 						<div class="info-stats">
@@ -111,17 +116,37 @@
 					</div>
 				{:else}
 					<div class="shortcuts-section">
-						<h4 class="shortcuts-group-title">Keyboard Shortcuts</h4>
-						<div class="shortcut-row"><span class="shortcut-desc">New note</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>N</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Quick open</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>P</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Search</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>F</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Save</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>S</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Bold</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>B</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Italic</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>I</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Underline</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>U</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Undo</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>Z</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Redo</span><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd></span></div>
-						<div class="shortcut-row"><span class="shortcut-desc">Exit focus mode</span><span class="shortcut-keys"><kbd>Esc</kbd></span></div>
+						<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">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">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>
@@ -159,7 +184,8 @@
 		border-radius: 16px;
 		box-shadow: var(--shadow-lg);
 		width: 500px;
-		max-height: 80vh;
+		height: 80vh;
+		max-height: 600px;
 		overflow: hidden;
 		display: flex;
 		flex-direction: column;
@@ -196,7 +222,7 @@
 	}
 
 	.info-body {
-		padding: 0 24px 32px;
+		padding: 0 24px 16px;
 		display: flex;
 		flex-direction: column;
 		align-items: center;
@@ -239,6 +265,7 @@
 	}
 
 	.info-logo {
+		margin-top: 12px;
 		margin-bottom: 8px;
 	}
 
@@ -389,4 +416,19 @@
 		color: var(--text-tertiary);
 		line-height: 1.4;
 	}
+
+	/* Mobile */
+	@media (max-width: 600px) {
+		.info-panel {
+			width: 100%;
+			height: 100%;
+			max-height: 100%;
+			border-radius: 0;
+			border: none;
+		}
+
+		.info-header {
+			padding-top: calc(env(safe-area-inset-top, 12px) + 12px);
+		}
+	}
 </style>

src/lib/components/NoteWindow.svelte

@@ -0,0 +1,327 @@
+<script lang="ts">
+	import { onMount, onDestroy } from 'svelte';
+	import { listen } from '@tauri-apps/api/event';
+	import { getCurrentWindow } from '@tauri-apps/api/window';
+	import Editor from './Editor.svelte';
+	import {
+		activeNote,
+		activeNotePath,
+		editorDirty,
+		readOnly,
+		sourceMode,
+		theme
+	} from '$lib/stores/app';
+	import { readNote } from '$lib/api';
+	import type { FileEvent } from '$lib/types';
+
+	let { notePath }: { notePath: string } = $props();
+
+	const appWindow = getCurrentWindow();
+	const isMac = navigator.platform.startsWith('Mac');
+	let editor = $state<Editor>(null!);
+	let unlistenFileChange: (() => void) | null = null;
+	let maximized = $state(false);
+	let loadError = $state<string | null>(null);
+
+	async function checkMaximized() {
+		maximized = await appWindow.isMaximized();
+	}
+
+	$effect(() => {
+		checkMaximized();
+		const unlisten = appWindow.onResized(() => checkMaximized());
+		return () => { unlisten.then(fn => fn()); };
+	});
+
+	$effect(() => {
+		const themeValue = $theme || 'system';
+		const root = document.documentElement;
+		root.classList.remove('dark');
+		if (themeValue === 'dark' || (themeValue === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
+			root.classList.add('dark');
+		}
+	});
+
+	let lastMouseDown = 0;
+	const RESIZE_EDGE = 6;
+
+	function handleMouseDown(e: MouseEvent) {
+		if (e.button !== 0) return;
+		const target = e.target as HTMLElement;
+		if (target.closest('.titlebar-controls') || target.closest('.titlebar-actions')) return;
+
+		if (!maximized) {
+			const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+			if (e.clientY - rect.top < RESIZE_EDGE || e.clientX - rect.left < RESIZE_EDGE) return;
+		}
+
+		const now = Date.now();
+		if (now - lastMouseDown < 300) {
+			appWindow.toggleMaximize();
+			lastMouseDown = 0;
+			return;
+		}
+		lastMouseDown = now;
+		appWindow.startDragging();
+	}
+
+	function handleKeydown(e: KeyboardEvent) {
+		const mod = e.ctrlKey || e.metaKey;
+		if (mod && !e.shiftKey && e.code === 'KeyS') {
+			e.preventDefault();
+			editor?.forceSave();
+			return;
+		}
+		if (mod && e.shiftKey && e.code === 'KeyM') {
+			e.preventDefault();
+			$sourceMode = !$sourceMode;
+		}
+	}
+
+	onMount(async () => {
+		try {
+			const content = await readNote(notePath);
+			$activeNote = content;
+			$activeNotePath = notePath;
+			$editorDirty = false;
+			setTimeout(() => {
+				editor?.loadNote(notePath, content.content);
+				appWindow.setTitle(`${content.meta.title} - HelixNotes`);
+			}, 50);
+		} catch (e) {
+			loadError = String(e);
+		}
+
+		unlistenFileChange = await listen<FileEvent>('file-changed', async (event) => {
+			if (event.payload.path === notePath && event.payload.event_type === 'modify') {
+				if (!$editorDirty) {
+					try {
+						const content = await readNote(notePath);
+						$activeNote = content;
+						editor?.loadNote(notePath, content.content);
+					} catch (_) {}
+				}
+			}
+		});
+	});
+
+	onDestroy(() => {
+		unlistenFileChange?.();
+	});
+</script>
+
+<svelte:window onkeydown={handleKeydown} />
+
+<div class="note-window">
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div class="nw-titlebar" class:macos={isMac} onmousedown={handleMouseDown}>
+		<div class="nw-titlebar-brand">
+			<svg width="14" height="14" viewBox="0 0 48 48" fill="none">
+				<rect width="48" height="48" rx="12" fill="var(--accent)" />
+				<circle cx="16" cy="16" r="3.5" fill="white" opacity="0.9" />
+				<circle cx="32" cy="16" r="3.5" fill="white" opacity="0.9" />
+				<circle cx="16" cy="32" r="3.5" fill="white" opacity="0.9" />
+				<circle cx="32" cy="32" r="3.5" fill="white" opacity="0.9" />
+				<line x1="19" y1="18" x2="29" y2="30" stroke="white" stroke-width="2" stroke-linecap="round" opacity="0.7" />
+				<line x1="29" y1="18" x2="19" y2="30" stroke="white" stroke-width="2" stroke-linecap="round" opacity="0.7" />
+			</svg>
+			<span class="nw-title">{$activeNote?.meta.title || 'Loading...'}</span>
+			{#if $editorDirty}
+				<span class="nw-dirty-dot" title="Unsaved changes"></span>
+			{/if}
+		</div>
+		<div class="titlebar-actions">
+			<button class="nw-btn" class:active={$sourceMode} onclick={() => ($sourceMode = !$sourceMode)} title="Toggle Source Mode">
+				<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="16 18 22 12 16 6" /><polyline points="8 6 2 12 8 18" />
+				</svg>
+			</button>
+			<button class="nw-btn" class:active={$readOnly} onclick={() => ($readOnly = !$readOnly)} title={$readOnly ? 'Switch to Edit Mode' : 'Switch to View Mode'}>
+				<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+					{#if $readOnly}
+						<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" />
+						<circle cx="12" cy="12" r="3" />
+					{:else}
+						<path d="M17.94 17.94A10.07 10.07 0 0112 20c-7 0-11-8-11-8a18.45 18.45 0 015.06-5.94" />
+						<path d="M9.9 4.24A9.12 9.12 0 0112 4c7 0 11 8 11 8a18.5 18.5 0 01-2.16 3.19" />
+						<line x1="1" y1="1" x2="23" y2="23" />
+					{/if}
+				</svg>
+			</button>
+		</div>
+		{#if !isMac}
+		<div class="titlebar-controls">
+			<button class="titlebar-btn" onclick={() => appWindow.minimize()} title="Minimize">
+				<svg width="10" height="10" viewBox="0 0 10 10">
+					<line x1="1" y1="5" x2="9" y2="5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" />
+				</svg>
+			</button>
+			<button class="titlebar-btn" onclick={() => appWindow.toggleMaximize()} title={maximized ? 'Restore' : 'Maximize'}>
+				{#if maximized}
+					<svg width="10" height="10" viewBox="0 0 10 10">
+						<rect x="2.5" y="0.5" width="7" height="7" rx="1" fill="none" stroke="currentColor" stroke-width="1.2" />
+						<rect x="0.5" y="2.5" width="7" height="7" rx="1" fill="var(--bg-secondary)" stroke="currentColor" stroke-width="1.2" />
+					</svg>
+				{:else}
+					<svg width="10" height="10" viewBox="0 0 10 10">
+						<rect x="1" y="1" width="8" height="8" rx="1" fill="none" stroke="currentColor" stroke-width="1.2" />
+					</svg>
+				{/if}
+			</button>
+			<button class="titlebar-btn titlebar-close" onclick={() => appWindow.close()} title="Close">
+				<svg width="10" height="10" viewBox="0 0 10 10">
+					<line x1="1.5" y1="1.5" x2="8.5" y2="8.5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" />
+					<line x1="8.5" y1="1.5" x2="1.5" y2="8.5" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" />
+				</svg>
+			</button>
+		</div>
+		{/if}
+	</div>
+
+	{#if loadError}
+		<div class="nw-error">
+			<p>Failed to load note</p>
+			<p class="nw-error-detail">{loadError}</p>
+		</div>
+	{:else}
+		<div class="nw-editor">
+			<Editor bind:this={editor} />
+		</div>
+	{/if}
+</div>
+
+<style>
+	.note-window {
+		display: flex;
+		flex-direction: column;
+		height: 100vh;
+		background: var(--bg-primary);
+	}
+
+	.nw-titlebar {
+		display: flex;
+		align-items: center;
+		height: 34px;
+		background: var(--bg-secondary);
+		border-bottom: 1px solid var(--border-color);
+		user-select: none;
+		flex-shrink: 0;
+		-webkit-app-region: drag;
+	}
+
+	.nw-titlebar.macos {
+		padding-left: 78px;
+	}
+
+	.nw-titlebar-brand {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		padding-left: 14px;
+		pointer-events: none;
+		flex: 1;
+		min-width: 0;
+	}
+
+	.nw-title {
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--text-tertiary);
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.nw-dirty-dot {
+		width: 6px;
+		height: 6px;
+		border-radius: 50%;
+		background: var(--accent);
+		flex-shrink: 0;
+	}
+
+	.titlebar-actions {
+		display: flex;
+		align-items: center;
+		gap: 4px;
+		margin-right: 8px;
+		-webkit-app-region: no-drag;
+	}
+
+	.nw-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 28px;
+		height: 28px;
+		border: none;
+		border-radius: 7px;
+		background: var(--bg-hover);
+		color: var(--text-secondary);
+		cursor: pointer;
+		transition: background 0.15s, color 0.15s;
+	}
+
+	.nw-btn:hover {
+		background: var(--bg-tertiary, var(--bg-hover));
+		color: var(--text-primary);
+	}
+
+	.nw-btn.active {
+		background: color-mix(in srgb, var(--accent) 18%, transparent);
+		color: var(--accent);
+	}
+
+	.titlebar-controls {
+		display: flex;
+		height: 100%;
+		-webkit-app-region: no-drag;
+	}
+
+	.titlebar-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 38px;
+		height: 100%;
+		border: none;
+		background: none;
+		color: var(--text-tertiary);
+		cursor: pointer;
+		transition: background 0.1s, color 0.1s;
+	}
+
+	.titlebar-btn:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
+	.titlebar-close:hover {
+		background: #e81123;
+		color: white;
+	}
+
+	.nw-editor {
+		flex: 1;
+		overflow: hidden;
+	}
+
+	.nw-error {
+		flex: 1;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		gap: 8px;
+		color: var(--text-secondary);
+		font-size: 14px;
+	}
+
+	.nw-error-detail {
+		font-size: 12px;
+		color: var(--text-tertiary);
+		max-width: 400px;
+		text-align: center;
+		word-break: break-word;
+	}
+</style>

src/lib/components/ResizeHandle.svelte

@@ -2,23 +2,35 @@
 	let { onResize }: { onResize: (delta: number) => void } = $props();
 	let active = $state(false);
 	let startX = 0;
+	let rafId = 0;
+	let pendingDelta = 0;
 
 	function onMouseDown(e: MouseEvent) {
 		e.preventDefault();
 		active = true;
 		startX = e.clientX;
+		document.body.classList.add('resizing');
 		window.addEventListener('mousemove', onMouseMove);
 		window.addEventListener('mouseup', onMouseUp);
 	}
 
 	function onMouseMove(e: MouseEvent) {
-		const delta = e.clientX - startX;
+		pendingDelta += e.clientX - startX;
 		startX = e.clientX;
-		onResize(delta);
+		if (!rafId) {
+			rafId = requestAnimationFrame(() => {
+				onResize(pendingDelta);
+				pendingDelta = 0;
+				rafId = 0;
+			});
+		}
 	}
 
 	function onMouseUp() {
 		active = false;
+		document.body.classList.remove('resizing');
+		if (rafId) { cancelAnimationFrame(rafId); rafId = 0; }
+		if (pendingDelta) { onResize(pendingDelta); pendingDelta = 0; }
 		window.removeEventListener('mousemove', onMouseMove);
 		window.removeEventListener('mouseup', onMouseUp);
 	}

src/lib/components/SearchPanel.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { showSearch, activeNote, activeNotePath, editorDirty, appConfig } from '$lib/stores/app';
+	import { showSearch, activeNote, activeNotePath, editorDirty, appConfig, mobileView } from '$lib/stores/app';
 	import { searchNotes, readNote } from '$lib/api';
 	import { debounce } from '$lib/utils/debounce';
 	import type { SearchResult } from '$lib/types';
@@ -83,6 +83,8 @@
 		return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 	}
 
+	const isMobile = /android|ios/i.test(navigator.userAgent);
+
 	async function openResult(result: SearchResult) {
 		try {
 			const content = await readNote(result.path);
@@ -90,6 +92,7 @@
 			$activeNotePath = result.path;
 			$editorDirty = false;
 			$showSearch = false;
+			if (isMobile) $mobileView = 'editor';
 		} catch (e) {
 			console.error('Failed to open search result:', e);
 		}
@@ -118,7 +121,7 @@
 					oninput={handleInput}
 					onkeydown={handleKeydown}
 				/>
-				<kbd class="search-esc">Esc</kbd>
+				{#if !isMobile}<kbd class="search-esc">Esc</kbd>{/if}
 			</div>
 
 			{#if results.length > 0}

src/lib/components/SettingsPanel.svelte

@@ -1,12 +1,14 @@
 <script lang="ts">
-	import { showSettings, theme, appConfig } from '$lib/stores/app';
-	import { setTheme, setAccentColor, setFontSize, setFontFamily, setGeneralSettings, importObsidian, createBackup, listBackups, restoreBackup, deleteBackup, setBackupSettings, setAiSettings, testAiConnection } from '$lib/api';
+	import { showSettings, theme, appConfig, updateAvailable as globalUpdateAvailable, updateObj as globalUpdateObj, installType, settingsTab, vaultReady, androidApkUrl, checkForUpdateMobile } from '$lib/stores/app';
+	import { setTheme, setAccentColor, setFontSize, setFontFamily, setLineHeight, setGeneralSettings, importObsidian, createBackup, listBackups, restoreBackup, deleteBackup, setBackupSettings, setAiSettings, testAiConnection } from '$lib/api';
 	import { open as openDialog } from '@tauri-apps/plugin-dialog';
 	import { listen } from '@tauri-apps/api/event';
-	import { check as checkUpdate } from '@tauri-apps/plugin-updater';
 	import { getVersion } from '@tauri-apps/api/app';
+	import { openUrl } from '$lib/api';
 	import type { ImportResult, BackupEntry } from '$lib/types';
 
+	const isMobile = /android|ios/i.test(navigator.userAgent);
+
 	type Tab = 'general' | 'editor' | 'styling' | 'import' | 'backup' | 'ai' | 'updates';
 	let activeTab = $state<Tab>('styling');
 
@@ -24,18 +26,57 @@
 	}
 	loadAppVersion();
 
+	// Switch to requested tab if set externally (e.g. from update badge)
+	$effect(() => {
+		const tab = $settingsTab;
+		if (tab) {
+			activeTab = tab as Tab;
+			$settingsTab = null;
+		}
+	});
+
+	// Pre-populate from global store if update was already detected at startup
+	$effect(() => {
+		const global = $globalUpdateAvailable;
+		if (global && !updateAvailable) {
+			updateAvailable = { version: global.version, body: global.body };
+		}
+	});
+
+	// Pre-populate updater object from global store so Download & Install works without manual check
+	$effect(() => {
+		const obj = $globalUpdateObj;
+		if (obj && !updateObj) {
+			updateObj = obj;
+		}
+	});
+
 	async function handleCheckUpdate() {
 		updateChecking = true;
 		updateMessage = null;
 		updateAvailable = null;
 		try {
-			const update = await checkUpdate();
-			if (update) {
-				updateObj = update;
-				updateAvailable = { version: update.version, body: update.body, date: update.date };
-				updateMessage = { type: 'info', text: `Version ${update.version} is available!` };
+			if (isMobile) {
+				await checkForUpdateMobile();
+				const global = $globalUpdateAvailable;
+				if (global) {
+					updateAvailable = { version: global.version, body: global.body };
+					updateMessage = { type: 'info', text: `Version ${global.version} is available!` };
+				} else {
+					updateMessage = { type: 'success', text: 'You are on the latest version.' };
+				}
 			} else {
-				updateMessage = { type: 'success', text: 'You are on the latest version.' };
+				const { check: checkUpdate } = await import('@tauri-apps/plugin-updater');
+				const update = await checkUpdate();
+				if (update) {
+					updateObj = update;
+					$globalUpdateObj = update;
+					updateAvailable = { version: update.version, body: update.body, date: update.date };
+					globalUpdateAvailable.set({ version: update.version, body: update.body });
+					updateMessage = { type: 'info', text: `Version ${update.version} is available!` };
+				} else {
+					updateMessage = { type: 'success', text: 'You are on the latest version.' };
+				}
 			}
 		} catch (e) {
 			updateMessage = { type: 'error', text: `Failed to check: ${e}` };
@@ -177,18 +218,20 @@
 	let aiProvider = $state<string | null>($appConfig?.ai_provider ?? null);
 	let aiApiKey = $derived.by(() => {
 		if (aiProvider === 'openai') return _openaiKey;
+		if (aiProvider === 'ollama') return '';
 		return _anthropicKey;
 	});
 	let _anthropicKey = $state($appConfig?.ai_api_key ?? '');
 	let _openaiKey = $state($appConfig?.openai_api_key ?? '');
-	let aiModel = $state($appConfig?.ai_model ?? 'claude-sonnet-4-5-20250929');
+	let _ollamaBaseUrl = $state($appConfig?.ollama_base_url ?? 'http://localhost:11434');
+	let aiModel = $state($appConfig?.ai_model ?? 'claude-sonnet-4-6');
 	let aiWritingStyle = $state($appConfig?.ai_writing_style ?? '');
 	let aiShowKey = $state(false);
 	let aiTestLoading = $state(false);
 	let aiTestMessage = $state<{ type: 'success' | 'error'; text: string } | null>(null);
 
 	const anthropicModels = [
-		{ value: 'claude-sonnet-4-5-20250929', label: 'Claude Sonnet 4.5', desc: 'Balanced' },
+		{ value: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6', desc: 'Balanced' },
 		{ value: 'claude-opus-4-6', label: 'Claude Opus 4.6', desc: 'Most capable' },
 		{ value: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', desc: 'Fast' },
 	];
@@ -201,13 +244,15 @@
 	let aiModels = $derived(aiProvider === 'openai' ? openaiModels : anthropicModels);
 
 	async function saveAiSettings() {
-		await setAiSettings(aiProvider, aiApiKey || null, aiModel, aiWritingStyle || null);
+		const baseUrl = aiProvider === 'ollama' ? (_ollamaBaseUrl || null) : null;
+		await setAiSettings(aiProvider, aiApiKey || null, aiModel, aiWritingStyle || null, baseUrl);
 		if ($appConfig) {
 			$appConfig = {
 				...$appConfig,
 				ai_provider: aiProvider,
 				ai_api_key: _anthropicKey || null,
 				openai_api_key: _openaiKey || null,
+				ollama_base_url: _ollamaBaseUrl || null,
 				ai_model: aiModel,
 				ai_writing_style: aiWritingStyle || null,
 			};
@@ -266,9 +311,17 @@
 		{ name: 'Mono', value: 'mono', stack: '"JetBrains Mono", "Fira Code", "Cascadia Code", monospace' },
 	];
 
+	const lineHeightPresets = [
+		{ label: 'Tight', value: 1.4 },
+		{ label: 'Default', value: 1.6 },
+		{ label: 'Relaxed', value: 1.8 },
+		{ label: 'Loose', value: 2.0 },
+	];
+
 	let activeAccent = $state($appConfig?.accent_color ?? 'Indigo');
 	let activeFontSize = $state($appConfig?.font_size ?? 14);
 	let activeFontFamily = $state($appConfig?.font_family ?? 'system');
+	let activeLineHeight = $state($appConfig?.line_height ?? 1.6);
 
 	// General settings
 	let compactNotes = $state($appConfig?.compact_notes ?? false);
@@ -281,6 +334,7 @@
 	let pdfHeight = $state($appConfig?.pdf_height ?? 600);
 	let titleMode = $state($appConfig?.title_mode ?? 'input');
 	let hideTitleInBody = $state($appConfig?.hide_title_in_body ?? false);
+	let showLineNumbers = $state($appConfig?.show_line_numbers ?? false);
 	let defaultViewMode = $state($appConfig?.default_view_mode ?? false);
 	let showTrayIcon = $state($appConfig?.show_tray_icon ?? false);
 	let closeToTray = $state($appConfig?.close_to_tray ?? false);
@@ -333,12 +387,13 @@
 			$appConfig.pdf_height = pdfHeight;
 			$appConfig.title_mode = titleMode;
 			$appConfig.hide_title_in_body = hideTitleInBody;
+			$appConfig.show_line_numbers = showLineNumbers;
 			$appConfig.default_view_mode = defaultViewMode;
 			$appConfig.show_tray_icon = showTrayIcon;
 			$appConfig.close_to_tray = closeToTray;
 			$appConfig.enable_wiki_links = enableWikiLinks;
 		}
-		setGeneralSettings(compactNotes, timeFormat, gpuAcceleration, autostart, pdfPreview, pdfHeight, titleMode, hideTitleInBody, defaultViewMode, showTrayIcon, closeToTray, enableWikiLinks)
+		setGeneralSettings(compactNotes, timeFormat, gpuAcceleration, autostart, pdfPreview, pdfHeight, titleMode, hideTitleInBody, showLineNumbers, defaultViewMode, showTrayIcon, closeToTray, enableWikiLinks)
 			.catch((e) => console.error('Failed to save general settings:', e));
 	}
 
@@ -393,6 +448,17 @@
 		document.documentElement.style.setProperty('--editor-font-family', stack);
 	}
 
+	function selectLineHeight(value: number) {
+		activeLineHeight = value;
+		applyLineHeight(value);
+		if ($appConfig) $appConfig.line_height = value;
+		setLineHeight(value).catch((e) => console.error('Failed to save line height:', e));
+	}
+
+	function applyLineHeight(value: number) {
+		document.documentElement.style.setProperty('--editor-line-height', String(value));
+	}
+
 	function close() {
 		// Ensure AI settings are saved when closing (in case input wasn't blurred)
 		// Only save if the key differs from what's already stored
@@ -425,6 +491,11 @@
 				applyFontFamily(preset.stack);
 			}
 		}
+		const savedLineHeight = $appConfig?.line_height;
+		if (savedLineHeight) {
+			activeLineHeight = savedLineHeight;
+			applyLineHeight(savedLineHeight);
+		}
 		// Sync general settings
 		if ($appConfig) {
 			compactNotes = $appConfig.compact_notes ?? false;
@@ -449,9 +520,9 @@
 
 {#if $showSettings}
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
-	<div class="settings-overlay" onclick={close} onkeydown={(e) => { if (e.key === 'Escape') close(); }}>
+	<div class="settings-overlay" class:mobile={isMobile} onclick={close} onkeydown={(e) => { if (e.key === 'Escape') close(); }}>
 		<!-- svelte-ignore a11y_no_static_element_interactions -->
-		<div class="settings-panel" onclick={(e) => e.stopPropagation()}>
+		<div class="settings-panel" class:mobile={isMobile} onclick={(e) => e.stopPropagation()}>
 			<div class="settings-header">
 				<h2>Settings</h2>
 				<button class="close-btn" onclick={close}>
@@ -482,18 +553,22 @@
 						</svg>
 						Styling
 					</button>
+					{#if !isMobile}
 					<button class="tab-btn" class:active={activeTab === 'import'} onclick={() => activeTab = 'import'}>
 						<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 							<path d="M12 3v12"/><path d="m8 11 4 4 4-4"/><path d="M8 5H4a2 2 0 00-2 2v10a2 2 0 002 2h16a2 2 0 002-2V7a2 2 0 00-2-2h-4"/>
 						</svg>
 						Import
 					</button>
+				{/if}
+					{#if !isMobile}
 					<button class="tab-btn" class:active={activeTab === 'backup'} onclick={() => { activeTab = 'backup'; loadBackups(); }}>
 						<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 							<path d="M21 12a9 9 0 00-9-9 9.75 9.75 0 00-6.74 2.74L3 8"/><path d="M3 3v5h5"/><path d="M3 12a9 9 0 009 9 9.75 9.75 0 006.74-2.74L21 16"/><path d="M16 16h5v5"/>
 						</svg>
 						Backup
 					</button>
+					{/if}
 					<button class="tab-btn" class:active={activeTab === 'ai'} onclick={() => activeTab = 'ai'}>
 						<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 							<path d="M12 8V4l-2-2"/><rect x="4" y="8" width="16" height="12" rx="2"/><path d="M2 14h2"/><path d="M20 14h2"/><path d="M9 13v2"/><path d="M15 13v2"/>
@@ -533,6 +608,20 @@
 								</div>
 							</div>
 
+							{#if isMobile}
+							<div class="settings-section">
+								<h3>Vault</h3>
+								<p class="setting-desc" style="margin-bottom: 12px; color: var(--text-tertiary); font-size: 13px;">Current: <strong style="color: var(--text-primary);">{$appConfig?.active_vault?.split('/').pop() ?? 'Unknown'}</strong></p>
+								<button class="import-btn" onclick={() => { $showSettings = false; $vaultReady = false; }}>
+									<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+										<path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z"/>
+									</svg>
+									Switch Vault
+								</button>
+							</div>
+							{/if}
+
+							{#if !isMobile}
 							<div class="settings-section">
 								<h3>Performance</h3>
 								<label class="setting-toggle">
@@ -578,18 +667,13 @@
 								</label>
 								{/if}
 							</div>
+						{/if}
 						</div>
 					{:else if activeTab === 'editor'}
 						<div class="tab-content">
 							<div class="settings-section">
 								<h3>Title</h3>
-								<div class="setting-options">
-									<button class="option-btn" class:active={titleMode === 'input'} onclick={() => { titleMode = 'input'; saveGeneralSettings(); }}>Input</button>
-									<button class="option-btn" class:active={titleMode === 'heading'} onclick={() => { titleMode = 'heading'; saveGeneralSettings(); }}>Heading</button>
-									<button class="option-btn" class:active={titleMode === 'hidden'} onclick={() => { titleMode = 'hidden'; saveGeneralSettings(); }}>Hidden</button>
-								</div>
-								<span class="setting-hint">How the note title is displayed in the editor</span>
-								<label class="setting-toggle" style="margin-top: 12px;">
+								<label class="setting-toggle">
 									<span class="setting-label">
 										<span class="setting-name">Hide title in note body</span>
 										<span class="setting-desc">Hide the first heading when it matches the note title</span>
@@ -598,6 +682,17 @@
 										<span class="toggle-knob"></span>
 									</button>
 								</label>
+								{#if !isMobile}
+								<label class="setting-toggle" style="margin-top: 12px;">
+									<span class="setting-label">
+										<span class="setting-name">Show line numbers</span>
+										<span class="setting-desc">Display line numbers in the markdown source editor</span>
+									</span>
+									<button class="toggle-switch" class:on={showLineNumbers} onclick={() => { showLineNumbers = !showLineNumbers; saveGeneralSettings(); }}>
+										<span class="toggle-knob"></span>
+									</button>
+								</label>
+								{/if}
 								<label class="setting-toggle" style="margin-top: 12px;">
 									<span class="setting-label">
 										<span class="setting-name">Open notes in View Mode</span>
@@ -622,6 +717,7 @@
 								</label>
 							</div>
 
+							{#if !isMobile}
 							<div class="settings-section">
 								<h3>PDF Preview</h3>
 								<label class="setting-toggle">
@@ -653,6 +749,7 @@
 									<span class="setting-hint">Default height for PDF previews in notes</span>
 								</div>
 							{/if}
+						{/if}
 						</div>
 					{:else if activeTab === 'styling'}
 						<div class="tab-content">
@@ -716,6 +813,22 @@
 								</div>
 							</div>
 
+							<div class="settings-section">
+								<h3>Line Height</h3>
+								<div class="font-size-options">
+									{#each lineHeightPresets as preset}
+										<button
+											class="font-size-btn"
+											class:active={activeLineHeight === preset.value}
+											onclick={() => selectLineHeight(preset.value)}
+										>
+											<span class="font-size-label">{preset.label}</span>
+											<span class="font-size-value">{preset.value}</span>
+										</button>
+									{/each}
+								</div>
+							</div>
+
 							<div class="settings-section">
 								<h3>Font</h3>
 								<div class="font-family-options">
@@ -773,6 +886,7 @@
 								</label>
 
 								<div class="backup-actions">
+									{#if !isMobile}
 									<button class="backup-link-btn" onclick={handleSelectBackupFolder}>
 										<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 											<path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z"/>
@@ -782,6 +896,7 @@
 									{#if $appConfig?.backup_location}
 										<p class="backup-path">{$appConfig.backup_location}</p>
 									{/if}
+									{/if}
 									<button class="backup-link-btn" onclick={handleBackupNow} disabled={backupLoading}>
 										{#if backupLoading}
 											<svg class="spinner-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10" opacity="0.25" /><path d="M12 2a10 10 0 019.95 9" /></svg>
@@ -909,52 +1024,86 @@
 								<h3>Provider</h3>
 								<div class="setting-options">
 									<button class="option-btn" class:active={!aiProvider} onclick={() => { if (!aiProvider) return; aiProvider = null; aiTestMessage = null; saveAiSettings(); }}>Disabled</button>
-									<button class="option-btn" class:active={aiProvider === 'anthropic'} onclick={() => { if (aiProvider === 'anthropic') return; aiProvider = 'anthropic'; aiModel = 'claude-sonnet-4-5-20250929'; aiTestMessage = null; saveAiSettings(); }}>Anthropic</button>
+									<button class="option-btn" class:active={aiProvider === 'ollama'} onclick={() => { if (aiProvider === 'ollama') return; aiProvider = 'ollama'; aiModel = 'gemma3:4b'; aiTestMessage = null; saveAiSettings(); }}>Ollama</button>
+									<button class="option-btn" class:active={aiProvider === 'anthropic'} onclick={() => { if (aiProvider === 'anthropic') return; aiProvider = 'anthropic'; aiModel = 'claude-sonnet-4-6'; aiTestMessage = null; saveAiSettings(); }}>Anthropic</button>
 									<button class="option-btn" class:active={aiProvider === 'openai'} onclick={() => { if (aiProvider === 'openai') return; aiProvider = 'openai'; aiModel = 'gpt-5.2'; aiTestMessage = null; saveAiSettings(); }}>OpenAI</button>
 								</div>
 							</div>
 
 							{#if aiProvider}
-								<div class="settings-section">
-									<h3>API Key</h3>
-									<div class="ai-key-row">
+								{#if aiProvider === 'ollama'}
+									<p class="setting-hint" style="color: var(--text-success, #4ade80); margin-top: -4px; margin-bottom: 12px;">Your data stays on your device. No text is sent to any external server.</p>
+								{:else}
+									<p class="setting-hint" style="color: var(--text-warning, #f59e0b); margin-top: -4px; margin-bottom: 12px;">Your selected text and note content will be sent to {aiProvider === 'openai' ? 'OpenAI' : 'Anthropic'} servers for processing.</p>
+								{/if}
+
+								{#if aiProvider === 'ollama'}
+									<div class="settings-section">
+										<h3>Server URL</h3>
 										<input
-											type={aiShowKey ? 'text' : 'password'}
+											type="text"
 											class="ai-key-input"
-											placeholder={aiProvider === 'openai' ? 'sk-...' : 'sk-ant-...'}
-											value={aiApiKey}
-											oninput={(e) => { const v = (e.target as HTMLInputElement).value; if (aiProvider === 'openai') _openaiKey = v; else _anthropicKey = v; }}
+											placeholder="http://localhost:11434"
+											value={_ollamaBaseUrl}
+											oninput={(e) => { _ollamaBaseUrl = (e.target as HTMLInputElement).value; }}
 											onblur={saveAiSettings}
 										/>
-										<button class="ai-key-toggle" onclick={() => aiShowKey = !aiShowKey} title={aiShowKey ? 'Hide' : 'Show'}>
-											{#if aiShowKey}
-												<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.94 17.94A10.07 10.07 0 0112 20c-7 0-11-8-11-8a18.45 18.45 0 015.06-5.94M9.9 4.24A9.12 9.12 0 0112 4c7 0 11 8 11 8a18.5 18.5 0 01-2.16 3.19m-6.72-1.07a3 3 0 11-4.24-4.24"/><line x1="1" y1="1" x2="23" y2="23"/></svg>
-											{:else}
-												<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/></svg>
-											{/if}
-										</button>
+										<p class="setting-hint">Ollama server address. Install from <a href="https://ollama.com" target="_blank" class="ai-link">ollama.com</a></p>
 									</div>
-									{#if aiProvider === 'openai'}
-										<p class="setting-hint">Get your API key from <a href="https://platform.openai.com/api-keys" target="_blank" class="ai-link">platform.openai.com</a></p>
-									{:else}
-										<p class="setting-hint">Get your API key from <a href="https://console.anthropic.com/settings/keys" target="_blank" class="ai-link">console.anthropic.com</a></p>
-									{/if}
-								</div>
+								{:else}
+									<div class="settings-section">
+										<h3>API Key</h3>
+										<div class="ai-key-row">
+											<input
+												type={aiShowKey ? 'text' : 'password'}
+												class="ai-key-input"
+												placeholder={aiProvider === 'openai' ? 'sk-...' : 'sk-ant-...'}
+												value={aiApiKey}
+												oninput={(e) => { const v = (e.target as HTMLInputElement).value; if (aiProvider === 'openai') _openaiKey = v; else _anthropicKey = v; }}
+												onblur={saveAiSettings}
+											/>
+											<button class="ai-key-toggle" onclick={() => aiShowKey = !aiShowKey} title={aiShowKey ? 'Hide' : 'Show'}>
+												{#if aiShowKey}
+													<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.94 17.94A10.07 10.07 0 0112 20c-7 0-11-8-11-8a18.45 18.45 0 015.06-5.94M9.9 4.24A9.12 9.12 0 0112 4c7 0 11 8 11 8a18.5 18.5 0 01-2.16 3.19m-6.72-1.07a3 3 0 11-4.24-4.24"/><line x1="1" y1="1" x2="23" y2="23"/></svg>
+												{:else}
+													<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/></svg>
+												{/if}
+											</button>
+										</div>
+										{#if aiProvider === 'openai'}
+											<p class="setting-hint">Get your API key from <a href="https://platform.openai.com/api-keys" target="_blank" class="ai-link">platform.openai.com</a></p>
+										{:else}
+											<p class="setting-hint">Get your API key from <a href="https://console.anthropic.com/settings/keys" target="_blank" class="ai-link">console.anthropic.com</a></p>
+										{/if}
+									</div>
+								{/if}
 
 								<div class="settings-section">
 									<h3>Model</h3>
-									<div class="ai-model-options">
-										{#each aiModels as m}
-											<button
-												class="ai-model-btn"
-												class:active={aiModel === m.value}
-												onclick={() => { aiModel = m.value; saveAiSettings(); }}
-											>
-												<span class="ai-model-name">{m.label}</span>
-												<span class="ai-model-desc">{m.desc}</span>
-											</button>
-										{/each}
-									</div>
+									{#if aiProvider === 'ollama'}
+										<input
+											type="text"
+											class="ai-key-input"
+											placeholder="gemma3:4b"
+											value={aiModel}
+											oninput={(e) => { aiModel = (e.target as HTMLInputElement).value; }}
+											onblur={saveAiSettings}
+										/>
+										<p class="setting-hint">Enter the model name as shown by <code>ollama list</code></p>
+									{:else}
+										<div class="ai-model-options">
+											{#each aiModels as m}
+												<button
+													class="ai-model-btn"
+													class:active={aiModel === m.value}
+													onclick={() => { aiModel = m.value; saveAiSettings(); }}
+												>
+													<span class="ai-model-name">{m.label}</span>
+													<span class="ai-model-desc">{m.desc}</span>
+												</button>
+											{/each}
+										</div>
+									{/if}
 								</div>
 
 								<div class="settings-section">
@@ -972,7 +1121,7 @@
 
 								<div class="settings-section">
 									<h3>Connection</h3>
-									<button class="import-btn" onclick={handleTestAi} disabled={aiTestLoading || !aiApiKey}>
+									<button class="import-btn" onclick={handleTestAi} disabled={aiTestLoading || (aiProvider !== 'ollama' && !aiApiKey)}>
 										{#if aiTestLoading}
 											<svg class="spinner-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10" opacity="0.25" /><path d="M12 2a10 10 0 019.95 9" /></svg>
 											Testing...
@@ -995,7 +1144,11 @@
 
 								<div class="settings-section">
 									<h3>Usage</h3>
+									{#if isMobile}
+									<p class="import-desc">Use the AI button in the toolbar or header to access AI writing tools: improve, fix grammar, rewrite, summarize, translate, and more.</p>
+								{:else}
 									<p class="import-desc">Select text in the editor and right-click to access AI writing tools: improve, fix grammar, rewrite, summarize, translate, and more.</p>
+								{/if}
 								</div>
 							{/if}
 						</div>
@@ -1034,6 +1187,7 @@
 											<div class="update-notes">{updateAvailable.body}</div>
 										{/if}
 									</div>
+									{#if $installType === 'appimage' || $installType === 'windows' || $installType === 'macos'}
 									<button class="update-install-btn" onclick={handleDownloadAndInstall} disabled={updateDownloading}>
 										{#if updateDownloading}
 											<svg class="spinner-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10" opacity="0.25" /><path d="M12 2a10 10 0 019.95 9" /></svg>
@@ -1050,6 +1204,31 @@
 											<div class="update-progress-fill" style="width: {updateProgress}%"></div>
 										</div>
 									{/if}
+								{:else if $installType === 'deb'}
+									<div class="update-apt-info">
+										<p>Update via your package manager:</p>
+										<code>sudo apt update && sudo apt upgrade helix-notes</code>
+									</div>
+								{:else if $installType === 'aur'}
+									<div class="update-apt-info">
+										<p>Update via your AUR helper:</p>
+										<code>yay -Syu helixnotes</code>
+									</div>
+								{:else if $installType === 'android'}
+									<button class="update-install-btn" onclick={() => { openUrl('https://helixnotes.com/#download').catch(() => {}); }}>
+										<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+											<path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/>
+										</svg>
+										Download from Website
+									</button>
+								{:else}
+									<a class="update-install-btn" href="https://codeberg.org/ArkHost/HelixNotes/releases" target="_blank" rel="noopener">
+										<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+											<path d="M18 13v6a2 2 0 01-2 2H5a2 2 0 01-2-2V8a2 2 0 012-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/>
+										</svg>
+										Download from Codeberg
+									</a>
+								{/if}
 								</div>
 							{/if}
 
@@ -1090,7 +1269,8 @@
 		border-radius: 16px;
 		box-shadow: var(--shadow-lg);
 		width: 620px;
-		max-height: 80vh;
+		height: 80vh;
+		max-height: 700px;
 		overflow: hidden;
 		display: flex;
 		flex-direction: column;
@@ -1918,6 +2098,23 @@
 		cursor: not-allowed;
 	}
 
+	.update-apt-info {
+		margin-top: 8px;
+	}
+	.update-apt-info p {
+		margin: 0 0 6px 0;
+		font-size: 13px;
+		color: var(--text-secondary);
+	}
+	.update-apt-info code {
+		display: block;
+		padding: 8px 12px;
+		background: var(--bg-secondary);
+		border-radius: 6px;
+		font-size: 12px;
+		user-select: all;
+	}
+
 	.update-progress-bar {
 		margin-top: 10px;
 		height: 6px;
@@ -1938,4 +2135,111 @@
 		color: var(--accent);
 	}
 
+	/* ═══ Mobile ═══ */
+
+	.settings-overlay.mobile {
+		align-items: stretch;
+		justify-content: stretch;
+	}
+
+	.settings-panel.mobile {
+		width: 100%;
+		height: 100%;
+		max-height: 100%;
+		border-radius: 0;
+		border: none;
+	}
+
+	.settings-panel.mobile .settings-content {
+		flex-direction: column;
+	}
+
+	.settings-panel.mobile .settings-tabs {
+		flex-direction: row;
+		min-width: 0;
+		border-right: none;
+		border-bottom: 1px solid var(--border-light);
+		padding: 8px 8px 0;
+		overflow-x: auto;
+		overflow-y: hidden;
+		-webkit-overflow-scrolling: touch;
+		scrollbar-width: none;
+		gap: 0;
+	}
+
+	.settings-panel.mobile .settings-tabs::-webkit-scrollbar {
+		display: none;
+	}
+
+	.settings-panel.mobile .tab-btn {
+		flex-shrink: 0;
+		flex-direction: column;
+		gap: 4px;
+		padding: 8px 14px 10px;
+		font-size: 11px;
+		border-radius: 8px 8px 0 0;
+	}
+
+	.settings-panel.mobile .tab-btn.active {
+		border-bottom: 2px solid var(--accent);
+		border-radius: 8px 8px 0 0;
+	}
+
+	.settings-panel.mobile .settings-header {
+		padding-top: calc(env(safe-area-inset-top, 12px) + 12px);
+	}
+
+	.settings-panel.mobile .settings-body {
+		padding: 16px;
+	}
+
+	.settings-panel.mobile .setting-name {
+		font-size: 14px;
+	}
+
+	.settings-panel.mobile .setting-desc {
+		font-size: 12px;
+	}
+
+	.settings-panel.mobile .toggle-switch {
+		width: 44px;
+		height: 26px;
+	}
+
+	.settings-panel.mobile .toggle-knob {
+		width: 22px;
+		height: 22px;
+	}
+
+	.settings-panel.mobile .toggle-switch.on .toggle-knob {
+		transform: translateX(18px);
+	}
+
+	.settings-panel.mobile .option-btn {
+		padding: 12px 10px;
+		font-size: 14px;
+	}
+
+	.settings-panel.mobile .theme-btn {
+		padding: 12px 10px;
+		font-size: 14px;
+	}
+
+	.settings-panel.mobile .accent-grid {
+		grid-template-columns: repeat(4, 1fr);
+		gap: 10px;
+	}
+
+	.settings-panel.mobile .accent-swatch {
+		padding: 14px 8px;
+	}
+
+	.settings-panel.mobile .font-size-options {
+		gap: 8px;
+	}
+
+	.settings-panel.mobile .font-size-btn {
+		padding: 12px 6px;
+	}
+
 </style>

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, 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';
@@ -27,13 +28,19 @@
 		onViewChanged?: () => void;
 	} = $props();
 
+	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
+	const isMobile = /android|ios/i.test(navigator.userAgent);
+
 	let editingNotebook = $state<string | null>(null);
 	let editValue = $state('');
 	let newNotebookName = $state('');
 	let showNewNotebook = $state(false);
 	let dropTargetPath = $state<string | null>(null);
+	let draggedNotebookPath = $state<string | null>(null);
 	let contextMenu = $state<{ x: number; y: number; notebook: NotebookEntry } | null>(null);
 	let trashContextMenu = $state<{ x: number; y: number } | null>(null);
+	let tagsCollapsed = $state(true);
+	let deleteConfirm = $state<NotebookEntry | null>(null);
 	function toggleCollapse(path: string, e: MouseEvent) {
 		e.stopPropagation();
 		if ($collapsedNotebooks.includes(path)) {
@@ -43,13 +50,30 @@
 		}
 	}
 
+
 	export async function refresh() {
 		try {
-			$notebooks = await getNotebooks();
-			$tags = await getAllTags();
-			$notebookIcons = await getNotebookIcons();
-			const qaNotes = await getQuickAccess();
-			$quickAccessPaths = qaNotes.map(n => n.relative_path);
+			if (isMobile) {
+				// On mobile, parallelize and skip getAllTags (derive from $notes instead)
+				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 {
+				const [nbs, rootCount] = await Promise.all([getNotebooks(), countRootNotes()]);
+				$notebooks = nbs;
+				$rootNoteCount = rootCount;
+				$tags = await getAllTags();
+				$notebookIcons = await getNotebookIcons();
+				const qaNotes = await getQuickAccess();
+				$quickAccessPaths = qaNotes.map(n => n.relative_path);
+			}
 		} catch (e) {
 			console.error('Failed to refresh sidebar:', e);
 		}
@@ -62,7 +86,25 @@
 		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) {
+			selectAllNotes();
+			return;
+		}
 		$viewMode = 'notebook';
 		$activeNotebook = nb;
 		$activeTag = null;
@@ -83,6 +125,13 @@
 		onViewChanged();
 	}
 
+	function selectDaily() {
+		$viewMode = 'daily';
+		$activeNotebook = null;
+		$activeTag = null;
+		onViewChanged();
+	}
+
 	function selectTrash() {
 		$viewMode = 'trash';
 		$activeNotebook = null;
@@ -90,18 +139,33 @@
 		onViewChanged();
 	}
 
+	let newNotebookParent = $state<NotebookEntry | null>(null);
+
 	async function handleCreateNotebook() {
 		if (!newNotebookName.trim()) return;
 		try {
-			await createNotebook(null, newNotebookName.trim());
+			const parentRel = newNotebookParent?.relative_path ?? null;
+			await createNotebook(parentRel, newNotebookName.trim());
 			newNotebookName = '';
 			showNewNotebook = false;
+			newNotebookParent = null;
 			await refresh();
 		} catch (e) {
 			console.error('Failed to create notebook:', e);
 		}
 	}
 
+	function startNewSubNotebook(nb: NotebookEntry) {
+		contextMenu = null;
+		newNotebookParent = nb;
+		newNotebookName = '';
+		showNewNotebook = true;
+		// Expand parent so the new child is visible
+		if ($collapsedNotebooks.includes(nb.path)) {
+			$collapsedNotebooks = $collapsedNotebooks.filter(p => p !== nb.path);
+		}
+	}
+
 	async function handleRename(nb: NotebookEntry) {
 		if (!editValue.trim() || editValue.trim() === nb.name) {
 			editingNotebook = null;
@@ -116,8 +180,22 @@
 		}
 	}
 
-	async function handleDelete(nb: NotebookEntry) {
+	function countNotesRecursive(nb: NotebookEntry): number {
+		return nb.note_count + nb.children.reduce((sum, c) => sum + countNotesRecursive(c), 0);
+	}
+
+	function handleDelete(nb: NotebookEntry) {
 		contextMenu = null;
+		const total = countNotesRecursive(nb);
+		if (total > 0) {
+			deleteConfirm = nb;
+		} else {
+			confirmDelete(nb);
+		}
+	}
+
+	async function confirmDelete(nb: NotebookEntry) {
+		deleteConfirm = null;
 		try {
 			await deleteNotebook(nb.path);
 			if ($activeNotebook?.path === nb.path) {
@@ -150,6 +228,43 @@
 		}
 	}
 
+	async function handleNotebookDrop(e: DragEvent, destPath: string) {
+		e.preventDefault();
+		dropTargetPath = null;
+		const srcPath = e.dataTransfer?.getData('text/plain');
+		if (!srcPath) return;
+		draggedNotebookPath = null;
+		// Don't move onto self or descendant
+		if (destPath === srcPath || destPath.startsWith(srcPath + '/')) return;
+		// Don't move if already in that parent
+		const parentDir = srcPath.substring(0, srcPath.lastIndexOf('/'));
+		if (parentDir === destPath) return;
+		try {
+			const oldName = srcPath.split('/').pop() || '';
+			const newBasePath = destPath + '/' + oldName;
+			await moveNotebook(srcPath, destPath);
+			// Update collapsedNotebooks paths
+			$collapsedNotebooks = $collapsedNotebooks.map(p => {
+				if (p === srcPath) return newBasePath;
+				if (p.startsWith(srcPath + '/')) return newBasePath + p.slice(srcPath.length);
+				return p;
+			});
+			// Update active notebook/note if inside the moved notebook
+			if ($activeNotebook?.path === srcPath || $activeNotebook?.path.startsWith(srcPath + '/')) {
+				selectAllNotes();
+			}
+			if ($activeNotePath && $activeNotePath.startsWith(srcPath + '/')) {
+				const newNotePath = newBasePath + $activeNotePath.slice(srcPath.length);
+				$activeNotePath = newNotePath;
+				$activeNote = await readNote(newNotePath);
+			}
+			$notebookIcons = await getNotebookIcons();
+			await refresh();
+		} catch (e) {
+			console.error('Failed to move notebook:', e);
+		}
+	}
+
 	function startRename(nb: NotebookEntry) {
 		contextMenu = null;
 		editingNotebook = nb.path;
@@ -194,9 +309,18 @@
 		return convertFileSrc(`${vaultRoot}/${iconPath}`);
 	}
 
+	function clampMenu(x: number, y: number, menuWidth = 220, menuHeight = 300): { x: number; y: number } {
+		if (x + menuWidth > window.innerWidth) x = window.innerWidth - menuWidth - 8;
+		if (y + menuHeight > window.innerHeight) y = window.innerHeight - menuHeight - 8;
+		if (x < 4) x = 4;
+		if (y < 4) y = 4;
+		return { x, y };
+	}
+
 	function onContextMenu(e: MouseEvent, nb: NotebookEntry) {
 		e.preventDefault();
-		contextMenu = { x: e.clientX, y: e.clientY, notebook: nb };
+		const { x, y } = clampMenu(e.clientX, e.clientY);
+		contextMenu = { x, y, notebook: nb };
 	}
 
 	function closeContextMenu() {
@@ -206,7 +330,8 @@
 	function onTrashContextMenu(e: MouseEvent) {
 		e.preventDefault();
 		e.stopPropagation();
-		trashContextMenu = { x: e.clientX, y: e.clientY };
+		const { x, y } = clampMenu(e.clientX, e.clientY, 180, 60);
+		trashContextMenu = { x, y };
 	}
 
 	async function handleEmptyTrash() {
@@ -232,7 +357,8 @@
 
 <svelte:window onclick={handleWindowClick} />
 
-<aside class="sidebar" class:collapsed={$sidebarCollapsed}>
+<aside class="sidebar" class:collapsed={$sidebarCollapsed} class:mobile={isMobile}>
+	{#if !isMobile}
 	<div class="sidebar-header">
 		<button class="collapse-btn" onclick={() => ($sidebarCollapsed = !$sidebarCollapsed)} title="Toggle sidebar">
 			<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
@@ -244,7 +370,7 @@
 			</svg>
 		</button>
 		{#if !$sidebarCollapsed}
-			<button class="icon-btn" onclick={() => ($showSearch = true)} title="Search (Ctrl+F)">
+			<button class="icon-btn" onclick={() => ($showSearch = true)} title={`Search (${modKey}+F)`}>
 				<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 					<circle cx="11" cy="11" r="8" />
 					<line x1="21" y1="21" x2="16.65" y2="16.65" />
@@ -252,6 +378,7 @@
 			</button>
 		{/if}
 	</div>
+	{/if}
 
 	{#if !$sidebarCollapsed}
 		<nav class="sidebar-nav">
@@ -278,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'}
@@ -292,9 +433,34 @@
 		</nav>
 
 		<div class="section">
-			<div class="section-header">
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+			<div
+				class="section-header"
+				class:drop-target={dropTargetPath === '__root__'}
+				ondragover={(e) => {
+					if (draggedNotebookPath) {
+						e.preventDefault();
+						e.dataTransfer!.dropEffect = 'move';
+						dropTargetPath = '__root__';
+					}
+				}}
+				ondragleave={() => { if (dropTargetPath === '__root__') dropTargetPath = null; }}
+				ondrop={(e) => {
+					if (draggedNotebookPath) {
+						const vaultRoot = $appConfig?.active_vault;
+						if (vaultRoot) handleNotebookDrop(e, vaultRoot);
+					}
+				}}
+			>
 				<span class="section-title">Notebooks</span>
-				<button class="icon-btn-sm" onclick={() => (showNewNotebook = !showNewNotebook)} title="New notebook">
+				<button class="icon-btn-sm" onclick={() => {
+					if (showNewNotebook) {
+						showNewNotebook = false; newNotebookName = ''; newNotebookParent = null;
+					} else {
+						newNotebookParent = ($viewMode === 'notebook' && $activeNotebook) ? $activeNotebook : null;
+						showNewNotebook = true;
+					}
+				}} title={$viewMode === 'notebook' && $activeNotebook ? `New notebook inside ${$activeNotebook.name}` : 'New notebook'}>
 					<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="12" y1="5" x2="12" y2="19" /><line x1="5" y1="12" x2="19" y2="12" />
 					</svg>
@@ -303,43 +469,86 @@
 
 			{#if showNewNotebook}
 				<div class="new-notebook-input">
+					{#if newNotebookParent}
+						<span class="new-notebook-parent">{newNotebookParent.name}/</span>
+					{/if}
 					<input
 						type="text"
 						bind:value={newNotebookName}
-						placeholder="Notebook name..."
+						placeholder={newNotebookParent ? 'Sub-notebook name...' : 'Notebook name...'}
 						onkeydown={(e) => {
 							if (e.key === 'Enter') handleCreateNotebook();
-							if (e.key === 'Escape') { showNewNotebook = false; newNotebookName = ''; }
+							if (e.key === 'Escape') { showNewNotebook = false; newNotebookName = ''; newNotebookParent = null; }
 						}}
 					/>
 				</div>
 			{/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}
 			</div>
+		{#if isMobile && $tags.length > 0}
+				<div class="tags-section-inline">
+					<button class="section-header" onclick={() => tagsCollapsed = !tagsCollapsed}>
+						<span class="section-title">Tags</span>
+						<span class="tag-count" style="margin-left: auto">{$tags.length}</span>
+					</button>
+					{#if !tagsCollapsed}
+						<div class="tag-list">
+							{#each $tags as [tag, count]}
+								<button
+									class="tag-item"
+									class:active={$viewMode === 'tag' && $activeTag === tag}
+									onclick={() => selectTag(tag)}
+								>
+									<span class="tag-hash">#</span>
+									<span class="tag-name">{tag}</span>
+									<span class="tag-count">{count}</span>
+								</button>
+							{/each}
+						</div>
+					{/if}
+				</div>
+			{/if}
 		</div>
 
-		{#if $tags.length > 0}
-			<div class="section">
-				<div class="section-header">
+		{#if !isMobile && $tags.length > 0}
+			<div class="tags-section">
+				<button class="section-header" onclick={() => tagsCollapsed = !tagsCollapsed}>
 					<span class="section-title">Tags</span>
-				</div>
-				<div class="tag-list">
-					{#each $tags as [tag, count]}
-						<button
-							class="tag-item"
-							class:active={$viewMode === 'tag' && $activeTag === tag}
-							onclick={() => selectTag(tag)}
-						>
-							<span class="tag-hash">#</span>
-							<span class="tag-name">{tag}</span>
-							<span class="tag-count">{count}</span>
-						</button>
-					{/each}
-				</div>
+					<span class="tag-count" style="margin-left: auto">{$tags.length}</span>
+				</button>
+				{#if !tagsCollapsed}
+					<div class="tag-list">
+						{#each $tags as [tag, count]}
+							<button
+								class="tag-item"
+								class:active={$viewMode === 'tag' && $activeTag === tag}
+								onclick={() => selectTag(tag)}
+							>
+								<span class="tag-hash">#</span>
+								<span class="tag-name">{tag}</span>
+								<span class="tag-count">{count}</span>
+							</button>
+						{/each}
+					</div>
+				{/if}
 			</div>
 		{/if}
 
@@ -367,6 +576,10 @@
 {#if contextMenu}
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
 	<div class="context-menu" style="left: {contextMenu.x}px; top: {contextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
+		<button onclick={() => startNewSubNotebook(contextMenu!.notebook)}>
+			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z" /><line x1="12" y1="11" x2="12" y2="17" /><line x1="9" y1="14" x2="15" y2="14" /></svg>
+			New Sub-notebook
+		</button>
 		<button onclick={() => startRename(contextMenu!.notebook)}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7" /><path d="M18.5 2.5a2.121 2.121 0 013 3L12 15l-4 1 1-4 9.5-9.5z" /></svg>
 			Rename
@@ -400,6 +613,21 @@
 	</div>
 {/if}
 
+{#if deleteConfirm}
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div class="delete-confirm-overlay" onclick={() => deleteConfirm = null}>
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<div class="delete-confirm" onclick={(e) => e.stopPropagation()}>
+			<h4>Delete "{deleteConfirm.name}"?</h4>
+			<p>This notebook contains {countNotesRecursive(deleteConfirm)} note{countNotesRecursive(deleteConfirm) === 1 ? '' : 's'} that will be permanently deleted.</p>
+			<div class="delete-confirm-actions">
+				<button class="delete-confirm-cancel" onclick={() => deleteConfirm = null}>Cancel</button>
+				<button class="delete-confirm-btn" onclick={() => confirmDelete(deleteConfirm!)}>Delete</button>
+			</div>
+		</div>
+	</div>
+{/if}
+
 {#snippet notebookItem(nb: NotebookEntry, depth: number)}
 	{@const hasChildren = nb.children.length > 0}
 	{@const isCollapsed = $collapsedNotebooks.includes(nb.path)}
@@ -423,11 +651,34 @@
 			class:active={$viewMode === 'notebook' && $activeNotebook?.path === nb.path}
 			class:drop-target={dropTargetPath === nb.path}
 			style="padding-left: {8 + depth * 16}px"
+			draggable="true"
 			onclick={() => selectNotebook(nb)}
 			oncontextmenu={(e) => onContextMenu(e, nb)}
-			ondragover={(e) => { e.preventDefault(); e.dataTransfer!.dropEffect = 'move'; dropTargetPath = nb.path; }}
+			ondragstart={(e) => { draggedNotebookPath = nb.path; e.dataTransfer!.setData('text/plain', nb.path); e.dataTransfer!.effectAllowed = 'move'; }}
+			ondragend={() => { draggedNotebookPath = null; }}
+			ondragover={(e) => {
+				e.preventDefault();
+				if (draggedNotebookPath) {
+					// Prevent drop on self or descendant
+					if (nb.path === draggedNotebookPath || nb.path.startsWith(draggedNotebookPath + '/')) {
+						e.dataTransfer!.dropEffect = 'none';
+						return;
+					}
+					// Prevent no-op (already in this parent)
+					const parentDir = draggedNotebookPath.substring(0, draggedNotebookPath.lastIndexOf('/'));
+					if (parentDir === nb.path) { e.dataTransfer!.dropEffect = 'none'; return; }
+				}
+				e.dataTransfer!.dropEffect = 'move';
+				dropTargetPath = nb.path;
+			}}
 			ondragleave={() => { if (dropTargetPath === nb.path) dropTargetPath = null; }}
-			ondrop={(e) => handleNoteDrop(e, nb)}
+			ondrop={(e) => {
+				if (draggedNotebookPath) {
+					handleNotebookDrop(e, nb.path);
+				} else {
+					handleNoteDrop(e, nb);
+				}
+			}}
 		>
 			{#if hasChildren}
 				<!-- svelte-ignore a11y_no_static_element_interactions -->
@@ -519,11 +770,26 @@
 		padding: 4px 0;
 	}
 
+	.tags-section {
+		flex-shrink: 0;
+		border-top: 1px solid var(--border-light);
+		padding: 4px 0;
+		max-height: 30%;
+		overflow-y: auto;
+	}
+
 	.section-header {
 		display: flex;
 		align-items: center;
 		justify-content: space-between;
 		padding: 8px 12px 4px;
+		width: 100%;
+		background: none;
+		border: none;
+		cursor: pointer;
+		color: inherit;
+		font: inherit;
+		text-align: left;
 	}
 
 	.section-title {
@@ -569,9 +835,35 @@
 
 	.new-notebook-input {
 		padding: 2px 8px;
+		display: flex;
+		align-items: center;
+		gap: 0;
+		border: 1px solid var(--accent);
+		border-radius: 4px;
+		background: var(--bg-primary);
+		overflow: hidden;
 	}
 
-	.new-notebook-input input, .rename-input {
+	.new-notebook-parent {
+		padding: 4px 0 4px 8px;
+		color: var(--text-tertiary);
+		font-size: inherit;
+		white-space: nowrap;
+		flex-shrink: 0;
+	}
+
+	.new-notebook-input input {
+		flex: 1;
+		min-width: 0;
+		padding: 4px 8px;
+		border: none;
+		background: transparent;
+		color: var(--text-primary);
+		font-size: inherit;
+		outline: none;
+	}
+
+	.rename-input {
 		width: 100%;
 		padding: 4px 8px;
 		border: 1px solid var(--accent);
@@ -610,7 +902,8 @@
 		color: var(--text-accent);
 	}
 
-	.notebook-item.drop-target {
+	.notebook-item.drop-target,
+	.section-header.drop-target {
 		background: color-mix(in srgb, var(--accent) 20%, transparent);
 		outline: 2px dashed var(--accent);
 		outline-offset: -2px;
@@ -759,4 +1052,205 @@
 	.context-menu button.danger:hover {
 		background: color-mix(in srgb, var(--danger) 10%, transparent);
 	}
+
+	.delete-confirm-overlay {
+		position: fixed;
+		inset: 0;
+		background: rgba(0, 0, 0, 0.4);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		z-index: 1000;
+	}
+
+	.delete-confirm {
+		background: var(--bg-primary);
+		border: 1px solid var(--border-color);
+		border-radius: 10px;
+		padding: 20px 24px;
+		max-width: 340px;
+		box-shadow: 0 8px 32px rgba(0, 0, 0, 0.25);
+	}
+
+	.delete-confirm h4 {
+		margin: 0 0 8px;
+		font-size: 14px;
+		color: var(--text-primary);
+	}
+
+	.delete-confirm p {
+		margin: 0 0 16px;
+		font-size: 12.5px;
+		color: var(--text-secondary);
+		line-height: 1.4;
+	}
+
+	.delete-confirm-actions {
+		display: flex;
+		gap: 8px;
+		justify-content: flex-end;
+	}
+
+	.delete-confirm-cancel {
+		padding: 6px 14px;
+		border: 1px solid var(--border-color);
+		border-radius: 6px;
+		background: var(--bg-secondary);
+		color: var(--text-primary);
+		font-size: 12px;
+		cursor: pointer;
+	}
+
+	.delete-confirm-cancel:hover {
+		background: var(--bg-hover);
+	}
+
+	.delete-confirm-btn {
+		padding: 6px 14px;
+		border: none;
+		border-radius: 6px;
+		background: var(--danger, #e53e3e);
+		color: white;
+		font-size: 12px;
+		font-weight: 600;
+		cursor: pointer;
+	}
+
+	.delete-confirm-btn:hover {
+		opacity: 0.9;
+	}
+
+	/* ═══ MOBILE (class-based for Android high-DPI) ═══ */
+	.sidebar.mobile {
+		width: 100% !important;
+		min-width: 100%;
+		border-right: none;
+	}
+
+	.sidebar.mobile.collapsed {
+		width: 100% !important;
+		min-width: 100%;
+		max-width: 100%;
+	}
+
+	.sidebar.mobile .sidebar-header {
+		padding: 10px 12px;
+	}
+
+	.sidebar.mobile .collapse-btn {
+		display: none;
+	}
+
+	.sidebar.mobile .nav-item {
+		padding: 12px 14px;
+		font-size: 15px;
+		min-height: 48px;
+		gap: 12px;
+	}
+
+	.sidebar.mobile .nav-item svg {
+		width: 20px;
+		height: 20px;
+	}
+
+	.sidebar.mobile .section {
+		padding-bottom: 180px;
+	}
+
+	.sidebar.mobile .tags-section-inline {
+		border-top: 1px solid var(--border-light);
+		padding: 4px 0;
+		margin-top: 8px;
+	}
+
+	.sidebar.mobile .section-header {
+		padding: 12px 16px 6px;
+		min-height: 44px;
+	}
+
+	.sidebar.mobile .section-title {
+		font-size: 12px;
+	}
+
+	.sidebar.mobile .icon-btn,
+	.sidebar.mobile .icon-btn-sm {
+		min-width: 44px;
+		min-height: 44px;
+		padding: 10px;
+	}
+
+	.sidebar.mobile .notebook-item {
+		padding: 12px 12px;
+		min-height: 48px;
+		gap: 10px;
+		font-size: 15px;
+	}
+
+	.sidebar.mobile .notebook-icon {
+		width: 24px;
+		height: 24px;
+	}
+
+	.sidebar.mobile .new-notebook-input {
+		padding: 4px 12px;
+	}
+
+	.sidebar.mobile .new-notebook-parent {
+		padding: 10px 0 10px 12px;
+		font-size: 15px;
+	}
+
+	.sidebar.mobile .new-notebook-input input {
+		padding: 10px 12px;
+		font-size: 15px;
+	}
+
+	.sidebar.mobile .rename-input {
+		padding: 10px 12px;
+		font-size: 15px;
+	}
+
+	.sidebar.mobile .tag-item {
+		padding: 10px 16px;
+		min-height: 44px;
+		font-size: 14px;
+	}
+
+	.sidebar.mobile .sidebar-footer {
+		padding: 8px 12px;
+		display: none;
+	}
+
+	.sidebar.mobile .context-menu {
+		min-width: 200px;
+		border-radius: 12px;
+		padding: 6px;
+	}
+
+	.sidebar.mobile .context-menu button {
+		padding: 12px 16px;
+		font-size: 15px;
+		min-height: 44px;
+		border-radius: 8px;
+	}
+
+	.sidebar.mobile .delete-confirm {
+		max-width: calc(100vw - 40px);
+		padding: 24px;
+	}
+
+	.sidebar.mobile .delete-confirm h4 {
+		font-size: 16px;
+	}
+
+	.sidebar.mobile .delete-confirm p {
+		font-size: 14px;
+	}
+
+	.sidebar.mobile .delete-confirm-cancel,
+	.sidebar.mobile .delete-confirm-btn {
+		padding: 10px 20px;
+		font-size: 14px;
+		min-height: 44px;
+	}
 </style>

src/lib/components/TitleBar.svelte

@@ -1,12 +1,15 @@
 <script lang="ts">
 	import { getCurrentWindow } from '@tauri-apps/api/window';
-	import { vaultReady, focusMode } from '$lib/stores/app';
+	import { vaultReady, focusMode, readOnly, updateAvailable, showSettings, settingsTab } from '$lib/stores/app';
 
-	let { onNewNote = () => {} }: {
+	let { onNewNote = () => {}, onDailyNote = () => {} }: {
 		onNewNote?: () => void;
+		onDailyNote?: () => void;
 	} = $props();
 
 	const appWindow = getCurrentWindow();
+	const isMac = navigator.platform.startsWith('Mac');
+	const modKey = isMac ? '⌘' : 'Ctrl';
 	let maximized = $state(false);
 
 	async function checkMaximized() {
@@ -59,7 +62,7 @@
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
-<div class="titlebar" onmousedown={handleMouseDown}>
+<div class="titlebar" class:macos={isMac} onmousedown={handleMouseDown}>
 	<div class="titlebar-brand">
 		<svg width="18" height="18" viewBox="0 0 48 48" fill="none">
 			<rect width="48" height="48" rx="12" fill="var(--accent)" />
@@ -71,6 +74,12 @@
 			<line x1="29" y1="18" x2="19" y2="30" stroke="white" stroke-width="2" stroke-linecap="round" opacity="0.7" />
 		</svg>
 		<span class="titlebar-title">HelixNotes</span>
+		{#if $updateAvailable}
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<button class="update-badge" onmousedown={(e) => e.stopPropagation()} onclick={() => { $settingsTab = 'updates'; $showSettings = true; }}>
+				v{$updateAvailable.version} available
+			</button>
+		{/if}
 	</div>
 	<div class="titlebar-actions">
 		<button class="switch-vault-btn" onclick={() => ($vaultReady = false)} title="Switch Vault">
@@ -83,13 +92,34 @@
 				<path d="M8 3H5a2 2 0 00-2 2v3m18 0V5a2 2 0 00-2-2h-3m0 18h3a2 2 0 002-2v-3M3 16v3a2 2 0 002 2h3"/>
 			</svg>
 		</button>
-		<button class="new-note-btn" onclick={onNewNote} title="New Note (Ctrl+N)">
+		<button class="switch-vault-btn" class:active={$readOnly} onclick={() => ($readOnly = !$readOnly)} title={$readOnly ? 'Switch to Edit Mode' : 'Switch to View Mode'}>
+			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+				{#if $readOnly}
+					<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" />
+					<circle cx="12" cy="12" r="3" />
+				{:else}
+					<path d="M17.94 17.94A10.07 10.07 0 0112 20c-7 0-11-8-11-8a18.45 18.45 0 015.06-5.94" />
+					<path d="M9.9 4.24A9.12 9.12 0 0112 4c7 0 11 8 11 8a18.5 18.5 0 01-2.16 3.19" />
+					<line x1="1" y1="1" x2="23" y2="23" />
+				{/if}
+			</svg>
+		</button>
+		<button class="switch-vault-btn" onclick={onDailyNote} title="Daily Note">
+			<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="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>
+		</button>
+		<button class="new-note-btn" onclick={onNewNote} title={`New Note (${modKey}+N)`}>
 			<svg width="14" height="14" viewBox="0 0 14 14" fill="none">
 				<path d="M7 1v12M1 7h12" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" />
 			</svg>
 			New Note
 		</button>
 	</div>
+	{#if !isMac}
 	<div class="titlebar-controls">
 		<button class="titlebar-btn" onclick={minimize} title="Minimize">
 			<svg width="10" height="10" viewBox="0 0 10 10">
@@ -115,6 +145,7 @@
 			</svg>
 		</button>
 	</div>
+	{/if}
 </div>
 
 <style>
@@ -144,6 +175,25 @@
 		color: var(--text-tertiary);
 	}
 
+	.update-badge {
+		font-size: 10px;
+		font-weight: 600;
+		color: var(--accent);
+		background: color-mix(in srgb, var(--accent) 12%, transparent);
+		border: 1px solid color-mix(in srgb, var(--accent) 25%, transparent);
+		border-radius: 10px;
+		padding: 1px 8px;
+		cursor: pointer;
+		pointer-events: auto;
+		-webkit-app-region: no-drag;
+		transition: background 0.15s, border-color 0.15s;
+	}
+
+	.update-badge:hover {
+		background: color-mix(in srgb, var(--accent) 20%, transparent);
+		border-color: color-mix(in srgb, var(--accent) 40%, transparent);
+	}
+
 	.titlebar-actions {
 		display: flex;
 		align-items: center;
@@ -171,6 +221,12 @@
 		color: var(--text-primary);
 	}
 
+
+	.switch-vault-btn.active {
+		background: color-mix(in srgb, var(--accent) 18%, transparent);
+		color: var(--accent);
+	}
+
 	.new-note-btn {
 		display: flex;
 		align-items: center;
@@ -178,7 +234,7 @@
 		padding: 4px 12px 4px 10px;
 		border: none;
 		border-radius: 7px;
-		background: var(--accent);
+		background: color-mix(in srgb, var(--accent) 85%, black);
 		color: white;
 		font-size: 11.5px;
 		font-weight: 600;
@@ -227,4 +283,9 @@
 		background: #e81123;
 		color: white;
 	}
+
+	/* macOS: add left padding for native traffic light buttons */
+	.titlebar.macos .titlebar-brand {
+		padding-left: 78px;
+	}
 </style>

src/lib/components/VaultPicker.svelte

@@ -6,15 +6,66 @@
 	import type { VaultConfig } from '$lib/types';
 
 	const appWindow = getCurrentWindow();
+	const isMobile = /android|ios/i.test(navigator.userAgent);
 
 	let recentVaults: VaultConfig[] = $derived($appConfig?.vaults ?? []);
 	let loading = $state(false);
 	let error = $state('');
+	let vaultName = $state('HelixNotes');
+	let hasPermission = $state(!isMobile);
+	let selectedLocation = $state('Documents');
+	let customPath = $state('');
+
+	const storageLocations = [
+		{ label: 'Documents', path: '/storage/emulated/0/Documents' },
+		{ label: 'Downloads', path: '/storage/emulated/0/Download' },
+		{ label: 'Internal Storage', path: '/storage/emulated/0' },
+	];
+
+	if (isMobile) {
+		checkPermission();
+		setTimeout(checkPermission, 500);
+		(window as any).__storagePermissionGranted = () => { hasPermission = true; };
+		document.addEventListener('visibilitychange', () => {
+			if (document.visibilityState === 'visible') setTimeout(checkPermission, 300);
+		});
+	}
+
+	function checkPermission() {
+		try {
+			const bridge = (window as any).Android;
+			if (bridge?.hasStoragePermission) {
+				hasPermission = bridge.hasStoragePermission() === true;
+			}
+		} catch { /* bridge not ready */ }
+	}
+
+	function requestPermission() {
+		try {
+			const bridge = (window as any).Android;
+			bridge?.requestStoragePermission?.();
+		} catch {
+			error = 'Go to Settings > Apps > HelixNotes > Permissions and enable "All files access".';
+		}
+	}
+
+	function getMobileBasePath(): string {
+		if (selectedLocation === 'Custom') {
+			return customPath.trim() || '/storage/emulated/0/Documents';
+		}
+		return storageLocations.find(l => l.label === selectedLocation)?.path || '/storage/emulated/0/Documents';
+	}
+
+	let fullPath = $derived(isMobile ? `${getMobileBasePath()}/${vaultName.trim() || 'HelixNotes'}` : '');
 
 	async function pickFolder() {
-		const selected = await open({ directory: true, multiple: false, title: 'Choose Notes Folder' });
-		if (selected) {
-			await openSelectedVault(selected as string);
+		if (isMobile) {
+			await openSelectedVault(fullPath);
+		} else {
+			const selected = await open({ directory: true, multiple: false, title: 'Choose Notes Folder' });
+			if (selected) {
+				await openSelectedVault(selected as string);
+			}
 		}
 	}
 
@@ -22,6 +73,12 @@
 		loading = true;
 		error = '';
 		try {
+			if (isMobile) {
+				try {
+					const bridge = (window as any).Android;
+					bridge?.prepareVaultDir?.(path);
+				} catch { /* Rust will retry mkdir itself */ }
+			}
 			await openVault(path);
 			const config = await getAppConfig();
 			$appConfig = config;
@@ -35,7 +92,8 @@
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
-<div class="vault-picker" onmousedown={(e) => { if (!(e.target as HTMLElement).closest('button, .picker-card')) appWindow.startDragging(); }}>
+<div class="vault-picker" class:mobile={isMobile} onmousedown={(e) => { if (!isMobile && !(e.target as HTMLElement).closest('button, .picker-card')) appWindow.startDragging(); }}>
+	{#if !isMobile}
 	<div class="window-controls">
 		<button class="window-close" onclick={() => appWindow.close()} title="Close">
 			<svg width="10" height="10" viewBox="0 0 10 10">
@@ -44,6 +102,7 @@
 			</svg>
 		</button>
 	</div>
+	{/if}
 	<div class="picker-card">
 		<div class="logo">
 			<svg width="72" height="72" viewBox="0 0 48 48" fill="none">
@@ -57,8 +116,46 @@
 			</svg>
 		</div>
 		<h1>HelixNotes</h1>
-		<p class="subtitle">Local-first markdown notes</p>
-		<p class="description">Your notes are stored as standard Markdown (.md) files. Pick any folder — existing .md files will be recognized automatically.</p>
+		<p class="subtitle">Local markdown notes</p>
+		{#if isMobile}
+			<p class="description">Choose where to store your notes. Sync with Syncthing, Nextcloud, or any file sync app.</p>
+
+			{#if !hasPermission}
+				<button class="btn-permission" onclick={requestPermission}>
+					Grant File Access
+				</button>
+				<p class="permission-hint">Required to access Documents, Downloads, and other shared folders.</p>
+			{/if}
+
+			<div class="location-selector">
+				<label class="location-label">Location</label>
+				<div class="location-options">
+					{#each storageLocations as loc}
+						<button
+							class="location-option"
+							class:active={selectedLocation === loc.label}
+							onclick={() => selectedLocation = loc.label}
+						>{loc.label}</button>
+					{/each}
+					<button
+						class="location-option"
+						class:active={selectedLocation === 'Custom'}
+						onclick={() => selectedLocation = 'Custom'}
+					>Custom</button>
+				</div>
+				{#if selectedLocation === 'Custom'}
+					<input class="custom-path-input" type="text" bind:value={customPath} placeholder="/storage/emulated/0/..." />
+				{/if}
+			</div>
+
+			<div class="vault-name-input">
+				<label for="vault-name">Vault name</label>
+				<div class="vault-name-preview"><input id="vault-name" type="text" bind:value={vaultName} placeholder="HelixNotes" /></div>
+				<span class="vault-path-hint">{fullPath}</span>
+			</div>
+		{:else}
+			<p class="description">Your notes are stored as standard Markdown (.md) files. Pick any folder — existing .md files will be recognized automatically.</p>
+		{/if}
 
 		{#if error}
 			<div class="error">{error}</div>
@@ -67,6 +164,8 @@
 		<button class="btn-primary" onclick={pickFolder} disabled={loading}>
 			{#if loading}
 				Opening...
+			{:else if isMobile}
+				Get Started
 			{:else}
 				Open Notes Folder
 			{/if}
@@ -95,11 +194,13 @@
 <style>
 	.vault-picker {
 		display: flex;
-		align-items: center;
 		justify-content: center;
 		height: 100vh;
+		height: 100dvh;
 		background: var(--bg-primary);
 		position: relative;
+		overflow-y: auto;
+		-webkit-overflow-scrolling: touch;
 	}
 
 	.window-controls {
@@ -133,6 +234,9 @@
 		max-width: 400px;
 		width: 100%;
 		padding: 48px 32px;
+		padding-bottom: calc(120px + env(safe-area-inset-bottom, 0px));
+		margin: auto;
+		flex-shrink: 0;
 	}
 
 	.logo {
@@ -260,4 +364,166 @@
 		text-overflow: ellipsis;
 		white-space: nowrap;
 	}
+
+	.vault-name-input {
+		margin-bottom: 20px;
+		text-align: left;
+	}
+
+	.vault-name-input label {
+		display: block;
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--text-tertiary);
+		margin-bottom: 6px;
+	}
+
+	.vault-name-preview {
+		display: flex;
+		align-items: center;
+		background: var(--bg-secondary);
+		border: 1px solid var(--border-color);
+		border-radius: 8px;
+		padding: 10px 12px;
+		font-size: 14px;
+		color: var(--text-tertiary);
+	}
+
+	.vault-name-preview input {
+		background: none;
+		border: none;
+		outline: none;
+		color: var(--text-primary);
+		font-size: 14px;
+		font-family: inherit;
+		width: 100%;
+		padding: 0;
+	}
+
+	.location-selector {
+		margin-bottom: 16px;
+		text-align: left;
+	}
+
+	.location-label {
+		display: block;
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--text-tertiary);
+		margin-bottom: 6px;
+	}
+
+	.location-options {
+		display: flex;
+		gap: 6px;
+		flex-wrap: wrap;
+	}
+
+	.location-option {
+		padding: 8px 14px;
+		border: 1px solid var(--border-color);
+		border-radius: 8px;
+		background: var(--bg-secondary);
+		color: var(--text-secondary);
+		font-size: 13px;
+		font-family: inherit;
+		cursor: pointer;
+		transition: all 0.15s;
+	}
+
+	.location-option.active {
+		background: var(--accent);
+		color: white;
+		border-color: var(--accent);
+	}
+
+	.custom-path-input {
+		width: 100%;
+		margin-top: 8px;
+		padding: 10px 12px;
+		background: var(--bg-secondary);
+		border: 1px solid var(--border-color);
+		border-radius: 8px;
+		color: var(--text-primary);
+		font-size: 13px;
+		font-family: inherit;
+		outline: none;
+		box-sizing: border-box;
+	}
+
+	.custom-path-input:focus {
+		border-color: var(--accent);
+	}
+
+	.vault-path-hint {
+		display: block;
+		font-size: 11px;
+		color: var(--text-tertiary);
+		margin-top: 6px;
+		opacity: 0.7;
+		word-break: break-all;
+	}
+
+	.btn-permission {
+		width: 100%;
+		padding: 12px 20px;
+		background: var(--accent);
+		color: white;
+		border: none;
+		border-radius: 10px;
+		font-size: 15px;
+		font-weight: 600;
+		cursor: pointer;
+		margin-bottom: 6px;
+		transition: background 0.15s;
+	}
+
+	.btn-permission:hover {
+		background: var(--accent-hover);
+	}
+
+	.permission-hint {
+		font-size: 12px;
+		color: var(--text-tertiary);
+		margin-bottom: 20px;
+		opacity: 0.7;
+	}
+
+	/* Mobile */
+	.mobile .btn-primary {
+		padding: 14px 20px;
+		font-size: 16px;
+		border-radius: 12px;
+	}
+
+	.mobile .description {
+		font-size: 14px;
+	}
+
+	.mobile h1 {
+		font-size: 28px;
+	}
+
+	.mobile .logo :global(svg) {
+		width: 88px;
+		height: 88px;
+	}
+
+	.mobile .btn-back {
+		padding: 14px 20px;
+		font-size: 16px;
+		border-radius: 12px;
+	}
+
+	.mobile .vault-item {
+		padding: 14px 16px;
+	}
+
+	.mobile .vault-name {
+		font-size: 15px;
+	}
+
+	.mobile .vault-path {
+		font-size: 13px;
+	}
 </style>

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,
@@ -23,6 +23,7 @@ export const searchQuery = writable("");
 export const showCommandPalette = writable(false);
 export const showSearch = writable(false);
 export const showSettings = writable(false);
+export const settingsTab = writable<string | null>(null);
 export const showInfo = writable(false);
 export const notebookIcons = writable<Record<string, string>>({});
 export const quickAccessPaths = writable<string[]>([]);
@@ -30,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);
@@ -37,39 +39,133 @@ export const activeNotePath = writable<string | null>(null);
 export const activeNotebook = writable<NotebookEntry | null>(null);
 export const activeTag = writable<string | null>(null);
 
+// Mobile state
+export const mobileView = writable<"sidebar" | "notelist" | "editor">(
+  "sidebar",
+);
+
 // Editor state
 export const editorDirty = writable(false);
 export const sourceMode = writable(false);
 export const focusMode = writable(false);
+export const readOnly = writable(false);
 
 // Theme
 export const theme = writable<string>("system");
 
-// Derived
-export const sortedNotes = derived([notes, sortMode], ([$notes, $sortMode]) => {
-  const pinned = $notes.filter((n) => n.meta.pinned);
-  const unpinned = $notes.filter((n) => !n.meta.pinned);
+// Update state
+export const updateAvailable = writable<{
+  version: string;
+  body?: string;
+} | null>(null);
+export const updateObj = writable<any>(null);
+export const installType = writable<string>("native");
+export const androidApkUrl = writable<string | null>(null);
 
-  const sortFn = (a: NoteEntry, b: NoteEntry) => {
-    switch ($sortMode) {
-      case "title":
-        return a.meta.title.localeCompare(b.meta.title);
-      case "created":
-        return (
-          new Date(b.meta.created).getTime() -
-          new Date(a.meta.created).getTime()
-        );
-      case "modified":
-      default:
-        return (
-          new Date(b.meta.modified).getTime() -
-          new Date(a.meta.modified).getTime()
-        );
+export async function checkForUpdate() {
+  try {
+    const { check } = await import("@tauri-apps/plugin-updater");
+    const update = await check();
+    if (update) {
+      updateAvailable.set({ version: update.version, body: update.body });
+      updateObj.set(update);
     }
-  };
+  } catch {
+    // Silent fail — don't disrupt app startup
+  }
+}
 
-  return [...pinned.sort(sortFn), ...unpinned.sort(sortFn)];
-});
+function isNewerVersion(remote: string, local: string): boolean {
+  const r = remote.split(".").map(Number);
+  const l = local.split(".").map(Number);
+  for (let i = 0; i < Math.max(r.length, l.length); i++) {
+    const rv = r[i] || 0;
+    const lv = l[i] || 0;
+    if (rv > lv) return true;
+    if (rv < lv) return false;
+  }
+  return false;
+}
+
+export async function checkForUpdateMobile() {
+  try {
+    const { getVersion } = await import("@tauri-apps/api/app");
+    const currentVersion = await getVersion();
+    const res = await fetch("https://helixnotes.com/latest.json");
+    if (!res.ok) return;
+    const data = await res.json();
+    if (data.version && isNewerVersion(data.version, currentVersion)) {
+      updateAvailable.set({ version: data.version, body: data.notes });
+      const android = data.platforms?.["android-universal"];
+      if (android?.url) {
+        androidApkUrl.set(android.url);
+      }
+    }
+  } catch {
+    // Silent fail
+  }
+}
+
+// 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],
+  ([$notes, $sortMode, $viewMode]) => {
+    // Quick Access preserves stored order
+    if ($viewMode === "quickaccess") return $notes;
+
+    const pinned = $notes.filter((n) => n.meta.pinned);
+    const unpinned = $notes.filter((n) => !n.meta.pinned);
+
+    const sortFn = (a: NoteEntry, b: NoteEntry) => {
+      switch ($sortMode) {
+        case "title":
+          return a.meta.title.localeCompare(b.meta.title);
+        case "created":
+          return (
+            new Date(b.meta.created).getTime() -
+            new Date(a.meta.created).getTime()
+          );
+        case "modified":
+        default:
+          return (
+            new Date(b.meta.modified).getTime() -
+            new Date(a.meta.modified).getTime()
+          );
+      }
+    };
+
+    return [...pinned.sort(sortFn), ...unpinned.sort(sortFn)];
+  },
+);
 
 export const vaultState = derived(
   [

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;
@@ -41,6 +53,7 @@ export interface AppConfig {
   accent_color: string | null;
   font_size: number | null;
   font_family: string | null;
+  line_height: number | null;
   compact_notes: boolean;
   time_format: string;
   gpu_acceleration: boolean;
@@ -59,6 +72,7 @@ export interface AppConfig {
   ai_provider: string | null;
   ai_api_key: string | null;
   openai_api_key: string | null;
+  ollama_base_url: string | null;
   ai_model: string;
   ai_writing_style: string | null;
   default_view_mode: boolean;
@@ -129,4 +143,5 @@ export type ViewMode =
   | "tag"
   | "trash"
   | "search"
-  | "quickaccess";
+  | "quickaccess"
+  | "daily";

src/lib/utils/window.ts

@@ -0,0 +1,42 @@
+import { WebviewWindow } from '@tauri-apps/api/webviewWindow';
+
+const openNoteWindows = new Map<string, string>();
+
+export async function openNoteWindow(notePath: string, noteTitle: string) {
+	const existingLabel = openNoteWindows.get(notePath);
+	if (existingLabel) {
+		const existing = await WebviewWindow.getByLabel(existingLabel);
+		if (existing) {
+			await existing.show();
+			await existing.unminimize();
+			await existing.setFocus();
+			return;
+		}
+		openNoteWindows.delete(notePath);
+	}
+
+	const label = `note-${Date.now()}`;
+	const url = `/?note=${encodeURIComponent(notePath)}`;
+
+	const noteWindow = new WebviewWindow(label, {
+		url,
+		title: `${noteTitle} - HelixNotes`,
+		width: 900,
+		height: 700,
+		minWidth: 500,
+		minHeight: 400,
+		decorations: false,
+		center: true
+	});
+
+	openNoteWindows.set(notePath, label);
+
+	noteWindow.once('tauri://destroyed', () => {
+		openNoteWindows.delete(notePath);
+	});
+
+	noteWindow.once('tauri://error', (e) => {
+		console.error('Failed to create note window:', e);
+		openNoteWindows.delete(notePath);
+	});
+}

src/routes/+layout.svelte

@@ -1,13 +1,14 @@
 <script lang="ts">
 	import { onMount } from 'svelte';
 	import '../app.css';
-	import { theme, appConfig, activeNotePath } from '$lib/stores/app';
-	import { openUrl } from '@tauri-apps/plugin-opener';
-	import { openFile } from '$lib/api';
+	import { theme, appConfig, activeNote, activeNotePath, installType, checkForUpdate, checkForUpdateMobile } from '$lib/stores/app';
+	import { openFile, openUrl, readNote, getInstallType } from '$lib/api';
 	import { get } from 'svelte/store';
 
 	let { children } = $props();
 
+	const isMobile = /android|ios/i.test(navigator.userAgent);
+
 	// Reactively apply theme class to <html> whenever $theme changes
 	$effect(() => {
 		const t = $theme;
@@ -31,26 +32,32 @@
 		return resolved.join('/');
 	}
 
-	// Intercept all link clicks in capture phase to prevent webview navigation
-	onMount(() => {
-		function handleLinkClick(e: MouseEvent) {
-			const target = (e.target as HTMLElement)?.closest('a');
-			if (!target) return;
-			const href = target.getAttribute('href');
-			if (!href) return;
+	const isAndroid = /android/i.test(navigator.userAgent);
 
-			e.preventDefault();
-			e.stopPropagation();
-			e.stopImmediatePropagation();
+	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));
+		}
+	}
 
-			if (href.startsWith('http://') || href.startsWith('https://') || href.startsWith('mailto:')) {
-				openUrl(href).catch((err) => console.error('Failed to open URL:', err));
-			} else if (!href.startsWith('#')) {
-				const decoded = decodeURIComponent(href);
-				const config = get(appConfig);
-				const vaultRoot = config?.active_vault;
-				let absPath = decoded;
-				if (!decoded.startsWith('/') && vaultRoot) {
+	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));
+		} else if (!href.startsWith('#')) {
+			const decoded = decodeURIComponent(href);
+			const config = get(appConfig);
+			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('/'));
@@ -59,16 +66,103 @@
 						absPath = normalizePath(`${vaultRoot}/${decoded}`);
 					}
 				}
-				openFile(absPath).catch((err) => console.error('Failed to open file:', err));
 			}
+			// Internal .md note link — navigate within the app
+			if (absPath.endsWith('.md')) {
+				readNote(absPath).then((content) => {
+					activeNote.set({ ...content, content: content.content });
+					activeNotePath.set(absPath);
+				}).catch((err) => console.error('Failed to navigate to note:', err));
+			} else {
+				openLocalFile(absPath);
+			}
+		}
+	}
+
+	// Detect install type and check for updates on startup
+	onMount(() => {
+		if (isMobile) {
+			installType.set('android');
+			checkForUpdateMobile();
+		} else {
+			getInstallType().then(t => installType.set(t)).catch(() => {});
+			checkForUpdate();
+		}
+	});
+
+	// Intercept all link clicks in capture phase to prevent webview navigation
+	onMount(() => {
+		function handleLinkClick(e: MouseEvent) {
+			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;
+			e.preventDefault();
+			e.stopPropagation();
+			e.stopImmediatePropagation();
+			resolveAndHandleLink(href);
 		}
 
 		document.addEventListener('click', handleLinkClick, true);
-		return () => document.removeEventListener('click', handleLinkClick, true);
+
+		// On Android WebView, tapping a link can trigger native navigation before
+		// the JS click event fires (causing 404s for relative .md links).
+		// We intercept touchend: if it's a tap (not a scroll) on an <a>, we
+		// preventDefault to block the native navigation and handle it ourselves.
+		let touchStartY = 0;
+		function handleTouchStart(e: TouchEvent) {
+			touchStartY = e.touches[0]?.clientY ?? 0;
+		}
+		function handleTouchEnd(e: TouchEvent) {
+			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;
+			// 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;
+			e.preventDefault();
+			resolveAndHandleLink(href);
+		}
+
+		if (isMobile) {
+			document.addEventListener('touchstart', handleTouchStart, { capture: true, passive: true });
+			document.addEventListener('touchend', handleTouchEnd, true);
+		}
+
+		return () => {
+			document.removeEventListener('click', handleLinkClick, true);
+			if (isMobile) {
+				document.removeEventListener('touchstart', handleTouchStart, true);
+				document.removeEventListener('touchend', handleTouchEnd, true);
+			}
+		};
 	});
 </script>
 
-<svelte:document oncontextmenu={(e) => e.preventDefault()} />
+<svelte:document oncontextmenu={(e) => { if (!isMobile) e.preventDefault(); }} />
 
 <svelte:head>
 	<title>HelixNotes</title>

src/routes/+page.svelte

@@ -4,10 +4,19 @@
 	import { getAppConfig, openVault } from '$lib/api';
 	import VaultPicker from '$lib/components/VaultPicker.svelte';
 	import AppLayout from '$lib/components/AppLayout.svelte';
+	import NoteWindow from '$lib/components/NoteWindow.svelte';
 
 	let loading = $state(true);
+	let noteWindowPath = $state<string | null>(null);
 
 	onMount(async () => {
+		// Check for note window mode
+		const params = new URLSearchParams(window.location.search);
+		const notePath = params.get('note');
+		if (notePath) {
+			noteWindowPath = notePath;
+		}
+
 		try {
 			const config = await getAppConfig();
 			$appConfig = config;
@@ -25,6 +34,9 @@
 			if (config.font_size) {
 				document.documentElement.style.setProperty('--editor-font-size', `${config.font_size}px`);
 			}
+			if (config.line_height) {
+				document.documentElement.style.setProperty('--editor-line-height', String(config.line_height));
+			}
 			if (config.font_family) {
 				const fontStacks: Record<string, string> = {
 					system: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
@@ -69,7 +81,10 @@
 			// Auto-open last vault if available
 			if (config.active_vault) {
 				try {
-					await openVault(config.active_vault);
+					// Note windows don't re-open the vault (already open in main process)
+					if (!noteWindowPath) {
+						await openVault(config.active_vault);
+					}
 					$vaultReady = true;
 				} catch {
 					// Vault path might not exist anymore
@@ -86,6 +101,8 @@
 	<div class="loading">
 		<div class="spinner"></div>
 	</div>
+{:else if noteWindowPath}
+	<NoteWindow notePath={noteWindowPath} />
 {:else if $vaultReady}
 	<AppLayout />
 {:else}

tsconfig.json

@@ -1,20 +1,20 @@
 {
-	"extends": "./.svelte-kit/tsconfig.json",
-	"compilerOptions": {
-		"rewriteRelativeImportExtensions": true,
-		"allowJs": true,
-		"checkJs": true,
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"sourceMap": true,
-		"strict": true,
-		"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
-	//
-	// To make changes to top-level options such as include and exclude, we recommend extending
-	// the generated config; see https://svelte.dev/docs/kit/configuration#typescript
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "rewriteRelativeImportExtensions": true,
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "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
+  //
+  // To make changes to top-level options such as include and exclude, we recommend extending
+  // the generated config; see https://svelte.dev/docs/kit/configuration#typescript
 }