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/tasks_repository.dart

@@ -3,8 +3,8 @@ import '../api/tasks_api.dart';
 import '../local/database.dart';
 import '../models/task.dart';
 
-/// Tasks repository with read-through caching for Tier 2 offline support.
-/// Mirrors the pattern in NotesRepository — see that file for full notes.
+/// Tasks repository with read-through caching (Phase 1+2) and offline-write
+/// queueing (Phase 3). See `notes_repository.dart` for the full pattern.
 class TasksRepository {
   final TasksApi _api;
   final FabledDatabase _db;
@@ -68,27 +68,129 @@ class TasksRepository {
     int? projectId,
     int? parentId,
   }) async {
-    final task = await _api.create(
-      title: title,
-      description: description,
-      status: status,
-      priority: priority,
-      dueDate: dueDate,
-      projectId: projectId,
-      parentId: parentId,
-    );
-    await _db.upsertTask(task);
-    return task;
+    try {
+      final task = await _api.create(
+        title: title,
+        description: description,
+        status: status,
+        priority: priority,
+        dueDate: dueDate,
+        projectId: projectId,
+        parentId: parentId,
+      );
+      await _db.upsertTask(task);
+      return task;
+    } on NetworkException {
+      final tempId = await _db.nextTempId();
+      final now = DateTime.now();
+      final optimistic = Task(
+        id: tempId,
+        title: title,
+        description: description,
+        status: status,
+        priority: priority,
+        dueDate: dueDate,
+        projectId: projectId,
+        parentId: parentId,
+        createdAt: now,
+        updatedAt: now,
+      );
+      await _db.upsertTask(optimistic);
+      await _db.enqueuePending(
+        domain: kSyncDomainTasks,
+        verb: kWriteVerbCreate,
+        tempId: tempId,
+        payload: {
+          'title': title,
+          'description': description,
+          'status': status.value,
+          'priority': priority.value,
+          'due_date': dueDate?.toIso8601String(),
+          'project_id': projectId,
+          'parent_id': parentId,
+        },
+      );
+      return optimistic;
+    }
   }
 
   Future<Task> update(int id, Map<String, dynamic> fields) async {
-    final updated = await _api.update(id, fields);
-    await _db.upsertTask(updated);
-    return updated;
+    try {
+      final updated = await _api.update(id, fields);
+      await _db.upsertTask(updated);
+      return updated;
+    } on NetworkException {
+      final cached = await _db.getTask(id);
+      if (cached == null) rethrow;
+      final optimistic = _applyTaskFields(cached, fields);
+      await _db.upsertTask(optimistic);
+      if (id < 0) {
+        final queued = await _db.findQueuedCreate(kSyncDomainTasks, id);
+        if (queued != null) {
+          await _db.updatePendingPayload(queued.id, fields);
+          return optimistic;
+        }
+      }
+      await _db.enqueuePending(
+        domain: kSyncDomainTasks,
+        verb: kWriteVerbUpdate,
+        targetId: id,
+        payload: fields,
+        baselineUpdatedAt: cached.updatedAt,
+      );
+      return optimistic;
+    }
   }
 
   Future<void> delete(int id) async {
-    await _api.delete(id);
-    await _db.deleteTask(id);
+    try {
+      await _api.delete(id);
+      await _db.deleteTask(id);
+    } on NetworkException {
+      if (id < 0) {
+        final queued = await _db.findQueuedCreate(kSyncDomainTasks, id);
+        if (queued != null) await _db.deletePending(queued.id);
+        await _db.deleteTask(id);
+        return;
+      }
+      await _db.deleteTask(id);
+      await _db.enqueuePending(
+        domain: kSyncDomainTasks,
+        verb: kWriteVerbDelete,
+        targetId: id,
+      );
+    }
   }
 }
+
+/// Applies a partial-fields map (the same shape sent to the PUT endpoint)
+/// to a cached Task so the UI can show the edit immediately.
+Task _applyTaskFields(Task t, Map<String, dynamic> f) {
+  return Task(
+    id: t.id,
+    title: f['title'] as String? ?? t.title,
+    description:
+        f.containsKey('body') ? f['body'] as String? : t.description,
+    status: f.containsKey('status')
+        ? TaskStatusExtension.fromString(f['status'] as String?)
+        : t.status,
+    priority: f.containsKey('priority')
+        ? TaskPriorityExtension.fromString(f['priority'] as String?)
+        : t.priority,
+    dueDate: f.containsKey('due_date')
+        ? (f['due_date'] is String
+            ? DateTime.tryParse(f['due_date'] as String)
+            : null)
+        : t.dueDate,
+    projectId: f.containsKey('project_id')
+        ? f['project_id'] as int?
+        : t.projectId,
+    milestoneId: f.containsKey('milestone_id')
+        ? f['milestone_id'] as int?
+        : t.milestoneId,
+    parentId:
+        f.containsKey('parent_id') ? f['parent_id'] as int? : t.parentId,
+    createdAt: t.createdAt,
+    updatedAt: t.updatedAt,
+  );
+}