fix(ui,tauri): prevent navigation from killing in-progress tasks, add deep scan coordination

The root bug: useStartupRecovery used useRef(false) as a run-once guard,
but navigating to /settings unmounts AppShell. Navigating back remounts a
fresh instance, resetting the ref — so recoverStaleTasks() ran again and
reset the legitimately in-progress task to "failed". Combined with a
missing "failed" case in TaskRow's icon switch, both the spinner and
state icon disappeared completely.

Navigation fix:
- Replace useRef guards in useStartupRecovery and useStartupScan with
  module-level flags that survive unmount/remount cycles
- Add "failed" state to TaskRow (red AlertCircle icon + [Failed] prefix)

Deep scan / concurrency fixes:
- Add deep_scanning_repos set to EngineState for scan-task coordination
- engine_start_task waits for active deep scan before starting work,
  preventing concurrent Claude CLI instances in the same repo
- engine_scan_now marks/unmarks repos in deep_scanning_repos
- Add busy_timeout(10s) to Rust SQLite connections to avoid SQLITE_BUSY
- Add dbUpdateTaskWithRetry helper for resilient DB writes
- TaskStatusBanner shows amber "Waiting for scan" state
- useStartTask awaits DB write before long-running invoke
- useDeepScanListener re-invalidates active task query after list refetch

Author: Ghvstcode

README.md

@@ -58,7 +58,7 @@ If you'd prefer to build locally:
 **Prerequisites:** Node.js >= 22, Rust (stable), pnpm
 
 ```bash
-git clone https://github.com/user/sustn.git
+git clone https://github.com/ghvstcode/sustn.git
 cd sustn
 pnpm install
 pnpm tauri:dev

src-tauri/src/engine/db.rs

@@ -136,6 +136,9 @@ pub fn save_scanned_tasks(
     let conn = Connection::open(&db_path).map_err(|e| {
         format!("Failed to open database at {}: {e}", db_path.display())
     })?;
+    // Set busy timeout so concurrent writes (from Tauri SQL plugin) don't
+    // immediately fail with SQLITE_BUSY — wait up to 10s for the lock.
+    let _ = conn.busy_timeout(std::time::Duration::from_secs(10));
 
     // Load existing task titles for dedup (case-insensitive)
     let mut existing_titles: std::collections::HashSet<String> = std::collections::HashSet::new();

src-tauri/src/engine/mod.rs

@@ -7,6 +7,7 @@ pub mod scheduler;
 pub mod worker;
 
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
 use std::sync::Arc;
 use tokio::sync::{Mutex, RwLock};
 
@@ -18,6 +19,10 @@ pub struct EngineState {
     pub current_task: Mutex<Option<CurrentTask>>,
     /// Handle to cancel the scheduler loop.
     pub cancel_token: Mutex<Option<tokio::sync::watch::Sender<bool>>>,
+    /// Repository IDs that currently have a deep scan in progress.
+    /// Task execution waits for the scan to finish before starting,
+    /// preventing concurrent Claude CLI instances in the same repo.
+    pub deep_scanning_repos: Mutex<HashSet<String>>,
 }
 
 impl EngineState {
@@ -26,6 +31,7 @@ impl EngineState {
             running: RwLock::new(false),
             current_task: Mutex::new(None),
             cancel_token: Mutex::new(None),
+            deep_scanning_repos: Mutex::new(HashSet::new()),
         })
     }
 }

src-tauri/src/engine_commands.rs

@@ -70,9 +70,16 @@ pub async fn engine_scan_now(
             let repo_id_clone = repository_id.clone();
             let scan_prefs_clone = scan_prefs.clone();
 
+            // Access shared engine state to coordinate with task execution
+            let engine_state: tauri::State<'_, Arc<EngineState>> = app.state();
+            let engine_state_clone = Arc::clone(&engine_state);
+
             tokio::spawn(async move {
                 println!("[engine] deep scan starting for repository {repo_id_clone}");
 
+                // Mark this repo as deep-scanning so engine_start_task can wait
+                engine_state_clone.deep_scanning_repos.lock().await.insert(repo_id_clone.clone());
+
                 let _ = app_clone.emit("agent:scan-deep-started", serde_json::json!({
                     "repositoryId": repo_id_clone,
                 }));
@@ -94,6 +101,7 @@ pub async fn engine_scan_now(
                                 "repositoryId": repo_id_clone,
                                 "error": format!("Failed to get app data dir: {e}"),
                             }));
+                            engine_state_clone.deep_scanning_repos.lock().await.remove(&repo_id_clone);
                             return;
                         }
                     };
@@ -133,6 +141,10 @@ pub async fn engine_scan_now(
                         "taskIds": serde_json::Value::Array(vec![]),
                     }));
                 }
+
+                // Clear deep-scanning flag so waiting tasks can proceed
+                engine_state_clone.deep_scanning_repos.lock().await.remove(&repo_id_clone);
+                println!("[engine] deep scan flag cleared for repository {repo_id_clone}");
             });
         } else {
             println!("[engine] deep scan skipped — budget exhausted");
@@ -160,6 +172,31 @@ pub async fn engine_start_task(
 ) -> Result<worker::WorkResult, String> {
     println!("[engine_start_task] invoked — task_id={task_id}, repo_path={repo_path}, title={task_title}, base_branch={base_branch}, branch_name={branch_name}, has_user_messages={}, resume_session={:?}", user_messages.is_some(), resume_session_id);
 
+    // Wait for any active deep scan on this repo to finish.
+    // Running two Claude CLI instances in the same repo concurrently causes
+    // git conflicts and unpredictable behavior.
+    {
+        let mut waited = false;
+        loop {
+            let is_scanning = state.deep_scanning_repos.lock().await.contains(&repository_id);
+            if !is_scanning {
+                break;
+            }
+            if !waited {
+                println!("[engine_start_task] waiting for deep scan to finish on {repository_id}...");
+                let _ = app.emit("agent:task-waiting-for-scan", serde_json::json!({
+                    "taskId": task_id,
+                    "repositoryId": repository_id,
+                }));
+                waited = true;
+            }
+            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+        }
+        if waited {
+            println!("[engine_start_task] deep scan finished, proceeding with task {task_id}");
+        }
+    }
+
     // Check budget before starting work (respects per-project ceiling override)
     {
         let app_data_dir = app

src/core/api/useEngine.ts

@@ -362,6 +362,32 @@ function invalidateTaskQueries(
     });
 }
 
+/** Retry a DB write with a short delay. Prevents tasks getting permanently
+ *  stuck as in_progress when a transient SQLITE_BUSY error occurs. */
+async function dbUpdateTaskWithRetry(
+    taskId: string,
+    fields: Parameters<typeof dbUpdateTask>[1],
+    retries = 2,
+): Promise<void> {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            await dbUpdateTask(taskId, fields);
+            return;
+        } catch (e) {
+            console.error(
+                `[dbUpdateTaskWithRetry] attempt ${attempt + 1}/${retries + 1} failed:`,
+                e,
+            );
+            if (attempt < retries) {
+                await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+            }
+        }
+    }
+    console.error(
+        `[dbUpdateTaskWithRetry] all ${retries + 1} attempts failed for task ${taskId}`,
+    );
+}
+
 async function handleTaskResult(
     result: WorkResult,
     variables: TaskStartParams,
@@ -421,7 +447,7 @@ async function handleTaskResult(
                 }
             }
 
-            await dbUpdateTask(variables.taskId, {
+            await dbUpdateTaskWithRetry(variables.taskId, {
                 state: prUrl ? ("done" as const) : ("review" as const),
                 baseBranch: variables.baseBranch,
                 branchName: result.branchName,
@@ -448,7 +474,7 @@ async function handleTaskResult(
                 "[handleTaskResult] persisting failure — error:",
                 result.error,
             );
-            await dbUpdateTask(variables.taskId, {
+            await dbUpdateTaskWithRetry(variables.taskId, {
                 state: "failed" as const,
                 lastError: result.error ?? "Unknown error",
                 branchName: result.branchName,
@@ -495,14 +521,10 @@ async function handleTaskError(
         success: false,
     });
 
-    try {
-        await dbUpdateTask(variables.taskId, {
-            state: "failed" as const,
-            lastError: error instanceof Error ? error.message : String(error),
-        });
-    } catch (e) {
-        console.error("[handleTaskError] failed to persist error state:", e);
-    }
+    await dbUpdateTaskWithRetry(variables.taskId, {
+        state: "failed" as const,
+        lastError: error instanceof Error ? error.message : String(error),
+    });
 
     if (notify) {
         try {
@@ -898,17 +920,20 @@ export function useDiff(
 
 // ── Startup Recovery ────────────────────────────────────────
 
+// Module-level flag so it survives AppShell unmount/remount cycles
+// (e.g. navigating to /settings and back). Only resets on true app restart.
+let startupRecovered = false;
+
 /**
  * Recovers stale in_progress tasks on app startup.
  * Call once from the top-level app shell.
  */
 export function useStartupRecovery() {
     const queryClient = useQueryClient();
-    const recovered = useRef(false);
 
     useEffect(() => {
-        if (recovered.current) return;
-        recovered.current = true;
+        if (startupRecovered) return;
+        startupRecovered = true;
 
         void recoverStaleTasks().then((count) => {
             if (count > 0) {
@@ -926,18 +951,20 @@ export function useStartupRecovery() {
 
 // ── Startup Scan ────────────────────────────────────────────
 
+// Module-level flag — same rationale as startupRecovered above.
+let startupScanStarted = false;
+
 /**
  * Scans repositories that have never been scanned on app startup.
  * Runs once, staggering scans to avoid overloading the system.
  * Call once from the top-level app shell.
  */
 export function useStartupScan() {
     const queryClient = useQueryClient();
-    const started = useRef(false);
 
     useEffect(() => {
-        if (started.current) return;
-        started.current = true;
+        if (startupScanStarted) return;
+        startupScanStarted = true;
 
         void runStartupScans(queryClient);
     }, [queryClient]);

src/ui/components/tasks/TaskListView.tsx

@@ -372,7 +372,7 @@ export function TaskListView({ repositoryId }: TaskListViewProps) {
                     className="flex-1 overflow-y-auto"
                     onMouseLeave={() => setHoveredTaskId(null)}
                 >
-                    <div className="mx-auto w-full max-w-2xl px-6 pt-[28vh] pb-8">
+                    <div className="mx-auto w-full max-w-2xl px-6 pt-[5vh] pb-8">
                         <DndContext
                             sensors={sensors}
                             collisionDetection={closestCenter}

src/ui/components/tasks/TaskRow.tsx

@@ -8,6 +8,7 @@ import {
     Loader2,
     GitPullRequest,
     XCircle,
+    AlertCircle,
     Pencil,
     MessageSquare,
     Clock,
@@ -48,6 +49,7 @@ const categoryLabels: Record<string, string> = {
 const statePrefix: Record<string, string | undefined> = {
     pending: undefined,
     in_progress: "In-Progress",
+    failed: "Failed",
     review: "Awaiting Review",
     done: "Done",
     dismissed: "Dismissed",
@@ -156,6 +158,16 @@ export function TaskRow({
                         <Loader2 className="h-4 w-4 text-blue-500 animate-spin transition-colors group-hover/circle:text-green-500 group-hover/circle:animate-none" />
                     </button>
                 );
+            case "failed":
+                return (
+                    <button
+                        type="button"
+                        onClick={handleToggleDone}
+                        className="group/circle shrink-0"
+                    >
+                        <AlertCircle className="h-4 w-4 text-red-500 transition-colors group-hover/circle:text-green-500" />
+                    </button>
+                );
             case "review":
                 return (
                     <button

src/ui/components/tasks/TaskStatusBanner.tsx

@@ -1,4 +1,6 @@
+import { useState, useEffect } from "react";
 import { Loader2 } from "lucide-react";
+import { listen } from "@tauri-apps/api/event";
 import { useEngineStatus } from "@core/api/useEngine";
 
 interface TaskStatusBannerProps {
@@ -13,10 +15,54 @@ const phaseLabels: Record<string, string> = {
 
 export function TaskStatusBanner({ taskId }: TaskStatusBannerProps) {
     const { data: status } = useEngineStatus();
+    const [waitingForScan, setWaitingForScan] = useState(false);
+
+    // Listen for the waiting-for-scan event from the Rust backend.
+    // This fires when engine_start_task is blocked waiting for a deep scan
+    // to finish before it can start working on the task.
+    useEffect(() => {
+        const unlisten = listen<{ taskId: string; repositoryId: string }>(
+            "agent:task-waiting-for-scan",
+            (event) => {
+                if (event.payload.taskId === taskId) {
+                    setWaitingForScan(true);
+                }
+            },
+        );
+
+        return () => {
+            void unlisten.then((fn) => fn());
+        };
+    }, [taskId]);
 
     const isWorking = status?.currentTask?.taskId === taskId;
     const phase = status?.currentTask?.phase;
 
+    // Clear scan-waiting state once the engine picks up the task
+    useEffect(() => {
+        if (isWorking && waitingForScan) {
+            setWaitingForScan(false);
+        }
+    }, [isWorking, waitingForScan]);
+
+    if (waitingForScan && !isWorking) {
+        return (
+            <div className="flex items-center gap-2.5 rounded-lg border border-amber-500/20 bg-amber-500/5 px-4 py-3">
+                <Loader2 className="h-4 w-4 animate-spin text-amber-500" />
+                <div className="flex-1 min-w-0">
+                    <p className="text-sm font-medium text-foreground">
+                        Waiting for scan to finish
+                    </p>
+                    <p className="text-xs text-muted-foreground mt-0.5">
+                        A deep scan is still running on this repository. Work
+                        will start automatically once it completes.
+                    </p>
+                </div>
+                <div className="h-2 w-2 rounded-full bg-amber-500 animate-pulse" />
+            </div>
+        );
+    }
+
     if (!isWorking) return null;
 
     return (