fix: show all direct relationship properties in note list sidebar (#182)

The GroupBuilder's `seen` set was causing direct relationship properties
to be suppressed. Reverse/computed groups (Children, Events) ran before
the entity's own relationship keys, consuming entries into `seen` and
preventing direct properties like "Belongs to" and "Notes" from appearing.

Fix: process all direct relationship keys from entity.relationships
before the reverse groups, so direct properties always take priority.

Co-authored-by: Test <test@test.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

.claude-pid

@@ -1 +1 @@
-81859
+

.github/workflows/ci.yml

@@ -60,6 +60,9 @@ jobs:
       - name: Run frontend tests
         run: pnpm test
 
+      - name: Bundle MCP server resources (required by Tauri build)
+        run: node scripts/bundle-mcp-server.mjs
+
       - name: Run Rust tests
         run: cargo test --manifest-path=src-tauri/Cargo.toml
 

.gitignore

@@ -42,3 +42,6 @@ final_selection.py
 .claude-done
 .claude-blocked
 src-tauri/target
+
+# Generated mcp-server bundle (built by scripts/bundle-mcp-server.mjs)
+src-tauri/resources/

design/themes-editable.pen

@@ -0,0 +1 @@
+{"children":[],"variables":{}}

design/trashed-note-editor.pen

@@ -0,0 +1 @@
+{"children":[{"id":"trashed-banner-frame","type":"frame","name":"Trashed Note Banner","x":0,"y":0,"width":720,"height":340,"fill":"#FFFFFF","cornerRadius":[8,8,8,8],"children":[{"id":"breadcrumb","type":"frame","name":"Breadcrumb Bar","width":720,"height":45,"fill":"#FFFFFF","layout":"horizontal","mainAxisAlignment":"space-between","crossAxisAlignment":"center","padding":16,"children":[{"id":"breadcrumb-left","type":"frame","layout":"horizontal","gap":4,"crossAxisAlignment":"center","children":[{"id":"type-label","type":"text","content":"Note","fontSize":12,"textColor":"#6B7280"},{"id":"sep","type":"text","content":"›","fontSize":12,"textColor":"#6B7280"},{"id":"title","type":"text","content":"My Trashed Note","fontSize":12,"fontWeight":"600","textColor":"#1F2937"},{"id":"dot","type":"text","content":"·","fontSize":12,"textColor":"#6B7280"},{"id":"words","type":"text","content":"1,234 words","fontSize":12,"textColor":"#6B7280"}]},{"id":"breadcrumb-right","type":"frame","layout":"horizontal","gap":12,"crossAxisAlignment":"center","children":[{"id":"restore-icon","type":"text","content":"↺","fontSize":14,"textColor":"#6B7280"},{"id":"inspector-icon","type":"text","content":"⚙","fontSize":14,"textColor":"#6B7280"}]}]},{"id":"banner","type":"frame","name":"Trashed Note Banner","width":720,"height":32,"fill":"#FEF2F2","layout":"horizontal","crossAxisAlignment":"center","gap":8,"padding":16,"children":[{"id":"trash-icon","type":"text","content":"🗑","fontSize":12,"textColor":"#DC2626"},{"id":"banner-text","type":"text","content":"This note is in the Trash","fontSize":12,"textColor":"#6B7280","width":400},{"id":"restore-btn","type":"frame","layout":"horizontal","gap":4,"crossAxisAlignment":"center","padding":4,"cornerRadius":[4,4,4,4],"children":[{"id":"restore-icon-2","type":"text","content":"↺","fontSize":11,"textColor":"#2563EB"},{"id":"restore-label","type":"text","content":"Restore","fontSize":11,"textColor":"#2563EB"}]},{"id":"delete-btn","type":"frame","layout":"horizontal","gap":4,"crossAxisAlignment":"center","padding":4,"cornerRadius":[4,4,4,4],"children":[{"id":"delete-icon","type":"text","content":"🗑","fontSize":11,"textColor":"#DC2626"},{"id":"delete-label","type":"text","content":"Delete permanently","fontSize":11,"textColor":"#DC2626"}]}]},{"id":"editor-area","type":"frame","name":"Editor (read-only, muted)","width":720,"height":260,"fill":"#FAFAFA","padding":32,"children":[{"id":"h1","type":"text","content":"My Trashed Note","fontSize":24,"fontWeight":"700","textColor":"#9CA3AF"},{"id":"p1","type":"text","content":"This is the content of a trashed note. The editor is non-editable.","fontSize":14,"textColor":"#9CA3AF","y":40},{"id":"p2","type":"text","content":"Navigation and copy still work, but typing and editing are disabled.","fontSize":14,"textColor":"#9CA3AF","y":64}]}]}],"variables":{}}

e2e/core-flows.spec.ts

@@ -231,3 +231,30 @@ test('full create note flow', async ({ page }) => {
 
   await page.screenshot({ path: 'test-results/core-create-note.png', fullPage: true })
 })
+
+// --- Flow 8: Wiki-link navigation ---
+
+test('clicking a wikilink opens the target note in a new tab', async ({ page }) => {
+  // Open "Manage Sponsorships" which contains [[Matteo Cellini]] wikilink
+  await page.locator('.note-list__item', { hasText: 'Manage Sponsorships' }).click()
+  await page.waitForTimeout(300)
+
+  // Verify we opened the right note
+  await expect(page.locator('.editor__tab--active')).toHaveText(/Manage Sponsorships/)
+
+  // Click the wikilink — use mouse.click to fire real mousedown
+  const wikilink = page.locator('.cm-wikilink', { hasText: 'Matteo Cellini' })
+  await expect(wikilink).toBeVisible()
+  const box = await wikilink.boundingBox()
+  expect(box).not.toBeNull()
+  await page.mouse.click(box!.x + box!.width / 2, box!.y + box!.height / 2)
+  await page.waitForTimeout(300)
+
+  // New tab should open with the target note active
+  await expect(page.locator('.editor__tab--active')).toHaveText(/Matteo Cellini/)
+
+  // Editor should show the target note's content
+  await expect(page.locator('.cm-content')).toContainText('Matteo Cellini')
+
+  await page.screenshot({ path: 'test-results/core-wikilink-nav.png', fullPage: true })
+})

eslint.config.js

@@ -6,7 +6,7 @@ import tseslint from 'typescript-eslint'
 import { defineConfig, globalIgnores } from 'eslint/config'
 
 export default defineConfig([
-  globalIgnores(['dist', 'coverage']),
+  globalIgnores(['dist', 'coverage', 'src-tauri/resources/', 'src-tauri/target/']),
   {
     files: ['**/*.{ts,tsx}'],
     extends: [

package.json

@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc -b && vite build",
+    "bundle-mcp": "node scripts/bundle-mcp-server.mjs",
     "lint": "eslint .",
     "preview": "vite preview",
     "tauri": "tauri",
@@ -64,6 +65,7 @@
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.1.1",
     "@vitest/coverage-v8": "^4.0.18",
+    "esbuild": "^0.27.3",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",

pnpm-workspace.yaml

@@ -1,2 +1,5 @@
+packages:
+  - mcp-server
+
 ignoredBuiltDependencies:
   - esbuild

scripts/bundle-mcp-server.mjs

@@ -0,0 +1,45 @@
+/**
+ * Bundle the mcp-server Node.js files into self-contained CJS bundles
+ * that can be shipped as Tauri resources inside the .app bundle.
+ *
+ * Output: src-tauri/resources/mcp-server/{index.js,ws-bridge.js}
+ */
+import { build } from 'esbuild'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import { mkdirSync, writeFileSync } from 'fs'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ROOT = join(__dirname, '..')
+const SRC = join(ROOT, 'mcp-server')
+const OUT = join(ROOT, 'src-tauri', 'resources', 'mcp-server')
+
+mkdirSync(OUT, { recursive: true })
+
+// Tell Node.js that this directory contains CJS bundles, even if the
+// root package.json declares "type": "module".
+writeFileSync(join(OUT, 'package.json'), JSON.stringify({ type: 'commonjs' }))
+
+const shared = {
+  platform: 'node',
+  bundle: true,
+  format: 'cjs',
+  target: 'node18',
+  // Mark optional native bindings as external — ws works fine without them
+  external: ['bufferutil', 'utf-8-validate'],
+  logLevel: 'warning',
+}
+
+await build({
+  ...shared,
+  entryPoints: [join(SRC, 'index.js')],
+  outfile: join(OUT, 'index.js'),
+})
+
+await build({
+  ...shared,
+  entryPoints: [join(SRC, 'ws-bridge.js')],
+  outfile: join(OUT, 'ws-bridge.js'),
+})
+
+console.log('mcp-server bundled → src-tauri/resources/mcp-server/')

src-tauri/src/lib.rs

@@ -9,6 +9,7 @@ pub mod search;
 pub mod settings;
 pub mod theme;
 pub mod vault;
+pub mod vault_list;
 
 use std::borrow::Cow;
 use std::path::Path;
@@ -24,6 +25,7 @@ use search::SearchResponse;
 use settings::Settings;
 use theme::{ThemeFile, VaultSettings};
 use vault::{RenameResult, VaultEntry};
+use vault_list::VaultList;
 
 /// Expand a leading `~` or `~/` in a path string to the user's home directory.
 /// Returns the original string unchanged if it doesn't start with `~` or if the
@@ -114,10 +116,7 @@ fn git_commit(vault_path: String, message: String) -> Result<String, String> {
 
 #[tauri::command]
 fn get_build_number() -> String {
-    {
-        let n = std::env::var("BUILD_NUMBER").unwrap_or_else(|_| "0".to_string());
-        format!("b{}", n)
-    }
+    format!("b{}", env!("BUILD_NUMBER"))
 }
 
 #[tauri::command]
@@ -207,6 +206,12 @@ fn purge_trash(vault_path: String) -> Result<Vec<String>, String> {
     vault::purge_trash(&vault_path)
 }
 
+#[tauri::command]
+fn delete_note(path: String) -> Result<String, String> {
+    let path = expand_tilde(&path);
+    vault::delete_note(&path)
+}
+
 #[tauri::command]
 fn migrate_is_a_to_type(vault_path: String) -> Result<usize, String> {
     let vault_path = expand_tilde(&vault_path);
@@ -277,6 +282,16 @@ fn save_settings(settings: Settings) -> Result<(), String> {
     settings::save_settings(settings)
 }
 
+#[tauri::command]
+fn load_vault_list() -> Result<VaultList, String> {
+    vault_list::load_vault_list()
+}
+
+#[tauri::command]
+fn save_vault_list(list: VaultList) -> Result<(), String> {
+    vault_list::save_vault_list(&list)
+}
+
 #[tauri::command]
 async fn github_list_repos(token: String) -> Result<Vec<GithubRepo>, String> {
     github::github_list_repos(&token).await
@@ -372,6 +387,12 @@ fn create_theme(vault_path: String, source_id: Option<String>) -> Result<String,
     theme::create_theme(&vault_path, source_id.as_deref())
 }
 
+#[tauri::command]
+fn create_vault_theme(vault_path: String, name: Option<String>) -> Result<String, String> {
+    let vault_path = expand_tilde(&vault_path);
+    theme::create_vault_theme(&vault_path, name.as_deref())
+}
+
 fn log_startup_result(label: &str, result: Result<usize, String>) {
     match result {
         Ok(n) if n > 0 => log::info!("{}: {} files", label, n),
@@ -398,8 +419,10 @@ fn run_startup_tasks() {
         vault::migrate_is_a_to_type(vp_str),
     );
 
-    // Seed _themes/ with built-in themes if missing
+    // Seed _themes/ with built-in JSON themes (legacy) if missing
     theme::seed_default_themes(vp_str);
+    // Seed theme/ with built-in vault theme notes if missing
+    theme::seed_vault_themes(vp_str);
 
     // Register Laputa MCP server in Claude Code and Cursor configs
     match mcp::register_mcp(vp_str) {
@@ -452,6 +475,22 @@ mod tests {
             "expected 'b' prefix, got: {}",
             result
         );
+        assert_ne!(result, "b0", "build number should not fall back to 0");
+    }
+}
+
+fn spawn_ws_bridge(app: &mut tauri::App) {
+    use tauri::Manager;
+    let vault_path = dirs::home_dir()
+        .map(|h| h.join("Laputa"))
+        .unwrap_or_default();
+    let vp_str = vault_path.to_string_lossy().to_string();
+    match mcp::spawn_ws_bridge(&vp_str) {
+        Ok(child) => {
+            let state: tauri::State<'_, WsBridgeChild> = app.state();
+            *state.0.lock().unwrap() = Some(child);
+        }
+        Err(e) => log::warn!("Failed to start ws-bridge: {}", e),
     }
 }
 
@@ -485,23 +524,7 @@ pub fn run() {
             }
 
             run_startup_tasks();
-
-            // Spawn the MCP WebSocket bridge for the default vault
-            {
-                use tauri::Manager;
-                let vault_path = dirs::home_dir()
-                    .map(|h| h.join("Laputa"))
-                    .unwrap_or_default();
-                let vp_str = vault_path.to_string_lossy().to_string();
-                match mcp::spawn_ws_bridge(&vp_str) {
-                    Ok(child) => {
-                        let state: tauri::State<'_, WsBridgeChild> = app.state();
-                        *state.0.lock().unwrap() = Some(child);
-                    }
-                    Err(e) => log::warn!("Failed to start ws-bridge: {}", e),
-                }
-            }
-
+            spawn_ws_bridge(app);
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
@@ -527,12 +550,15 @@ pub fn run() {
             save_image,
             copy_image_to_vault,
             purge_trash,
+            delete_note,
             migrate_is_a_to_type,
             batch_archive_notes,
             batch_trash_notes,
             get_settings,
             update_menu_state,
             save_settings,
+            load_vault_list,
+            save_vault_list,
             github_list_repos,
             github_create_repo,
             clone_repo,
@@ -549,7 +575,8 @@ pub fn run() {
             get_vault_settings,
             save_vault_settings,
             set_active_theme,
-            create_theme
+            create_theme,
+            create_vault_theme
         ])
         .build(tauri::generate_context!())
         .expect("error while building tauri application")

src-tauri/src/mcp.rs

@@ -27,10 +27,12 @@ pub(crate) fn mcp_server_dir() -> Result<PathBuf, String> {
     }
 
     let exe = std::env::current_exe().map_err(|e| format!("Cannot find executable: {e}"))?;
+    // On macOS the exe lives at Contents/MacOS/<binary>.
+    // Resources are placed at Contents/Resources/ by Tauri.
     let release_path = exe
         .parent()
         .and_then(|p| p.parent())
-        .map(|p| p.join("mcp-server"))
+        .map(|p| p.join("Resources").join("mcp-server"))
         .ok_or_else(|| "Cannot resolve mcp-server directory".to_string())?;
     if release_path.join("ws-bridge.js").exists() {
         return Ok(release_path);

src-tauri/src/settings.rs

@@ -71,6 +71,36 @@ pub fn save_settings(settings: Settings) -> Result<(), String> {
     save_settings_at(&settings_path()?, settings)
 }
 
+fn last_vault_file() -> Result<PathBuf, String> {
+    dirs::config_dir()
+        .map(|d| d.join("com.laputa.app").join("last-vault.txt"))
+        .ok_or_else(|| "Could not determine config directory".to_string())
+}
+
+fn get_last_vault_at(path: &PathBuf) -> Option<String> {
+    fs::read_to_string(path)
+        .ok()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+}
+
+fn set_last_vault_at(path: &PathBuf, vault_path: &str) -> Result<(), String> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create config directory: {}", e))?;
+    }
+    fs::write(path, vault_path.trim())
+        .map_err(|e| format!("Failed to write last vault path: {}", e))
+}
+
+pub fn get_last_vault() -> Option<String> {
+    last_vault_file().ok().and_then(|p| get_last_vault_at(&p))
+}
+
+pub fn set_last_vault(vault_path: &str) -> Result<(), String> {
+    set_last_vault_at(&last_vault_file()?, vault_path)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -199,4 +229,65 @@ mod tests {
         assert!(result.is_ok());
         assert!(result.unwrap().to_str().unwrap().contains("com.laputa.app"));
     }
+
+    #[test]
+    fn test_get_last_vault_returns_none_for_missing_file() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("last-vault.txt");
+        assert!(get_last_vault_at(&path).is_none());
+    }
+
+    #[test]
+    fn test_set_and_get_last_vault_roundtrip() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("last-vault.txt");
+        set_last_vault_at(&path, "/Users/test/MyVault").unwrap();
+        assert_eq!(
+            get_last_vault_at(&path).as_deref(),
+            Some("/Users/test/MyVault")
+        );
+    }
+
+    #[test]
+    fn test_set_last_vault_trims_whitespace() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("last-vault.txt");
+        set_last_vault_at(&path, "  /Users/test/Vault  ").unwrap();
+        assert_eq!(
+            get_last_vault_at(&path).as_deref(),
+            Some("/Users/test/Vault")
+        );
+    }
+
+    #[test]
+    fn test_get_last_vault_returns_none_for_empty_file() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("last-vault.txt");
+        fs::write(&path, "   \n  ").unwrap();
+        assert!(get_last_vault_at(&path).is_none());
+    }
+
+    #[test]
+    fn test_set_last_vault_creates_parent_directories() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("nested").join("dir").join("last-vault.txt");
+        set_last_vault_at(&path, "/Users/test/Vault").unwrap();
+        assert!(path.exists());
+        assert_eq!(
+            get_last_vault_at(&path).as_deref(),
+            Some("/Users/test/Vault")
+        );
+    }
+
+    #[test]
+    fn test_set_last_vault_overwrites_previous() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("last-vault.txt");
+        set_last_vault_at(&path, "/Users/test/OldVault").unwrap();
+        set_last_vault_at(&path, "/Users/test/NewVault").unwrap();
+        assert_eq!(
+            get_last_vault_at(&path).as_deref(),
+            Some("/Users/test/NewVault")
+        );
+    }
 }

src-tauri/src/theme.rs

@@ -116,20 +116,112 @@ pub fn get_theme(vault_path: &str, theme_id: &str) -> Result<ThemeFile, String>
     parse_theme_file(&path)
 }
 
+/// Create `dir` and write each `(filename, content)` pair if the directory doesn't exist yet.
+fn seed_dir_with_files(dir: &Path, files: &[(&str, &str)], log_msg: &str) {
+    if dir.is_dir() {
+        return;
+    }
+    if fs::create_dir_all(dir).is_err() {
+        return;
+    }
+    for (name, content) in files {
+        let _ = fs::write(dir.join(name), content);
+    }
+    log::info!("{log_msg}");
+}
+
 /// Seed the `_themes/` directory with built-in themes if it doesn't exist yet.
 /// Safe to call multiple times — only writes files that are missing.
 pub fn seed_default_themes(vault_path: &str) {
-    let themes_dir = Path::new(vault_path).join("_themes");
-    if themes_dir.is_dir() {
-        return;
+    seed_dir_with_files(
+        &Path::new(vault_path).join("_themes"),
+        &[
+            ("default.json", DEFAULT_THEME),
+            ("dark.json", DARK_THEME),
+            ("minimal.json", MINIMAL_THEME),
+        ],
+        "Seeded _themes/ with built-in themes",
+    );
+}
+
+/// Seed the vault `theme/` directory with built-in vault-based theme notes.
+/// Safe to call multiple times — only writes files that are missing.
+pub fn seed_vault_themes(vault_path: &str) {
+    seed_dir_with_files(
+        &Path::new(vault_path).join("theme"),
+        &[
+            ("default.md", DEFAULT_VAULT_THEME),
+            ("dark.md", DARK_VAULT_THEME),
+            ("minimal.md", MINIMAL_VAULT_THEME),
+        ],
+        "Seeded theme/ with built-in vault themes",
+    );
+}
+
+/// Create a new vault theme note in `theme/` directory.
+/// Returns the absolute path to the newly created theme note.
+pub fn create_vault_theme(vault_path: &str, name: Option<&str>) -> Result<String, String> {
+    let theme_dir = Path::new(vault_path).join("theme");
+    fs::create_dir_all(&theme_dir).map_err(|e| format!("Failed to create theme directory: {e}"))?;
+
+    let display_name = name.unwrap_or("Untitled Theme");
+    let slug = slugify(display_name);
+    let filename = format!("{}.md", find_available_stem(&theme_dir, &slug, "md"));
+    let path = theme_dir.join(&filename);
+
+    let content = vault_theme_note_content(display_name, &DEFAULT_VAULT_THEME_VARS);
+    fs::write(&path, content).map_err(|e| format!("Failed to write theme note: {e}"))?;
+
+    Ok(path.to_string_lossy().to_string())
+}
+
+/// Convert a display name to a URL-safe slug.
+fn slugify(name: &str) -> String {
+    name.chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() {
+                c.to_ascii_lowercase()
+            } else {
+                '-'
+            }
+        })
+        .collect::<String>()
+        .split('-')
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>()
+        .join("-")
+}
+
+/// Find an available filename stem (base, base-2, base-3, …) that doesn't conflict when `ext` is appended.
+fn find_available_stem(dir: &Path, base: &str, ext: &str) -> String {
+    if !dir.join(format!("{base}.{ext}")).exists() {
+        return base.to_string();
     }
-    if fs::create_dir_all(&themes_dir).is_err() {
-        return;
+    for i in 2.. {
+        let candidate = format!("{base}-{i}");
+        if !dir.join(format!("{candidate}.{ext}")).exists() {
+            return candidate;
+        }
     }
-    let _ = fs::write(themes_dir.join("default.json"), DEFAULT_THEME);
-    let _ = fs::write(themes_dir.join("dark.json"), DARK_THEME);
-    let _ = fs::write(themes_dir.join("minimal.json"), MINIMAL_THEME);
-    log::info!("Seeded _themes/ with built-in themes");
+    unreachable!()
+}
+
+/// Build a vault theme note markdown string from a name and CSS variable map.
+fn vault_theme_note_content(name: &str, vars: &[(&str, &str)]) -> String {
+    let mut fm = format!("---\nIs A: Theme\nDescription: {name} theme\n");
+    for (key, value) in vars {
+        // Values with '#' or spaces need quoting; others can be bare strings.
+        if value.contains('#') || value.contains('\'') || value.contains(',') {
+            fm.push_str(&format!("{key}: \"{value}\"\n"));
+        } else {
+            fm.push_str(&format!("{key}: {value}\n"));
+        }
+    }
+    fm.push_str("---\n\n");
+    fm.push_str(&format!(
+        "# {name} Theme\n\nA custom {name} theme for Laputa.\n"
+    ));
+    fm
 }
 
 /// Create a new theme file by copying the active theme (or default).
@@ -139,7 +231,7 @@ pub fn create_theme(vault_path: &str, source_id: Option<&str>) -> Result<String,
     fs::create_dir_all(&themes_dir)
         .map_err(|e| format!("Failed to create _themes directory: {e}"))?;
 
-    let new_id = find_available_id(&themes_dir, "untitled");
+    let new_id = find_available_stem(&themes_dir, "untitled", "json");
 
     let source = source_id.unwrap_or("default");
     let source_path = themes_dir.join(format!("{source}.json"));
@@ -169,20 +261,6 @@ pub fn create_theme(vault_path: &str, source_id: Option<&str>) -> Result<String,
     Ok(new_id)
 }
 
-/// Find a filename that doesn't conflict (untitled, untitled-2, untitled-3, ...).
-fn find_available_id(dir: &Path, base: &str) -> String {
-    if !dir.join(format!("{base}.json")).exists() {
-        return base.to_string();
-    }
-    for i in 2.. {
-        let candidate = format!("{base}-{i}");
-        if !dir.join(format!("{candidate}.json")).exists() {
-            return candidate;
-        }
-    }
-    unreachable!()
-}
-
 /// Generate the default light theme JSON.
 fn default_theme_json(name: &str) -> String {
     serde_json::to_string_pretty(&serde_json::json!({
@@ -312,6 +390,233 @@ pub const MINIMAL_THEME: &str = r##"{
   }
 }"##;
 
+/// CSS variable key-value pairs for the default light vault theme.
+pub const DEFAULT_VAULT_THEME_VARS: [(&str, &str); 46] = [
+    // shadcn/ui base
+    ("background", "#FFFFFF"),
+    ("foreground", "#37352F"),
+    ("card", "#FFFFFF"),
+    ("popover", "#FFFFFF"),
+    ("primary", "#155DFF"),
+    ("primary-foreground", "#FFFFFF"),
+    ("secondary", "#EBEBEA"),
+    ("secondary-foreground", "#37352F"),
+    ("muted", "#F0F0EF"),
+    ("muted-foreground", "#787774"),
+    ("accent", "#EBEBEA"),
+    ("accent-foreground", "#37352F"),
+    ("destructive", "#E03E3E"),
+    ("border", "#E9E9E7"),
+    ("input", "#E9E9E7"),
+    ("ring", "#155DFF"),
+    ("sidebar", "#F7F6F3"),
+    ("sidebar-foreground", "#37352F"),
+    ("sidebar-border", "#E9E9E7"),
+    ("sidebar-accent", "#EBEBEA"),
+    // Text hierarchy
+    ("text-primary", "#37352F"),
+    ("text-secondary", "#787774"),
+    ("text-muted", "#B4B4B4"),
+    ("text-heading", "#37352F"),
+    // Backgrounds
+    ("bg-primary", "#FFFFFF"),
+    ("bg-sidebar", "#F7F6F3"),
+    ("bg-hover", "#EBEBEA"),
+    ("bg-hover-subtle", "#F0F0EF"),
+    ("bg-selected", "#E8F4FE"),
+    ("border-primary", "#E9E9E7"),
+    // Accent colours
+    ("accent-blue", "#155DFF"),
+    ("accent-green", "#00B38B"),
+    ("accent-orange", "#D9730D"),
+    ("accent-red", "#E03E3E"),
+    ("accent-purple", "#A932FF"),
+    ("accent-yellow", "#F0B100"),
+    ("accent-blue-light", "#155DFF14"),
+    ("accent-green-light", "#00B38B14"),
+    ("accent-purple-light", "#A932FF14"),
+    ("accent-red-light", "#E03E3E14"),
+    ("accent-yellow-light", "#F0B10014"),
+    // Typography
+    (
+        "font-family",
+        "'Inter', -apple-system, BlinkMacSystemFont, sans-serif",
+    ),
+    ("font-size-base", "14px"),
+    // Editor
+    ("editor-font-size", "16"),
+    ("editor-line-height", "1.5"),
+    ("editor-max-width", "720"),
+];
+
+/// Vault-based theme note for the built-in Default theme.
+pub const DEFAULT_VAULT_THEME: &str = "---\n\
+Is A: Theme\n\
+Description: Light theme with warm, paper-like tones\n\
+background: \"#FFFFFF\"\n\
+foreground: \"#37352F\"\n\
+card: \"#FFFFFF\"\n\
+popover: \"#FFFFFF\"\n\
+primary: \"#155DFF\"\n\
+primary-foreground: \"#FFFFFF\"\n\
+secondary: \"#EBEBEA\"\n\
+secondary-foreground: \"#37352F\"\n\
+muted: \"#F0F0EF\"\n\
+muted-foreground: \"#787774\"\n\
+accent: \"#EBEBEA\"\n\
+accent-foreground: \"#37352F\"\n\
+destructive: \"#E03E3E\"\n\
+border: \"#E9E9E7\"\n\
+input: \"#E9E9E7\"\n\
+ring: \"#155DFF\"\n\
+sidebar: \"#F7F6F3\"\n\
+sidebar-foreground: \"#37352F\"\n\
+sidebar-border: \"#E9E9E7\"\n\
+sidebar-accent: \"#EBEBEA\"\n\
+text-primary: \"#37352F\"\n\
+text-secondary: \"#787774\"\n\
+text-muted: \"#B4B4B4\"\n\
+text-heading: \"#37352F\"\n\
+bg-primary: \"#FFFFFF\"\n\
+bg-sidebar: \"#F7F6F3\"\n\
+bg-hover: \"#EBEBEA\"\n\
+bg-hover-subtle: \"#F0F0EF\"\n\
+bg-selected: \"#E8F4FE\"\n\
+border-primary: \"#E9E9E7\"\n\
+accent-blue: \"#155DFF\"\n\
+accent-green: \"#00B38B\"\n\
+accent-orange: \"#D9730D\"\n\
+accent-red: \"#E03E3E\"\n\
+accent-purple: \"#A932FF\"\n\
+accent-yellow: \"#F0B100\"\n\
+accent-blue-light: \"#155DFF14\"\n\
+accent-green-light: \"#00B38B14\"\n\
+accent-purple-light: \"#A932FF14\"\n\
+accent-red-light: \"#E03E3E14\"\n\
+accent-yellow-light: \"#F0B10014\"\n\
+font-family: \"'Inter', -apple-system, BlinkMacSystemFont, sans-serif\"\n\
+font-size-base: 14px\n\
+editor-font-size: 16\n\
+editor-line-height: 1.5\n\
+editor-max-width: 720\n\
+---\n\
+\n\
+# Default Theme\n\
+\n\
+The default light theme for Laputa. Clean and warm, inspired by Notion.\n";
+
+/// Vault-based theme note for the built-in Dark theme.
+pub const DARK_VAULT_THEME: &str = "---\n\
+Is A: Theme\n\
+Description: Dark variant with deep navy tones\n\
+background: \"#0f0f1a\"\n\
+foreground: \"#e0e0e0\"\n\
+card: \"#16162a\"\n\
+popover: \"#1e1e3a\"\n\
+primary: \"#155DFF\"\n\
+primary-foreground: \"#FFFFFF\"\n\
+secondary: \"#2a2a4a\"\n\
+secondary-foreground: \"#e0e0e0\"\n\
+muted: \"#1e1e3a\"\n\
+muted-foreground: \"#888888\"\n\
+accent: \"#2a2a4a\"\n\
+accent-foreground: \"#e0e0e0\"\n\
+destructive: \"#f44336\"\n\
+border: \"#2a2a4a\"\n\
+input: \"#2a2a4a\"\n\
+ring: \"#155DFF\"\n\
+sidebar: \"#1a1a2e\"\n\
+sidebar-foreground: \"#e0e0e0\"\n\
+sidebar-border: \"#2a2a4a\"\n\
+sidebar-accent: \"#2a2a4a\"\n\
+text-primary: \"#e0e0e0\"\n\
+text-secondary: \"#888888\"\n\
+text-muted: \"#666666\"\n\
+text-heading: \"#e0e0e0\"\n\
+bg-primary: \"#0f0f1a\"\n\
+bg-sidebar: \"#1a1a2e\"\n\
+bg-hover: \"#2a2a4a\"\n\
+bg-hover-subtle: \"#1e1e3a\"\n\
+bg-selected: \"#155DFF22\"\n\
+border-primary: \"#2a2a4a\"\n\
+accent-blue: \"#155DFF\"\n\
+accent-green: \"#00B38B\"\n\
+accent-orange: \"#D9730D\"\n\
+accent-red: \"#f44336\"\n\
+accent-purple: \"#A932FF\"\n\
+accent-yellow: \"#F0B100\"\n\
+accent-blue-light: \"#155DFF33\"\n\
+accent-green-light: \"#00B38B33\"\n\
+accent-purple-light: \"#A932FF33\"\n\
+accent-red-light: \"#f4433633\"\n\
+accent-yellow-light: \"#F0B10033\"\n\
+font-family: \"'Inter', -apple-system, BlinkMacSystemFont, sans-serif\"\n\
+font-size-base: 14px\n\
+editor-font-size: 16\n\
+editor-line-height: 1.5\n\
+editor-max-width: 720\n\
+---\n\
+\n\
+# Dark Theme\n\
+\n\
+A dark theme with deep navy tones for comfortable night-time reading.\n";
+
+/// Vault-based theme note for the built-in Minimal theme.
+pub const MINIMAL_VAULT_THEME: &str = "---\n\
+Is A: Theme\n\
+Description: High contrast, minimal chrome\n\
+background: \"#FAFAFA\"\n\
+foreground: \"#111111\"\n\
+card: \"#FFFFFF\"\n\
+popover: \"#FFFFFF\"\n\
+primary: \"#000000\"\n\
+primary-foreground: \"#FFFFFF\"\n\
+secondary: \"#F0F0F0\"\n\
+secondary-foreground: \"#111111\"\n\
+muted: \"#F5F5F5\"\n\
+muted-foreground: \"#666666\"\n\
+accent: \"#F0F0F0\"\n\
+accent-foreground: \"#111111\"\n\
+destructive: \"#CC0000\"\n\
+border: \"#E0E0E0\"\n\
+input: \"#E0E0E0\"\n\
+ring: \"#000000\"\n\
+sidebar: \"#F5F5F5\"\n\
+sidebar-foreground: \"#111111\"\n\
+sidebar-border: \"#E0E0E0\"\n\
+sidebar-accent: \"#E8E8E8\"\n\
+text-primary: \"#111111\"\n\
+text-secondary: \"#666666\"\n\
+text-muted: \"#999999\"\n\
+text-heading: \"#111111\"\n\
+bg-primary: \"#FAFAFA\"\n\
+bg-sidebar: \"#F5F5F5\"\n\
+bg-hover: \"#EBEBEB\"\n\
+bg-hover-subtle: \"#F5F5F5\"\n\
+bg-selected: \"#00000014\"\n\
+border-primary: \"#E0E0E0\"\n\
+accent-blue: \"#000000\"\n\
+accent-green: \"#006600\"\n\
+accent-orange: \"#996600\"\n\
+accent-red: \"#CC0000\"\n\
+accent-purple: \"#660099\"\n\
+accent-yellow: \"#996600\"\n\
+accent-blue-light: \"#00000014\"\n\
+accent-green-light: \"#00660014\"\n\
+accent-purple-light: \"#66009914\"\n\
+accent-red-light: \"#CC000014\"\n\
+accent-yellow-light: \"#99660014\"\n\
+font-family: \"'SF Mono', 'Menlo', monospace\"\n\
+font-size-base: 13px\n\
+editor-font-size: 15\n\
+editor-line-height: 1.6\n\
+editor-max-width: 680\n\
+---\n\
+\n\
+# Minimal Theme\n\
+\n\
+High contrast, minimal chrome. Monospace typography throughout.\n";
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -462,4 +767,88 @@ mod tests {
         let themes = list_themes(&vault).unwrap();
         assert_eq!(themes.len(), 2); // broken.json is skipped
     }
+
+    #[test]
+    fn test_seed_vault_themes_creates_theme_dir() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        fs::create_dir_all(&vault).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        assert!(!vault.join("theme").exists());
+        seed_vault_themes(vp);
+        assert!(vault.join("theme").is_dir());
+        assert!(vault.join("theme").join("default.md").exists());
+        assert!(vault.join("theme").join("dark.md").exists());
+        assert!(vault.join("theme").join("minimal.md").exists());
+    }
+
+    #[test]
+    fn test_seed_vault_themes_is_idempotent() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        fs::create_dir_all(&vault).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        seed_vault_themes(vp);
+        seed_vault_themes(vp); // second call should be a no-op
+        assert!(vault.join("theme").join("default.md").exists());
+    }
+
+    #[test]
+    fn test_create_vault_theme_creates_md_file() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        fs::create_dir_all(&vault).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        let path = create_vault_theme(vp, Some("My Theme")).unwrap();
+        assert!(std::path::Path::new(&path).exists());
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.contains("Is A: Theme"));
+        assert!(content.contains("# My Theme"));
+        assert!(content.contains("background:"));
+    }
+
+    #[test]
+    fn test_create_vault_theme_default_name() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        fs::create_dir_all(&vault).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        let path = create_vault_theme(vp, None).unwrap();
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.contains("# Untitled Theme"));
+    }
+
+    #[test]
+    fn test_create_vault_theme_avoids_conflicts() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        fs::create_dir_all(&vault).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        let p1 = create_vault_theme(vp, Some("Custom")).unwrap();
+        let p2 = create_vault_theme(vp, Some("Custom")).unwrap();
+        assert_ne!(p1, p2);
+    }
+
+    #[test]
+    fn test_slugify() {
+        assert_eq!(slugify("My Cool Theme"), "my-cool-theme");
+        assert_eq!(slugify("default"), "default");
+        assert_eq!(slugify("Dark Mode!"), "dark-mode");
+    }
+
+    #[test]
+    fn test_vault_theme_content_contains_all_vars() {
+        let content = DEFAULT_VAULT_THEME;
+        assert!(content.contains("background:"));
+        assert!(content.contains("primary:"));
+        assert!(content.contains("sidebar:"));
+        assert!(content.contains("text-primary:"));
+        assert!(content.contains("accent-blue:"));
+        assert!(content.contains("editor-font-size:"));
+    }
 }

src-tauri/src/vault/cache.rs

@@ -7,12 +7,16 @@ use super::{parse_md_file, scan_vault, VaultEntry};
 // --- Vault Cache ---
 
 /// Bump this when VaultEntry fields change to force a full rescan.
-const CACHE_VERSION: u32 = 2;
+const CACHE_VERSION: u32 = 3;
 
 #[derive(Debug, Serialize, Deserialize)]
 struct VaultCache {
     #[serde(default = "default_cache_version")]
     version: u32,
+    /// The vault path when the cache was written. Used to detect stale caches
+    /// from a different machine or a moved vault directory.
+    #[serde(default)]
+    vault_path: String,
     commit_hash: String,
     entries: Vec<VaultEntry>,
 }
@@ -50,11 +54,6 @@ fn parse_porcelain_line(line: &str) -> Option<(&str, String)> {
     Some((&line[..2], line[3..].trim().to_string()))
 }
 
-/// Check if a porcelain status indicates a new/untracked file.
-fn is_new_file_status(status: &str) -> bool {
-    status == "??" || status.starts_with('A')
-}
-
 /// Extract .md file paths from git diff --name-only output.
 fn collect_md_paths_from_diff(stdout: &str) -> Vec<String> {
     stdout
@@ -80,11 +79,15 @@ fn git_changed_files(vault: &Path, from_hash: &str, to_hash: &str) -> Vec<String
         .map(|s| collect_md_paths_from_diff(&s))
         .unwrap_or_default();
 
-    let uncommitted = run_git(vault, &["status", "--porcelain"])
+    // Use ls-files for untracked files so that newly-seeded directories are picked up
+    // as individual files rather than as a single "?? dirname/" entry.
+    let uncommitted = git_uncommitted_files(vault);
+    // Also include modified-but-unstaged files via status --porcelain.
+    let modified = run_git(vault, &["status", "--porcelain"])
         .map(|s| collect_md_paths_from_porcelain(&s))
         .unwrap_or_default();
 
-    for path in uncommitted {
+    for path in uncommitted.into_iter().chain(modified) {
         if !files.contains(&path) {
             files.push(path);
         }
@@ -93,17 +96,10 @@ fn git_changed_files(vault: &Path, from_hash: &str, to_hash: &str) -> Vec<String
     files
 }
 
-fn git_uncommitted_new_files(vault: &Path) -> Vec<String> {
-    let stdout = match run_git(vault, &["status", "--porcelain"]) {
-        Some(s) => s,
-        None => return Vec::new(),
-    };
-    stdout
-        .lines()
-        .filter_map(parse_porcelain_line)
-        .filter(|(status, path)| path.ends_with(".md") && is_new_file_status(status))
-        .map(|(_, path)| path)
-        .collect()
+fn git_uncommitted_files(vault: &Path) -> Vec<String> {
+    run_git(vault, &["status", "--porcelain"])
+        .map(|s| collect_md_paths_from_porcelain(&s))
+        .unwrap_or_default()
 }
 
 fn load_cache(vault: &Path) -> Option<VaultCache> {
@@ -115,6 +111,7 @@ fn write_cache(vault: &Path, cache: &VaultCache) {
     if let Ok(data) = serde_json::to_string(cache) {
         let _ = fs::write(cache_path(vault), data);
     }
+    ensure_cache_excluded(vault);
 }
 
 /// Normalize an absolute path to a relative path for comparison with git output.
@@ -143,6 +140,23 @@ fn parse_files_at(vault: &Path, rel_paths: &[String]) -> Vec<VaultEntry> {
         .collect()
 }
 
+/// Ensure `.laputa-cache.json` is excluded from git via `.git/info/exclude`.
+/// This prevents the cache (which contains machine-specific absolute paths)
+/// from being committed and causing stale-path bugs on cloned vaults.
+fn ensure_cache_excluded(vault: &Path) {
+    let exclude_path = vault.join(".git/info/exclude");
+    let entry = ".laputa-cache.json";
+    if let Ok(content) = fs::read_to_string(&exclude_path) {
+        if content.lines().any(|line| line.trim() == entry) {
+            return;
+        }
+        let separator = if content.ends_with('\n') { "" } else { "\n" };
+        let _ = fs::write(&exclude_path, format!("{content}{separator}{entry}\n"));
+    } else if exclude_path.parent().map(|p| p.is_dir()).unwrap_or(false) {
+        let _ = fs::write(&exclude_path, format!("{entry}\n"));
+    }
+}
+
 /// Sort entries by modified_at descending and write the cache.
 fn finalize_and_cache(vault: &Path, mut entries: Vec<VaultEntry>, hash: String) -> Vec<VaultEntry> {
     entries.sort_by(|a, b| b.modified_at.cmp(&a.modified_at));
@@ -150,6 +164,7 @@ fn finalize_and_cache(vault: &Path, mut entries: Vec<VaultEntry>, hash: String)
         vault,
         &VaultCache {
             version: CACHE_VERSION,
+            vault_path: vault.to_string_lossy().to_string(),
             commit_hash: hash,
             entries: entries.clone(),
         },
@@ -157,23 +172,19 @@ fn finalize_and_cache(vault: &Path, mut entries: Vec<VaultEntry>, hash: String)
     entries
 }
 
-/// Handle same-commit cache hit: add any uncommitted new files.
+/// Handle same-commit cache hit: re-parse any uncommitted changes (new or modified files).
 fn update_same_commit(vault: &Path, cache: VaultCache) -> Vec<VaultEntry> {
-    let new_files = git_uncommitted_new_files(vault);
-    let mut entries = cache.entries;
-    let existing: std::collections::HashSet<String> = entries
-        .iter()
-        .map(|e| to_relative_path(&e.path, vault))
-        .collect();
-
-    let new_entries = parse_files_at(vault, &new_files);
-    for entry in new_entries {
-        let rel = to_relative_path(&entry.path, vault);
-        if !existing.contains(&rel) {
-            entries.push(entry);
-        }
+    let changed = git_uncommitted_files(vault);
+    if changed.is_empty() {
+        return cache.entries;
     }
-
+    let changed_set: std::collections::HashSet<String> = changed.iter().cloned().collect();
+    let mut entries: Vec<VaultEntry> = cache
+        .entries
+        .into_iter()
+        .filter(|e| !changed_set.contains(&to_relative_path(&e.path, vault)))
+        .collect();
+    entries.extend(parse_files_at(vault, &changed));
     finalize_and_cache(vault, entries, cache.commit_hash)
 }
 
@@ -212,7 +223,10 @@ pub fn scan_vault_cached(vault_path: &Path) -> Result<Vec<VaultEntry>, String> {
     };
 
     if let Some(cache) = load_cache(vault_path) {
-        if cache.version != CACHE_VERSION {
+        let current_vault_str = vault_path.to_string_lossy();
+        let cache_stale = cache.version != CACHE_VERSION
+            || (!cache.vault_path.is_empty() && cache.vault_path != current_vault_str.as_ref());
+        if cache_stale {
             let entries = scan_vault(vault_path)?;
             return Ok(finalize_and_cache(vault_path, entries, current_hash));
         }
@@ -300,6 +314,71 @@ mod tests {
         assert_eq!(entries2[0].title, "Note");
     }
 
+    #[test]
+    fn test_scan_vault_cached_invalidates_stale_vault_path() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path();
+
+        // Init git repo
+        std::process::Command::new("git")
+            .args(["init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.email", "test@test.com"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.name", "Test"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        create_test_file(vault, "note.md", "# Note\n\nContent.");
+        std::process::Command::new("git")
+            .args(["add", "."])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["commit", "-m", "init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        // Build cache normally
+        let entries = scan_vault_cached(vault).unwrap();
+        assert_eq!(entries.len(), 1);
+        assert!(
+            entries[0]
+                .path
+                .starts_with(&vault.to_string_lossy().as_ref()),
+            "Entry path should start with vault path"
+        );
+
+        // Tamper with cache to simulate a clone from a different machine
+        let cache_file = cache_path(vault);
+        let cache_data = fs::read_to_string(&cache_file).unwrap();
+        let tampered = cache_data.replace(
+            &vault.to_string_lossy().as_ref(),
+            "/Users/other-machine/OtherVault",
+        );
+        fs::write(&cache_file, tampered).unwrap();
+
+        // Rescanning should invalidate the stale cache and produce correct paths
+        let entries2 = scan_vault_cached(vault).unwrap();
+        assert_eq!(entries2.len(), 1);
+        assert!(
+            entries2[0]
+                .path
+                .starts_with(&vault.to_string_lossy().as_ref()),
+            "After stale-cache invalidation, paths should use the current vault path, got: {}",
+            entries2[0].path
+        );
+    }
+
     #[test]
     fn test_scan_vault_cached_incremental_different_commit() {
         let dir = TempDir::new().unwrap();
@@ -358,4 +437,108 @@ mod tests {
         assert!(titles.contains(&"First"));
         assert!(titles.contains(&"Second"));
     }
+
+    #[test]
+    fn test_update_same_commit_picks_up_modified_file() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path();
+
+        std::process::Command::new("git")
+            .args(["init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.email", "test@test.com"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.name", "Test"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        // Commit a type note without sidebar label
+        create_test_file(vault, "type/news.md", "---\ntype: Type\n---\n# News\n");
+        std::process::Command::new("git")
+            .args(["add", "."])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["commit", "-m", "init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        // Prime the cache (same commit hash)
+        let entries = scan_vault_cached(vault).unwrap();
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].sidebar_label, None);
+
+        // User edits the type note to add sidebar label (uncommitted)
+        create_test_file(
+            vault,
+            "type/news.md",
+            "---\ntype: Type\nsidebar label: News\n---\n# News\n",
+        );
+
+        // Reload with same git HEAD — must pick up the modification
+        let entries2 = scan_vault_cached(vault).unwrap();
+        assert_eq!(entries2.len(), 1);
+        assert_eq!(
+            entries2[0].sidebar_label,
+            Some("News".to_string()),
+            "sidebarLabel must reflect the uncommitted edit"
+        );
+    }
+
+    #[test]
+    fn test_update_same_commit_new_file_still_added() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path();
+
+        std::process::Command::new("git")
+            .args(["init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.email", "test@test.com"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.name", "Test"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        create_test_file(vault, "existing.md", "# Existing\n");
+        std::process::Command::new("git")
+            .args(["add", "."])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["commit", "-m", "init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        // Prime cache
+        let entries = scan_vault_cached(vault).unwrap();
+        assert_eq!(entries.len(), 1);
+
+        // Create new untracked file
+        create_test_file(vault, "new-note.md", "# New Note\n");
+
+        // Cache still same commit — new untracked file must appear
+        let entries2 = scan_vault_cached(vault).unwrap();
+        assert_eq!(entries2.len(), 2);
+        let titles: Vec<&str> = entries2.iter().map(|e| e.title.as_str()).collect();
+        assert!(titles.contains(&"Existing"));
+        assert!(titles.contains(&"New Note"));
+    }
 }

src-tauri/src/vault/getting_started.rs

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 /// Default location for the Getting Started vault.
 pub fn default_vault_path() -> Result<PathBuf, String> {
     dirs::document_dir()
-        .map(|d| d.join("Laputa"))
+        .map(|d| d.join("Getting Started"))
         .ok_or_else(|| "Could not determine Documents directory".to_string())
 }
 
@@ -423,7 +423,7 @@ mod tests {
         let path = default_vault_path().unwrap();
         let path_str = path.to_string_lossy();
         assert!(path_str.contains("Documents"));
-        assert!(path_str.ends_with("Laputa"));
+        assert!(path_str.ends_with("Getting Started"));
     }
 
     #[test]

src-tauri/src/vault/mod.rs

@@ -11,7 +11,7 @@ pub use getting_started::{create_getting_started_vault, default_vault_path, vaul
 pub use image::{copy_image_to_vault, save_image};
 pub use migration::migrate_is_a_to_type;
 pub use rename::{rename_note, RenameResult};
-pub use trash::purge_trash;
+pub use trash::{delete_note, purge_trash};
 
 use parsing::{
     capitalize_first, contains_wikilink, count_body_words, extract_outgoing_links, extract_snippet,

src-tauri/src/vault/trash.rs

@@ -42,6 +42,21 @@ fn try_purge_file(path: &Path) -> Option<String> {
     }
 }
 
+/// Permanently delete a single note file.
+/// Returns the deleted path on success, or an error if the file doesn't exist.
+pub fn delete_note(path: &str) -> Result<String, String> {
+    let file = Path::new(path);
+    if !file.exists() {
+        return Err(format!("File does not exist: {}", path));
+    }
+    if !file.is_file() {
+        return Err(format!("Path is not a file: {}", path));
+    }
+    fs::remove_file(file).map_err(|e| format!("Failed to delete {}: {}", path, e))?;
+    log::info!("Permanently deleted note: {}", path);
+    Ok(path.to_string())
+}
+
 /// Scan all markdown files in the vault and delete those where
 /// `Trashed at` frontmatter is more than 30 days ago.
 /// Returns the list of deleted file paths.
@@ -95,6 +110,28 @@ mod tests {
         file.write_all(content.as_bytes()).unwrap();
     }
 
+    #[test]
+    fn test_delete_note_removes_file() {
+        let dir = TempDir::new().unwrap();
+        create_test_file(
+            dir.path(),
+            "doomed.md",
+            "---\ntitle: Doomed\n---\n# Doomed\n",
+        );
+        let path = dir.path().join("doomed.md");
+        assert!(path.exists());
+        let result = delete_note(path.to_str().unwrap());
+        assert!(result.is_ok());
+        assert!(!path.exists());
+    }
+
+    #[test]
+    fn test_delete_note_nonexistent_file() {
+        let result = delete_note("/nonexistent/path/that/does/not/exist.md");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("does not exist"));
+    }
+
     #[test]
     fn test_purge_trash_deletes_old_trashed_files() {
         let dir = TempDir::new().unwrap();

src-tauri/src/vault_list.rs

@@ -0,0 +1,140 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct VaultEntry {
+    pub label: String,
+    pub path: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct VaultList {
+    pub vaults: Vec<VaultEntry>,
+    pub active_vault: Option<String>,
+}
+
+fn vault_list_path() -> Result<PathBuf, String> {
+    dirs::config_dir()
+        .map(|d| d.join("com.laputa.app").join("vaults.json"))
+        .ok_or_else(|| "Could not determine config directory".to_string())
+}
+
+fn load_at(path: &PathBuf) -> Result<VaultList, String> {
+    if !path.exists() {
+        return Ok(VaultList::default());
+    }
+    let content =
+        fs::read_to_string(path).map_err(|e| format!("Failed to read vault list: {}", e))?;
+    serde_json::from_str(&content).map_err(|e| format!("Failed to parse vault list: {}", e))
+}
+
+fn save_at(path: &PathBuf, list: &VaultList) -> Result<(), String> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create config directory: {}", e))?;
+    }
+    let json = serde_json::to_string_pretty(list)
+        .map_err(|e| format!("Failed to serialize vault list: {}", e))?;
+    fs::write(path, json).map_err(|e| format!("Failed to write vault list: {}", e))
+}
+
+pub fn load_vault_list() -> Result<VaultList, String> {
+    load_at(&vault_list_path()?)
+}
+
+pub fn save_vault_list(list: &VaultList) -> Result<(), String> {
+    save_at(&vault_list_path()?, list)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn save_and_reload(list: &VaultList) -> VaultList {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("vaults.json");
+        save_at(&path, list).unwrap();
+        load_at(&path).unwrap()
+    }
+
+    #[test]
+    fn default_vault_list_is_empty() {
+        let vl = VaultList::default();
+        assert!(vl.vaults.is_empty());
+        assert!(vl.active_vault.is_none());
+    }
+
+    #[test]
+    fn roundtrip_preserves_data() {
+        let list = VaultList {
+            vaults: vec![
+                VaultEntry {
+                    label: "My Vault".to_string(),
+                    path: "/Users/luca/Laputa".to_string(),
+                },
+                VaultEntry {
+                    label: "Work".to_string(),
+                    path: "/Users/luca/Work".to_string(),
+                },
+            ],
+            active_vault: Some("/Users/luca/Laputa".to_string()),
+        };
+        let loaded = save_and_reload(&list);
+        assert_eq!(loaded.vaults.len(), 2);
+        assert_eq!(loaded.vaults[0].label, "My Vault");
+        assert_eq!(loaded.vaults[0].path, "/Users/luca/Laputa");
+        assert_eq!(loaded.vaults[1].label, "Work");
+        assert_eq!(loaded.active_vault.as_deref(), Some("/Users/luca/Laputa"));
+    }
+
+    #[test]
+    fn load_returns_default_for_missing_file() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("nonexistent.json");
+        let result = load_at(&path).unwrap();
+        assert!(result.vaults.is_empty());
+        assert!(result.active_vault.is_none());
+    }
+
+    #[test]
+    fn load_returns_error_for_malformed_json() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("bad.json");
+        fs::write(&path, "not valid json{{{").unwrap();
+        let err = load_at(&path).unwrap_err();
+        assert!(err.contains("Failed to parse vault list"));
+    }
+
+    #[test]
+    fn save_creates_parent_directories() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("nested").join("dir").join("vaults.json");
+        let list = VaultList {
+            vaults: vec![VaultEntry {
+                label: "Test".to_string(),
+                path: "/tmp/test".to_string(),
+            }],
+            active_vault: None,
+        };
+        save_at(&path, &list).unwrap();
+        assert!(path.exists());
+        let loaded = load_at(&path).unwrap();
+        assert_eq!(loaded.vaults.len(), 1);
+    }
+
+    #[test]
+    fn vault_list_path_returns_ok() {
+        let result = vault_list_path();
+        assert!(result.is_ok());
+        assert!(result.unwrap().to_str().unwrap().contains("com.laputa.app"));
+    }
+
+    #[test]
+    fn empty_vault_list_roundtrip() {
+        let list = VaultList::default();
+        let loaded = save_and_reload(&list);
+        assert!(loaded.vaults.is_empty());
+        assert!(loaded.active_vault.is_none());
+    }
+}

src-tauri/tauri.conf.json

@@ -5,9 +5,9 @@
   "identifier": "club.refactoring.laputa",
   "build": {
     "frontendDist": "../dist",
-    "devUrl": "http://localhost:5201",
+    "devUrl": "http://localhost:5202",
     "beforeDevCommand": "pnpm dev",
-    "beforeBuildCommand": "pnpm build"
+    "beforeBuildCommand": "pnpm build && pnpm bundle-mcp"
   },
   "app": {
     "withGlobalTauri": true,
@@ -37,6 +37,9 @@
     "active": true,
     "targets": "all",
     "createUpdaterArtifacts": true,
+    "resources": {
+      "resources/mcp-server/**/*": "mcp-server/"
+    },
     "icon": [
       "icons/32x32.png",
       "icons/128x128.png",

src/App.test.tsx

@@ -71,7 +71,7 @@ const mockCommandResults: Record<string, unknown> = {
   git_pull: { status: 'up_to_date', message: 'Already up to date', updatedFiles: [], conflictFiles: [] },
   save_settings: null,
   check_vault_exists: true,
-  get_default_vault_path: '/Users/mock/Documents/Laputa',
+  get_default_vault_path: '/Users/mock/Documents/Getting Started',
   list_themes: [],
   get_vault_settings: { theme: null },
 }

src/App.tsx

@@ -33,6 +33,8 @@ import { useBuildNumber } from './hooks/useBuildNumber'
 import { useOnboarding } from './hooks/useOnboarding'
 import { useThemeManager } from './hooks/useThemeManager'
 import { UpdateBanner } from './components/UpdateBanner'
+import { invoke } from '@tauri-apps/api/core'
+import { isTauri, mockInvoke } from './mock-tauri'
 import { extractOutgoingLinks } from './utils/wikilinks'
 import type { SidebarSelection } from './types'
 import './App.css'
@@ -123,7 +125,7 @@ function App() {
   const resolvedPath = onboarding.state.status === 'ready' ? onboarding.state.vaultPath : vaultSwitcher.vaultPath
   const vault = useVaultLoader(resolvedPath)
   const { settings, saveSettings } = useSettings()
-  const themeManager = useThemeManager(resolvedPath)
+  const themeManager = useThemeManager(resolvedPath, vault.entries, vault.allContent)
 
   useMcpRegistration(resolvedPath, setToastMessage)
 
@@ -248,6 +250,18 @@ function App() {
     createTypeEntry: notes.createTypeEntrySilent,
   })
 
+  const handleDeleteNote = useCallback(async (path: string) => {
+    try {
+      if (isTauri()) await invoke('delete_note', { path })
+      else await mockInvoke('delete_note', { path })
+      notes.handleCloseTab(path)
+      vault.removeEntry(path)
+      setToastMessage('Note permanently deleted')
+    } catch (e) {
+      setToastMessage(`Failed to delete note: ${e}`)
+    }
+  }, [notes, vault, setToastMessage])
+
   const gitHistory = useGitHistory(notes.activeTabPath, vault.loadGitHistory)
 
   const handleCreateType = useCallback((name: string) => {
@@ -277,6 +291,18 @@ function App() {
   const zoom = useZoom()
   const buildNumber = useBuildNumber()
 
+  const { status: updateStatus, actions: updateActions } = useUpdater()
+
+  const handleCheckForUpdates = useCallback(async () => {
+    const result = await updateActions.checkForUpdates()
+    if (result === 'up-to-date') {
+      setToastMessage("You're on the latest version")
+    } else if (result === 'error') {
+      setToastMessage('Could not check for updates')
+    }
+    // 'available' → UpdateBanner handles it automatically
+  }, [updateActions, setToastMessage])
+
   const commands = useAppCommands({
     activeTabPath: notes.activeTabPath, activeTabPathRef: notes.activeTabPathRef,
     handleCloseTabRef: notes.handleCloseTabRef, tabs: notes.tabs,
@@ -303,13 +329,22 @@ function App() {
     canGoBack: navHistory.canGoBack, canGoForward: navHistory.canGoForward,
     themes: themeManager.themes, activeThemeId: themeManager.activeThemeId,
     onSwitchTheme: themeManager.switchTheme,
-    onCreateTheme: async () => { await themeManager.createTheme() },
+    onCreateTheme: async () => {
+      await themeManager.createTheme()
+      await vault.reloadVault()
+      setSelection({ kind: 'sectionGroup', type: 'Theme' })
+    },
+    onOpenTheme: (themeId: string) => {
+      const entry = vault.entries.find(e => e.path === themeId)
+      if (entry) notes.handleSelectNote(entry)
+    },
     onOpenVault: vaultSwitcher.handleOpenLocalFolder,
+    onCreateType: dialogs.openCreateType,
     onToggleAIChat: dialogs.toggleAIChat,
+    onCheckForUpdates: handleCheckForUpdates,
+    isUpdating: updateStatus.state === 'downloading' || updateStatus.state === 'ready',
   })
 
-  const { status: updateStatus, actions: updateActions } = useUpdater()
-
   const activeTab = notes.tabs.find((t) => t.entry.path === notes.activeTabPath) ?? null
 
   // Show welcome/onboarding screen when vault doesn't exist
@@ -347,7 +382,7 @@ function App() {
         {sidebarVisible && (
           <>
             <div className="app__sidebar" style={{ width: layout.sidebarWidth }}>
-              <Sidebar entries={vault.entries} selection={selection} onSelect={setSelection} onSelectNote={notes.handleSelectNote} onCreateType={notes.handleCreateNoteImmediate} onCreateNewType={dialogs.openCreateType} onCustomizeType={entryActions.handleCustomizeType} onUpdateTypeTemplate={entryActions.handleUpdateTypeTemplate} onReorderSections={entryActions.handleReorderSections} modifiedCount={vault.modifiedFiles.length} onCommitPush={commitFlow.openCommitDialog} />
+              <Sidebar entries={vault.entries} selection={selection} onSelect={setSelection} onSelectNote={notes.handleSelectNote} onCreateType={notes.handleCreateNoteImmediate} onCreateNewType={dialogs.openCreateType} onCustomizeType={entryActions.handleCustomizeType} onUpdateTypeTemplate={entryActions.handleUpdateTypeTemplate} onReorderSections={entryActions.handleReorderSections} onRenameSection={entryActions.handleRenameSection} modifiedCount={vault.modifiedFiles.length} onCommitPush={commitFlow.openCommitDialog} />
             </div>
             <ResizeHandle onResize={layout.handleSidebarResize} />
           </>
@@ -355,7 +390,7 @@ function App() {
         {noteListVisible && (
           <>
             <div className="app__note-list" style={{ width: layout.noteListWidth }}>
-              <NoteList entries={vault.entries} selection={selection} selectedNote={activeTab?.entry ?? null} allContent={vault.allContent} modifiedFiles={vault.modifiedFiles} getNoteStatus={vault.getNoteStatus} sidebarCollapsed={!sidebarVisible} onSelectNote={notes.handleSelectNote} onReplaceActiveTab={notes.handleReplaceActiveTab} onCreateNote={notes.handleCreateNoteImmediate} onBulkArchive={bulkActions.handleBulkArchive} onBulkTrash={bulkActions.handleBulkTrash} />
+              <NoteList entries={vault.entries} selection={selection} selectedNote={activeTab?.entry ?? null} allContent={vault.allContent} modifiedFiles={vault.modifiedFiles} modifiedFilesError={vault.modifiedFilesError} getNoteStatus={vault.getNoteStatus} sidebarCollapsed={!sidebarVisible} onSelectNote={notes.handleSelectNote} onReplaceActiveTab={notes.handleReplaceActiveTab} onCreateNote={notes.handleCreateNoteImmediate} onBulkArchive={bulkActions.handleBulkArchive} onBulkTrash={bulkActions.handleBulkTrash} />
             </div>
             <ResizeHandle onResize={layout.handleNoteListResize} />
           </>
@@ -389,6 +424,7 @@ function App() {
             vaultPath={resolvedPath}
             onTrashNote={entryActions.handleTrashNote}
             onRestoreNote={entryActions.handleRestoreNote}
+            onDeleteNote={handleDeleteNote}
             onArchiveNote={entryActions.handleArchiveNote}
             onUnarchiveNote={entryActions.handleUnarchiveNote}
             onRenameTab={handleRenameTab}

src/components/CommandPalette.tsx

@@ -51,7 +51,7 @@ export function CommandPalette({ open, commands, onClose }: CommandPaletteProps)
   useEffect(() => {
     if (open) {
       setQuery('') // eslint-disable-line react-hooks/set-state-in-effect -- reset on open
-      setSelectedIndex(0) // eslint-disable-line react-hooks/set-state-in-effect -- reset on open
+      setSelectedIndex(0)
       setTimeout(() => inputRef.current?.focus(), 50)
     }
   }, [open])

src/components/DynamicPropertiesPanel.tsx

@@ -129,7 +129,7 @@ function TagsValue({ propKey, value, isEditing, vaultTags, onSave, onStartEdit }
                 fontFamily: "'IBM Plex Mono', monospace",
                 fontSize: 10,
                 fontWeight: 600,
-                letterSpacing: '1.2px',
+                letterSpacing: '0',
                 textTransform: 'uppercase' as const,
                 overflow: 'hidden',
                 whiteSpace: 'nowrap' as const,

src/components/Editor.test.tsx

@@ -44,7 +44,7 @@ vi.mock('@blocknote/react', () => ({
 }))
 
 vi.mock('@blocknote/mantine', () => ({
-  BlockNoteView: ({ children }: { children?: React.ReactNode }) => <div data-testid="blocknote-view">{children}</div>,
+  BlockNoteView: ({ children, editable }: { children?: React.ReactNode; editable?: boolean }) => <div data-testid="blocknote-view" data-editable={editable !== false ? 'true' : 'false'}>{children}</div>,
 }))
 
 vi.mock('@blocknote/mantine/style.css', () => ({}))
@@ -294,6 +294,41 @@ describe('Editor', () => {
     mockEditor.replaceBlocks.mockClear()
     mockEditor.insertBlocks.mockClear()
   })
+  describe('trashed note behavior', () => {
+    const trashedEntry: VaultEntry = { ...mockEntry, trashed: true, trashedAt: Date.now() / 1000 }
+    const trashedTab = { entry: trashedEntry, content: mockContent }
+
+    function renderTrashed(overrides: Partial<Parameters<typeof Editor>[0]> = {}) {
+      return render(<Editor {...defaultProps} tabs={[trashedTab]} activeTabPath={trashedEntry.path} {...overrides} />)
+    }
+
+    it('shows banner and read-only editor when note is trashed', () => {
+      renderTrashed()
+      expect(screen.getByTestId('trashed-note-banner')).toBeInTheDocument()
+      expect(screen.getByText('This note is in the Trash')).toBeInTheDocument()
+      expect(screen.getByTestId('blocknote-view')).toHaveAttribute('data-editable', 'false')
+    })
+
+    it('does not show banner and sets editable for normal notes', () => {
+      render(<Editor {...defaultProps} tabs={[mockTab]} activeTabPath={mockEntry.path} />)
+      expect(screen.queryByTestId('trashed-note-banner')).not.toBeInTheDocument()
+      expect(screen.getByTestId('blocknote-view')).toHaveAttribute('data-editable', 'true')
+    })
+
+    it('calls onRestoreNote when banner restore is clicked', () => {
+      const onRestoreNote = vi.fn()
+      renderTrashed({ onRestoreNote })
+      fireEvent.click(screen.getByTestId('trashed-banner-restore'))
+      expect(onRestoreNote).toHaveBeenCalledWith(trashedEntry.path)
+    })
+
+    it('calls onDeleteNote when banner delete is clicked', () => {
+      const onDeleteNote = vi.fn()
+      renderTrashed({ onDeleteNote })
+      fireEvent.click(screen.getByTestId('trashed-banner-delete'))
+      expect(onDeleteNote).toHaveBeenCalledWith(trashedEntry.path)
+    })
+  })
 })
 
 describe('wikilink autocomplete', () => {

src/components/Editor.tsx

@@ -50,6 +50,7 @@ interface EditorProps {
   vaultPath?: string
   onTrashNote?: (path: string) => void
   onRestoreNote?: (path: string) => void
+  onDeleteNote?: (path: string) => void
   onArchiveNote?: (path: string) => void
   onUnarchiveNote?: (path: string) => void
   onRenameTab?: (path: string, newTitle: string) => void
@@ -110,7 +111,7 @@ export const Editor = memo(function Editor({
   onUpdateFrontmatter, onDeleteProperty, onAddProperty,
   showAIChat, onToggleAIChat,
   vaultPath,
-  onTrashNote, onRestoreNote, onArchiveNote, onUnarchiveNote,
+  onTrashNote, onRestoreNote, onDeleteNote, onArchiveNote, onUnarchiveNote,
   onRenameTab, onContentChange, onSave, onTitleSync,
   canGoBack, canGoForward, onGoBack, onGoForward, leftPanelsCollapsed,
   isDarkTheme,
@@ -157,7 +158,6 @@ export const Editor = memo(function Editor({
   const isLoadingNewTab = activeTabPath !== null && !activeTab
   const activeStatus = activeTab ? getNoteStatus?.(activeTab.entry.path) ?? 'clean' : 'clean'
   const showDiffToggle = !!(activeTab && (diffMode || activeStatus === 'modified'))
-  const showRightPanel = !!(showAIChat || !inspectorCollapsed)
 
   return (
     <div className="editor flex flex-col min-h-0 overflow-hidden bg-background text-foreground">
@@ -202,13 +202,14 @@ export const Editor = memo(function Editor({
               onEditorChange={handleEditorChange}
               onTrashNote={onTrashNote}
               onRestoreNote={onRestoreNote}
+              onDeleteNote={onDeleteNote}
               onArchiveNote={onArchiveNote}
               onUnarchiveNote={onUnarchiveNote}
               vaultPath={vaultPath}
               isDarkTheme={isDarkTheme}
             />
         }
-        {showRightPanel && <ResizeHandle onResize={onInspectorResize} />}
+        {(showAIChat || !inspectorCollapsed) && <ResizeHandle onResize={onInspectorResize} />}
         <EditorRightPanel
           showAIChat={showAIChat}
           inspectorCollapsed={inspectorCollapsed}

src/components/EditorContent.tsx

@@ -2,6 +2,7 @@ import type { VaultEntry, NoteStatus } from '../types'
 import type { useCreateBlockNote } from '@blocknote/react'
 import { DiffView } from './DiffView'
 import { BreadcrumbBar } from './BreadcrumbBar'
+import { TrashedNoteBanner } from './TrashedNoteBanner'
 import { RawEditorView } from './RawEditorView'
 import { countWords } from '../utils/wikilinks'
 import { SingleEditorView } from './SingleEditorView'
@@ -34,6 +35,7 @@ interface EditorContentProps {
   onEditorChange?: () => void
   onTrashNote?: (path: string) => void
   onRestoreNote?: (path: string) => void
+  onDeleteNote?: (path: string) => void
   onArchiveNote?: (path: string) => void
   onUnarchiveNote?: (path: string) => void
   vaultPath?: string
@@ -97,7 +99,7 @@ function bindPath(cb: ((path: string) => void) | undefined, path: string) {
 
 function ActiveTabBreadcrumb({ activeTab, props }: {
   activeTab: Tab
-  props: Omit<EditorContentProps, 'activeTab' | 'isLoadingNewTab' | 'entries' | 'editor' | 'onNavigateWikilink' | 'onEditorChange' | 'onRawContentChange' | 'onSave'>
+  props: Omit<EditorContentProps, 'activeTab' | 'isLoadingNewTab' | 'entries' | 'editor' | 'onNavigateWikilink' | 'onEditorChange' | 'onRawContentChange' | 'onSave' | 'onDeleteNote'>
 }) {
   const wordCount = countWords(activeTab.content)
   const path = activeTab.entry.path
@@ -124,14 +126,38 @@ function ActiveTabBreadcrumb({ activeTab, props }: {
   )
 }
 
+function EditorBody({ activeTab, isLoadingNewTab, entries, editor, diffMode, diffContent, onToggleDiff, rawMode, onRawContentChange, onSave, onNavigateWikilink, onEditorChange, vaultPath, isDarkTheme, isTrashed }: {
+  activeTab: Tab | null; isLoadingNewTab: boolean; entries: VaultEntry[]
+  editor: ReturnType<typeof useCreateBlockNote>
+  diffMode: boolean; diffContent: string | null; onToggleDiff: () => void
+  rawMode: boolean; onRawContentChange?: (path: string, content: string) => void; onSave?: () => void
+  onNavigateWikilink: (target: string) => void; onEditorChange?: () => void
+  vaultPath?: string; isDarkTheme?: boolean; isTrashed: boolean
+}) {
+  const showEditor = !diffMode && !rawMode
+  return (
+    <>
+      {diffMode && <DiffModeView diffContent={diffContent} onToggleDiff={onToggleDiff} />}
+      <RawModeEditorSection rawMode={rawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} />
+      {showEditor && activeTab && (
+        <div style={{ display: 'flex', flex: 1, flexDirection: 'column', minHeight: 0 }}>
+          <SingleEditorView editor={editor} entries={entries} onNavigateWikilink={onNavigateWikilink} onChange={onEditorChange} vaultPath={vaultPath} isDarkTheme={isDarkTheme} editable={!isTrashed} />
+        </div>
+      )}
+      {isLoadingNewTab && showEditor && <EditorLoadingSkeleton />}
+    </>
+  )
+}
+
 export function EditorContent({
   activeTab, isLoadingNewTab, entries, editor,
   diffMode, diffContent, onToggleDiff,
   rawMode, onToggleRaw, onRawContentChange, onSave,
   onNavigateWikilink, onEditorChange, vaultPath, isDarkTheme,
+  onDeleteNote,
   ...breadcrumbProps
 }: EditorContentProps) {
-  const showEditor = !diffMode && !rawMode
+  const isTrashed = activeTab?.entry.trashed ?? false
 
   return (
     <div className="flex flex-1 flex-col min-w-0 min-h-0">
@@ -141,14 +167,13 @@ export function EditorContent({
           props={{ diffMode, diffContent, onToggleDiff, rawMode, onToggleRaw, ...breadcrumbProps }}
         />
       )}
-      {diffMode && <DiffModeView diffContent={diffContent} onToggleDiff={onToggleDiff} />}
-      <RawModeEditorSection rawMode={rawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} />
-      {showEditor && activeTab && (
-        <div style={{ display: 'flex', flex: 1, flexDirection: 'column', minHeight: 0 }}>
-          <SingleEditorView editor={editor} entries={entries} onNavigateWikilink={onNavigateWikilink} onChange={onEditorChange} vaultPath={vaultPath} isDarkTheme={isDarkTheme} />
-        </div>
+      {activeTab && isTrashed && (
+        <TrashedNoteBanner
+          onRestore={() => breadcrumbProps.onRestoreNote?.(activeTab.entry.path)}
+          onDeletePermanently={() => onDeleteNote?.(activeTab.entry.path)}
+        />
       )}
-      {isLoadingNewTab && showEditor && <EditorLoadingSkeleton />}
+      <EditorBody activeTab={activeTab} isLoadingNewTab={isLoadingNewTab} entries={entries} editor={editor} diffMode={diffMode} diffContent={diffContent} onToggleDiff={onToggleDiff} rawMode={rawMode} onRawContentChange={onRawContentChange} onSave={onSave} onNavigateWikilink={onNavigateWikilink} onEditorChange={onEditorChange} vaultPath={vaultPath} isDarkTheme={isDarkTheme} isTrashed={isTrashed} />
     </div>
   )
 }

src/components/NoteList.test.tsx

@@ -996,6 +996,33 @@ describe('NoteList — virtual list with large datasets', () => {
       expect(screen.queryByText('Matteo Cellini')).not.toBeInTheDocument()
     })
 
+    it('matches entries by relative path suffix when absolute paths differ (cross-machine)', () => {
+      // Simulate a cloned vault where cached entries have paths from a different machine
+      const crossMachineEntries: VaultEntry[] = mockEntries.map((e) => ({
+        ...e,
+        path: e.path.replace('/Users/luca/Laputa', '/Users/other-machine/OtherVault'),
+      }))
+      const modifiedFromCurrentMachine = [
+        { path: mockEntries[0].path, relativePath: 'project/26q1-laputa-app.md', status: 'modified' as const },
+        { path: mockEntries[1].path, relativePath: 'note/facebook-ads-strategy.md', status: 'modified' as const },
+      ]
+      render(
+        <NoteList entries={crossMachineEntries} selection={changesSelection} selectedNote={null} modifiedFiles={modifiedFromCurrentMachine} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} allContent={{}} onCreateNote={vi.fn()} />
+      )
+      // Even though absolute paths differ, entries should match via relative path suffix
+      expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
+      expect(screen.getByText('Facebook Ads Strategy')).toBeInTheDocument()
+      expect(screen.queryByText('Matteo Cellini')).not.toBeInTheDocument()
+    })
+
+    it('shows error message when modifiedFilesError is set', () => {
+      render(
+        <NoteList entries={mockEntries} selection={changesSelection} selectedNote={null} modifiedFiles={[]} modifiedFilesError="git status failed: not a git repository" onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} allContent={{}} onCreateNote={vi.fn()} />
+      )
+      expect(screen.getByText(/Failed to load changes/)).toBeInTheDocument()
+      expect(screen.getByText(/git status failed/)).toBeInTheDocument()
+    })
+
     it('shows untracked (new) notes alongside modified notes in changes view', () => {
       const mixedFiles = [
         { path: mockEntries[0].path, relativePath: 'project/26q1-laputa-app.md', status: 'modified' as const },

src/components/NoteList.tsx

@@ -26,6 +26,7 @@ interface NoteListProps {
   selectedNote: VaultEntry | null
   allContent: Record<string, string>
   modifiedFiles?: ModifiedFile[]
+  modifiedFilesError?: string | null
   getNoteStatus?: (path: string) => NoteStatus
   sidebarCollapsed?: boolean
   onSelectNote: (entry: VaultEntry) => void
@@ -143,13 +144,13 @@ function ListViewHeader({ isTrashView, expiredTrashCount }: {
   return <TrashWarningBanner expiredCount={isTrashView ? expiredTrashCount : 0} />
 }
 
-function ListView({ isTrashView, isChangesView, expiredTrashCount, searched, query, renderItem, virtuosoRef }: {
-  isTrashView: boolean; isChangesView?: boolean; expiredTrashCount: number
+function ListView({ isTrashView, isChangesView, changesError, expiredTrashCount, searched, query, renderItem, virtuosoRef }: {
+  isTrashView: boolean; isChangesView?: boolean; changesError?: string | null; expiredTrashCount: number
   searched: VaultEntry[]; query: string
   renderItem: (entry: VaultEntry) => React.ReactNode
   virtuosoRef?: React.RefObject<VirtuosoHandle | null>
 }) {
-  const emptyText = isChangesView ? 'No pending changes' : isTrashView ? 'Trash is empty' : (query ? 'No matching notes' : 'No notes found')
+  const emptyText = (isChangesView && changesError) ? `Failed to load changes: ${changesError}` : isChangesView ? 'No pending changes' : isTrashView ? 'Trash is empty' : (query ? 'No matching notes' : 'No notes found')
   const hasHeader = isTrashView && expiredTrashCount > 0
 
   if (searched.length === 0) {
@@ -232,10 +233,15 @@ function toggleSetMember<T>(set: Set<T>, member: T): Set<T> {
 interface NoteListDataParams {
   entries: VaultEntry[]; selection: SidebarSelection; allContent: Record<string, string>
   query: string; listSort: SortOption; listDirection: SortDirection
-  modifiedPathSet: Set<string>
+  modifiedPathSet: Set<string>; modifiedSuffixes: string[]
 }
 
-function useNoteListData({ entries, selection, allContent, query, listSort, listDirection, modifiedPathSet }: NoteListDataParams) {
+function isModifiedEntry(path: string, pathSet: Set<string>, suffixes: string[]): boolean {
+  if (pathSet.has(path)) return true
+  return suffixes.some((suffix) => path.endsWith(suffix))
+}
+
+function useNoteListData({ entries, selection, allContent, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes }: NoteListDataParams) {
   const isEntityView = selection.kind === 'entity'
   const isTrashView = selection.kind === 'filter' && selection.filter === 'trash'
   const isChangesView = selection.kind === 'filter' && selection.filter === 'changes'
@@ -248,12 +254,12 @@ function useNoteListData({ entries, selection, allContent, query, listSort, list
   const searched = useMemo(() => {
     if (isEntityView) return []
     if (isChangesView) {
-      const sorted = [...entries.filter((e) => modifiedPathSet.has(e.path))].sort(getSortComparator(listSort, listDirection))
+      const sorted = [...entries.filter((e) => isModifiedEntry(e.path, modifiedPathSet, modifiedSuffixes))].sort(getSortComparator(listSort, listDirection))
       return filterByQuery(sorted, query)
     }
     const sorted = [...filterEntries(entries, selection)].sort(getSortComparator(listSort, listDirection))
     return filterByQuery(sorted, query)
-  }, [entries, selection, isEntityView, isChangesView, listSort, listDirection, query, modifiedPathSet])
+  }, [entries, selection, isEntityView, isChangesView, listSort, listDirection, query, modifiedPathSet, modifiedSuffixes])
 
   const searchedGroups = useMemo(() => {
     if (!isEntityView) return []
@@ -273,7 +279,7 @@ function useNoteListData({ entries, selection, allContent, query, listSort, list
 
 const defaultGetNoteStatus = (): NoteStatus => 'clean'
 
-function NoteListInner({ entries, selection, selectedNote, allContent, modifiedFiles, getNoteStatus, sidebarCollapsed, onSelectNote, onReplaceActiveTab, onCreateNote, onBulkArchive, onBulkTrash }: NoteListProps) {
+function NoteListInner({ entries, selection, selectedNote, allContent, modifiedFiles, modifiedFilesError, getNoteStatus, sidebarCollapsed, onSelectNote, onReplaceActiveTab, onCreateNote, onBulkArchive, onBulkTrash }: NoteListProps) {
   const [search, setSearch] = useState('')
   const [searchVisible, setSearchVisible] = useState(false)
   const [collapsedGroups, setCollapsedGroups] = useState<Set<string>>(new Set())
@@ -285,6 +291,14 @@ function NoteListInner({ entries, selection, selectedNote, allContent, modifiedF
     [modifiedFiles],
   )
 
+  // Suffix patterns for cross-machine robustness: if the vault cache carried
+  // stale absolute paths from another machine, fall back to matching by the
+  // relative path suffix so the changes view stays in sync with the badge.
+  const modifiedSuffixes = useMemo(
+    () => (modifiedFiles ?? []).map((f) => '/' + f.relativePath),
+    [modifiedFiles],
+  )
+
   const resolvedGetNoteStatus = useMemo<(path: string) => NoteStatus>(
     () => createNoteStatusResolver(getNoteStatus, modifiedFiles, modifiedPathSet),
     [getNoteStatus, modifiedFiles, modifiedPathSet],
@@ -303,7 +317,7 @@ function NoteListInner({ entries, selection, selectedNote, allContent, modifiedF
   const listConfig = sortPrefs['__list__'] ?? { option: 'modified' as SortOption, direction: 'desc' as SortDirection }
   const listSort = listConfig.option
   const listDirection = listConfig.direction
-  const { isEntityView, isTrashView, isChangesView, typeDocument, searched, searchedGroups, expiredTrashCount } = useNoteListData({ entries, selection, allContent, query, listSort, listDirection, modifiedPathSet })
+  const { isEntityView, isTrashView, isChangesView, typeDocument, searched, searchedGroups, expiredTrashCount } = useNoteListData({ entries, selection, allContent, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes })
 
   const noteListKeyboard = useNoteListKeyboard({
     items: searched,
@@ -401,7 +415,7 @@ function NoteListInner({ entries, selection, selectedNote, allContent, modifiedF
         {isEntityView && selection.kind === 'entity' ? (
           <EntityView entity={selection.entry} groups={searchedGroups} query={query} collapsedGroups={collapsedGroups} sortPrefs={sortPrefs} onToggleGroup={toggleGroup} onSortChange={handleSortChange} renderItem={renderItem} typeEntryMap={typeEntryMap} onClickNote={handleClickNote} />
         ) : (
-          <ListView isTrashView={isTrashView} isChangesView={isChangesView} expiredTrashCount={expiredTrashCount} searched={searched} query={query} renderItem={renderItem} virtuosoRef={noteListKeyboard.virtuosoRef} />
+          <ListView isTrashView={isTrashView} isChangesView={isChangesView} changesError={modifiedFilesError} expiredTrashCount={expiredTrashCount} searched={searched} query={query} renderItem={renderItem} virtuosoRef={noteListKeyboard.virtuosoRef} />
         )}
       </div>
 

src/components/SearchPanel.tsx

@@ -209,7 +209,6 @@ function SearchContent({
                   onMouseEnter={() => onHover(i)}
                 >
                   <div className="flex items-center gap-2">
-                    {/* eslint-disable-next-line react-hooks/static-components -- icon from static map lookup */}
                     <TypeIcon width={14} height={14} className="shrink-0" style={{ color: typeColor ?? 'var(--muted-foreground)' }} />
                     <span className="min-w-0 flex-1 truncate text-[13px] font-medium text-foreground">{result.title}</span>
                     {noteType && (

src/components/Sidebar.test.tsx

@@ -809,11 +809,67 @@ describe('Sidebar', () => {
       expect(topicsIdx).toBeLessThan(peopleIdx)
     })
 
-    it('renders drag handle on section headers', () => {
+    it('does not render drag handle icons on section headers', () => {
       render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
-      const dragHandles = screen.getAllByLabelText(/^Drag to reorder/)
-      // Should have one drag handle per visible section group
-      expect(dragHandles.length).toBeGreaterThan(0)
+      const dragHandles = screen.queryAllByLabelText(/^Drag to reorder/)
+      expect(dragHandles.length).toBe(0)
+    })
+  })
+
+  describe('rename section via context menu', () => {
+    it('shows Rename section option in context menu on right-click', () => {
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+      const projectHeader = screen.getByText('Projects').closest('div')!
+      fireEvent.contextMenu(projectHeader)
+      expect(screen.getByText('Rename section…')).toBeInTheDocument()
+    })
+
+    it('shows Customize icon option in context menu on right-click', () => {
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+      const projectHeader = screen.getByText('Projects').closest('div')!
+      fireEvent.contextMenu(projectHeader)
+      expect(screen.getByText('Customize icon & color…')).toBeInTheDocument()
+    })
+
+    it('shows inline input when Rename section is clicked', () => {
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+      const projectHeader = screen.getByText('Projects').closest('div')!
+      fireEvent.contextMenu(projectHeader)
+      fireEvent.click(screen.getByText('Rename section…'))
+      expect(screen.getByRole('textbox', { name: 'Section name' })).toBeInTheDocument()
+    })
+
+    it('inline input is pre-filled with current label', () => {
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+      const projectHeader = screen.getByText('Projects').closest('div')!
+      fireEvent.contextMenu(projectHeader)
+      fireEvent.click(screen.getByText('Rename section…'))
+      const input = screen.getByRole('textbox', { name: 'Section name' }) as HTMLInputElement
+      expect(input.value).toBe('Projects')
+    })
+
+    it('calls onRenameSection with new name on Enter', () => {
+      const onRenameSection = vi.fn()
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} onRenameSection={onRenameSection} />)
+      const projectHeader = screen.getByText('Projects').closest('div')!
+      fireEvent.contextMenu(projectHeader)
+      fireEvent.click(screen.getByText('Rename section…'))
+      const input = screen.getByRole('textbox', { name: 'Section name' })
+      fireEvent.change(input, { target: { value: 'My Projects' } })
+      fireEvent.keyDown(input, { key: 'Enter' })
+      expect(onRenameSection).toHaveBeenCalledWith('Project', 'My Projects')
+    })
+
+    it('cancels rename on Escape and hides input', () => {
+      const onRenameSection = vi.fn()
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} onRenameSection={onRenameSection} />)
+      const projectHeader = screen.getByText('Projects').closest('div')!
+      fireEvent.contextMenu(projectHeader)
+      fireEvent.click(screen.getByText('Rename section…'))
+      const input = screen.getByRole('textbox', { name: 'Section name' })
+      fireEvent.keyDown(input, { key: 'Escape' })
+      expect(onRenameSection).not.toHaveBeenCalled()
+      expect(screen.queryByRole('textbox', { name: 'Section name' })).not.toBeInTheDocument()
     })
   })
 })

src/components/Sidebar.tsx

@@ -34,6 +34,7 @@ interface SidebarProps {
   onCustomizeType?: (typeName: string, icon: string, color: string) => void
   onUpdateTypeTemplate?: (typeName: string, template: string) => void
   onReorderSections?: (orderedTypes: { typeName: string; order: number }[]) => void
+  onRenameSection?: (typeName: string, label: string) => void
   modifiedCount?: number
   onCommitPush?: () => void
   onCollapse?: () => void
@@ -161,12 +162,13 @@ function applyCustomization(
 
 function SortableSection({ group, sectionProps }: {
   group: SectionGroup
-  sectionProps: Omit<SectionContentProps, 'group' | 'items' | 'isCollapsed' | 'dragHandleProps' | 'onToggle'>
-    & { entries: VaultEntry[]; collapsed: Record<string, boolean>; onToggle: (type: string) => void }
+  sectionProps: Omit<SectionContentProps, 'group' | 'items' | 'isCollapsed' | 'onToggle' | 'isRenaming' | 'renameInitialValue'>
+    & { entries: VaultEntry[]; collapsed: Record<string, boolean>; onToggle: (type: string) => void; renamingType: string | null; renameInitialValue: string }
 }) {
-  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: group.type })
+  const { attributes, setNodeRef, transform, transition, isDragging } = useSortable({ id: group.type })
   const items = sectionProps.entries.filter((e) => e.isA === group.type && !e.archived && !e.trashed)
   const isCollapsed = sectionProps.collapsed[group.type] ?? true
+  const isRenaming = sectionProps.renamingType === group.type
 
   return (
     <div ref={setNodeRef} style={{ transform: CSS.Transform.toString(transform), transition, opacity: isDragging ? 0.5 : 1, padding: '4px 6px' }} {...attributes}>
@@ -176,7 +178,10 @@ function SortableSection({ group, sectionProps }: {
         onSelectNote={sectionProps.onSelectNote} onCreateType={sectionProps.onCreateType}
         onCreateNewType={sectionProps.onCreateNewType} onContextMenu={sectionProps.onContextMenu}
         onToggle={() => sectionProps.onToggle(group.type)}
-        dragHandleProps={listeners}
+        isRenaming={isRenaming}
+        renameInitialValue={isRenaming ? sectionProps.renameInitialValue : undefined}
+        onRenameSubmit={sectionProps.onRenameSubmit}
+        onRenameCancel={sectionProps.onRenameCancel}
       />
     </div>
   )
@@ -216,16 +221,21 @@ function SidebarTitleBar({ onCollapse }: { onCollapse?: () => void }) {
   )
 }
 
-function ContextMenuOverlay({ pos, type, innerRef, onOpenCustomize }: {
+function ContextMenuOverlay({ pos, type, innerRef, onOpenCustomize, onStartRename }: {
   pos: { x: number; y: number } | null; type: string | null
   innerRef: React.Ref<HTMLDivElement>
   onOpenCustomize: (type: string) => void
+  onStartRename: (type: string) => void
 }) {
   if (!pos || !type) return null
+  const btnClass = "flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-sm cursor-default hover:bg-accent hover:text-accent-foreground transition-colors border-none bg-transparent text-left"
   return (
     <div ref={innerRef} className="fixed z-50 rounded-md border bg-popover p-1 shadow-md" style={{ left: pos.x, top: pos.y, minWidth: 180 }}>
-      <button className="flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-sm cursor-default hover:bg-accent hover:text-accent-foreground transition-colors border-none bg-transparent text-left" onClick={() => onOpenCustomize(type)}>
-        Customize icon & color…
+      <button className={btnClass} onClick={() => onStartRename(type)}>
+        Rename section…
+      </button>
+      <button className={btnClass} onClick={() => onOpenCustomize(type)}>
+        Customize icon &amp; color…
       </button>
     </div>
   )
@@ -258,11 +268,14 @@ function CustomizeOverlay({ target, typeEntryMap, innerRef, onCustomize, onChang
 
 export const Sidebar = memo(function Sidebar({
   entries, selection, onSelect, onSelectNote, onCreateType, onCreateNewType,
-  onCustomizeType, onUpdateTypeTemplate, onReorderSections, modifiedCount = 0, onCommitPush, onCollapse,
+  onCustomizeType, onUpdateTypeTemplate, onReorderSections, onRenameSection,
+  modifiedCount = 0, onCommitPush, onCollapse,
 }: SidebarProps) {
   const [collapsed, setCollapsed] = useState<Record<string, boolean>>({})
   const [customizeTarget, setCustomizeTarget] = useState<string | null>(null)
   const [contextMenuPos, setContextMenuPos] = useState<{ x: number; y: number } | null>(null)
+  const [renamingType, setRenamingType] = useState<string | null>(null)
+  const [renameInitialValue, setRenameInitialValue] = useState('')
   const [contextMenuType, setContextMenuType] = useState<string | null>(null)
   const [showCustomize, setShowCustomize] = useState(false)
 
@@ -303,6 +316,20 @@ export const Sidebar = memo(function Sidebar({
     setContextMenuPos({ x: e.clientX, y: e.clientY }); setContextMenuType(type)
   }, [])
 
+  const cancelRename = useCallback(() => setRenamingType(null), [])
+
+  const handleStartRename = useCallback((type: string) => {
+    closeContextMenu()
+    const group = allSectionGroups.find((g) => g.type === type)
+    setRenameInitialValue(group?.label ?? type)
+    setRenamingType(type)
+  }, [closeContextMenu, allSectionGroups])
+
+  const handleRenameSubmit = useCallback((value: string) => {
+    if (renamingType) onRenameSection?.(renamingType, value)
+    setRenamingType(null)
+  }, [renamingType, onRenameSection])
+
   const handleCustomize = useCallback((prop: 'icon' | 'color', value: string) => {
     applyCustomization(customizeTarget, typeEntryMap, onCustomizeType, prop, value)
   }, [customizeTarget, typeEntryMap, onCustomizeType])
@@ -314,6 +341,7 @@ export const Sidebar = memo(function Sidebar({
   const sectionProps = {
     entries, collapsed, selection, onSelect, onSelectNote, onCreateType, onCreateNewType,
     onContextMenu: handleContextMenu, onToggle: toggleSection,
+    renamingType, renameInitialValue, onRenameSubmit: handleRenameSubmit, onRenameCancel: cancelRename,
   }
 
   return (
@@ -354,7 +382,7 @@ export const Sidebar = memo(function Sidebar({
       </nav>
 
       <CommitButton modifiedCount={modifiedCount} onClick={onCommitPush} />
-      <ContextMenuOverlay pos={contextMenuPos} type={contextMenuType} innerRef={contextMenuRef} onOpenCustomize={(type) => { closeContextMenu(); setCustomizeTarget(type) }} />
+      <ContextMenuOverlay pos={contextMenuPos} type={contextMenuType} innerRef={contextMenuRef} onOpenCustomize={(type) => { closeContextMenu(); setCustomizeTarget(type) }} onStartRename={handleStartRename} />
       <CustomizeOverlay target={customizeTarget} typeEntryMap={typeEntryMap} innerRef={popoverRef} onCustomize={handleCustomize} onChangeTemplate={handleChangeTemplate} onClose={closeCustomizeTarget} />
     </aside>
   )

src/components/SidebarParts.tsx

@@ -1,7 +1,7 @@
-import { type ComponentType } from 'react'
+import { type ComponentType, useState, useEffect, useRef } from 'react'
 import type { VaultEntry, SidebarSelection } from '../types'
 import { cn } from '@/lib/utils'
-import { ChevronRight, ChevronDown, Plus, GripVertical } from 'lucide-react'
+import { ChevronRight, ChevronDown, Plus } from 'lucide-react'
 import { getTypeColor, getTypeLightColor } from '../utils/typeColors'
 import { type IconProps } from '@phosphor-icons/react'
 
@@ -75,7 +75,10 @@ export interface SectionContentProps {
   onCreateNewType?: () => void
   onContextMenu: (e: React.MouseEvent, type: string) => void
   onToggle: () => void
-  dragHandleProps?: Record<string, unknown>
+  isRenaming?: boolean
+  renameInitialValue?: string
+  onRenameSubmit?: (value: string) => void
+  onRenameCancel?: () => void
 }
 
 function childSelection(type: string, entry: VaultEntry): SidebarSelection {
@@ -90,7 +93,8 @@ function resolveCreateHandler(type: string, onCreateType?: (type: string) => voi
 
 export function SectionContent({
   group, items, isCollapsed, selection, onSelect, onSelectNote,
-  onCreateType, onCreateNewType, onContextMenu, onToggle, dragHandleProps,
+  onCreateType, onCreateNewType, onContextMenu, onToggle,
+  isRenaming, renameInitialValue, onRenameSubmit, onRenameCancel,
 }: SectionContentProps) {
   const { label, type, Icon, customColor } = group
   const sectionColor = getTypeColor(type, customColor)
@@ -109,7 +113,10 @@ export function SectionContent({
         onContextMenu={(e) => onContextMenu(e, type)}
         onToggle={onToggle}
         onCreate={(e) => { e.stopPropagation(); onCreate?.() }}
-        dragHandleProps={dragHandleProps}
+        isRenaming={isRenaming}
+        renameInitialValue={renameInitialValue}
+        onRenameSubmit={onRenameSubmit}
+        onRenameCancel={onRenameCancel}
       />
       {!isCollapsed && items.length > 0 && (
         <SectionChildList
@@ -145,29 +152,67 @@ function SectionChildList({ items, type, selection, sectionColor, sectionLightCo
   )
 }
 
-function SectionHeader({ label, type, Icon, sectionColor, isCollapsed, isActive, showCreate, onSelect, onContextMenu, onToggle, onCreate, dragHandleProps }: {
+function InlineRenameInput({ initialValue, onSubmit, onCancel }: {
+  initialValue: string
+  onSubmit: (value: string) => void
+  onCancel: () => void
+}) {
+  const [value, setValue] = useState(initialValue)
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  useEffect(() => { inputRef.current?.focus(); inputRef.current?.select() }, [])
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); onSubmit(value.trim()) }
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); onCancel() }
+  }
+
+  return (
+    <input
+      ref={inputRef}
+      value={value}
+      onChange={(e) => setValue(e.target.value)}
+      onKeyDown={handleKeyDown}
+      onBlur={() => onSubmit(value.trim())}
+      onClick={(e) => e.stopPropagation()}
+      aria-label="Section name"
+      className="flex-1 rounded border border-primary bg-background text-[13px] font-medium text-foreground outline-none"
+      style={{ padding: '1px 4px' }}
+    />
+  )
+}
+
+function SectionHeader({ label, type, Icon, sectionColor, isCollapsed, isActive, showCreate, onSelect, onContextMenu, onToggle, onCreate, isRenaming, renameInitialValue, onRenameSubmit, onRenameCancel }: {
   label: string; type: string; Icon: ComponentType<IconProps>
   sectionColor: string; isCollapsed: boolean; isActive: boolean; showCreate: boolean
   onSelect: () => void; onContextMenu: (e: React.MouseEvent) => void
   onToggle: () => void; onCreate: (e: React.MouseEvent) => void
-  dragHandleProps?: Record<string, unknown>
+  isRenaming?: boolean; renameInitialValue?: string
+  onRenameSubmit?: (value: string) => void; onRenameCancel?: () => void
 }) {
   return (
     <div
       className={cn("group/section flex cursor-pointer select-none items-center justify-between rounded transition-colors", isActive ? "bg-secondary" : "hover:bg-accent")}
-      style={{ padding: '6px 8px 6px 6px', borderRadius: 4, gap: 4 }}
+      style={{ padding: '6px 8px 6px 16px', borderRadius: 4, gap: 4 }}
       onClick={() => {
+        if (isRenaming) return
         if (isCollapsed) { onToggle(); onSelect() }
         else if (isActive) { onToggle() }
         else { onSelect() }
-      }} onContextMenu={onContextMenu}
+      }} onContextMenu={isRenaming ? undefined : onContextMenu}
     >
-      <div className="flex items-center" style={{ gap: 4 }}>
-        <div className="flex shrink-0 items-center justify-center text-muted-foreground opacity-0 group-hover/section:opacity-50 hover:!opacity-100 cursor-grab" style={{ width: 16, height: 16 }} {...dragHandleProps} aria-label={`Drag to reorder ${label}`}>
-          <GripVertical size={12} />
-        </div>
-        <Icon size={16} style={{ color: sectionColor }} />
-        <span className="text-[13px] font-medium text-foreground" style={{ marginLeft: 4 }}>{label}</span>
+      <div className="flex min-w-0 flex-1 items-center" style={{ gap: 4 }}>
+        <Icon size={16} style={{ color: sectionColor, flexShrink: 0 }} />
+        {isRenaming && onRenameSubmit && onRenameCancel ? (
+          <InlineRenameInput
+            key={`rename-${type}`}
+            initialValue={renameInitialValue ?? label}
+            onSubmit={onRenameSubmit}
+            onCancel={onRenameCancel}
+          />
+        ) : (
+          <span className="text-[13px] font-medium text-foreground" style={{ marginLeft: 4 }}>{label}</span>
+        )}
       </div>
       <div className="flex items-center" style={{ gap: 2 }}>
         {showCreate && (

src/components/SingleEditorView.tsx

@@ -23,13 +23,14 @@ function useInsertImageCallback(editor: ReturnType<typeof useCreateBlockNote>) {
 }
 
 /** Single BlockNote editor view — content is swapped via replaceBlocks */
-export function SingleEditorView({ editor, entries, onNavigateWikilink, onChange, vaultPath, isDarkTheme }: {
+export function SingleEditorView({ editor, entries, onNavigateWikilink, onChange, vaultPath, isDarkTheme, editable = true }: {
   editor: ReturnType<typeof useCreateBlockNote>
   entries: VaultEntry[]
   onNavigateWikilink: (target: string) => void
   onChange?: () => void
   vaultPath?: string
   isDarkTheme?: boolean
+  editable?: boolean
 }) {
   const navigateRef = useRef(onNavigateWikilink)
   useEffect(() => { navigateRef.current = onNavigateWikilink }, [onNavigateWikilink])
@@ -103,6 +104,7 @@ export function SingleEditorView({ editor, entries, onNavigateWikilink, onChange
         editor={editor}
         theme={isDarkTheme ? 'dark' : 'light'}
         onChange={onChange}
+        editable={editable}
       >
         <SuggestionMenuController
           triggerCharacter="[["

src/components/StatusBar.tsx

@@ -6,6 +6,7 @@ import { openExternalUrl } from '../utils/url'
 export interface VaultOption {
   label: string
   path: string
+  available?: boolean
 }
 
 interface StatusBarProps {
@@ -29,19 +30,36 @@ interface StatusBarProps {
   buildNumber?: string
 }
 
+function VaultMenuIcon({ isActive, unavailable }: { isActive: boolean; unavailable: boolean }) {
+  if (isActive) return <Check size={12} />
+  if (unavailable) return <AlertTriangle size={12} style={{ color: 'var(--muted-foreground)' }} />
+  return <span style={{ width: 12 }} />
+}
+
+function vaultItemStyle(isActive: boolean, unavailable: boolean): React.CSSProperties {
+  return {
+    display: 'flex', alignItems: 'center', gap: 6, padding: '4px 8px', borderRadius: 4,
+    cursor: unavailable ? 'not-allowed' : 'pointer',
+    background: isActive ? 'var(--hover)' : 'transparent',
+    opacity: unavailable ? 0.45 : 1,
+    color: isActive ? 'var(--foreground)' : 'var(--muted-foreground)', fontSize: 12,
+  }
+}
+
 function VaultMenuItem({ vault, isActive, onSelect }: { vault: VaultOption; isActive: boolean; onSelect: () => void }) {
+  const unavailable = vault.available === false
+  const canHover = !isActive && !unavailable
   return (
     <div
-      role="button" onClick={onSelect}
-      style={{
-        display: 'flex', alignItems: 'center', gap: 6, padding: '4px 8px', borderRadius: 4, cursor: 'pointer',
-        background: isActive ? 'var(--hover)' : 'transparent',
-        color: isActive ? 'var(--foreground)' : 'var(--muted-foreground)', fontSize: 12,
-      }}
-      onMouseEnter={(e) => { if (!isActive) e.currentTarget.style.background = 'var(--hover)' }}
-      onMouseLeave={(e) => { if (!isActive) e.currentTarget.style.background = 'transparent' }}
+      role="button"
+      onClick={unavailable ? undefined : onSelect}
+      style={vaultItemStyle(isActive, unavailable)}
+      title={unavailable ? `Vault not found: ${vault.path}` : vault.path}
+      onMouseEnter={canHover ? (e) => { e.currentTarget.style.background = 'var(--hover)' } : undefined}
+      onMouseLeave={canHover ? (e) => { e.currentTarget.style.background = 'transparent' } : undefined}
+      data-testid={`vault-menu-item-${vault.label}`}
     >
-      {isActive ? <Check size={12} /> : <span style={{ width: 12 }} />}
+      <VaultMenuIcon isActive={isActive} unavailable={unavailable} />
       {vault.label}
     </div>
   )
@@ -116,21 +134,21 @@ const DISABLED_STYLE = { display: 'flex', alignItems: 'center', opacity: 0.4, cu
 const SEP_STYLE = { color: 'var(--border)' } as const
 const SYNC_ICON_MAP: Record<string, typeof RefreshCw> = { syncing: Loader2, conflict: AlertTriangle }
 
-function formatSyncLabel(status: SyncStatus, lastSyncTime: number | null): string {
-  if (status === 'syncing') return 'Syncing…'
-  if (status === 'conflict') return 'Conflict'
-  if (status === 'error') return 'Sync failed'
+const SYNC_LABELS: Record<string, string> = { syncing: 'Syncing…', conflict: 'Conflict', error: 'Sync failed' }
+const SYNC_COLORS: Record<string, string> = { conflict: 'var(--accent-orange)', error: 'var(--muted-foreground)' }
+
+function formatElapsedSync(lastSyncTime: number | null): string {
   if (!lastSyncTime) return 'Not synced'
-  const elapsed = Math.round((Date.now() - lastSyncTime) / 1000)
-  if (elapsed < 60) return 'Synced just now'
-  const mins = Math.floor(elapsed / 60)
-  return `Synced ${mins}m ago`
+  const secs = Math.round((Date.now() - lastSyncTime) / 1000)
+  return secs < 60 ? 'Synced just now' : `Synced ${Math.floor(secs / 60)}m ago`
+}
+
+function formatSyncLabel(status: SyncStatus, lastSyncTime: number | null): string {
+  return SYNC_LABELS[status] ?? formatElapsedSync(lastSyncTime)
 }
 
 function syncIconColor(status: SyncStatus): string {
-  if (status === 'conflict') return 'var(--accent-orange)'
-  if (status === 'error') return 'var(--muted-foreground)'
-  return 'var(--accent-green)'
+  return SYNC_COLORS[status] ?? 'var(--accent-green)'
 }
 
 function CommitBadge({ info }: { info: LastCommitInfo }) {
@@ -156,17 +174,59 @@ function CommitBadge({ info }: { info: LastCommitInfo }) {
   )
 }
 
+function SyncBadge({ status, lastSyncTime, onTriggerSync }: { status: SyncStatus; lastSyncTime: number | null; onTriggerSync?: () => void }) {
+  const SyncIcon = SYNC_ICON_MAP[status] ?? RefreshCw
+  const isSyncing = status === 'syncing'
+  return (
+    <span
+      role="button"
+      onClick={onTriggerSync}
+      style={{ ...ICON_STYLE, cursor: onTriggerSync ? 'pointer' : 'default', padding: '2px 4px', borderRadius: 3 }}
+      title={isSyncing ? 'Syncing…' : 'Click to sync now'}
+      data-testid="status-sync"
+    >
+      <SyncIcon size={13} style={{ color: syncIconColor(status) }} className={isSyncing ? 'animate-spin' : ''} />{formatSyncLabel(status, lastSyncTime)}
+    </span>
+  )
+}
+
+function ConflictBadge({ count }: { count: number }) {
+  if (count <= 0) return null
+  return (
+    <>
+      <span style={SEP_STYLE}>|</span>
+      <span style={{ ...ICON_STYLE, color: 'var(--destructive, #e03e3e)' }} data-testid="status-conflict-count">
+        <AlertTriangle size={13} />{count} conflict{count > 1 ? 's' : ''}
+      </span>
+    </>
+  )
+}
+
+function PendingBadge({ count, onClick }: { count: number; onClick?: () => void }) {
+  if (count <= 0) return null
+  return (
+    <>
+      <span style={SEP_STYLE}>|</span>
+      <span
+        role="button"
+        onClick={onClick}
+        style={{ ...ICON_STYLE, cursor: 'pointer', padding: '2px 4px', borderRadius: 3, background: 'transparent' }}
+        title="View pending changes"
+        onMouseEnter={e => { e.currentTarget.style.background = 'var(--hover)' }}
+        onMouseLeave={e => { e.currentTarget.style.background = 'transparent' }}
+        data-testid="status-modified-count"
+      ><CircleDot size={13} style={{ color: 'var(--accent-orange)' }} />{count} pending</span>
+    </>
+  )
+}
+
 export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onSwitchVault, onOpenSettings, onOpenLocalFolder, onConnectGitHub, onClickPending, hasGitHub, syncStatus = 'idle', lastSyncTime = null, conflictCount = 0, lastCommitInfo, onTriggerSync, zoomLevel = 100, onZoomReset, buildNumber }: StatusBarProps) {
-  // Force re-render every 30s to keep relative time label fresh
   const [, setTick] = useState(0)
   useEffect(() => {
     const id = setInterval(() => setTick((t) => t + 1), 30_000)
     return () => clearInterval(id)
   }, [])
 
-  const syncLabel = formatSyncLabel(syncStatus, lastSyncTime)
-  const SyncIcon = SYNC_ICON_MAP[syncStatus] ?? RefreshCw
-
   return (
     <footer style={{ height: 30, flexShrink: 0, display: 'flex', alignItems: 'center', justifyContent: 'space-between', background: 'var(--sidebar)', borderTop: '1px solid var(--border)', padding: '0 8px', fontSize: 11, color: 'var(--muted-foreground)' }}>
       <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
@@ -174,38 +234,10 @@ export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onS
         <span style={SEP_STYLE}>|</span>
         <span style={ICON_STYLE} data-testid="status-build-number"><Package size={13} />{buildNumber ?? 'b?'}</span>
         <span style={SEP_STYLE}>|</span>
-        <span
-          role="button"
-          onClick={onTriggerSync}
-          style={{ ...ICON_STYLE, cursor: onTriggerSync ? 'pointer' : 'default', padding: '2px 4px', borderRadius: 3 }}
-          title={syncStatus === 'syncing' ? 'Syncing…' : 'Click to sync now'}
-          data-testid="status-sync"
-        >
-          <SyncIcon size={13} style={{ color: syncIconColor(syncStatus) }} className={syncStatus === 'syncing' ? 'animate-spin' : ''} />{syncLabel}
-        </span>
+        <SyncBadge status={syncStatus} lastSyncTime={lastSyncTime} onTriggerSync={onTriggerSync} />
         {lastCommitInfo && <CommitBadge info={lastCommitInfo} />}
-        {conflictCount > 0 && (
-          <>
-            <span style={SEP_STYLE}>|</span>
-            <span style={{ ...ICON_STYLE, color: 'var(--destructive, #e03e3e)' }} data-testid="status-conflict-count">
-              <AlertTriangle size={13} />{conflictCount} conflict{conflictCount > 1 ? 's' : ''}
-            </span>
-          </>
-        )}
-        {modifiedCount > 0 && (
-          <>
-            <span style={SEP_STYLE}>|</span>
-            <span
-              role="button"
-              onClick={onClickPending}
-              style={{ ...ICON_STYLE, cursor: 'pointer', padding: '2px 4px', borderRadius: 3, background: 'transparent' }}
-              title="View pending changes"
-              onMouseEnter={e => { e.currentTarget.style.background = 'var(--hover)' }}
-              onMouseLeave={e => { e.currentTarget.style.background = 'transparent' }}
-              data-testid="status-modified-count"
-            ><CircleDot size={13} style={{ color: 'var(--accent-orange)' }} />{modifiedCount} pending</span>
-          </>
-        )}
+        <ConflictBadge count={conflictCount} />
+        <PendingBadge count={modifiedCount} onClick={onClickPending} />
       </div>
       <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
         <span style={ICON_STYLE}><Sparkles size={13} style={{ color: 'var(--accent-purple)' }} />Claude Sonnet 4</span>

src/components/StatusDropdown.tsx

@@ -16,7 +16,7 @@ export function StatusPill({ status, className }: { status: string; className?:
         fontFamily: "'IBM Plex Mono', monospace",
         fontSize: 10,
         fontWeight: 600,
-        letterSpacing: '1.2px',
+        letterSpacing: '0',
         textTransform: 'uppercase' as const,
         maxWidth: 160,
       }}
@@ -101,7 +101,7 @@ const SECTION_LABEL_STYLE = {
   fontFamily: "'IBM Plex Mono', monospace",
   fontSize: 9,
   fontWeight: 500,
-  letterSpacing: '1.2px',
+  letterSpacing: '0',
   textTransform: 'uppercase' as const,
 }
 

src/components/TrashedNoteBanner.test.tsx

@@ -0,0 +1,31 @@
+import { render, screen, fireEvent } from '@testing-library/react'
+import { describe, it, expect, vi } from 'vitest'
+import { TrashedNoteBanner } from './TrashedNoteBanner'
+
+describe('TrashedNoteBanner', () => {
+  it('renders the banner with trash message', () => {
+    render(<TrashedNoteBanner onRestore={vi.fn()} onDeletePermanently={vi.fn()} />)
+    expect(screen.getByText('This note is in the Trash')).toBeInTheDocument()
+    expect(screen.getByTestId('trashed-note-banner')).toBeInTheDocument()
+  })
+
+  it('shows Restore and Delete permanently buttons', () => {
+    render(<TrashedNoteBanner onRestore={vi.fn()} onDeletePermanently={vi.fn()} />)
+    expect(screen.getByText('Restore')).toBeInTheDocument()
+    expect(screen.getByText('Delete permanently')).toBeInTheDocument()
+  })
+
+  it('calls onRestore when Restore button is clicked', () => {
+    const onRestore = vi.fn()
+    render(<TrashedNoteBanner onRestore={onRestore} onDeletePermanently={vi.fn()} />)
+    fireEvent.click(screen.getByTestId('trashed-banner-restore'))
+    expect(onRestore).toHaveBeenCalledOnce()
+  })
+
+  it('calls onDeletePermanently when Delete permanently button is clicked', () => {
+    const onDeletePermanently = vi.fn()
+    render(<TrashedNoteBanner onRestore={vi.fn()} onDeletePermanently={onDeletePermanently} />)
+    fireEvent.click(screen.getByTestId('trashed-banner-delete'))
+    expect(onDeletePermanently).toHaveBeenCalledOnce()
+  })
+})

src/components/TrashedNoteBanner.tsx

@@ -0,0 +1,44 @@
+import { memo } from 'react'
+import { Trash, ArrowCounterClockwise } from '@phosphor-icons/react'
+
+interface TrashedNoteBannerProps {
+  onRestore: () => void
+  onDeletePermanently: () => void
+}
+
+export const TrashedNoteBanner = memo(function TrashedNoteBanner({
+  onRestore,
+  onDeletePermanently,
+}: TrashedNoteBannerProps) {
+  return (
+    <div
+      className="flex shrink-0 items-center gap-3"
+      style={{
+        padding: '6px 16px',
+        background: 'var(--destructive-muted, color-mix(in srgb, var(--destructive) 8%, var(--background)))',
+        borderBottom: '1px solid var(--border)',
+        fontSize: 12,
+      }}
+      data-testid="trashed-note-banner"
+    >
+      <Trash size={14} style={{ color: 'var(--destructive)', flexShrink: 0 }} />
+      <span className="text-muted-foreground" style={{ flex: 1 }}>This note is in the Trash</span>
+      <button
+        className="flex items-center gap-1 border-none bg-transparent px-2 py-0.5 text-xs cursor-pointer rounded transition-colors text-primary hover:bg-accent"
+        onClick={onRestore}
+        data-testid="trashed-banner-restore"
+      >
+        <ArrowCounterClockwise size={12} />
+        Restore
+      </button>
+      <button
+        className="flex items-center gap-1 border-none bg-transparent px-2 py-0.5 text-xs cursor-pointer rounded transition-colors text-destructive hover:bg-destructive/10"
+        onClick={onDeletePermanently}
+        data-testid="trashed-banner-delete"
+      >
+        <Trash size={12} />
+        Delete permanently
+      </button>
+    </div>
+  )
+})

src/hooks/useAppCommands.ts

@@ -51,8 +51,12 @@ interface AppCommandsConfig {
   activeThemeId?: string | null
   onSwitchTheme?: (themeId: string) => void
   onCreateTheme?: () => void
+  onOpenTheme?: (themeId: string) => void
   onOpenVault?: () => void
+  onCreateType?: () => void
   onToggleAIChat?: () => void
+  onCheckForUpdates?: () => void
+  isUpdating?: boolean
 }
 
 /** Sets up keyboard shortcuts, command registry, menu events, and keyboard navigation. */
@@ -88,6 +92,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onGoBack: config.onGoBack,
     onGoForward: config.onGoForward,
     onToggleAIChat: config.onToggleAIChat,
+    onToggleRawEditor: config.onToggleRawEditor,
     activeTabPathRef: config.activeTabPathRef,
     handleCloseTabRef: config.handleCloseTabRef,
   })
@@ -146,8 +151,12 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     activeThemeId: config.activeThemeId,
     onSwitchTheme: config.onSwitchTheme,
     onCreateTheme: config.onCreateTheme,
+    onOpenTheme: config.onOpenTheme,
     onOpenVault: config.onOpenVault,
+    onCreateType: config.onCreateType,
     onToggleAIChat: config.onToggleAIChat,
+    onCheckForUpdates: config.onCheckForUpdates,
+    isUpdating: config.isUpdating,
   })
 
   useKeyboardNavigation({

src/hooks/useAppKeyboard.ts

@@ -18,6 +18,7 @@ interface KeyboardActions {
   onGoBack?: () => void
   onGoForward?: () => void
   onToggleAIChat?: () => void
+  onToggleRawEditor?: () => void
   activeTabPathRef: React.MutableRefObject<string | null>
   handleCloseTabRef: React.MutableRefObject<(path: string) => void>
 }
@@ -63,7 +64,7 @@ function handleCmdKey(e: KeyboardEvent, keyMap: Record<string, ShortcutHandler>)
 
 export function useAppKeyboard({
   onQuickOpen, onCommandPalette, onSearch, onCreateNote, onOpenDailyNote, onSave, onOpenSettings, onTrashNote, onArchiveNote,
-  onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, activeTabPathRef, handleCloseTabRef,
+  onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor, activeTabPathRef, handleCloseTabRef,
 }: KeyboardActions) {
   useEffect(() => {
     const withActiveTab = (fn: (path: string) => void): ShortcutHandler => () => {
@@ -89,6 +90,7 @@ export function useAppKeyboard({
       '-': onZoomOut,
       '0': onZoomReset,
       i: () => onToggleAIChat?.(),
+      '\\': () => onToggleRawEditor?.(),
     }
 
     const handleKeyDown = (e: KeyboardEvent) => {
@@ -104,5 +106,5 @@ export function useAppKeyboard({
     }
     window.addEventListener('keydown', handleKeyDown)
     return () => window.removeEventListener('keydown', handleKeyDown)
-  }, [onQuickOpen, onCommandPalette, onSearch, onCreateNote, onOpenDailyNote, onSave, onOpenSettings, onTrashNote, onArchiveNote, activeTabPathRef, handleCloseTabRef, onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat])
+  }, [onQuickOpen, onCommandPalette, onSearch, onCreateNote, onOpenDailyNote, onSave, onOpenSettings, onTrashNote, onArchiveNote, activeTabPathRef, handleCloseTabRef, onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor])
 }

src/hooks/useCommandRegistry.test.ts

@@ -281,6 +281,76 @@ describe('useCommandRegistry', () => {
     expect(onOpenDailyNote).toHaveBeenCalled()
   })
 
+  describe('check-updates command', () => {
+    it('has check-updates command in Settings group', () => {
+      const { result } = renderHook(() => useCommandRegistry(makeConfig()))
+      const cmd = result.current.find(c => c.id === 'check-updates')
+      expect(cmd).toBeDefined()
+      expect(cmd!.label).toBe('Check for Updates')
+      expect(cmd!.group).toBe('Settings')
+      expect(cmd!.keywords).toContain('update')
+      expect(cmd!.keywords).toContain('version')
+    })
+
+    it('is enabled when not updating', () => {
+      const { result } = renderHook(() =>
+        useCommandRegistry(makeConfig({ isUpdating: false })),
+      )
+      expect(result.current.find(c => c.id === 'check-updates')!.enabled).toBe(true)
+    })
+
+    it('is disabled when updating', () => {
+      const { result } = renderHook(() =>
+        useCommandRegistry(makeConfig({ isUpdating: true })),
+      )
+      expect(result.current.find(c => c.id === 'check-updates')!.enabled).toBe(false)
+    })
+
+    it('calls onCheckForUpdates when executed', () => {
+      const onCheckForUpdates = vi.fn()
+      const { result } = renderHook(() =>
+        useCommandRegistry(makeConfig({ onCheckForUpdates })),
+      )
+      result.current.find(c => c.id === 'check-updates')!.execute()
+      expect(onCheckForUpdates).toHaveBeenCalled()
+    })
+  })
+
+  describe('create-type command', () => {
+    it('has create-type command in Note group when onCreateType is provided', () => {
+      const onCreateType = vi.fn()
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({ onCreateType })))
+      const cmd = result.current.find(c => c.id === 'create-type')
+      expect(cmd).toBeDefined()
+      expect(cmd!.label).toBe('New Type')
+      expect(cmd!.group).toBe('Note')
+      expect(cmd!.enabled).toBe(true)
+    })
+
+    it('is disabled when onCreateType is not provided', () => {
+      const { result } = renderHook(() => useCommandRegistry(makeConfig()))
+      const cmd = result.current.find(c => c.id === 'create-type')
+      expect(cmd).toBeDefined()
+      expect(cmd!.enabled).toBe(false)
+    })
+
+    it('calls onCreateType when executed', () => {
+      const onCreateType = vi.fn()
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({ onCreateType })))
+      result.current.find(c => c.id === 'create-type')!.execute()
+      expect(onCreateType).toHaveBeenCalled()
+    })
+
+    it('has relevant keywords for discoverability', () => {
+      const onCreateType = vi.fn()
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({ onCreateType })))
+      const cmd = result.current.find(c => c.id === 'create-type')
+      expect(cmd!.keywords).toContain('new')
+      expect(cmd!.keywords).toContain('create')
+      expect(cmd!.keywords).toContain('type')
+    })
+  })
+
   describe('type-aware commands', () => {
     it('generates "New [Type]" commands from vault entries', () => {
       const entries = [
@@ -437,6 +507,46 @@ describe('useCommandRegistry', () => {
       const groups = new Set(result.current.map(c => c.group))
       expect(groups).toContain('Appearance')
     })
+
+    it('generates open-theme commands for each theme when onOpenTheme is provided', () => {
+      const onOpenTheme = vi.fn()
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({
+        themes: themeFixtures, activeThemeId: 'default', onOpenTheme,
+      })))
+      const openDefault = result.current.find(c => c.id === 'open-theme-default')
+      const openDark = result.current.find(c => c.id === 'open-theme-dark')
+      expect(openDefault).toBeDefined()
+      expect(openDefault!.label).toBe('Edit Default Theme')
+      expect(openDefault!.group).toBe('Appearance')
+      expect(openDefault!.enabled).toBe(true)
+      expect(openDark).toBeDefined()
+      expect(openDark!.label).toBe('Edit Dark Theme')
+    })
+
+    it('omits open-theme commands when onOpenTheme is not provided', () => {
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({
+        themes: themeFixtures, activeThemeId: 'default',
+      })))
+      expect(result.current.find(c => c.id === 'open-theme-default')).toBeUndefined()
+      expect(result.current.find(c => c.id === 'open-theme-dark')).toBeUndefined()
+    })
+
+    it('calls onOpenTheme with correct themeId when open-theme command executes', () => {
+      const onOpenTheme = vi.fn()
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({
+        themes: themeFixtures, activeThemeId: 'default', onOpenTheme,
+      })))
+      result.current.find(c => c.id === 'open-theme-dark')!.execute()
+      expect(onOpenTheme).toHaveBeenCalledWith('dark')
+    })
+
+    it('open-theme command is always enabled regardless of active theme', () => {
+      const onOpenTheme = vi.fn()
+      const { result } = renderHook(() => useCommandRegistry(makeConfig({
+        themes: themeFixtures, activeThemeId: 'default', onOpenTheme,
+      })))
+      expect(result.current.find(c => c.id === 'open-theme-default')!.enabled).toBe(true)
+    })
   })
 })
 

src/hooks/useCommandRegistry.ts

@@ -25,6 +25,7 @@ interface CommandRegistryConfig {
   onSave: () => void
   onOpenSettings: () => void
   onOpenVault?: () => void
+  onCreateType?: () => void
   onTrashNote: (path: string) => void
   onRestoreNote: (path: string) => void
   onArchiveNote: (path: string) => void
@@ -34,6 +35,8 @@ interface CommandRegistryConfig {
   onToggleInspector: () => void
   onToggleRawEditor?: () => void
   onToggleAIChat?: () => void
+  onCheckForUpdates?: () => void
+  isUpdating?: boolean
   onZoomIn: () => void
   onZoomOut: () => void
   onZoomReset: () => void
@@ -49,6 +52,7 @@ interface CommandRegistryConfig {
   activeThemeId?: string | null
   onSwitchTheme?: (themeId: string) => void
   onCreateTheme?: () => void
+  onOpenTheme?: (themeId: string) => void
 }
 
 const PLURAL_OVERRIDES: Record<string, string> = {
@@ -132,22 +136,36 @@ export function buildThemeCommands(
   activeThemeId: string | null | undefined,
   onSwitchTheme: ((themeId: string) => void) | undefined,
   onCreateTheme: (() => void) | undefined,
+  onOpenTheme: ((themeId: string) => void) | undefined,
 ): CommandAction[] {
-  const switchCmds = (themes ?? []).map(t => ({
-    id: `switch-theme-${t.id}`,
-    label: `Switch to ${t.name} Theme`,
-    group: 'Appearance' as CommandGroup,
-    keywords: ['theme', 'appearance', 'color', t.name.toLowerCase()],
-    enabled: t.id !== activeThemeId,
-    execute: () => onSwitchTheme?.(t.id),
-  }))
+  const cmds: CommandAction[] = []
+  for (const t of (themes ?? [])) {
+    cmds.push({
+      id: `switch-theme-${t.id}`,
+      label: `Switch to ${t.name} Theme`,
+      group: 'Appearance' as CommandGroup,
+      keywords: ['theme', 'appearance', 'color', t.name.toLowerCase()],
+      enabled: t.id !== activeThemeId,
+      execute: () => onSwitchTheme?.(t.id),
+    })
+    if (onOpenTheme) {
+      cmds.push({
+        id: `open-theme-${t.id}`,
+        label: `Edit ${t.name} Theme`,
+        group: 'Appearance' as CommandGroup,
+        keywords: ['theme', 'edit', 'open', 'appearance', t.name.toLowerCase()],
+        enabled: true,
+        execute: () => onOpenTheme(t.id),
+      })
+    }
+  }
   if (onCreateTheme) {
-    switchCmds.push({
+    cmds.push({
       id: 'new-theme', label: 'New Theme', group: 'Appearance' as CommandGroup,
       keywords: ['theme', 'create', 'appearance'], enabled: true, execute: onCreateTheme,
     })
   }
-  return switchCmds
+  return cmds
 }
 
 export function useCommandRegistry(config: CommandRegistryConfig): CommandAction[] {
@@ -159,7 +177,9 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     onZoomIn, onZoomOut, onZoomReset, zoomLevel,
     onSelect, onOpenDailyNote, onCloseTab,
     onGoBack, onGoForward, canGoBack, canGoForward,
-    themes, activeThemeId, onSwitchTheme, onCreateTheme,
+    themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenTheme,
+    onCheckForUpdates, isUpdating,
+    onCreateType,
   } = config
 
   const hasActiveNote = activeTabPath !== null
@@ -187,6 +207,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
 
       // Note actions (contextual)
       { id: 'create-note', label: 'Create New Note', group: 'Note', shortcut: '⌘N', keywords: ['new', 'add'], enabled: true, execute: onCreateNote },
+      { id: 'create-type', label: 'New Type', group: 'Note', keywords: ['new', 'create', 'type', 'template'], enabled: !!onCreateType, execute: () => onCreateType?.() },
       { id: 'open-daily-note', label: "Open Today's Note", group: 'Note', shortcut: '⌘J', keywords: ['daily', 'journal', 'today'], enabled: true, execute: onOpenDailyNote },
       { id: 'save-note', label: 'Save Note', group: 'Note', shortcut: '⌘S', keywords: ['write'], enabled: hasActiveNote, execute: onSave },
       { id: 'close-tab', label: 'Close Tab', group: 'Note', shortcut: '⌘W', keywords: [], enabled: hasActiveNote, execute: () => { if (activeTabPath) onCloseTab(activeTabPath) } },
@@ -209,11 +230,12 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
       ...buildViewCommands(hasActiveNote, onSetViewMode, onToggleInspector, onToggleRawEditor, onToggleAIChat, zoomLevel, onZoomIn, onZoomOut, onZoomReset),
 
       // Appearance
-      ...buildThemeCommands(themes, activeThemeId, onSwitchTheme, onCreateTheme),
+      ...buildThemeCommands(themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenTheme),
 
       // Settings
       { id: 'open-settings', label: 'Open Settings', group: 'Settings', shortcut: '⌘,', keywords: ['preferences', 'config'], enabled: true, execute: onOpenSettings },
       { id: 'open-vault', label: 'Open Vault…', group: 'Settings', keywords: ['vault', 'folder', 'switch', 'open', 'workspace'], enabled: true, execute: () => onOpenVault?.() },
+      { id: 'check-updates', label: 'Check for Updates', group: 'Settings', keywords: ['update', 'version', 'upgrade', 'release'], enabled: !isUpdating, execute: () => onCheckForUpdates?.() },
 
       // Type-aware: "New [Type]" and "List [Type]"
       ...buildTypeCommands(vaultTypes, onCreateNoteOfType, onSelect),
@@ -222,12 +244,13 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     return cmds
   }, [
     hasActiveNote, activeTabPath, isArchived, isTrashed, modifiedCount,
-    onQuickOpen, onCreateNote, onCreateNoteOfType, onSave, onOpenSettings,
+    onQuickOpen, onCreateNote, onCreateNoteOfType, onCreateType, onSave, onOpenSettings,
     onTrashNote, onRestoreNote, onArchiveNote, onUnarchiveNote,
     onCommitPush, onSetViewMode, onToggleInspector, onToggleRawEditor, onToggleAIChat, onOpenVault,
+    onCheckForUpdates, isUpdating,
     onZoomIn, onZoomOut, onZoomReset, zoomLevel,
     onSelect, onOpenDailyNote, onCloseTab,
     onGoBack, onGoForward, canGoBack, canGoForward,
-    vaultTypes, themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenVault,
+    vaultTypes, themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenTheme,
   ])
 }

src/hooks/useEditorFocus.test.ts

@@ -110,6 +110,9 @@ describe('useEditorFocus', () => {
 
     it('selects H1 text after timeout when editor not yet mounted', () => {
       vi.useFakeTimers()
+      // Mock rAF synchronously so the deferred selectFirstHeading call inside doFocus
+      // runs immediately when requestAnimationFrame is invoked, keeping the test simple.
+      vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => { cb(0); return 0 })
       const tiptap = makeTiptapMock(true)
       const { editor } = setup(false, tiptap)
 
@@ -122,5 +125,37 @@ describe('useEditorFocus', () => {
       expect(tiptap._chainResult.setTextSelection).toHaveBeenCalledWith({ from: 3, to: 16 })
       vi.useRealTimers()
     })
+
+    it('selection happens in second rAF (not first), allowing content swap to complete', () => {
+      // Verify the double-rAF contract: focus in rAF1, selection deferred to rAF2.
+      // This ensures the new note's blocks are applied (via queueMicrotask between frames)
+      // before selectFirstHeading runs.
+      const callbacks: FrameRequestCallback[] = []
+      vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => {
+        callbacks.push(cb)
+        return callbacks.length
+      })
+      const tiptap = makeTiptapMock(true)
+      const { editor } = setup(true, tiptap)
+
+      window.dispatchEvent(new CustomEvent('laputa:focus-editor', { detail: { selectTitle: true } }))
+
+      // rAF 1 is scheduled (doFocus)
+      expect(callbacks.length).toBe(1)
+      callbacks[0](0)
+
+      // After rAF 1: editor focused, but selection NOT yet triggered
+      expect(editor.focus).toHaveBeenCalled()
+      expect(tiptap.chain).not.toHaveBeenCalled()
+
+      // rAF 2 is now scheduled (selectFirstHeading)
+      expect(callbacks.length).toBe(2)
+      callbacks[1](0)
+
+      // After rAF 2: heading is selected
+      expect(tiptap.chain).toHaveBeenCalled()
+      expect(tiptap._chainResult.setTextSelection).toHaveBeenCalledWith({ from: 3, to: 16 })
+      expect(tiptap._chainResult.run).toHaveBeenCalled()
+    })
   })
 })

src/hooks/useEditorFocus.ts

@@ -48,8 +48,20 @@ export function useEditorFocus(
       const selectTitle = detail?.selectTitle ?? false
       const doFocus = () => {
         editor.focus()
-        if (selectTitle) selectFirstHeading(editor)
-        if (t0) console.debug(`[perf] createNote → focus: ${(performance.now() - t0).toFixed(1)}ms`)
+        if (!selectTitle) {
+          if (t0) console.debug(`[perf] createNote → focus: ${(performance.now() - t0).toFixed(1)}ms`)
+          return
+        }
+        // Defer selection to the next animation frame so the new note's content
+        // (applied via queueMicrotask inside a React effect triggered by the tab
+        // change) is in the document before we try to select the heading.
+        // Between two rAF callbacks, all pending macrotasks — including React's
+        // MessageChannel re-render and the subsequent queueMicrotask content swap
+        // — complete, so the heading block is guaranteed to exist by rAF 2.
+        requestAnimationFrame(() => {
+          selectFirstHeading(editor)
+          if (t0) console.debug(`[perf] createNote → focus+select: ${(performance.now() - t0).toFixed(1)}ms`)
+        })
       }
       if (editorMountedRef.current) {
         requestAnimationFrame(doFocus)

src/hooks/useEntryActions.test.ts

@@ -238,4 +238,54 @@ describe('useEntryActions', () => {
       expect(updateEntry).toHaveBeenCalledTimes(1)
     })
   })
+
+  describe('handleRenameSection', () => {
+    it('writes sidebar label frontmatter and updates entry in memory', async () => {
+      const typeEntry = makeEntry({ isA: 'Type', title: 'Recipe', path: '/vault/type/recipe.md', sidebarLabel: null })
+      const { result } = setup([typeEntry])
+
+      await act(async () => {
+        await result.current.handleRenameSection('Recipe', 'Recipes')
+      })
+
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/type/recipe.md', 'sidebar label', 'Recipes')
+      expect(updateEntry).toHaveBeenCalledWith('/vault/type/recipe.md', { sidebarLabel: 'Recipes' })
+    })
+
+    it('trims whitespace before saving', async () => {
+      const typeEntry = makeEntry({ isA: 'Type', title: 'Recipe', path: '/vault/type/recipe.md', sidebarLabel: null })
+      const { result } = setup([typeEntry])
+
+      await act(async () => {
+        await result.current.handleRenameSection('Recipe', '  Dishes  ')
+      })
+
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/type/recipe.md', 'sidebar label', 'Dishes')
+      expect(updateEntry).toHaveBeenCalledWith('/vault/type/recipe.md', { sidebarLabel: 'Dishes' })
+    })
+
+    it('deletes sidebar label when label is empty', async () => {
+      const typeEntry = makeEntry({ isA: 'Type', title: 'Recipe', path: '/vault/type/recipe.md', sidebarLabel: 'Dishes' })
+      const { result } = setup([typeEntry])
+
+      await act(async () => {
+        await result.current.handleRenameSection('Recipe', '')
+      })
+
+      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/type/recipe.md', 'sidebar label')
+      expect(updateEntry).toHaveBeenCalledWith('/vault/type/recipe.md', { sidebarLabel: null })
+      expect(handleUpdateFrontmatter).not.toHaveBeenCalled()
+    })
+
+    it('does nothing when type entry not found', async () => {
+      const { result } = setup([])
+
+      await act(async () => {
+        await result.current.handleRenameSection('NonExistent', 'Label')
+      })
+
+      expect(handleUpdateFrontmatter).not.toHaveBeenCalled()
+      expect(updateEntry).not.toHaveBeenCalled()
+    })
+  })
 })

src/hooks/useEntryActions.ts

@@ -68,5 +68,17 @@ export function useEntryActions({
     updateEntry(typeEntry.path, { template: template || null })
   }, [entries, handleUpdateFrontmatter, updateEntry])
 
-  return { handleTrashNote, handleRestoreNote, handleArchiveNote, handleUnarchiveNote, handleCustomizeType, handleReorderSections, handleUpdateTypeTemplate }
+  const handleRenameSection = useCallback(async (typeName: string, label: string) => {
+    const typeEntry = findTypeEntry(entries, typeName)
+    if (!typeEntry) return
+    const trimmed = label.trim()
+    updateEntry(typeEntry.path, { sidebarLabel: trimmed || null })
+    if (trimmed) {
+      await handleUpdateFrontmatter(typeEntry.path, 'sidebar label', trimmed)
+    } else {
+      await handleDeleteProperty(typeEntry.path, 'sidebar label')
+    }
+  }, [entries, handleUpdateFrontmatter, handleDeleteProperty, updateEntry])
+
+  return { handleTrashNote, handleRestoreNote, handleArchiveNote, handleUnarchiveNote, handleCustomizeType, handleReorderSections, handleUpdateTypeTemplate, handleRenameSection }
 }

src/hooks/useOnboarding.test.ts

@@ -20,6 +20,9 @@ vi.mock('../mock-tauri', () => ({
   mockInvoke: (...args: unknown[]) => mockInvokeFn(...args),
 }))
 
+vi.mock('./useVaultSwitcher', () => ({
+}))
+
 vi.mock('../utils/vault-dialog', () => ({
   pickFolder: vi.fn(),
 }))
@@ -35,7 +38,7 @@ describe('useOnboarding', () => {
 
   it('transitions to ready when vault exists', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return true
       return null
     })
@@ -50,7 +53,7 @@ describe('useOnboarding', () => {
 
   it('shows welcome screen when vault does not exist', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
       return null
     })
@@ -60,14 +63,14 @@ describe('useOnboarding', () => {
     await waitFor(() => {
       expect(result.current.state.status).toBe('welcome')
     })
-    expect(result.current.state).toEqual({ status: 'welcome', defaultPath: '/mock/Documents/Laputa' })
+    expect(result.current.state).toEqual({ status: 'welcome', defaultPath: '/mock/Documents/Getting Started' })
   })
 
   it('shows vault-missing when previously dismissed and vault gone', async () => {
     localStorage.setItem('laputa_welcome_dismissed', '1')
 
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
       return null
     })
@@ -80,15 +83,15 @@ describe('useOnboarding', () => {
     expect(result.current.state).toEqual({
       status: 'vault-missing',
       vaultPath: '/vault/deleted',
-      defaultPath: '/mock/Documents/Laputa',
+      defaultPath: '/mock/Documents/Getting Started',
     })
   })
 
   it('handleCreateVault creates vault and transitions to ready', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
-      if (cmd === 'create_getting_started_vault') return '/mock/Documents/Laputa'
+      if (cmd === 'create_getting_started_vault') return '/mock/Documents/Getting Started'
       return null
     })
 
@@ -102,13 +105,13 @@ describe('useOnboarding', () => {
       await result.current.handleCreateVault()
     })
 
-    expect(result.current.state).toEqual({ status: 'ready', vaultPath: '/mock/Documents/Laputa' })
+    expect(result.current.state).toEqual({ status: 'ready', vaultPath: '/mock/Documents/Getting Started' })
     expect(localStorage.getItem('laputa_welcome_dismissed')).toBe('1')
   })
 
   it('handleCreateVault sets error on failure', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
       if (cmd === 'create_getting_started_vault') throw 'Permission denied'
       return null
@@ -130,7 +133,7 @@ describe('useOnboarding', () => {
 
   it('handleOpenFolder opens folder picker and transitions to ready', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
       return null
     })
@@ -152,7 +155,7 @@ describe('useOnboarding', () => {
 
   it('handleOpenFolder does nothing when picker is cancelled', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
       return null
     })
@@ -173,7 +176,7 @@ describe('useOnboarding', () => {
 
   it('handleDismiss marks dismissed and transitions to ready', async () => {
     mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'get_default_vault_path') return '/mock/Documents/Laputa'
+      if (cmd === 'get_default_vault_path') return '/mock/Documents/Getting Started'
       if (cmd === 'check_vault_exists') return false
       return null
     })

src/hooks/useThemeManager.test.ts

@@ -1,356 +1,348 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { renderHook, act, waitFor } from '@testing-library/react'
-import type { ThemeFile, VaultSettings } from '../types'
+import type { VaultEntry } from '../types'
 
-const mockThemes: ThemeFile[] = [
-  {
-    id: 'default', name: 'Default', description: 'Clean default theme',
-    colors: { background: '#FFFFFF', foreground: '#1A1A2E', primary: '#6366F1', border: '#E2E8F0', 'sidebar-background': '#F8FAFC' },
-    typography: { 'font-family': 'Inter, sans-serif' },
-    spacing: { 'sidebar-width': '240px' },
-  },
-  {
-    id: 'dark', name: 'Dark', description: 'Dark theme',
-    colors: { background: '#0F0F23', foreground: '#E2E8F0', primary: '#818CF8', border: '#1E293B' },
-    typography: { 'font-family': 'Inter, sans-serif' },
-    spacing: {},
-  },
-]
+const THEME_PATH_DEFAULT = '/vault/theme/default.md'
+const THEME_PATH_DARK = '/vault/theme/dark.md'
 
-const mockSettings: VaultSettings = { theme: 'default' }
+const DEFAULT_THEME_CONTENT = `---
+Is A: Theme
+Description: Light theme
+background: "#FFFFFF"
+foreground: "#37352F"
+primary: "#155DFF"
+sidebar: "#F7F6F3"
+text-primary: "#37352F"
+---
 
-const mockInvokeFn = vi.fn(async (cmd: string) => {
-  if (cmd === 'list_themes') return mockThemes
-  if (cmd === 'get_vault_settings') return mockSettings
+# Default Theme
+`
+
+const DARK_THEME_CONTENT = `---
+Is A: Theme
+Description: Dark theme
+background: "#0f0f1a"
+foreground: "#e0e0e0"
+primary: "#155DFF"
+sidebar: "#1a1a2e"
+text-primary: "#e0e0e0"
+---
+
+# Dark Theme
+`
+
+function makeThemeEntry(path: string, title: string): VaultEntry {
+  return {
+    path,
+    filename: path.split('/').pop()!,
+    title,
+    isA: 'Theme',
+    aliases: [],
+    belongsTo: [],
+    relatedTo: [],
+    status: null,
+    owner: null,
+    cadence: null,
+    archived: false,
+    trashed: false,
+    trashedAt: null,
+    modifiedAt: null,
+    createdAt: null,
+    fileSize: 0,
+    snippet: '',
+    wordCount: 0,
+    relationships: {},
+    icon: null,
+    color: null,
+    order: null,
+    sidebarLabel: null,
+    template: null,
+    outgoingLinks: [],
+  }
+}
+
+const defaultEntry = makeThemeEntry(THEME_PATH_DEFAULT, 'Default Theme')
+const darkEntry = makeThemeEntry(THEME_PATH_DARK, 'Dark Theme')
+
+const mockInvokeFn = vi.fn(async (cmd: string, args?: Record<string, unknown>) => {
+  if (cmd === 'get_vault_settings') return { theme: THEME_PATH_DEFAULT }
+  if (cmd === 'get_note_content') {
+    const path = args?.path as string | undefined
+    if (path === THEME_PATH_DEFAULT) return DEFAULT_THEME_CONTENT
+    if (path === THEME_PATH_DARK) return DARK_THEME_CONTENT
+    return ''
+  }
   if (cmd === 'set_active_theme') return null
-  if (cmd === 'create_theme') return 'new-theme-id'
+  if (cmd === 'create_vault_theme') return '/vault/theme/untitled.md'
   return null
 })
 
-vi.mock('@tauri-apps/api/core', () => ({
-  invoke: vi.fn(),
-}))
-
+vi.mock('@tauri-apps/api/core', () => ({ invoke: vi.fn() }))
 vi.mock('../mock-tauri', () => ({
   isTauri: () => false,
   mockInvoke: (cmd: string, args?: Record<string, unknown>) => mockInvokeFn(cmd, args),
 }))
 
-// Must import after mocks
-const { useThemeManager, isColorDark } = await import('./useThemeManager')
+const { useThemeManager, extractCssVars } = await import('./useThemeManager')
 
-describe('isColorDark', () => {
-  it('identifies dark colors', () => {
-    expect(isColorDark('#000000')).toBe(true)
-    expect(isColorDark('#0F0F23')).toBe(true)
-    expect(isColorDark('#1a1a2e')).toBe(true)
-    expect(isColorDark('#0f0f1a')).toBe(true)
+describe('extractCssVars', () => {
+  it('extracts color variables from frontmatter', () => {
+    const vars = extractCssVars(DEFAULT_THEME_CONTENT)
+    expect(vars['--background']).toBe('#FFFFFF')
+    expect(vars['--foreground']).toBe('#37352F')
+    expect(vars['--primary']).toBe('#155DFF')
   })
 
-  it('identifies light colors', () => {
-    expect(isColorDark('#FFFFFF')).toBe(false)
-    expect(isColorDark('#F7F6F3')).toBe(false)
-    expect(isColorDark('#E0E0E0')).toBe(false)
+  it('excludes metadata keys', () => {
+    const vars = extractCssVars(DEFAULT_THEME_CONTENT)
+    expect('--Is A' in vars).toBe(false)
+    expect('--Description' in vars).toBe(false)
   })
 })
 
 describe('useThemeManager', () => {
+  const entries = [defaultEntry, darkEntry]
+  const allContent: Record<string, string> = {}
+
   beforeEach(() => {
     vi.clearAllMocks()
-    mockInvokeFn.mockImplementation(async (cmd: string) => {
-      if (cmd === 'list_themes') return mockThemes
-      if (cmd === 'get_vault_settings') return mockSettings
+    mockInvokeFn.mockImplementation(async (cmd: string, args?: Record<string, unknown>) => {
+      if (cmd === 'get_vault_settings') return { theme: THEME_PATH_DEFAULT }
+      if (cmd === 'get_note_content') {
+        const path = args?.path as string | undefined
+        if (path === THEME_PATH_DEFAULT) return DEFAULT_THEME_CONTENT
+        if (path === THEME_PATH_DARK) return DARK_THEME_CONTENT
+        return ''
+      }
       if (cmd === 'set_active_theme') return null
-      if (cmd === 'create_theme') return 'new-theme-id'
+      if (cmd === 'create_vault_theme') return '/vault/theme/untitled.md'
       return null
     })
-    // Clear any theme CSS properties from previous tests
-    const root = document.documentElement
-    root.style.cssText = ''
+    document.documentElement.style.cssText = ''
   })
 
-  it('loads themes and active theme on mount', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
+  it('builds themes list from vault entries with isA === Theme', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
     await waitFor(() => {
       expect(result.current.themes).toHaveLength(2)
     })
-    expect(result.current.activeThemeId).toBe('default')
-    expect(result.current.activeTheme?.name).toBe('Default')
+    expect(result.current.themes[0].name).toBe('Default Theme')
+    expect(result.current.themes[0].id).toBe(THEME_PATH_DEFAULT)
+  })
+
+  it('loads active theme from vault settings on mount', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => {
+      expect(result.current.activeThemeId).toBe(THEME_PATH_DEFAULT)
+    })
+    expect(result.current.activeTheme?.name).toBe('Default Theme')
+  })
+
+  it('applies CSS vars from theme note content', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => {
+      expect(result.current.activeTheme).not.toBeNull()
+    })
+    const root = document.documentElement
+    expect(root.style.getPropertyValue('--background')).toBe('#FFFFFF')
+    expect(root.style.getPropertyValue('--foreground')).toBe('#37352F')
+    expect(root.style.getPropertyValue('--primary')).toBe('#155DFF')
   })
 
   it('returns empty state when vaultPath is null', async () => {
-    const { result } = renderHook(() => useThemeManager(null))
-    // Give it time to settle — should remain empty
+    const { result } = renderHook(() =>
+      useThemeManager(null, entries, allContent)
+    )
     await new Promise(r => setTimeout(r, 50))
-    expect(result.current.themes).toHaveLength(0)
     expect(result.current.activeThemeId).toBeNull()
     expect(result.current.activeTheme).toBeNull()
     expect(mockInvokeFn).not.toHaveBeenCalled()
   })
 
-  it('applies CSS custom properties for active theme', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
+  it('excludes trashed entries from themes list', async () => {
+    const trashedEntry = { ...darkEntry, trashed: true }
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', [defaultEntry, trashedEntry], allContent)
+    )
     await waitFor(() => {
-      expect(result.current.activeTheme).not.toBeNull()
+      expect(result.current.themes).toHaveLength(1)
     })
-    const root = document.documentElement
-    expect(root.style.getPropertyValue('--background')).toBe('#FFFFFF')
-    expect(root.style.getPropertyValue('--foreground')).toBe('#1A1A2E')
-    expect(root.style.getPropertyValue('--primary')).toBe('#6366F1')
-    expect(root.style.getPropertyValue('--theme-background')).toBe('#FFFFFF')
-    expect(root.style.getPropertyValue('--theme-font-family')).toBe('Inter, sans-serif')
-    expect(root.style.getPropertyValue('--theme-sidebar-width')).toBe('240px')
-  })
-
-  it('maps sidebar-background to --sidebar', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.activeTheme).not.toBeNull()
-    })
-    expect(document.documentElement.style.getPropertyValue('--sidebar')).toBe('#F8FAFC')
+    expect(result.current.themes[0].name).toBe('Default Theme')
   })
 
   it('switchTheme calls set_active_theme and updates activeThemeId', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => { expect(result.current.themes).toHaveLength(2) })
+
+    await act(async () => {
+      await result.current.switchTheme(THEME_PATH_DARK)
+    })
+
+    expect(mockInvokeFn).toHaveBeenCalledWith('set_active_theme', {
+      vaultPath: '/vault', themeId: THEME_PATH_DARK,
+    })
+    expect(result.current.activeThemeId).toBe(THEME_PATH_DARK)
+  })
+
+  it('clears old CSS vars and applies new theme on switch', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
     await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
+      expect(document.documentElement.style.getPropertyValue('--background')).toBe('#FFFFFF')
     })
 
     await act(async () => {
-      await result.current.switchTheme('dark')
+      await result.current.switchTheme(THEME_PATH_DARK)
     })
 
-    expect(mockInvokeFn).toHaveBeenCalledWith('set_active_theme', { vaultPath: '/vault', themeId: 'dark' })
-    expect(result.current.activeThemeId).toBe('dark')
+    await waitFor(() => {
+      expect(document.documentElement.style.getPropertyValue('--background')).toBe('#0f0f1a')
+    })
   })
 
-  it('clears old theme CSS and applies new theme on switch', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.activeTheme?.id).toBe('default')
-    })
-
-    const root = document.documentElement
-    expect(root.style.getPropertyValue('--background')).toBe('#FFFFFF')
+  it('createTheme calls create_vault_theme and switches to new theme', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => { expect(result.current.themes).toHaveLength(2) })
 
+    let newPath = ''
     await act(async () => {
-      await result.current.switchTheme('dark')
+      newPath = await result.current.createTheme('My Theme')
     })
 
-    await waitFor(() => {
-      expect(root.style.getPropertyValue('--background')).toBe('#0F0F23')
+    expect(newPath).toBe('/vault/theme/untitled.md')
+    expect(mockInvokeFn).toHaveBeenCalledWith('create_vault_theme', {
+      vaultPath: '/vault', name: 'My Theme',
     })
-    expect(root.style.getPropertyValue('--foreground')).toBe('#E2E8F0')
+    expect(result.current.activeThemeId).toBe('/vault/theme/untitled.md')
   })
 
-  it('createTheme calls create_theme and reloads themes', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
-
-    let newId = ''
-    await act(async () => {
-      newId = await result.current.createTheme('default')
-    })
-
-    expect(newId).toBe('new-theme-id')
-    expect(mockInvokeFn).toHaveBeenCalledWith('create_theme', { vaultPath: '/vault', sourceId: 'default' })
-    // Should reload after creation
-    const listCalls = mockInvokeFn.mock.calls.filter(c => c[0] === 'list_themes')
-    expect(listCalls.length).toBeGreaterThanOrEqual(2)
-  })
-
-  it('createTheme passes null source_id when no sourceId provided', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
+  it('createTheme passes null name when none provided', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => { expect(result.current.themes).toHaveLength(2) })
 
     await act(async () => {
       await result.current.createTheme()
     })
 
-    expect(mockInvokeFn).toHaveBeenCalledWith('create_theme', { vaultPath: '/vault', sourceId: null })
+    expect(mockInvokeFn).toHaveBeenCalledWith('create_vault_theme', {
+      vaultPath: '/vault', name: null,
+    })
+  })
+
+  it('falls back when active theme is trashed', async () => {
+    const { result, rerender } = renderHook(
+      ({ ents }) => useThemeManager('/vault', ents, allContent),
+      { initialProps: { ents: entries } },
+    )
+    await waitFor(() => {
+      expect(result.current.activeThemeId).toBe(THEME_PATH_DEFAULT)
+    })
+
+    const trashedDefault = { ...defaultEntry, trashed: true }
+    rerender({ ents: [trashedDefault, darkEntry] })
+
+    await waitFor(() => {
+      expect(result.current.activeThemeId).toBeNull()
+    })
+    // CSS vars are cleared from tracked applied vars — DOM state depends on prior apply
   })
 
   it('handles load failure gracefully', async () => {
     const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     mockInvokeFn.mockRejectedValue(new Error('disk error'))
 
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(warnSpy).toHaveBeenCalledWith('Failed to load themes:', expect.any(Error))
-    })
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await new Promise(r => setTimeout(r, 50))
 
-    expect(result.current.themes).toHaveLength(0)
     expect(result.current.activeThemeId).toBeNull()
     warnSpy.mockRestore()
   })
 
   it('handles switchTheme failure gracefully', async () => {
     const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => { expect(result.current.themes).toHaveLength(2) })
 
     mockInvokeFn.mockRejectedValueOnce(new Error('permission denied'))
 
     await act(async () => {
-      await result.current.switchTheme('dark')
+      await result.current.switchTheme(THEME_PATH_DARK)
     })
 
-    // Should not have changed the active theme
-    expect(result.current.activeThemeId).toBe('default')
-    expect(errorSpy).toHaveBeenCalledWith('Failed to switch theme:', expect.any(Error))
-    errorSpy.mockRestore()
-  })
-
-  it('handles createTheme failure gracefully', async () => {
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
-
-    mockInvokeFn.mockRejectedValueOnce(new Error('write error'))
-
-    let newId = ''
-    await act(async () => {
-      newId = await result.current.createTheme('default')
-    })
-
-    expect(newId).toBe('')
-    expect(errorSpy).toHaveBeenCalledWith('Failed to create theme:', expect.any(Error))
+    expect(result.current.activeThemeId).toBe(THEME_PATH_DEFAULT)
     errorSpy.mockRestore()
   })
 
   it('switchTheme is a no-op when vaultPath is null', async () => {
-    const { result } = renderHook(() => useThemeManager(null))
+    const { result } = renderHook(() =>
+      useThemeManager(null, entries, allContent)
+    )
     await act(async () => {
-      await result.current.switchTheme('dark')
+      await result.current.switchTheme(THEME_PATH_DARK)
     })
     expect(mockInvokeFn).not.toHaveBeenCalledWith('set_active_theme', expect.anything())
   })
 
   it('createTheme returns empty string when vaultPath is null', async () => {
-    const { result } = renderHook(() => useThemeManager(null))
-    let newId = ''
+    const { result } = renderHook(() =>
+      useThemeManager(null, entries, allContent)
+    )
+    let newPath = ''
     await act(async () => {
-      newId = await result.current.createTheme()
+      newPath = await result.current.createTheme()
     })
-    expect(newId).toBe('')
+    expect(newPath).toBe('')
   })
 
-  it('isDark is false for light theme', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.activeTheme?.id).toBe('default')
-    })
-    expect(result.current.isDark).toBe(false)
-  })
-
-  it('isDark is true for dark theme', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
-
-    await act(async () => {
-      await result.current.switchTheme('dark')
-    })
-
-    expect(result.current.isDark).toBe(true)
-  })
-
-  it('isDark is false when no active theme', async () => {
-    const { result } = renderHook(() => useThemeManager(null))
-    expect(result.current.isDark).toBe(false)
-  })
-
-  it('derives app-specific CSS variables from theme colors', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
+  it('re-applies theme when active content changes in allContent', async () => {
+    const { result, rerender } = renderHook(
+      ({ content }) => useThemeManager('/vault', entries, content),
+      { initialProps: { content: allContent } },
+    )
     await waitFor(() => {
       expect(result.current.activeTheme).not.toBeNull()
     })
 
-    const root = document.documentElement
-    expect(root.style.getPropertyValue('--bg-primary')).toBe('#FFFFFF')
-    expect(root.style.getPropertyValue('--text-primary')).toBe('#1A1A2E')
-    expect(root.style.getPropertyValue('--text-heading')).toBe('#1A1A2E')
-    expect(root.style.getPropertyValue('--border-primary')).toBe('#E2E8F0')
+    const newContent = {
+      [THEME_PATH_DEFAULT]: `---\nIs A: Theme\nbackground: "#FF0000"\n---\n# Default Theme\n`,
+    }
+    rerender({ content: newContent })
+
+    await waitFor(() => {
+      expect(document.documentElement.style.getPropertyValue('--background')).toBe('#FF0000')
+    })
   })
 
-  it('sets color-scheme and data-theme-mode for dark theme', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
+  it('reloadThemes re-reads vault settings', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => { expect(result.current.themes).toHaveLength(2) })
 
-    await act(async () => {
-      await result.current.switchTheme('dark')
-    })
-
-    const root = document.documentElement
-    await waitFor(() => {
-      expect(root.style.getPropertyValue('color-scheme')).toBe('dark')
-    })
-    expect(root.dataset.themeMode).toBe('dark')
-    expect(root.style.getPropertyValue('--bg-primary')).toBe('#0F0F23')
-    expect(root.style.getPropertyValue('--text-primary')).toBe('#E2E8F0')
-  })
-
-  it('sets color-scheme to light for light theme', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.activeTheme).not.toBeNull()
-    })
-
-    const root = document.documentElement
-    expect(root.style.getPropertyValue('color-scheme')).toBe('light')
-    expect(root.dataset.themeMode).toBe('light')
-  })
-
-  it('updates derived variables when switching between themes', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
-
-    await act(async () => {
-      await result.current.switchTheme('dark')
-    })
-
-    const root = document.documentElement
-    await waitFor(() => {
-      expect(root.style.getPropertyValue('--bg-primary')).toBe('#0F0F23')
-    })
-
-    await act(async () => {
-      await result.current.switchTheme('default')
-    })
-
-    await waitFor(() => {
-      expect(root.style.getPropertyValue('--bg-primary')).toBe('#FFFFFF')
-    })
-    expect(root.style.getPropertyValue('color-scheme')).toBe('light')
-    expect(root.dataset.themeMode).toBe('light')
-  })
-
-  it('reloadThemes re-fetches theme list', async () => {
-    const { result } = renderHook(() => useThemeManager('/vault'))
-    await waitFor(() => {
-      expect(result.current.themes).toHaveLength(2)
-    })
-
-    const initialListCalls = mockInvokeFn.mock.calls.filter(c => c[0] === 'list_themes').length
+    const initialCalls = mockInvokeFn.mock.calls.filter(c => c[0] === 'get_vault_settings').length
 
     await act(async () => {
       await result.current.reloadThemes()
     })
 
-    const afterListCalls = mockInvokeFn.mock.calls.filter(c => c[0] === 'list_themes').length
-    expect(afterListCalls).toBe(initialListCalls + 1)
+    const afterCalls = mockInvokeFn.mock.calls.filter(c => c[0] === 'get_vault_settings').length
+    expect(afterCalls).toBe(initialCalls + 1)
   })
 })

src/hooks/useThemeManager.ts

@@ -1,157 +1,76 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from '../mock-tauri'
-import type { ThemeFile, VaultSettings } from '../types'
+import { parseFrontmatter } from '../utils/frontmatter'
+import type { ThemeFile, VaultEntry, VaultSettings } from '../types'
 
 function tauriCall<T>(command: string, args: Record<string, unknown>): Promise<T> {
   return isTauri() ? invoke<T>(command, args) : mockInvoke<T>(command, args)
 }
 
-// --- Color utilities for theme variable derivation ---
+/** Frontmatter keys that are metadata — not CSS custom properties. */
+const NON_THEME_KEYS = new Set([
+  'Is A', 'type', 'is_a', 'is a',
+  'Name', 'name', 'title', 'Title',
+  'Description', 'description',
+  'Archived', 'archived',
+  'Trashed', 'trashed',
+  'Trashed at', 'trashed at', 'trashed_at',
+  'Created at', 'created at', 'created_at',
+  'Created time', 'created_time',
+  'Owner', 'owner',
+  'Status', 'status',
+  'Cadence', 'cadence',
+  'aliases',
+  'Belongs to', 'belongs_to', 'belongs to',
+  'Related to', 'related_to', 'related to',
+])
 
-function parseHex(hex: string): [number, number, number] {
-  const h = hex.replace('#', '')
-  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)]
-}
-
-function toHex(r: number, g: number, b: number): string {
-  return '#' + [r, g, b].map(c => Math.round(Math.max(0, Math.min(255, c))).toString(16).padStart(2, '0')).join('')
-}
-
-/** Blend two hex colors. ratio=0 → color1, ratio=1 → color2. */
-function mixColors(hex1: string, hex2: string, ratio: number): string {
-  const [r1, g1, b1] = parseHex(hex1)
-  const [r2, g2, b2] = parseHex(hex2)
-  return toHex(r1 + (r2 - r1) * ratio, g1 + (g2 - g1) * ratio, b1 + (b2 - b1) * ratio)
-}
-
-/** Check if a hex color is perceptually dark (luminance < 0.5). */
-export function isColorDark(hex: string): boolean {
-  const [r, g, b] = parseHex(hex)
-  return (0.299 * r + 0.587 * g + 0.114 * b) / 255 < 0.5
-}
-
-// Variables derived from theme core colors (not present in theme.colors directly)
-const DERIVED_VAR_NAMES = [
-  'bg-primary', 'bg-sidebar', 'bg-card', 'bg-hover', 'bg-hover-subtle', 'bg-selected',
-  'bg-input', 'bg-button', 'bg-dialog',
-  'text-primary', 'text-heading', 'text-secondary', 'text-tertiary', 'text-muted', 'text-faint',
-  'border-primary', 'border-subtle', 'border-input', 'border-dialog',
-  'link-color', 'link-hover',
-  // shadcn variables that may not be in the theme
-  'card', 'card-foreground', 'popover', 'popover-foreground',
-  'secondary', 'secondary-foreground', 'muted-foreground',
-  'accent', 'accent-foreground', 'input', 'ring',
-  'sidebar-foreground', 'sidebar-primary', 'sidebar-primary-foreground',
-  'sidebar-accent', 'sidebar-accent-foreground', 'sidebar-border', 'sidebar-ring',
-]
-
-/** Derive app-specific and missing shadcn CSS variables from core theme colors. */
-function deriveThemeVariables(root: HTMLElement, colors: Record<string, string>): void {
-  const bg = colors.background
-  const fg = colors.foreground
-  if (!bg || !fg) return
-
-  const isDark = isColorDark(bg)
-  root.style.setProperty('color-scheme', isDark ? 'dark' : 'light')
-  root.dataset.themeMode = isDark ? 'dark' : 'light'
-
-  const primary = colors.primary ?? (isDark ? '#5C9CFF' : '#155DFF')
-  const border = colors.border ?? mixColors(bg, fg, isDark ? 0.15 : 0.08)
-  const muted = colors.muted ?? mixColors(bg, fg, isDark ? 0.08 : 0.05)
-  const sidebarBg = colors['sidebar-background'] ?? mixColors(bg, fg, 0.04)
-
-  // App-specific variables
-  root.style.setProperty('--bg-primary', bg)
-  root.style.setProperty('--bg-sidebar', sidebarBg)
-  root.style.setProperty('--bg-card', mixColors(bg, fg, 0.03))
-  root.style.setProperty('--bg-hover', mixColors(bg, fg, 0.1))
-  root.style.setProperty('--bg-hover-subtle', muted)
-  root.style.setProperty('--bg-selected', `${primary}25`)
-  root.style.setProperty('--bg-input', bg)
-  root.style.setProperty('--bg-button', mixColors(bg, fg, 0.1))
-  root.style.setProperty('--bg-dialog', mixColors(bg, fg, 0.02))
-
-  root.style.setProperty('--text-primary', fg)
-  root.style.setProperty('--text-heading', fg)
-  root.style.setProperty('--text-secondary', mixColors(fg, bg, 0.25))
-  root.style.setProperty('--text-tertiary', mixColors(fg, bg, 0.35))
-  root.style.setProperty('--text-muted', mixColors(fg, bg, 0.5))
-  root.style.setProperty('--text-faint', mixColors(fg, bg, 0.6))
-
-  root.style.setProperty('--border-primary', border)
-  root.style.setProperty('--border-subtle', border)
-  root.style.setProperty('--border-input', border)
-  root.style.setProperty('--border-dialog', border)
-
-  root.style.setProperty('--link-color', primary)
-  root.style.setProperty('--link-hover', mixColors(primary, fg, 0.2))
-
-  // Shadcn variables — only set if not already provided by the theme
-  const setIfMissing = (name: string, value: string) => {
-    if (!(name in colors)) root.style.setProperty(`--${name}`, value)
+/** Extract CSS custom properties from a theme note's frontmatter content. */
+export function extractCssVars(content: string): Record<string, string> {
+  const fm = parseFrontmatter(content)
+  const vars: Record<string, string> = {}
+  for (const [key, value] of Object.entries(fm)) {
+    if (NON_THEME_KEYS.has(key)) continue
+    if (typeof value === 'string' && value) {
+      vars[`--${key}`] = value
+    } else if (typeof value === 'number') {
+      vars[`--${key}`] = String(value)
+    }
   }
-  setIfMissing('card', mixColors(bg, fg, 0.03))
-  setIfMissing('card-foreground', fg)
-  setIfMissing('popover', mixColors(bg, fg, 0.04))
-  setIfMissing('popover-foreground', fg)
-  setIfMissing('secondary', mixColors(bg, fg, 0.08))
-  setIfMissing('secondary-foreground', fg)
-  setIfMissing('muted-foreground', mixColors(fg, bg, 0.3))
-  setIfMissing('accent', mixColors(bg, fg, 0.08))
-  setIfMissing('accent-foreground', fg)
-  setIfMissing('input', border)
-  setIfMissing('ring', primary)
-  setIfMissing('sidebar-foreground', fg)
-  setIfMissing('sidebar-accent', mixColors(sidebarBg, fg, 0.1))
-  setIfMissing('sidebar-accent-foreground', fg)
-  setIfMissing('sidebar-border', border)
-  setIfMissing('sidebar-primary', primary)
-  setIfMissing('sidebar-primary-foreground', '#FFFFFF')
-  setIfMissing('sidebar-ring', primary)
+  return vars
 }
 
-function clearDerivedVariables(root: HTMLElement): void {
-  for (const name of DERIVED_VAR_NAMES) {
-    root.style.removeProperty(`--${name}`)
-  }
-  root.style.removeProperty('color-scheme')
-  delete root.dataset.themeMode
-}
-
-/** Map theme colors/typography/spacing to CSS custom properties on :root. */
-function applyThemeToDom(theme: ThemeFile): void {
+function applyVarsToDom(vars: Record<string, string>): void {
   const root = document.documentElement
-  for (const [key, value] of Object.entries(theme.colors)) {
-    root.style.setProperty(`--theme-${key}`, value)
-    root.style.setProperty(`--${key}`, value)
+  for (const [key, value] of Object.entries(vars)) {
+    root.style.setProperty(key, value)
   }
-  for (const [key, value] of Object.entries(theme.typography)) {
-    root.style.setProperty(`--theme-${key}`, value)
-  }
-  for (const [key, value] of Object.entries(theme.spacing)) {
-    root.style.setProperty(`--theme-${key}`, value)
-  }
-  if (theme.colors['sidebar-background']) {
-    root.style.setProperty('--sidebar', theme.colors['sidebar-background'])
-  }
-  deriveThemeVariables(root, theme.colors)
 }
 
-function clearThemeFromDom(theme: ThemeFile): void {
+function clearVarsFromDom(vars: Record<string, string>): void {
   const root = document.documentElement
-  for (const key of Object.keys(theme.colors)) {
-    root.style.removeProperty(`--theme-${key}`)
-    root.style.removeProperty(`--${key}`)
+  for (const key of Object.keys(vars)) {
+    root.style.removeProperty(key)
   }
-  for (const key of Object.keys(theme.typography)) {
-    root.style.removeProperty(`--theme-${key}`)
+}
+
+/** Build a ThemeFile descriptor from a vault entry (metadata only). */
+function entryToThemeFile(entry: VaultEntry): ThemeFile {
+  return {
+    id: entry.path,
+    name: entry.title,
+    description: '',
+    path: entry.path,
+    colors: {},
+    typography: {},
+    spacing: {},
   }
-  for (const key of Object.keys(theme.spacing)) {
-    root.style.removeProperty(`--theme-${key}`)
-  }
-  root.style.removeProperty('--sidebar')
-  clearDerivedVariables(root)
+}
+
+/** True when a theme entry should no longer be applied (trashed or archived). */
+function isEntryRemoved(entry: VaultEntry): boolean {
+  return entry.trashed || entry.archived
 }
 
 export interface ThemeManager {
@@ -160,81 +79,125 @@ export interface ThemeManager {
   activeTheme: ThemeFile | null
   isDark: boolean
   switchTheme: (themeId: string) => Promise<void>
-  createTheme: (sourceId?: string) => Promise<string>
+  createTheme: (name?: string) => Promise<string>
   reloadThemes: () => Promise<void>
 }
 
-/** Sync CSS custom properties: clear old theme, apply new one. */
-function syncThemeDom(
-  prevRef: React.MutableRefObject<ThemeFile | null>,
-  theme: ThemeFile | null,
-): void {
-  if (prevRef.current) clearThemeFromDom(prevRef.current)
-  if (theme) {
-    applyThemeToDom(theme)
-    prevRef.current = theme
-  } else {
-    prevRef.current = null
-  }
-}
-
-export function useThemeManager(vaultPath: string | null): ThemeManager {
-  const [themes, setThemes] = useState<ThemeFile[]>([])
+/** Manages loading and persisting the active theme path from vault settings. */
+function useThemeSetting(vaultPath: string | null) {
   const [activeThemeId, setActiveThemeId] = useState<string | null>(null)
-  const prevThemeRef = useRef<ThemeFile | null>(null)
 
-  const activeTheme = themes.find(t => t.id === activeThemeId) ?? null
-  const isDark = activeTheme?.colors.background ? isColorDark(activeTheme.colors.background) : false
-
-  const loadThemes = useCallback(async () => {
+  const load = useCallback(async () => {
     if (!vaultPath) return
     try {
-      const [themeList, settings] = await Promise.all([
-        tauriCall<ThemeFile[]>('list_themes', { vaultPath }),
-        tauriCall<VaultSettings>('get_vault_settings', { vaultPath }),
-      ])
-      setThemes(themeList)
-      setActiveThemeId(settings.theme)
-    } catch (err) {
-      console.warn('Failed to load themes:', err)
-    }
+      const s = await tauriCall<VaultSettings>('get_vault_settings', { vaultPath })
+      setActiveThemeId(s.theme)
+    } catch { /* no settings file — fine, no active theme */ }
   }, [vaultPath])
 
-  useEffect(() => { loadThemes() }, [loadThemes]) // eslint-disable-line react-hooks/set-state-in-effect -- trigger initial load
-  useEffect(() => { syncThemeDom(prevThemeRef, activeTheme) }, [activeTheme])
+  // eslint-disable-next-line react-hooks/set-state-in-effect -- async fn; setState runs after await
+  useEffect(() => { load() }, [load])
 
-  // Reload themes when window regains focus (live reload for external edits)
   useEffect(() => {
-    const onFocus = () => { loadThemes() }
-    window.addEventListener('focus', onFocus)
-    return () => window.removeEventListener('focus', onFocus)
-  }, [loadThemes])
+    window.addEventListener('focus', load)
+    return () => window.removeEventListener('focus', load)
+  }, [load])
+
+  return { activeThemeId, setActiveThemeId, reload: load }
+}
+
+/** Applies CSS custom properties to the document root from the active theme. */
+function useThemeApplier(
+  activeThemeId: string | null,
+  cachedContent: string | undefined,
+) {
+  const appliedVarsRef = useRef<Record<string, string>>({})
+
+  const apply = useCallback((content: string) => {
+    const newVars = extractCssVars(content)
+    clearVarsFromDom(appliedVarsRef.current)
+    applyVarsToDom(newVars)
+    appliedVarsRef.current = newVars
+  }, [])
+
+  const clear = useCallback(() => {
+    clearVarsFromDom(appliedVarsRef.current)
+    appliedVarsRef.current = {}
+  }, [])
+
+  // Apply theme when activeThemeId or cached content changes.
+  // Also serves as live-preview: re-applies when the user saves the theme note.
+  useEffect(() => {
+    if (!activeThemeId) { clear(); return }
+    if (cachedContent) { apply(cachedContent); return }
+    tauriCall<string>('get_note_content', { path: activeThemeId })
+      .then(apply)
+      .catch(clear)
+  }, [activeThemeId, cachedContent, apply, clear])
+
+  return { clear }
+}
+
+export function useThemeManager(
+  vaultPath: string | null,
+  entries: VaultEntry[],
+  allContent: Record<string, string>,
+): ThemeManager {
+  const { activeThemeId, setActiveThemeId, reload } = useThemeSetting(vaultPath)
+  const cachedThemeContent = activeThemeId ? allContent[activeThemeId] : undefined
+  const { clear: clearTheme } = useThemeApplier(activeThemeId, cachedThemeContent)
+
+  const themes = useMemo(
+    () => entries.filter(e => e.isA === 'Theme' && !e.trashed && !e.archived).map(entryToThemeFile),
+    [entries],
+  )
+
+  const activeTheme = useMemo(
+    () => themes.find(t => t.id === activeThemeId) ?? null,
+    [themes, activeThemeId],
+  )
+
+  // If active theme is trashed or archived: clear CSS vars and fall back to no theme
+  useEffect(() => {
+    if (!activeThemeId) return
+    const entry = entries.find(e => e.path === activeThemeId)
+    if (!entry || !isEntryRemoved(entry)) return
+    clearTheme()
+    setActiveThemeId(null)
+    if (vaultPath) tauriCall('set_active_theme', { vaultPath, themeId: null }).catch(() => {})
+  }, [entries, activeThemeId, clearTheme, vaultPath, setActiveThemeId])
 
   const switchTheme = useCallback(async (themeId: string) => {
     if (!vaultPath) return
     try {
       await tauriCall<null>('set_active_theme', { vaultPath, themeId })
       setActiveThemeId(themeId)
-    } catch (err) {
-      console.error('Failed to switch theme:', err)
-    }
-  }, [vaultPath])
+    } catch (err) { console.error('Failed to switch theme:', err) }
+  }, [vaultPath, setActiveThemeId])
 
-  const createTheme = useCallback(async (sourceId?: string) => {
+  const createTheme = useCallback(async (name?: string) => {
     if (!vaultPath) return ''
     try {
-      const newId = await tauriCall<string>('create_theme', {
-        vaultPath,
-        sourceId: sourceId ?? null,
-      })
-      await loadThemes()
-      await switchTheme(newId)
-      return newId
-    } catch (err) {
-      console.error('Failed to create theme:', err)
-      return ''
-    }
-  }, [vaultPath, loadThemes, switchTheme])
+      const path = await tauriCall<string>('create_vault_theme', { vaultPath, name: name ?? null })
+      await tauriCall<null>('set_active_theme', { vaultPath, themeId: path })
+      setActiveThemeId(path)
+      return path
+    } catch (err) { console.error('Failed to create theme:', err); return '' }
+  }, [vaultPath, setActiveThemeId])
 
-  return { themes, activeThemeId, activeTheme, isDark, switchTheme, createTheme, reloadThemes: loadThemes }
+  const reloadThemes = useCallback(async () => { await reload() }, [reload])
+
+  // Determine if the active theme is dark by checking --background CSS variable
+  const isDark = useMemo(() => {
+    if (!activeThemeId || !cachedThemeContent) return false
+    const vars = extractCssVars(cachedThemeContent)
+    const bg = vars['--background'] ?? ''
+    if (!bg.startsWith('#') || bg.length < 7) return false
+    const r = parseInt(bg.slice(1, 3), 16)
+    const g = parseInt(bg.slice(3, 5), 16)
+    const b = parseInt(bg.slice(5, 7), 16)
+    return (0.299 * r + 0.587 * g + 0.114 * b) / 255 < 0.5
+  }, [activeThemeId, cachedThemeContent])
+
+  return { themes, activeThemeId, activeTheme, isDark, switchTheme, createTheme, reloadThemes }
 }

src/hooks/useUpdater.test.ts

@@ -199,4 +199,73 @@ describe('useUpdater', () => {
     expect(result.current.status).toEqual({ state: 'ready', version: '1.2.0' })
     expect(mockDownload).toHaveBeenCalled()
   })
+
+  describe('checkForUpdates (manual)', () => {
+    it('returns up-to-date when no update is available', async () => {
+      vi.mocked(isTauri).mockReturnValue(true)
+      mockCheck.mockResolvedValue(null)
+
+      const { result } = renderHook(() => useUpdater())
+
+      let checkResult: string | undefined
+      await act(async () => {
+        checkResult = await result.current.actions.checkForUpdates()
+      })
+
+      expect(checkResult).toBe('up-to-date')
+      expect(result.current.status).toEqual({ state: 'idle' })
+    })
+
+    it('returns available and sets status when update exists', async () => {
+      vi.mocked(isTauri).mockReturnValue(true)
+      mockCheck.mockResolvedValue({
+        version: '3.0.0',
+        body: 'Major release',
+        downloadAndInstall: vi.fn(),
+      })
+
+      const { result } = renderHook(() => useUpdater())
+
+      let checkResult: string | undefined
+      await act(async () => {
+        checkResult = await result.current.actions.checkForUpdates()
+      })
+
+      expect(checkResult).toBe('available')
+      expect(result.current.status).toEqual({
+        state: 'available',
+        version: '3.0.0',
+        notes: 'Major release',
+      })
+    })
+
+    it('returns error on network failure', async () => {
+      vi.mocked(isTauri).mockReturnValue(true)
+      mockCheck.mockRejectedValue(new Error('No internet'))
+
+      const { result } = renderHook(() => useUpdater())
+
+      let checkResult: string | undefined
+      await act(async () => {
+        checkResult = await result.current.actions.checkForUpdates()
+      })
+
+      expect(checkResult).toBe('error')
+      expect(console.warn).toHaveBeenCalledWith('[updater] Failed to check for updates')
+    })
+
+    it('returns up-to-date when not in Tauri', async () => {
+      vi.mocked(isTauri).mockReturnValue(false)
+
+      const { result } = renderHook(() => useUpdater())
+
+      let checkResult: string | undefined
+      await act(async () => {
+        checkResult = await result.current.actions.checkForUpdates()
+      })
+
+      expect(checkResult).toBe('up-to-date')
+      expect(mockCheck).not.toHaveBeenCalled()
+    })
+  })
 })

src/hooks/useUpdater.ts

@@ -11,7 +11,10 @@ export type UpdateStatus =
   | { state: 'ready'; version: string }
   | { state: 'error' }
 
+export type UpdateCheckResult = 'up-to-date' | 'available' | 'error'
+
 export interface UpdateActions {
+  checkForUpdates: () => Promise<UpdateCheckResult>
   startDownload: () => void
   openReleaseNotes: () => void
   dismiss: () => void
@@ -21,31 +24,32 @@ export function useUpdater(): { status: UpdateStatus; actions: UpdateActions } {
   const [status, setStatus] = useState<UpdateStatus>({ state: 'idle' })
   const updateRef = useRef<unknown>(null)
 
+  const checkForUpdates = useCallback(async (): Promise<UpdateCheckResult> => {
+    if (!isTauri()) return 'up-to-date'
+
+    try {
+      const { check } = await import('@tauri-apps/plugin-updater')
+      const update = await check()
+      if (!update) return 'up-to-date'
+
+      updateRef.current = update
+      setStatus({
+        state: 'available',
+        version: update.version,
+        notes: update.body ?? undefined,
+      })
+      return 'available'
+    } catch {
+      console.warn('[updater] Failed to check for updates')
+      return 'error'
+    }
+  }, [])
+
   useEffect(() => {
     if (!isTauri()) return
-
-    const checkForUpdates = async () => {
-      try {
-        const { check } = await import('@tauri-apps/plugin-updater')
-        const update = await check()
-        if (!update) return // up to date
-
-        updateRef.current = update
-        setStatus({
-          state: 'available',
-          version: update.version,
-          notes: update.body ?? undefined,
-        })
-      } catch {
-        // Network error or 404 — fail silently
-        console.warn('[updater] Failed to check for updates')
-      }
-    }
-
-    // Delay so the app can render first
-    const timer = setTimeout(checkForUpdates, 3000)
+    const timer = setTimeout(() => { checkForUpdates() }, 3000)
     return () => clearTimeout(timer)
-  }, [])
+  }, [checkForUpdates])
 
   const startDownload = useCallback(async () => {
     const update = updateRef.current as {
@@ -88,7 +92,7 @@ export function useUpdater(): { status: UpdateStatus; actions: UpdateActions } {
     setStatus({ state: 'idle' })
   }, [])
 
-  return { status, actions: { startDownload, openReleaseNotes, dismiss } }
+  return { status, actions: { checkForUpdates, startDownload, openReleaseNotes, dismiss } }
 }
 
 /**

src/hooks/useVaultLoader.ts

@@ -97,13 +97,14 @@ export function useVaultLoader(vaultPath: string) {
   const [entries, setEntries] = useState<VaultEntry[]>([])
   const [allContent, setAllContent] = useState<Record<string, string>>({})
   const [modifiedFiles, setModifiedFiles] = useState<ModifiedFile[]>([])
+  const [modifiedFilesError, setModifiedFilesError] = useState<string | null>(null)
   const tracker = useNewNoteTracker()
   const pendingSave = usePendingSaveTracker()
   const unsaved = useUnsavedTracker()
 
   useEffect(() => {
     // eslint-disable-next-line react-hooks/set-state-in-effect -- clear stale data then load new vault
-    setEntries([]); setAllContent({}); setModifiedFiles([]); tracker.clear(); unsaved.clearAll()
+    setEntries([]); setAllContent({}); setModifiedFiles([]); setModifiedFilesError(null); tracker.clear(); unsaved.clearAll()
     loadVaultData(vaultPath)
       .then(({ entries: e, allContent: c }) => { setEntries(e); setAllContent(c) })
       .catch((err) => console.warn('Vault scan failed:', err))
@@ -111,9 +112,12 @@ export function useVaultLoader(vaultPath: string) {
 
   const loadModifiedFiles = useCallback(async () => {
     try {
+      setModifiedFilesError(null)
       setModifiedFiles(await tauriCall<ModifiedFile[]>('get_modified_files', { vaultPath }, {}))
     } catch (err) {
+      const message = typeof err === 'string' ? err : 'Failed to load changes'
       console.warn('Failed to load modified files:', err)
+      setModifiedFilesError(message)
       setModifiedFiles([])
     }
   }, [vaultPath])
@@ -174,7 +178,7 @@ export function useVaultLoader(vaultPath: string) {
   )
 
   return {
-    entries, allContent, modifiedFiles,
+    entries, allContent, modifiedFiles, modifiedFilesError,
     addEntry, updateEntry, removeEntry, replaceEntry, updateContent,
     loadModifiedFiles, loadGitHistory, loadDiff, loadDiffAtCommit,
     getNoteStatus, commitAndPush, reloadVault,

src/hooks/useVaultSwitcher.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { renderHook, act, waitFor } from '@testing-library/react'
+import { useVaultSwitcher, DEFAULT_VAULTS } from './useVaultSwitcher'
+import type { PersistedVaultList } from './useVaultSwitcher'
+
+let mockVaultListStore: PersistedVaultList = { vaults: [], active_vault: null }
+
+const mockInvokeFn = vi.fn((cmd: string, args?: Record<string, unknown>): Promise<unknown> => {
+  if (cmd === 'load_vault_list') return Promise.resolve({ ...mockVaultListStore })
+  if (cmd === 'save_vault_list') {
+    mockVaultListStore = { ...(args as { list: PersistedVaultList }).list }
+    return Promise.resolve(null)
+  }
+  if (cmd === 'check_vault_exists') return Promise.resolve(true)
+  return Promise.resolve(null)
+})
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: vi.fn(),
+}))
+
+vi.mock('../mock-tauri', () => ({
+  isTauri: () => false,
+  mockInvoke: (cmd: string, args?: Record<string, unknown>) => mockInvokeFn(cmd, args),
+}))
+
+vi.mock('../utils/vault-dialog', () => ({
+  pickFolder: vi.fn(),
+}))
+
+describe('useVaultSwitcher', () => {
+  const onSwitch = vi.fn()
+  const onToast = vi.fn()
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    mockVaultListStore = { vaults: [], active_vault: null }
+    // Re-set default implementation after resetAllMocks
+    mockInvokeFn.mockImplementation((cmd: string, args?: Record<string, unknown>): Promise<unknown> => {
+      if (cmd === 'load_vault_list') return Promise.resolve({ ...mockVaultListStore })
+      if (cmd === 'save_vault_list') {
+        mockVaultListStore = { ...(args as { list: PersistedVaultList }).list }
+        return Promise.resolve(null)
+      }
+      if (cmd === 'check_vault_exists') return Promise.resolve(true)
+      return Promise.resolve(null)
+    })
+  })
+
+  it('starts with default vaults', () => {
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+    expect(result.current.allVaults).toEqual(DEFAULT_VAULTS)
+    expect(result.current.vaultPath).toBe(DEFAULT_VAULTS[0].path)
+  })
+
+  it('loads persisted vaults on mount', async () => {
+    mockVaultListStore = {
+      vaults: [{ label: 'My Vault', path: '/Users/luca/Laputa' }],
+      active_vault: '/Users/luca/Laputa',
+    }
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await waitFor(() => {
+      expect(result.current.loaded).toBe(true)
+    })
+
+    expect(result.current.allVaults).toHaveLength(2) // default + persisted
+    expect(result.current.allVaults[1].label).toBe('My Vault')
+    expect(result.current.allVaults[1].path).toBe('/Users/luca/Laputa')
+    expect(result.current.allVaults[1].available).toBe(true)
+    expect(result.current.vaultPath).toBe('/Users/luca/Laputa')
+    expect(mockInvokeFn).toHaveBeenCalledWith('load_vault_list', {})
+  })
+
+  it('marks unavailable vaults when check_vault_exists returns false', async () => {
+    mockVaultListStore = {
+      vaults: [{ label: 'External', path: '/Volumes/USB/vault' }],
+      active_vault: null,
+    }
+    mockInvokeFn.mockImplementation((cmd: string, args?: Record<string, unknown>) => {
+      if (cmd === 'load_vault_list') return Promise.resolve({ ...mockVaultListStore })
+      if (cmd === 'save_vault_list') {
+        mockVaultListStore = { ...(args as { list: PersistedVaultList }).list }
+        return Promise.resolve(null)
+      }
+      if (cmd === 'check_vault_exists') return Promise.resolve(false)
+      return Promise.resolve(null)
+    })
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await waitFor(() => {
+      expect(result.current.loaded).toBe(true)
+    })
+
+    expect(result.current.allVaults[1].available).toBe(false)
+    expect(result.current.allVaults[1].label).toBe('External')
+  })
+
+  it('persists vault list when adding a vault via handleVaultCloned', async () => {
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await waitFor(() => { expect(result.current.loaded).toBe(true) })
+
+    act(() => {
+      result.current.handleVaultCloned('/cloned/vault', 'Cloned')
+    })
+
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('save_vault_list', expect.objectContaining({
+        list: expect.objectContaining({
+          vaults: expect.arrayContaining([
+            expect.objectContaining({ label: 'Cloned', path: '/cloned/vault' }),
+          ]),
+        }),
+      }))
+    })
+  })
+
+  it('persists active vault when switching', async () => {
+    mockVaultListStore = {
+      vaults: [{ label: 'Work', path: '/work/vault' }],
+      active_vault: null,
+    }
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await waitFor(() => { expect(result.current.loaded).toBe(true) })
+
+    act(() => {
+      result.current.switchVault('/work/vault')
+    })
+
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('save_vault_list', expect.objectContaining({
+        list: expect.objectContaining({
+          active_vault: '/work/vault',
+        }),
+      }))
+    })
+    expect(onSwitch).toHaveBeenCalled()
+  })
+
+  it('handles load error gracefully', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mockInvokeFn.mockImplementation((cmd: string) => {
+      if (cmd === 'load_vault_list') return Promise.reject(new Error('disk error'))
+      return Promise.resolve(null)
+    })
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await waitFor(() => { expect(result.current.loaded).toBe(true) })
+
+    // Should fall back to defaults
+    expect(result.current.allVaults).toEqual(DEFAULT_VAULTS)
+    warnSpy.mockRestore()
+  })
+
+  it('does not duplicate vaults with same path', async () => {
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+    await waitFor(() => { expect(result.current.loaded).toBe(true) })
+
+    act(() => {
+      result.current.handleVaultCloned('/some/vault', 'First')
+    })
+    act(() => {
+      result.current.handleVaultCloned('/some/vault', 'Duplicate')
+    })
+
+    const extras = result.current.allVaults.filter(v => v.path === '/some/vault')
+    expect(extras).toHaveLength(1)
+  })
+
+  it('opens local folder and persists', async () => {
+    const { pickFolder } = await import('../utils/vault-dialog')
+    vi.mocked(pickFolder).mockResolvedValue('/Users/luca/MyVault')
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+    await waitFor(() => { expect(result.current.loaded).toBe(true) })
+
+    await act(async () => {
+      await result.current.handleOpenLocalFolder()
+    })
+
+    expect(result.current.allVaults.some(v => v.path === '/Users/luca/MyVault')).toBe(true)
+    expect(onToast).toHaveBeenCalledWith('Vault "MyVault" opened')
+  })
+})

src/hooks/useVaultSwitcher.ts

@@ -1,36 +1,68 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { isTauri } from '../mock-tauri'
 import { pickFolder } from '../utils/vault-dialog'
+import { loadVaultList, saveVaultList } from '../utils/vaultListStore'
 import type { VaultOption } from '../components/StatusBar'
 
-export const DEFAULT_VAULTS: VaultOption[] = isTauri()
-  ? [
-      { label: 'Demo v2', path: '/Users/luca/Workspace/laputa-app/demo-vault-v2' },
-      { label: 'Laputa', path: '/Users/luca/Laputa' },
-    ]
-  : [
-      { label: 'Demo v2', path: '/Users/luca/Workspace/laputa-app/demo-vault-v2' },
-    ]
+export type { PersistedVaultList } from '../utils/vaultListStore'
+
+export const DEFAULT_VAULTS: VaultOption[] = [
+  { label: 'Getting Started', path: '/Users/luca/Workspace/laputa-app/demo-vault-v2' },
+]
 
 interface UseVaultSwitcherOptions {
   onSwitch: () => void
   onToast: (msg: string) => void
 }
 
-/** Manages vault path, extra vaults, switching, cloning, and local folder opening. */
+function labelFromPath(path: string): string {
+  return path.split('/').pop() || 'Local Vault'
+}
+
+/** Manages vault path, extra vaults, switching, cloning, and local folder opening.
+ *  Vault list and active vault are persisted via Tauri backend to survive app updates. */
 export function useVaultSwitcher({ onSwitch, onToast }: UseVaultSwitcherOptions) {
   const [vaultPath, setVaultPath] = useState(DEFAULT_VAULTS[0].path)
   const [extraVaults, setExtraVaults] = useState<VaultOption[]>([])
+  const [loaded, setLoaded] = useState(false)
   const allVaults = useMemo(() => [...DEFAULT_VAULTS, ...extraVaults], [extraVaults])
 
-  // Refs ensure stable callbacks that always invoke the latest closures,
-  // breaking the circular dependency between useVaultSwitcher and downstream hooks.
   const onSwitchRef = useRef(onSwitch)
   const onToastRef = useRef(onToast)
   useEffect(() => { onSwitchRef.current = onSwitch; onToastRef.current = onToast })
 
+  const hasLoadedRef = useRef(false)
+
+  useEffect(() => {
+    let cancelled = false
+    loadVaultList()
+      .then(({ vaults, activeVault }) => {
+        if (cancelled) return
+        setExtraVaults(vaults)
+        if (activeVault) {
+          setVaultPath(activeVault)
+          onSwitchRef.current()
+        }
+      })
+      .catch(err => console.warn('Failed to load vault list:', err))
+      .finally(() => {
+        hasLoadedRef.current = true
+        setLoaded(true)
+      })
+    return () => { cancelled = true }
+  }, [])
+
+  useEffect(() => {
+    if (!hasLoadedRef.current) return
+    saveVaultList(extraVaults, vaultPath).catch(err =>
+      console.warn('Failed to persist vault list:', err),
+    )
+  }, [extraVaults, vaultPath])
+
   const addVault = useCallback((path: string, label: string) => {
-    setExtraVaults(prev => prev.some(v => v.path === path) ? prev : [...prev, { label, path }])
+    setExtraVaults(prev => {
+      const exists = prev.some(v => v.path === path)
+      return exists ? prev : [...prev, { label, path, available: true }]
+    })
   }, [])
 
   const switchVault = useCallback((path: string) => {
@@ -38,25 +70,23 @@ export function useVaultSwitcher({ onSwitch, onToast }: UseVaultSwitcherOptions)
     onSwitchRef.current()
   }, [])
 
-  const handleVaultCloned = useCallback((path: string, label: string) => {
+  const addAndSwitch = useCallback((path: string, label: string) => {
     addVault(path, label)
     switchVault(path)
-    onToastRef.current(`Vault "${label}" cloned and opened`)
   }, [addVault, switchVault])
 
+  const handleVaultCloned = useCallback((path: string, label: string) => {
+    addAndSwitch(path, label)
+    onToastRef.current(`Vault "${label}" cloned and opened`)
+  }, [addAndSwitch])
+
   const handleOpenLocalFolder = useCallback(async () => {
-    try {
-      const path = await pickFolder('Open vault folder')
-      if (!path) return
-      const label = path.split('/').pop() || 'Local Vault'
-      addVault(path, label)
-      switchVault(path)
-      onToastRef.current(`Vault "${label}" opened`)
-    } catch (err) {
-      console.error('Failed to open local folder:', err)
-      onToastRef.current(`Failed to open folder: ${err}`)
-    }
-  }, [addVault, switchVault])
+    const path = await pickFolder('Open vault folder')
+    if (!path) return
+    const label = labelFromPath(path)
+    addAndSwitch(path, label)
+    onToastRef.current(`Vault "${label}" opened`)
+  }, [addAndSwitch])
 
-  return { vaultPath, allVaults, switchVault, handleVaultCloned, handleOpenLocalFolder }
+  return { vaultPath, allVaults, switchVault, handleVaultCloned, handleOpenLocalFolder, loaded }
 }

src/mock-tauri/mock-content.ts

@@ -732,5 +732,68 @@ rating: 5
 # Designing Data-Intensive Applications
 
 Essential reading for anyone building distributed systems. Covers replication, partitioning, transactions, and stream processing.
+`,
+  '/Users/luca/Laputa/theme/default.md': `---
+Is A: Theme
+title: Default
+primary: "#155DFF"
+background: "#FFFFFF"
+foreground: "#37352F"
+sidebar: "#F7F6F3"
+border: "#E9E9E7"
+muted: "#F0F0EF"
+muted-foreground: "#9B9A97"
+accent: "#F0F7FF"
+accent-foreground: "#0A3B8F"
+font-family: "'Inter', -apple-system, BlinkMacSystemFont, sans-serif"
+font-size-base: 14
+line-height-base: 1.6
+---
+
+# Default
+
+Light theme with warm, paper-like tones.
+`,
+  '/Users/luca/Laputa/theme/dark.md': `---
+Is A: Theme
+title: Dark
+primary: "#155DFF"
+background: "#0f0f1a"
+foreground: "#e0e0e0"
+sidebar: "#1a1a2e"
+border: "#2a2a4a"
+muted: "#1e1e3a"
+muted-foreground: "#6b6b8a"
+accent: "#1a2a4a"
+accent-foreground: "#8ab4ff"
+font-family: "'Inter', -apple-system, BlinkMacSystemFont, sans-serif"
+font-size-base: 14
+line-height-base: 1.6
+---
+
+# Dark
+
+Dark variant with deep navy tones.
+`,
+  '/Users/luca/Laputa/theme/minimal.md': `---
+Is A: Theme
+title: Minimal
+primary: "#000000"
+background: "#FAFAFA"
+foreground: "#111111"
+sidebar: "#F5F5F5"
+border: "#E0E0E0"
+muted: "#F5F5F5"
+muted-foreground: "#888888"
+accent: "#F0F0F0"
+accent-foreground: "#000000"
+font-family: "'SF Mono', 'Menlo', monospace"
+font-size-base: 13
+line-height-base: 1.5
+---
+
+# Minimal
+
+High contrast, minimal chrome.
 `,
 }

src/mock-tauri/mock-entries.ts

@@ -1121,5 +1121,90 @@ function generateBulkEntries(count: number): VaultEntry[] {
   return entries
 }
 
+// Theme entries — seeded vault themes
+MOCK_ENTRIES.push(
+  {
+    path: '/Users/luca/Laputa/theme/default.md',
+    filename: 'default.md',
+    title: 'Default',
+    isA: 'Theme',
+    aliases: [],
+    belongsTo: [],
+    relatedTo: [],
+    status: null,
+    owner: null,
+    cadence: null,
+    archived: false,
+    trashed: false,
+    trashedAt: null,
+    modifiedAt: now - 86400 * 30,
+    createdAt: now - 86400 * 30,
+    fileSize: 512,
+    snippet: 'Light theme with warm, paper-like tones.',
+    wordCount: 10,
+    relationships: {},
+    icon: null,
+    color: null,
+    order: null,
+    sidebarLabel: null,
+    template: null,
+    outgoingLinks: [],
+  },
+  {
+    path: '/Users/luca/Laputa/theme/dark.md',
+    filename: 'dark.md',
+    title: 'Dark',
+    isA: 'Theme',
+    aliases: [],
+    belongsTo: [],
+    relatedTo: [],
+    status: null,
+    owner: null,
+    cadence: null,
+    archived: false,
+    trashed: false,
+    trashedAt: null,
+    modifiedAt: now - 86400 * 30,
+    createdAt: now - 86400 * 30,
+    fileSize: 512,
+    snippet: 'Dark variant with deep navy tones.',
+    wordCount: 10,
+    relationships: {},
+    icon: null,
+    color: null,
+    order: null,
+    sidebarLabel: null,
+    template: null,
+    outgoingLinks: [],
+  },
+  {
+    path: '/Users/luca/Laputa/theme/minimal.md',
+    filename: 'minimal.md',
+    title: 'Minimal',
+    isA: 'Theme',
+    aliases: [],
+    belongsTo: [],
+    relatedTo: [],
+    status: null,
+    owner: null,
+    cadence: null,
+    archived: false,
+    trashed: false,
+    trashedAt: null,
+    modifiedAt: now - 86400 * 30,
+    createdAt: now - 86400 * 30,
+    fileSize: 512,
+    snippet: 'High contrast, minimal chrome.',
+    wordCount: 10,
+    relationships: {},
+    icon: null,
+    color: null,
+    order: null,
+    sidebarLabel: null,
+    template: null,
+    outgoingLinks: [],
+  },
+)
+
 // Append 9000 generated entries for realistic large-vault testing
 MOCK_ENTRIES.push(...generateBulkEntries(9000))

src/mock-tauri/mock-handlers.ts

@@ -82,8 +82,15 @@ let mockSettings: Settings = {
   auto_pull_interval_minutes: 5,
 }
 
+let mockLastVaultPath: string | null = null
+
 let mockVaultSettings: VaultSettings = { theme: null }
 
+let mockVaultList: { vaults: Array<{ label: string; path: string }>; active_vault: string | null } = {
+  vaults: [],
+  active_vault: null,
+}
+
 const mockThemes: ThemeFile[] = [
   {
     id: 'default', name: 'Default', description: 'Light theme with warm, paper-like tones',
@@ -197,6 +204,8 @@ export const mockHandlers: Record<string, (args: any) => any> = {
     }
     return null
   },
+  load_vault_list: () => ({ ...mockVaultList, vaults: [...mockVaultList.vaults] }),
+  save_vault_list: (args: { list: typeof mockVaultList }) => { mockVaultList = { ...args.list }; return null },
   rename_note: handleRenameNote,
   github_list_repos: () => [
     { name: 'laputa-vault', full_name: 'lucaong/laputa-vault', description: 'Personal knowledge vault — markdown + YAML frontmatter', private: true, clone_url: 'https://github.com/lucaong/laputa-vault.git', html_url: 'https://github.com/lucaong/laputa-vault', updated_at: '2026-02-20T10:30:00Z' },
@@ -212,6 +221,7 @@ export const mockHandlers: Record<string, (args: any) => any> = {
   }),
   clone_repo: (args: { url: string; local_path: string }) => `Cloned to ${args.local_path}`,
   purge_trash: () => [],
+  delete_note: (args: { path: string }) => args.path,
   migrate_is_a_to_type: () => 0,
   batch_archive_notes: (args: { paths: string[] }) => args.paths.length,
   batch_trash_notes: (args: { paths: string[] }) => args.paths.length,
@@ -245,12 +255,14 @@ export const mockHandlers: Record<string, (args: any) => any> = {
       }))
     return { results: matches, elapsed_ms: 42, query: q, mode: args.mode }
   },
-  get_default_vault_path: () => '/Users/mock/Documents/Laputa',
+  get_last_vault_path: () => mockLastVaultPath,
+  set_last_vault_path: (args: { path: string }) => { mockLastVaultPath = args.path; return null },
+  get_default_vault_path: () => '/Users/mock/Documents/Getting Started',
   check_vault_exists: (args: { path: string }) => {
     // In mock mode, the demo-vault-v2 path always "exists"
     return args.path.includes('demo-vault-v2')
   },
-  create_getting_started_vault: () => '/Users/mock/Documents/Laputa',
+  create_getting_started_vault: () => '/Users/mock/Documents/Getting Started',
   register_mcp_tools: () => 'registered',
   list_themes: (): ThemeFile[] => [...mockThemes],
   get_theme: (args: { themeId: string }): ThemeFile => {
@@ -268,6 +280,32 @@ export const mockHandlers: Record<string, (args: any) => any> = {
     mockThemes.push({ ...source, id: newId, name: 'Untitled Theme' })
     return newId
   },
+  create_vault_theme: (args: { vaultPath: string; name?: string | null }): string => {
+    const displayName = args.name ?? 'Untitled Theme'
+    const slug = displayName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '') || 'untitled-theme'
+    const path = `${args.vaultPath}/theme/${slug}.md`
+    MOCK_CONTENT[path] = `---
+Is A: Theme
+title: ${displayName}
+primary: "#155DFF"
+background: "#FFFFFF"
+foreground: "#37352F"
+sidebar: "#F7F6F3"
+border: "#E9E9E7"
+muted: "#F0F0EF"
+muted-foreground: "#9B9A97"
+accent: "#F0F7FF"
+accent-foreground: "#0A3B8F"
+font-family: "'Inter', -apple-system, BlinkMacSystemFont, sans-serif"
+font-size-base: 14
+line-height-base: 1.6
+---
+
+# ${displayName}
+`
+    syncWindowContent()
+    return path
+  },
 }
 
 export function addMockEntry(_entry: VaultEntry, content: string): void {

src/theme.json

@@ -1,7 +1,7 @@
 {
   "editor": {
     "fontFamily": "'Inter', -apple-system, BlinkMacSystemFont, sans-serif",
-    "fontSize": 16,
+    "fontSize": 15,
     "lineHeight": 1.5,
     "maxWidth": 720,
     "paddingHorizontal": 40,
@@ -25,7 +25,7 @@
       "marginTop": 28,
       "marginBottom": 10,
       "color": "var(--text-heading)",
-      "letterSpacing": 0
+      "letterSpacing": -0.5
     },
     "h3": {
       "fontSize": 20,
@@ -34,7 +34,7 @@
       "marginTop": 24,
       "marginBottom": 8,
       "color": "var(--text-heading)",
-      "letterSpacing": 0
+      "letterSpacing": -0.5
     },
     "h4": {
       "fontSize": 20,

src/types.ts

@@ -120,9 +120,12 @@ export interface SearchResponse {
 export type SearchMode = 'keyword' | 'semantic' | 'hybrid'
 
 export interface ThemeFile {
+  /** For vault-based themes: absolute note path. For legacy JSON themes: filename stem. */
   id: string
   name: string
   description: string
+  /** Absolute path to the vault note (vault-based themes only). */
+  path?: string
   colors: Record<string, string>
   typography: Record<string, string>
   spacing: Record<string, string>

src/utils/noteListHelpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, afterEach } from 'vitest'
-import { formatSubtitle, formatSearchSubtitle, relativeDate } from './noteListHelpers'
+import { formatSubtitle, formatSearchSubtitle, relativeDate, buildRelationshipGroups } from './noteListHelpers'
 import type { VaultEntry } from '../types'
 
 function makeEntry(overrides: Partial<VaultEntry> = {}): VaultEntry {
@@ -154,3 +154,174 @@ describe('relativeDate', () => {
     expect(relativeDate(1700000000)).toMatch(/Nov 14/)
   })
 })
+
+// --- buildRelationshipGroups tests ---
+
+function makeVault(overrides: Partial<VaultEntry>[]): VaultEntry[] {
+  return overrides.map((o, i) => makeEntry({
+    path: `/Laputa/note/entry-${i}.md`,
+    filename: `entry-${i}.md`,
+    title: `Entry ${i}`,
+    modifiedAt: 1700000000 - i * 100,
+    ...o,
+  }))
+}
+
+describe('buildRelationshipGroups', () => {
+  it('shows direct relationship properties from entity.relationships', () => {
+    const building = makeEntry({ path: '/Laputa/responsibility/building.md', filename: 'building.md', title: 'Building' })
+    const entity = makeEntry({
+      path: '/Laputa/project/alpha.md', filename: 'alpha.md', title: 'Alpha',
+      relationships: { 'Belongs to': ['[[responsibility/building]]'] },
+    })
+    const groups = buildRelationshipGroups(entity, [entity, building], {})
+    const labels = groups.map((g) => g.label)
+    expect(labels).toContain('Belongs to')
+    expect(groups.find((g) => g.label === 'Belongs to')!.entries[0].title).toBe('Building')
+  })
+
+  it('shows all direct relationships even when entries also appear as Children', () => {
+    // The entity has "Notes" pointing at note1 and note2.
+    // Those notes also have belongsTo pointing back at the entity.
+    // Previously, Children consumed them via the seen set, suppressing "Notes".
+    const note1 = makeEntry({ path: '/Laputa/note/note1.md', filename: 'note1.md', title: 'Note 1', belongsTo: ['[[project/alpha]]'], modifiedAt: 1700000000 })
+    const note2 = makeEntry({ path: '/Laputa/note/note2.md', filename: 'note2.md', title: 'Note 2', belongsTo: ['[[project/alpha]]'], modifiedAt: 1700000000 })
+    const entity = makeEntry({
+      path: '/Laputa/project/alpha.md', filename: 'alpha.md', title: 'Alpha',
+      relationships: { Notes: ['[[note/note1]]', '[[note/note2]]'] },
+    })
+    const groups = buildRelationshipGroups(entity, [entity, note1, note2], {})
+    const labels = groups.map((g) => g.label)
+    expect(labels).toContain('Notes')
+    expect(groups.find((g) => g.label === 'Notes')!.entries).toHaveLength(2)
+  })
+
+  it('shows all 5+ direct relationship properties', () => {
+    const entries = makeVault([
+      { path: '/Laputa/area/eng.md', filename: 'eng.md', title: 'Engineering' },
+      { path: '/Laputa/person/alice.md', filename: 'alice.md', title: 'Alice' },
+      { path: '/Laputa/note/n1.md', filename: 'n1.md', title: 'Note 1' },
+      { path: '/Laputa/note/n2.md', filename: 'n2.md', title: 'Note 2' },
+      { path: '/Laputa/topic/rust.md', filename: 'rust.md', title: 'Rust' },
+      { path: '/Laputa/project/sibling.md', filename: 'sibling.md', title: 'Sibling' },
+    ])
+    const entity = makeEntry({
+      path: '/Laputa/project/big.md', filename: 'big.md', title: 'Big Project',
+      relationships: {
+        'Belongs to': ['[[area/eng]]'],
+        Notes: ['[[note/n1]]', '[[note/n2]]'],
+        Owner: ['[[person/alice]]'],
+        'Related to': ['[[project/sibling]]'],
+        Topics: ['[[topic/rust]]'],
+      },
+    })
+    const groups = buildRelationshipGroups(entity, [entity, ...entries], {})
+    const labels = groups.map((g) => g.label)
+    expect(labels).toContain('Belongs to')
+    expect(labels).toContain('Notes')
+    expect(labels).toContain('Owner')
+    expect(labels).toContain('Related to')
+    expect(labels).toContain('Topics')
+  })
+
+  it('shows Children group for reverse belongsTo entries not covered by direct rels', () => {
+    const child = makeEntry({ path: '/Laputa/note/child.md', filename: 'child.md', title: 'Child', belongsTo: ['[[project/alpha]]'], modifiedAt: 1700000000 })
+    const entity = makeEntry({
+      path: '/Laputa/project/alpha.md', filename: 'alpha.md', title: 'Alpha',
+      relationships: {},
+    })
+    const groups = buildRelationshipGroups(entity, [entity, child], {})
+    const labels = groups.map((g) => g.label)
+    expect(labels).toContain('Children')
+    expect(groups.find((g) => g.label === 'Children')!.entries[0].title).toBe('Child')
+  })
+
+  it('excludes Type key from relationship groups', () => {
+    const entity = makeEntry({
+      path: '/Laputa/project/alpha.md', filename: 'alpha.md', title: 'Alpha',
+      relationships: { Type: ['[[type/project]]'] },
+    })
+    const groups = buildRelationshipGroups(entity, [entity], {})
+    const labels = groups.map((g) => g.label)
+    expect(labels).not.toContain('Type')
+  })
+
+  it('returns empty groups for entity with no relationships', () => {
+    const entity = makeEntry({ path: '/Laputa/note/solo.md', filename: 'solo.md', title: 'Solo', relationships: {} })
+    const groups = buildRelationshipGroups(entity, [entity], {})
+    expect(groups).toHaveLength(0)
+  })
+
+  it('shows single-item and multi-item relationship properties', () => {
+    const alice = makeEntry({ path: '/Laputa/person/alice.md', filename: 'alice.md', title: 'Alice' })
+    const n1 = makeEntry({ path: '/Laputa/note/n1.md', filename: 'n1.md', title: 'Note 1' })
+    const n2 = makeEntry({ path: '/Laputa/note/n2.md', filename: 'n2.md', title: 'Note 2' })
+    const entity = makeEntry({
+      path: '/Laputa/project/x.md', filename: 'x.md', title: 'X',
+      relationships: {
+        Owner: ['[[person/alice]]'],
+        Notes: ['[[note/n1]]', '[[note/n2]]'],
+      },
+    })
+    const groups = buildRelationshipGroups(entity, [entity, alice, n1, n2], {})
+    expect(groups.find((g) => g.label === 'Owner')!.entries).toHaveLength(1)
+    expect(groups.find((g) => g.label === 'Notes')!.entries).toHaveLength(2)
+  })
+
+  it('shows Instances group for Type entities', () => {
+    const instance1 = makeEntry({ path: '/Laputa/project/a.md', filename: 'a.md', title: 'Project A', isA: 'Project', modifiedAt: 1700000000 })
+    const instance2 = makeEntry({ path: '/Laputa/project/b.md', filename: 'b.md', title: 'Project B', isA: 'Project', modifiedAt: 1700000000 })
+    const typeEntity = makeEntry({
+      path: '/Laputa/type/project.md', filename: 'project.md', title: 'Project',
+      isA: 'Type', relationships: {},
+    })
+    const groups = buildRelationshipGroups(typeEntity, [typeEntity, instance1, instance2], {})
+    const labels = groups.map((g) => g.label)
+    expect(labels).toContain('Instances')
+    expect(groups.find((g) => g.label === 'Instances')!.entries).toHaveLength(2)
+  })
+
+  it('direct relationships are sorted alphabetically', () => {
+    const a = makeEntry({ path: '/Laputa/note/a.md', filename: 'a.md', title: 'A' })
+    const b = makeEntry({ path: '/Laputa/note/b.md', filename: 'b.md', title: 'B' })
+    const c = makeEntry({ path: '/Laputa/note/c.md', filename: 'c.md', title: 'C' })
+    const entity = makeEntry({
+      path: '/Laputa/project/x.md', filename: 'x.md', title: 'X',
+      relationships: {
+        Zebra: ['[[note/c]]'],
+        Alpha: ['[[note/a]]'],
+        Middle: ['[[note/b]]'],
+      },
+    })
+    const groups = buildRelationshipGroups(entity, [entity, a, b, c], {})
+    const directLabels = groups.map((g) => g.label)
+    expect(directLabels.indexOf('Alpha')).toBeLessThan(directLabels.indexOf('Middle'))
+    expect(directLabels.indexOf('Middle')).toBeLessThan(directLabels.indexOf('Zebra'))
+  })
+
+  it('Referenced By shows entries whose relatedTo matches the entity', () => {
+    const referer = makeEntry({
+      path: '/Laputa/project/ref.md', filename: 'ref.md', title: 'Referer',
+      relatedTo: ['[[project/alpha]]'], modifiedAt: 1700000000,
+    })
+    const entity = makeEntry({
+      path: '/Laputa/project/alpha.md', filename: 'alpha.md', title: 'Alpha',
+      relationships: {},
+    })
+    const groups = buildRelationshipGroups(entity, [entity, referer], {})
+    expect(groups.find((g) => g.label === 'Referenced By')!.entries[0].title).toBe('Referer')
+  })
+
+  it('Backlinks shows entries that mention the entity via wikilinks in content', () => {
+    const linker = makeEntry({
+      path: '/Laputa/note/linker.md', filename: 'linker.md', title: 'Linker', modifiedAt: 1700000000,
+    })
+    const entity = makeEntry({
+      path: '/Laputa/project/alpha.md', filename: 'alpha.md', title: 'Alpha',
+      relationships: {},
+    })
+    const allContent = { '/Laputa/note/linker.md': 'See [[Alpha]] for details.' }
+    const groups = buildRelationshipGroups(entity, [entity, linker], allContent)
+    expect(groups.find((g) => g.label === 'Backlinks')!.entries[0].title).toBe('Linker')
+  })
+})

src/utils/noteListHelpers.ts

@@ -220,17 +220,16 @@ export function buildRelationshipGroups(
     b.filterAndAdd('Instances', (e) => e.isA === entity.title)
   }
 
-  b.addFromRefs('Has', rels['Has'] ?? [])
-  b.filterAndAdd('Children', (e) => e.isA !== 'Event' && refsMatch(e.belongsTo, entity))
-  b.filterAndAdd('Events', (e) => e.isA === 'Event' && (refsMatch(e.belongsTo, entity) || refsMatch(e.relatedTo, entity)))
-  b.addFromRefs('Topics', rels['Topics'] ?? [])
-
-  const handledKeys = new Set(['Has', 'Topics'])
+  // Direct relationships first — all keys from entity.relationships take
+  // priority so that reverse/computed groups (Children, Events, Referenced By)
+  // only show *additional* entries not already covered by a direct property.
   Object.keys(rels)
-    .filter((k) => !handledKeys.has(k) && k.toLowerCase() !== 'type')
+    .filter((k) => k.toLowerCase() !== 'type')
     .sort((a, b) => a.localeCompare(b))
     .forEach((key) => b.addFromRefs(key, rels[key] ?? []))
 
+  b.filterAndAdd('Children', (e) => e.isA !== 'Event' && refsMatch(e.belongsTo, entity))
+  b.filterAndAdd('Events', (e) => e.isA === 'Event' && (refsMatch(e.belongsTo, entity) || refsMatch(e.relatedTo, entity)))
   b.filterAndAdd('Referenced By', (e) => e.isA !== 'Event' && refsMatch(e.relatedTo, entity))
   b.add('Backlinks', findBacklinks(entity, allEntries, allContent).sort(sortByModified))
 

src/utils/vaultListStore.ts

@@ -0,0 +1,36 @@
+import { invoke } from '@tauri-apps/api/core'
+import { isTauri, mockInvoke } from '../mock-tauri'
+import type { VaultOption } from '../components/StatusBar'
+
+export interface PersistedVaultList {
+  vaults: Array<{ label: string; path: string }>
+  active_vault: string | null
+}
+
+function tauriCall<T>(command: string, args: Record<string, unknown>): Promise<T> {
+  return isTauri() ? invoke<T>(command, args) : mockInvoke<T>(command, args)
+}
+
+async function checkAvailability(v: { label: string; path: string }): Promise<VaultOption> {
+  try {
+    const exists = await tauriCall<boolean>('check_vault_exists', { path: v.path })
+    return { label: v.label, path: v.path, available: exists }
+  } catch {
+    return { label: v.label, path: v.path, available: false }
+  }
+}
+
+export async function loadVaultList(): Promise<{ vaults: VaultOption[]; activeVault: string | null }> {
+  const data = await tauriCall<PersistedVaultList>('load_vault_list', {})
+  const persisted = data?.vaults ?? []
+  const checked = await Promise.all(persisted.map(checkAvailability))
+  return { vaults: checked, activeVault: data?.active_vault ?? null }
+}
+
+export function saveVaultList(vaults: VaultOption[], activeVault: string): Promise<void> {
+  const list: PersistedVaultList = {
+    vaults: vaults.map(v => ({ label: v.label, path: v.path })),
+    active_vault: activeVault,
+  }
+  return tauriCall('save_vault_list', { list })
+}

vite.config.ts

@@ -395,7 +395,7 @@ export default defineConfig({
 
   // Tauri expects a fixed port
   server: {
-    port: 5201,
+    port: 5202,
     strictPort: true,
     allowedHosts: true,
   },