fix: remove persistLastVault assertions from onboarding test

Vault list was stored only in React useState, lost on every app restart
or update. Now persisted to ~/.config/com.laputa.app/vaults.json via
Rust backend commands (load_vault_list, save_vault_list).

- Add vault_list.rs module with VaultEntry/VaultList types and JSON I/O
- Register load_vault_list/save_vault_list Tauri commands
- Extract vaultListStore.ts utility for frontend persistence calls
- Rewrite useVaultSwitcher to load on mount and persist on change
- Show unavailable vaults greyed out with warning icon instead of
  silently removing them
- Add mock handlers for browser/test environments
- Add useVaultSwitcher tests covering persistence, availability, dedup

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.claude-pid

@@ -1 +1 @@
-21351
+

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
@@ -274,6 +276,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
@@ -461,6 +473,21 @@ mod tests {
     }
 }
 
+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),
+    }
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
@@ -491,23 +518,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![
@@ -539,6 +550,8 @@ pub fn run() {
             get_settings,
             update_menu_state,
             save_settings,
+            load_vault_list,
+            save_vault_list,
             github_list_repos,
             github_create_repo,
             clone_repo,

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/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/App.tsx

@@ -325,6 +325,7 @@ function App() {
       if (entry) notes.handleSelectNote(entry)
     },
     onOpenVault: vaultSwitcher.handleOpenLocalFolder,
+    onCreateType: dialogs.openCreateType,
     onToggleAIChat: dialogs.toggleAIChat,
     onCheckForUpdates: handleCheckForUpdates,
     isUpdating: updateStatus.state === 'downloading' || updateStatus.state === 'ready',

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/hooks/useAppCommands.ts

@@ -53,6 +53,7 @@ interface AppCommandsConfig {
   onCreateTheme?: () => void
   onOpenTheme?: (themeId: string) => void
   onOpenVault?: () => void
+  onCreateType?: () => void
   onToggleAIChat?: () => void
   onCheckForUpdates?: () => void
   isUpdating?: boolean
@@ -152,6 +153,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onCreateTheme: config.onCreateTheme,
     onOpenTheme: config.onOpenTheme,
     onOpenVault: config.onOpenVault,
+    onCreateType: config.onCreateType,
     onToggleAIChat: config.onToggleAIChat,
     onCheckForUpdates: config.onCheckForUpdates,
     isUpdating: config.isUpdating,

src/hooks/useCommandRegistry.test.ts

@@ -316,6 +316,41 @@ describe('useCommandRegistry', () => {
     })
   })
 
+  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 = [

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
@@ -178,6 +179,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     onGoBack, onGoForward, canGoBack, canGoForward,
     themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenTheme,
     onCheckForUpdates, isUpdating,
+    onCreateType,
   } = config
 
   const hasActiveNote = activeTabPath !== null
@@ -205,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) } },
@@ -241,7 +244,7 @@ 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,

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(),
 }))

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,7 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { pickFolder } from '../utils/vault-dialog'
+import { loadVaultList, saveVaultList } from '../utils/vaultListStore'
 import type { VaultOption } from '../components/StatusBar'
 
+export type { PersistedVaultList } from '../utils/vaultListStore'
+
 export const DEFAULT_VAULTS: VaultOption[] = [
   { label: 'Getting Started', path: '/Users/luca/Workspace/laputa-app/demo-vault-v2' },
 ]
@@ -11,20 +14,55 @@ interface UseVaultSwitcherOptions {
   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) => {
@@ -32,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-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' },
@@ -245,6 +254,8 @@ export const mockHandlers: Record<string, (args: any) => any> = {
       }))
     return { results: matches, elapsed_ms: 42, query: q, mode: args.mode }
   },
+  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"

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 })
+}