feat(vault): pick a notebook vault folder on first run

Phase 0 of the file-based storage plan (docs/plans/
2026-06-24-file-based-storage.md). Foundation only — no editor or
DB change yet.

- VaultService (SharedPreferences): stores the vault root path,
  vaultRootValid() = path set AND directory exists.
- VaultSetupScreen: first-run folder picker (file_picker, Windows).
- main.dart gates HomeScreen behind a valid vault, re-prompting if
  the saved folder is gone.
- Settings: a Vault section to change the folder.

Editors still use SQLite; later phases move annotations into
per-file sidecars under the vault. analyze clean, tests green.

lib/screens/vault_setup_screen.dart

@@ -0,0 +1,158 @@
+import 'dart:io';
+
+import 'package:file_picker/file_picker.dart';
+import 'package:flutter/material.dart';
+import 'package:path/path.dart' as p;
+
+import '../l10n/app_localizations.dart';
+import '../services/vault_service.dart';
+
+/// First-run (and re-prompt) gate that asks the user to pick a vault root
+/// folder — the single folder under which all notebooks will live, like an
+/// Obsidian vault.
+///
+/// On a successful, writable selection the chosen path is persisted via
+/// [VaultService] and [onVaultReady] is invoked so the host can proceed to the
+/// home screen. When [missing] is true the screen shows a "your vault folder is
+/// missing" message instead of the first-run copy (the saved folder no longer
+/// exists).
+class VaultSetupScreen extends StatefulWidget {
+  const VaultSetupScreen({
+    super.key,
+    required this.vaultService,
+    required this.onVaultReady,
+    this.missing = false,
+  });
+
+  final VaultService vaultService;
+
+  /// Called after a valid, writable vault root has been persisted.
+  final VoidCallback onVaultReady;
+
+  /// Whether a previously-chosen folder went missing (changes the copy).
+  final bool missing;
+
+  @override
+  State<VaultSetupScreen> createState() => _VaultSetupScreenState();
+}
+
+class _VaultSetupScreenState extends State<VaultSetupScreen> {
+  bool _busy = false;
+  String? _error;
+
+  Future<void> _pickFolder() async {
+    final l = AppLocalizations.of(context);
+    setState(() {
+      _busy = true;
+      _error = null;
+    });
+    try {
+      // getDirectoryPath is Desktop/Windows supported by file_picker.
+      // lockParentWindow makes the native Windows dialog modal.
+      final path = await FilePicker.platform.getDirectoryPath(
+        dialogTitle: l.vaultSetupTitle,
+        lockParentWindow: true,
+      );
+      if (path == null) {
+        // User cancelled the native dialog.
+        if (mounted) setState(() => _busy = false);
+        return;
+      }
+      if (!await _isWritable(path)) {
+        if (mounted) {
+          setState(() {
+            _busy = false;
+            _error = l.vaultNotWritable;
+          });
+        }
+        return;
+      }
+      await widget.vaultService.setVaultRoot(path);
+      if (mounted) widget.onVaultReady();
+    } catch (e) {
+      if (mounted) {
+        setState(() {
+          _busy = false;
+          _error = l.vaultPickFailed(e.toString());
+        });
+      }
+    }
+  }
+
+  /// Probe writability by creating and deleting a temp file in [path]. The
+  /// native folder dialog can hand back a read-only location on Windows, so we
+  /// validate before committing it as the vault.
+  Future<bool> _isWritable(String path) async {
+    final probe = File(p.join(path, '.badnote-write-probe'));
+    try {
+      await probe.writeAsString('ok', flush: true);
+      await probe.delete();
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final l = AppLocalizations.of(context);
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+
+    return Scaffold(
+      body: Center(
+        child: ConstrainedBox(
+          constraints: const BoxConstraints(maxWidth: 480),
+          child: Padding(
+            padding: const EdgeInsets.all(32),
+            child: Column(
+              mainAxisAlignment: MainAxisAlignment.center,
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Icon(
+                  widget.missing
+                      ? Icons.folder_off_outlined
+                      : Icons.folder_special_outlined,
+                  size: 56,
+                  color: colorScheme.primary,
+                ),
+                const SizedBox(height: 24),
+                Text(
+                  widget.missing ? l.vaultMissingTitle : l.vaultSetupHeadline,
+                  style: textTheme.headlineSmall
+                      ?.copyWith(fontWeight: FontWeight.bold),
+                ),
+                const SizedBox(height: 12),
+                Text(
+                  widget.missing ? l.vaultMissingBody : l.vaultSetupBody,
+                  style: textTheme.bodyMedium
+                      ?.copyWith(color: colorScheme.onSurfaceVariant),
+                ),
+                if (_error != null) ...[
+                  const SizedBox(height: 16),
+                  Text(
+                    _error!,
+                    style: textTheme.bodyMedium
+                        ?.copyWith(color: colorScheme.error),
+                  ),
+                ],
+                const SizedBox(height: 32),
+                FilledButton.icon(
+                  onPressed: _busy ? null : _pickFolder,
+                  icon: _busy
+                      ? const SizedBox(
+                          width: 18,
+                          height: 18,
+                          child: CircularProgressIndicator(strokeWidth: 2),
+                        )
+                      : const Icon(Icons.folder_open),
+                  label: Text(l.vaultChooseFolder),
+                ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}