Fix tasks disappearing on Dashboard click (empty API guard) (#5815)

## Summary
- **Root cause**: Rust backend's `get_action_items` Firestore query
silently swallowed errors (`break` instead of `return Err`), returning
`Ok(vec![])`. The handler's HTTP 500 fix (commit 35a8d4d) was bypassed
because it only caught `Err` results.
- When user clicked Dashboard, `refreshTasksIfNeeded()` and
`reconcileWithAPIIfNeeded()` ran reconciliation against the empty
response, hard-deleting all synced tasks from SQLite.
- Same `break` pattern existed in `get_memories_filtered`.

## Changes
1. **Rust backend** (`firestore.rs`): Changed `break` to `return
Err(...)` on Firestore query failures in `get_action_items` and
`get_memories_filtered`, so errors propagate to handlers and result in
HTTP 500
2. **Swift** (`TasksStore.swift`): Added `!response.items.isEmpty` guard
to `refreshTasksIfNeeded()` and `allApiIds.isEmpty` guard to
`reconcileWithAPIIfNeeded()` — matches existing guard in
`forceReconcileOnLoad()`
3. **Swift** (`ActionItemStorage.swift`): Added empty-set guards to
`hardDeleteAbsentTasks()` and `markAbsentTasksAsStaged()` as last line
of defense

## Test plan
- [x] Swift app builds clean
- [x] Rust backend compiles clean
- [x] Verified affected user (Salman, UID
`6HbrDL1WZ4PYqwa6O7N4uWT0nPj1`) has 17 incomplete tasks in Firestore and
macOS FCM token
- [ ] After release, verify Salman's tasks persist across Dashboard
navigation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: kodjima33

desktop/Backend-Rust/src/services/firestore.rs

@@ -1072,8 +1072,8 @@ impl FirestoreService {
 
             if !response.status().is_success() {
                 let error_text = response.text().await?;
-                tracing::error!("Firestore query error: {}", error_text);
-                break;
+                tracing::error!("Firestore query error for memories: {}", error_text);
+                return Err(format!("Firestore query error: {}", error_text).into());
             }
 
             let results: Vec<Value> = response.json().await?;
@@ -1997,8 +1997,8 @@ impl FirestoreService {
 
             if !response.status().is_success() {
                 let error_text = response.text().await?;
-                tracing::error!("Firestore query error: {}", error_text);
-                break;
+                tracing::error!("Firestore query error for action_items: {}", error_text);
+                return Err(format!("Firestore query error: {}", error_text).into());
             }
 
             let results: Vec<Value> = response.json().await?;

desktop/CHANGELOG.json

@@ -2,7 +2,8 @@
   "unreleased": [
     "Reduced auth error log spam with exponential backoff across all polling operations",
     "Fixed Tasks page showing misleading \"No Matching Tasks\" when user has no tasks",
-    "API keys are now served securely from the backend instead of bundled in the app"
+    "API keys are now served securely from the backend instead of bundled in the app",
+    "Fixed tasks disappearing when switching to Dashboard (missing safety guard on empty API responses)"
   ],
   "releases": [
     {

desktop/Desktop/Sources/Rewind/Core/ActionItemStorage.swift

@@ -610,6 +610,12 @@ actor ActionItemStorage {
     /// This cleans up tasks that were moved to staged_tasks or deleted on the backend
     /// but still linger in local SQLite, preventing phantom entries in the task list.
     func markAbsentTasksAsStaged(apiIds: Set<String>) async throws {
+        // Safety guard: never wipe all tasks if the API set is empty (backend error)
+        guard !apiIds.isEmpty else {
+            log("ActionItemStorage: markAbsentTasksAsStaged skipped — empty API set")
+            return
+        }
+
         let db = try await ensureInitialized()
 
         let deleted = try await db.write { database -> Int in
@@ -640,6 +646,12 @@ actor ActionItemStorage {
     /// deleting locally-created tasks that haven't been pushed yet.
     /// Returns the number of records deleted.
     func hardDeleteAbsentTasks(apiIds: Set<String>) async throws -> Int {
+        // Safety guard: never wipe all tasks if the API set is empty (backend error)
+        guard !apiIds.isEmpty else {
+            log("ActionItemStorage: hardDeleteAbsentTasks skipped — empty API set")
+            return 0
+        }
+
         let db = try await ensureInitialized()
 
         let deleted = try await db.write { database -> Int in

desktop/Desktop/Sources/Stores/TasksStore.swift

@@ -203,7 +203,8 @@ class TasksStore: ObservableObject {
 
             // Reconcile: if we got the full set, hard-delete local tasks absent from API
             // (completed/deleted on mobile). Safe: only deletes synced records.
-            if response.items.count < reloadLimit {
+            // Safety guard: skip if API returned zero tasks (possible backend error / empty 200).
+            if response.items.count < reloadLimit, !response.items.isEmpty {
                 let apiIds = Set(response.items.map { $0.id })
                 let reconciled = try await ActionItemStorage.shared.hardDeleteAbsentTasks(apiIds: apiIds)
                 if reconciled > 0 {
@@ -341,6 +342,12 @@ class TasksStore: ObservableObject {
                 if response.items.count < batchSize { break }
             }
 
+            // Safety guard: skip if API returned zero tasks (possible backend error / empty 200).
+            if allApiIds.isEmpty {
+                log("TasksStore: Periodic reconciliation skipped — API returned zero task IDs (possible backend error)")
+                return
+            }
+
             let deleted = try await ActionItemStorage.shared.hardDeleteAbsentTasks(apiIds: allApiIds)
             lastReconciliationDate = Date()