fix(mobile): expose notebook actions

Pressing ctrl-F doesn’t refocus the search field if there is already a search term, it only focuses search on 1st open of the search field. This PR fixes it so that every time the user presses CTRL+F, the search field is focused again.

Tested on linux.

Reviewed-on: https://codeberg.org/ArkHost/HelixNotes/pulls/216

README.md

@@ -1,7 +1,7 @@
 # HelixNotes
 
-[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://codeberg.org/ArkHost/HelixNotes/src/branch/main/LICENSE)
-[![Latest Release](https://img.shields.io/badge/release-v1.2.9-green)](https://codeberg.org/ArkHost/HelixNotes/releases)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://gitlab.com/ArkHost/HelixNotes/-/blob/main/LICENSE)
+[![Latest Release](https://img.shields.io/badge/release-v1.3.4-green)](https://gitlab.com/ArkHost/HelixNotes/-/releases/v1.3.4)
 [![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)]()
 
@@ -10,7 +10,7 @@ A local markdown note-taking app built with Tauri, SvelteKit, and Rust.
 Your notes are stored as standard Markdown files on your local filesystem.
 No cloud, no lock-in.
 
-## Download (v1.2.9)
+## Download (v1.3.4)
 
 ### Linux
 
@@ -26,6 +26,12 @@ yay -S helixnotes-appimage-bin
 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
 ```
 
+#### Solus (EOPKG)
+
+```bash
+sudo eopkg it helixnotes
+```
+
 #### NixOS
 
 <details>
@@ -36,7 +42,7 @@ curl -fsSL https://repo.arkhost.com/gpg.key | sudo gpg --dearmor -o /usr/share/k
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     helix-notes = {
-      url = "git+https://codeberg.org/ArkHost/HelixNotes";
+      url = "git+https://gitlab.com/ArkHost/HelixNotes";
       # inputs.nixpkgs.follows = "nixpkgs";
     }
   };
@@ -86,44 +92,58 @@ curl -fsSL https://repo.arkhost.com/gpg.key | sudo gpg --dearmor -o /usr/share/k
 
 #### AppImage (Arch, Fedora 43+, openSUSE Tumbleweed)
 
-[Download AppImage](https://download.helixnotes.com/releases/v1.2.9/HelixNotes_1.2.9_amd64.AppImage)
+[Download AppImage](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_amd64.AppImage)
 
 #### .deb (manual)
 
-[Download .deb](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.9/HelixNotes_1.2.9_amd64.deb) (Ubuntu 22.04+)
+[Download .deb](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_amd64.deb) (Ubuntu 22.04+)
+
+#### .rpm (manual)
+
+[Download .rpm](https://download.helixnotes.com/releases/v1.3.4/HelixNotes-1.3.4-1.x86_64.rpm)
 
 ### Windows
 
-[Download Installer](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.9/HelixNotes_1.2.9_x64-setup.exe) (Windows 10/11)
+[Download Installer](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_x64-setup.exe) (Windows 10/11)
 
 ### macOS
 
-[Download .dmg](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.9/HelixNotes_1.2.9_x64.dmg) (Intel, runs on Apple Silicon via Rosetta)
+[Download .dmg (Apple Silicon)](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_aarch64.dmg) (M-series Macs)
+
+> **"HelixNotes is damaged and can't be opened"?** The app isn't damaged. The macOS build isn't notarized by Apple yet, so Gatekeeper blocks it on Apple Silicon. Run this once in Terminal, then open it normally (you'll need to redo it after each update):
+>
+> ```bash
+> xattr -cr /Applications/HelixNotes.app
+> ```
 
 ### Android
 
-[Download APK](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.2.9/HelixNotes_1.2.9_android.apk)
+[Download APK](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_android.apk)
 
 ---
 
-All releases: [codeberg.org/ArkHost/HelixNotes/releases](https://codeberg.org/ArkHost/HelixNotes/releases)
+All releases: [gitlab.com/ArkHost/HelixNotes/-/releases](https://gitlab.com/ArkHost/HelixNotes/-/releases)
 
 ## Features
 
 - Markdown editor with toolbar, slash commands, source mode, code highlighting
+- **Tasks view**: aggregate `- [ ]` checklists from across all notes, set priority and due dates, work in a list or a calendar (drag a task to reschedule)
 - `[[Wiki-links]]` and graph view
-- Full-text search (Tantivy)
-- Outline panel, daily notes with calendar view, tags, drag-and-drop
+- Full-text search (Tantivy), CJK-aware for Chinese, Japanese, and Korean
+- Outline panel, daily notes with calendar view, tags with autocomplete, drag-and-drop
 - Live KaTeX math editor (`/math`, `/imath`) with modal preview, double-click to edit
 - Mermaid diagrams (opt-in render, copy as PNG, save as PNG/SVG)
+- Encrypted secret blocks (`/secret`) stored as portable `helix-secret` markdown fences
+- Insert date/time (`/date`, `/time`, `/now`), color swatches (`/color`), configurable week start
 - Manual notebook sorting (drag to reorder above, into, or below)
 - External `.md` viewer mode with import-to-vault flow
 - PDF preview, Obsidian import, "Show in File Manager"
-- AI writing tools (Ollama / Anthropic / OpenAI)
+- AI writing tools (Ollama / OpenAI-compatible / Anthropic / OpenAI)
+- **Optional WebDAV sync** to your own server (Nextcloud, ownCloud, a NAS): manual or automatic, with keep-both conflict copies
 - Version history with diffs, automatic backups
 - Multi-window, file associations, focus mode, view mode
-- Themes, accent colors, fonts
-- Local files, no cloud
+- Themes (light, dark, and 14 palettes), accent colors, fonts, 80-200% interface scale
+- Local plain-text files, no company cloud
 
 Full documentation: [helixnotes.com/docs](https://helixnotes.com/docs.html)
 
@@ -158,10 +178,11 @@ 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)
+![Tasks calendar](https://cdn.helixnotes.com/assets/screenshots/screenshot-2.png)
+![Graph view](https://cdn.helixnotes.com/assets/screenshots/screenshot-7.png)
+![Daily notes](https://cdn.helixnotes.com/assets/screenshots/screenshot-4.png)
+![Themes](https://cdn.helixnotes.com/assets/screenshots/screenshot-6.png)
 
 ## License
 
-[AGPL-3.0](https://codeberg.org/ArkHost/HelixNotes/src/branch/main/LICENSE)
+[AGPL-3.0](https://gitlab.com/ArkHost/HelixNotes/-/blob/main/LICENSE)

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1777268161,
-        "narHash": "sha256-bxrdOn8SCOv8tN4JbTF/TXq7kjo9ag4M+C8yzzIRYbE=",
+        "lastModified": 1782959384,
+        "narHash": "sha256-xnJJk+ct+D2+wdRxj1wk36w5zV9RVESwRqcklPdt3fM=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1c3fe55ad329cbcb28471bb30f05c9827f724c76",
+        "rev": "65179426c83bb3f6bc14898b42ea1c6f01d374b0",
         "type": "github"
       },
       "original": {

flake.nix

@@ -6,71 +6,77 @@
     flake-utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = {
-    self,
-    nixpkgs,
-    flake-utils,
-  }:
-    flake-utils.lib.eachDefaultSystem (system: let
-      pkgs = import nixpkgs {inherit system;};
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = import nixpkgs { inherit system; };
 
-      cargoToml = builtins.fromTOML (builtins.readFile ./src-tauri/Cargo.toml);
-      pname = cargoToml.package.name;
-      version = cargoToml.package.version;
-    in {
-      packages.default = pkgs.rustPlatform.buildRustPackage {
-        inherit pname version;
-        src = ./.;
-
-        cargoHash = "sha256-QF4HMYBjrxCBiq6PcsNy+kEOq/j+3zDzlcT5dy7MtQk=";
-
-        pnpmDeps = pkgs.fetchPnpmDeps {
+        cargoToml = builtins.fromTOML (builtins.readFile ./src-tauri/Cargo.toml);
+        pname = cargoToml.package.name;
+        version = cargoToml.package.version;
+      in
+      {
+        packages.default = pkgs.rustPlatform.buildRustPackage {
           inherit pname version;
           src = ./.;
-          fetcherVersion = 3;
-          hash = "sha256-Odmd1gwioCvnnExvCOQwDPCgLyrBfTpeUKHy3BrNtiM=";
-        };
 
-        nativeBuildInputs = with pkgs; [
-          cargo-tauri.hook
+          cargoHash = "sha256-oPShWgL5DjucCmQgqKbIBaxRwqyWnae52+Hj/YVIqbE=";
 
-          pnpmConfigHook
-          pnpm
-          nodejs
+          pnpmDeps = pkgs.fetchPnpmDeps {
+            inherit pname version;
+            src = ./.;
+            fetcherVersion = 3;
+            hash = "sha256-0TFLZY9zmRFNHPFJEiU2U8zMqSSPkeCl4bhORAbcdZY=";
+          };
 
-          pkg-config
-          jq
-          moreutils
-          wrapGAppsHook3
-        ];
+          nativeBuildInputs = with pkgs; [
+            cargo-tauri.hook
 
-        buildInputs = with pkgs;
-          lib.optionals stdenv.hostPlatform.isLinux [
-            webkitgtk_4_1
-            libayatana-appindicator
+            pnpmConfigHook
+            pnpm
+            nodejs
+
+            pkg-config
+            jq
+            moreutils
+            wrapGAppsHook3
           ];
 
-        cargoRoot = "src-tauri";
-        buildAndTestSubdir = self.packages.${system}.default.cargoRoot;
+          buildInputs =
+            with pkgs;
+            lib.optionals stdenv.hostPlatform.isLinux [
+              webkitgtk_4_1
+              libayatana-appindicator
+            ];
 
-        # Deactivate the upstream update mechanism
-        postPatch = ''
-          jq '
-            .bundle.createUpdaterArtifacts = false |
-            .plugins.updater = {"active": false, "pubkey": "", "endpoints": []}
-          ' \
-          src-tauri/tauri.conf.json | sponge src-tauri/tauri.conf.json
-        '';
+          cargoRoot = "src-tauri";
+          buildAndTestSubdir = self.packages.${system}.default.cargoRoot;
 
-        meta = with pkgs.lib; {
-          description = "HelixNotes desktop application";
-          homepage = "https://helixnotes.com/";
-          license = licenses.agpl3Plus;
-          platforms = platforms.linux ++ platforms.darwin;
-          mainProgram = "helixnotes";
+          # Deactivate the upstream update mechanism
+          postPatch = ''
+            jq '
+              .bundle.createUpdaterArtifacts = false |
+              .plugins.updater = {"active": false, "pubkey": "", "endpoints": []}
+            ' \
+            src-tauri/tauri.conf.json | sponge src-tauri/tauri.conf.json
+          '';
+
+          meta = with pkgs.lib; {
+            description = "HelixNotes desktop application";
+            homepage = "https://helixnotes.com/";
+            license = licenses.agpl3Plus;
+            platforms = platforms.linux ++ platforms.darwin;
+            mainProgram = "helixnotes";
+          };
         };
-      };
 
-      formatter = pkgs.alejandra;
-    });
+        formatter = pkgs.nixfmt;
+      }
+    );
 }

package.json

@@ -2,7 +2,7 @@
   "name": "helixnotes",
   "private": true,
   "license": "AGPL-3.0-or-later",
-  "version": "1.3.0",
+  "version": "1.3.4",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
@@ -59,6 +59,7 @@
     "@tiptap/starter-kit": "^3.19.0",
     "@types/katex": "^0.16.8",
     "@types/markdown-it": "^14.1.2",
+    "highlight.js": "^11.11.1",
     "katex": "^0.16.28",
     "lowlight": "^3.3.0",
     "markdown-it": "^14.1.0",

pnpm-lock.yaml

@@ -95,6 +95,9 @@ importers:
       '@types/markdown-it':
         specifier: ^14.1.2
         version: 14.1.2
+      highlight.js:
+        specifier: ^11.11.1
+        version: 11.11.1
       katex:
         specifier: ^0.16.28
         version: 0.16.28

src-tauri/Cargo.lock

@@ -1850,7 +1850,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "helixnotes"
-version = "1.3.0"
+version = "1.3.4"
 dependencies = [
  "arboard",
  "chrono",
@@ -1860,6 +1860,7 @@ dependencies = [
  "image",
  "log",
  "notify",
+ "objc2-app-kit",
  "png 0.17.16",
  "quick-xml 0.36.2",
  "rayon",
@@ -1876,6 +1877,7 @@ dependencies = [
  "tauri-build",
  "tauri-plugin-dialog",
  "tauri-plugin-fs",
+ "tauri-plugin-ios-vault-access",
  "tauri-plugin-log",
  "tauri-plugin-opener",
  "tauri-plugin-single-instance",
@@ -5201,6 +5203,15 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "tauri-plugin-ios-vault-access"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "tauri",
+ "tauri-plugin",
+]
+
 [[package]]
 name = "tauri-plugin-log"
 version = "2.8.0"

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "helixnotes"
-version = "1.3.0"
+version = "1.3.4"
 description = "Local markdown note-taking app"
 authors = ["HelixNotes"]
 license = "AGPL-3.0-or-later"
@@ -42,6 +42,12 @@ quick-xml = "0.36"
 urlencoding = "2"
 sha2 = "0.10"
 rustls = { version = "0.23", default-features = false, features = ["ring", "logging", "std", "tls12"] }
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2-app-kit = "0.3.2"
+
+[target.'cfg(target_os = "ios")'.dependencies]
+tauri-plugin-ios-vault-access = { path = "plugins/ios-vault-access" }
+
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-updater = "2"
 tauri-plugin-single-instance = "2"

src-tauri/Info.ios.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>UIFileSharingEnabled</key>
+    <true/>
+    <key>LSSupportsOpeningDocumentsInPlace</key>
+    <true/>
+</dict>
+</plist>

src-tauri/entitlements.plist

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Hardened runtime entitlements for Developer ID distribution (outside Mac App Store).
+         Required for notarization. These do NOT enable App Sandbox.
+         Without these, the WebKit webview and bundled Rust libraries get killed by the
+         hardened runtime's library validation. -->
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+    <!-- Network access for auto-updater, AI features, WebDAV sync, image proxy -->
+    <key>com.apple.security.network.client</key>
+    <true/>
+</dict>
+</plist>

src-tauri/gen/android/app/src/main/java/com/helixnotes/app/MainActivity.kt

@@ -26,6 +26,13 @@ class MainActivity : TauriActivity() {
     super.onWebViewCreate(webView)
     this.webView = webView
     webView.addJavascriptInterface(StorageBridge(this), "Android")
+    // Render text at the size CSS specifies, ignoring the device's system font-size
+    // accessibility setting (textZoom is otherwise tied to the system font scale). (#100)
+    webView.settings.textZoom = 100
+    // The actual fix: disable WebView "text autosizing" / font-boosting, which recomputes
+    // paragraph font-size and line-height from viewport heuristics and ignores our CSS (only
+    // size + line-height were affected; font-family was fine). NORMAL turns it off. (#100)
+    webView.settings.layoutAlgorithm = android.webkit.WebSettings.LayoutAlgorithm.NORMAL
   }
 
   override fun onResume() {

src-tauri/gen/android/app/src/main/res/values/ic_launcher_background.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-  <color name="ic_launcher_background">#fff</color>
+  <color name="ic_launcher_background">#626ED4</color>
 </resources>

src-tauri/icons/icon-foreground.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">
+  <g transform="translate(85.333 85.333) scale(0.666667)">
+  <line x1="178.45584" y1="178.45584" x2="333.54416" y2="333.54416" stroke="#ffffff" stroke-width="25" stroke-opacity="0.5" stroke-linecap="round"/>
+  <line x1="337.53708" y1="174.46292" x2="174.46294" y2="337.53708" stroke="#ffffff" stroke-width="25" stroke-opacity="0.5" stroke-linecap="round"/>
+  <circle cx="153" cy="153" r="36" fill="#ffffff"/>
+  <circle cx="359" cy="153" r="36" fill="#ffffff"/>
+  <circle cx="153" cy="359" r="36" fill="#ffffff"/>
+  <circle cx="359" cy="359" r="36" fill="#ffffff"/>
+  </g>
+</svg>

src-tauri/icons/icon.svg

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="512"
+   height="512"
+   viewBox="0 0 512 512"
+   version="1.1"
+   id="svg5"
+   xmlns="http://www.w3.org/2000/svg"><rect
+     width="512"
+     height="512"
+     rx="112"
+     ry="112"
+     fill="#626ED4"
+     id="rect1" /><line
+     x1="178.45584"
+     y1="178.45584"
+     x2="333.54416"
+     y2="333.54416"
+     stroke="#ffffff"
+     stroke-width="25"
+     stroke-opacity="0.5"
+     stroke-linecap="round"
+     id="line1" /><line
+     x1="337.53708"
+     y1="174.46292"
+     x2="174.46294"
+     y2="337.53708"
+     stroke="#ffffff"
+     stroke-width="25"
+     stroke-opacity="0.5"
+     stroke-linecap="round"
+     id="line2" /><circle
+     cx="153"
+     cy="153"
+     r="36"
+     fill="#ffffff"
+     id="circle2" /><circle
+     cx="359"
+     cy="153"
+     r="36"
+     fill="#ffffff"
+     id="circle3" /><circle
+     cx="153"
+     cy="359"
+     r="36"
+     fill="#ffffff"
+     id="circle4" /><circle
+     cx="359"
+     cy="359"
+     r="36"
+     fill="#ffffff"
+     id="circle5" /></svg>

src-tauri/my-theme.json

@@ -0,0 +1,21 @@
+{
+  "themes": [
+    {
+      "colors": {
+        "bg_active": "#373a52",
+        "bg_editor": "#1a1b26",
+        "bg_hover": "#2f3145",
+        "bg_primary": "#1a1b26",
+        "bg_secondary": "#1f2029",
+        "bg_tertiary": "#2a2b3d",
+        "border_color": "#2f3145",
+        "text_primary": "#c8cde4",
+        "text_secondary": "#6b7094"
+      },
+      "id": "custom-1782146306429",
+      "is_dark": true,
+      "name": "My theme"
+    }
+  ],
+  "version": 1
+}

src-tauri/plugins/ios-vault-access/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tauri-plugin-ios-vault-access"
+version = "0.1.0"
+authors = ["HelixNotes"]
+description = "iOS Files folder access for HelixNotes"
+edition = "2021"
+rust-version = "1.77.2"
+links = "tauri-plugin-ios-vault-access"
+
+[dependencies]
+tauri = "2"
+serde = { version = "1", features = ["derive"] }
+
+[build-dependencies]
+tauri-plugin = { version = "2", features = ["build"] }

src-tauri/plugins/ios-vault-access/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_plugin::Builder::new(&[]).ios_path("ios").build();
+}

src-tauri/plugins/ios-vault-access/ios/Package.swift

@@ -0,0 +1,24 @@
+// swift-tools-version:5.3
+import PackageDescription
+
+let package = Package(
+    name: "tauri-plugin-ios-vault-access",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "tauri-plugin-ios-vault-access",
+            type: .static,
+            targets: ["tauri-plugin-ios-vault-access"]
+        )
+    ],
+    dependencies: [
+        .package(name: "Tauri", path: "../.tauri/tauri-api")
+    ],
+    targets: [
+        .target(
+            name: "tauri-plugin-ios-vault-access",
+            dependencies: [.byName(name: "Tauri")],
+            path: "Sources"
+        )
+    ]
+)

src-tauri/plugins/ios-vault-access/ios/Sources/IosVaultAccessPlugin.swift

@@ -0,0 +1,312 @@
+import Foundation
+import SwiftRs
+import Tauri
+import UIKit
+import UniformTypeIdentifiers
+
+private struct BookmarkRequest: Decodable {
+    let bookmarkId: String
+}
+
+final class IosVaultAccessPlugin: Plugin, UIDocumentPickerDelegate {
+    private let fileManager = FileManager.default
+    private let lock = NSLock()
+    private var pickerInvoke: Invoke?
+    private var activeBookmarkId: String?
+    private var activeURL: URL?
+    private var stagedBookmarkId: String?
+    private var stagedURL: URL?
+
+    deinit {
+        rollbackStagedScope()
+        releaseCurrentScope()
+    }
+
+    @objc func chooseFolder(_ invoke: Invoke) {
+        DispatchQueue.main.async {
+            guard self.pickerInvoke == nil else {
+                invoke.reject("A folder picker is already open.")
+                return
+            }
+            guard let viewController = self.manager.viewController else {
+                self.pickerInvoke = nil
+                invoke.reject("Files is unavailable right now. Try again.")
+                return
+            }
+            self.pickerInvoke = invoke
+            let picker = UIDocumentPickerViewController(
+                forOpeningContentTypes: [.folder],
+                asCopy: false
+            )
+            picker.delegate = self
+            picker.allowsMultipleSelection = false
+            viewController.present(picker, animated: true)
+        }
+    }
+
+    @objc func resolveFolder(_ invoke: Invoke) throws {
+        let request = try invoke.parseArgs(BookmarkRequest.self)
+        do {
+            invoke.resolve(try resolveBookmark(request.bookmarkId))
+        } catch {
+            invoke.reject(message(for: error))
+        }
+    }
+
+    @objc func releaseActive(_ invoke: Invoke) {
+        rollbackStagedScope()
+        releaseCurrentScope()
+        invoke.resolve()
+    }
+
+    @objc func commitStaged(_ invoke: Invoke) {
+        commitStagedScope()
+        invoke.resolve()
+    }
+
+    @objc func rollbackStaged(_ invoke: Invoke) {
+        rollbackStagedScope()
+        invoke.resolve()
+    }
+
+    @objc func forgetBookmark(_ invoke: Invoke) throws {
+        let request = try invoke.parseArgs(BookmarkRequest.self)
+        do {
+            let file = try bookmarkFile(for: request.bookmarkId, createDirectory: false)
+            lock.lock()
+            let isActive = activeBookmarkId == request.bookmarkId
+            let isStaged = stagedBookmarkId == request.bookmarkId
+            lock.unlock()
+            if fileManager.fileExists(atPath: file.path) {
+                try fileManager.removeItem(at: file)
+            }
+            if isActive {
+                releaseCurrentScope()
+            }
+            if isStaged {
+                rollbackStagedScope()
+            }
+            invoke.resolve()
+        } catch {
+            invoke.reject(message(for: error))
+        }
+    }
+
+    func documentPicker(
+        _ controller: UIDocumentPickerViewController,
+        didPickDocumentsAt urls: [URL]
+    ) {
+        guard let invoke = takePickerInvoke() else { return }
+        guard let url = urls.first else {
+            invoke.resolve(cancelledResult())
+            return
+        }
+
+        do {
+            guard url.startAccessingSecurityScopedResource() else {
+                throw AccessError.denied
+            }
+            var adopted = false
+            defer {
+                if !adopted { url.stopAccessingSecurityScopedResource() }
+            }
+
+            let name = try validateFolder(url)
+            let bookmarkId = existingBookmarkId(for: url) ?? UUID().uuidString.lowercased()
+            let bookmark = try url.bookmarkData(
+                options: .minimalBookmark,
+                includingResourceValuesForKeys: nil,
+                relativeTo: nil
+            )
+            try bookmark.write(to: bookmarkFile(for: bookmarkId, createDirectory: true), options: .atomic)
+            stageScope(url: url, bookmarkId: bookmarkId)
+            adopted = true
+            invoke.resolve(result(bookmarkId: bookmarkId, url: url, name: name))
+        } catch {
+            invoke.reject(message(for: error))
+        }
+    }
+
+    func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+        takePickerInvoke()?.resolve(cancelledResult())
+    }
+
+    private func resolveBookmark(_ bookmarkId: String) throws -> [String: Any] {
+        guard UUID(uuidString: bookmarkId) != nil else { throw AccessError.missing }
+
+        lock.lock()
+        let currentURL = activeBookmarkId == bookmarkId ? activeURL : nil
+        lock.unlock()
+        if let currentURL {
+            return result(bookmarkId: bookmarkId, url: currentURL, name: try validateFolder(currentURL))
+        }
+
+        let data = try Data(contentsOf: bookmarkFile(for: bookmarkId, createDirectory: false))
+        var stale = false
+        let url = try URL(
+            resolvingBookmarkData: data,
+            options: [],
+            relativeTo: nil,
+            bookmarkDataIsStale: &stale
+        )
+        guard url.startAccessingSecurityScopedResource() else { throw AccessError.denied }
+        var adopted = false
+        defer {
+            if !adopted { url.stopAccessingSecurityScopedResource() }
+        }
+
+        let name = try validateFolder(url)
+        if stale {
+            let refreshed = try url.bookmarkData(
+                options: .minimalBookmark,
+                includingResourceValuesForKeys: nil,
+                relativeTo: nil
+            )
+            try refreshed.write(to: bookmarkFile(for: bookmarkId, createDirectory: true), options: .atomic)
+        }
+        stageScope(url: url, bookmarkId: bookmarkId)
+        adopted = true
+        return result(bookmarkId: bookmarkId, url: url, name: name)
+    }
+
+    private func validateFolder(_ url: URL) throws -> String {
+        let values = try url.resourceValues(forKeys: [.isDirectoryKey, .nameKey])
+        guard values.isDirectory == true else { throw AccessError.notFolder }
+        guard try url.checkResourceIsReachable() else { throw AccessError.unavailable }
+        return values.name ?? url.lastPathComponent
+    }
+
+    private func stageScope(url: URL, bookmarkId: String) {
+        lock.lock()
+        let previous = stagedURL
+        stagedURL = url
+        stagedBookmarkId = bookmarkId
+        lock.unlock()
+        previous?.stopAccessingSecurityScopedResource()
+    }
+
+    private func commitStagedScope() {
+        lock.lock()
+        guard let next = stagedURL else {
+            lock.unlock()
+            return
+        }
+        let previous = activeURL
+        activeURL = next
+        activeBookmarkId = stagedBookmarkId
+        stagedURL = nil
+        stagedBookmarkId = nil
+        lock.unlock()
+        previous?.stopAccessingSecurityScopedResource()
+    }
+
+    private func rollbackStagedScope() {
+        lock.lock()
+        let staged = stagedURL
+        stagedURL = nil
+        stagedBookmarkId = nil
+        lock.unlock()
+        staged?.stopAccessingSecurityScopedResource()
+    }
+
+    private func releaseCurrentScope() {
+        lock.lock()
+        let previous = activeURL
+        activeURL = nil
+        activeBookmarkId = nil
+        lock.unlock()
+        previous?.stopAccessingSecurityScopedResource()
+    }
+
+    private func takePickerInvoke() -> Invoke? {
+        let invoke = pickerInvoke
+        pickerInvoke = nil
+        return invoke
+    }
+
+    private func bookmarkDirectory(create: Bool) throws -> URL {
+        let base = try fileManager.url(
+            for: .applicationSupportDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )
+        let directory = base.appendingPathComponent("VaultBookmarks", isDirectory: true)
+        if create {
+            try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        }
+        return directory
+    }
+
+    private func bookmarkFile(for id: String, createDirectory: Bool) throws -> URL {
+        guard UUID(uuidString: id) != nil else { throw AccessError.missing }
+        let directory = try bookmarkDirectory(create: createDirectory)
+        return directory.appendingPathComponent("\(id).bookmark")
+    }
+
+    private func existingBookmarkId(for selectedURL: URL) -> String? {
+        guard
+            let directory = try? bookmarkDirectory(create: true),
+            let files = try? fileManager.contentsOfDirectory(
+                at: directory,
+                includingPropertiesForKeys: nil
+            )
+        else { return nil }
+
+        let selectedPath = selectedURL.standardizedFileURL.path
+        for file in files where file.pathExtension == "bookmark" {
+            guard let data = try? Data(contentsOf: file) else { continue }
+            var stale = false
+            guard
+                let resolved = try? URL(
+                    resolvingBookmarkData: data,
+                    options: [],
+                    relativeTo: nil,
+                    bookmarkDataIsStale: &stale
+                ),
+                resolved.standardizedFileURL.path == selectedPath
+            else { continue }
+            let id = file.deletingPathExtension().lastPathComponent
+            if UUID(uuidString: id) != nil { return id }
+        }
+        return nil
+    }
+
+    private func result(bookmarkId: String, url: URL, name: String) -> [String: Any] {
+        ["bookmarkId": bookmarkId, "path": url.path, "name": name, "cancelled": false]
+    }
+
+    private func cancelledResult() -> [String: Any] {
+        ["bookmarkId": "", "path": "", "name": "", "cancelled": true]
+    }
+
+    private func message(for error: Error) -> String {
+        if let accessError = error as? AccessError { return accessError.localizedDescription }
+        return "The selected folder is unavailable. Open Files and try again."
+    }
+}
+
+private enum AccessError: LocalizedError {
+    case denied
+    case missing
+    case notFolder
+    case unavailable
+
+    var errorDescription: String? {
+        switch self {
+        case .denied:
+            return "HelixNotes no longer has access to this folder. Choose it again in Files."
+        case .missing:
+            return "Saved access to this folder is missing. Choose it again in Files."
+        case .notFolder:
+            return "The selected item is not a folder."
+        case .unavailable:
+            return "The selected folder is unavailable. Open Files and try again."
+        }
+    }
+}
+
+@_cdecl("init_plugin_ios_vault_access")
+func initPlugin() -> Plugin {
+    IosVaultAccessPlugin()
+}

src-tauri/plugins/ios-vault-access/src/lib.rs

@@ -0,0 +1,84 @@
+use serde::{Deserialize, Serialize};
+use tauri::{
+    plugin::{Builder, PluginHandle, TauriPlugin},
+    Manager, Runtime,
+};
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FolderSelection {
+    pub bookmark_id: String,
+    pub path: String,
+    pub name: String,
+    #[serde(default)]
+    pub cancelled: bool,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct BookmarkRequest<'a> {
+    bookmark_id: &'a str,
+}
+
+#[cfg(target_os = "ios")]
+tauri::ios_plugin_binding!(init_plugin_ios_vault_access);
+
+pub struct IosVaultAccess<R: Runtime>(PluginHandle<R>);
+
+impl<R: Runtime> IosVaultAccess<R> {
+    pub fn choose_folder(&self) -> Result<FolderSelection, String> {
+        self.0
+            .run_mobile_plugin("chooseFolder", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn resolve_folder(&self, bookmark_id: &str) -> Result<FolderSelection, String> {
+        self.0
+            .run_mobile_plugin("resolveFolder", BookmarkRequest { bookmark_id })
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn release_active(&self) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("releaseActive", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn commit_staged(&self) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("commitStaged", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn rollback_staged(&self) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("rollbackStaged", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn forget_bookmark(&self, bookmark_id: &str) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("forgetBookmark", BookmarkRequest { bookmark_id })
+            .map_err(|error| error.to_string())
+    }
+}
+
+pub trait IosVaultAccessExt<R: Runtime> {
+    fn ios_vault_access(&self) -> &IosVaultAccess<R>;
+}
+
+impl<R: Runtime, T: Manager<R>> IosVaultAccessExt<R> for T {
+    fn ios_vault_access(&self) -> &IosVaultAccess<R> {
+        self.state::<IosVaultAccess<R>>().inner()
+    }
+}
+
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("ios-vault-access")
+        .setup(|app, api| {
+            let handle = api.register_ios_plugin(init_plugin_ios_vault_access)?;
+            app.manage(IosVaultAccess(handle));
+            Ok(())
+        })
+        .build()
+}

src-tauri/src/ai.rs

@@ -55,8 +55,8 @@ pub fn ai_request(
                     if url.is_empty() {
                         Err("No base URL configured for OpenAI Compatible provider".to_string())
                     } else {
-                        let url = format!("{}/v1/completions", url.trim_end_matches('/'));
-                        stream_completions(
+                        let url = format!("{}/v1/chat/completions", normalize_openai_base(url));
+                        stream_openai(
                             &app,
                             &url,
                             key_opt,
@@ -94,6 +94,13 @@ pub fn ai_request(
     });
 }
 
+/// Normalize an OpenAI-compatible base URL: drop a trailing slash and a trailing `/v1`,
+/// so both `https://host` and `https://host/v1` work (we append `/v1/chat/completions`).
+fn normalize_openai_base(base: &str) -> String {
+    let b = base.trim().trim_end_matches('/');
+    b.strip_suffix("/v1").unwrap_or(b).trim_end_matches('/').to_string()
+}
+
 async fn stream_anthropic(
     app: &AppHandle,
     api_key: &str,
@@ -386,8 +393,8 @@ pub async fn test_connection(
             if url.is_empty() {
                 return Err("No base URL configured for OpenAI Compatible provider".to_string());
             }
-            let url = format!("{}/v1/completions", url.trim_end_matches('/'));
-            test_completions(&url, key_opt, model).await
+            let url = format!("{}/v1/chat/completions", normalize_openai_base(url));
+            test_openai(&url, key_opt, model).await
         }
         _ => test_anthropic(api_key, model).await,
     }
@@ -398,7 +405,7 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
 
     let body = json!({
         "model": model,
-        "max_tokens": 10,
+        "max_tokens": 20,
         "messages": [
             {
                 "role": "user",
@@ -426,174 +433,15 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
     }
 }
 
-async fn stream_completions(
-    app: &AppHandle,
-    url: &str,
-    api_key: Option<&str>,
-    model: &str,
-    system_prompt: &str,
-    user_message: &str,
-    _request_id: &str,
-) -> Result<(), String> {
-    let client = Client::new();
-
-    let prompt = format!("{}\n\nUser: {}\nAssistant:", system_prompt, user_message);
-
-    let body = json!({
-        "model": model,
-        "prompt": prompt,
-        "max_tokens": 4096,
-        "stream": true,
-        "temperature": 0.7
-    });
-
-    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
-        .map_err(|e| format!("Request failed: {}", e))?;
-
-    if !response.status().is_success() {
-        let status = response.status();
-        let body_text = response.text().await.unwrap_or_default();
-        return Err(format!("API error {}: {}", status, body_text));
-    }
-
-    // Parse SSE stream
-    use futures::StreamExt;
-    let mut stream = response.bytes_stream();
-    let mut buffer = String::new();
-
-    while let Some(chunk) = stream.next().await {
-        let chunk = chunk.map_err(|e| format!("Stream error: {}", e))?;
-        buffer.push_str(&String::from_utf8_lossy(&chunk));
-
-        // Process complete SSE events from buffer
-        while let Some(event_end) = buffer.find("\n\n") {
-            let event_str = buffer[..event_end].to_string();
-            buffer = buffer[event_end + 2..].to_string();
-
-            for line in event_str.lines() {
-                if let Some(data) = line.strip_prefix("data: ") {
-                    if data == "[DONE]" {
-                        let _ = app.emit(
-                            "ai-stream",
-                            AiStreamEvent {
-                                event_type: "done".to_string(),
-                                text: None,
-                                error: None,
-                            },
-                        );
-                        return Ok(());
-                    }
-
-                    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(data) {
-                        // Completions streaming: choices[0].text
-                        if let Some(text) = parsed["choices"][0]["text"].as_str() {
-                            if !text.is_empty() {
-                                let _ = app.emit(
-                                    "ai-stream",
-                                    AiStreamEvent {
-                                        event_type: "text".to_string(),
-                                        text: Some(text.to_string()),
-                                        error: None,
-                                    },
-                                );
-                            }
-                        }
-
-                        // Check finish_reason
-                        if let Some(reason) = parsed["choices"][0]["finish_reason"].as_str() {
-                            if reason == "stop" || reason == "length" {
-                                let _ = app.emit(
-                                    "ai-stream",
-                                    AiStreamEvent {
-                                        event_type: "done".to_string(),
-                                        text: None,
-                                        error: None,
-                                    },
-                                );
-                                return Ok(());
-                            }
-                        }
-
-                        // Check for error in stream
-                        if let Some(err) = parsed["error"]["message"].as_str() {
-                            let _ = app.emit(
-                                "ai-stream",
-                                AiStreamEvent {
-                                    event_type: "error".to_string(),
-                                    text: None,
-                                    error: Some(err.to_string()),
-                                },
-                            );
-                            return Err(err.to_string());
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let _ = app.emit(
-        "ai-stream",
-        AiStreamEvent {
-            event_type: "done".to_string(),
-            text: None,
-            error: None,
-        },
-    );
-
-    Ok(())
-}
-
-async fn test_completions(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
-    let client = Client::new();
-
-    let body = json!({
-        "model": model,
-        "prompt": "Hi",
-        "max_tokens": 10,
-    });
-
-    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
-        .map_err(|e| format!("Connection failed: {}", e))?;
-
-    if response.status().is_success() {
-        Ok("Connection successful".to_string())
-    } else {
-        let status = response.status();
-        let body_text = response.text().await.unwrap_or_default();
-        Err(format!("API error {}: {}", status, body_text))
-    }
-}
-
 async fn test_openai(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
-    let client = Client::new();
+	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,
-        "max_tokens": 10,
-        "messages": [
+	let body = json!({
+		"model": model,
+		token_key: 20,
+		"messages": [
             {
                 "role": "user",
                 "content": "Hi"

src-tauri/src/lib.rs

@@ -38,11 +38,45 @@ pub fn run() {
     let close_to_tray = config.close_to_tray && show_tray;
     let app_state = AppState::new(config);
 
+    // Inject the compile-time platform so the frontend never sniffs the (sometimes
+    // mobile-looking) WebKitGTK user-agent. (#63)
+    let platform_init = format!(
+        "window.__HELIX_PLATFORM__={{mobile:{},android:{},ios:{}}};",
+        cfg!(mobile),
+        cfg!(target_os = "android"),
+        cfg!(target_os = "ios"),
+    );
+
     let mut builder = tauri::Builder::default()
+        .plugin(
+            tauri::plugin::Builder::<tauri::Wry>::new("helix-platform")
+                .js_init_script(platform_init)
+                .build(),
+        )
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_opener::init())
+        .on_page_load(|webview, payload| {
+            #[cfg(target_os = "macos")]
+            if webview.label() == "main"
+                && matches!(
+                    payload.event(),
+                    tauri::webview::PageLoadEvent::Finished
+                )
+            {
+                let window = webview.window();
+                let window_on_main = window.clone();
+                let _ = window.run_on_main_thread(move || {
+                    fix_macos_traffic_lights(&window_on_main);
+                });
+            }
+            #[cfg(not(target_os = "macos"))]
+            let _ = (webview, payload);
+        })
         .setup(move |app| {
+            #[cfg(target_os = "ios")]
+            app.handle().plugin(tauri_plugin_ios_vault_access::init())?;
+
             if cfg!(debug_assertions) {
                 app.handle().plugin(
                     tauri_plugin_log::Builder::default()
@@ -98,13 +132,21 @@ pub fn run() {
         .manage(app_state)
         .invoke_handler(tauri::generate_handler![
             commands::open_vault,
+            commands::choose_external_vault,
+            commands::restore_external_vault,
+            commands::remove_vault,
             commands::get_app_config,
             commands::set_theme,
             commands::set_accent_color,
+            commands::save_custom_theme,
+            commands::delete_custom_theme,
+            commands::export_custom_theme,
+            commands::import_custom_themes,
             commands::set_font_size,
             commands::set_font_family,
             commands::set_line_height,
             commands::set_ui_scale,
+            commands::set_content_width,
             commands::get_notebooks,
             commands::count_root_notes,
             commands::create_notebook,
@@ -147,6 +189,8 @@ pub fn run() {
             commands::remove_quick_access,
             commands::reorder_quick_access,
             commands::get_vault_stats,
+            commands::find_orphaned_attachments,
+            commands::trash_orphaned_attachments,
             commands::import_obsidian,
             commands::open_file,
             commands::open_url,
@@ -168,6 +212,7 @@ pub fn run() {
             commands::test_sync_connection,
             commands::sync_now,
             commands::get_install_type,
+            commands::is_mobile_platform,
             commands::get_pending_open_file,
         ])
         .register_asynchronous_uri_scheme_protocol("imgproxy", |_ctx, request, responder| {
@@ -364,3 +409,51 @@ fn percent_decode(input: &str) -> String {
     }
     String::from_utf8_lossy(&output).to_string()
 }
+
+#[cfg(target_os = "macos")]
+fn fix_macos_traffic_lights(window: &tauri::Window) {
+    use objc2_app_kit::{NSView, NSWindow, NSWindowButton};
+
+    const TITLEBAR_HEIGHT: f64 = 34.0;
+    const LEFT_INSET: f64 = 12.0;
+
+    let ns_window_ptr = match window.ns_window() {
+        Ok(ptr) => ptr,
+        Err(_) => return,
+    };
+    let ns_window: &NSWindow = unsafe { &*(ns_window_ptr as *const NSWindow) };
+
+    let close = match ns_window.standardWindowButton(NSWindowButton::CloseButton) {
+        Some(button) => button,
+        None => return,
+    };
+    let miniaturize = match ns_window.standardWindowButton(NSWindowButton::MiniaturizeButton) {
+        Some(button) => button,
+        None => return,
+    };
+    let zoom = match ns_window.standardWindowButton(NSWindowButton::ZoomButton) {
+        Some(button) => button,
+        None => return,
+    };
+
+    let window_height = ns_window.frame().size.height;
+    if window_height <= 0.0 {
+        return;
+    }
+
+    let close_frame = NSView::frame(&close);
+    let button_spacing = NSView::frame(&miniaturize).origin.x - close_frame.origin.x;
+    for (index, button) in [&close, &miniaturize, &zoom].into_iter().enumerate() {
+        let button_superview = match unsafe { button.superview() } {
+            Some(view) => view,
+            None => return,
+        };
+        let mut frame = NSView::frame(button);
+        let top_inset = ((TITLEBAR_HEIGHT - frame.size.height) / 2.0).max(0.0);
+        let mut target = frame.origin;
+        target.y = window_height - top_inset - frame.size.height;
+        frame.origin.y = button_superview.convertPoint_fromView(target, None).y;
+        frame.origin.x = LEFT_INSET + index as f64 * button_spacing;
+        button.setFrameOrigin(frame.origin);
+    }
+}

src-tauri/src/state.rs

@@ -1,14 +1,15 @@
 use crate::search::SearchIndex;
 use crate::types::AppConfig;
-use notify::RecommendedWatcher;
+use crate::vault::watcher::VaultWatcher;
 use std::sync::atomic::AtomicBool;
-use std::sync::Mutex;
 use std::sync::Arc;
+use std::sync::Mutex;
 
 pub struct AppState {
     pub config: Mutex<AppConfig>,
     pub search_index: Mutex<Option<Arc<SearchIndex>>>,
-    pub watcher: Mutex<Option<RecommendedWatcher>>,
+    pub watcher: Mutex<Option<VaultWatcher>>,
+    pub vault_transition: tokio::sync::Mutex<()>,
     pub importing: AtomicBool,
     pub syncing: AtomicBool,
     pub pending_open_file: Mutex<Option<String>>,
@@ -20,6 +21,7 @@ impl AppState {
             config: Mutex::new(config),
             search_index: Mutex::new(None),
             watcher: Mutex::new(None),
+            vault_transition: tokio::sync::Mutex::new(()),
             importing: AtomicBool::new(false),
             syncing: AtomicBool::new(false),
             pending_open_file: Mutex::new(None),

src-tauri/src/sync.rs

@@ -312,8 +312,9 @@ impl WebdavClient {
             .send()
             .map_err(|e| e.to_string())?;
         let s = resp.status().as_u16();
-        // 201 created; 405 already exists; 301 redirect-to-existing.
-        if resp.status().is_success() || s == 405 || s == 301 {
+        // 201 created; 405 already exists; 301 redirect-to-existing;
+        // 403 some servers (openmediavault et al.) return 403 instead of 405.
+        if resp.status().is_success() || s == 405 || s == 301 || s == 403 {
             Ok(())
         } else {
             Err(format!("MKCOL {} failed: HTTP {}", relpath, s))
@@ -339,31 +340,72 @@ impl WebdavClient {
         Ok(())
     }
 
-    fn put_with_dirs(
+    /// Read a file's authoritative remote etag via a Depth-0 PROPFIND. The PUT-response
+    /// etag is unreliable across WebDAV servers (some omit it, some differ in format from
+    /// the getetag PROPFIND returns), so we always source the manifest etag from PROPFIND
+    /// to keep it consistent with future listings. (issue #147)
+    fn etag_for(&self, relpath: &str) -> String {
+        self.propfind(relpath, "0")
+            .ok()
+            .and_then(|es| es.into_iter().find(|e| !e.is_dir).map(|e| e.etag))
+            .unwrap_or_default()
+    }
+
+    /// PUT a file (creating parent collections first), then read back its authoritative
+    /// etag via PROPFIND. Returns the PROPFIND etag (empty if the server exposes no
+    /// getetag), NOT the PUT-response etag, which is unreliable across servers. (issue #147)
+    fn upload(
         &self,
         relpath: &str,
         bytes: &[u8],
         created: &mut HashSet<String>,
-    ) -> Result<Option<String>, String> {
+    ) -> Result<String, String> {
         self.ensure_dirs(relpath, created)?;
-        self.put(relpath, bytes)
+        self.put(relpath, bytes)?; // PUT-response etag intentionally discarded
+        Ok(self.etag_for(relpath))
     }
 }
 
-/// Map a WebDAV `href` to a vault-relative path (forward slash). Returns None for
-/// the base collection itself.
-fn href_to_relpath(href: &str, base_path: &str) -> Option<String> {
-    let path = if href.starts_with("http://") || href.starts_with("https://") {
-        reqwest::Url::parse(href).ok()?.path().to_string()
+/// Map a WebDAV `href` to a vault-relative path (forward slash).
+/// `Ok(None)` is the base collection itself. `Err` means the href could not be mapped
+/// (e.g. it does not sit under the configured base path, as some providers like Infomaniak
+/// kDrive return). Callers MUST treat `Err` as a hard failure: silently dropping an
+/// unmappable href makes that file look deleted on the remote, and the reconciler then
+/// wipes the local copy. (issue #102)
+fn href_to_relpath(href: &str, base_path: &str) -> Result<Option<String>, String> {
+    // Pull out just the path component (some servers return absolute-URL hrefs).
+    let raw = if href.starts_with("http://") || href.starts_with("https://") {
+        reqwest::Url::parse(href)
+            .map_err(|e| format!("invalid remote href URL '{href}': {e}"))?
+            .path()
+            .to_string()
     } else {
         href.to_string()
     };
-    let path = path.trim_end_matches('/');
-    let rest = path.strip_prefix(base_path)?.trim_start_matches('/');
+    // Compare DECODED paths, not the raw percent-encoded strings. Providers differ in how they
+    // encode hrefs: Infomaniak kDrive lowercases the hex (`%5b`/`%5d`) and encodes spaces, while
+    // reqwest emits uppercase hex (`%5B`/`%5D`) for base_path. A raw strip_prefix then spuriously
+    // fails, every remote file looks deleted, and the reconciler wipes the local copies. Decoding
+    // both sides first makes the prefix match encoding-agnostic. (issue #102)
+    let path = urlencoding::decode(raw.trim_end_matches('/'))
+        .map_err(|e| format!("bad percent-encoding in remote path '{raw}': {e}"))?
+        .into_owned();
+    let base = urlencoding::decode(base_path.trim_end_matches('/'))
+        .map_err(|e| format!("bad percent-encoding in WebDAV base path '{base_path}': {e}"))?
+        .into_owned();
+    let rest = match path.strip_prefix(&base) {
+        Some(r) => r.trim_start_matches('/'),
+        None => {
+            return Err(format!(
+                "remote path '{path}' is not under the configured WebDAV folder '{base}'. \
+                 Aborting before deleting anything locally - please report this URL."
+            ))
+        }
+    };
     if rest.is_empty() {
-        return None;
+        return Ok(None); // the base collection itself
     }
-    Some(urlencoding::decode(rest).ok()?.into_owned())
+    Ok(Some(rest.to_string()))
 }
 
 fn parse_multistatus(xml: &str, base_path: &str) -> Result<Vec<RemoteEntry>, String> {
@@ -427,7 +469,7 @@ fn parse_multistatus(xml: &str, base_path: &str) -> Result<Vec<RemoteEntry>, Str
                 }
                 b"response" => {
                     if let Some(h) = href.take() {
-                        if let Some(rel) = href_to_relpath(&h, base_path) {
+                        if let Some(rel) = href_to_relpath(&h, base_path)? {
                             entries.push(RemoteEntry {
                                 relpath: rel,
                                 etag: etag.take().map(|s| normalize_etag(&s)).unwrap_or_default(),
@@ -485,12 +527,12 @@ fn apply_changes(
                     );
                 } else if local_changed && !remote_changed {
                     let bytes = fs::read(&lf.path).map_err(|e| e.to_string())?;
-                    let etag = client.put_with_dirs(key, &bytes, &mut created)?;
+                    let etag = client.upload(key, &bytes, &mut created)?;
                     new_m.files.insert(
                         key.clone(),
                         ManifestEntry {
                             local_hash: lf.hash.clone(),
-                            remote_etag: etag.unwrap_or_else(|| re.clone()),
+                            remote_etag: etag,
                         },
                     );
                     sum.uploaded += 1;
@@ -530,12 +572,12 @@ fn apply_changes(
                         );
                         let ckey = conflict_relpath(key, &stamp);
                         write_local(vault_path, &ckey, &lbytes)?;
-                        let cetag = client.put_with_dirs(&ckey, &lbytes, &mut created)?;
+                        let cetag = client.upload(&ckey, &lbytes, &mut created)?;
                         new_m.files.insert(
                             ckey,
                             ManifestEntry {
                                 local_hash: sha256_hex(&lbytes),
-                                remote_etag: cetag.unwrap_or_default(),
+                                remote_etag: cetag,
                             },
                         );
                         sum.conflicts += 1;
@@ -546,12 +588,12 @@ fn apply_changes(
                 None => {
                     // new local -> upload
                     let bytes = fs::read(&lf.path).map_err(|e| e.to_string())?;
-                    let etag = client.put_with_dirs(key, &bytes, &mut created)?;
+                    let etag = client.upload(key, &bytes, &mut created)?;
                     new_m.files.insert(
                         key.clone(),
                         ManifestEntry {
                             local_hash: lf.hash.clone(),
-                            remote_etag: etag.unwrap_or_default(),
+                            remote_etag: etag,
                         },
                     );
                     sum.uploaded += 1;
@@ -560,12 +602,12 @@ fn apply_changes(
                     if me.local_hash != lf.hash {
                         // remote deleted but local edited -> resurrect (upload)
                         let bytes = fs::read(&lf.path).map_err(|e| e.to_string())?;
-                        let etag = client.put_with_dirs(key, &bytes, &mut created)?;
+                        let etag = client.upload(key, &bytes, &mut created)?;
                         new_m.files.insert(
                             key.clone(),
                             ManifestEntry {
                                 local_hash: lf.hash.clone(),
-                                remote_etag: etag.unwrap_or_default(),
+                                remote_etag: etag,
                             },
                         );
                         sum.uploaded += 1;
@@ -642,6 +684,20 @@ pub fn run_sync(app: tauri::AppHandle, vault: String, cfg: WebdavConfig) -> Resu
     let local = scan_local(&vault)?;
     let manifest = load_manifest(&vault);
 
+    // Safety guard (issue #102): never treat an empty remote listing as "everything was
+    // deleted remotely". If a prior sync exists (non-empty manifest) but the remote came back
+    // empty, it is almost certainly a listing failure (e.g. a provider whose paths we can't
+    // map), not a real mass-deletion - so abort instead of wiping local notes.
+    if remote.is_empty() && !manifest.files.is_empty() {
+        return Err(
+            "Sync aborted to protect your notes: the WebDAV server returned an empty file list \
+             even though files were synced before, so no local files were deleted. This usually \
+             means the server reports paths in a format the app can't read yet - please report \
+             your WebDAV provider and folder URL."
+                .to_string(),
+        );
+    }
+
     let _ = app.emit("sync-progress", serde_json::json!({ "status": "syncing" }));
     // Mute the watcher across local writes so a pull doesn't storm the reindex path.
     state.importing.store(true, Ordering::Relaxed);

src-tauri/src/types.rs

@@ -50,16 +50,58 @@ pub struct NoteContent {
     pub raw: String,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct VaultConfig {
     pub path: String,
     pub name: String,
+    #[serde(default)]
+    pub bookmark_id: Option<String>,
+    // Per-vault WebDAV sync (was previously global on AppConfig; those fields are kept deprecated for migration).
+    #[serde(default)]
+    pub sync_provider: Option<String>,
+    #[serde(default)]
+    pub webdav_url: Option<String>,
+    #[serde(default)]
+    pub webdav_username: Option<String>,
+    #[serde(default)]
+    pub webdav_password: Option<String>,
+    #[serde(default)]
+    pub sync_on_open: bool,
+    #[serde(default)]
+    pub sync_on_change: bool,
+    #[serde(default)]
+    pub sync_interval_minutes: u32,
+    #[serde(default)]
+    pub last_sync_time: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CustomThemeColors {
+    pub bg_primary: String,
+    pub bg_secondary: String,
+    pub bg_tertiary: String,
+    pub bg_hover: String,
+    pub bg_active: String,
+    pub bg_editor: String,
+    pub text_primary: String,
+    pub text_secondary: String,
+    pub border_color: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CustomTheme {
+    pub id: String,
+    pub name: String,
+    pub is_dark: bool,
+    pub colors: CustomThemeColors,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AppConfig {
     pub vaults: Vec<VaultConfig>,
     pub active_vault: Option<String>,
+    #[serde(default)]
+    pub active_bookmark_id: Option<String>,
     pub theme: String,
     #[serde(default)]
     pub accent_color: Option<String>,
@@ -72,6 +114,8 @@ pub struct AppConfig {
     #[serde(default)]
     pub ui_scale: Option<f64>,
     #[serde(default)]
+    pub content_width: Option<u32>,
+    #[serde(default)]
     pub compact_notes: bool,
     #[serde(default = "default_true")]
     pub show_note_dates: bool,
@@ -79,6 +123,8 @@ pub struct AppConfig {
     pub time_format: String,
     #[serde(default = "default_week_start")]
     pub week_start: String,
+    #[serde(default = "default_daily_title_format")]
+    pub daily_title_format: String,
     #[serde(default)]
     pub gpu_acceleration: bool,
     #[serde(default)]
@@ -93,6 +139,18 @@ pub struct AppConfig {
     pub hide_title_in_body: bool,
     #[serde(default)]
     pub show_line_numbers: bool,
+    #[serde(default = "default_true")]
+    pub show_link_arrows: bool,
+    #[serde(default = "default_true")]
+    pub show_all_notes: bool,
+    #[serde(default = "default_true")]
+    pub show_quick_access: bool,
+    #[serde(default = "default_true")]
+    pub show_tasks: bool,
+    #[serde(default = "default_true")]
+    pub show_daily_notes: bool,
+    #[serde(default = "default_true")]
+    pub show_trash: bool,
     #[serde(default)]
     pub backup_enabled: bool,
     #[serde(default = "default_backup_frequency")]
@@ -135,7 +193,7 @@ pub struct AppConfig {
     pub enable_wiki_links: bool,
     #[serde(default)]
     pub restore_last_session: bool,
-    // WebDAV sync (opt-in; all off by default). Endpoint is fully user-configured.
+    // DEPRECATED: WebDAV sync moved to per-vault VaultConfig. Kept for one release to migrate old configs.
     #[serde(default)]
     pub sync_provider: Option<String>,
     #[serde(default)]
@@ -152,12 +210,18 @@ pub struct AppConfig {
     pub sync_interval_minutes: u32,
     #[serde(default)]
     pub last_sync_time: Option<String>,
+    #[serde(default)]
+    pub custom_themes: Vec<CustomTheme>,
 }
 
 fn default_true() -> bool {
     true
 }
 
+fn default_outline_width() -> f64 {
+    220.0
+}
+
 fn default_pdf_height() -> u32 {
     600
 }
@@ -178,6 +242,10 @@ fn default_week_start() -> String {
     "monday".to_string()
 }
 
+fn default_daily_title_format() -> String {
+    "localized".to_string()
+}
+
 fn default_max_versions() -> u32 {
     20
 }
@@ -191,16 +259,19 @@ impl Default for AppConfig {
         Self {
             vaults: Vec::new(),
             active_vault: None,
+            active_bookmark_id: None,
             theme: "system".to_string(),
             accent_color: None,
             font_size: None,
             font_family: None,
             line_height: None,
             ui_scale: None,
+            content_width: None,
             compact_notes: false,
             show_note_dates: true,
             time_format: "relative".to_string(),
             week_start: "monday".to_string(),
+            daily_title_format: "localized".to_string(),
             gpu_acceleration: true,
             autostart: false,
             pdf_preview: false,
@@ -208,6 +279,12 @@ impl Default for AppConfig {
             title_mode: "input".to_string(),
             hide_title_in_body: false,
             show_line_numbers: false,
+            show_link_arrows: true,
+            show_all_notes: true,
+            show_quick_access: true,
+            show_tasks: true,
+            show_daily_notes: true,
+            show_trash: true,
             backup_enabled: false,
             backup_frequency: "24h".to_string(),
             backup_max_count: 10,
@@ -237,6 +314,7 @@ impl Default for AppConfig {
             sync_on_change: false,
             sync_interval_minutes: 0,
             last_sync_time: None,
+            custom_themes: Vec::new(),
         }
     }
 }
@@ -246,14 +324,20 @@ pub struct VaultState {
     pub last_open_note: Option<String>,
     pub sidebar_width: f64,
     pub notelist_width: f64,
+    #[serde(default = "default_outline_width")]
+    pub outline_width: f64,
     pub sidebar_collapsed: bool,
     #[serde(default)]
+    pub notelist_collapsed: bool,
+    #[serde(default)]
     pub collapsed_notebooks: Vec<String>,
     #[serde(default)]
     pub notebook_sort_mode: String,
     #[serde(default)]
     pub notebook_order: std::collections::HashMap<String, i32>,
     #[serde(default)]
+    pub note_order: std::collections::HashMap<String, i32>,
+    #[serde(default)]
     pub sort_mode: String,
     #[serde(default)]
     pub last_view_mode: String,
@@ -263,6 +347,12 @@ pub struct VaultState {
     pub last_tag: Option<String>,
     #[serde(default)]
     pub tasks_layout: String,
+    #[serde(default = "default_true")]
+    pub tasks_hide_completed: bool,
+    #[serde(default)]
+    pub tasks_only_flagged: bool,
+    #[serde(default)]
+    pub tasks_sort: String,
 }
 
 impl Default for VaultState {
@@ -271,15 +361,21 @@ impl Default for VaultState {
             last_open_note: None,
             sidebar_width: 220.0,
             notelist_width: 280.0,
+            outline_width: default_outline_width(),
             sidebar_collapsed: false,
+            notelist_collapsed: false,
             collapsed_notebooks: Vec::new(),
             notebook_sort_mode: String::new(),
             notebook_order: std::collections::HashMap::new(),
+            note_order: std::collections::HashMap::new(),
             sort_mode: String::new(),
             last_view_mode: String::new(),
             last_notebook: None,
             last_tag: None,
             tasks_layout: String::new(),
+            tasks_hide_completed: true,
+            tasks_only_flagged: false,
+            tasks_sort: String::new(),
         }
     }
 }
@@ -302,6 +398,9 @@ pub struct FileEvent {
 pub struct ImportResult {
     pub files_converted: u64,
     pub links_converted: u64,
+    pub frontmatter_normalized: u64,
+    pub syntax_converted: u64,
+    pub attachments_moved: u64,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

src-tauri/src/vault/frontmatter.rs

@@ -15,7 +15,7 @@ struct RawFrontmatter {
 }
 
 /// Try to parse a date string in multiple common formats.
-fn parse_date_flexible(s: &str) -> Option<chrono::DateTime<Utc>> {
+pub 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>>() {
@@ -191,7 +191,7 @@ pub fn merge_frontmatter(original_raw: &str, meta: &NoteMeta, body: &str) -> Str
     format!("---\n{}---\n{}", yaml_str, body_with_heading)
 }
 
-fn filename_to_title(filename: &str) -> String {
+pub fn filename_to_title(filename: &str) -> String {
     let stem = filename.trim_end_matches(".md");
     // Only replace dashes/underscores acting as word separators (between non-space chars).
     // Keep dashes that are surrounded by spaces (e.g. "Title - Subtitle").

src-tauri/src/vault/mod.rs

@@ -1,3 +1,4 @@
 pub mod frontmatter;
+pub mod import;
 pub mod operations;
 pub mod watcher;

src-tauri/src/vault/operations.rs

@@ -52,11 +52,10 @@ pub fn scan_notebooks(vault_path: &str) -> Result<Vec<NotebookEntry>, String> {
 }
 
 fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
-    let mut entries = Vec::new();
     let root = Path::new(vault_root);
 
     let Ok(read_dir) = fs::read_dir(dir) else {
-        return entries;
+        return Vec::new();
     };
 
     // Collect subdirs (root level only lists directories, note counts come from scan_dir_with_count)
@@ -76,29 +75,29 @@ 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();
-        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
+    // Scan sibling notebooks in parallel: each subtree is independent, so
+    // overlapping the per-directory read_dir calls hides FUSE latency on Android.
+    // par_iter().collect() preserves the (already-sorted) order.
+    let paths: Vec<PathBuf> = dirs.iter().map(|e| e.path()).collect();
+    paths
+        .par_iter()
+        .map(|path| {
+            let name = path.file_name().unwrap_or_default().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);
+            NotebookEntry {
+                name,
+                path: path.to_string_lossy().to_string(),
+                relative_path: relative,
+                children,
+                note_count: child_note_count,
+            }
+        })
+        .collect()
 }
 
 /// Combined scan: returns (children, note_count) in a single read_dir pass.
@@ -130,26 +129,26 @@ fn scan_dir_with_count(dir: &Path, vault_root: &str) -> (Vec<NotebookEntry>, usi
             .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,
-        });
-    }
+    let paths: Vec<PathBuf> = subdirs.iter().map(|e| e.path()).collect();
+    let entries: Vec<NotebookEntry> = paths
+        .par_iter()
+        .map(|path| {
+            let name = path.file_name().unwrap_or_default().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);
+            NotebookEntry {
+                name,
+                path: path.to_string_lossy().to_string(),
+                relative_path: relative,
+                children,
+                note_count: child_note_count,
+            }
+        })
+        .collect();
 
     (entries, note_count)
 }
@@ -197,47 +196,36 @@ pub fn scan_notes(vault_path: &str, notebook_path: Option<&str>) -> Result<Vec<N
     // On mobile, use metadata-only scan (no file reads) for fast listing on sandboxed FS
     #[cfg(mobile)]
     {
-        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);
-        }
-
-        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);
-                        }
-                    }
-                }
+        // Collect candidate .md paths first, then read their metadata in parallel.
+        // Overlapping the per-file reads hides FUSE latency on Android (matches the
+        // desktop path below). The previous version also did an extra read_dir purely
+        // for debug logging, which doubled the directory I/O on the sandboxed FS.
+        let paths: Vec<PathBuf> = if notebook_path.is_some() {
+            match fs::read_dir(root) {
+                Ok(rd) => rd
+                    .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(),
+                Err(_) => Vec::new(),
             }
         } else {
             let hn_dir = helixnotes_dir(vault_path);
-            for entry in WalkDir::new(root)
+            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);
-                }
-            }
-        }
+                .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> = paths
+            .par_iter()
+            .filter_map(|path| read_note_entry_metadata_only(path, vault_root).ok())
+            .collect();
+
         log::info!("scan_notes: mobile scan found {} notes", notes.len());
         notes.sort_by(|a, b| b.meta.modified.cmp(&a.meta.modified));
         return Ok(notes);
@@ -386,7 +374,26 @@ pub fn read_note(path: &str) -> Result<NoteContent, String> {
         .to_string_lossy()
         .to_string();
 
-    let (meta, content) = frontmatter::parse_note(&raw, &filename);
+    let (mut meta, content) = frontmatter::parse_note(&raw, &filename);
+
+    // Fall back to filesystem times when the frontmatter has no created/modified, matching the
+    // note-list scan (read_note_entry_from_str). Without this, a missing `created:` defaults to
+    // Utc::now() here and then gets written to disk on the next save (e.g. a title change),
+    // resetting the create date of imported/frontmatter-less notes. (issue #139)
+    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(p) {
+        if !has_modified {
+            if let Ok(modified) = fs_meta.modified() {
+                meta.modified = modified.into();
+            }
+        }
+        if !has_created {
+            if let Ok(created) = fs_meta.created() {
+                meta.created = created.into();
+            }
+        }
+    }
 
     Ok(NoteContent {
         path: path.to_string(),
@@ -520,15 +527,27 @@ fn get_system_locale() -> Locale {
     }
 }
 
-pub fn create_daily_note(vault_path: &str, date: Option<&str>) -> Result<NoteEntry, String> {
+pub fn create_daily_note(
+    vault_path: &str,
+    date: Option<&str>,
+    format: &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 title = match format {
+        "iso" => target_date.format("%Y-%m-%d").to_string(),
+        "long" => target_date.format("%B %-d, %Y").to_string(),
+        "us" => target_date.format("%m/%d/%Y").to_string(),
+        "eu" => target_date.format("%d/%m/%Y").to_string(),
+        _ => {
+            let locale = get_system_locale();
+            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())?;

src-tauri/src/vault/watcher.rs

@@ -1,4 +1,4 @@
-use notify::{Config, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
+use notify::{Config, EventKind, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher};
 use std::path::Path;
 use std::sync::mpsc;
 use std::time::Duration;
@@ -8,14 +8,57 @@ use crate::state::AppState;
 use crate::types::FileEvent;
 use crate::vault::operations::helixnotes_dir;
 
-pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<RecommendedWatcher, String> {
+const IOS_POLL_INTERVAL: Duration = Duration::from_secs(10);
+const NATIVE_POLL_INTERVAL: Duration = Duration::from_secs(1);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum WatcherBackend {
+    Recommended,
+    Poll,
+}
+
+const fn watcher_backend_for_target(is_ios: bool) -> WatcherBackend {
+    if is_ios {
+        WatcherBackend::Poll
+    } else {
+        WatcherBackend::Recommended
+    }
+}
+
+const fn poll_interval_for_backend(backend: WatcherBackend) -> Duration {
+    match backend {
+        WatcherBackend::Recommended => NATIVE_POLL_INTERVAL,
+        WatcherBackend::Poll => IOS_POLL_INTERVAL,
+    }
+}
+
+pub enum VaultWatcher {
+    Recommended(RecommendedWatcher),
+    Poll(PollWatcher),
+}
+
+impl VaultWatcher {
+    fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> notify::Result<()> {
+        match self {
+            Self::Recommended(watcher) => watcher.watch(path, recursive_mode),
+            Self::Poll(watcher) => watcher.watch(path, recursive_mode),
+        }
+    }
+}
+
+pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<VaultWatcher, String> {
     let (tx, rx) = mpsc::channel();
 
-    let mut watcher = RecommendedWatcher::new(
-        tx,
-        Config::default().with_poll_interval(Duration::from_secs(1)),
-    )
-    .map_err(|e| e.to_string())?;
+    let backend = watcher_backend_for_target(cfg!(target_os = "ios"));
+    let config = Config::default().with_poll_interval(poll_interval_for_backend(backend));
+    let mut watcher = match backend {
+        WatcherBackend::Recommended => VaultWatcher::Recommended(
+            RecommendedWatcher::new(tx, config).map_err(|e| e.to_string())?,
+        ),
+        WatcherBackend::Poll => {
+            VaultWatcher::Poll(PollWatcher::new(tx, config).map_err(|e| e.to_string())?)
+        }
+    };
 
     watcher
         .watch(Path::new(&vault_path), RecursiveMode::Recursive)
@@ -61,6 +104,15 @@ pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<RecommendedWa
                         };
                         let _ = app.emit("file-changed", &fe);
                     }
+
+                    // On mobile, throttle event emission to prevent IPC flooding
+                    // on FUSE filesystems where Syncthing/other apps generate
+                    // constant file activity that blocks the Tauri command channel.
+                    #[cfg(mobile)]
+                    {
+                        std::thread::sleep(Duration::from_secs(2));
+                        while rx.try_recv().is_ok() {}
+                    }
                 }
                 Err(e) => {
                     log::error!("File watcher error: {}", e);
@@ -71,3 +123,33 @@ pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<RecommendedWa
 
     Ok(watcher)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ios_uses_polling_backend() {
+        assert_eq!(watcher_backend_for_target(true), WatcherBackend::Poll);
+    }
+
+    #[test]
+    fn other_platforms_keep_recommended_backend() {
+        assert_eq!(
+            watcher_backend_for_target(false),
+            WatcherBackend::Recommended
+        );
+    }
+
+    #[test]
+    fn watcher_backends_use_the_expected_intervals() {
+        assert_eq!(
+            poll_interval_for_backend(WatcherBackend::Poll),
+            Duration::from_secs(10)
+        );
+        assert_eq!(
+            poll_interval_for_backend(WatcherBackend::Recommended),
+            Duration::from_secs(1)
+        );
+    }
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "productName": "HelixNotes",
-  "version": "1.3.0",
+  "version": "1.3.4",
   "identifier": "com.helixnotes.app",
   "build": {
     "frontendDist": "../build",
@@ -55,6 +55,9 @@
       "appimage": {
         "bundleMediaFramework": false
       }
+    },
+    "macOS": {
+      "entitlements": "entitlements.plist"
     }
   }
 }

src/lib/api.ts

@@ -1,6 +1,7 @@
 import { invoke } from "@tauri-apps/api/core";
 import type {
   AppConfig,
+  CustomTheme,
   NoteContent,
   NoteEntry,
   NoteMeta,
@@ -14,12 +15,25 @@ import type {
   BackupEntry,
   VersionEntry,
   TaskItem,
+  ExternalVaultResult,
 } from "./types";
 
 export async function openVault(path: string): Promise<void> {
   return invoke("open_vault", { path });
 }
 
+export async function chooseExternalVault(): Promise<ExternalVaultResult | null> {
+  return invoke("choose_external_vault");
+}
+
+export async function restoreExternalVault(bookmarkId: string): Promise<ExternalVaultResult> {
+  return invoke("restore_external_vault", { bookmarkId });
+}
+
+export async function removeVault(path: string, bookmarkId?: string | null): Promise<void> {
+  return invoke("remove_vault", { path, bookmarkId: bookmarkId ?? null });
+}
+
 export async function getAppConfig(): Promise<AppConfig> {
   return invoke("get_app_config");
 }
@@ -32,6 +46,22 @@ export async function setAccentColor(color: string): Promise<void> {
   return invoke("set_accent_color", { color });
 }
 
+export async function saveCustomTheme(theme: CustomTheme): Promise<void> {
+  return invoke("save_custom_theme", { theme });
+}
+
+export async function deleteCustomTheme(id: string): Promise<void> {
+  return invoke("delete_custom_theme", { id });
+}
+
+export async function exportCustomTheme(id: string, path: string): Promise<void> {
+  return invoke("export_custom_theme", { id, path });
+}
+
+export async function importCustomThemes(path: string): Promise<CustomTheme[]> {
+  return invoke("import_custom_themes", { path });
+}
+
 export async function setFontSize(size: number): Promise<void> {
   return invoke("set_font_size", { size });
 }
@@ -48,6 +78,10 @@ export async function setUiScale(scale: number): Promise<void> {
   return invoke("set_ui_scale", { scale });
 }
 
+export async function setContentWidth(width: number | null): Promise<void> {
+  return invoke("set_content_width", { width });
+}
+
 export async function getNotebooks(): Promise<NotebookEntry[]> {
   return invoke("get_notebooks");
 }
@@ -216,6 +250,7 @@ export async function setGeneralSettings(
   compactNotes: boolean,
   timeFormat: string,
   weekStart: string,
+  dailyTitleFormat: string,
   gpuAcceleration: boolean,
   autostart: boolean,
   pdfPreview: boolean,
@@ -223,17 +258,24 @@ export async function setGeneralSettings(
   titleMode: string,
   hideTitleInBody: boolean,
   showLineNumbers: boolean,
+  showLinkArrows: boolean,
   defaultViewMode: boolean,
   showTrayIcon: boolean,
   closeToTray: boolean,
   enableWikiLinks: boolean,
   showNoteDates: boolean,
   restoreLastSession: boolean,
+  showAllNotes: boolean,
+  showQuickAccess: boolean,
+  showTasks: boolean,
+  showDailyNotes: boolean,
+  showTrash: boolean,
 ): Promise<void> {
   return invoke("set_general_settings", {
     compactNotes,
     timeFormat,
     weekStart,
+    dailyTitleFormat,
     gpuAcceleration,
     autostart,
     pdfPreview,
@@ -241,12 +283,18 @@ export async function setGeneralSettings(
     titleMode,
     hideTitleInBody,
     showLineNumbers,
+    showLinkArrows,
     defaultViewMode,
     showTrayIcon,
     closeToTray,
     enableWikiLinks,
     showNoteDates,
     restoreLastSession,
+    showAllNotes,
+    showQuickAccess,
+    showTasks,
+    showDailyNotes,
+    showTrash,
   });
 }
 
@@ -270,6 +318,19 @@ export async function getVaultStats(): Promise<VaultStats> {
   return invoke("get_vault_stats");
 }
 
+export interface OrphanAttachment {
+  name: string;
+  size: number;
+}
+
+export async function findOrphanedAttachments(): Promise<OrphanAttachment[]> {
+  return invoke("find_orphaned_attachments");
+}
+
+export async function trashOrphanedAttachments(names: string[]): Promise<number> {
+  return invoke("trash_orphaned_attachments", { names });
+}
+
 export async function importObsidian(): Promise<void> {
   return invoke("import_obsidian");
 }
@@ -444,6 +505,10 @@ export async function getInstallType(): Promise<string> {
   return invoke("get_install_type");
 }
 
+export async function isMobilePlatform(): Promise<boolean> {
+  return invoke("is_mobile_platform");
+}
+
 export async function getPendingOpenFile(): Promise<string | null> {
   return invoke("get_pending_open_file");
 }

src/lib/components/AppLayout.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { onMount, onDestroy } from 'svelte';
+	import { onMount, onDestroy, tick } from 'svelte';
 	import { listen } from '@tauri-apps/api/event';
 	import Sidebar from './Sidebar.svelte';
 	import NoteList from './NoteList.svelte';
@@ -14,7 +14,9 @@
 	import {
 		sidebarWidth,
 		notelistWidth,
+		outlineWidth,
 		sidebarCollapsed,
+		notelistCollapsed,
 		collapsedNotebooks,
 		showSearch,
 		showCommandPalette,
@@ -37,7 +39,11 @@
 		rootNoteCount,
 		viewMode,
 		sortMode,
+		groupNotesByDate,
 		tasksLayout,
+		tasksHideCompleted,
+		tasksOnlyFlagged,
+		tasksSort,
 		activeTag,
 		updateAvailable as globalUpdateAvailable,
 		settingsTab,
@@ -45,14 +51,18 @@
 		viewerNote,
 		notebookSortMode,
 		notebookOrder,
-		syncState
+		noteOrder,
+		syncState,
+		platformIsMobile,
+		activeVaultConfig,
 	} from '$lib/stores/app';
+	import { keybindings, matchAction } from '$lib/keybindings';
 
 	const appWindow = getCurrentWindow();
 	const isMac = navigator.platform.startsWith('Mac');
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
-	const isAndroid = /android/i.test(navigator.userAgent);
-	import { loadVaultState, saveVaultState, readNote, createDailyNote, createBackup, getPendingOpenFile, addQuickAccess, removeQuickAccess, getQuickAccess, setTheme, syncNow, setTaskDone, setTaskPriority, setTaskDue } from '$lib/api';
+	const isMobile = $derived($platformIsMobile);
+	import { loadVaultState, saveVaultState, readNote, createDailyNote, createBackup, getPendingOpenFile, addQuickAccess, removeQuickAccess, getQuickAccess, setTheme, syncNow, getAppConfig, setTaskDone, setTaskPriority, setTaskDue, findOrphanedAttachments, trashOrphanedAttachments } from '$lib/api';
+	import { darkThemes, isAndroid } from '$lib/platform';
 	import { debounce } from '$lib/utils/debounce';
 	import { openNoteWindow } from '$lib/utils/window';
 	import { get } from 'svelte/store';
@@ -112,16 +122,16 @@
 	}
 
 	function syncConfigured(): boolean {
-		return get(appConfig)?.sync_provider === 'webdav';
+		return activeVaultConfig(get(appConfig))?.sync_provider === 'webdav';
 	}
 
 	// Auto-sync on a timer (only when configured and an interval is set).
 	async function checkScheduledSync() {
-		const config = get(appConfig);
-		if (config?.sync_provider !== 'webdav') return;
-		const mins = config.sync_interval_minutes ?? 0;
+		const vc = activeVaultConfig(get(appConfig));
+		if (vc?.sync_provider !== 'webdav') return;
+		const mins = vc.sync_interval_minutes ?? 0;
 		if (!mins || get(syncState).running) return;
-		const last = config.last_sync_time ? new Date(config.last_sync_time).getTime() : 0;
+		const last = vc.last_sync_time ? new Date(vc.last_sync_time).getTime() : 0;
 		if (Date.now() - last >= mins * 60 * 1000) {
 			try { await syncNow(); } catch (_) {}
 		}
@@ -194,15 +204,22 @@
 			last_open_note: $activeNotePath,
 			sidebar_width: $sidebarWidth,
 			notelist_width: $notelistWidth,
+			outline_width: $outlineWidth,
 			sidebar_collapsed: $sidebarCollapsed,
+			notelist_collapsed: $notelistCollapsed,
 			collapsed_notebooks: $collapsedNotebooks,
 			notebook_sort_mode: $notebookSortMode,
 			notebook_order: $notebookOrder,
+			note_order: $noteOrder,
 			sort_mode: $sortMode,
+			group_notes_by_date: $groupNotesByDate,
 			last_view_mode: $viewMode,
 			last_notebook: $activeNotebook?.relative_path ?? null,
 			last_tag: $activeTag,
-			tasks_layout: $tasksLayout
+			tasks_layout: $tasksLayout,
+			tasks_hide_completed: $tasksHideCompleted,
+			tasks_only_flagged: $tasksOnlyFlagged,
+			tasks_sort: $tasksSort
 		};
 		try {
 			await saveVaultState(state);
@@ -219,20 +236,40 @@
 		persistState();
 	}
 
+	function revealNoteList() {
+		$notelistCollapsed = false;
+		tick().then(() => noteList?.refresh());
+	}
+
+	function toggleNoteList() {
+		const nextCollapsed = !$notelistCollapsed;
+		$notelistCollapsed = nextCollapsed;
+		if (!nextCollapsed) {
+			tick().then(() => noteList?.refresh());
+		}
+	}
+
 	// Tasks view: the editor pane shows a placeholder until a task is opened from the list.
 	let taskNoteOpened = $state(false);
 
-	function handleNoteSelected(path: string, content: string) {
+	function handleNoteSelected(path: string, content: string, task?: TaskItem) {
 		// Selecting a real vault note exits viewer mode
 		$viewerNote = null;
 		taskNoteOpened = true;
-		editor?.loadNote(path, content);
+		editor?.loadNote(path, content, task);
 		if (isMobile) $mobileView = 'editor';
 	}
 
 	function handleViewChanged() {
 		taskNoteOpened = false;
-		noteList?.refresh();
+		// Picking a notebook/tag/Tasks/etc. in the sidebar is a request to browse that view's
+		// notes - so if the notes list was hidden, bring it back rather than navigating blindly
+		// into a panel the user can't see. revealNoteList() re-mounts the list and refreshes it.
+		if ($notelistCollapsed) {
+			revealNoteList();
+		} else {
+			noteList?.refresh();
+		}
 		if (isMobile) $mobileView = 'notelist';
 	}
 
@@ -323,7 +360,7 @@
 	let historyDepth = 0;
 	let navFromPopstate = false;
 
-	if (isMobile) {
+	if (get(platformIsMobile)) {
 		history.replaceState({ mobileView: 'sidebar', depth: 0 }, '');
 
 		$effect(() => {
@@ -353,6 +390,16 @@
 				navFromPopstate = false;
 				return;
 			}
+			// If a modal is open, close it instead of navigating
+			if ($showSettings || $showInfo || $showSearch || $showCommandPalette) {
+				$showSettings = false;
+				$showInfo = false;
+				$showSearch = false;
+				$showCommandPalette = false;
+				// Re-push the current state so the next back still works
+				history.pushState({ mobileView: $mobileView, depth: historyDepth }, '');
+				return;
+			}
 			const state = e.state;
 			const targetDepth = state?.depth ?? 0;
 			historyDepth = targetDepth;
@@ -376,88 +423,83 @@
 	function handleKeydown(e: KeyboardEvent) {
 		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 (mod && e.shiftKey && code === 'KeyN') {
-			e.preventDefault();
-			const isDark = $theme === 'dark' || ($theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
-			const next = isDark ? 'light' : 'dark';
-			$theme = next;
-			setTheme(next);
-			return;
-		}
-		if (mod && e.shiftKey && code === 'KeyF') {
-			e.preventDefault();
-			$showSearch = true;
-			return;
-		}
-		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 (mod && !e.shiftKey && code === 'KeyS') {
-			e.preventDefault();
-			editor?.forceSave();
-			return;
-		}
+
+		// Mod+K (insert link) is an editor formatting action and is not user-customizable.
 		if (mod && code === 'KeyK' && !e.shiftKey && $activeNotePath && !$sourceMode) {
 			e.preventDefault();
 			editor?.addLinkFromToolbar();
 		}
-		if (mod && e.shiftKey && code === 'KeyM') {
+
+		// Ctrl/Cmd+Shift+Delete: move the open note to the trash.
+		if (mod && e.shiftKey && code === 'Delete' && $activeNotePath) {
 			e.preventDefault();
-			$sourceMode = !$sourceMode;
+			noteList?.trashActiveNote();
+			return;
 		}
-		if (mod && e.shiftKey && code === 'KeyW') {
+
+		const action = matchAction(e, $keybindings);
+		if (action) {
 			e.preventDefault();
-			if ($activeNotePath && $activeNote) {
-				openNoteWindow($activeNotePath, $activeNote.meta.title);
+			switch (action) {
+				case 'nav-back':
+					navigateHistory(-1);
+					return;
+				case 'nav-forward':
+					navigateHistory(1);
+					return;
+				case 'new-note':
+					createAndFocusNote();
+					return;
+				case 'toggle-theme': {
+					const isDark = $theme === 'dark' || ($theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+					const next = isDark ? 'light' : 'dark';
+					$theme = next;
+					setTheme(next);
+					return;
+				}
+				case 'search-vault':
+					$showSearch = true;
+					return;
+				case 'find-in-note':
+					if ($activeNotePath) {
+						editor?.openNoteSearch();
+					} else {
+						$showSearch = true;
+					}
+					return;
+				case 'quick-open':
+					$showCommandPalette = true;
+					return;
+				case 'save':
+					editor?.forceSave();
+					return;
+				case 'toggle-source':
+					$sourceMode = !$sourceMode;
+					return;
+				case 'open-new-window':
+					if ($activeNotePath && $activeNote) {
+						openNoteWindow($activeNotePath, $activeNote.meta.title);
+					}
+					return;
+				case 'toggle-sidebar':
+					$sidebarCollapsed = !$sidebarCollapsed;
+					return;
+				case 'toggle-notelist':
+					toggleNoteList();
+					return;
+				case 'toggle-focus':
+					$focusMode = !$focusMode;
+					return;
+				case 'toggle-readonly':
+					if ($viewerNote) return; // viewer mode is always read-only
+					$readOnly = !$readOnly;
+					return;
+				case 'fullscreen':
+					appWindow.isFullscreen().then(fs => appWindow.setFullscreen(!fs));
+					return;
 			}
 		}
-		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();
-			if ($viewerNote) return; // viewer mode is always read-only
-			$readOnly = !$readOnly;
-			return;
-		}
-		if (e.key === 'F11') {
-			e.preventDefault();
-			appWindow.isFullscreen().then(fs => appWindow.setFullscreen(!fs));
-			return;
-		}
+
 		if (e.key === 'Escape') {
 			if ($showSettings) $showSettings = false;
 			else if ($showInfo) $showInfo = false;
@@ -468,8 +510,7 @@
 	}
 
 	function applyTheme(t: string) {
-		const darkThemes = ['dark', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-dark', 'dracula'];
-		const namedThemes = ['solarized-light', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-light', 'github-dark', 'dracula'];
+		const namedThemes = ['solarized-light', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-light', 'github-dark', 'dracula', 'blueberry', 'forest-green', 'gruvbox', 'midnight-tide', 'cherry-blossom', 'synthwave', 'ember', 'moonlit', 'light-coffee', 'dark-coffee', 'cotton-candy', 'crimson', 'cloud', 'peach', 'material-dark', 'material-light', 'monokai', 'rose-pine', 'everforest', 'horizon', 'cyberpunk', 'black', 'one-dark'];
 		const root = document.documentElement;
 		root.classList.remove('dark');
 		root.removeAttribute('data-theme');
@@ -495,15 +536,31 @@
 		persistState();
 	});
 
+	$effect(() => {
+		$sidebarCollapsed;
+		$notelistCollapsed;
+		$outlineWidth;
+		persistState();
+	});
+
 	$effect(() => {
 		$notebookSortMode;
 		$notebookOrder;
 		persistState();
 	});
 
+	$effect(() => {
+		$noteOrder;
+		persistState();
+	});
+
 	$effect(() => {
 		$sortMode;
+		$groupNotesByDate;
 		$tasksLayout;
+		$tasksHideCompleted;
+		$tasksOnlyFlagged;
+		$tasksSort;
 		persistState();
 	});
 
@@ -523,12 +580,19 @@
 			const state = await loadVaultState();
 			$sidebarWidth = state.sidebar_width;
 			$notelistWidth = state.notelist_width;
+			if (typeof state.outline_width === 'number') $outlineWidth = state.outline_width;
 			$sidebarCollapsed = state.sidebar_collapsed;
+			$notelistCollapsed = state.notelist_collapsed ?? false;
 			$collapsedNotebooks = state.collapsed_notebooks ?? [];
 			$notebookSortMode = state.notebook_sort_mode === 'manual' ? 'manual' : 'alphabetical';
 			$notebookOrder = state.notebook_order ?? {};
-			if (state.sort_mode === 'created' || state.sort_mode === 'title' || state.sort_mode === 'modified') $sortMode = state.sort_mode;
+			$noteOrder = state.note_order ?? {};
+			if (state.sort_mode === 'created' || state.sort_mode === 'title' || state.sort_mode === 'modified' || state.sort_mode === 'custom') $sortMode = state.sort_mode;
+			if (typeof state.group_notes_by_date === 'boolean') $groupNotesByDate = state.group_notes_by_date;
 			if (state.tasks_layout === 'calendar' || state.tasks_layout === 'list') $tasksLayout = state.tasks_layout;
+			if (typeof state.tasks_hide_completed === 'boolean') $tasksHideCompleted = state.tasks_hide_completed;
+			if (typeof state.tasks_only_flagged === 'boolean') $tasksOnlyFlagged = state.tasks_only_flagged;
+			if (state.tasks_sort === 'due' || state.tasks_sort === 'priority' || state.tasks_sort === 'note') $tasksSort = state.tasks_sort;
 			lastNotePath = state.last_open_note ?? null;
 			lastViewMode = state.last_view_mode ?? '';
 			lastNotebook = state.last_notebook ?? null;
@@ -550,6 +614,29 @@
 		// Run sidebar and note list refresh in parallel
 		await Promise.all([sidebar?.refresh(), noteList?.refresh()]);
 
+		// Full-vault attachment scans cause navigation stalls on mobile storage.
+		// Mobile users can run the same cleanup explicitly from the Info panel.
+		if (!isMobile) {
+			setTimeout(async () => {
+				if (get(editorDirty)) return; // skip if user is actively editing
+				try {
+					const orphans = await findOrphanedAttachments();
+					if (orphans.length > 0) {
+						if (get(editorDirty)) return; // re-check after async scan
+						const moved = await trashOrphanedAttachments(orphans.map((o) => o.name));
+						if (moved > 0) {
+							const toast = document.createElement('div');
+							toast.style.cssText = 'position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:var(--bg-secondary);color:var(--text-primary);padding:10px 18px;border-radius:8px;box-shadow:0 4px 12px rgba(0,0,0,.15);border:1px solid var(--border-color);font-size:13px;z-index:10000;opacity:0;transition:opacity .3s;pointer-events:none';
+							toast.textContent = `Moved ${moved} orphaned attachment${moved > 1 ? 's' : ''} to trash`;
+							document.body.appendChild(toast);
+							requestAnimationFrame(() => (toast.style.opacity = '1'));
+							setTimeout(() => { toast.style.opacity = '0'; setTimeout(() => toast.remove(), 300); }, 4000);
+						}
+					}
+				} catch (_) {}
+			}, 3000);
+		}
+
 		// Restore the last session (view + open note) if enabled.
 		if ($appConfig?.restore_last_session) {
 			const vault = $appConfig?.active_vault;
@@ -615,7 +702,7 @@
 					}
 				}
 				tags.set(Array.from(tagMap.entries()).sort((a, b) => a[0].localeCompare(b[0])));
-			}, 3000);
+		}, 10000);
 			unlistenFileChange = await listen<FileEvent>('file-changed', () => {
 				debouncedRefresh();
 			});
@@ -645,15 +732,16 @@
 
 		// ── WebDAV sync: global status + auto-sync triggers ──
 		unlistenSync.push(await listen('sync-progress', () => syncState.set({ running: true, error: null })));
-		unlistenSync.push(await listen('sync-done', (event: any) => {
+		unlistenSync.push(await listen('sync-done', async () => {
 			syncState.set({ running: false, error: null });
-			const cur = get(appConfig);
-			if (cur && event.payload?.last_sync_time) appConfig.set({ ...cur, last_sync_time: event.payload.last_sync_time });
+			try {
+				appConfig.set(await getAppConfig());
+			} catch {}
 		}));
 		unlistenSync.push(await listen('sync-error', (event: any) => syncState.set({ running: false, error: event.payload?.error ?? 'Sync failed' })));
 
 		// Sync when the vault opens (if enabled)
-		if (syncConfigured() && get(appConfig)?.sync_on_open) {
+		if (syncConfigured() && activeVaultConfig(get(appConfig))?.sync_on_open) {
 			try { await syncNow(); } catch (_) {}
 		}
 
@@ -663,8 +751,8 @@
 
 		// Auto-sync on note change: a save flips editorDirty true -> false. Debounce a sync.
 		unsubDirty = editorDirty.subscribe((d) => {
-			const config = get(appConfig);
-			if (prevDirty && !d && config?.sync_provider === 'webdav' && config?.sync_on_change) {
+			const vc = activeVaultConfig(get(appConfig));
+			if (prevDirty && !d && vc?.sync_provider === 'webdav' && vc?.sync_on_change) {
 				if (onChangeSyncTimer) clearTimeout(onChangeSyncTimer);
 				onChangeSyncTimer = setTimeout(() => { if (!get(syncState).running) syncNow().catch(() => {}); }, 15000);
 			}
@@ -712,7 +800,7 @@
 					{#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 $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 === 'tasks'}Tasks{:else if $viewMode === 'trash'}Trash{:else}All Notes{/if}
 					{/if}
 				</span>
 				{#if $globalUpdateAvailable && $mobileView === 'sidebar'}
@@ -780,7 +868,7 @@
 						</svg>
 					</button>
 					{/if}
-					{#if $appConfig?.sync_provider === 'webdav'}
+					{#if activeVaultConfig($appConfig)?.sync_provider === 'webdav'}
 					<button class="mobile-header-btn" class:active={$syncState.running} onclick={triggerSyncNow} disabled={$syncState.running} title={$syncState.error ? `Sync error: ${$syncState.error}` : ($syncState.running ? 'Syncing...' : 'Sync now')}>
 						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class:sync-spin={$syncState.running}>
 							<path d="M21 2v6h-6"/><path d="M3 12a9 9 0 0115-6.7L21 8"/><path d="M3 22v-6h6"/><path d="M21 12a9 9 0 01-15 6.7L3 16"/>
@@ -807,6 +895,13 @@
 							<line x1="3" y1="10" x2="21" y2="10" />
 						</svg>
 					</button>
+					<button class="mobile-header-btn" onclick={() => ($showInfo = true)} title="Info">
+						<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" />
+							<line x1="12" y1="16" x2="12" y2="12" />
+							<line x1="12" y1="8" x2="12.01" y2="8" />
+						</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" />
@@ -823,7 +918,7 @@
 				<Sidebar bind:this={sidebar} onViewChanged={handleViewChanged} />
 			</div>
 			<div class="mobile-panel" class:active={$mobileView === 'notelist'}>
-				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); sidebar?.refresh(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
+				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
 			</div>
 			<div class="mobile-panel" class:active={$mobileView === 'editor'}>
 				<Editor bind:this={editor} />
@@ -882,11 +977,24 @@
 					<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(); sidebar?.refresh(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
-				</div>
+				{#if !$notelistCollapsed}
+					<div class="notelist-panel" style="width: {$notelistWidth}px">
+						<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
+					</div>
 
-				<ResizeHandle onResize={handleNotelistResize} />
+					<ResizeHandle onResize={handleNotelistResize} />
+				{:else}
+					<div class="notelist-restore-panel">
+						<button class="notelist-restore-btn" onclick={revealNoteList} title={`Show notes list (${isMac ? '⌘' : 'Ctrl'}+Shift+\\)`} aria-label="Show notes list">
+							<svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+								<line x1="8" y1="6" x2="20" y2="6" />
+								<line x1="8" y1="12" x2="20" y2="12" />
+								<line x1="8" y1="18" x2="20" y2="18" />
+								<polyline points="5 8 3 12 5 16" />
+							</svg>
+						</button>
+					</div>
+				{/if}
 			{/if}
 
 			<div class="editor-panel">
@@ -905,7 +1013,7 @@
 {/if}
 
 <SearchPanel />
-<CommandPalette />
+<CommandPalette onNavigate={handleViewChanged} />
 <SettingsPanel />
 <InfoPanel />
 
@@ -936,6 +1044,36 @@
 		overflow: hidden;
 	}
 
+	.notelist-restore-panel {
+		flex-shrink: 0;
+		width: 36px;
+		height: 100%;
+		padding-top: 8px;
+		display: flex;
+		justify-content: center;
+		background: var(--bg-primary);
+		border-right: 1px solid var(--border-color);
+	}
+
+	.notelist-restore-btn {
+		width: 24px;
+		height: 24px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+		border: none;
+		border-radius: 4px;
+		background: transparent;
+		color: var(--text-tertiary);
+		cursor: pointer;
+	}
+
+	.notelist-restore-btn:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
 	.editor-panel {
 		flex: 1;
 		height: 100%;
@@ -1022,7 +1160,13 @@
 	.mobile-shell {
 		display: flex;
 		flex-direction: column;
-		height: 100vh;
+		height: 100dvh;
+		box-sizing: border-box;
+		padding:
+			env(safe-area-inset-top, 0px)
+			env(safe-area-inset-right, 0px)
+			env(safe-area-inset-bottom, 0px)
+			env(safe-area-inset-left, 0px);
 		overflow: hidden;
 		background: var(--bg-primary);
 	}

src/lib/components/CommandPalette.svelte

@@ -1,6 +1,19 @@
 <script lang="ts">
-	import { showCommandPalette, showSearch, theme, sourceMode } from '$lib/stores/app';
+	import { showCommandPalette, showSearch, theme, sourceMode, viewMode, activeNotebook, activeTag } from '$lib/stores/app';
 	import { setTheme, reindex } from '$lib/api';
+	import { darkThemes } from '$lib/platform';
+
+	// onNavigate runs the parent's view-change handler (refreshes the note list and reveals it
+	// if it was hidden), so opening a view here behaves exactly like clicking it in the sidebar.
+	let { onNavigate = () => {} }: { onNavigate?: () => void } = $props();
+
+	function openView(mode: 'all' | 'quickaccess' | 'tasks' | 'daily' | 'trash') {
+		$viewMode = mode;
+		$activeNotebook = null;
+		$activeTag = null;
+		$showCommandPalette = false;
+		onNavigate();
+	}
 
 	interface Command {
 		id: string;
@@ -25,6 +38,31 @@
 				$showSearch = true;
 			}
 		},
+		{
+			id: 'open-all-notes',
+			label: 'Open All Notes',
+			action: () => openView('all')
+		},
+		{
+			id: 'open-quick-access',
+			label: 'Open Quick Access',
+			action: () => openView('quickaccess')
+		},
+		{
+			id: 'open-tasks',
+			label: 'Open Tasks',
+			action: () => openView('tasks')
+		},
+		{
+			id: 'open-daily',
+			label: 'Open Daily Notes',
+			action: () => openView('daily')
+		},
+		{
+			id: 'open-trash',
+			label: 'Open Trash (restore deleted notes)',
+			action: () => openView('trash')
+		},
 		{
 			id: 'theme-light',
 			label: 'Switch to Light Theme',
@@ -142,8 +180,7 @@
 	}
 
 	function applyTheme(t: string) {
-		const darkThemes = ['dark', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-dark', 'dracula'];
-		const namedThemes = ['solarized-light', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-light', 'github-dark', 'dracula'];
+		const namedThemes = ['solarized-light', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-light', 'github-dark', 'dracula', 'blueberry', 'forest-green', 'gruvbox', 'midnight-tide', 'cherry-blossom', 'synthwave', 'ember', 'moonlit', 'light-coffee', 'dark-coffee', 'cotton-candy', 'crimson', 'cloud', 'peach', 'material-dark', 'material-light', 'monokai', 'rose-pine', 'everforest', 'horizon', 'cyberpunk', 'black', 'one-dark'];
 		const root = document.documentElement;
 		root.classList.remove('dark');
 		root.removeAttribute('data-theme');

src/lib/components/GraphView.svelte

@@ -2,14 +2,13 @@
 	import { onDestroy } from 'svelte';
 	import { getGraphData } from '$lib/api';
 	import { activeNotePath, appConfig } from '$lib/stores/app';
+	import { isMobile } from '$lib/platform';
 
 	let { onclose, onnavigate }: {
 		onclose: () => void;
 		onnavigate: (path: string, title: string) => void;
 	} = $props();
 
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
-
 	let canvas = $state<HTMLCanvasElement>(null!);
 	let loading = $state(true);
 	let searchQuery = $state('');

src/lib/components/InfoPanel.svelte

@@ -1,22 +1,102 @@
 <script lang="ts">
 	import { showInfo, appConfig } from '$lib/stores/app';
-	import { getVaultStats } from '$lib/api';
+	import { getVaultStats, findOrphanedAttachments, trashOrphanedAttachments } from '$lib/api';
+	import type { OrphanAttachment } from '$lib/api';
 	import { openUrl } from '$lib/api';
 	import { getVersion } from '@tauri-apps/api/app';
 	import type { VaultStats } from '$lib/types';
+	import {
+		ACTIONS,
+		keybindings,
+		setBinding,
+		resetBinding,
+		bindingFromEvent,
+		bindingToKeys,
+		bindingsEqual,
+		type ActionDef,
+	} from '$lib/keybindings';
+	import { isMobile } from '$lib/platform';
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
+
+	// Customizable shortcuts, grouped for display.
+	const actionGroups: { title: string; actions: ActionDef[] }[] = [
+		{ title: 'General', actions: ACTIONS.filter((a) => a.group === 'General') },
+		{ title: 'Interface', actions: ACTIONS.filter((a) => a.group === 'Interface') },
+		{ title: 'Navigation', actions: ACTIONS.filter((a) => a.group === 'Navigation') },
+	];
+
+	// id of the action currently listening for a new key combo, or null.
+	let capturingId = $state<string | null>(null);
+	// id of an action whose row should briefly flash a "already in use" warning.
+	let conflictId = $state<string | null>(null);
+	let conflictTimer: ReturnType<typeof setTimeout> | null = null;
+
+	function startCapture(id: string) {
+		conflictId = null;
+		capturingId = id;
+	}
+
+	function stopCapture() {
+		capturingId = null;
+	}
+
+	function flashConflict(id: string) {
+		conflictId = id;
+		if (conflictTimer) clearTimeout(conflictTimer);
+		conflictTimer = setTimeout(() => { conflictId = null; }, 1600);
+	}
+
+	function captureKeydown(e: KeyboardEvent) {
+		if (!capturingId) return;
+		// Capture phase + stopImmediatePropagation keeps the combo from also
+		// triggering the app-level shortcut handler on window.
+		e.preventDefault();
+		e.stopImmediatePropagation();
+		if (e.key === 'Escape') { stopCapture(); return; }
+
+		const binding = bindingFromEvent(e);
+		if (!binding) return; // modifier-only press; keep listening
+
+		// Reject combos already bound to a different action.
+		const map = $keybindings;
+		const target = capturingId;
+		const clash = Object.keys(map).find((other) => other !== target && bindingsEqual(map[other], binding));
+		if (clash) {
+			flashConflict(target);
+			stopCapture();
+			return;
+		}
+
+		setBinding(target, binding);
+		stopCapture();
+	}
+
+	$effect(() => {
+		if (!capturingId) return;
+		window.addEventListener('keydown', captureKeydown, true);
+		return () => window.removeEventListener('keydown', captureKeydown, true);
+	});
+
+	function resetKey(e: MouseEvent, id: string) {
+		e.preventDefault();
+		resetBinding(id);
+		if (capturingId === id) stopCapture();
+	}
 
 	let stats = $state<VaultStats | null>(null);
 	let activeTab = $state<'about' | 'shortcuts'>(isMobile ? 'about' : 'shortcuts');
 	let appVersion = $state('...');
+	let orphans = $state<OrphanAttachment[] | null>(null);
+	let scanning = $state(false);
+	let trashing = $state(false);
+	const orphanTotal = $derived((orphans ?? []).reduce((a, o) => a + o.size, 0));
 
 	getVersion().then(v => appVersion = v).catch(() => appVersion = '0.0.0');
 
 	function close() {
 		$showInfo = false;
-		activeTab = 'shortcuts';
+		activeTab = isMobile ? 'about' : 'shortcuts';
 	}
 
 	function openLink(url: string) {
@@ -35,8 +115,26 @@
 			getVaultStats().then((s) => { stats = s; }).catch(console.error);
 		} else {
 			stats = null;
+			orphans = null;
 		}
 	});
+
+	async function scanOrphans() {
+		scanning = true;
+		try { orphans = await findOrphanedAttachments(); }
+		catch (e) { console.error(e); }
+		finally { scanning = false; }
+	}
+	async function trashOrphans() {
+		if (!orphans || orphans.length === 0) return;
+		trashing = true;
+		try {
+			await trashOrphanedAttachments(orphans.map((o) => o.name));
+			orphans = null;
+			getVaultStats().then((sv) => { stats = sv; }).catch(console.error);
+		} catch (e) { console.error(e); }
+		finally { trashing = false; }
+	}
 </script>
 
 {#if $showInfo}
@@ -103,6 +201,25 @@
 						</div>
 					{/if}
 
+					{#if stats}
+						<div class="info-cleanup">
+							{#if orphans === null}
+								<button class="cleanup-btn" onclick={scanOrphans} disabled={scanning}>{#if scanning}<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>Scanning…{:else}Find orphaned attachments{/if}</button>
+							{:else if orphans.length === 0}
+								<p class="cleanup-msg">No orphaned attachments. Nothing to clean up.</p>
+							{:else}
+								<p class="cleanup-msg">{orphans.length} {orphans.length === 1 ? 'attachment is' : 'attachments are'} not referenced by any note ({formatSize(orphanTotal)}).</p>
+								<div class="cleanup-list">
+									{#each orphans as o}
+										<div class="cleanup-row"><span class="cleanup-name" title={o.name}>{o.name}</span><span class="cleanup-size">{formatSize(o.size)}</span></div>
+									{/each}
+								</div>
+								<button class="cleanup-btn" onclick={trashOrphans} disabled={trashing}>{#if trashing}<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>Moving…{:else}Move {orphans.length} to Trash{/if}</button>
+								<p class="cleanup-hint">Moved to the vault's trash folder (recoverable), not permanently deleted.</p>
+							{/if}
+						</div>
+					{/if}
+
 					<div class="info-credits">
 						<p>Created by <strong>Yuri Karamian</strong></p>
 						<button class="info-link" onclick={() => openLink('https://helixnotes.com')}>
@@ -116,27 +233,39 @@
 					</div>
 				{:else}
 					<div class="shortcuts-section">
-						<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>
+						{#if !isMobile}
+							<p class="shortcuts-hint">Click a shortcut to rebind it, right-click to reset.</p>
+						{/if}
+						{#each actionGroups as group}
+							<h4 class="shortcuts-group-title">{group.title}</h4>
+							{#each group.actions as action}
+								<div class="shortcut-row">
+									<span class="shortcut-desc">{action.label}</span>
+									{#if isMobile}
+										<span class="shortcut-keys">{#each bindingToKeys($keybindings[action.id]) as key, i}{#if i > 0}+{/if}<kbd>{key}</kbd>{/each}</span>
+									{:else}
+										<button
+											class="shortcut-key-btn"
+											class:capturing={capturingId === action.id}
+											class:conflict={conflictId === action.id}
+											title="Click to rebind · right-click to reset"
+											onclick={() => startCapture(action.id)}
+											oncontextmenu={(e) => resetKey(e, action.id)}
+										>
+											{#if capturingId === action.id}
+												<span class="capture-prompt">Press keys…</span>
+											{:else if conflictId === action.id}
+												<span class="conflict-msg">Already in use</span>
+											{:else}
+												<span class="shortcut-keys">{#each bindingToKeys($keybindings[action.id]) as key, i}{#if i > 0}+{/if}<kbd>{key}</kbd>{/each}</span>
+											{/if}
+										</button>
+									{/if}
+								</div>
+							{/each}
+						{/each}
 						<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>
@@ -147,6 +276,7 @@
 						<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>
+						<div class="shortcut-row"><span class="shortcut-desc">Move list item up / down</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>Shift</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>
@@ -350,6 +480,71 @@
 	.info-link:hover {
 		background: var(--accent-light);
 	}
+	.info-cleanup {
+		width: 100%;
+		margin-top: 16px;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		gap: 8px;
+	}
+	.cleanup-btn {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		gap: 6px;
+		background: var(--bg-secondary);
+		border: 1px solid var(--border-color);
+		border-radius: 8px;
+		color: var(--text-primary);
+		font-size: 13px;
+		padding: 7px 14px;
+		cursor: pointer;
+	}
+	.cleanup-btn:hover:not(:disabled) { background: var(--bg-hover); }
+	.cleanup-btn:disabled { opacity: 0.6; cursor: default; }
+	.cleanup-msg {
+		font-size: 13px;
+		color: var(--text-secondary);
+		text-align: center;
+	}
+	.cleanup-list {
+		width: 100%;
+		max-height: 140px;
+		overflow-y: auto;
+		background: var(--bg-secondary);
+		border: 1px solid var(--border-light);
+		border-radius: 8px;
+	}
+	.cleanup-row {
+		display: flex;
+		justify-content: space-between;
+		gap: 12px;
+		padding: 5px 12px;
+		font-size: 12px;
+	}
+	.cleanup-name {
+		color: var(--text-secondary);
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.cleanup-size {
+		color: var(--text-tertiary);
+		flex-shrink: 0;
+	}
+	.cleanup-hint {
+		font-size: 11px;
+		color: var(--text-tertiary);
+		text-align: center;
+	}
+	.spinner-icon {
+		animation: spin 0.8s linear infinite;
+	}
+	@keyframes spin {
+		from { transform: rotate(0deg); }
+		to { transform: rotate(360deg); }
+	}
 
 	.shortcuts-section {
 		width: 100%;
@@ -394,6 +589,48 @@
 		color: var(--text-tertiary);
 	}
 
+	.shortcuts-hint {
+		font-size: 12px;
+		color: var(--text-tertiary);
+		margin: 0 0 4px;
+	}
+
+	.shortcut-key-btn {
+		background: none;
+		border: 1px solid transparent;
+		border-radius: 6px;
+		padding: 2px 4px;
+		margin: -2px -4px;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		flex-shrink: 0;
+		font: inherit;
+	}
+
+	.shortcut-key-btn:hover {
+		background: var(--bg-hover);
+	}
+
+	.shortcut-key-btn.capturing {
+		border-color: var(--accent);
+		background: var(--accent-light);
+	}
+
+	.shortcut-key-btn.conflict {
+		border-color: var(--danger, #e11d48);
+	}
+
+	.capture-prompt {
+		font-size: 12px;
+		color: var(--accent);
+	}
+
+	.conflict-msg {
+		font-size: 12px;
+		color: var(--danger, #e11d48);
+	}
+
 	.shortcut-keys kbd,
 	.shortcut-desc kbd {
 		display: inline-block;

src/lib/components/NoteList.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { tick } from 'svelte';
 	import {
 		notes,
 		sortedNotes,
@@ -8,9 +9,12 @@
 		activeNotebook,
 		activeTag,
 		sortMode,
+		groupNotesByDate,
 		editorDirty,
 		quickAccessPaths,
 		appConfig,
+		notelistCollapsed,
+		noteOrder,
 		notebooks,
 		tags,
 		mobileView
@@ -34,15 +38,16 @@
 		getAllTags,
 		createDailyNote
 	} from '$lib/api';
-	import { formatRelativeTime, formatDate } from '$lib/utils/time';
+	import { formatRelativeTime, formatDate, dateBucketLabel } from '$lib/utils/time';
 	import { openNoteWindow } from '$lib/utils/window';
 	import { revealItemInDir } from '@tauri-apps/plugin-opener';
 	import type { NoteEntry, TrashNotebookEntry, SortMode, TaskItem } from '$lib/types';
 	import TasksView from './TasksView.svelte';
 	import TagSuggestInput from './TagSuggestInput.svelte';
+	import { isMobile, isAndroid } from '$lib/platform';
 
-	let { onNoteSelected = (_path: string, _content: string) => {}, onNoteMoved = () => {}, onBeforeNoteSwitch = () => {}, onNoteCreated = () => {}, onToggleTask = async (_t: TaskItem) => {}, onSetTaskPriority = async (_t: TaskItem, _p: string | null) => {}, onSetTaskDue = async (_t: TaskItem, _d: string | null) => {} }: {
-		onNoteSelected?: (path: string, content: string) => void;
+	let { onNoteSelected = (_path: string, _content: string, _task?: TaskItem) => {}, onNoteMoved = () => {}, onBeforeNoteSwitch = () => {}, onNoteCreated = () => {}, onToggleTask = async (_t: TaskItem) => {}, onSetTaskPriority = async (_t: TaskItem, _p: string | null) => {}, onSetTaskDue = async (_t: TaskItem, _d: string | null) => {} }: {
+		onNoteSelected?: (path: string, content: string, task?: TaskItem) => void;
 		onNoteMoved?: () => void;
 		onBeforeNoteSwitch?: () => void;
 		onNoteCreated?: () => void;
@@ -52,8 +57,6 @@
 	} = $props();
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
-	const isAndroid = /android/i.test(navigator.userAgent);
 	let multiSelectMode = $state(false);
 	let trashNotebooks = $state<TrashNotebookEntry[]>([]);
 	let trashBusy = $state<string | null>(null);
@@ -143,6 +146,7 @@
 	let sortMenu = $state<{ x: number; y: number } | null>(null);
 	let editingNote = $state<string | null>(null);
 	let editValue = $state('');
+	let renameInput: HTMLInputElement | null = $state(null);
 	let movePickerNote = $state<NoteEntry | null>(null);
 	let tagEditNote = $state<NoteEntry | null>(null);
 	let tagEditTags = $state<string[]>([]);
@@ -203,6 +207,29 @@
 	let qaDragFrom = $state<number | null>(null);
 	let qaDragOver = $state<number | null>(null);
 	let qaDragHalf = $state<'top' | 'bottom'>('bottom');
+	let noteDragFrom = $state<number | null>(null);
+	let noteDragOver = $state<number | null>(null);
+	let noteDragHalf = $state<'top' | 'bottom'>('bottom');
+	const customOrderViews = new Set(['all', 'notebook', 'tag']);
+	let canCustomReorder = $derived($sortMode === 'custom' && customOrderViews.has($viewMode));
+
+	// Relative-date grouping (All Notes + date sorts only). Pinned notes form their own leading group.
+	let groupingActive = $derived($groupNotesByDate && $viewMode === 'all' && ($sortMode === 'created' || $sortMode === 'modified'));
+	let noteGroups = $derived.by(() => {
+		if (!groupingActive) return [] as { label: string; notes: NoteEntry[] }[];
+		const pinned: NoteEntry[] = [];
+		const rest: NoteEntry[] = [];
+		for (const n of $sortedNotes) (n.meta.pinned ? pinned : rest).push(n);
+		const groups: { label: string; notes: NoteEntry[] }[] = [];
+		if (pinned.length) groups.push({ label: 'Pinned', notes: pinned });
+		let cur: { label: string; notes: NoteEntry[] } | null = null;
+		for (const n of rest) {
+			const label = dateBucketLabel($sortMode === 'created' ? n.meta.created : n.meta.modified);
+			if (!cur || cur.label !== label) { cur = { label, notes: [] }; groups.push(cur); }
+			cur.notes.push(n);
+		}
+		return groups;
+	});
 
 	// Virtual scroll
 	let listContainer = $state<HTMLDivElement>(null!);
@@ -310,7 +337,9 @@
 		}
 
 		const key = cacheKey();
-		const cached = noteCache.get(key);
+		// Never serve the trash view from cache: emptying / restoring / deleting changes it,
+		// and a stale cache left it showing cleared items until an app restart. Always re-read.
+		const cached = $viewMode === 'trash' ? undefined : noteCache.get(key);
 		if (cached) {
 			$notes = cached;
 			return;
@@ -380,13 +409,14 @@
 			$activeNote = content;
 			$activeNotePath = task.note_path;
 			$editorDirty = false;
-			onNoteSelected(task.note_path, content.content);
+			onNoteSelected(task.note_path, content.content, task);
 		} catch (e) {
 			console.error('Failed to open task note:', e);
 		}
 	}
 
 	export async function handleCreateNote() {
+		if ($viewMode === 'quickaccess' || $viewMode === 'trash') return;
 		if ($viewMode === 'daily') {
 			const today = new Date();
 			const date = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
@@ -410,15 +440,28 @@
 		}
 		try {
 			const entry = await createNote(nbRelative, 'Untitled');
+			if ($sortMode === 'custom') appendManualNoteOrder(entry.path);
 			noteCache.clear();
-			await refresh();
-			await selectNote(entry);
+			$notes = [entry, ...$notes];
+			onBeforeNoteSwitch();
+			$activeNote = { path: entry.path, meta: entry.meta, content: '\n', raw: '' };
+			$activeNotePath = entry.path;
+			$editorDirty = false;
+			onNoteSelected(entry.path, '\n');
 			onNoteCreated();
 		} catch (e) {
 			console.error('Failed to create note:', e);
 		}
 	}
 
+	function handleListDoubleClick(e: MouseEvent) {
+		const target = e.target as HTMLElement | null;
+		if (target?.closest('button, input, .note-item, .context-menu, .sort-menu, .batch-move-picker, .cal')) return;
+		e.stopPropagation();
+		if ($viewMode === 'tasks' || $viewMode === 'trash' || $viewMode === 'quickaccess') return;
+		handleCreateNote();
+	}
+
 	async function handleRename(note: NoteEntry) {
 		if (!editValue.trim() || editValue.trim() === note.meta.title) {
 			editingNote = null;
@@ -427,6 +470,7 @@
 		try {
 			const newTitle = editValue.trim();
 			const newPath = await renameNote(note.path, newTitle);
+			renameManualNoteOrderPath(note.path, newPath);
 			noteCache.clear();
 			editingNote = null;
 			// Update local store immediately (avoid full vault re-scan)
@@ -448,6 +492,7 @@
 		contextMenu = null;
 		try {
 			await deleteNote(note.path);
+			removeManualNoteOrderPath(note.path);
 			noteCache.clear();
 			// Remove from local store immediately (avoid full vault re-scan)
 			$notes = $notes.filter(n => n.path !== note.path);
@@ -460,6 +505,13 @@
 		}
 	}
 
+	// Move the currently open note to the trash (keyboard shortcut from the editor).
+	export async function trashActiveNote() {
+		if ($viewMode === 'trash' || !$activeNotePath) return;
+		const note = $notes.find(n => n.path === $activeNotePath);
+		if (note) await handleDelete(note);
+	}
+
 	async function handleRestore(note: NoteEntry) {
 		contextMenu = null;
 		try {
@@ -475,6 +527,7 @@
 		contextMenu = null;
 		try {
 			await permanentDelete(note.path);
+			removeManualNoteOrderPath(note.path);
 			noteCache.clear();
 			$notes = $notes.filter(n => n.path !== note.path);
 			if ($activeNotePath === note.path) {
@@ -668,11 +721,60 @@
 		}
 	}
 
+	function persistManualNoteOrder(orderedNotes: NoteEntry[]) {
+		// Merge into (not replace) the order map so reordering notes in one view does
+		// not wipe the saved custom order of other notebooks / tags / the all-notes view.
+		const updates = Object.fromEntries(orderedNotes.map((note, index) => [note.path, index]));
+		$noteOrder = { ...$noteOrder, ...updates };
+	}
+
+	function appendManualNoteOrder(path: string) {
+		const nextIndex = Math.max(-1, ...Object.values($noteOrder)) + 1;
+		$noteOrder = { ...$noteOrder, [path]: nextIndex };
+	}
+
+	function renameManualNoteOrderPath(oldPath: string, newPath: string) {
+		if (!Object.hasOwn($noteOrder, oldPath)) return;
+		const { [oldPath]: index, ...rest } = $noteOrder;
+		$noteOrder = { ...rest, [newPath]: index };
+	}
+
+	function removeManualNoteOrderPath(path: string) {
+		if (!Object.hasOwn($noteOrder, path)) return;
+		const { [path]: _, ...rest } = $noteOrder;
+		$noteOrder = rest;
+	}
+
+	function resetNoteDrag() {
+		noteDragFrom = null;
+		noteDragOver = null;
+	}
+
+	function handleCustomNoteDrop(targetIndex: number) {
+		if (noteDragFrom === null || !canCustomReorder) {
+			resetNoteDrag();
+			return;
+		}
+		let insertAt = noteDragHalf === 'bottom' ? targetIndex + 1 : targetIndex;
+		if (noteDragFrom === insertAt || noteDragFrom + 1 === insertAt) {
+			resetNoteDrag();
+			return;
+		}
+		const arr = [...$sortedNotes];
+		const [moved] = arr.splice(noteDragFrom, 1);
+		if (insertAt > noteDragFrom) insertAt--;
+		arr.splice(insertAt, 0, moved);
+		$notes = arr;
+		persistManualNoteOrder(arr);
+		resetNoteDrag();
+	}
+
 	async function handleMoveNote(note: NoteEntry, destPath: string) {
 		contextMenu = null;
 		movePickerNote = null;
 		try {
 			const newPath = await moveNote(note.path, destPath);
+			renameManualNoteOrderPath(note.path, newPath);
 			noteCache.clear();
 			$notes = $notes.filter(n => n.path !== note.path);
 			if ($activeNotePath === note.path) {
@@ -685,6 +787,19 @@
 		}
 	}
 
+	function isFiled(note: NoteEntry): boolean {
+		const vaultRoot = $appConfig?.active_vault?.replace(/\\/g, '/').replace(/\/$/, '');
+		if (!vaultRoot) return false;
+		const normalizedPath = note.path.replace(/\\/g, '/');
+		const noteDir = normalizedPath.substring(0, normalizedPath.lastIndexOf('/'));
+		return noteDir !== vaultRoot;
+	}
+
+	function unfileNote(note: NoteEntry) {
+		const vaultRoot = $appConfig?.active_vault;
+		if (vaultRoot) handleMoveNote(note, vaultRoot);
+	}
+
 	function clampMenu(x: number, y: number, menuWidth = 220, menuHeight = 400): { x: number; y: number } {
 		if (x + menuWidth > window.innerWidth) x = window.innerWidth - menuWidth - 8;
 		if (y + menuHeight > window.innerHeight) y = window.innerHeight - menuHeight - 8;
@@ -699,10 +814,13 @@
 		contextMenu = { x, y, note };
 	}
 
-	function startRename(note: NoteEntry) {
+	async function startRename(note: NoteEntry) {
 		contextMenu = null;
 		editingNote = note.path;
 		editValue = note.meta.title;
+		await tick();
+		renameInput?.focus();
+		renameInput?.select();
 	}
 
 	function getNotebookPath(note: NoteEntry): string {
@@ -771,6 +889,7 @@
 	async function handleBatchDelete() {
 		const toDelete = new Set(selectedPaths);
 		noteCache.clear();
+		for (const path of toDelete) removeManualNoteOrderPath(path);
 		$notes = $notes.filter(n => !toDelete.has(n.path));
 		if ($activeNotePath && toDelete.has($activeNotePath)) {
 			$activeNote = null;
@@ -806,6 +925,7 @@
 	async function handleBatchPermanentDelete() {
 		const toDelete = new Set(selectedPaths);
 		noteCache.clear();
+		for (const path of toDelete) removeManualNoteOrderPath(path);
 		$notes = $notes.filter(n => !toDelete.has(n.path));
 		if ($activeNotePath && toDelete.has($activeNotePath)) {
 			$activeNote = null;
@@ -831,6 +951,9 @@
 	}
 
 	function setSortMode(mode: SortMode) {
+		if (mode === 'custom' && Object.keys($noteOrder).length === 0) {
+			persistManualNoteOrder($sortedNotes);
+		}
 		$sortMode = mode;
 		sortMenu = null;
 	}
@@ -854,6 +977,16 @@
 	<div class="list-header">
 		<span class="list-title">{viewTitle}</span>
 		<div class="list-actions">
+			{#if !isMobile}
+				<button class="icon-btn" onclick={() => ($notelistCollapsed = true)} title={`Hide notes list (${modKey}+Shift+\\)`} aria-label="Hide notes list">
+					<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+						<line x1="4" y1="6" x2="16" y2="6" />
+						<line x1="4" y1="12" x2="16" y2="12" />
+						<line x1="4" y1="18" x2="16" y2="18" />
+						<polyline points="19 8 21 12 19 16" />
+					</svg>
+				</button>
+			{/if}
 			{#if $viewMode !== 'tasks'}
 			{#if isAndroid}
 				<button class="icon-btn" class:active-toggle={multiSelectMode} onclick={() => { multiSelectMode = !multiSelectMode; if (!multiSelectMode) clearSelection(); }} title="Multi-select">
@@ -867,7 +1000,14 @@
 					<line x1="4" y1="6" x2="11" y2="6" /><line x1="4" y1="12" x2="15" y2="12" /><line x1="4" y1="18" x2="20" y2="18" />
 				</svg>
 			</button>
-			{#if $viewMode !== 'trash'}
+			{#if $viewMode === 'all' && ($sortMode === 'created' || $sortMode === 'modified')}
+				<button class="icon-btn" class:active-toggle={$groupNotesByDate} onclick={() => { $groupNotesByDate = !$groupNotesByDate; }} title="Group by date">
+					<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="8" y1="6" x2="21" y2="6" /><line x1="8" y1="12" x2="21" y2="12" /><line x1="8" y1="18" x2="21" y2="18" /><line x1="3" y1="6" x2="3.01" y2="6" /><line x1="3" y1="12" x2="3.01" y2="12" /><line x1="3" y1="18" x2="3.01" y2="18" />
+					</svg>
+				</button>
+			{/if}
+			{#if $viewMode !== 'trash' && $viewMode !== 'quickaccess'}
 				<button class={isMobile ? 'mobile-create-btn' : 'icon-btn'} onclick={handleCreateNote} title={`New note (${modKey}+N)`}>
 					<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width={isMobile ? '3' : '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" />
@@ -883,8 +1023,14 @@
 			<span class="selection-count">{selectedPaths.size} selected</span>
 			<div class="selection-actions">
 				{#if $viewMode === 'trash'}
-					<button class="selection-action" onclick={handleBatchRestore}>Restore</button>
-					<button class="selection-action danger" onclick={handleBatchPermanentDelete}>Delete</button>
+					<button class="selection-action" onclick={handleBatchRestore} title="Restore selected">
+						<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="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>
+						Restore
+					</button>
+					<button class="selection-action danger" onclick={handleBatchPermanentDelete} title="Delete permanently">
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-2 14a2 2 0 0 1-2 2H9a2 2 0 0 1-2-2L5 6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>
+						Delete
+					</button>
 				{:else}
 					<button class="selection-action" onclick={() => { batchMovePicker = true; }}>Move</button>
 					<button class="selection-action" onclick={() => openBatchTagEdit()}>Tag</button>
@@ -965,7 +1111,8 @@
 		</div>
 	{/if}
 
-	<div class="list-content" bind:this={listContainer} onscroll={onListScroll}>
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div class="list-content" class:tasks-mode={$viewMode === 'tasks'} bind:this={listContainer} onscroll={onListScroll} ondblclick={handleListDoubleClick}>
 		{#if $viewMode === 'tasks'}
 			<TasksView onOpenTask={openTask} onToggleTask={onToggleTask} onSetTaskPriority={onSetTaskPriority} onSetTaskDue={onSetTaskDue} />
 		{/if}
@@ -1007,6 +1154,8 @@
 			<div class="empty-state">
 				{#if $viewMode === 'trash'}
 					<p>Trash is empty</p>
+				{:else if $viewMode === 'quickaccess'}
+					<p>No starred notes</p>
 				{:else}
 					<p>No notes yet</p>
 					<button class="btn-link" onclick={handleCreateNote}>Create your first note</button>
@@ -1045,14 +1194,13 @@
 			{/each}
 		{/if}
 
-		<div style="height: {topPad}px"></div>
-		{#each visibleNotes as note, i (note.path)}
-			{@const noteIndex = startIndex + i}
+		{#snippet noteRow(note: NoteEntry, noteIndex: number)}
 			{#if editingNote === note.path}
 				<div class="note-item active">
 					<input
 						type="text"
 						class="rename-input"
+						bind:this={renameInput}
 						bind:value={editValue}
 						onkeydown={(e) => {
 							if (e.key === 'Enter') handleRename(note);
@@ -1070,7 +1218,15 @@
 					class:compact={compact}
 					class:qa-drag-above={$viewMode === 'quickaccess' && qaDragOver === noteIndex && qaDragFrom !== null && qaDragHalf === 'top'}
 					class:qa-drag-below={$viewMode === 'quickaccess' && qaDragOver === noteIndex && qaDragFrom !== null && qaDragHalf === 'bottom'}
+					class:note-drag-above={canCustomReorder && noteDragOver === noteIndex && noteDragFrom !== null && noteDragHalf === 'top'}
+					class:note-drag-below={canCustomReorder && noteDragOver === noteIndex && noteDragFrom !== null && noteDragHalf === 'bottom'}
 					onclick={(e) => handleNoteClick(e, note)}
+					onkeydown={(e) => {
+						if (e.key === 'F2') {
+							e.preventDefault();
+							startRename(note);
+						}
+					}}
 					ontouchstart={(e) => { if (isMobile && !isAndroid) handleTouchStart(e, note); }}
 					ontouchmove={(e) => { if (isMobile && !isAndroid) handleTouchMove(e); }}
 					ontouchend={() => { if (isMobile && !isAndroid) handleTouchEnd(); }}
@@ -1097,6 +1253,12 @@
 							e.dataTransfer!.effectAllowed = 'move';
 							return;
 						}
+						if (canCustomReorder) {
+							noteDragFrom = noteIndex;
+							e.dataTransfer!.setData('text/plain', note.path);
+							e.dataTransfer!.effectAllowed = 'move';
+							return;
+						}
 						if (selectedPaths.size > 1 && selectedPaths.has(note.path)) {
 							e.dataTransfer!.setData('text/plain', [...selectedPaths].join('\n'));
 						} else {
@@ -1111,18 +1273,28 @@
 							const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
 							qaDragHalf = e.clientY < rect.top + rect.height / 2 ? 'top' : 'bottom';
 							qaDragOver = noteIndex;
+						} else if (canCustomReorder && noteDragFrom !== null) {
+							e.preventDefault();
+							e.dataTransfer!.dropEffect = 'move';
+							const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+							noteDragHalf = e.clientY < rect.top + rect.height / 2 ? 'top' : 'bottom';
+							noteDragOver = noteIndex;
 						}
 					}}
 					ondragleave={() => {
 						if (qaDragOver === noteIndex) qaDragOver = null;
+						if (noteDragOver === noteIndex) noteDragOver = null;
 					}}
 					ondrop={(e) => {
 						if ($viewMode === 'quickaccess' && qaDragFrom !== null) {
 							e.preventDefault();
 							handleQaDrop(noteIndex);
+						} else if (canCustomReorder && noteDragFrom !== null) {
+							e.preventDefault();
+							handleCustomNoteDrop(noteIndex);
 						}
 					}}
-					ondragend={() => { qaDragFrom = null; qaDragOver = null; }}
+					ondragend={() => { qaDragFrom = null; qaDragOver = null; resetNoteDrag(); }}
 				>
 					{#if compact}
 						<div class="note-compact-row" title={getNotebookPath(note) ? `${getNotebookPath(note)}/${note.meta.title}` : note.meta.title}>
@@ -1173,11 +1345,35 @@
 								</span>
 							{/if}
 						</div>
-					{/if}
-				</button>
+				{/if}
+				{#if $viewMode === 'trash'}
+					<span class="trash-row-actions">
+						<span class="trash-row-btn" role="button" tabindex="0" onclick={(e) => { e.stopPropagation(); handleRestore(note); }} title="Restore" onkeydown={(e) => { if (e.key === 'Enter') { e.stopPropagation(); handleRestore(note); } }}>
+							<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="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>
+						</span>
+						<span class="trash-row-btn danger" role="button" tabindex="0" onclick={(e) => { e.stopPropagation(); handlePermanentDelete(note); }} title="Delete permanently" onkeydown={(e) => { if (e.key === 'Enter') { e.stopPropagation(); handlePermanentDelete(note); } }}>
+							<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-2 14a2 2 0 0 1-2 2H9a2 2 0 0 1-2-2L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/><path d="M9 6V4h6v2"/></svg>
+						</span>
+					</span>
+				{/if}
+			</button>
 			{/if}
-		{/each}
-		<div style="height: {bottomPad}px"></div>
+		{/snippet}
+
+		{#if groupingActive}
+			{#each noteGroups as group (group.label)}
+				<div class="note-list-section">{group.label}</div>
+				{#each group.notes as note (note.path)}
+					{@render noteRow(note, -1)}
+				{/each}
+			{/each}
+		{:else}
+			<div style="height: {topPad}px"></div>
+			{#each visibleNotes as note, i (note.path)}
+				{@render noteRow(note, startIndex + i)}
+			{/each}
+			<div style="height: {bottomPad}px"></div>
+		{/if}
 	</div>
 </div>
 
@@ -1352,6 +1548,14 @@
 				</svg>
 				Move to...
 			</button>
+			{#if isFiled(contextMenu.note)}
+			<button onclick={() => unfileNote(contextMenu!.note)}>
+				<svg width="12" height="12" 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"/><path d="M9 13h6"/>
+				</svg>
+				Unfile Note
+			</button>
+			{/if}
 			{#if !isMobile}
 			<button onclick={async () => { const n = contextMenu!.note; contextMenu = null; await selectNote(n); setTimeout(() => window.print(), 300); }}>
 				<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
@@ -1401,6 +1605,18 @@
 			Title
 			{#if $sortMode === 'title'}<span class="sort-check">&#10003;</span>{/if}
 		</button>
+		<button class:active={$sortMode === 'custom'} onclick={() => setSortMode('custom')}>
+			<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="8" y1="6" x2="21" y2="6" />
+				<line x1="8" y1="12" x2="21" y2="12" />
+				<line x1="8" y1="18" x2="21" y2="18" />
+				<circle cx="4" cy="6" r="1" />
+				<circle cx="4" cy="12" r="1" />
+				<circle cx="4" cy="18" r="1" />
+			</svg>
+			Custom
+			{#if $sortMode === 'custom'}<span class="sort-check">&#10003;</span>{/if}
+		</button>
 	</div>
 {/if}
 
@@ -1462,17 +1678,19 @@
 		padding: 4px;
 	}
 
-	.list-content::-webkit-scrollbar {
-		width: 8px;
+	.note-list-section {
+		padding: 14px 12px 4px;
+		font-size: 0.7rem;
+		font-weight: 700;
+		letter-spacing: 0.06em;
+		text-transform: uppercase;
+		color: var(--accent);
+		border-bottom: 1px solid var(--border-light);
+		margin-bottom: 2px;
+		user-select: none;
 	}
-
-	.list-content::-webkit-scrollbar-thumb {
-		background: var(--text-tertiary);
-		border-radius: 4px;
-	}
-
-	.list-content::-webkit-scrollbar-thumb:hover {
-		background: var(--text-secondary);
+	.note-list-section:first-child {
+		padding-top: 6px;
 	}
 
 	.note-item {
@@ -1486,6 +1704,7 @@
 		text-align: left;
 		margin-bottom: 1px;
 		contain: content;
+		position: relative;
 	}
 
 	.note-item:hover {
@@ -1532,6 +1751,9 @@
 	}
 
 	.selection-action {
+		display: inline-flex;
+		align-items: center;
+		gap: 4px;
 		background: none;
 		border: 1px solid var(--border-color);
 		color: var(--text-primary);
@@ -1546,6 +1768,37 @@
 		background: var(--bg-hover);
 	}
 
+	.trash-row-actions {
+		position: absolute;
+		right: 6px;
+		top: 50%;
+		transform: translateY(-50%);
+		display: none;
+		gap: 2px;
+	}
+	.note-item:hover .trash-row-actions {
+		display: flex;
+	}
+	.trash-row-btn {
+		cursor: pointer;
+		padding: 4px;
+		border-radius: 4px;
+		color: var(--text-secondary);
+		display: flex;
+		align-items: center;
+	}
+	.trash-row-btn:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+	.trash-row-btn.danger:hover {
+		color: var(--danger);
+		background: color-mix(in srgb, var(--danger) 10%, transparent);
+	}
+	.note-list.mobile .trash-row-actions {
+		display: flex;
+	}
+
 	.selection-action.danger {
 		color: var(--danger);
 		border-color: color-mix(in srgb, var(--danger) 30%, var(--border-color));
@@ -1923,11 +2176,13 @@
 		font-size: 14px;
 	}
 
-	.note-item.qa-drag-above {
+	.note-item.qa-drag-above,
+	.note-item.note-drag-above {
 		border-top: 2px solid var(--accent);
 	}
 
-	.note-item.qa-drag-below {
+	.note-item.qa-drag-below,
+	.note-item.note-drag-below {
 		border-bottom: 2px solid var(--accent);
 	}
 
@@ -1958,6 +2213,11 @@
 		padding: 4px 8px 180px;
 	}
 
+	.note-list.mobile .list-content.tasks-mode {
+		padding-bottom: 0;
+		overflow: hidden;
+	}
+
 	.note-list.mobile .note-item {
 		padding: 14px 16px;
 		min-height: 56px;

src/lib/components/NoteWindow.svelte

@@ -12,10 +12,13 @@
 		theme
 	} from '$lib/stores/app';
 	import { readNote } from '$lib/api';
+	import { keybindings, matchAction } from '$lib/keybindings';
 	import type { FileEvent } from '$lib/types';
 
 	let { notePath }: { notePath: string } = $props();
 
+	import { darkThemes } from '$lib/platform';
+
 	const appWindow = getCurrentWindow();
 	const isMac = navigator.platform.startsWith('Mac');
 	let editor = $state<Editor>(null!);
@@ -35,8 +38,7 @@
 
 	$effect(() => {
 		const t = $theme || 'system';
-		const darkThemes = ['dark', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-dark', 'dracula'];
-		const namedThemes = ['solarized-light', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-light', 'github-dark', 'dracula'];
+		const namedThemes = ['solarized-light', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-light', 'github-dark', 'dracula', 'blueberry', 'forest-green', 'gruvbox', 'midnight-tide', 'cherry-blossom', 'synthwave', 'ember', 'moonlit', 'light-coffee', 'dark-coffee', 'cotton-candy', 'crimson', 'cloud', 'peach', 'material-dark', 'material-light', 'monokai', 'rose-pine', 'everforest', 'horizon', 'cyberpunk', 'black', 'one-dark'];
 		const root = document.documentElement;
 		root.classList.remove('dark');
 		root.removeAttribute('data-theme');
@@ -72,13 +74,11 @@
 	}
 
 	function handleKeydown(e: KeyboardEvent) {
-		const mod = e.ctrlKey || e.metaKey;
-		if (mod && !e.shiftKey && e.code === 'KeyS') {
+		const action = matchAction(e, $keybindings);
+		if (action === 'save') {
 			e.preventDefault();
 			editor?.forceSave();
-			return;
-		}
-		if (mod && e.shiftKey && e.code === 'KeyM') {
+		} else if (action === 'toggle-source') {
 			e.preventDefault();
 			$sourceMode = !$sourceMode;
 		}
@@ -103,8 +103,11 @@
 				if (!$editorDirty) {
 					try {
 						const content = await readNote(notePath);
-						$activeNote = content;
-						editor?.loadNote(notePath, content.content);
+						// Ignore the file-watcher echo of our own save; only reload genuine external edits.
+						if (content.content.trim() !== (editor?.getCurrentBody() ?? '').trim()) {
+							$activeNote = content;
+							editor?.loadNote(notePath, content.content);
+						}
 					} catch (_) {}
 				}
 			}

src/lib/components/SearchPanel.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
-	import { showSearch, activeNote, activeNotePath, editorDirty, appConfig, mobileView } from '$lib/stores/app';
+	import { showSearch, activeNote, activeNotePath, editorDirty, appConfig, mobileView, notebooks, activeNotebook, activeTag, viewMode } from '$lib/stores/app';
 	import { searchNotes, readNote } from '$lib/api';
 	import { debounce } from '$lib/utils/debounce';
-	import type { SearchResult } from '$lib/types';
+	import type { SearchResult, NotebookEntry } from '$lib/types';
+	import { isMobile } from '$lib/platform';
 
 	let query = $state('');
 	let results = $state<SearchResult[]>([]);
@@ -83,7 +84,16 @@
 		return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 	}
 
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
+	function findNotebookByPath(nbs: NotebookEntry[], target: string): NotebookEntry | null {
+		for (const nb of nbs) {
+			if (nb.path === target) return nb;
+			if (nb.children.length) {
+				const found = findNotebookByPath(nb.children, target);
+				if (found) return found;
+			}
+		}
+		return null;
+	}
 
 	async function openResult(result: SearchResult) {
 		try {
@@ -92,6 +102,19 @@
 			$activeNotePath = result.path;
 			$editorDirty = false;
 			$showSearch = false;
+			// Reveal the note in the notes list: switch to its notebook (or All Notes).
+			const sep = result.path.includes('\\') ? '\\' : '/';
+			const parentDir = result.path.slice(0, result.path.lastIndexOf(sep));
+			const nb = parentDir ? findNotebookByPath($notebooks, parentDir) : null;
+			if (nb) {
+				$activeNotebook = nb;
+				$activeTag = null;
+				$viewMode = 'notebook';
+			} else {
+				$activeNotebook = null;
+				$activeTag = null;
+				$viewMode = 'all';
+			}
 			if (isMobile) $mobileView = 'editor';
 		} catch (e) {
 			console.error('Failed to open search result:', e);

src/lib/components/Sidebar.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { tick } from 'svelte';
 	import {
 		notebooks,
 		notes,
@@ -20,26 +21,47 @@
 		notebookSortMode,
 		notebookOrder
 	} from '$lib/stores/app';
-	import { getNotebooks, getAllTags, createNotebook, deleteNotebook, renameNotebook, moveNotebook, getNotebookIcons, setNotebookIcon, saveAttachment, getQuickAccess, addQuickAccess, removeQuickAccess, emptyTrash, moveNote, readNote, getNotes, countRootNotes } from '$lib/api';
+	import { getNotebooks, getAllTags, createNotebook, deleteNotebook, renameNotebook, moveNotebook, getNotebookIcons, setNotebookIcon, saveAttachment, getQuickAccess, addQuickAccess, removeQuickAccess, emptyTrash, moveNote, readNote, 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';
 	import type { NotebookEntry } from '$lib/types';
+	import { isMobile } from '$lib/platform';
 
 	let { onViewChanged = () => {} }: {
 		onViewChanged?: () => void;
 	} = $props();
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
+
+	// Whether any top nav item (All Notes, Quick Access, Tasks, Daily Notes, Trash) is visible.
+	// When all are hidden we drop the empty <nav> and its divider so the tree sits flush.
+	const anyNavItem = $derived(
+		$appConfig?.show_all_notes !== false ||
+		$appConfig?.show_quick_access !== false ||
+		$appConfig?.show_tasks !== false ||
+		$appConfig?.show_daily_notes !== false ||
+		$appConfig?.show_trash !== false
+	);
 
 	let editingNotebook = $state<string | null>(null);
 	let editValue = $state('');
+	let renameInput: HTMLInputElement | null = $state(null);
 	let newNotebookName = $state('');
 	let showNewNotebook = $state(false);
+	let newNotebookInput: HTMLInputElement | null = $state(null);
 	let dropTargetPath = $state<string | null>(null);
 	let dropPosition = $state<'above' | 'into' | 'below' | null>(null);
 	let draggedNotebookPath = $state<string | null>(null);
+	let nbPointer: { src: string } | null = null;
+
+	// Notebook paths arrive from Rust with native separators (backslashes on Windows), so path math must be separator-agnostic.
+	const norm = (p: string) => (p ?? '').replace(/\\/g, '/');
+	const lastSep = (p: string) => Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+	const parentOf = (p: string) => { const i = lastSep(p); return i < 0 ? '' : p.slice(0, i); };
+	const baseOf = (p: string) => p.slice(lastSep(p) + 1);
+	const joinPath = (parent: string, name: string) => parent + (parent.includes('\\') ? '\\' : '/') + name;
+	const isDescendant = (child: string, anc: string) => child.startsWith(anc + '/') || child.startsWith(anc + '\\');
 
 	// Apply manual ordering recursively when in 'manual' sort mode.
 	// In 'alphabetical' mode the Rust scanner already sorts, so we pass through unchanged.
@@ -59,14 +81,30 @@
 	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) {
+	function toggleCollapse(nb: NotebookEntry, e: Event) {
 		e.stopPropagation();
-		if ($collapsedNotebooks.includes(path)) {
-			$collapsedNotebooks = $collapsedNotebooks.filter(p => p !== path);
+		if ($collapsedNotebooks.includes(nb.path)) {
+			$collapsedNotebooks = $collapsedNotebooks.filter(p => p !== nb.path);
 		} else {
-			$collapsedNotebooks = [...$collapsedNotebooks, path];
+			$collapsedNotebooks = [...$collapsedNotebooks, nb.path];
 		}
 	}
+	// Collapse-all / expand-all: toggles every notebook that has children.
+	function collectParentPaths(tree: NotebookEntry[]): string[] {
+		const out: string[] = [];
+		for (const nb of tree) {
+			if (nb.children.length > 0) {
+				out.push(nb.path);
+				out.push(...collectParentPaths(nb.children));
+			}
+		}
+		return out;
+	}
+	const allParentPaths = $derived(collectParentPaths($notebooks));
+	const allCollapsed = $derived(allParentPaths.length > 0 && allParentPaths.every((p) => $collapsedNotebooks.includes(p)));
+	function toggleAllCollapse() {
+		$collapsedNotebooks = allCollapsed ? [] : [...allParentPaths];
+	}
 
 
 	export async function refresh() {
@@ -108,6 +146,10 @@
 		const vault = $appConfig?.active_vault;
 		if (!vault) return;
 		if ($viewMode === 'notebook' && $activeNotebook?.relative_path === '') {
+			if (isMobile) {
+				onViewChanged();
+				return;
+			}
 			selectAllNotes();
 			return;
 		}
@@ -117,9 +159,13 @@
 		onViewChanged();
 	}
 
-	function selectNotebook(nb: NotebookEntry) {
-		// Deselect if clicking the already-active notebook
+	async function selectNotebook(nb: NotebookEntry) {
+		// Deselect if clicking the already-active notebook; expand/collapse is the chevron's job
 		if ($viewMode === 'notebook' && $activeNotebook?.path === nb.path) {
+			if (isMobile) {
+				onViewChanged();
+				return;
+			}
 			selectAllNotes();
 			return;
 		}
@@ -166,11 +212,52 @@
 
 	let newNotebookParent = $state<NotebookEntry | null>(null);
 
+	function getNotebookNameSegments(name: string): string[] | null {
+		const segments = name.split('/').map((segment) => segment.trim());
+		if (segments.some((segment) => !segment || segment === '.' || segment === '..' || segment.includes('\\'))) {
+			return null;
+		}
+		return segments;
+	}
+
+	async function focusNewNotebookInput() {
+		await tick();
+		newNotebookInput?.focus();
+	}
+
+	async function toggleNewNotebookInput() {
+		if (showNewNotebook) {
+			showNewNotebook = false;
+			newNotebookName = '';
+			newNotebookParent = null;
+			return;
+		}
+
+		// Unfiled Notes is the root pseudo-notebook (empty relative_path); treat it as root.
+		newNotebookParent = ($viewMode === 'notebook' && $activeNotebook?.relative_path) ? $activeNotebook : null;
+		showNewNotebook = true;
+		await focusNewNotebookInput();
+	}
+
+	async function startNewNotebookFromSidebar(e: MouseEvent) {
+		const target = e.target as HTMLElement | null;
+		if (target?.closest('button, input, .context-menu, .delete-confirm-overlay')) return;
+
+		newNotebookParent = ($viewMode === 'notebook' && $activeNotebook?.relative_path) ? $activeNotebook : null;
+		newNotebookName = '';
+		showNewNotebook = true;
+		await focusNewNotebookInput();
+	}
+
 	async function handleCreateNotebook() {
 		if (!newNotebookName.trim()) return;
 		try {
+			const trimmedName = newNotebookName.trim();
 			const parentRel = newNotebookParent?.relative_path ?? null;
-			await createNotebook(parentRel, newNotebookName.trim());
+			const name = parentRel ? trimmedName : getNotebookNameSegments(trimmedName)?.join('/');
+			if (!name) return;
+
+			await createNotebook(parentRel, name);
 			newNotebookName = '';
 			showNewNotebook = false;
 			newNotebookParent = null;
@@ -180,7 +267,24 @@
 		}
 	}
 
-	function startNewSubNotebook(nb: NotebookEntry) {
+	function handleNewNotebookKeydown(e: KeyboardEvent) {
+		if (e.key === 'Enter') {
+			handleCreateNotebook();
+			return;
+		}
+		if (e.key === 'Escape') {
+			showNewNotebook = false;
+			newNotebookName = '';
+			newNotebookParent = null;
+			return;
+		}
+		if (e.key === 'Backspace' && newNotebookParent && newNotebookName.length === 0) {
+			e.preventDefault();
+			newNotebookParent = null;
+		}
+	}
+
+	async function startNewSubNotebook(nb: NotebookEntry) {
 		contextMenu = null;
 		newNotebookParent = nb;
 		newNotebookName = '';
@@ -189,6 +293,7 @@
 		if ($collapsedNotebooks.includes(nb.path)) {
 			$collapsedNotebooks = $collapsedNotebooks.filter(p => p !== nb.path);
 		}
+		await focusNewNotebookInput();
 	}
 
 	async function handleRename(nb: NotebookEntry) {
@@ -255,30 +360,34 @@
 
 	async function handleNotebookDrop(e: DragEvent, destPath: string) {
 		e.preventDefault();
-		dropTargetPath = null;
 		const srcPath = e.dataTransfer?.getData('text/plain');
-		if (!srcPath) return;
+		if (srcPath) await nestNotebook(srcPath, destPath);
+	}
+
+	async function nestNotebook(srcPath: string, destPath: string) {
+		dropTargetPath = null;
+		dropPosition = null;
 		draggedNotebookPath = null;
 		// Don't move onto self or descendant
-		if (destPath === srcPath || destPath.startsWith(srcPath + '/')) return;
+		if (destPath === srcPath || isDescendant(destPath, srcPath)) return;
 		// Don't move if already in that parent
-		const parentDir = srcPath.substring(0, srcPath.lastIndexOf('/'));
+		const parentDir = parentOf(srcPath);
 		if (parentDir === destPath) return;
 		try {
-			const oldName = srcPath.split('/').pop() || '';
-			const newBasePath = destPath + '/' + oldName;
+			const oldName = baseOf(srcPath);
+			const newBasePath = joinPath(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);
+				if (isDescendant(p, 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 + '/')) {
+			if ($activeNotebook?.path === srcPath || isDescendant($activeNotebook?.path ?? '', srcPath)) {
 				selectAllNotes();
 			}
-			if ($activeNotePath && $activeNotePath.startsWith(srcPath + '/')) {
+			if ($activeNotePath && isDescendant($activeNotePath, srcPath)) {
 				const newNotePath = newBasePath + $activeNotePath.slice(srcPath.length);
 				$activeNotePath = newNotePath;
 				$activeNote = await readNote(newNotePath);
@@ -290,10 +399,74 @@
 		}
 	}
 
+	function nbStopDragListeners() {
+		window.removeEventListener('pointermove', nbPointerMove);
+		window.removeEventListener('pointerup', nbDragEnd);
+		window.removeEventListener('pointercancel', nbDragEnd);
+		window.removeEventListener('mouseup', nbDragEnd);
+	}
+
+	function nbHandleDown(e: PointerEvent, nb: NotebookEntry) {
+		if (e.pointerType === 'mouse' && e.button !== 0) return;
+		e.stopPropagation();
+		e.preventDefault();
+		nbStopDragListeners();
+		nbPointer = { src: nb.path };
+		draggedNotebookPath = nb.path;
+		// Capture helps touch hold the gesture; on Windows mouse it makes WebView2 swallow the release, so skip it there.
+		if (e.pointerType === 'touch') {
+			try { (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId); } catch {}
+		}
+		window.addEventListener('pointermove', nbPointerMove, { passive: false });
+		window.addEventListener('pointerup', nbDragEnd);
+		window.addEventListener('pointercancel', nbDragEnd);
+		window.addEventListener('mouseup', nbDragEnd);
+	}
+
+	function nbPointerMove(e: PointerEvent) {
+		if (!nbPointer) return;
+		e.preventDefault();
+		const el = document.elementFromPoint(e.clientX, e.clientY) as HTMLElement | null;
+		if (el?.closest('[data-nb-root]')) { dropTargetPath = '__root__'; dropPosition = null; return; }
+		const row = el?.closest('[data-nb-path]') as HTMLElement | null;
+		const path = row?.getAttribute('data-nb-path');
+		if (!path) { dropTargetPath = null; dropPosition = null; return; }
+		const src = nbPointer.src;
+		if (path === src || path.startsWith(src + '/')) { dropTargetPath = null; dropPosition = null; return; }
+		const rect = row!.getBoundingClientRect();
+		const relY = (e.clientY - rect.top) / rect.height;
+		const pos: 'above' | 'into' | 'below' = relY < 0.3 ? 'above' : relY > 0.7 ? 'below' : 'into';
+		if (pos === 'into' && src.substring(0, src.lastIndexOf('/')) === path) { dropTargetPath = null; dropPosition = null; return; }
+		dropTargetPath = path;
+		dropPosition = pos;
+	}
+
+	function nbDragEnd() {
+		if (!nbPointer) return;
+		nbStopDragListeners();
+		const src = nbPointer.src;
+		const target = dropTargetPath;
+		const pos = dropPosition;
+		nbPointer = null;
+		draggedNotebookPath = null;
+		dropTargetPath = null;
+		dropPosition = null;
+		if (!target) return;
+		if (target === '__root__') {
+			const vaultRoot = $appConfig?.active_vault;
+			if (vaultRoot) nestNotebook(src, vaultRoot);
+		} else if (pos === 'above' || pos === 'below') {
+			handleNotebookReorder(src, target, pos);
+		} else if (pos === 'into') {
+			nestNotebook(src, target);
+		}
+	}
+
 	function findSiblingsOfPath(tree: NotebookEntry[], parentPath: string, vaultRoot: string): NotebookEntry[] {
-		if (parentPath === vaultRoot) return tree;
+		const target = norm(parentPath);
+		if (target === norm(vaultRoot)) return tree;
 		for (const nb of tree) {
-			if (nb.path === parentPath) return nb.children;
+			if (norm(nb.path) === target) return nb.children;
 			if (nb.children.length > 0) {
 				const found = findSiblingsOfPath(nb.children, parentPath, vaultRoot);
 				if (found.length > 0) return found;
@@ -307,41 +480,39 @@
 		dropPosition = null;
 		draggedNotebookPath = null;
 		if (srcPath === targetPath) return;
-		if (targetPath.startsWith(srcPath + '/')) return; // can't move into descendant
+		if (isDescendant(targetPath, srcPath)) return; // can't move into descendant
 		const vaultRoot = $appConfig?.active_vault;
 		if (!vaultRoot) return;
 
-		const srcParent = srcPath.substring(0, srcPath.lastIndexOf('/'));
-		const targetParent = targetPath.substring(0, targetPath.lastIndexOf('/'));
+		const srcParent = parentOf(srcPath);
+		const targetParent = parentOf(targetPath);
 		let actualSrcPath = srcPath;
 
 		try {
 			// Step 1: if different parents, move src into target's parent first
 			if (srcParent !== targetParent) {
-				const oldName = srcPath.split('/').pop() || '';
-				const newPath = targetParent === vaultRoot
-					? vaultRoot + '/' + oldName
-					: targetParent + '/' + oldName;
+				const oldName = baseOf(srcPath);
+				const newPath = joinPath(targetParent, oldName);
 				await moveNotebook(srcPath, targetParent);
 				// Migrate paths in collapsedNotebooks
 				$collapsedNotebooks = $collapsedNotebooks.map(p => {
 					if (p === srcPath) return newPath;
-					if (p.startsWith(srcPath + '/')) return newPath + p.slice(srcPath.length);
+					if (isDescendant(p, srcPath)) return newPath + p.slice(srcPath.length);
 					return p;
 				});
 				// Migrate paths in notebookOrder
 				const migrated: Record<string, number> = {};
 				for (const [p, v] of Object.entries($notebookOrder)) {
 					if (p === srcPath) migrated[newPath] = v;
-					else if (p.startsWith(srcPath + '/')) migrated[newPath + p.slice(srcPath.length)] = v;
+					else if (isDescendant(p, srcPath)) migrated[newPath + p.slice(srcPath.length)] = v;
 					else migrated[p] = v;
 				}
 				$notebookOrder = migrated;
 				// Update active notebook/note
-				if ($activeNotebook?.path === srcPath || $activeNotebook?.path.startsWith(srcPath + '/')) {
+				if ($activeNotebook?.path === srcPath || isDescendant($activeNotebook?.path ?? '', srcPath)) {
 					selectAllNotes();
 				}
-				if ($activeNotePath && $activeNotePath.startsWith(srcPath + '/')) {
+				if ($activeNotePath && isDescendant($activeNotePath, srcPath)) {
 					const newNotePath = newPath + $activeNotePath.slice(srcPath.length);
 					$activeNotePath = newNotePath;
 					$activeNote = await readNote(newNotePath);
@@ -378,10 +549,13 @@
 		}
 	}
 
-	function startRename(nb: NotebookEntry) {
+	async function startRename(nb: NotebookEntry) {
 		contextMenu = null;
 		editingNotebook = nb.path;
 		editValue = nb.name;
+		await tick();
+		renameInput?.focus();
+		renameInput?.select();
 	}
 
 	async function handleSetIcon(nb: NotebookEntry) {
@@ -436,6 +610,14 @@
 		contextMenu = { x, y, notebook: nb };
 	}
 
+	function openNotebookMenu(e: Event, nb: NotebookEntry) {
+		e.preventDefault();
+		e.stopPropagation();
+		const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+		const { x, y } = clampMenu(rect.right - 200, rect.bottom + 4, 200, 280);
+		contextMenu = { x, y, notebook: nb };
+	}
+
 	function closeContextMenu() {
 		contextMenu = null;
 	}
@@ -470,7 +652,7 @@
 
 <svelte:window onclick={handleWindowClick} />
 
-<aside class="sidebar" class:collapsed={$sidebarCollapsed} class:mobile={isMobile}>
+<aside class="sidebar" class:collapsed={$sidebarCollapsed} class:mobile={isMobile} class:nav-empty={!anyNavItem}>
 	{#if !isMobile}
 	<div class="sidebar-header">
 		<button class="collapse-btn" onclick={() => ($sidebarCollapsed = !$sidebarCollapsed)} title="Toggle sidebar">
@@ -482,19 +664,19 @@
 				{/if}
 			</svg>
 		</button>
-		{#if !$sidebarCollapsed}
 			<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" />
 				</svg>
 			</button>
-		{/if}
 	</div>
 	{/if}
 
 	{#if !$sidebarCollapsed}
+		{#if anyNavItem}
 		<nav class="sidebar-nav">
+			{#if $appConfig?.show_all_notes !== false}
 			<button
 				class="nav-item"
 				class:active={$viewMode === 'all'}
@@ -506,7 +688,9 @@
 				</svg>
 				<span>All Notes</span>
 			</button>
+			{/if}
 
+			{#if $appConfig?.show_quick_access !== false}
 			<button
 				class="nav-item"
 				class:active={$viewMode === 'quickaccess'}
@@ -517,7 +701,9 @@
 				</svg>
 				<span>Quick Access</span>
 			</button>
+			{/if}
 
+			{#if $appConfig?.show_tasks !== false}
 			<button
 				class="nav-item"
 				class:active={$viewMode === 'tasks'}
@@ -529,7 +715,9 @@
 				</svg>
 				<span>Tasks</span>
 			</button>
+			{/if}
 
+			{#if $appConfig?.show_daily_notes !== false}
 			<button
 				class="nav-item"
 				class:active={$viewMode === 'daily'}
@@ -543,7 +731,9 @@
 				</svg>
 				<span>Daily Notes</span>
 			</button>
+			{/if}
 
+			{#if $appConfig?.show_trash !== false}
 			<button
 				class="nav-item"
 				class:active={$viewMode === 'trash'}
@@ -555,13 +745,17 @@
 				</svg>
 				<span>Trash</span>
 			</button>
+			{/if}
 		</nav>
+		{/if}
 
-		<div class="section">
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<div class="section" ondblclick={startNewNotebookFromSidebar}>
 			<!-- svelte-ignore a11y_no_static_element_interactions -->
 			<div
 				class="section-header"
 				class:drop-target={dropTargetPath === '__root__'}
+				data-nb-root
 				ondragover={(e) => {
 					if (draggedNotebookPath) {
 						e.preventDefault();
@@ -578,19 +772,24 @@
 				}}
 			>
 				<span class="section-title">Notebooks</span>
-				<button class="icon-btn-sm" onclick={() => {
-					if (showNewNotebook) {
-						showNewNotebook = false; newNotebookName = ''; newNotebookParent = null;
-					} else {
-						// Unfiled Notes is the root pseudo-notebook (empty relative_path); treat it as root.
-						newNotebookParent = ($viewMode === 'notebook' && $activeNotebook?.relative_path) ? $activeNotebook : null;
-						showNewNotebook = true;
-					}
-				}} title={$viewMode === 'notebook' && $activeNotebook?.relative_path ? `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>
-				</button>
+				<div class="section-actions">
+					{#if allParentPaths.length > 0}
+						<button class="icon-btn-sm" onclick={(e) => { e.stopPropagation(); toggleAllCollapse(); }} title={allCollapsed ? 'Expand all notebooks' : 'Collapse all notebooks'} aria-label={allCollapsed ? 'Expand all notebooks' : 'Collapse all notebooks'}>
+							<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+								{#if allCollapsed}
+									<path d="m7 15 5 5 5-5" /><path d="m7 9 5-5 5 5" />
+								{:else}
+									<path d="m7 20 5-5 5 5" /><path d="m7 4 5 5 5-5" />
+								{/if}
+							</svg>
+						</button>
+					{/if}
+					<button class="icon-btn-sm" onclick={toggleNewNotebookInput} title={$viewMode === 'notebook' && $activeNotebook?.relative_path ? `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>
+					</button>
+				</div>
 			</div>
 
 			{#if showNewNotebook}
@@ -601,13 +800,11 @@
 						</button>
 					{/if}
 					<input
+						bind:this={newNotebookInput}
 						type="text"
 						bind:value={newNotebookName}
 						placeholder={newNotebookParent ? 'Sub-notebook name...' : 'Notebook name...'}
-						onkeydown={(e) => {
-							if (e.key === 'Enter') handleCreateNotebook();
-							if (e.key === 'Escape') { showNewNotebook = false; newNotebookName = ''; newNotebookParent = null; }
-						}}
+						onkeydown={handleNewNotebookKeydown}
 					/>
 				</div>
 			{/if}
@@ -618,13 +815,14 @@
 						class="notebook-item"
 						class:active={$viewMode === 'notebook' && $activeNotebook?.relative_path === ''}
 						onclick={selectUnfiled}
+						style="padding-left: 4px"
 					>
-						<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>
+					<span style="width:14px;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="M22 12h-6l-2 3h-4l-2-3H2" />
+						<path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" />
+					</svg>
+					<span class="notebook-name">Unfiled Notes <span class="notebook-count">{$rootNoteCount}</span></span>
 					</button>
 				{/if}
 				{#each sortedNotebooks as nb (nb.path)}
@@ -679,6 +877,7 @@
 				{/if}
 			</div>
 		{/if}
+	{/if}
 
 		<div class="sidebar-footer">
 			<button class="icon-btn" onclick={() => ($showInfo = true)} title="Info">
@@ -698,12 +897,14 @@
 
 			</div>
 		</div>
-	{/if}
 </aside>
 
 {#if contextMenu}
+	{#if isMobile}
+		<button type="button" class="context-menu-backdrop" aria-label="Close notebook actions" onclick={closeContextMenu}></button>
+	{/if}
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
-	<div class="context-menu" style="left: {contextMenu.x}px; top: {contextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
+	<div class="context-menu" class:mobile={isMobile} 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
@@ -730,8 +931,11 @@
 {/if}
 
 {#if trashContextMenu}
+	{#if isMobile}
+		<button type="button" class="context-menu-backdrop" aria-label="Close trash actions" onclick={() => trashContextMenu = null}></button>
+	{/if}
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
-	<div class="context-menu" style="left: {trashContextMenu.x}px; top: {trashContextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
+	<div class="context-menu" class:mobile={isMobile} style="left: {trashContextMenu.x}px; top: {trashContextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
 		<button class="danger" onclick={handleEmptyTrash}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 				<polyline points="3 6 5 6 21 6" /><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2" /><line x1="10" y1="11" x2="10" y2="17" /><line x1="14" y1="11" x2="14" y2="17" />
@@ -745,7 +949,7 @@
 	<!-- 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()}>
+		<div class="delete-confirm" class:mobile={isMobile} 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">
@@ -761,10 +965,11 @@
 	{@const isCollapsed = $collapsedNotebooks.includes(nb.path)}
 	{@const iconSrc = getNotebookIconSrc(nb)}
 	{#if editingNotebook === nb.path}
-		<div class="notebook-item" style="padding-left: {8 + depth * 16}px">
+		<div class="notebook-item" style="padding-left: {4 + depth * 16}px">
 			<input
 				type="text"
 				class="rename-input"
+				bind:this={renameInput}
 				bind:value={editValue}
 				onkeydown={(e) => {
 					if (e.key === 'Enter') handleRename(nb);
@@ -774,18 +979,23 @@
 			/>
 		</div>
 	{:else}
+		<div class="notebook-row" data-nb-path={nb.path}>
 		<button
 			class="notebook-item"
 			class:active={$viewMode === 'notebook' && $activeNotebook?.path === nb.path}
 			class:drop-target={dropTargetPath === nb.path && dropPosition === 'into'}
 			class:drop-above={dropTargetPath === nb.path && dropPosition === 'above'}
 			class:drop-below={dropTargetPath === nb.path && dropPosition === 'below'}
-			style="padding-left: {8 + depth * 16}px"
-			draggable="true"
+			style="padding-left: {4 + depth * 16}px"
+			data-nb-path={nb.path}
 			onclick={() => selectNotebook(nb)}
+			onkeydown={(e) => {
+				if (e.key === 'F2') {
+					e.preventDefault();
+					startRename(nb);
+				}
+			}}
 			oncontextmenu={(e) => onContextMenu(e, nb)}
-			ondragstart={(e) => { draggedNotebookPath = nb.path; e.dataTransfer!.setData('text/plain', nb.path); e.dataTransfer!.effectAllowed = 'move'; }}
-			ondragend={() => { draggedNotebookPath = null; dropPosition = null; }}
 			ondragover={(e) => {
 				e.preventDefault();
 				if (draggedNotebookPath) {
@@ -814,8 +1024,14 @@
 			ondragleave={() => { if (dropTargetPath === nb.path) { dropTargetPath = null; dropPosition = null; } }}
 			ondrop={(e) => {
 				e.preventDefault();
-				const pos = dropPosition;
 				if (draggedNotebookPath) {
+					// Recompute the drop position from the drop coordinates, not the dragover-set
+					// state: dragleave over the row's child nodes (chevron/icon/label) clears
+					// dropPosition before drop (esp. Windows WebView2), which mis-routed every drop
+					// to "nest" and broke reorder + un-nest. (issue #97)
+					const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+					const relY = (e.clientY - rect.top) / rect.height;
+					const pos = relY < 0.3 ? 'above' : relY > 0.7 ? 'below' : 'into';
 					if (pos === 'above' || pos === 'below') {
 						handleNotebookReorder(draggedNotebookPath, nb.path, pos);
 					} else {
@@ -828,7 +1044,7 @@
 		>
 			{#if hasChildren}
 				<!-- svelte-ignore a11y_no_static_element_interactions -->
-				<span class="chevron" class:collapsed={isCollapsed} onclick={(e) => toggleCollapse(nb.path, e)} onkeydown={(e) => { if (e.key === 'Enter') toggleCollapse(nb.path, e); }}>
+				<span class="chevron" class:collapsed={isCollapsed} onclick={(e) => toggleCollapse(nb, e)} onkeydown={(e) => { if (e.key === 'Enter') toggleCollapse(nb, e); }}>
 					<svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 						<polyline points="6 9 12 15 18 9" />
 					</svg>
@@ -836,15 +1052,44 @@
 			{:else}
 				<span class="chevron-spacer"></span>
 			{/if}
-			{#if iconSrc}
-				<img class="notebook-icon" src={iconSrc} alt="" />
-			{:else}
-				<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" opacity="0.6">
-					<path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z" />
-				</svg>
-			{/if}
+		{#if iconSrc}
+			<img class="notebook-icon" src={iconSrc} alt="" />
+		{:else if isCollapsed || nb.children.length === 0}
+			<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="opacity:0.6;flex-shrink:0">
+				<path d="M2 6h4"/><path d="M2 10h4"/><path d="M2 14h4"/><path d="M2 18h4"/>
+				<path d="M6 2h12a2 2 0 012 2v16a2 2 0 01-2 2H6a2 2 0 01-2-2V4a2 2 0 012-2z"/>
+			</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" style="opacity:0.6;flex-shrink:0">
+				<path d="M2 6h4"/><path d="M2 10h4"/><path d="M2 14h4"/><path d="M2 18h4"/>
+				<path d="M6 2h12a2 2 0 012 2v16a2 2 0 01-2 2H6a2 2 0 01-2-2V4a2 2 0 012-2z"/>
+				<path d="M10 9h8"/><path d="M10 13h8"/><path d="M10 17h5"/>
+			</svg>
+		{/if}
 			<span class="notebook-name">{nb.name} <span class="notebook-count">{nb.note_count}</span></span>
+			{#if $notebookSortMode === 'manual'}
+				<!-- svelte-ignore a11y_no_static_element_interactions a11y_click_events_have_key_events -->
+				<span
+					class="nb-drag-handle"
+					title="Drag to reorder"
+					onpointerdown={(e) => nbHandleDown(e, nb)}
+					onclick={(e) => e.stopPropagation()}
+				>
+					<svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor"><circle cx="9" cy="5" r="1.6"/><circle cx="15" cy="5" r="1.6"/><circle cx="9" cy="12" r="1.6"/><circle cx="15" cy="12" r="1.6"/><circle cx="9" cy="19" r="1.6"/><circle cx="15" cy="19" r="1.6"/></svg>
+				</span>
+			{/if}
 		</button>
+		{#if isMobile}
+			<button
+				type="button"
+				class="notebook-actions-btn"
+				aria-label={`Actions for ${nb.name}`}
+				onclick={(e) => openNotebookMenu(e, nb)}
+			>
+				<svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="5" cy="12" r="1.8"/><circle cx="12" cy="12" r="1.8"/><circle cx="19" cy="12" r="1.8"/></svg>
+			</button>
+		{/if}
+		</div>
 	{/if}
 	{#if hasChildren && !isCollapsed}
 		{#each nb.children as child (child.path)}
@@ -871,6 +1116,29 @@
 		max-width: 44px;
 	}
 
+	/* Collapsed rail: stack the toolbar icons vertically - search under the expand chevron at
+	   the top, info + settings pinned to the bottom. */
+	.sidebar.collapsed .sidebar-header {
+		flex-direction: column;
+		justify-content: flex-start;
+		gap: 4px;
+		padding: 8px 4px;
+		border-bottom: none;
+	}
+
+	.sidebar.collapsed .sidebar-footer {
+		flex-direction: column;
+		align-items: center;
+		gap: 4px;
+		margin-top: auto;
+		padding: 8px 4px;
+		border-top: none;
+	}
+
+	.sidebar.collapsed .sidebar-footer-right {
+		flex-direction: column;
+	}
+
 	.sidebar-header {
 		display: flex;
 		align-items: center;
@@ -913,7 +1181,23 @@
 	.section {
 		flex: 1;
 		overflow-y: auto;
-		padding: 4px 0;
+		padding: 0 0 4px;
+		border-top: 1px solid var(--border-light);
+	}
+
+	/* With the top nav hidden, the header's border-bottom is the only divider needed -
+	   drop the section's border-top so there's no doubled line under the header. */
+	.sidebar.nav-empty .section {
+		border-top: none;
+	}
+
+	/* Pin the Notebooks header so its collapse/expand-all button stays reachable while the tree
+	   scrolls; the section's border-top draws the divider above it, matching the Tags section. (issue #126) */
+	.section > .section-header {
+		position: sticky;
+		top: 0;
+		z-index: 1;
+		background: var(--bg-secondary);
 	}
 
 	.tags-section {
@@ -946,6 +1230,11 @@
 		color: var(--text-tertiary);
 	}
 
+	.section-actions {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+	}
 	.icon-btn, .icon-btn-sm {
 		background: none;
 		border: none;
@@ -1043,12 +1332,16 @@
 		padding: 0 2px;
 	}
 
+	.notebook-row {
+		position: relative;
+	}
+
 	.notebook-item {
 		display: flex;
 		align-items: center;
 		gap: 6px;
 		width: 100%;
-		padding: 5px 8px;
+		padding: 5px 8px 5px 4px;
 		border: none;
 		background: none;
 		border-radius: 6px;
@@ -1129,6 +1422,49 @@
 		margin-left: 2px;
 	}
 
+	.nb-drag-handle {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex: 0 0 auto;
+		padding: 2px;
+		margin-left: 2px;
+		color: var(--text-tertiary);
+		opacity: 0.45;
+		cursor: grab;
+		touch-action: none;
+	}
+
+	.nb-drag-handle:hover {
+		opacity: 1;
+	}
+
+	.nb-drag-handle:active {
+		cursor: grabbing;
+	}
+
+	.notebook-actions-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		position: absolute;
+		right: 4px;
+		top: 50%;
+		transform: translateY(-50%);
+		width: 44px;
+		height: 44px;
+		padding: 0;
+		border: none;
+		border-radius: 8px;
+		background: none;
+		color: var(--text-tertiary);
+	}
+
+	.notebook-actions-btn:active {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
 	.tag-list {
 		padding: 0 4px;
 	}
@@ -1197,6 +1533,15 @@
 		min-width: 140px;
 	}
 
+	.context-menu-backdrop {
+		position: fixed;
+		inset: 0;
+		z-index: 999;
+		padding: 0;
+		border: none;
+		background: rgba(0, 0, 0, 0.18);
+	}
+
 	.context-menu button {
 		display: flex;
 		align-items: center;
@@ -1351,7 +1696,7 @@
 	}
 
 	.sidebar.mobile .notebook-item {
-		padding: 12px 12px;
+		padding: 2px 56px 2px 12px;
 		min-height: 48px;
 		gap: 10px;
 		font-size: 15px;
@@ -1392,34 +1737,40 @@
 		display: none;
 	}
 
-	.sidebar.mobile .context-menu {
-		min-width: 200px;
+	.context-menu.mobile {
+		left: calc(12px + env(safe-area-inset-left, 0px)) !important;
+		right: calc(12px + env(safe-area-inset-right, 0px));
+		top: auto !important;
+		bottom: calc(12px + env(safe-area-inset-bottom, 0px));
+		min-width: 0;
+		max-height: calc(100dvh - 24px - env(safe-area-inset-top, 0px) - env(safe-area-inset-bottom, 0px));
+		overflow-y: auto;
 		border-radius: 12px;
 		padding: 6px;
 	}
 
-	.sidebar.mobile .context-menu button {
+	.context-menu.mobile button {
 		padding: 12px 16px;
 		font-size: 15px;
 		min-height: 44px;
 		border-radius: 8px;
 	}
 
-	.sidebar.mobile .delete-confirm {
+	.delete-confirm.mobile {
 		max-width: calc(100vw - 40px);
 		padding: 24px;
 	}
 
-	.sidebar.mobile .delete-confirm h4 {
+	.delete-confirm.mobile h4 {
 		font-size: 16px;
 	}
 
-	.sidebar.mobile .delete-confirm p {
+	.delete-confirm.mobile p {
 		font-size: 14px;
 	}
 
-	.sidebar.mobile .delete-confirm-cancel,
-	.sidebar.mobile .delete-confirm-btn {
+	.delete-confirm.mobile .delete-confirm-cancel,
+	.delete-confirm.mobile .delete-confirm-btn {
 		padding: 10px 20px;
 		font-size: 14px;
 		min-height: 44px;

src/lib/components/TagSuggestInput.svelte

@@ -16,11 +16,10 @@
 	// Existing tags that match what's typed, prefix matches first, already-applied ones excluded.
 	const suggestions = $derived.by(() => {
 		const q = query.trim().toLowerCase();
-		if (!q) return [];
 		const taken = new Set(existing);
 		const names = $tags
 			.map(([name]) => name)
-			.filter((name) => !taken.has(name) && name.toLowerCase().includes(q));
+			.filter((name) => !taken.has(name) && (!q || name.toLowerCase().includes(q)));
 		names.sort((a, b) => {
 			const ap = a.toLowerCase().startsWith(q) ? 0 : 1;
 			const bp = b.toLowerCase().startsWith(q) ? 0 : 1;

src/lib/components/TasksView.svelte

@@ -3,7 +3,7 @@
 	import { listen } from '@tauri-apps/api/event';
 	import { getTasks } from '$lib/api';
 	import { debounce } from '$lib/utils/debounce';
-	import { tasksLayout, appConfig } from '$lib/stores/app';
+	import { tasksLayout, tasksHideCompleted, tasksOnlyFlagged, tasksSort, appConfig } from '$lib/stores/app';
 	import { isAndroid } from '$lib/platform';
 	import type { TaskItem, FileEvent } from '$lib/types';
 
@@ -16,8 +16,7 @@
 
 	let tasks = $state<TaskItem[]>([]);
 	let loading = $state(true);
-	let hideCompleted = $state(true);
-	let sortBy = $state<'due' | 'priority' | 'note'>('due');
+	let taskQuery = $state('');
 	let unlisten: (() => void) | null = null;
 
 	async function load() {
@@ -43,16 +42,24 @@
 
 	const prioRank: Record<string, number> = { high: 0, med: 1, low: 2 };
 	function prank(p: string | null) { return p ? (prioRank[p] ?? 3) : 3; }
+	// Free-text task filter: matches the task text or its note title (case-insensitive).
+	function matchesQuery(t: TaskItem): boolean {
+		const q = taskQuery.trim().toLowerCase();
+		if (!q) return true;
+		return t.text.toLowerCase().includes(q) || t.note_title.toLowerCase().includes(q);
+	}
 
 	const filtered = $derived.by(() => {
 		let list = tasks.slice();
-		if (hideCompleted) list = list.filter((t) => !t.completed);
+		if ($tasksHideCompleted) list = list.filter((t) => !t.completed);
+		if ($tasksOnlyFlagged) list = list.filter((t) => !!t.due || !!t.priority);
+		list = list.filter(matchesQuery);
 		list.sort((a, b) => {
 			if (a.completed !== b.completed) return a.completed ? 1 : -1; // done last
-			if (sortBy === 'priority') {
+			if ($tasksSort === 'priority') {
 				const d = prank(a.priority) - prank(b.priority);
 				if (d) return d;
-			} else if (sortBy === 'note') {
+			} else if ($tasksSort === 'note') {
 				const d = a.note_title.localeCompare(b.note_title);
 				if (d) return d;
 			} else {
@@ -110,7 +117,7 @@
 	const calDayNames = $derived([...DOW.slice(weekStartsOn), ...DOW.slice(0, weekStartsOn)]);
 
 	// Calendar tasks share the list's hide-completed filter (no sort).
-	const calBase = $derived(tasks.filter((t) => !hideCompleted || !t.completed));
+	const calBase = $derived(tasks.filter((t) => (!$tasksHideCompleted || !t.completed) && (!$tasksOnlyFlagged || !!t.due || !!t.priority) && matchesQuery(t)));
 
 	const tasksByDate = $derived.by(() => {
 		const m = new Map<string, TaskItem[]>();
@@ -186,7 +193,9 @@
 		<button class="prio-backdrop" onclick={() => { prioMenuFor = null; dueMenuFor = null; }} aria-label="Close menu"></button>
 	{/if}
 	<div class="tasks-controls">
-		<button class="tasks-ctl" class:active={hideCompleted} onclick={() => (hideCompleted = !hideCompleted)} title="Hide completed tasks">Hide done</button>
+		<input class="tasks-filter" type="text" placeholder="Filter tasks…" bind:value={taskQuery} onkeydown={(e) => { if (e.key === 'Escape') taskQuery = ''; }} aria-label="Filter tasks by text" />
+		<button class="tasks-ctl" class:active={$tasksHideCompleted} onclick={() => ($tasksHideCompleted = !$tasksHideCompleted)} title="Hide completed tasks">Hide done</button>
+		<button class="tasks-ctl" class:active={$tasksOnlyFlagged} onclick={() => ($tasksOnlyFlagged = !$tasksOnlyFlagged)} title="Only show tasks with a due date or priority">Flagged</button>
 		{#if !isAndroid}
 			<div class="tasks-layout">
 				<button class="tasks-ctl" class:active={viewLayout === 'list'} onclick={() => ($tasksLayout = 'list')} title="List view">List</button>
@@ -196,7 +205,7 @@
 		{#if viewLayout === 'list'}
 			<div class="tasks-sort">
 				{#each [['due', 'Due'], ['priority', 'Priority'], ['note', 'Note']] as [v, label]}
-					<button class="tasks-ctl" class:active={sortBy === v} onclick={() => (sortBy = v as 'due' | 'priority' | 'note')}>{label}</button>
+					<button class="tasks-ctl" class:active={$tasksSort === v} onclick={() => ($tasksSort = v as 'due' | 'priority' | 'note')}>{label}</button>
 				{/each}
 			</div>
 		{/if}
@@ -366,6 +375,17 @@
 		color: #fff;
 		border-color: var(--accent);
 	}
+	.tasks-filter {
+		width: 150px;
+		padding: 3px 8px;
+		border: 1px solid var(--border-color);
+		border-radius: 5px;
+		background: var(--bg-secondary);
+		color: var(--text-primary);
+		font-size: 12px;
+	}
+	.tasks-filter::placeholder { color: var(--text-tertiary); }
+	.tasks-filter:focus { outline: none; border-color: var(--accent); }
 	.tasks-list {
 		flex: 1;
 		overflow-y: auto;
@@ -458,7 +478,7 @@
 		background: transparent;
 		color: var(--text-tertiary);
 		border: 1px dashed var(--border-color);
-		opacity: 0;
+		opacity: 0.4;
 		transition: opacity 0.1s;
 	}
 	.task-row:hover .task-prio.prio-none { opacity: 1; }
@@ -529,7 +549,7 @@
 		background: transparent;
 		border-style: dashed;
 		color: var(--text-tertiary);
-		opacity: 0;
+		opacity: 0.4;
 		transition: opacity 0.1s;
 	}
 	.task-row:hover .task-due:not(.set) { opacity: 1; }

src/lib/components/TitleBar.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { getCurrentWindow } from '@tauri-apps/api/window';
-	import { vaultReady, focusMode, readOnly, updateAvailable, showSettings, settingsTab, appConfig, syncState } from '$lib/stores/app';
+	import { vaultReady, focusMode, readOnly, updateAvailable, showSettings, settingsTab, appConfig, activeVaultConfig, syncState } from '$lib/stores/app';
 	import { syncNow } from '$lib/api';
 
 	let { onNewNote = () => {}, onDailyNote = () => {} }: {
@@ -112,7 +112,7 @@
 				<line x1="3" y1="10" x2="21" y2="10" />
 			</svg>
 		</button>
-		{#if $appConfig?.sync_provider === 'webdav'}
+		{#if activeVaultConfig($appConfig)?.sync_provider === 'webdav'}
 		<button class="switch-vault-btn" class:active={$syncState.running} onclick={() => { if (!$syncState.running) syncNow().catch(() => {}); }} disabled={$syncState.running} title={$syncState.error ? `Sync error: ${$syncState.error}` : ($syncState.running ? 'Syncing vault...' : 'Sync vault now')}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class:sync-spin={$syncState.running}>
 				<path d="M21 2v6h-6"/><path d="M3 12a9 9 0 0115-6.7L21 8"/><path d="M3 22v-6h6"/><path d="M21 12a9 9 0 01-15 6.7L3 16"/>

src/lib/components/VaultPicker.svelte

@@ -2,11 +2,13 @@
 	import { open } from '@tauri-apps/plugin-dialog';
 	import { getCurrentWindow } from '@tauri-apps/api/window';
 	import { documentDir } from '@tauri-apps/api/path';
-	import { openVault, getAppConfig } from '$lib/api';
+	import { chooseExternalVault, getAppConfig, openVault, removeVault, restoreExternalVault } from '$lib/api';
 	import { appConfig, vaultReady } from '$lib/stores/app';
 	import { isAndroid, isIOS, isMobile } from '$lib/platform';
 	import type { VaultConfig } from '$lib/types';
 
+	let { initialError = '' }: { initialError?: string } = $props();
+
 	const appWindow = getCurrentWindow();
 
 	let recentVaults: VaultConfig[] = $derived($appConfig?.vaults ?? []);
@@ -15,6 +17,10 @@
 	let vaultName = $state('HelixNotes');
 	let hasPermission = $state(!isAndroid);
 	let selectedLocation = $state('Documents');
+
+	$effect(() => {
+		if (initialError && !error) error = initialError;
+	});
 	let customPath = $state('');
 	let iosBasePath = $state('');
 
@@ -107,6 +113,64 @@
 			loading = false;
 		}
 	}
+
+	async function pickExternalFolder() {
+		loading = true;
+		error = '';
+		try {
+			const selected = await chooseExternalVault();
+			if (!selected) return;
+			$appConfig = await getAppConfig();
+			$vaultReady = true;
+		} catch (e) {
+			error = String(e);
+		} finally {
+			loading = false;
+		}
+	}
+
+	async function openRecentVault(vault: VaultConfig) {
+		if (loading) return;
+		if (!isIOS || !vault.bookmark_id) {
+			await openSelectedVault(vault.path);
+			return;
+		}
+
+		loading = true;
+		error = '';
+		try {
+			await restoreExternalVault(vault.bookmark_id);
+			$appConfig = await getAppConfig();
+			$vaultReady = true;
+		} catch (e) {
+			error = String(e);
+		} finally {
+			loading = false;
+		}
+	}
+
+	async function forgetVault(vault: VaultConfig) {
+		if (loading) return;
+		loading = true;
+		error = '';
+		try {
+			const wasActive = isActiveVault(vault);
+			await removeVault(vault.path, vault.bookmark_id);
+			$appConfig = await getAppConfig();
+			if (wasActive) $vaultReady = false;
+		} catch (e) {
+			error = String(e);
+		} finally {
+			loading = false;
+		}
+	}
+
+	function isActiveVault(vault: VaultConfig): boolean {
+		if (vault.bookmark_id) {
+			return vault.bookmark_id === $appConfig?.active_bookmark_id;
+		}
+		return !$appConfig?.active_bookmark_id && vault.path === $appConfig?.active_vault;
+	}
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
@@ -137,7 +201,7 @@
 		<p class="subtitle">Local markdown notes</p>
 		{#if isMobile}
 			{#if isIOS}
-				<p class="description">Your notes are saved in the app's folder and appear in the Files app under "On My iPhone &rarr; HelixNotes".</p>
+				<p class="description">Keep notes in HelixNotes, or use an existing folder from iCloud Drive or Files.</p>
 			{:else}
 				<p class="description">Choose where to store your notes. Sync with Syncthing, Nextcloud, or any file sync app.</p>
 			{/if}
@@ -188,6 +252,8 @@
 		<button class="btn-primary" onclick={pickFolder} disabled={loading}>
 			{#if loading}
 				Opening...
+			{:else if isIOS}
+				Use Local Folder
 			{:else if isMobile}
 				Get Started
 			{:else}
@@ -195,6 +261,12 @@
 			{/if}
 		</button>
 
+		{#if isIOS}
+			<button class="btn-back" onclick={pickExternalFolder} disabled={loading}>
+				Choose Folder in Files
+			</button>
+		{/if}
+
 		{#if $appConfig?.active_vault}
 			<button class="btn-back" onclick={() => ($vaultReady = true)}>
 				Back
@@ -205,10 +277,18 @@
 			<div class="recent">
 				<span class="recent-label">Recent</span>
 				{#each recentVaults as vault}
-					<button class="vault-item" onclick={() => openSelectedVault(vault.path)}>
-						<span class="vault-name">{vault.name}</span>
-						<span class="vault-path">{vault.path}</span>
-					</button>
+					<div class="vault-row">
+						<button class="vault-item" class:current={isActiveVault(vault)} onclick={() => openRecentVault(vault)} disabled={loading}>
+							<span class="vault-name">{vault.name}{#if isActiveVault(vault)}<span class="vault-current-badge">Current</span>{/if}</span>
+							<span class="vault-path">{vault.bookmark_id ? `Files · ${vault.path}` : vault.path}</span>
+						</button>
+						<button class="vault-remove" title="Remove from list" aria-label="Remove from list" onclick={() => forgetVault(vault)} disabled={loading}>
+							<svg width="12" height="12" viewBox="0 0 10 10">
+								<line x1="1.5" y1="1.5" x2="8.5" y2="8.5" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" />
+								<line x1="8.5" y1="1.5" x2="1.5" y2="8.5" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" />
+							</svg>
+						</button>
+					</div>
 				{/each}
 			</div>
 		{/if}
@@ -372,6 +452,24 @@
 		background: var(--bg-hover);
 	}
 
+	.vault-item.current {
+		border-color: var(--accent);
+	}
+
+	.vault-current-badge {
+		display: inline-block;
+		font-size: 10px;
+		font-weight: 600;
+		text-transform: uppercase;
+		letter-spacing: 0.04em;
+		color: var(--accent);
+		background: color-mix(in srgb, var(--accent) 12%, transparent);
+		padding: 2px 7px;
+		border-radius: 10px;
+		margin-left: 8px;
+		vertical-align: middle;
+	}
+
 	.vault-name {
 		display: block;
 		font-weight: 500;
@@ -389,6 +487,48 @@
 		white-space: nowrap;
 	}
 
+	.vault-row {
+		display: flex;
+		align-items: stretch;
+		gap: 6px;
+		margin-bottom: 6px;
+	}
+
+	.vault-row .vault-item {
+		flex: 1;
+		min-width: 0;
+		margin-bottom: 0;
+	}
+
+	.vault-remove {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex-shrink: 0;
+		width: 36px;
+		background: var(--bg-secondary);
+		border: 1px solid var(--border-color);
+		border-radius: 8px;
+		color: var(--text-tertiary);
+		cursor: pointer;
+		opacity: 0;
+		transition: opacity 0.15s, background 0.15s, color 0.15s;
+	}
+
+	.vault-row:hover .vault-remove,
+	.vault-remove:focus-visible {
+		opacity: 1;
+	}
+
+	.vault-remove:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
+	.vault-picker.mobile .vault-remove {
+		opacity: 1;
+	}
+
 	.vault-name-input {
 		margin-bottom: 20px;
 		text-align: left;

src/lib/editor/callouts.ts

@@ -0,0 +1,171 @@
+// Obsidian-compatible callouts.
+//
+// Callouts are written as blockquotes whose first line is `[!type]`:
+//
+//     > [!warning] Optional title
+//     > Body markdown...
+//
+// A trailing `+` / `-` on the type makes the callout foldable
+// (`+` = expanded, `-` = collapsed). Types are case-insensitive and have
+// aliases. Callouts round-trip to this exact syntax so notes stay portable
+// (no lock-in) and stay compatible with Obsidian.
+
+// alias (lowercase) -> canonical group used for icon + colour
+const ALIASES: Record<string, string> = {
+	note: 'note',
+	abstract: 'abstract', summary: 'abstract', tldr: 'abstract',
+	info: 'info',
+	todo: 'todo',
+	tip: 'tip', hint: 'tip', important: 'tip',
+	success: 'success', check: 'success', done: 'success',
+	question: 'question', help: 'question', faq: 'question',
+	warning: 'warning', caution: 'warning', attention: 'warning',
+	failure: 'failure', fail: 'failure', missing: 'failure',
+	danger: 'danger', error: 'danger',
+	bug: 'bug',
+	example: 'example',
+	quote: 'quote', cite: 'quote',
+};
+
+/**
+ * Resolve a (possibly aliased / cased) type to its canonical styling group.
+ * Unknown / user-defined types resolve to 'custom' (neutral accent + tag icon)
+ * so a `[!decision]` reads as intentional rather than masquerading as a note.
+ */
+export function calloutGroup(type: string): string {
+	return ALIASES[(type || '').trim().toLowerCase()] || 'custom';
+}
+
+/** Default header label shown when no custom title is set (matches Obsidian). */
+export function calloutLabel(type: string): string {
+	const t = (type || 'note').trim();
+	return t ? t.charAt(0).toUpperCase() + t.slice(1) : 'Note';
+}
+
+// Inner SVG markup per canonical group (24x24, stroke = currentColor).
+const ICONS: Record<string, string> = {
+	note: '<path d="M12 20h9"/><path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4Z"/>',
+	abstract: '<rect x="8" y="2" width="8" height="4" rx="1"/><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/><path d="M9 12h6"/><path d="M9 16h6"/>',
+	info: '<circle cx="12" cy="12" r="10"/><line x1="12" y1="11" x2="12" y2="16"/><line x1="12" y1="8" x2="12.01" y2="8"/>',
+	todo: '<circle cx="12" cy="12" r="10"/><path d="m9 12 2 2 4-4"/>',
+	tip: '<path d="M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.07-2.14-.22-4.05 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.15.43-2.29 1-3a2.5 2.5 0 0 0 2.5 2.5Z"/>',
+	success: '<polyline points="20 6 9 17 4 12"/>',
+	question: '<circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><line x1="12" y1="17" x2="12.01" y2="17"/>',
+	warning: '<path d="m21.73 18-8-14a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/>',
+	failure: '<circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/>',
+	danger: '<polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>',
+	bug: '<rect x="8" y="6" width="8" height="14" rx="4"/><path d="m19 8-3 2"/><path d="m5 8 3 2"/><path d="m19 16-3-2"/><path d="m5 16 3-2"/><path d="M21 13h-5"/><path d="M3 13h5"/><path d="m15 4-1.5 2.5"/><path d="m9 4 1.5 2.5"/>',
+	example: '<line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/>',
+	quote: '<path d="M3 21c3 0 7-1 7-8V5c0-1.25-.76-2.02-2-2H4c-1.25 0-2 .75-2 1.97V11c0 1.25.75 2 2 2 1 0 1 0 1 1v1c0 1-1 2-2 2s-1 0-1 1.03V20c0 1 0 1 1 1z"/><path d="M15 21c3 0 7-1 7-8V5c0-1.25-.76-2.02-2-2h-4c-1.25 0-2 .75-2 1.97V11c0 1.25.75 2 2 2h.75c0 2.25.25 4-2.75 4v3c0 1 0 1 1 1z"/>',
+	custom: '<path d="M20.59 13.41 13.42 20.58a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z"/><line x1="7" y1="7" x2="7.01" y2="7"/>',
+};
+
+/** Full SVG icon string for a callout type, at the given pixel size. */
+export function calloutIcon(type: string, size = 18): string {
+	const inner = ICONS[calloutGroup(type)] || ICONS.note;
+	return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${inner}</svg>`;
+}
+
+/** Ordered list of types offered in the type picker. */
+export const CALLOUT_MENU: { type: string; label: string }[] = [
+	{ type: 'note', label: 'Note' },
+	{ type: 'abstract', label: 'Abstract' },
+	{ type: 'info', label: 'Info' },
+	{ type: 'todo', label: 'Todo' },
+	{ type: 'tip', label: 'Tip' },
+	{ type: 'success', label: 'Success' },
+	{ type: 'question', label: 'Question' },
+	{ type: 'warning', label: 'Warning' },
+	{ type: 'failure', label: 'Failure' },
+	{ type: 'danger', label: 'Danger' },
+	{ type: 'bug', label: 'Bug' },
+	{ type: 'example', label: 'Example' },
+	{ type: 'quote', label: 'Quote' },
+];
+
+// First line of a callout: [!type], optional +/- fold marker, optional title.
+const CALLOUT_RE = /^\s*\[!([\w-]+)\]([-+]?)[ \t]*(.*)$/;
+
+const BLOCK_SELECTOR =
+	'p,ul,ol,blockquote,pre,h1,h2,h3,h4,h5,h6,table,hr,div[data-callout],div[data-secret-block],div[data-math-block],div[data-pdf-src],div[data-page-break]';
+
+/**
+ * Convert callout blockquotes produced by markdown-it into
+ * `<div data-callout=...>` blocks that the Callout node parses. Operates in
+ * place on a detached container element. Processes depth-first so nested
+ * callouts (`> > [!todo]`) are converted before their parents.
+ */
+export function transformCalloutBlockquotes(root: Element): void {
+	const walk = (el: Element) => {
+		for (const child of Array.from(el.children)) walk(child);
+		if (el.tagName === 'BLOCKQUOTE') convertBlockquote(el);
+	};
+	walk(root);
+}
+
+function convertBlockquote(bq: Element): void {
+	const first = bq.firstElementChild;
+	if (!first || first.tagName !== 'P') return;
+
+	// markdown-it merges the title line and any immediately-following body lines
+	// into one paragraph (separated by "\n"). Split off the first line.
+	const innerHtml = (first as HTMLElement).innerHTML;
+	const nlIdx = innerHtml.indexOf('\n');
+	const firstLineHtml = nlIdx === -1 ? innerHtml : innerHtml.slice(0, nlIdx);
+	const restHtml = nlIdx === -1 ? '' : innerHtml.slice(nlIdx + 1);
+
+	const probe = document.createElement('div');
+	probe.innerHTML = firstLineHtml;
+	const m = (probe.textContent || '').match(CALLOUT_RE);
+	if (!m) return;
+
+	const type = m[1].toLowerCase();
+	const foldChar = m[2];
+	const title = (m[3] || '').trim();
+	const foldable = foldChar === '+' || foldChar === '-';
+	const folded = foldChar === '-';
+
+	const div = document.createElement('div');
+	div.setAttribute('data-callout', type);
+	div.setAttribute('data-callout-foldable', foldable ? 'true' : 'false');
+	div.setAttribute('data-callout-folded', folded ? 'true' : 'false');
+	if (title) div.setAttribute('data-callout-title', title);
+
+	if (restHtml.trim()) {
+		(first as HTMLElement).innerHTML = restHtml;
+		div.appendChild(first);
+	} else {
+		first.remove();
+	}
+	while (bq.firstChild) div.appendChild(bq.firstChild);
+
+	// content is `block+`; guarantee at least one block.
+	if (!div.querySelector(BLOCK_SELECTOR)) div.appendChild(document.createElement('p'));
+
+	bq.replaceWith(div);
+}
+
+/**
+ * Serialize a Callout ProseMirror node back to `> [!type] ...` markdown.
+ * `serializeChild` serializes a child block (the editor's own serializer),
+ * which makes nesting fall out automatically (each `>` line gains another `>`).
+ */
+export function serializeCallout(node: any, serializeChild: (child: any) => string): string {
+	const type = node.attrs.type || 'note';
+	const foldable = !!node.attrs.foldable;
+	const folded = !!node.attrs.folded;
+	const title = (node.attrs.title || '').trim();
+	const suffix = foldable ? (folded ? '-' : '+') : '';
+	const header = `[!${type}]${suffix}${title ? ' ' + title : ''}`;
+
+	const parts: string[] = [];
+	node.forEach((child: any) => parts.push(serializeChild(child).replace(/\n+$/, '')));
+	while (parts.length && parts[parts.length - 1] === '') parts.pop();
+
+	const out = [`> ${header}`];
+	const inner = parts.join('\n\n');
+	if (inner.length) {
+		for (const line of inner.split('\n')) out.push(line.length ? `> ${line}` : '>');
+	}
+	return out.join('\n') + '\n';
+}

src/lib/editor/extensions/wrapSelectedText.ts

@@ -0,0 +1,30 @@
+import { Extension } from '@tiptap/core';
+import { Plugin, PluginKey, TextSelection } from '@tiptap/pm/state';
+import { getSelectionPair } from '../selectionPairs';
+
+// TipTap/ProseMirror behavior for wrapping a non-empty rich-editor selection
+// without flattening selected inline marks or content to plain text.
+export const WrapSelectedText = Extension.create({
+	name: 'wrapSelectedText',
+
+	addProseMirrorPlugins() {
+		return [
+			new Plugin({
+				key: new PluginKey('wrapSelectedText'),
+				props: {
+					// Intercept only supported single-character text input over a range.
+					// Everything else falls back to ProseMirror's normal input handling.
+					handleTextInput(view, from, to, text) {
+						const close = getSelectionPair(text);
+						if (!close || from === to) return false;
+
+						const tr = view.state.tr.insertText(close, to).insertText(text, from);
+						tr.setSelection(TextSelection.create(tr.doc, from + text.length, to + text.length));
+						view.dispatch(tr);
+						return true;
+					},
+				},
+			}),
+		];
+	},
+});

src/lib/editor/selectionPairs.ts

@@ -0,0 +1,15 @@
+// Shared source of truth for editor behaviors that wrap an active selection.
+// Keep this small: only characters users reasonably expect to form pairs.
+const selectionPairs: Record<string, string> = {
+	'(': ')',
+	'{': '}',
+	'[': ']',
+	"'": "'",
+	'"': '"',
+	'`': '`',
+};
+
+// Returns the closing character for a typed wrapper key, or null to pass through.
+export function getSelectionPair(key: string) {
+	return selectionPairs[key] ?? null;
+}