fix: persist last vault path so app reopens correct vault after update

The vault path was stored only in React state (useState), which resets
on every app restart. Now the last active vault path is written to
~/Library/Application Support/com.laputa.app/last-vault.txt on every
vault switch, and loaded on startup. If the saved vault no longer exists,
the existing onboarding flow shows the vault picker instead of silently
falling back to the demo vault.

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

.claude-pid

@@ -1 +1 @@
-21351
+3852

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

src-tauri/src/lib.rs

@@ -274,6 +274,16 @@ fn save_settings(settings: Settings) -> Result<(), String> {
     settings::save_settings(settings)
 }
 
+#[tauri::command]
+fn get_last_vault_path() -> Option<String> {
+    settings::get_last_vault()
+}
+
+#[tauri::command]
+fn set_last_vault_path(path: String) -> Result<(), String> {
+    settings::set_last_vault(&path)
+}
+
 #[tauri::command]
 async fn github_list_repos(token: String) -> Result<Vec<GithubRepo>, String> {
     github::github_list_repos(&token).await
@@ -539,6 +549,8 @@ pub fn run() {
             get_settings,
             update_menu_state,
             save_settings,
+            get_last_vault_path,
+            set_last_vault_path,
             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/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/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

@@ -277,6 +277,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,
@@ -313,11 +325,12 @@ 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',
   })
 
-  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

src/hooks/useAppCommands.ts

@@ -53,7 +53,10 @@ interface AppCommandsConfig {
   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. */
@@ -150,7 +153,10 @@ 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,
   })
 
   useKeyboardNavigation({

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 = [

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
@@ -175,6 +178,8 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     onSelect, onOpenDailyNote, onCloseTab,
     onGoBack, onGoForward, canGoBack, canGoForward,
     themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenTheme,
+    onCheckForUpdates, isUpdating,
+    onCreateType,
   } = config
 
   const hasActiveNote = activeTabPath !== null
@@ -202,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) } },
@@ -229,6 +235,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
       // 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),
@@ -237,9 +244,10 @@ 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,

src/hooks/useOnboarding.test.ts

@@ -20,12 +20,17 @@ vi.mock('../mock-tauri', () => ({
   mockInvoke: (...args: unknown[]) => mockInvokeFn(...args),
 }))
 
+vi.mock('./useVaultSwitcher', () => ({
+  persistLastVault: vi.fn(),
+}))
+
 vi.mock('../utils/vault-dialog', () => ({
   pickFolder: vi.fn(),
 }))
 
 import { useOnboarding } from './useOnboarding'
 import { pickFolder } from '../utils/vault-dialog'
+import { persistLastVault } from './useVaultSwitcher'
 
 describe('useOnboarding', () => {
   beforeEach(() => {
@@ -35,7 +40,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 +55,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 +65,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 +85,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 +107,14 @@ 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')
+    expect(persistLastVault).toHaveBeenCalledWith('/mock/Documents/Getting Started')
   })
 
   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 +136,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
     })
@@ -148,11 +154,12 @@ describe('useOnboarding', () => {
 
     expect(result.current.state).toEqual({ status: 'ready', vaultPath: '/selected/folder' })
     expect(localStorage.getItem('laputa_welcome_dismissed')).toBe('1')
+    expect(persistLastVault).toHaveBeenCalledWith('/selected/folder')
   })
 
   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 +180,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/useOnboarding.ts

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useState } from 'react'
 import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from '../mock-tauri'
 import { pickFolder } from '../utils/vault-dialog'
+import { persistLastVault } from './useVaultSwitcher'
 
 type OnboardingState =
   | { status: 'loading' }
@@ -70,6 +71,7 @@ export function useOnboarding(initialVaultPath: string) {
     try {
       const vaultPath = await tauriCall<string>('create_getting_started_vault', { targetPath: null })
       markDismissed()
+      persistLastVault(vaultPath)
       setState({ status: 'ready', vaultPath })
     } catch (err) {
       setError(typeof err === 'string' ? err : `Failed to create vault: ${err}`)
@@ -83,6 +85,7 @@ export function useOnboarding(initialVaultPath: string) {
       const path = await pickFolder('Open vault folder')
       if (!path) return
       markDismissed()
+      persistLastVault(path)
       setState({ status: 'ready', vaultPath: path })
     } catch (err) {
       setError(`Failed to open folder: ${err}`)

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/useVaultSwitcher.test.ts

@@ -0,0 +1,133 @@
+import { renderHook, waitFor, act } from '@testing-library/react'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const mockInvokeFn = vi.fn()
+
+vi.mock('../mock-tauri', () => ({
+  isTauri: () => false,
+  mockInvoke: (...args: unknown[]) => mockInvokeFn(...args),
+}))
+
+vi.mock('../utils/vault-dialog', () => ({
+  pickFolder: vi.fn(),
+}))
+
+import { useVaultSwitcher, DEFAULT_VAULTS, persistLastVault } from './useVaultSwitcher'
+import { pickFolder } from '../utils/vault-dialog'
+
+describe('useVaultSwitcher', () => {
+  const onSwitch = vi.fn()
+  const onToast = vi.fn()
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockInvokeFn.mockImplementation(async (cmd: string) => {
+      if (cmd === 'get_last_vault_path') return null
+      if (cmd === 'set_last_vault_path') return null
+      return null
+    })
+  })
+
+  it('starts with the default vault path', () => {
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+    expect(result.current.vaultPath).toBe(DEFAULT_VAULTS[0].path)
+  })
+
+  it('loads last vault path from backend on mount', async () => {
+    mockInvokeFn.mockImplementation(async (cmd: string) => {
+      if (cmd === 'get_last_vault_path') return '/Users/test/MyVault'
+      if (cmd === 'set_last_vault_path') return null
+      return null
+    })
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await waitFor(() => {
+      expect(result.current.vaultPath).toBe('/Users/test/MyVault')
+    })
+  })
+
+  it('falls back to default when no last vault is stored', async () => {
+    mockInvokeFn.mockImplementation(async (cmd: string) => {
+      if (cmd === 'get_last_vault_path') return null
+      return null
+    })
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    // Wait for the async load to complete
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('get_last_vault_path', {})
+    })
+
+    expect(result.current.vaultPath).toBe(DEFAULT_VAULTS[0].path)
+  })
+
+  it('falls back to default when get_last_vault_path fails', async () => {
+    mockInvokeFn.mockImplementation(async (cmd: string) => {
+      if (cmd === 'get_last_vault_path') throw new Error('read failed')
+      return null
+    })
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    // Wait for the async load to complete
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('get_last_vault_path', {})
+    })
+
+    expect(result.current.vaultPath).toBe(DEFAULT_VAULTS[0].path)
+  })
+
+  it('persists vault path when switching', async () => {
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    act(() => {
+      result.current.switchVault('/Users/test/NewVault')
+    })
+
+    expect(result.current.vaultPath).toBe('/Users/test/NewVault')
+    expect(mockInvokeFn).toHaveBeenCalledWith('set_last_vault_path', { path: '/Users/test/NewVault' })
+  })
+
+  it('persists vault path on handleOpenLocalFolder', async () => {
+    vi.mocked(pickFolder).mockResolvedValue('/Users/test/OpenedVault')
+
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    await act(async () => {
+      await result.current.handleOpenLocalFolder()
+    })
+
+    expect(result.current.vaultPath).toBe('/Users/test/OpenedVault')
+    expect(mockInvokeFn).toHaveBeenCalledWith('set_last_vault_path', { path: '/Users/test/OpenedVault' })
+  })
+
+  it('persists vault path on handleVaultCloned', async () => {
+    const { result } = renderHook(() => useVaultSwitcher({ onSwitch, onToast }))
+
+    act(() => {
+      result.current.handleVaultCloned('/Users/test/ClonedVault', 'ClonedVault')
+    })
+
+    expect(result.current.vaultPath).toBe('/Users/test/ClonedVault')
+    expect(mockInvokeFn).toHaveBeenCalledWith('set_last_vault_path', { path: '/Users/test/ClonedVault' })
+  })
+})
+
+describe('persistLastVault', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockInvokeFn.mockResolvedValue(null)
+  })
+
+  it('calls set_last_vault_path with the given path', () => {
+    persistLastVault('/Users/test/Vault')
+    expect(mockInvokeFn).toHaveBeenCalledWith('set_last_vault_path', { path: '/Users/test/Vault' })
+  })
+
+  it('does not throw when the backend call fails', () => {
+    mockInvokeFn.mockRejectedValue(new Error('write failed'))
+    expect(() => persistLastVault('/Users/test/Vault')).not.toThrow()
+  })
+})

src/hooks/useVaultSwitcher.ts

@@ -1,28 +1,39 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { isTauri } from '../mock-tauri'
+import { invoke } from '@tauri-apps/api/core'
+import { isTauri, mockInvoke } from '../mock-tauri'
 import { pickFolder } from '../utils/vault-dialog'
 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 const DEFAULT_VAULTS: VaultOption[] = [
+  { label: 'Getting Started', path: '/Users/luca/Workspace/laputa-app/demo-vault-v2' },
+]
 
 interface UseVaultSwitcherOptions {
   onSwitch: () => void
   onToast: (msg: string) => void
 }
 
+function tauriCall<T>(command: string, args: Record<string, unknown>): Promise<T> {
+  return isTauri() ? invoke<T>(command, args) : mockInvoke<T>(command, args)
+}
+
+export function persistLastVault(path: string): void {
+  tauriCall('set_last_vault_path', { path }).catch(() => {})
+}
+
 /** Manages vault path, extra vaults, switching, cloning, and local folder opening. */
 export function useVaultSwitcher({ onSwitch, onToast }: UseVaultSwitcherOptions) {
   const [vaultPath, setVaultPath] = useState(DEFAULT_VAULTS[0].path)
   const [extraVaults, setExtraVaults] = useState<VaultOption[]>([])
   const allVaults = useMemo(() => [...DEFAULT_VAULTS, ...extraVaults], [extraVaults])
 
+  // On mount, load the last vault path from persistent storage
+  useEffect(() => {
+    tauriCall<string | null>('get_last_vault_path', {}).then((saved) => {
+      if (saved) setVaultPath(saved)
+    }).catch(() => {})
+  }, [])
+
   // Refs ensure stable callbacks that always invoke the latest closures,
   // breaking the circular dependency between useVaultSwitcher and downstream hooks.
   const onSwitchRef = useRef(onSwitch)
@@ -35,6 +46,7 @@ export function useVaultSwitcher({ onSwitch, onToast }: UseVaultSwitcherOptions)
 
   const switchVault = useCallback((path: string) => {
     setVaultPath(path)
+    persistLastVault(path)
     onSwitchRef.current()
   }, [])
 

src/mock-tauri/mock-handlers.ts

@@ -82,6 +82,8 @@ let mockSettings: Settings = {
   auto_pull_interval_minutes: 5,
 }
 
+let mockLastVaultPath: string | null = null
+
 let mockVaultSettings: VaultSettings = { theme: null }
 
 const mockThemes: ThemeFile[] = [
@@ -245,12 +247,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 => {