@mentra/engine 0.1.0-dev.0 → 0.1.0-dev.1

package/build/services/asg/gallerySyncService.js

@@ -22,10 +22,13 @@ import { permissions, PermissionFeatures } from "../../facades/permissions";
 import { asgCameraApi } from "./asgCameraApi";
 import { gallerySettingsService } from "./gallerySettingsService";
 import { gallerySyncNotifications } from "./gallerySyncNotifications";
+import { localNetworkTransport } from "./localNetworkTransport";
 import { localStorageService } from "./localStorageService";
 import { mediaProcessingQueue } from "./mediaProcessingQueue";
 import { validateCaptureMetadataForDownload } from "./galleryMediaValidation";
 import { emitGalleryNotice } from "./galleryNotices";
+import { galleryTransferLedger } from "./galleryTransferLedger";
+import { cameraRollExportCoordinator } from "./cameraRollExportCoordinator";
 // Timing constants
 const TIMING = {
     HOTSPOT_CONNECT_DELAY_MS: 3000, // Increased from 1000ms - hotspot needs time to broadcast and become discoverable
@@ -87,6 +90,7 @@ class GallerySyncService {
         this.appStateSubscription = AppState.addEventListener("change", this.handleAppStateChange);
         this.hotspotListenerRegistered = true;
         this.isInitialized = true;
+        void cameraRollExportCoordinator.initialize();
         // console.log("[GallerySyncService] Initialized")
         // Check for resumable sync on startup
         this.checkForResumableSync();
@@ -95,6 +99,7 @@ class GallerySyncService {
      * Cleanup - remove event listeners
      */
     cleanup() {
+        void localNetworkTransport.disconnect();
         if (this.hotspotListenerRegistered) {
             GlobalEventEmitter.removeListener("hotspot_status_change", this.handleHotspotStatusChange);
             GlobalEventEmitter.removeListener("hotspot_error", this.handleHotspotError);
@@ -109,6 +114,7 @@ class GallerySyncService {
             this.appStateSubscription.remove();
             this.appStateSubscription = null;
         }
+        cameraRollExportCoordinator.cleanup();
         if (this.hotspotConnectionTimeout) {
             BgTimer.clearTimeout(this.hotspotConnectionTimeout);
             this.hotspotConnectionTimeout = null;
@@ -118,6 +124,10 @@ class GallerySyncService {
             this.hotspotRequestTimeout = null;
         }
         this.syncStartPromise = null;
+        useGallerySyncStore.getState().setSyncStarting(false);
+        this.waitingForWifiRetry = false;
+        this.wifiSettingsOpenedAt = null;
+        this.startAborted = false;
         this.isInitialized = false;
         console.log("[GallerySyncService] Cleaned up");
     }
@@ -153,6 +163,7 @@ class GallerySyncService {
             this.hotspotRequestTimeout = null;
         }
         gallerySyncNotifications.showSyncError("Glasses disconnected");
+        void localNetworkTransport.disconnect();
     };
     /**
      * Handle app state changes to auto-retry sync when user returns from settings
@@ -162,6 +173,8 @@ class GallerySyncService {
         if (nextAppState !== "active") {
             return;
         }
+        // Camera-roll backfill is phone-local and must resume independently of glasses/WiFi.
+        void cameraRollExportCoordinator.resume("app foreground");
         // Only auto-retry if we were waiting for WiFi
         if (!this.waitingForWifiRetry) {
             return;
@@ -174,41 +187,46 @@ class GallerySyncService {
         if (!glassesConnected) {
             console.log("[GallerySyncService] Glasses disconnected - not retrying sync");
             this.waitingForWifiRetry = false;
+            this.wifiSettingsOpenedAt = null;
             return;
         }
+        // The user has returned from the WiFi settings prompt, so the previous
+        // "Sync failed" state is no longer actionable. Make the button available
+        // immediately while the native WiFi state catches up; a successful check
+        // below will start the sync automatically.
+        if (store.syncState === "error" && store.lastError?.startsWith("WiFi disabled")) {
+            store.setSyncState("idle");
+        }
         // Check if WiFi is now enabled (Android only)
         // Use retry logic because WiFi status takes time to propagate after user enables it
         if (Platform.OS === "android") {
             const MAX_RETRIES = 5;
-            const RETRY_DELAY_MS = 1000; // Wait 500ms between checks
+            const RETRY_DELAY_MS = 1000;
             console.log("[GallerySyncService] Waiting for WiFi to initialize (may take a moment after enabling)...");
             for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                 try {
                     await new Promise((resolve) => BgTimer.setTimeout(() => resolve(), RETRY_DELAY_MS));
-                    const netState = await NetInfo.fetch();
-                    console.log(`[GallerySyncService] WiFi check attempt ${attempt}/${MAX_RETRIES}: enabled=${netState.isWifiEnabled}`);
-                    if (netState.isWifiEnabled === true) {
+                    // NetInfo can remain stale after Android's WiFi settings close. Use
+                    // the same native source as the normal sync preflight.
+                    const wifiEnabled = await WifiManager.isEnabled();
+                    console.log(`[GallerySyncService] WiFi check attempt ${attempt}/${MAX_RETRIES}: enabled=${wifiEnabled}`);
+                    if (wifiEnabled) {
                         console.log("[GallerySyncService] ✅ WiFi is now enabled - auto-retrying sync");
                         this.waitingForWifiRetry = false;
                         this.wifiSettingsOpenedAt = null; // Clear cooldown timestamp
-                        // Clear previous error state
-                        store.setSyncState("idle");
                         // Auto-retry sync
                         await this.startSync();
                         return;
                     }
-                    // If this was the last attempt, log and give up
-                    if (attempt === MAX_RETRIES) {
-                        console.log("[GallerySyncService] ❌ WiFi still disabled after all retries - user may need to tap sync manually");
-                        this.waitingForWifiRetry = false;
-                        this.wifiSettingsOpenedAt = null; // Clear cooldown timestamp
-                    }
                 }
                 catch (error) {
                     console.warn(`[GallerySyncService] Failed to check WiFi status on attempt ${attempt}:`, error);
                     // Continue to next retry
                 }
             }
+            console.log("[GallerySyncService] WiFi not detected after retries - leaving sync available for manual retry");
+            this.waitingForWifiRetry = false;
+            this.wifiSettingsOpenedAt = null;
         }
     };
     /**
@@ -294,8 +312,10 @@ class GallerySyncService {
             console.log("[GallerySyncService] ⚠️ Sync start already in progress, joining existing attempt");
             return this.syncStartPromise;
         }
+        useGallerySyncStore.getState().setSyncStarting(true);
         this.syncStartPromise = this.runStartSync().finally(() => {
             this.syncStartPromise = null;
+            useGallerySyncStore.getState().setSyncStarting(false);
         });
         return this.syncStartPromise;
     }
@@ -401,8 +421,6 @@ class GallerySyncService {
             connected: glassesConnected,
             hotspotEnabled: glassesHotspot !== null,
         });
-        // Reset processing queue only after pre-flight passes — avoids clobbering an active session
-        mediaProcessingQueue.reset();
         // Request all permissions upfront so user isn't interrupted during WiFi/download
         console.log("[GallerySyncService] 🔐 Step 1/6: Requesting permissions...");
         // 1. Notification permission (for background sync progress)
@@ -434,6 +452,22 @@ class GallerySyncService {
             console.log("[GallerySyncService] Pre-flight aborted after location permission");
             return;
         }
+        if (Platform.OS === "android") {
+            console.log("[GallerySyncService]   📡 Checking local WiFi permission...");
+            const hasLocalWifiPermission = await permissions.check(PermissionFeatures.LOCAL_WIFI);
+            if (!hasLocalWifiPermission) {
+                const granted = await permissions.request(PermissionFeatures.LOCAL_WIFI);
+                if (!granted) {
+                    store.setSyncError("Local WiFi permission is required for gallery sync");
+                    await gallerySyncNotifications.showSyncError("Allow WiFi access to connect to your glasses");
+                    return;
+                }
+            }
+            if (this.shouldAbortPreFlight()) {
+                console.log("[GallerySyncService] Pre-flight aborted after local WiFi permission");
+                return;
+            }
+        }
         // 3. Camera roll permission (if auto-save is enabled)
         const shouldAutoSave = await gallerySettingsService.getAutoSaveToCameraRoll();
         console.log(`[GallerySyncService]   📸 Auto-save to camera roll: ${shouldAutoSave}`);
@@ -444,9 +478,10 @@ class GallerySyncService {
                 console.log("[GallerySyncService]   ⚠️ Camera roll permission not granted - requesting...");
                 const granted = await MediaLibraryPermissions.requestPermission();
                 if (!granted) {
-                    console.warn("[GallerySyncService]   ❌ Camera roll permission denied - photos will still sync to app");
-                    // Don't block sync - photos will still be downloaded to app storage
-                    // They just won't be saved to the camera roll
+                    console.warn("[GallerySyncService]   ❌ Camera roll permission denied - auto-save sync cannot continue");
+                    store.setSyncError("Camera-roll permission required while automatic saving is enabled");
+                    emitGalleryNotice({ code: "camera_roll_permission_required" });
+                    return;
                 }
                 else {
                     console.log("[GallerySyncService]   ✅ Camera roll permission granted");
@@ -635,12 +670,21 @@ class GallerySyncService {
             console.log("[GallerySyncService]   ℹ️ Glasses hotspot not currently enabled");
             console.log("[GallerySyncService]   ➡️ Will request hotspot activation");
         }
+        // Every fallible pre-flight gate has passed. It is now safe to replace the previous
+        // in-memory queue; startFileDownload immediately recovers its durable ledger work.
+        mediaProcessingQueue.reset();
         if (isAlreadyConnected && currentGlassesHotspot) {
-            console.log("[GallerySyncService] 🚀 Skipping hotspot request - already connected!");
             const hotspotInfo = currentGlassesHotspot;
             store.setHotspotInfo(hotspotInfo);
             store.setSyncState("connecting_wifi");
-            await this.startFileDownload(hotspotInfo);
+            if (localNetworkTransport.supportsScopedConnection() && !localNetworkTransport.isScopedConnectionActive()) {
+                console.log("[GallerySyncService] 📡 System SSID matches; establishing scoped glasses transport");
+                await this.connectToHotspotWifi(hotspotInfo);
+            }
+            else {
+                console.log("[GallerySyncService] 🚀 Skipping hotspot request - already connected!");
+                await this.startFileDownload(hotspotInfo);
+            }
             return;
         }
         // Request hotspot
@@ -773,7 +817,7 @@ class GallerySyncService {
                         preConnectSSID = await WifiManager.getCurrentWifiSSID();
                         console.log(`[GallerySyncService] 📡 Current WiFi SSID: "${preConnectSSID}"`);
                         // Check if already connected (shouldn't happen, but good to verify)
-                        if (preConnectSSID === hotspotInfo.ssid) {
+                        if (!localNetworkTransport.supportsScopedConnection() && preConnectSSID === hotspotInfo.ssid) {
                             console.log("[GallerySyncService] ✅ Already connected to target SSID! Proceeding to download.");
                             appStateSubscription.remove();
                             const totalWifiDuration = Date.now() - wifiConnectStartTime;
@@ -790,8 +834,7 @@ class GallerySyncService {
                         console.warn(`[GallerySyncService] ⚠️ Could not get current SSID: ${preError?.message}`);
                         console.warn("[GallerySyncService] ⚠️ Error code:", preError?.code);
                     }
-                    // Use connectToProtectedSSID with joinOnce=false for persistent connection
-                    console.log(`[GallerySyncService] 🔌 Calling WifiManager.connectToProtectedSSID...`);
+                    console.log(`[GallerySyncService] 🔌 Connecting the glasses-local transport...`);
                     console.log(`[GallerySyncService] 🔌 Parameters:`);
                     console.log(`[GallerySyncService]    - SSID: "${hotspotInfo.ssid}"`);
                     console.log(`[GallerySyncService]    - Password: ${"*".repeat(hotspotInfo.password.length)}`);
@@ -800,9 +843,9 @@ class GallerySyncService {
                     const connectCallStartTime = Date.now();
                     appBackgrounded = false; // Reset flag for this attempt
                     appBackgroundTime = null;
-                    await WifiManager.connectToProtectedSSID(hotspotInfo.ssid, hotspotInfo.password, false, false);
+                    await localNetworkTransport.connect(hotspotInfo.ssid, hotspotInfo.password);
                     const connectCallDuration = Date.now() - connectCallStartTime;
-                    console.log(`[GallerySyncService] ✅ WifiManager.connectToProtectedSSID returned successfully`);
+                    console.log(`[GallerySyncService] ✅ Glasses-local transport connected successfully`);
                     console.log(`[GallerySyncService] ⏱️ Library call duration: ${connectCallDuration}ms`);
                     console.log(`[GallerySyncService] 📱 App was backgrounded during call: ${appBackgrounded}`);
                     if (appBackgrounded && appBackgroundTime) {
@@ -860,7 +903,9 @@ class GallerySyncService {
                     console.log("[GallerySyncService] 👂 App state listener removed");
                     // Final verification: Check SSID one more time before starting download
                     try {
-                        const finalSSID = await WifiManager.getCurrentWifiSSID();
+                        const finalSSID = localNetworkTransport.isScopedConnectionActive()
+                            ? hotspotInfo.ssid
+                            : await WifiManager.getCurrentWifiSSID();
                         console.log(`[GallerySyncService] 📶 Final SSID check before download: "${finalSSID}"`);
                         if (Platform.OS === "android") {
                             // Some local builds can have stale generated typings for the Bluetooth SDK module.
@@ -891,7 +936,7 @@ class GallerySyncService {
                                 const probeController = new AbortController();
                                 const probeTimeout = BgTimer.setTimeout(() => probeController.abort(), 1000); // 1 second timeout per probe
                                 const probeStartTime = Date.now();
-                                const probeResponse = await fetch(`http://${hotspotInfo.ip}:8089/api/health`, {
+                                const probeResponse = await localNetworkTransport.fetch(`http://${hotspotInfo.ip}:8089/api/health`, {
                                     method: "GET",
                                     signal: probeController.signal,
                                 });
@@ -1064,13 +1109,40 @@ class GallerySyncService {
             }
         }
         finally {
+            // Release the scoped Android Network on every terminal path. This is idempotent with
+            // closeHotspot(), and intentionally leaves Android 9/iOS legacy routing unchanged.
+            await localNetworkTransport.disconnect();
             // L2: Guarantee listener cleanup on all exit paths (cancel, success, error, exhaustion)
             appStateSubscription.remove();
         }
     }
     async fetchSyncManifest(clientId, lastSyncTime) {
-        const syncResponse = await asgCameraApi.syncWithServer(clientId, lastSyncTime, true);
-        return (syncResponse.data || syncResponse);
+        const v3 = typeof asgCameraApi.getV3Manifest === "function" ? await asgCameraApi.getV3Manifest() : null;
+        if (v3) {
+            const downloadedFiles = await localStorageService.getDownloadedFiles();
+            await localStorageService.reconcileRemoteCaptures(v3.captures.map((capture) => capture.capture_id), downloadedFiles);
+            return {
+                api_version: 3,
+                client_id: clientId,
+                // The ledger is a crash-recovery journal, not proof that app-private media survived an
+                // Android restore or reinstall. Suppress a remote capture only when both records agree.
+                captures: v3.captures.filter((capture) => !downloadedFiles[capture.capture_id] || !galleryTransferLedger.isLocallyCommitted(capture.capture_id)),
+                changed_files: [],
+                deleted_files: [],
+                server_time: v3.server_time,
+                total_changed: v3.captures.length,
+                total_size: v3.captures.reduce((total, capture) => total + capture.total_size, 0),
+            };
+        }
+        // Old firmware remains on the exact v2 endpoint/schema. Avoid expensive inline thumbnails;
+        // video thumbnails are fetched as small side downloads with their primary media.
+        const syncResponse = await asgCameraApi.syncWithServer(clientId, lastSyncTime, false);
+        const data = (syncResponse.data || syncResponse);
+        if (data.captures) {
+            data.captures = data.captures.filter((capture) => !galleryTransferLedger.isLocallyCommitted(capture.capture_id));
+        }
+        data.changed_files = (data.changed_files || []).filter((file) => !galleryTransferLedger.isFileLocallyCommitted(file.name));
+        return data;
     }
     /**
      * Resolve sync manifest: detect skew, optionally fix clock, retry full sync when needed.
@@ -1125,6 +1197,10 @@ class GallerySyncService {
             // Set up the API client
             asgCameraApi.setServer(hotspotInfo.ip, 8089);
             console.log("[GallerySyncService]   ✅ API client configured");
+            const recovery = await mediaProcessingQueue.retryPending();
+            if (recovery.retried > 0 || recovery.failed > 0) {
+                console.log(`[GallerySyncService]   ♻️ Recovery: ${recovery.retried} completed, ${recovery.failed} still pending`);
+            }
             // Get sync state and files to download
             // IMPORTANT: This creates a SNAPSHOT of files at this moment based on last_sync_time.
             // Any photos taken AFTER this call (during the sync) will NOT be included in this sync.
@@ -1159,16 +1235,21 @@ class GallerySyncService {
             console.log(`[GallerySyncService]      - Captures: ${syncData.captures?.length || 0}`);
             if (isSyncManifestEmpty(syncData)) {
                 console.log("[GallerySyncService]   ✅ No new files to sync - already up to date!");
-                store.setSyncComplete();
+                if (galleryTransferLedger.hasPendingRecovery()) {
+                    store.setSyncError("Gallery export or acknowledgement needs retry");
+                }
+                else {
+                    store.setSyncComplete();
+                }
                 await this.onSyncComplete(0, 0);
                 return;
             }
             // Detect API version and route to appropriate download path
-            const useCaptures = syncData.api_version === 2 && syncData.captures && syncData.captures.length > 0;
+            const useCaptures = (syncData.api_version || 0) >= 2 && syncData.captures && syncData.captures.length > 0;
             if (useCaptures) {
                 // New capture-aware sync path
                 const captures = syncData.captures;
-                console.log(`[GallerySyncService]   📊 Found ${captures.length} captures to download (api_version=2)`);
+                console.log(`[GallerySyncService]   📊 Found ${captures.length} captures to download (api_version=${syncData.api_version})`);
                 captures.slice(0, 5).forEach((c, idx) => {
                     console.log(`[GallerySyncService]      ${idx + 1}. ${c.capture_id} (${c.type}, ${c.files.length} files, ${(c.total_size / 1024).toFixed(1)} KB)`);
                 });
@@ -1260,7 +1341,7 @@ class GallerySyncService {
             const downloadResult = await asgCameraApi.batchSyncFiles(files, true, (current, total, fileName, fileProgress, downloadedFile) => {
                 // CRITICAL: This callback MUST NOT throw!
                 // RNFS progress callbacks run inside native bridge — throwing here causes
-                // EXC_BAD_ACCESS. Cancellation is handled via AbortSignal → RNFS.stopDownload.
+                // EXC_BAD_ACCESS. Cancellation is handled via AbortSignal → the active transport.
                 // Check if cancelled — just return, abort signal will stop the download
                 if (this.abortController?.signal.aborted) {
                     return;
@@ -1345,6 +1426,7 @@ class GallerySyncService {
                                 shouldAutoSave: !!shouldAutoSave,
                                 thumbnailPath: downloadedFile.thumbnailPath,
                                 deleteFromGlasses: [downloadedFile.name],
+                                protocolVersion: 1,
                             });
                         }
                     }
@@ -1375,18 +1457,6 @@ class GallerySyncService {
                     currentStore.onFileComplete(lastFileName);
                 }
             }
-            // Save downloaded files metadata (skip auxiliary files from gallery entries)
-            for (const photoInfo of downloadResult.downloaded) {
-                // Skip HDR brackets and IMU sidecars — they shouldn't appear as separate gallery items
-                const isAuxiliary = photoInfo.name?.match(/_ev-?\d+\.(jpg|jpeg)$/i) ||
-                    photoInfo.name?.match(/\.imu\.json$/i) ||
-                    photoInfo.name?.match(/\/ev-?\d+\.jpe?g$/i) ||
-                    photoInfo.name?.match(/\/imu\.json$/i);
-                if (isAuxiliary)
-                    continue;
-                const downloadedFile = localStorageService.convertToDownloadedFile(photoInfo, photoInfo.filePath || "", photoInfo.thumbnailPath, defaultWearable);
-                await localStorageService.saveDownloadedFile(downloadedFile);
-            }
             // Update queue index to final position
             await localStorageService.updateSyncQueueIndex(files.length);
             // Mark failed files in store
@@ -1398,6 +1468,16 @@ class GallerySyncService {
             console.log("[GallerySyncService]   ⏳ Waiting for processing queue to drain...");
             await mediaProcessingQueue.waitUntilDrained();
             console.log("[GallerySyncService]   ✅ Processing queue drained");
+            // Download success is not destination success. Export, validation, metadata, and
+            // acknowledgement failures are reported asynchronously by the processing queue; fold them
+            // back into the legacy result so its timestamp watermark cannot skip the source forever.
+            const processingFailures = new Set(useGallerySyncStore.getState().failedFiles);
+            for (const file of files) {
+                if (processingFailures.has(file.name) && !downloadResult.failed.includes(file.name)) {
+                    downloadResult.failed.push(file.name);
+                }
+            }
+            failedCount = downloadResult.failed.length;
             // Update sync state — only advance watermark if files were downloaded.
             // If any failed, set it before the oldest failure so they get retried.
             let syncWatermark = serverTime;
@@ -1453,8 +1533,12 @@ class GallerySyncService {
             console.log(`[GallerySyncService]      - Total data (lifetime): ${((currentSyncState.total_size + downloadResult.total_size) /
                 1024 /
                 1024).toFixed(2)} MB`);
-            // Complete
-            store.setSyncComplete();
+            if (failedCount > 0 || galleryTransferLedger.hasPendingRecovery()) {
+                store.setSyncError(`${failedCount || "Some"} gallery items need retry`);
+            }
+            else {
+                store.setSyncComplete();
+            }
             await this.onSyncComplete(downloadedCount, failedCount);
         }
         catch (error) {
@@ -1539,6 +1623,7 @@ class GallerySyncService {
                         bracketPaths: result.bracketPaths,
                         sidecarPath: result.sidecarPath,
                         thumbnailData: capture.thumbnail_data,
+                        thumbnailPath: result.thumbnailPath,
                         captureDir: result.captureDir,
                         timestamp: capture.timestamp,
                         totalSize: capture.total_size,
@@ -1547,6 +1632,7 @@ class GallerySyncService {
                         shouldProcess: !!shouldProcessImages,
                         shouldAutoSave: !!shouldAutoSave,
                         deleteFromGlasses: [capture.capture_id],
+                        protocolVersion: capture.files.some((file) => !!file.etag) ? 3 : 2,
                     });
                 }
                 catch (captureError) {
@@ -1631,7 +1717,12 @@ class GallerySyncService {
                     total_size: currentSyncState.total_size + totalSizeDownloaded,
                 });
             }
-            store.setSyncComplete();
+            if (failedCount > 0 || galleryTransferLedger.hasPendingRecovery()) {
+                store.setSyncError(`${failedCount || "Some"} gallery items need retry`);
+            }
+            else {
+                store.setSyncComplete();
+            }
             await this.onSyncComplete(downloadedCount, failedCount);
         }
         catch (error) {
@@ -1689,12 +1780,24 @@ class GallerySyncService {
         // } catch (error) {
         //   console.error(`[GallerySyncService] Failed to get post-sync inventory:`, error)
         // }
-        // Clear the queue
-        console.log("[GallerySyncService]   🧹 Clearing sync queue...");
-        await localStorageService.clearSyncQueue();
-        // Show completion notification
-        console.log("[GallerySyncService]   📱 Showing completion notification...");
-        await gallerySyncNotifications.showSyncComplete(downloadedCount, failedCount);
+        const hasPendingRecovery = galleryTransferLedger.hasPendingRecovery();
+        if (!hasPendingRecovery && failedCount === 0) {
+            console.log("[GallerySyncService]   🧹 Clearing completed sync queue...");
+            await localStorageService.clearSyncQueue();
+        }
+        else {
+            console.log("[GallerySyncService]   ♻️ Keeping recovery state for unfinished export/ack work");
+        }
+        if (hasPendingRecovery || failedCount > 0) {
+            console.log("[GallerySyncService]   📱 Showing retry-required notification...");
+            await gallerySyncNotifications.showSyncError(failedCount > 0
+                ? `${failedCount} gallery item${failedCount === 1 ? "" : "s"} will be retried`
+                : "Gallery export or acknowledgement will be retried");
+        }
+        else {
+            console.log("[GallerySyncService]   📱 Showing completion notification...");
+            await gallerySyncNotifications.showSyncComplete(downloadedCount, 0);
+        }
         // Close hotspot if we opened it
         const store = useGallerySyncStore.getState();
         if (store.syncServiceOpenedHotspot) {
@@ -1707,8 +1810,10 @@ class GallerySyncService {
         // Clear glasses gallery count immediately after successful sync
         // This ensures UI shows 0 items remaining right away
         // The subsequent query will update this if new photos were taken during sync
-        console.log("[GallerySyncService]   🔄 Clearing glasses gallery count (synced all items)");
-        store.clearGlassesGalleryStatus();
+        if (!hasPendingRecovery && failedCount === 0) {
+            console.log("[GallerySyncService]   🔄 Clearing glasses gallery count (synced all items)");
+            store.clearGlassesGalleryStatus();
+        }
         // Auto-reset to idle after 4 seconds to clear "Sync complete!" message,
         // then query glasses for any new content taken during the sync.
         // The query MUST happen after the reset — otherwise setGlassesGalleryStatus
@@ -1764,6 +1869,7 @@ class GallerySyncService {
         const store = useGallerySyncStore.getState();
         try {
             console.log("[GallerySyncService] Closing hotspot...");
+            await localNetworkTransport.disconnect();
             await BluetoothSdk.setHotspotState(false);
             store.setSyncServiceOpenedHotspot(false);
             store.setHotspotInfo(null);
@@ -1824,7 +1930,7 @@ class GallerySyncService {
     }
     /** True while pre-flight startSync work is in flight (before sync state transitions). */
     isSyncStarting() {
-        return this.syncStartPromise !== null;
+        return useGallerySyncStore.getState().syncStarting;
     }
     /**
      * Check if sync is currently in progress (hotspot/WiFi/download phases).