feat(core,ui,tauri): parallel task execution with scan-aware concurrency

Enable multiple tasks to run simultaneously now that the worktree
migration makes each task filesystem-isolated. Default concurrency
is 5, configurable in Settings → General. Scans count against the
same pool so SUSTN never over-subscribes Claude CLI.

Backend (Rust):
- EngineState.running_tasks is now Mutex<HashMap<String, CurrentTask>>
  instead of Mutex<Option<CurrentTask>>, tracking multiple tasks by id
- New concurrency_limit (RwLock<usize>, default 5), tokens_reserved
  (Mutex<i64>), active_scans (Mutex<usize>) on EngineState
- engine_start_task and engine_address_review: capacity check sums
  running_tasks + active_scans; register/release on task boundaries;
  reserve/release estimated tokens via budget::estimated_task_tokens
- engine_scan_now: increments active_scans for pass 1 and spawned pass 2,
  releases on both success and error paths
- budget::calculate_budget_status_with_reservation subtracts reserved
  tokens so concurrent starts do not over-commit the daily budget
- New engine_set_concurrency_limit Tauri command (clamped 1..=10)
- EngineStatusResponse exposes running_tasks and concurrency_limit

Frontend:
- useQueueProcessor: removed single-task processingRef, now checks
  runningTasks.length + concurrencyLimit via engine_get_status before
  dequeuing. Chains processNext on task completion or enqueue
- useScheduler: skips tick when at concurrency capacity instead of when
  any task is running
- TaskDetailView: queues only when at capacity, starts immediately when
  a slot is available
- TaskStatusBanner: checks runningTasks.some(t => t.taskId === id)
  for per-task working state
- Deep scan listener invalidates every running task in the affected repo
- useStartupRecovery syncs persisted concurrencyLimit to the Rust state
  at boot so the setting survives restarts

Scan scope control:
- Migration 21: scan_enabled column on agent_config (default 1)
- AgentConfig.scanEnabled wired through DB layer and useUpdateAgentConfig
- Scheduler and startup scan skip repos with scanEnabled=false
- pr-import sets scanEnabled=false on imported repos; they never
  auto-scan again unless the user explicitly re-enables in project
  settings (new toggle in the Automation section)

PR lifecycle parallelism:
- prLifecycleTick now processes active PRs via Promise.allSettled
  instead of a sequential for-await loop, so multiple PRs can sync
  and address in parallel (bounded by backend concurrency limit)

Settings:
- GlobalSettings.concurrencyLimit (default 5), persisted in
  global_settings via migration 20
- General settings section: parallel-tasks selector (1-10)
- useUpdateGlobalSetting propagates the limit to the Rust state on
  change so it takes effect immediately without restart

Author: Ghvstcode

src-tauri/src/engine/budget.rs

@@ -149,13 +149,24 @@ pub fn get_weekly_usage() -> Result<(i64, String), String> {
 /// usage earlier in the week from falsely exhausting the budget for remaining days —
 /// the actual subscription resets on rolling windows, not as a rigid weekly lump sum.
 pub fn calculate_budget_status(config: &BudgetConfig) -> BudgetStatus {
+    calculate_budget_status_with_reservation(config, 0)
+}
+
+/// Calculate budget status accounting for tokens already reserved by
+/// in-flight tasks. Used to prevent over-commit when multiple tasks
+/// start concurrently.
+pub fn calculate_budget_status_with_reservation(
+    config: &BudgetConfig,
+    tokens_reserved: i64,
+) -> BudgetStatus {
     let (tokens_today, _) = get_today_usage().unwrap_or((0, "unavailable".to_string()));
     let (tokens_week, source) = get_weekly_usage().unwrap_or((0, "unavailable".to_string()));
 
     let daily_budget = config.weekly_token_budget / 7;
     let max_for_sustn = daily_budget * (config.max_usage_percent as i64) / 100;
     let reserve = daily_budget * (config.reserve_percent as i64) / 100;
-    let available = (max_for_sustn - tokens_today - reserve).max(0);
+    let available =
+        (max_for_sustn - tokens_today - reserve - tokens_reserved).max(0);
 
     BudgetStatus {
         weekly_token_budget: config.weekly_token_budget,

src-tauri/src/engine/mod.rs

@@ -8,32 +8,46 @@ pub mod worker;
 pub mod worktree;
 
 use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use tauri::Emitter;
 use tokio::sync::{Mutex, RwLock};
 
+/// Default number of tasks that can run concurrently.
+pub const DEFAULT_CONCURRENCY_LIMIT: usize = 5;
+
 /// Global engine state shared across Tauri commands and the background scheduler.
 pub struct EngineState {
     /// Whether the engine scheduler loop is running.
     pub running: RwLock<bool>,
-    /// The currently executing task (if any). Only one task runs at a time.
-    pub current_task: Mutex<Option<CurrentTask>>,
+    /// Currently executing tasks, keyed by task_id.
+    pub running_tasks: Mutex<HashMap<String, 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>>,
+    /// Maximum number of tasks that can run concurrently.
+    pub concurrency_limit: RwLock<usize>,
+    /// Total tokens reserved by in-flight tasks (prevents over-commit
+    /// when multiple tasks start near-simultaneously).
+    pub tokens_reserved: Mutex<i64>,
+    /// Number of scans currently running. Counted against the concurrency
+    /// limit so scans and tasks don't over-subscribe Claude CLI.
+    pub active_scans: Mutex<usize>,
 }
 
 impl EngineState {
     pub fn new() -> Arc<Self> {
         Arc::new(Self {
             running: RwLock::new(false),
-            current_task: Mutex::new(None),
+            running_tasks: Mutex::new(HashMap::new()),
             cancel_token: Mutex::new(None),
             deep_scanning_repos: Mutex::new(HashSet::new()),
+            concurrency_limit: RwLock::new(DEFAULT_CONCURRENCY_LIMIT),
+            tokens_reserved: Mutex::new(0),
+            active_scans: Mutex::new(0),
         })
     }
 }