feat(offline): tier 2 phase 3 — write queue with optimistic UI

Offline writes now queue + apply optimistically instead of throwing.
On reconnect, the queue drains automatically; conflicts and rejections
surface as one-time SnackBars so the user knows their edit didn't land.

- Drift schema v3: `pending_writes` table (verb + payload + baseline +
  tries + last_error). Negative ids serve as cache placeholders for
  offline-created rows until replay assigns the server id.
- Each write repository (notes, tasks, projects, milestones, events)
  now catches NetworkException, applies the change to cache (with a
  fresh `nextTempId()` for creates), and enqueues the API call.
- Edits to a still-queued offline-created row coalesce into the
  original create payload — only one server call per row, in order.
- Deletes of still-queued offline-created rows drop the queue entry
  and the cache row; no server call ever happens.
- New WriteQueue service drains the queue oldest-first.
  Server-wins on `updated_at` baseline check (notes/tasks/projects);
  last-writer-wins for milestones/events (no getOne available).
  4xx → drop + surface as `rejected`; conflict → drop + `overwritten`;
  404 on update → drop + `missing`; 5xx/network → keep + retry next
  online cycle.
- Replay fires on AuthStatus → authenticated transitions
  (cold-start, came-back-online, login).
- OfflineBanner shows "Retry (N)" with the pending-writes count.
- Distinct ServerException added so 4xx no longer masquerade as
  NetworkException — the queue can drop them instead of looping.

flutter analyze clean; 21 tests pass (3 new for QueueFailure messaging).
Phase 4 (read-only UI indicators on cached/temp rows) still ahead.

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

lib/data/repositories/notes_repository.dart

@@ -3,19 +3,22 @@ import '../api/notes_api.dart';
 import '../local/database.dart';
 import '../models/note.dart';
 
-/// Notes repository with read-through caching for Tier 2 offline support.
+/// Notes repository with read-through caching for Tier 2 offline support
+/// (Phase 1+2) and offline-write queueing (Phase 3).
 ///
 /// Reads attempt the network first; on success the response is written to
 /// the local Drift cache. On `NetworkException` the read falls back to the
 /// cache (rethrowing if the cache is empty so the UI can show its
-/// fresh-install empty state). Writes (create / update / delete) hit the
-/// server then sync the cache; offline write queueing is Phase 3 work and
-/// not yet wired here — write methods will throw on `NetworkException` in
-/// the meantime.
+/// fresh-install empty state).
+///
+/// Writes hit the server then sync the cache. On `NetworkException` the
+/// write is queued in `pending_writes` and applied optimistically to the
+/// cache (negative temp-id for creates, in-place update for edits, removal
+/// for deletes). Subsequent edits to a temp-id row are coalesced into the
+/// queued create — only one server call is made per offline-created row.
 ///
 /// `AuthStatus.offline` is owned by `AuthNotifier.verify()` (a periodic
-/// heartbeat). This repository deliberately does not poke that state — its
-/// only job is to serve what's cached when the network is unreachable.
+/// heartbeat). This repository deliberately does not poke that state.
 class NotesRepository {
   final NotesApi _api;
   final FabledDatabase _db;
@@ -53,15 +56,44 @@ class NotesRepository {
     int? projectId,
     String noteType = 'note',
   }) async {
-    final note = await _api.create(
-      title,
-      body,
-      tags: tags,
-      projectId: projectId,
-      noteType: noteType,
-    );
-    await _db.upsertNote(note);
-    return note;
+    try {
+      final note = await _api.create(
+        title,
+        body,
+        tags: tags,
+        projectId: projectId,
+        noteType: noteType,
+      );
+      await _db.upsertNote(note);
+      return note;
+    } on NetworkException {
+      final tempId = await _db.nextTempId();
+      final now = DateTime.now();
+      final optimistic = Note(
+        id: tempId,
+        title: title,
+        body: body,
+        tags: tags,
+        noteType: noteType,
+        projectId: projectId,
+        createdAt: now,
+        updatedAt: now,
+      );
+      await _db.upsertNote(optimistic);
+      await _db.enqueuePending(
+        domain: kSyncDomainNotes,
+        verb: kWriteVerbCreate,
+        tempId: tempId,
+        payload: {
+          'title': title,
+          'body': body,
+          'tags': tags,
+          'project_id': projectId,
+          'note_type': noteType,
+        },
+      );
+      return optimistic;
+    }
   }
 
   Future<Note> update(
@@ -73,21 +105,75 @@ class NotesRepository {
     bool clearProject = false,
     String noteType = 'note',
   }) async {
-    final updated = await _api.update(
-      id,
-      title,
-      body,
-      tags: tags,
-      projectId: projectId,
-      clearProject: clearProject,
-      noteType: noteType,
-    );
-    await _db.upsertNote(updated);
-    return updated;
+    try {
+      final updated = await _api.update(
+        id,
+        title,
+        body,
+        tags: tags,
+        projectId: projectId,
+        clearProject: clearProject,
+        noteType: noteType,
+      );
+      await _db.upsertNote(updated);
+      return updated;
+    } on NetworkException {
+      final cached = await _db.getNote(id);
+      if (cached == null) rethrow;
+      final payload = <String, dynamic>{
+        'title': title,
+        'body': body,
+        'tags': tags,
+        'project_id': projectId,
+        'clear_project': clearProject,
+        'note_type': noteType,
+      };
+      final optimistic = cached.copyWith(
+        title: title,
+        body: body,
+        tags: tags,
+        noteType: noteType,
+        projectId: clearProject ? null : projectId,
+      );
+      await _db.upsertNote(optimistic);
+      // Edits to an offline-created row coalesce into the queued create.
+      if (id < 0) {
+        final queued = await _db.findQueuedCreate(kSyncDomainNotes, id);
+        if (queued != null) {
+          await _db.updatePendingPayload(queued.id, payload);
+          return optimistic;
+        }
+      }
+      await _db.enqueuePending(
+        domain: kSyncDomainNotes,
+        verb: kWriteVerbUpdate,
+        targetId: id,
+        payload: payload,
+        baselineUpdatedAt: cached.updatedAt,
+      );
+      return optimistic;
+    }
   }
 
   Future<void> delete(int id) async {
-    await _api.delete(id);
-    await _db.deleteNote(id);
+    try {
+      await _api.delete(id);
+      await _db.deleteNote(id);
+    } on NetworkException {
+      // Deleting an offline-created row that never reached the server
+      // just drops the queued create — no server call needed.
+      if (id < 0) {
+        final queued = await _db.findQueuedCreate(kSyncDomainNotes, id);
+        if (queued != null) await _db.deletePending(queued.id);
+        await _db.deleteNote(id);
+        return;
+      }
+      await _db.deleteNote(id);
+      await _db.enqueuePending(
+        domain: kSyncDomainNotes,
+        verb: kWriteVerbDelete,
+        targetId: id,
+      );
+    }
   }
 }