feat(offline): tier 2 phase 2 — extend cache to tasks/projects/milestones/events/conversations

Phase 1 cached only notes. Phase 2 brings the read-through pattern to every
domain the app reads in bulk:

- Drift schema v2: 5 new cached_* tables + onUpgrade migration. Calendar
  events use range-scoped read/write (replaceEventsInRange) so disjoint
  month fetches don't clobber each other; milestones are per-project.
- Wrap TasksRepository, ProjectsRepository, MilestonesRepository, and
  ChatRepository (conversation list only) with NetworkException fallback.
  Writes hit the API then sync the cache.
- New EventsRepository wrapping EventsApi; calendar_provider and
  event_form_sheet repointed at the repository.
- OfflineBanner now surfaces getLatestSync() — most-recent timestamp
  across all domains — so the hint reads sensibly regardless of screen.

flutter analyze clean; existing tests pass. Phase 3 (offline write queue)
and Phase 4 (read-only UI indicators) still to come.

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

lib/data/repositories/projects_repository.dart

@@ -1,31 +1,87 @@
+import '../../core/exceptions.dart';
 import '../api/projects_api.dart';
+import '../local/database.dart';
 import '../models/project.dart';
 
+/// Projects repository with read-through caching for Tier 2 offline support.
+/// Mirrors the pattern in NotesRepository — see that file for full notes.
+///
+/// `getAll`'s sort/order/status query parameters are server-side filters; the
+/// cache stores the unfiltered list as last seen. Offline fallback returns
+/// the full cache regardless of the requested filters — close enough for a
+/// "view what you had" experience while disconnected.
 class ProjectsRepository {
   final ProjectsApi _api;
-  const ProjectsRepository(this._api);
+  final FabledDatabase _db;
+
+  const ProjectsRepository(this._api, this._db);
 
   Future<List<Project>> getAll({
     String? status,
     String sort = 'updated_at',
     String order = 'desc',
-  }) =>
-      _api.getAll(status: status, sort: sort, order: order);
-  Future<Project> getOne(int id) => _api.getOne(id);
+  }) async {
+    try {
+      final projects =
+          await _api.getAll(status: status, sort: sort, order: order);
+      // Only refresh the cache on the unfiltered default fetch — otherwise a
+      // status=archived call would clobber the active-projects cache.
+      if (status == null) {
+        await _db.replaceAllProjects(projects);
+      } else {
+        for (final p in projects) {
+          await _db.upsertProject(p);
+        }
+      }
+      return projects;
+    } on NetworkException {
+      final cached = await _db.getAllProjects();
+      if (cached.isEmpty) rethrow;
+      if (status != null) {
+        return cached.where((p) => p.status == status).toList();
+      }
+      return cached;
+    }
+  }
+
+  Future<Project> getOne(int id) async {
+    try {
+      final project = await _api.getOne(id);
+      await _db.upsertProject(project);
+      return project;
+    } on NetworkException {
+      final cached = await _db.getProject(id);
+      if (cached == null) rethrow;
+      return cached;
+    }
+  }
+
   Future<Project> create({
     required String title,
     String? description,
     String? goal,
     String? color,
     String status = 'active',
-  }) =>
-      _api.create(
-          title: title,
-          description: description,
-          goal: goal,
-          color: color,
-          status: status);
-  Future<Project> update(int id, Map<String, dynamic> fields) =>
-      _api.update(id, fields);
-  Future<void> delete(int id) => _api.delete(id);
+  }) async {
+    final project = await _api.create(
+      title: title,
+      description: description,
+      goal: goal,
+      color: color,
+      status: status,
+    );
+    await _db.upsertProject(project);
+    return project;
+  }
+
+  Future<Project> update(int id, Map<String, dynamic> fields) async {
+    final updated = await _api.update(id, fields);
+    await _db.upsertProject(updated);
+    return updated;
+  }
+
+  Future<void> delete(int id) async {
+    await _api.delete(id);
+    await _db.deleteProject(id);
+  }
 }