Merge branch 'custom-theme-derived-vars' into 'main'

Reapply the native traffic-light alignment after resize, focus, scale, and theme events so AppKit window-state transitions cannot leave the controls at their default position.

.gitignore

@@ -13,6 +13,9 @@ bun.lockb
 /.svelte-kit
 /build
 
+# Local tests
+/tests/
+
 # Nix
 /result
 

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.3.1-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.3.1)
+## Download (v1.3.4)
 
 ### Linux
 
@@ -42,7 +42,7 @@ sudo eopkg it helixnotes
   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";
     }
   };
@@ -92,27 +92,37 @@ sudo eopkg it helixnotes
 
 #### AppImage (Arch, Fedora 43+, openSUSE Tumbleweed)
 
-[Download AppImage](https://download.helixnotes.com/releases/v1.3.1/HelixNotes_1.3.1_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.3.1/HelixNotes_1.3.1_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.3.1/HelixNotes_1.3.1_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.3.1/HelixNotes_1.3.1_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.3.1/HelixNotes_1.3.1_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
 
@@ -175,4 +185,4 @@ pnpm tauri build
 
 ## 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": 1785571196,
+        "narHash": "sha256-KoTsyMQqnXQZq8deCEnu4QkyldkwH/bpMMhUcfMdGIw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1c3fe55ad329cbcb28471bb30f05c9827f724c76",
+        "rev": "148bab9c1c3c53136ecb44a6ea356a0ed5b39b06",
         "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-P0iXImWYKYPxVj7q2JSuDmd8JvjcKW4DzFUzXeUQZPk=C";
 
-          pnpmConfigHook
-          pnpm
-          nodejs
+          pnpmDeps = pkgs.fetchPnpmDeps {
+            inherit pname version;
+            src = ./.;
+            fetcherVersion = 4;
+            hash = "sha256-odUNKO2D50DG+VpuoTEo5FLMYy5pQSHQBtfHJrhJt78=";
+          };
 
-          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.1",
+  "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

pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

src-tauri/Cargo.lock

@@ -1850,7 +1850,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "helixnotes"
-version = "1.3.1"
+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.1"
+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/capabilities/default.json

@@ -11,6 +11,7 @@
     "core:window:allow-minimize",
     "core:window:allow-toggle-maximize",
     "core:window:allow-close",
+    "core:window:allow-show",
     "core:window:allow-is-maximized",
     "core:window:allow-set-decorations",
     "core:window:allow-is-fullscreen",

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/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

@@ -405,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",
@@ -434,12 +434,14 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
 }
 
 async fn test_openai(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
-    let client = Client::new();
+	let 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,38 @@ 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)
+            {
+                queue_macos_traffic_light_fix(&webview.window());
+            }
+            #[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,14 +125,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,
@@ -116,6 +150,7 @@ pub fn run() {
             commands::read_note,
             commands::save_note,
             commands::create_note,
+            commands::duplicate_note,
             commands::create_daily_note,
             commands::rename_note,
             commands::delete_note,
@@ -136,6 +171,7 @@ pub fn run() {
             commands::empty_trash,
             commands::load_vault_state,
             commands::save_vault_state,
+            commands::copy_text_to_clipboard,
             commands::read_clipboard_image,
             commands::copy_image_to_clipboard,
             commands::save_image,
@@ -277,9 +313,33 @@ pub fn run() {
         }));
 
         builder = builder.plugin(tauri_plugin_updater::Builder::new().build());
-        builder = builder.plugin(tauri_plugin_window_state::Builder::default().build());
+        let window_state_builder = tauri_plugin_window_state::Builder::default();
+        #[cfg(target_os = "linux")]
+        let window_state_builder = window_state_builder.with_state_flags(
+            tauri_plugin_window_state::StateFlags::SIZE
+                | tauri_plugin_window_state::StateFlags::POSITION
+                | tauri_plugin_window_state::StateFlags::MAXIMIZED
+                | tauri_plugin_window_state::StateFlags::DECORATIONS
+                | tauri_plugin_window_state::StateFlags::FULLSCREEN,
+        );
+        builder = builder.plugin(window_state_builder.build());
 
         builder = builder.on_window_event(move |window, event| {
+            #[cfg(target_os = "macos")]
+            if window.label() == "main"
+                && matches!(
+                    event,
+                    tauri::WindowEvent::Resized(_)
+                        | tauri::WindowEvent::Focused(true)
+                        | tauri::WindowEvent::ScaleFactorChanged { .. }
+                        | tauri::WindowEvent::ThemeChanged(_)
+                )
+            {
+                // AppKit can restore the default button Y position after window-state
+                // changes. Queue this pass so it runs after AppKit finishes its layout.
+                queue_macos_traffic_light_fix(window);
+            }
+
             match event {
                 tauri::WindowEvent::CloseRequested { api, .. } => {
                     // Only hide to tray for the main window
@@ -368,3 +428,59 @@ fn percent_decode(input: &str) -> String {
     }
     String::from_utf8_lossy(&output).to_string()
 }
+
+#[cfg(target_os = "macos")]
+fn queue_macos_traffic_light_fix(window: &tauri::Window) {
+    let window_on_main = window.clone();
+    let _ = window.run_on_main_thread(move || {
+        fix_macos_traffic_lights(&window_on_main);
+    });
+}
+
+#[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

@@ -6,9 +6,9 @@
 // vs manifest) and resolve each file as upload/download/delete, with keep-both
 // conflict copies so nothing is ever lost.
 //
-// Synced set: every `*.md` in the vault tree, plus `.helixnotes/attachments/`.
-// Everything else under `.helixnotes/` (search_index, trash, history, *.json, the
-// manifest itself) is local-only and never synced.
+// Synced set: every `*.md` in the vault tree, `.helixnotes/attachments/`, and
+// `.helixnotes/notebook_icons.json`. Search indexes, trash, history, other metadata,
+// and the manifest itself remain local-only.
 
 use crate::state::AppState;
 use crate::vault::operations::helixnotes_dir;
@@ -119,12 +119,12 @@ struct LocalFile {
     path: PathBuf,
 }
 
-/// The synced set: `*.md` anywhere outside `.helixnotes/`, plus everything under
-/// `.helixnotes/attachments/`. Applied to BOTH local and remote so pointing at a
-/// folder with unrelated files never drags them into the vault.
+/// The synced set: `*.md` anywhere outside `.helixnotes/`, everything under
+/// `.helixnotes/attachments/`, and the notebook icon mapping. Applied to BOTH local
+/// and remote so pointing at a folder with unrelated files never imports them.
 fn is_synced_relpath(rel: &str) -> bool {
     if rel.starts_with(".helixnotes/") {
-        rel.starts_with(".helixnotes/attachments/")
+        rel.starts_with(".helixnotes/attachments/") || rel == ".helixnotes/notebook_icons.json"
     } else {
         rel.ends_with(".md")
     }
@@ -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,14 +340,29 @@ 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))
     }
 }
 
@@ -511,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;
@@ -556,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;
@@ -572,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;
@@ -586,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;
@@ -708,3 +724,28 @@ pub fn run_sync(app: tauri::AppHandle, vault: String, cfg: WebdavConfig) -> Resu
     );
     Ok(summary)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::is_synced_relpath;
+
+    #[test]
+    fn syncs_notebook_icon_mapping_and_assets_only() {
+        for path in [
+            "Notes/plan.md",
+            ".helixnotes/attachments/notebook-icon.png",
+            ".helixnotes/notebook_icons.json",
+        ] {
+            assert!(is_synced_relpath(path), "expected {path} to be synced");
+        }
+
+        for path in [
+            "Notes/image.png",
+            ".helixnotes/sync_state.json",
+            ".helixnotes/notebook_icons.json.bak",
+            ".helixnotes/attachments-old/icon.png",
+        ] {
+            assert!(!is_synced_relpath(path), "expected {path} to stay local");
+        }
+    }
+}

src-tauri/src/types.rs

@@ -50,16 +50,69 @@ 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, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum StartupView {
+    Daily,
+    QuickAccess,
+    Tasks,
+    #[default]
+    #[serde(other)]
+    All,
 }
 
 #[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 +125,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,
@@ -95,6 +150,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")]
@@ -130,14 +197,18 @@ pub struct AppConfig {
     #[serde(default)]
     pub default_view_mode: bool,
     #[serde(default)]
+    pub new_notes_in_source_mode: bool,
+    #[serde(default)]
     pub show_tray_icon: bool,
     #[serde(default)]
     pub close_to_tray: bool,
     #[serde(default = "default_true")]
     pub enable_wiki_links: bool,
     #[serde(default)]
+    pub startup_view: StartupView,
+    #[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)]
@@ -154,12 +225,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
 }
@@ -197,12 +274,14 @@ 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(),
@@ -215,6 +294,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,
@@ -232,9 +317,11 @@ impl Default for AppConfig {
             ai_model: "claude-sonnet-4-6".to_string(),
             ai_writing_style: None,
             default_view_mode: false,
+            new_notes_in_source_mode: false,
             show_tray_icon: false,
             close_to_tray: false,
             enable_wiki_links: true,
+            startup_view: StartupView::All,
             restore_last_session: false,
             sync_provider: None,
             webdav_url: None,
@@ -244,6 +331,7 @@ impl Default for AppConfig {
             sync_on_change: false,
             sync_interval_minutes: 0,
             last_sync_time: None,
+            custom_themes: Vec::new(),
         }
     }
 }
@@ -253,14 +341,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,
@@ -284,10 +378,13 @@ 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,
@@ -318,6 +415,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)]
@@ -386,3 +486,28 @@ pub struct TaskItem {
     pub due: Option<String>,
     pub priority: Option<String>,
 }
+
+#[cfg(test)]
+mod startup_view_tests {
+    use super::StartupView;
+
+    #[test]
+    fn serializes_supported_startup_views() {
+        for (view, expected) in [
+            (StartupView::All, "\"all\""),
+            (StartupView::QuickAccess, "\"quickaccess\""),
+            (StartupView::Tasks, "\"tasks\""),
+            (StartupView::Daily, "\"daily\""),
+        ] {
+            assert_eq!(serde_json::to_string(&view).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn unknown_startup_view_falls_back_to_all_notes() {
+        assert_eq!(
+            serde_json::from_str::<StartupView>("\"future-view\"").unwrap(),
+            StartupView::All
+        );
+    }
+}

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(),
@@ -469,6 +476,75 @@ pub fn create_note(
     })
 }
 
+pub fn duplicate_note(path: &str, vault_path: &str) -> Result<NoteEntry, String> {
+    let src = Path::new(path);
+    if !src.is_file() {
+        return Err("Note does not exist".to_string());
+    }
+
+    let parent = src
+        .parent()
+        .ok_or_else(|| "Note has no parent directory".to_string())?;
+    let raw = fs::read_to_string(src).map_err(|e| e.to_string())?;
+    let filename = src
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .to_string();
+    let (mut meta, body) = frontmatter::parse_note(&raw, &filename);
+    let source_title = meta.title.clone();
+    let base_title = format!("{} copy", source_title.trim_end());
+    let mut copy_title = base_title.clone();
+    let mut copy_number = 2;
+    let mut copy_path = parent.join(format!("{}.md", sanitize_filename(&copy_title)));
+
+    while copy_path.exists() {
+        copy_title = format!("{} {}", base_title, copy_number);
+        copy_number += 1;
+        copy_path = parent.join(format!("{}.md", sanitize_filename(&copy_title)));
+    }
+
+    let now = Utc::now();
+    meta.id = Uuid::new_v4().to_string();
+    meta.title = copy_title;
+    meta.pinned = false;
+    meta.created = now;
+    meta.modified = now;
+
+    let body = retitle_leading_heading(&body, &source_title, &meta.title);
+    let copy_raw = frontmatter::merge_frontmatter(&raw, &meta, &body);
+    fs::write(&copy_path, copy_raw).map_err(|e| e.to_string())?;
+
+    read_note_entry(&copy_path, Path::new(vault_path))
+}
+
+fn retitle_leading_heading(body: &str, old_title: &str, new_title: &str) -> String {
+    let trimmed = body.trim_start();
+    let leading_len = body.len() - trimmed.len();
+    let first_line_end = trimmed.find('\n').unwrap_or(trimmed.len());
+    let first_line = &trimmed[..first_line_end];
+    let heading_len = first_line.chars().take_while(|&c| c == '#').count();
+
+    if !(1..=6).contains(&heading_len) {
+        return body.to_string();
+    }
+
+    let Some(heading_title) = first_line[heading_len..].strip_prefix(' ') else {
+        return body.to_string();
+    };
+    if !heading_title.trim().eq_ignore_ascii_case(old_title.trim()) {
+        return body.to_string();
+    }
+
+    let mut retitled = String::with_capacity(body.len() + new_title.len());
+    retitled.push_str(&body[..leading_len]);
+    retitled.push_str(&"#".repeat(heading_len));
+    retitled.push(' ');
+    retitled.push_str(new_title);
+    retitled.push_str(&trimmed[first_line_end..]);
+    retitled
+}
+
 fn get_system_locale() -> Locale {
     let sys = sys_locale::get_locale().unwrap_or_else(|| "en-US".to_string());
     let lang = sys.split(&['-', '_', '.'][..]).next().unwrap_or("en");
@@ -1230,3 +1306,62 @@ pub fn sanitize_filename(name: &str) -> String {
         .trim()
         .to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{duplicate_note, helixnotes_dir, load_notebook_icons, set_notebook_icon};
+    use std::fs;
+    use uuid::Uuid;
+
+    #[test]
+    fn persists_and_removes_builtin_notebook_icons() {
+        let vault =
+            std::env::temp_dir().join(format!("helixnotes-notebook-icon-test-{}", Uuid::new_v4()));
+        let vault_path = vault.to_string_lossy();
+        fs::create_dir_all(helixnotes_dir(&vault_path)).unwrap();
+
+        set_notebook_icon(&vault_path, "Projects", Some("builtin:briefcase")).unwrap();
+        let icons = load_notebook_icons(&vault_path).unwrap();
+        assert_eq!(
+            icons.get("Projects").map(String::as_str),
+            Some("builtin:briefcase")
+        );
+
+        set_notebook_icon(&vault_path, "Projects", None).unwrap();
+        assert!(load_notebook_icons(&vault_path).unwrap().is_empty());
+
+        fs::remove_dir_all(vault).unwrap();
+    }
+
+    #[test]
+    fn duplicates_note_content_and_assigns_unique_identity_and_name() {
+        let vault =
+            std::env::temp_dir().join(format!("helixnotes-duplicate-note-test-{}", Uuid::new_v4()));
+        let notebook = vault.join("Projects");
+        fs::create_dir_all(&notebook).unwrap();
+        let source_path = notebook.join("Project.md");
+        let source_raw = "---\nid: source-id\ntitle: Project\ntags:\n  - work\npinned: true\ncreated: 2020-01-01T00:00:00Z\nmodified: 2020-01-02T00:00:00Z\naliases:\n  - Plan\n---\n# Project\n\nOriginal body.\n";
+        fs::write(&source_path, source_raw).unwrap();
+
+        let vault_path = vault.to_string_lossy();
+        let first = duplicate_note(&source_path.to_string_lossy(), &vault_path).unwrap();
+        let second = duplicate_note(&source_path.to_string_lossy(), &vault_path).unwrap();
+
+        assert_eq!(first.meta.title, "Project copy");
+        assert_eq!(second.meta.title, "Project copy 2");
+        assert_eq!(first.meta.tags, vec!["work"]);
+        assert!(!first.meta.pinned);
+        assert_ne!(first.meta.id, "source-id");
+        assert_ne!(first.meta.id, second.meta.id);
+        assert_eq!(first.relative_path, "Projects/Project copy.md");
+        assert_eq!(second.relative_path, "Projects/Project copy 2.md");
+
+        let first_raw = fs::read_to_string(&first.path).unwrap();
+        assert!(first_raw.contains("aliases:\n- Plan"));
+        assert!(first_raw.contains("# Project copy\n\nOriginal body."));
+        assert!(!first_raw.contains("\n# Project\n"));
+        assert_eq!(fs::read_to_string(&source_path).unwrap(), source_raw);
+
+        fs::remove_dir_all(vault).unwrap();
+    }
+}

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.1",
+  "version": "1.3.4",
   "identifier": "com.helixnotes.app",
   "build": {
     "frontendDist": "../build",
@@ -55,6 +55,9 @@
       "appimage": {
         "bundleMediaFramework": false
       }
+    },
+    "macOS": {
+      "entitlements": "entitlements.plist"
     }
   }
 }

src-tauri/tauri.linux.conf.json

@@ -0,0 +1,10 @@
+{
+  "app": {
+    "windows": [
+      {
+        "label": "main",
+        "visible": false
+      }
+    ]
+  }
+}

src/app.css

@@ -173,6 +173,21 @@
   --danger-hover: #d43d3d;
   --success: #40c057;
   --warning: #fab005;
+  /* Obsidian-style callout accent hues (RGB triplets; mixed with the background via opacity, so one set works on every theme) */
+  --callout-note: 68, 138, 255;
+  --callout-abstract: 0, 191, 188;
+  --callout-info: 0, 184, 212;
+  --callout-todo: 0, 184, 212;
+  --callout-tip: 0, 191, 188;
+  --callout-success: 8, 185, 78;
+  --callout-question: 236, 191, 0;
+  --callout-warning: 236, 117, 0;
+  --callout-failure: 233, 49, 71;
+  --callout-danger: 233, 49, 71;
+  --callout-bug: 233, 49, 71;
+  --callout-example: 120, 82, 238;
+  --callout-quote: 158, 158, 158;
+  --callout-custom: 124, 134, 156;
   --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.05);
   --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.08);
   --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.12);
@@ -204,6 +219,20 @@
   --danger-hover: #eba0ac;
   --success: #a6e3a1;
   --warning: #f9e2af;
+  --callout-note: 100, 160, 255;
+  --callout-abstract: 60, 209, 205;
+  --callout-info: 60, 200, 224;
+  --callout-todo: 60, 200, 224;
+  --callout-tip: 60, 209, 205;
+  --callout-success: 80, 205, 120;
+  --callout-question: 240, 205, 80;
+  --callout-warning: 245, 150, 60;
+  --callout-failure: 240, 95, 115;
+  --callout-danger: 240, 95, 115;
+  --callout-bug: 240, 95, 115;
+  --callout-example: 165, 135, 245;
+  --callout-quote: 150, 150, 162;
+  --callout-custom: 150, 160, 182;
   --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.2);
   --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.3);
   --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.4);
@@ -961,6 +990,31 @@
   --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.8);
 }
 
+:root[data-theme="one-dark"] {
+  --bg-primary: #282c34;
+  --bg-secondary: #21252b;
+  --bg-tertiary: #2c313a;
+  --bg-hover: #3e4451;
+  --bg-active: #4b5263;
+  --bg-editor: #282c34;
+  --text-primary: #abb2bf;
+  --text-secondary: #828997;
+  --text-tertiary: #5c6370;
+  --text-accent: #61afef;
+  --border-color: #3e4451;
+  --border-light: #2c313a;
+  --accent: #61afef;
+  --accent-hover: #4d9fdf;
+  --accent-light: color-mix(in srgb, #61afef 12%, transparent);
+  --danger: #e06c75;
+  --danger-hover: #cc5560;
+  --success: #98c379;
+  --warning: #e5c07b;
+  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.3);
+  --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.4);
+  --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.5);
+}
+
 *,
 *::before,
 *::after {
@@ -1088,10 +1142,6 @@ body.resizing {
 /* ── Mobile (Android/iOS) ── */
 @media (max-width: 768px) {
   body {
-    padding-top: env(safe-area-inset-top);
-    padding-bottom: env(safe-area-inset-bottom);
-    padding-left: env(safe-area-inset-left);
-    padding-right: env(safe-area-inset-right);
     -webkit-tap-highlight-color: transparent;
     touch-action: manipulation;
   }

src/lib/api.ts

@@ -1,6 +1,7 @@
 import { invoke } from "@tauri-apps/api/core";
 import type {
   AppConfig,
+  CustomTheme,
   NoteContent,
   NoteEntry,
   NoteMeta,
@@ -14,14 +15,24 @@ import type {
   BackupEntry,
   VersionEntry,
   TaskItem,
+  ExternalVaultResult,
+  StartupView,
 } from "./types";
 
 export async function openVault(path: string): Promise<void> {
   return invoke("open_vault", { path });
 }
 
-export async function removeVault(path: string): Promise<void> {
-  return invoke("remove_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> {
@@ -36,6 +47,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 });
 }
@@ -52,6 +79,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");
 }
@@ -110,6 +141,10 @@ export async function createNote(
   return invoke("create_note", { notebookRelative, title });
 }
 
+export async function duplicateNote(path: string): Promise<NoteEntry> {
+  return invoke("duplicate_note", { path });
+}
+
 export async function createDailyNote(date?: string): Promise<NoteEntry> {
   return invoke("create_daily_note", { date: date ?? null });
 }
@@ -186,6 +221,10 @@ export async function saveVaultState(vaultState: VaultState): Promise<void> {
   return invoke("save_vault_state", { vaultState });
 }
 
+export async function copyTextToClipboard(text: string): Promise<void> {
+  return invoke("copy_text_to_clipboard", { text });
+}
+
 export async function readClipboardImage(): Promise<number[]> {
   return invoke("read_clipboard_image");
 }
@@ -228,12 +267,20 @@ export async function setGeneralSettings(
   titleMode: string,
   hideTitleInBody: boolean,
   showLineNumbers: boolean,
+  showLinkArrows: boolean,
   defaultViewMode: boolean,
+  newNotesInSourceMode: boolean,
   showTrayIcon: boolean,
   closeToTray: boolean,
   enableWikiLinks: boolean,
   showNoteDates: boolean,
+  startupView: StartupView,
   restoreLastSession: boolean,
+  showAllNotes: boolean,
+  showQuickAccess: boolean,
+  showTasks: boolean,
+  showDailyNotes: boolean,
+  showTrash: boolean,
 ): Promise<void> {
   return invoke("set_general_settings", {
     compactNotes,
@@ -247,12 +294,20 @@ export async function setGeneralSettings(
     titleMode,
     hideTitleInBody,
     showLineNumbers,
+    showLinkArrows,
     defaultViewMode,
+    newNotesInSourceMode,
     showTrayIcon,
     closeToTray,
     enableWikiLinks,
     showNoteDates,
+    startupView,
     restoreLastSession,
+    showAllNotes,
+    showQuickAccess,
+    showTasks,
+    showDailyNotes,
+    showTrash,
   });
 }
 

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,6 +39,7 @@
 		rootNoteCount,
 		viewMode,
 		sortMode,
+		groupNotesByDate,
 		tasksLayout,
 		tasksHideCompleted,
 		tasksOnlyFlagged,
@@ -48,19 +51,24 @@
 		viewerNote,
 		notebookSortMode,
 		notebookOrder,
+		noteOrder,
 		syncState,
-		platformIsMobile
+		platformIsMobile,
+		activeVaultConfig,
 	} from '$lib/stores/app';
+	import { keybindings, matchAction } from '$lib/keybindings';
 
 	const appWindow = getCurrentWindow();
 	const isMac = navigator.platform.startsWith('Mac');
 	const isMobile = $derived($platformIsMobile);
-	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';
+	import { loadVaultState, saveVaultState, readNote, deleteNote, 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 { normalizeStartupView, resolveStartupTarget } from '$lib/utils/startup-view';
 	import { get } from 'svelte/store';
 	import type { VaultState, FileEvent, NotebookEntry, TaskItem } from '$lib/types';
+	import type { StartupTarget } from '$lib/utils/startup-view';
 
 	function findNotebookByPath(list: NotebookEntry[], relPath: string): NotebookEntry | null {
 		for (const nb of list) {
@@ -75,6 +83,38 @@
 	let noteList: NoteList;
 	let editor: Editor;
 	let unlistenFileChange: (() => void) | null = null;
+	async function applyStartupTarget(target: StartupTarget): Promise<boolean> {
+		if (target.mode === 'notebook') {
+			const vault = $appConfig?.active_vault;
+			const notebook = target.notebookPath === '' && vault
+				? { name: 'Unfiled Notes', path: vault, relative_path: '', children: [], note_count: $rootNoteCount }
+				: findNotebookByPath($notebooks, target.notebookPath);
+			if (!notebook) return false;
+			const changed = $viewMode !== 'notebook' || $activeNotebook?.relative_path !== notebook.relative_path;
+			$viewMode = 'notebook';
+			$activeNotebook = notebook;
+			$activeTag = null;
+			if (changed) await noteList?.refresh();
+			return true;
+		}
+
+		if (target.mode === 'tag') {
+			const changed = $viewMode !== 'tag' || $activeTag !== target.tag;
+			$viewMode = 'tag';
+			$activeTag = target.tag;
+			$activeNotebook = null;
+			if (changed) await noteList?.refresh();
+			return true;
+		}
+
+		const changed = $viewMode !== target.mode || $activeNotebook !== null || $activeTag !== null;
+		$viewMode = target.mode;
+		$activeNotebook = null;
+		$activeTag = null;
+		if (changed) await noteList?.refresh();
+		return true;
+	}
+
 	let unlistenOpenFile: (() => void) | null = null;
 
 	// Mobile editor header helpers
@@ -116,16 +156,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 (_) {}
 		}
@@ -198,11 +238,15 @@
 			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,
@@ -226,20 +270,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';
 	}
 
@@ -360,6 +424,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;
@@ -375,6 +449,28 @@
 		else if ($mobileView === 'notelist') $mobileView = 'sidebar';
 	}
 
+	async function trashOpenNote(path: string): Promise<boolean> {
+		if (path !== $activeNotePath || $viewerNote || $viewMode === 'trash') return false;
+		try {
+			await deleteNote(path);
+			if (Object.hasOwn($noteOrder, path)) {
+				const { [path]: _, ...rest } = $noteOrder;
+				$noteOrder = rest;
+			}
+			$notes = $notes.filter((note) => note.path !== path);
+			if ($activeNotePath === path) {
+				$activeNote = null;
+				$activeNotePath = null;
+			}
+			noteList?.refresh(true).catch((error) => console.error('Failed to refresh notes after trashing:', error));
+			if (isMobile) $mobileView = 'notelist';
+			return true;
+		} catch (error) {
+			console.error('Failed to move open note to Trash:', error);
+			return false;
+		}
+	}
+
 	function handleMouseDown(e: MouseEvent) {
 		if (e.button === 3) { e.preventDefault(); navigateHistory(-1); }
 		if (e.button === 4) { e.preventDefault(); navigateHistory(1); }
@@ -383,88 +479,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;
+			editor?.moveOpenNoteToTrash();
+			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;
@@ -475,8 +566,7 @@
 	}
 
 	function applyTheme(t: string) {
-		const darkThemes = ['dark', 'solarized-dark', 'catppuccin', 'nord', 'tokyo-night', 'github-dark', 'dracula', 'blueberry', 'forest-green', 'gruvbox', 'midnight-tide', 'cherry-blossom', 'synthwave', 'ember', 'moonlit', 'dark-coffee', 'crimson'];
-		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'];
+		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');
@@ -502,14 +592,27 @@
 		persistState();
 	});
 
+	$effect(() => {
+		$sidebarCollapsed;
+		$notelistCollapsed;
+		$outlineWidth;
+		persistState();
+	});
+
 	$effect(() => {
 		$notebookSortMode;
 		$notebookOrder;
 		persistState();
 	});
 
+	$effect(() => {
+		$noteOrder;
+		persistState();
+	});
+
 	$effect(() => {
 		$sortMode;
+		$groupNotesByDate;
 		$tasksLayout;
 		$tasksHideCompleted;
 		$tasksOnlyFlagged;
@@ -533,11 +636,15 @@
 			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;
@@ -548,9 +655,11 @@
 			lastTag = state.last_tag ?? null;
 		} catch (_) {}
 
+		const restoreLastSession = $appConfig?.restore_last_session === true;
+
 		// On mobile, prefetch last-opened note so first tap is instant
 		let prefetchPromise: Promise<any> | null = null;
-		if (isMobile && lastNotePath) {
+		if (isMobile && restoreLastSession && lastNotePath) {
 			prefetchPromise = readNote(lastNotePath).catch(() => null);
 		}
 
@@ -563,32 +672,49 @@
 		// Run sidebar and note list refresh in parallel
 		await Promise.all([sidebar?.refresh(), noteList?.refresh()]);
 
-		// Restore the last session (view + open note) if enabled.
-		if ($appConfig?.restore_last_session) {
-			const vault = $appConfig?.active_vault;
-			if (lastViewMode === 'notebook' && lastNotebook === '' && vault) {
-				$viewMode = 'notebook';
-				$activeNotebook = { name: 'Unfiled Notes', path: vault, relative_path: '', children: [], note_count: $rootNoteCount };
-				$activeTag = null;
-				await noteList?.refresh();
-			} else if (lastViewMode === 'notebook' && lastNotebook) {
-				const nb = findNotebookByPath($notebooks, lastNotebook);
-				if (nb) { $viewMode = 'notebook'; $activeNotebook = nb; $activeTag = null; await noteList?.refresh(); }
-			} else if (lastViewMode === 'tag' && lastTag) {
-				$viewMode = 'tag'; $activeTag = lastTag; $activeNotebook = null; await noteList?.refresh();
-			} else if (lastViewMode === 'quickaccess') {
-				$viewMode = 'quickaccess'; $activeNotebook = null; $activeTag = null; await noteList?.refresh();
-			}
-			// Open the last note on desktop (mobile reopens it via its own prefetch path below).
-			if (!isMobile && lastNotePath) {
+		// 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 content = await readNote(lastNotePath);
-					$activeNote = content;
-					$activeNotePath = lastNotePath;
-					$editorDirty = false;
-					editor?.loadNote(lastNotePath, content.content);
+					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);
+		}
+
+		const startupTarget = resolveStartupTarget({
+			startupView: $appConfig?.startup_view,
+			restoreLastSession,
+			lastViewMode,
+			lastNotebook,
+			lastTag
+		});
+		if (!(await applyStartupTarget(startupTarget))) {
+			await applyStartupTarget({ mode: normalizeStartupView($appConfig?.startup_view) });
+		}
+
+		// Reopen the last note only when session restoration is enabled.
+		if (restoreLastSession && !isMobile && lastNotePath) {
+			try {
+				const content = await readNote(lastNotePath);
+				$activeNote = content;
+				$activeNotePath = lastNotePath;
+				$editorDirty = false;
+				editor?.loadNote(lastNotePath, content.content);
+			} catch (_) {}
 		}
 
 		// On mobile, derive tags from the scanned notes (avoids a separate full-scan Rust call)
@@ -628,7 +754,7 @@
 					}
 				}
 				tags.set(Array.from(tagMap.entries()).sort((a, b) => a[0].localeCompare(b[0])));
-			}, 3000);
+		}, 10000);
 			unlistenFileChange = await listen<FileEvent>('file-changed', () => {
 				debouncedRefresh();
 			});
@@ -658,15 +784,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 (_) {}
 		}
 
@@ -676,8 +803,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);
 			}
@@ -793,7 +920,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"/>
@@ -820,6 +947,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" />
@@ -836,10 +970,10 @@
 				<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()} onBeforeNoteDuplicate={() => editor?.forceSave() ?? Promise.resolve(true)} 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} />
+				<Editor bind:this={editor} onMoveToTrash={trashOpenNote} />
 			</div>
 		</div>
 
@@ -895,15 +1029,28 @@
 					<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()} onBeforeNoteDuplicate={() => editor?.forceSave() ?? Promise.resolve(true)} 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">
-				<Editor bind:this={editor} />
+				<Editor bind:this={editor} onMoveToTrash={trashOpenNote} />
 				{#if $viewMode === 'tasks' && !taskNoteOpened}
 					<div class="tasks-editor-placeholder">
 						<svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
@@ -918,7 +1065,7 @@
 {/if}
 
 <SearchPanel />
-<CommandPalette />
+<CommandPalette onNavigate={handleViewChanged} />
 <SettingsPanel />
 <InfoPanel />
 
@@ -949,6 +1096,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%;
@@ -1035,7 +1212,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', 'blueberry', 'forest-green', 'gruvbox', 'midnight-tide', 'cherry-blossom', 'synthwave', 'ember', 'moonlit', 'dark-coffee', 'crimson'];
-		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'];
+		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/ImageViewer.svelte

@@ -0,0 +1,385 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+
+	let { src, alt = '', onclose }: {
+		src: string;
+		alt?: string;
+		onclose: () => void;
+	} = $props();
+
+	const MIN_SCALE = 1;
+	const MAX_SCALE = 5;
+	const DOUBLE_TAP_MS = 300;
+	const TAP_MOVE_THRESHOLD = 6;
+
+	type Point = { x: number; y: number };
+	type ViewerGesture =
+		| { kind: 'pan'; start: Point; pan: Point }
+		| { kind: 'pinch'; distance: number; imagePoint: Point };
+
+	let canvasElement = $state<HTMLDivElement | null>(null);
+	let imageElement = $state<HTMLImageElement | null>(null);
+	let closeButton = $state<HTMLButtonElement | null>(null);
+	let scale = $state(1);
+	let panX = $state(0);
+	let panY = $state(0);
+	let interacting = $state(false);
+	let gesture: ViewerGesture | null = null;
+	let touchMoved = false;
+	let lastTapAt = 0;
+	let zoomPercent = $derived(Math.round(scale * 100));
+
+	function clamp(value: number, min: number, max: number): number {
+		return Math.min(max, Math.max(min, value));
+	}
+
+	function midpoint(first: Touch, second: Touch): Point {
+		return {
+			x: (first.clientX + second.clientX) / 2,
+			y: (first.clientY + second.clientY) / 2,
+		};
+	}
+
+	function touchDistance(first: Touch, second: Touch): number {
+		return Math.hypot(second.clientX - first.clientX, second.clientY - first.clientY);
+	}
+
+	function panLimits(nextScale: number): Point {
+		const canvasWidth = canvasElement?.clientWidth ?? window.innerWidth;
+		const canvasHeight = canvasElement?.clientHeight ?? window.innerHeight;
+		const imageWidth = imageElement?.clientWidth ?? 0;
+		const imageHeight = imageElement?.clientHeight ?? 0;
+		return {
+			x: Math.max(0, (imageWidth * nextScale - canvasWidth) / 2),
+			y: Math.max(0, (imageHeight * nextScale - canvasHeight) / 2),
+		};
+	}
+
+	function applyTransform(nextScale: number, nextPanX: number, nextPanY: number) {
+		const clampedScale = clamp(nextScale, MIN_SCALE, MAX_SCALE);
+		const limits = panLimits(clampedScale);
+		scale = clampedScale;
+		panX = clamp(nextPanX, -limits.x, limits.x);
+		panY = clamp(nextPanY, -limits.y, limits.y);
+	}
+
+	function resetViewer() {
+		interacting = false;
+		gesture = null;
+		applyTransform(MIN_SCALE, 0, 0);
+	}
+
+	function zoomAt(point: Point, nextScale: number) {
+		const canvasRect = canvasElement?.getBoundingClientRect();
+		const centerX = canvasRect ? canvasRect.left + canvasRect.width / 2 : window.innerWidth / 2;
+		const centerY = canvasRect ? canvasRect.top + canvasRect.height / 2 : window.innerHeight / 2;
+		const imageX = (point.x - centerX - panX) / scale;
+		const imageY = (point.y - centerY - panY) / scale;
+		applyTransform(
+			nextScale,
+			point.x - centerX - imageX * nextScale,
+			point.y - centerY - imageY * nextScale,
+		);
+	}
+
+	function beginPan(touch: Touch) {
+		gesture = {
+			kind: 'pan',
+			start: { x: touch.clientX, y: touch.clientY },
+			pan: { x: panX, y: panY },
+		};
+	}
+
+	function beginPinch(first: Touch, second: Touch) {
+		const point = midpoint(first, second);
+		const canvasRect = canvasElement?.getBoundingClientRect();
+		const centerX = canvasRect ? canvasRect.left + canvasRect.width / 2 : window.innerWidth / 2;
+		const centerY = canvasRect ? canvasRect.top + canvasRect.height / 2 : window.innerHeight / 2;
+		gesture = {
+			kind: 'pinch',
+			distance: Math.max(1, touchDistance(first, second)),
+			imagePoint: {
+				x: (point.x - centerX - panX) / scale,
+				y: (point.y - centerY - panY) / scale,
+			},
+		};
+	}
+
+	function handleTouchStart(event: TouchEvent) {
+		event.preventDefault();
+		interacting = true;
+		if (event.touches.length >= 2) {
+			touchMoved = true;
+			beginPinch(event.touches[0], event.touches[1]);
+			return;
+		}
+		if (event.touches.length === 1) {
+			touchMoved = false;
+			beginPan(event.touches[0]);
+		}
+	}
+
+	function handleTouchMove(event: TouchEvent) {
+		event.preventDefault();
+		if (event.touches.length >= 2) {
+			if (gesture?.kind !== 'pinch') beginPinch(event.touches[0], event.touches[1]);
+			if (gesture?.kind !== 'pinch') return;
+			const point = midpoint(event.touches[0], event.touches[1]);
+			const canvasRect = canvasElement?.getBoundingClientRect();
+			const centerX = canvasRect ? canvasRect.left + canvasRect.width / 2 : window.innerWidth / 2;
+			const centerY = canvasRect ? canvasRect.top + canvasRect.height / 2 : window.innerHeight / 2;
+			const nextScale = clamp(
+				scale * (touchDistance(event.touches[0], event.touches[1]) / gesture.distance),
+				MIN_SCALE,
+				MAX_SCALE,
+			);
+			gesture.distance = Math.max(1, touchDistance(event.touches[0], event.touches[1]));
+			applyTransform(
+				nextScale,
+				point.x - centerX - gesture.imagePoint.x * nextScale,
+				point.y - centerY - gesture.imagePoint.y * nextScale,
+			);
+			touchMoved = true;
+			return;
+		}
+		if (event.touches.length === 1 && gesture?.kind === 'pan') {
+			const dx = event.touches[0].clientX - gesture.start.x;
+			const dy = event.touches[0].clientY - gesture.start.y;
+			if (Math.hypot(dx, dy) > TAP_MOVE_THRESHOLD) touchMoved = true;
+			applyTransform(scale, gesture.pan.x + dx, gesture.pan.y + dy);
+		}
+	}
+
+	function handleTouchEnd(event: TouchEvent) {
+		event.preventDefault();
+		if (event.touches.length >= 2) {
+			beginPinch(event.touches[0], event.touches[1]);
+			return;
+		}
+		if (event.touches.length === 1) {
+			beginPan(event.touches[0]);
+			touchMoved = true;
+			return;
+		}
+
+		interacting = false;
+		gesture = null;
+		if (!touchMoved && event.changedTouches.length > 0) {
+			const now = performance.now();
+			const touch = event.changedTouches[0];
+			if (now - lastTapAt <= DOUBLE_TAP_MS) {
+				if (scale > MIN_SCALE + 0.01) resetViewer();
+				else zoomAt({ x: touch.clientX, y: touch.clientY }, 2);
+				lastTapAt = 0;
+			} else {
+				lastTapAt = now;
+			}
+		}
+	}
+
+	function handleTouchCancel(event: TouchEvent) {
+		event.preventDefault();
+		interacting = false;
+		gesture = null;
+		touchMoved = false;
+		applyTransform(scale, panX, panY);
+	}
+
+	function attachTouchGestures(node: HTMLElement) {
+		node.addEventListener('touchstart', handleTouchStart, { passive: false });
+		node.addEventListener('touchmove', handleTouchMove, { passive: false });
+		node.addEventListener('touchend', handleTouchEnd, { passive: false });
+		node.addEventListener('touchcancel', handleTouchCancel, { passive: false });
+		return {
+			destroy() {
+				node.removeEventListener('touchstart', handleTouchStart);
+				node.removeEventListener('touchmove', handleTouchMove);
+				node.removeEventListener('touchend', handleTouchEnd);
+				node.removeEventListener('touchcancel', handleTouchCancel);
+			},
+		};
+	}
+
+	onMount(() => {
+		closeButton?.focus();
+		const handleResize = () => applyTransform(scale, panX, panY);
+		window.addEventListener('resize', handleResize);
+		return () => window.removeEventListener('resize', handleResize);
+	});
+</script>
+
+<div
+	class="image-viewer"
+	role="dialog"
+	aria-modal="true"
+	aria-label={alt ? `Image viewer: ${alt}` : 'Image viewer'}
+	tabindex="-1"
+	onkeydown={(event) => {
+		if (event.key === 'Escape') {
+			event.preventDefault();
+			onclose();
+		}
+	}}
+>
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div
+		class="image-viewer-canvas"
+		bind:this={canvasElement}
+		use:attachTouchGestures
+		onclick={(event) => {
+			if (event.target === event.currentTarget) onclose();
+		}}
+		onkeydown={(event) => {
+			if (event.target === event.currentTarget && (event.key === 'Enter' || event.key === ' ')) onclose();
+		}}
+	>
+		<img
+			bind:this={imageElement}
+			class:interacting
+			src={src}
+			alt={alt}
+			draggable="false"
+			style:transform={`translate3d(${panX}px, ${panY}px, 0) scale(${scale})`}
+			onload={resetViewer}
+		/>
+	</div>
+
+	<div class="image-viewer-controls">
+		<button
+			type="button"
+			class="image-viewer-reset"
+			onclick={resetViewer}
+			disabled={scale === MIN_SCALE && panX === 0 && panY === 0}
+			aria-label={`Reset zoom, currently ${zoomPercent}%`}
+		>
+			<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+				<path d="M3 12a9 9 0 1 0 3-6.7" />
+				<path d="M3 4v6h6" />
+			</svg>
+			<span>{zoomPercent}%</span>
+		</button>
+		<button bind:this={closeButton} type="button" class="image-viewer-close" onclick={onclose} aria-label="Close image viewer">
+			<svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true">
+				<path d="M18 6 6 18M6 6l12 12" />
+			</svg>
+		</button>
+	</div>
+
+	<div class="image-viewer-hint" aria-hidden="true">Pinch to zoom · drag to move · double-tap to zoom or reset</div>
+	<span class="sr-only" aria-live="polite">Zoom {zoomPercent}%</span>
+</div>
+
+<style>
+	.image-viewer {
+		position: fixed;
+		inset: 0;
+		z-index: 10000;
+		background: #06080c;
+		color: #fff;
+		overflow: hidden;
+		overscroll-behavior: contain;
+	}
+
+	.image-viewer-canvas {
+		position: absolute;
+		inset: 0;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		touch-action: none;
+		user-select: none;
+		-webkit-user-select: none;
+	}
+
+	.image-viewer-canvas img {
+		display: block;
+		max-width: calc(100vw - 24px);
+		max-height: calc(100dvh - 24px);
+		object-fit: contain;
+		transform-origin: center center;
+		transition: transform 160ms ease-out;
+		will-change: transform;
+		-webkit-user-drag: none;
+		user-select: none;
+	}
+
+	.image-viewer-canvas img.interacting {
+		transition: none;
+	}
+
+	.image-viewer-controls {
+		position: absolute;
+		inset: max(12px, env(safe-area-inset-top)) max(12px, env(safe-area-inset-right)) auto max(12px, env(safe-area-inset-left));
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		pointer-events: none;
+	}
+
+	.image-viewer-controls button {
+		min-height: 44px;
+		border: 1px solid rgba(255, 255, 255, 0.18);
+		background: rgba(20, 23, 30, 0.86);
+		color: #fff;
+		box-shadow: 0 8px 24px rgba(0, 0, 0, 0.3);
+		pointer-events: auto;
+	}
+
+	.image-viewer-reset {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		padding: 0 14px;
+		border-radius: 10px;
+		font: inherit;
+		font-size: 13px;
+		font-weight: 600;
+	}
+
+	.image-viewer-reset:disabled {
+		opacity: 0.45;
+	}
+
+	.image-viewer-close {
+		display: grid;
+		place-items: center;
+		width: 44px;
+		padding: 0;
+		border-radius: 50%;
+	}
+
+	.image-viewer-hint {
+		position: absolute;
+		left: 50%;
+		bottom: max(18px, calc(env(safe-area-inset-bottom) + 10px));
+		transform: translateX(-50%);
+		width: max-content;
+		max-width: calc(100vw - 32px);
+		padding: 8px 12px;
+		border-radius: 8px;
+		background: rgba(20, 23, 30, 0.82);
+		color: rgba(255, 255, 255, 0.72);
+		font-size: 12px;
+		line-height: 1.35;
+		text-align: center;
+		pointer-events: none;
+	}
+
+	.sr-only {
+		position: absolute;
+		width: 1px;
+		height: 1px;
+		padding: 0;
+		margin: -1px;
+		overflow: hidden;
+		clip: rect(0, 0, 0, 0);
+		white-space: nowrap;
+		border: 0;
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.image-viewer-canvas img {
+			transition: none;
+		}
+	}
+</style>

src/lib/components/InfoPanel.svelte

@@ -1,13 +1,88 @@
 <script lang="ts">
-	import { showInfo, appConfig } from '$lib/stores/app';
+	import { showInfo } from '$lib/stores/app';
 	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');
@@ -21,7 +96,7 @@
 
 	function close() {
 		$showInfo = false;
-		activeTab = 'shortcuts';
+		activeTab = isMobile ? 'about' : 'shortcuts';
 	}
 
 	function openLink(url: string) {
@@ -69,7 +144,7 @@
 		<div class="info-panel" onclick={(e) => e.stopPropagation()}>
 			<div class="info-header">
 				<h2>Info</h2>
-				<button class="close-btn" onclick={close}>
+				<button class="close-btn" onclick={close} aria-label="Close info">
 					<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 						<line x1="18" y1="6" x2="6" y2="18" />
 						<line x1="6" y1="6" x2="18" y2="18" />
@@ -158,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>
@@ -186,9 +273,11 @@
 						<div class="shortcut-row"><span class="shortcut-desc">Strikethrough</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>X</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Code</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>E</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Link</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>K</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Collapsible section</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>.</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Undo</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Z</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Redo</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Move line up / down</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>↑↓</kbd></span></div>
+						<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>
@@ -501,6 +590,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
@@ -19,6 +23,7 @@
 		getNotes,
 		readNote,
 		createNote,
+		duplicateNote,
 		deleteNote,
 		renameNote,
 		saveNote,
@@ -34,17 +39,20 @@
 		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 { encodeNoteDragPaths } from '$lib/utils/note-drag';
 	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 = () => {}, onBeforeNoteDuplicate = async () => true, 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;
+		onBeforeNoteDuplicate?: () => Promise<boolean>;
 		onNoteCreated?: () => void;
 		onToggleTask?: (t: TaskItem) => Promise<void>;
 		onSetTaskPriority?: (t: TaskItem, p: string | null) => Promise<void>;
@@ -52,8 +60,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 +149,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 +210,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!);
@@ -238,6 +268,19 @@
 		if (listContainer) listContainer.scrollTop = 0;
 	});
 
+	// Notes can also be removed from this list by a drop handled in the sidebar.
+	$effect(() => {
+		if (selectedPaths.size === 0) return;
+		const availablePaths = new Set($notes.map((note) => note.path));
+		const remaining = new Set([...selectedPaths].filter((path) => availablePaths.has(path)));
+		if (remaining.size === selectedPaths.size) return;
+		if (remaining.size === 0) {
+			clearSelection();
+		} else {
+			selectedPaths = remaining;
+		}
+	});
+
 	// Invalidate quickaccess cache when starred notes change (e.g. from Editor star toggle)
 	$effect(() => {
 		$quickAccessPaths;
@@ -382,13 +425,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')}`;
@@ -412,15 +456,49 @@
 		}
 		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);
 		}
 	}
 
+	async function handleDuplicate(note: NoteEntry) {
+		contextMenu = null;
+		try {
+			if ($activeNotePath === note.path && $editorDirty) {
+				const saved = await onBeforeNoteDuplicate();
+				if (!saved) {
+					console.error('Failed to save note before duplicating');
+					return;
+				}
+			}
+
+			const entry = await duplicateNote(note.path);
+			if ($sortMode === 'custom') appendManualNoteOrder(entry.path);
+			noteCache.clear();
+			if ($viewMode !== 'quickaccess') $notes = [entry, ...$notes];
+			await selectNote(entry);
+		} catch (e) {
+			console.error('Failed to duplicate 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;
@@ -429,6 +507,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)
@@ -450,6 +529,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);
@@ -462,6 +542,7 @@
 		}
 	}
 
+
 	async function handleRestore(note: NoteEntry) {
 		contextMenu = null;
 		try {
@@ -477,6 +558,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) {
@@ -670,11 +752,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) {
@@ -687,6 +818,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;
@@ -701,10 +845,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 {
@@ -773,6 +920,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;
@@ -808,6 +956,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;
@@ -833,6 +982,9 @@
 	}
 
 	function setSortMode(mode: SortMode) {
+		if (mode === 'custom' && Object.keys($noteOrder).length === 0) {
+			persistManualNoteOrder($sortedNotes);
+		}
 		$sortMode = mode;
 		sortMenu = null;
 	}
@@ -856,6 +1008,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">
@@ -869,7 +1031,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" />
@@ -885,8 +1054,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>
@@ -967,7 +1142,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}
@@ -1009,6 +1185,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>
@@ -1047,14 +1225,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);
@@ -1072,7 +1249,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(); }}
@@ -1099,11 +1284,16 @@
 							e.dataTransfer!.effectAllowed = 'move';
 							return;
 						}
-						if (selectedPaths.size > 1 && selectedPaths.has(note.path)) {
-							e.dataTransfer!.setData('text/plain', [...selectedPaths].join('\n'));
-						} else {
+						if (canCustomReorder) {
+							noteDragFrom = noteIndex;
 							e.dataTransfer!.setData('text/plain', note.path);
+							e.dataTransfer!.effectAllowed = 'move';
+							return;
 						}
+						const dragPaths = selectedPaths.size > 1 && selectedPaths.has(note.path)
+							? selectedPaths
+							: [note.path];
+						e.dataTransfer!.setData('text/plain', encodeNoteDragPaths(dragPaths));
 						e.dataTransfer!.effectAllowed = 'move';
 					}}
 					ondragover={(e) => {
@@ -1113,18 +1303,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}>
@@ -1175,16 +1375,40 @@
 								</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>
 
 {#if contextMenu}
-	<div class="context-menu" style="left: {contextMenu.x}px; top: {contextMenu.y}px" onclick={(e) => e.stopPropagation()} role="menu">
+	<div class="context-menu" class:mobile={isMobile} style="left: {contextMenu.x}px; top: {contextMenu.y}px" onclick={(e) => e.stopPropagation()} role="menu">
 		{#if selectedPaths.size > 1 && selectedPaths.has(contextMenu.note.path)}
 			<!-- Batch context menu -->
 			{#if $viewMode === 'trash'}
@@ -1348,12 +1572,26 @@
 				</svg>
 				Rename
 			</button>
+			<button onclick={() => handleDuplicate(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">
+					<rect x="8" y="8" width="13" height="13" rx="2"/><path d="M16 8V5a2 2 0 00-2-2H5a2 2 0 00-2 2v9a2 2 0 002 2h3"/>
+				</svg>
+				Duplicate Note
+			</button>
 			<button onclick={() => { movePickerNote = 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"/>
 				</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">
@@ -1403,6 +1641,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}
 
@@ -1464,17 +1714,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 {
@@ -1488,6 +1740,7 @@
 		text-align: left;
 		margin-bottom: 1px;
 		contain: content;
+		position: relative;
 	}
 
 	.note-item:hover {
@@ -1534,6 +1787,9 @@
 	}
 
 	.selection-action {
+		display: inline-flex;
+		align-items: center;
+		gap: 4px;
 		background: none;
 		border: 1px solid var(--border-color);
 		color: var(--text-primary);
@@ -1548,6 +1804,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));
@@ -1925,11 +2212,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);
 	}
 
@@ -1960,6 +2249,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;
@@ -2026,13 +2320,15 @@
 		border-radius: 10px;
 	}
 
-	.note-list.mobile .context-menu {
+	.context-menu.mobile {
 		min-width: 220px;
 		border-radius: 12px;
 		padding: 6px;
+		max-height: calc(100dvh - 16px);
+		overflow-y: auto;
 	}
 
-	.note-list.mobile .context-menu button {
+	.context-menu.mobile button {
 		padding: 12px 16px;
 		font-size: 15px;
 		min-height: 44px;

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', 'blueberry', 'forest-green', 'gruvbox', 'midnight-tide', 'cherry-blossom', 'synthwave', 'ember', 'moonlit', 'dark-coffee', 'crimson'];
-		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'];
+		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/NotebookGlyph.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+  import type { NotebookIconId } from '$lib/utils/notebook-icons';
+
+  let { icon, size = 18 }: { icon: NotebookIconId; size?: number } = $props();
+</script>
+
+<svg
+  width={size}
+  height={size}
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="1.8"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+  aria-hidden="true"
+>
+  {#if icon === 'book'}
+    <path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20" />
+    <path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2Z" />
+  {:else if icon === 'folder'}
+    <path d="M3 6.5A2.5 2.5 0 0 1 5.5 4H9l2 2.5h7.5A2.5 2.5 0 0 1 21 9v8.5a2.5 2.5 0 0 1-2.5 2.5h-13A2.5 2.5 0 0 1 3 17.5Z" />
+  {:else if icon === 'briefcase'}
+    <rect x="3" y="7" width="18" height="13" rx="2" />
+    <path d="M8 7V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2M3 12h18M10 12v2h4v-2" />
+  {:else if icon === 'home'}
+    <path d="m3 11 9-8 9 8" />
+    <path d="M5 10v11h14V10M9 21v-7h6v7" />
+  {:else if icon === 'star'}
+    <path d="m12 2 3.1 6.3 6.9 1-5 4.8 1.2 6.9-6.2-3.3L5.8 21 7 14.1l-5-4.8 6.9-1Z" />
+  {:else if icon === 'heart'}
+    <path d="M20.8 4.6a5.5 5.5 0 0 0-7.8 0L12 5.7l-1.1-1.1a5.5 5.5 0 0 0-7.8 7.8l1.1 1.1L12 21l7.8-7.5 1.1-1.1a5.5 5.5 0 0 0-.1-7.8Z" />
+  {:else if icon === 'lightbulb'}
+    <path d="M9 18h6M10 22h4" />
+    <path d="M8.2 15.5A7 7 0 1 1 15.8 15.5c-.7.5-.8 1.1-.8 2.5H9c0-1.4-.1-2-.8-2.5Z" />
+  {:else if icon === 'code'}
+    <path d="m8 9-4 3 4 3M16 9l4 3-4 3M14 5l-4 14" />
+  {:else if icon === 'flask'}
+    <path d="M9 3h6M10 3v6l-5.5 9.5A1.7 1.7 0 0 0 6 21h12a1.7 1.7 0 0 0 1.5-2.5L14 9V3" />
+    <path d="M7 16h10" />
+  {:else if icon === 'graduation'}
+    <path d="m2 9 10-5 10 5-10 5Z" />
+    <path d="M6 11.5V16c3.5 2.7 8.5 2.7 12 0v-4.5M22 9v6" />
+  {:else if icon === 'calendar'}
+    <rect x="3" y="5" width="18" height="16" rx="2" />
+    <path d="M16 3v4M8 3v4M3 10h18M8 14h.01M12 14h.01M16 14h.01M8 18h.01M12 18h.01" />
+  {:else if icon === 'tasks'}
+    <rect x="3" y="3" width="18" height="18" rx="2" />
+    <path d="m7 8 1.5 1.5L11 7M13 9h4M7 14l1.5 1.5L11 13M13 15h4" />
+  {:else if icon === 'archive'}
+    <path d="M4 8v12h16V8M3 4h18v4H3ZM9 12h6" />
+  {:else if icon === 'globe'}
+    <circle cx="12" cy="12" r="9" />
+    <path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18" />
+  {:else if icon === 'plane'}
+    <path d="M22 2 9.5 14.5M22 2l-7 20-4-8-8-4Z" />
+  {:else}
+    <path d="M12 3a9 9 0 1 0 0 18h1.5a1.5 1.5 0 0 0 0-3H12a1.5 1.5 0 0 1 0-3h3a6 6 0 0 0 0-12Z" />
+    <path d="M7.5 10h.01M9.5 6.5h.01M14.5 6.5h.01M17 10h.01" />
+  {/if}
+</svg>

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/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/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"/>