Bugfix: startup panic, blocking_lock in async ctx

- `live_event_task` used `tokio::sync::Mutex` but `blocking_lock()` was called from a tokio worker thread (via `tauri::async_runtime::spawn`), which panics
- Switched to `std::sync::Mutex` — the lock is only held briefly to store/take a `JoinHandle`, never across an await point, so an async mutex was unnecessary
- Fixed two unrelated eslint errors in `ScanStatusOverlay` and `AiSection`

Author: vdavid

AGENTS.md

@@ -147,6 +147,7 @@ There are two MCP servers available to you:
 ## Things to avoid
 
 - ❌ Don't touch git, user handles commits manually. Unless explicitly asked to.
+- ❌ NEVER use `git stash`, `git checkout`, `git reset`, or any write operation on git. Multiple agents may be working on the codebase simultaneously — stashing or checking out will silently destroy another agent's uncommitted work. To test whether a failure is pre-existing, use `isolation: "worktree"` via the Agent tool, or simply check `git log` / `git blame`.
 - ❌ Don't add JSDoc that just repeats types or obvious function names
 - ❌ Don't ignore linter warnings (fix them or justify with a comment)
 - ❌ Don't add dependencies without checking license compatibility (`cargo deny check`)

apps/desktop/src-tauri/src/ai/manager.rs

@@ -464,7 +464,12 @@ fn macos_memory_info() -> SystemMemoryInfo {
     // Free = everything not wired or app (includes file cache, inactive, purgeable, speculative)
     let free_bytes = total_bytes.saturating_sub(wired_bytes + app_bytes);
 
-    SystemMemoryInfo { total_bytes, wired_bytes, app_bytes, free_bytes }
+    SystemMemoryInfo {
+        total_bytes,
+        wired_bytes,
+        app_bytes,
+        free_bytes,
+    }
 }
 
 /// Stores provider + context size + OpenAI config in manager state.

apps/desktop/src-tauri/src/indexing/mod.rs

@@ -336,7 +336,7 @@ pub struct IndexManager {
     drive_watcher: Option<DriveWatcher>,
     /// Live event processing task (runs after reconciliation completes).
     /// Shared with spawned async tasks so they can store the handle.
-    live_event_task: Arc<tokio::sync::Mutex<Option<tauri::async_runtime::JoinHandle<()>>>>,
+    live_event_task: Arc<std::sync::Mutex<Option<tauri::async_runtime::JoinHandle<()>>>>,
     /// Tauri app handle for emitting events
     app: AppHandle,
     /// Whether a full scan is currently running. Shared with the completion handler.
@@ -381,7 +381,7 @@ impl IndexManager {
             micro_scans,
             scan_handle: None,
             drive_watcher: None,
-            live_event_task: Arc::new(tokio::sync::Mutex::new(None)),
+            live_event_task: Arc::new(std::sync::Mutex::new(None)),
             app,
             scanning: Arc::new(AtomicBool::new(false)),
         })
@@ -531,7 +531,7 @@ impl IndexManager {
             }
         });
         {
-            let mut guard = live_event_task_slot.blocking_lock();
+            let mut guard = live_event_task_slot.lock().unwrap();
             *guard = Some(handle);
         }
 
@@ -553,7 +553,7 @@ impl IndexManager {
                     }
                     mgr.drive_watcher = None;
                     {
-                        let mut task_guard = mgr.live_event_task.blocking_lock();
+                        let mut task_guard = mgr.live_event_task.lock().unwrap();
                         if let Some(task) = task_guard.take() {
                             task.abort();
                         }
@@ -793,8 +793,10 @@ impl IndexManager {
                     });
 
                     // Store the handle so shutdown() can wait for it to drain
-                    let mut guard = live_event_task_slot.lock().await;
-                    *guard = Some(handle);
+                    {
+                        let mut guard = live_event_task_slot.lock().unwrap();
+                        *guard = Some(handle);
+                    }
 
                     // Store scan metadata via writer
                     let now = std::time::SystemTime::now()
@@ -850,7 +852,7 @@ impl IndexManager {
 
         // Abort the live event processing task
         {
-            let mut guard = self.live_event_task.blocking_lock();
+            let mut guard = self.live_event_task.lock().unwrap();
             if let Some(task) = guard.take() {
                 task.abort();
             }
@@ -1006,19 +1008,18 @@ impl IndexManager {
         // 3. Wait for the event loop to drain (process final batch + UpdateLastEventId).
         //    Use block_in_place so we can .await the join handle without blocking the
         //    tokio runtime thread pool.
-        let live_event_task = Arc::clone(&self.live_event_task);
-        tokio::task::block_in_place(|| {
-            tauri::async_runtime::block_on(async {
-                let mut guard = live_event_task.lock().await;
-                if let Some(task) = guard.take() {
+        let task = self.live_event_task.lock().unwrap().take();
+        if let Some(task) = task {
+            tokio::task::block_in_place(|| {
+                tauri::async_runtime::block_on(async {
                     match tokio::time::timeout(Duration::from_secs(5), task).await {
                         Ok(Ok(())) => log::debug!("Live event loop drained successfully"),
                         Ok(Err(e)) => log::debug!("Live event loop task error: {e}"),
                         Err(_) => log::warn!("Live event loop drain timed out after 5s"),
                     }
-                }
+                });
             });
-        });
+        }
 
         // 4. Now shut down the writer (all final writes have been queued)
         self.writer.shutdown();

apps/desktop/src/lib/indexing/ScanStatusOverlay.svelte

@@ -47,8 +47,8 @@
         if (rate <= 0) return ''
         const remaining = (aggTotal - aggCurrent) / rate
         if (remaining < 2) return 'Almost done'
-        if (remaining < 60) return `${Math.round(remaining)}s left`
-        return `${Math.round(remaining / 60)}m left`
+        if (remaining < 60) return `${String(Math.round(remaining))}s left`
+        return `${String(Math.round(remaining / 60))}m left`
     })
 
     const showProgressBar = $derived(