Add local data store adapter layer and Hive scaffold

lib/core/config/app_config.dart

@@ -22,6 +22,10 @@ class AppConfig {
   static bool get useFakeBackend =>
       const bool.fromEnvironment('USE_FAKE_BACKEND', defaultValue: true);
 
+  /// Enables Hive local persistence store instead of shared_preferences.
+  static bool get useHiveLocalDb =>
+      const bool.fromEnvironment('USE_HIVE_LOCAL_DB', defaultValue: false);
+
   /// Runtime override for backend URL (e.g. local settings screen).
   static void overrideBackendBaseUrl(String? baseUrl) {
     _baseUrlOverride = baseUrl;

lib/features/local/local_repository.dart

@@ -2,15 +2,14 @@ import 'dart:convert';
 
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:relationship_saver/features/local/local_models.dart';
+import 'package:relationship_saver/features/local/storage/local_data_store.dart';
+import 'package:relationship_saver/features/local/storage/local_data_store_provider.dart';
 import 'package:relationship_saver/features/sync/sync_queue_repository.dart';
 import 'package:relationship_saver/integrations/backend/models/backend_models.dart';
-import 'package:shared_preferences/shared_preferences.dart';
 import 'package:uuid/uuid.dart';
 
 /// Persisted local data source for offline-first product state.
 class LocalRepository extends AsyncNotifier<LocalDataState> {
-  static const String _storageKey = 'local_data_state_v1';
-  static const String _schemaVersionKey = 'local_data_schema_version';
   static const int _schemaVersion = 2;
   static const int _syncSchemaVersion = 1;
 
@@ -18,18 +17,18 @@ class LocalRepository extends AsyncNotifier<LocalDataState> {
 
   @override
   Future<LocalDataState> build() async {
-    final SharedPreferences prefs = await SharedPreferences.getInstance();
-    await _migrateIfNeeded(prefs);
-
-    final String? raw = prefs.getString(_storageKey);
-    if (raw == null || raw.isEmpty) {
+    final LocalDataStore store = ref.read(localDataStoreProvider);
+    final LocalDataRecord? record = await store.read();
+    if (record == null || record.rawState.isEmpty) {
       final LocalDataState seeded = LocalDataState.seed();
       await _persist(seeded);
       return seeded;
     }
 
+    final LocalDataRecord migrated = await _migrateIfNeeded(record);
     try {
-      final Map<String, dynamic> json = jsonDecode(raw) as Map<String, dynamic>;
+      final Map<String, dynamic> json =
+          jsonDecode(migrated.rawState) as Map<String, dynamic>;
       return LocalDataState.fromJson(json);
     } on FormatException {
       final LocalDataState fallback = LocalDataState.seed();
@@ -882,25 +881,37 @@ class LocalRepository extends AsyncNotifier<LocalDataState> {
   }
 
   Future<void> _persist(LocalDataState state) async {
-    final SharedPreferences prefs = await SharedPreferences.getInstance();
-    await prefs.setString(_storageKey, jsonEncode(state.toJson()));
-    await prefs.setInt(_schemaVersionKey, _schemaVersion);
+    await ref
+        .read(localDataStoreProvider)
+        .write(
+          rawState: jsonEncode(state.toJson()),
+          schemaVersion: _schemaVersion,
+        );
   }
 
-  Future<void> _migrateIfNeeded(SharedPreferences prefs) async {
-    final int currentVersion = prefs.getInt(_schemaVersionKey) ?? 0;
+  Future<LocalDataRecord> _migrateIfNeeded(LocalDataRecord record) async {
+    final int currentVersion = record.schemaVersion;
     if (currentVersion == _schemaVersion) {
-      return;
+      return record;
     }
 
+    final LocalDataStore store = ref.read(localDataStoreProvider);
     if (currentVersion <= 0) {
-      await prefs.remove(_storageKey);
-      await prefs.setInt(_schemaVersionKey, _schemaVersion);
-      return;
+      final LocalDataState seeded = LocalDataState.seed();
+      await store.clear();
+      await _persist(seeded);
+      return LocalDataRecord(
+        rawState: jsonEncode(seeded.toJson()),
+        schemaVersion: _schemaVersion,
+      );
     }
 
     // Migration placeholder for future schema versions.
-    await prefs.setInt(_schemaVersionKey, _schemaVersion);
+    await store.write(rawState: record.rawState, schemaVersion: _schemaVersion);
+    return LocalDataRecord(
+      rawState: record.rawState,
+      schemaVersion: _schemaVersion,
+    );
   }
 
   String _titleFromSummary(String summary) {

lib/features/local/storage/local_data_store.dart

@@ -0,0 +1,19 @@
+/// Raw local state payload and associated schema version.
+class LocalDataRecord {
+  const LocalDataRecord({required this.rawState, required this.schemaVersion});
+
+  final String rawState;
+  final int schemaVersion;
+}
+
+/// Persistence boundary for local app state.
+abstract interface class LocalDataStore {
+  /// Reads latest persisted state payload.
+  Future<LocalDataRecord?> read();
+
+  /// Writes state payload and schema version.
+  Future<void> write({required String rawState, required int schemaVersion});
+
+  /// Clears persisted state payload.
+  Future<void> clear();
+}

lib/features/local/storage/local_data_store_hive.dart

@@ -0,0 +1,54 @@
+import 'package:hive_flutter/hive_flutter.dart';
+import 'package:relationship_saver/features/local/storage/local_data_store.dart';
+
+/// Hive-backed local store for future DB migration path.
+class HiveLocalDataStore implements LocalDataStore {
+  static const String _boxName = 'relationship_saver_local';
+  static const String _stateKey = 'state_json';
+  static const String _schemaVersionKey = 'schema_version';
+
+  static bool _initialized = false;
+
+  @override
+  Future<void> clear() async {
+    final Box<dynamic> box = await _openBox();
+    await box.delete(_stateKey);
+    await box.delete(_schemaVersionKey);
+  }
+
+  @override
+  Future<LocalDataRecord?> read() async {
+    final Box<dynamic> box = await _openBox();
+    final String? rawState = box.get(_stateKey) as String?;
+    if (rawState == null || rawState.isEmpty) {
+      return null;
+    }
+
+    final int schemaVersion =
+        (box.get(_schemaVersionKey) as num?)?.toInt() ?? 0;
+    return LocalDataRecord(rawState: rawState, schemaVersion: schemaVersion);
+  }
+
+  @override
+  Future<void> write({
+    required String rawState,
+    required int schemaVersion,
+  }) async {
+    final Box<dynamic> box = await _openBox();
+    await box.put(_stateKey, rawState);
+    await box.put(_schemaVersionKey, schemaVersion);
+  }
+
+  Future<Box<dynamic>> _openBox() async {
+    if (!_initialized) {
+      await Hive.initFlutter();
+      _initialized = true;
+    }
+
+    if (!Hive.isBoxOpen(_boxName)) {
+      return Hive.openBox<dynamic>(_boxName);
+    }
+
+    return Hive.box<dynamic>(_boxName);
+  }
+}

lib/features/local/storage/local_data_store_in_memory.dart

@@ -0,0 +1,22 @@
+import 'package:relationship_saver/features/local/storage/local_data_store.dart';
+
+/// In-memory local store for deterministic tests.
+class InMemoryLocalDataStore implements LocalDataStore {
+  LocalDataRecord? _record;
+
+  @override
+  Future<void> clear() async {
+    _record = null;
+  }
+
+  @override
+  Future<LocalDataRecord?> read() async => _record;
+
+  @override
+  Future<void> write({
+    required String rawState,
+    required int schemaVersion,
+  }) async {
+    _record = LocalDataRecord(rawState: rawState, schemaVersion: schemaVersion);
+  }
+}

lib/features/local/storage/local_data_store_provider.dart

@@ -0,0 +1,14 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:relationship_saver/core/config/app_config.dart';
+import 'package:relationship_saver/features/local/storage/local_data_store.dart';
+import 'package:relationship_saver/features/local/storage/local_data_store_hive.dart';
+import 'package:relationship_saver/features/local/storage/local_data_store_shared_prefs.dart';
+
+/// Chooses local persistence backend for app state.
+final Provider<LocalDataStore> localDataStoreProvider =
+    Provider<LocalDataStore>((Ref ref) {
+      if (AppConfig.useHiveLocalDb) {
+        return HiveLocalDataStore();
+      }
+      return SharedPrefsLocalDataStore();
+    });

lib/features/local/storage/local_data_store_shared_prefs.dart

@@ -0,0 +1,44 @@
+import 'package:relationship_saver/features/local/storage/local_data_store.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+/// shared_preferences-backed local store used as stable default.
+class SharedPrefsLocalDataStore implements LocalDataStore {
+  SharedPrefsLocalDataStore({
+    this.stateKey = 'local_data_state_v1',
+    this.schemaVersionKey = 'local_data_schema_version',
+  });
+
+  final String stateKey;
+  final String schemaVersionKey;
+
+  @override
+  Future<void> clear() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.remove(stateKey);
+    await prefs.remove(schemaVersionKey);
+  }
+
+  @override
+  Future<LocalDataRecord?> read() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    final String? rawState = prefs.getString(stateKey);
+    if (rawState == null || rawState.isEmpty) {
+      return null;
+    }
+
+    return LocalDataRecord(
+      rawState: rawState,
+      schemaVersion: prefs.getInt(schemaVersionKey) ?? 0,
+    );
+  }
+
+  @override
+  Future<void> write({
+    required String rawState,
+    required int schemaVersion,
+  }) async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.setString(stateKey, rawState);
+    await prefs.setInt(schemaVersionKey, schemaVersion);
+  }
+}