diff --git a/README.md b/README.md
index 318ab10..0f9e0fc 100644
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@ v0.2.0 当前正式发布目标为 **macOS**，GitHub Release 同时生成：
 
 1. **启用数据源**：打开「设置 → 数据源」，确认本机已安装的 AI 工具与扫描目录。启动扫描只检测变化并写入本地 SQLite，不会调用模型。
 2. **同步会话**：点击顶栏「同步」，再从「进度中心」查看扫描、解析、写入进度和失败文件；取消会在当前文件处理完成后生效。
-3. **配置分析 Provider**：打开「设置 → AI 配置」，新增 API 或 CLI 配置并设为当前。API 支持刷新模型列表或手填完整模型 ID；CLI 的「检测命令」只检查可执行性，不调用模型。
+3. **配置分析 Provider**：打开「设置 → AI 配置」，新增 API 或 CLI 配置并设为当前，同时按本机和 Provider 承载能力设置 1–8 个全局并行分析。API 支持刷新模型列表或手填完整模型 ID；CLI 的「检测命令」只检查可执行性，不调用模型。
 4. **确认并开始分析**：在「对话档案」预览会话，选择单条或批量分析。运行期间不会自动跨 Provider 切换；失败后可为单项选择其他配置重试。
 5. **审核与复用知识**：在「知识笔记」中编辑类型、摘要、正文、主题标签和技术项。可全文搜索、合并标签、发布草稿，或将选中/全部知识导出为 Markdown。
 
diff --git a/apps/desktop/src-tauri/src/commands/config.rs b/apps/desktop/src-tauri/src/commands/config.rs
index a1c5393..a3f352f 100644
--- a/apps/desktop/src-tauri/src/commands/config.rs
+++ b/apps/desktop/src-tauri/src/commands/config.rs
@@ -21,6 +21,7 @@ pub struct AppConfigDto {
 #[serde(rename_all = "camelCase")]
 pub struct DistillerConfigDto {
     pub active_profile_id: String,
+    pub max_concurrent_analyses: usize,
     pub profiles: Vec<ProviderProfileDto>,
 }
 
@@ -64,6 +65,7 @@ impl From<&AppConfig> for AppConfigDto {
         Self {
             distiller: DistillerConfigDto {
                 active_profile_id: c.distiller.active_profile_id.clone(),
+                max_concurrent_analyses: c.distiller.max_concurrent_analyses,
                 profiles: c
                     .distiller
                     .profiles
@@ -128,6 +130,7 @@ impl From<AppConfigDto> for AppConfig {
         Self {
             distiller: DistillerConfig {
                 active_profile_id: dto.distiller.active_profile_id,
+                max_concurrent_analyses: dto.distiller.max_concurrent_analyses,
                 profiles: dto
                     .distiller
                     .profiles
@@ -198,6 +201,9 @@ pub async fn save_config(state: State<'_, AppState>, config: AppConfigDto) -> Re
     new_config
         .save(&AppConfig::default_path())
         .map_err(|e| format!("配置保存失败: {e}"))?;
+    state
+        .analysis_runtime
+        .set_limit(new_config.distiller.max_concurrent_analyses);
     *state
         .config
         .write()
diff --git a/apps/desktop/src-tauri/src/commands/jobs.rs b/apps/desktop/src-tauri/src/commands/jobs.rs
index debd9cb..b932ded 100644
--- a/apps/desktop/src-tauri/src/commands/jobs.rs
+++ b/apps/desktop/src-tauri/src/commands/jobs.rs
@@ -1,5 +1,5 @@
 use std::sync::Arc;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use tauri::{AppHandle, Emitter, State};
 
@@ -8,7 +8,7 @@ use crate::config::AppConfig;
 use crate::sidecar::SidecarManager;
 use crate::storage::models::{Job, NewJobItem};
 use crate::storage::Database;
-use crate::AppState;
+use crate::{AnalysisRuntime, AppState};
 
 fn emit_job(app: &AppHandle, db: &Database, job_id: &str) {
     if let Ok(job) = db.get_job_snapshot(job_id) {
@@ -21,163 +21,270 @@ fn spawn_job(
     db: Arc<Database>,
     config: AppConfig,
     sidecar: Option<Arc<SidecarManager>>,
-    job_lock: Arc<tokio::sync::Mutex<()>>,
+    job_lock: Arc<tokio::sync::RwLock<()>>,
+    analysis_runtime: Arc<AnalysisRuntime>,
     job_id: String,
 ) {
     tauri::async_runtime::spawn(async move {
-        let _guard = job_lock.lock().await;
         let Ok(job) = db.get_job(&job_id) else { return };
-        if job.cancel_requested {
-            let _ = db.cancel_queued_items(&job_id);
-            let _ = db.finish_job(&job_id, "cancelled", None);
-            emit_job(&app, &db, &job_id);
-            return;
-        }
-        let phase = if job.kind == "sync" {
-            "scanning"
+        if job.kind == "sync" {
+            let _guard = job_lock.write().await;
+            run_sync_job(app, db, config, job).await;
         } else {
-            "judging"
-        };
-        if db.mark_job_running(&job_id, phase).is_err() {
-            return;
+            let _guard = job_lock.read().await;
+            run_analysis_job(app, db, config, sidecar, analysis_runtime, job).await;
         }
+    });
+}
+
+async fn run_sync_job(app: AppHandle, db: Arc<Database>, config: AppConfig, job: Job) {
+    let job_id = job.id.clone();
+    if job.cancel_requested {
+        let _ = db.cancel_queued_items(&job_id);
+        let _ = db.finish_job(&job_id, "cancelled", None);
         emit_job(&app, &db, &job_id);
+        return;
+    }
+    if db.mark_job_running(&job_id, "scanning").is_err() {
+        return;
+    }
+    emit_job(&app, &db, &job_id);
 
-        // 一个分析任务只初始化一次供应商；任务内所有条目共享同一 Sidecar 与配置快照。
-        if job.kind == "analysis" {
-            let init_result = sidecar
-                .as_ref()
-                .ok_or_else(|| "Sidecar 未就绪".to_string())
-                .and_then(|sidecar| {
-                    let params = config.sidecar_init_params(job.provider_profile_id.as_deref())?;
-                    sidecar
-                        .call_with_timeout::<serde_json::Value>(
-                            "init",
-                            params,
-                            std::time::Duration::from_secs(30),
-                        )
-                        .map_err(|error| format!("Sidecar init 失败：{error}"))
+    let mut failed = false;
+    for item in job.items {
+        if db.job_cancel_requested(&job_id).unwrap_or(false) {
+            break;
+        }
+        if db.mark_item_running(&item.id, "scanning").is_err() {
+            failed = true;
+            continue;
+        }
+        emit_job(&app, &db, &job_id);
+        let started = Instant::now();
+        let source_id = item.source_id.clone().unwrap_or_default();
+        let progress_db = db.clone();
+        let progress_app = app.clone();
+        let progress_job_id = job_id.clone();
+        let progress_source_id = source_id.clone();
+        let worker_db = db.clone();
+        let worker_config = config.clone();
+        let result = tokio::task::spawn_blocking(move || {
+            let result = CollectorScheduler::new(&worker_config, &worker_db)
+                .collect_source_with_progress(&source_id, |raw_path, phase, error| {
+                    if let Ok(id) = progress_db.append_job_item(
+                        &progress_job_id,
+                        &NewJobItem {
+                            session_id: None,
+                            source_id: Some(&progress_source_id),
+                            raw_path: Some(raw_path),
+                        },
+                    ) {
+                        let status = if error.is_some() {
+                            "failed"
+                        } else {
+                            "succeeded"
+                        };
+                        let _ =
+                            progress_db.finish_item(&progress_job_id, &id, status, phase, 0, error);
+                        emit_job(&progress_app, &progress_db, &progress_job_id);
+                    }
                 });
-            if let Err(error) = init_result {
-                for item in &job.items {
-                    let _ = db.finish_item(&job_id, &item.id, "failed", "failed", 0, Some(&error));
-                }
-                let _ = db.finish_job(&job_id, "failed", Some(&error));
-                emit_job(&app, &db, &job_id);
-                return;
+            if result.failed > 0 {
+                Err(format!("{} 个文件同步失败", result.failed))
+            } else {
+                Ok(())
             }
-        }
+        })
+        .await
+        .map_err(|error| error.to_string())
+        .and_then(|value| value);
 
-        let mut failed = false;
-        for item in job.items {
-            if db.job_cancel_requested(&job_id).unwrap_or(false) {
-                break;
+        let duration = started.elapsed().as_millis().min(i64::MAX as u128) as i64;
+        let cancelled = db.job_cancel_requested(&job_id).unwrap_or(false);
+        match (result, cancelled) {
+            (_, true) => {
+                let _ = db.finish_item(
+                    &job_id,
+                    &item.id,
+                    "cancelled",
+                    "cancelled",
+                    duration,
+                    Some("用户取消"),
+                );
             }
-            let item_phase = if job.kind == "sync" {
-                "scanning"
-            } else {
-                "judging"
-            };
-            if db.mark_item_running(&item.id, item_phase).is_err() {
+            (Ok(()), false) => {
+                let _ = db.finish_item(&job_id, &item.id, "succeeded", "completed", duration, None);
+            }
+            (Err(error), false) => {
                 failed = true;
-                continue;
+                let _ = db.finish_item(
+                    &job_id,
+                    &item.id,
+                    "failed",
+                    "failed",
+                    duration,
+                    Some(&error),
+                );
             }
-            emit_job(&app, &db, &job_id);
-            let started = Instant::now();
+        }
+        emit_job(&app, &db, &job_id);
+    }
 
-            let result: Result<(), String> = if job.kind == "sync" {
-                let db = db.clone();
-                let config = config.clone();
-                let source_id = item.source_id.clone().unwrap_or_default();
-                let progress_db = db.clone();
-                let progress_app = app.clone();
-                let progress_job_id = job_id.clone();
-                let progress_source_id = source_id.clone();
-                tokio::task::spawn_blocking(move || {
-                    let result = CollectorScheduler::new(&config, &db)
-                        .collect_source_with_progress(&source_id, |raw_path, phase, error| {
-                            if let Ok(id) = progress_db.append_job_item(
-                                &progress_job_id,
-                                &NewJobItem {
-                                    session_id: None,
-                                    source_id: Some(&progress_source_id),
-                                    raw_path: Some(raw_path),
-                                },
-                            ) {
-                                let status = if error.is_some() {
-                                    "failed"
-                                } else {
-                                    "succeeded"
-                                };
-                                let _ = progress_db.finish_item(
-                                    &progress_job_id,
-                                    &id,
-                                    status,
-                                    phase,
-                                    0,
-                                    error,
-                                );
-                                emit_job(&progress_app, &progress_db, &progress_job_id);
-                            }
-                        });
-                    if result.failed > 0 {
-                        Err(format!("{} 个文件同步失败", result.failed))
-                    } else {
-                        Ok(())
-                    }
-                })
-                .await
-                .map_err(|error| error.to_string())
-                .and_then(|value| value)
-            } else {
-                let db = db.clone();
-                let config = config.clone();
-                let sidecar = sidecar.clone().ok_or_else(|| "Sidecar 未就绪".to_string());
-                let session_id = item
-                    .session_id
-                    .clone()
-                    .ok_or_else(|| "任务条目缺少会话".to_string());
-                let profile_id = job.provider_profile_id.clone();
-                match (sidecar, session_id) {
-                    (Ok(sidecar), Ok(session_id)) => {
-                        let phase_db = db.clone();
-                        let phase_app = app.clone();
-                        let phase_job_id = job_id.clone();
-                        let phase_item_id = item.id.clone();
-                        tokio::task::spawn_blocking(move || {
-                            let on_phase = |phase: &str| {
-                                let _ = phase_db.update_job_item_phase(
-                                    &phase_job_id,
-                                    &phase_item_id,
-                                    phase,
-                                );
-                                emit_job(&phase_app, &phase_db, &phase_job_id);
-                            };
-                            super::sessions::run_distill_pipeline(
-                                &db,
-                                &config,
-                                &sidecar,
-                                &session_id,
-                                &phase_job_id,
-                                profile_id.as_deref(),
-                                Some(&on_phase),
-                            )
-                            .map(|_| ())
-                        })
-                        .await
-                        .map_err(|error| error.to_string())
-                        .and_then(|value| value)
-                    }
-                    (Err(error), _) | (_, Err(error)) => Err(error),
+    finish_job(&app, &db, &job_id, failed);
+}
+
+async fn run_analysis_job(
+    app: AppHandle,
+    db: Arc<Database>,
+    config: AppConfig,
+    sidecar: Option<Arc<SidecarManager>>,
+    analysis_runtime: Arc<AnalysisRuntime>,
+    job: Job,
+) {
+    let job_id = job.id.clone();
+    if job.cancel_requested {
+        let _ = db.cancel_queued_items(&job_id);
+        let _ = db.finish_job(&job_id, "cancelled", None);
+        emit_job(&app, &db, &job_id);
+        return;
+    }
+    if db.mark_job_running(&job_id, "judging").is_err() {
+        return;
+    }
+    emit_job(&app, &db, &job_id);
+
+    let Some(base_sidecar) = sidecar else {
+        fail_all_analysis_items(&app, &db, &job, "Sidecar 未就绪");
+        return;
+    };
+    let init_params = match config.sidecar_init_params(job.provider_profile_id.as_deref()) {
+        Ok(params) => params,
+        Err(error) => {
+            fail_all_analysis_items(&app, &db, &job, &error);
+            return;
+        }
+    };
+
+    let mut tasks = tokio::task::JoinSet::new();
+    for item in job.items {
+        let task_app = app.clone();
+        let task_db = db.clone();
+        let task_config = config.clone();
+        let task_sidecar = base_sidecar.clone();
+        let task_init_params = init_params.clone();
+        let task_runtime = analysis_runtime.clone();
+        let task_job_id = job_id.clone();
+        let profile_id = job.provider_profile_id.clone();
+        tasks.spawn(async move {
+            let _permit = loop {
+                if task_db.job_cancel_requested(&task_job_id).unwrap_or(false) {
+                    return false;
+                }
+                if let Ok(permit) =
+                    tokio::time::timeout(Duration::from_millis(100), task_runtime.acquire()).await
+                {
+                    break permit;
+                }
+            };
+            if task_db.job_cancel_requested(&task_job_id).unwrap_or(false) {
+                return false;
+            }
+            if task_db.mark_item_running(&item.id, "judging").is_err() {
+                return true;
+            }
+            emit_job(&task_app, &task_db, &task_job_id);
+            let started = Instant::now();
+            let session_id = match item.session_id.clone() {
+                Some(session_id) => session_id,
+                None => {
+                    let _ = task_db.finish_item(
+                        &task_job_id,
+                        &item.id,
+                        "failed",
+                        "failed",
+                        0,
+                        Some("任务条目缺少会话"),
+                    );
+                    emit_job(&task_app, &task_db, &task_job_id);
+                    return true;
                 }
             };
+            let task_worker = Arc::new(task_sidecar.worker());
+            task_runtime.register_worker(&task_job_id, &item.id, task_worker.clone());
+            if task_db.job_cancel_requested(&task_job_id).unwrap_or(false) {
+                let _ = task_worker.cancel();
+                let _ = task_db.finish_item(
+                    &task_job_id,
+                    &item.id,
+                    "cancelled",
+                    "cancelled",
+                    started.elapsed().as_millis().min(i64::MAX as u128) as i64,
+                    Some("用户取消"),
+                );
+                task_runtime.unregister_worker(&task_job_id, &item.id);
+                emit_job(&task_app, &task_db, &task_job_id);
+                return false;
+            }
+            let init_worker = task_worker.clone();
+            let init_result = tokio::task::spawn_blocking(move || {
+                init_worker
+                    .call_with_timeout::<serde_json::Value>(
+                        "init",
+                        task_init_params,
+                        Duration::from_secs(30),
+                    )
+                    .map_err(|error| format!("Sidecar init 失败：{error}"))
+            })
+            .await
+            .map_err(|error| error.to_string())
+            .and_then(|value| value);
+            if let Err(error) = init_result {
+                let cancelled = task_db.job_cancel_requested(&task_job_id).unwrap_or(false);
+                let _ = task_db.finish_item(
+                    &task_job_id,
+                    &item.id,
+                    if cancelled { "cancelled" } else { "failed" },
+                    if cancelled { "cancelled" } else { "failed" },
+                    started.elapsed().as_millis().min(i64::MAX as u128) as i64,
+                    Some(if cancelled { "用户取消" } else { &error }),
+                );
+                task_runtime.unregister_worker(&task_job_id, &item.id);
+                emit_job(&task_app, &task_db, &task_job_id);
+                return !cancelled;
+            }
+            let phase_db = task_db.clone();
+            let phase_app = task_app.clone();
+            let phase_job_id = task_job_id.clone();
+            let phase_item_id = item.id.clone();
+            let pipeline_db = task_db.clone();
+            let pipeline_job_id = task_job_id.clone();
+            let result = tokio::task::spawn_blocking(move || {
+                let on_phase = |phase: &str| {
+                    let _ = phase_db.update_job_item_phase(&phase_job_id, &phase_item_id, phase);
+                    emit_job(&phase_app, &phase_db, &phase_job_id);
+                };
+                super::sessions::run_distill_pipeline(
+                    &pipeline_db,
+                    &task_config,
+                    &task_worker,
+                    &session_id,
+                    &pipeline_job_id,
+                    profile_id.as_deref(),
+                    Some(&on_phase),
+                )
+                .map(|_| ())
+            })
+            .await
+            .map_err(|error| error.to_string())
+            .and_then(|value| value);
 
             let duration = started.elapsed().as_millis().min(i64::MAX as u128) as i64;
-            let cancelled = db.job_cancel_requested(&job_id).unwrap_or(false);
+            let cancelled = task_db.job_cancel_requested(&task_job_id).unwrap_or(false);
+            let failed = result.is_err() && !cancelled;
             match (result, cancelled) {
                 (_, true) => {
-                    let _ = db.finish_item(
-                        &job_id,
+                    let _ = task_db.finish_item(
+                        &task_job_id,
                         &item.id,
                         "cancelled",
                         "cancelled",
@@ -186,13 +293,18 @@ fn spawn_job(
                     );
                 }
                 (Ok(()), false) => {
-                    let _ =
-                        db.finish_item(&job_id, &item.id, "succeeded", "completed", duration, None);
+                    let _ = task_db.finish_item(
+                        &task_job_id,
+                        &item.id,
+                        "succeeded",
+                        "completed",
+                        duration,
+                        None,
+                    );
                 }
                 (Err(error), false) => {
-                    failed = true;
-                    let _ = db.finish_item(
-                        &job_id,
+                    let _ = task_db.finish_item(
+                        &task_job_id,
                         &item.id,
                         "failed",
                         "failed",
@@ -201,19 +313,37 @@ fn spawn_job(
                     );
                 }
             }
-            emit_job(&app, &db, &job_id);
-        }
+            task_runtime.unregister_worker(&task_job_id, &item.id);
+            emit_job(&task_app, &task_db, &task_job_id);
+            failed
+        });
+    }
 
-        if db.job_cancel_requested(&job_id).unwrap_or(false) {
-            let _ = db.cancel_queued_items(&job_id);
-            let _ = db.finish_job(&job_id, "cancelled", None);
-        } else if failed {
-            let _ = db.finish_job(&job_id, "failed", Some("部分条目执行失败"));
-        } else {
-            let _ = db.finish_job(&job_id, "succeeded", None);
-        }
-        emit_job(&app, &db, &job_id);
-    });
+    let mut failed = false;
+    while let Some(result) = tasks.join_next().await {
+        failed |= result.unwrap_or(true);
+    }
+    finish_job(&app, &db, &job_id, failed);
+}
+
+fn fail_all_analysis_items(app: &AppHandle, db: &Database, job: &Job, error: &str) {
+    for item in &job.items {
+        let _ = db.finish_item(&job.id, &item.id, "failed", "failed", 0, Some(error));
+    }
+    let _ = db.finish_job(&job.id, "failed", Some(error));
+    emit_job(app, db, &job.id);
+}
+
+fn finish_job(app: &AppHandle, db: &Database, job_id: &str, failed: bool) {
+    if db.job_cancel_requested(job_id).unwrap_or(false) {
+        let _ = db.cancel_queued_items(job_id);
+        let _ = db.finish_job(job_id, "cancelled", None);
+    } else if failed {
+        let _ = db.finish_job(job_id, "failed", Some("部分条目执行失败"));
+    } else {
+        let _ = db.finish_job(job_id, "succeeded", None);
+    }
+    emit_job(app, db, job_id);
 }
 
 pub(crate) fn start_sync_internal(
@@ -221,7 +351,8 @@ pub(crate) fn start_sync_internal(
     db: Arc<Database>,
     config: AppConfig,
     sidecar: Option<Arc<SidecarManager>>,
-    job_lock: Arc<tokio::sync::Mutex<()>>,
+    job_lock: Arc<tokio::sync::RwLock<()>>,
+    analysis_runtime: Arc<AnalysisRuntime>,
     scope: Option<&str>,
 ) -> Result<Job, String> {
     let sources = config
@@ -243,7 +374,15 @@ pub(crate) fn start_sync_internal(
     let job = db
         .create_job("sync", "queued", None, &items)
         .map_err(|error| error.to_string())?;
-    spawn_job(app, db, config, sidecar, job_lock, job.id.clone());
+    spawn_job(
+        app,
+        db,
+        config,
+        sidecar,
+        job_lock,
+        analysis_runtime,
+        job.id.clone(),
+    );
     Ok(job)
 }
 
@@ -252,7 +391,8 @@ fn start_analysis_internal(
     db: Arc<Database>,
     config: AppConfig,
     sidecar: Option<Arc<SidecarManager>>,
-    job_lock: Arc<tokio::sync::Mutex<()>>,
+    job_lock: Arc<tokio::sync::RwLock<()>>,
+    analysis_runtime: Arc<AnalysisRuntime>,
     session_ids: &[String],
     provider_profile_id: Option<&str>,
 ) -> Result<Job, String> {
@@ -287,7 +427,15 @@ fn start_analysis_internal(
             &items,
         )
         .map_err(|error| error.to_string())?;
-    spawn_job(app, db, config, sidecar, job_lock, job.id.clone());
+    spawn_job(
+        app,
+        db,
+        config,
+        sidecar,
+        job_lock,
+        analysis_runtime,
+        job.id.clone(),
+    );
     Ok(job)
 }
 
@@ -303,6 +451,7 @@ pub async fn start_sync(
         state.config_snapshot(),
         state.sidecar.clone(),
         state.job_lock.clone(),
+        state.analysis_runtime.clone(),
         scope.as_deref(),
     )
 }
@@ -320,6 +469,7 @@ pub async fn start_analysis(
         state.config_snapshot(),
         state.sidecar.clone(),
         state.job_lock.clone(),
+        state.analysis_runtime.clone(),
         &session_ids,
         provider_profile_id.as_deref(),
     )
@@ -352,13 +502,12 @@ pub async fn cancel_job(
         .db
         .get_job(&job_id)
         .map_err(|error| error.to_string())?;
-    if job.kind == "analysis" && job.items.iter().any(|item| item.status == "running") {
-        if let Some(sidecar) = state.sidecar.clone() {
-            tokio::task::spawn_blocking(move || sidecar.stop())
-                .await
-                .map_err(|error| error.to_string())?
-                .map_err(|error| error.to_string())?;
-        }
+    if job.kind == "analysis" {
+        let runtime = state.analysis_runtime.clone();
+        let stopping_job_id = job_id.clone();
+        tokio::task::spawn_blocking(move || runtime.stop_job(&stopping_job_id))
+            .await
+            .map_err(|error| error.to_string())??;
     }
     emit_job(&app, &state.db, &job_id);
     state.db.get_job(&job_id).map_err(|error| error.to_string())
@@ -391,6 +540,7 @@ pub async fn retry_job_item(
             state.config_snapshot(),
             state.sidecar.clone(),
             state.job_lock.clone(),
+            state.analysis_runtime.clone(),
             item.source_id.as_deref(),
         )
     } else {
@@ -404,6 +554,7 @@ pub async fn retry_job_item(
             state.config_snapshot(),
             state.sidecar.clone(),
             state.job_lock.clone(),
+            state.analysis_runtime.clone(),
             &[session_id],
             profile_id,
         )
diff --git a/apps/desktop/src-tauri/src/config.rs b/apps/desktop/src-tauri/src/config.rs
index 7869cbd..2b0fb2d 100644
--- a/apps/desktop/src-tauri/src/config.rs
+++ b/apps/desktop/src-tauri/src/config.rs
@@ -35,6 +35,8 @@ pub struct SourceConfig {
 pub struct DistillerConfig {
     #[serde(default)]
     pub active_profile_id: String,
+    #[serde(default = "default_max_concurrent_analyses")]
+    pub max_concurrent_analyses: usize,
     #[serde(default)]
     pub profiles: Vec<ProviderProfile>,
     /// 仅用于把 v0.1 的单 API 配置迁移成 profile；落盘时移除。
@@ -56,6 +58,7 @@ impl Default for DistillerConfig {
     fn default() -> Self {
         Self {
             active_profile_id: "default".to_string(),
+            max_concurrent_analyses: default_max_concurrent_analyses(),
             profiles: vec![ProviderProfile {
                 id: "default".to_string(),
                 name: "OpenAI".to_string(),
@@ -112,6 +115,9 @@ fn default_true() -> bool {
 fn default_timeout() -> u64 {
     120
 }
+fn default_max_concurrent_analyses() -> usize {
+    2
+}
 fn default_provider_kind() -> String {
     "api".to_string()
 }
@@ -254,6 +260,7 @@ impl AppConfig {
             self.distiller = if let Some(api) = self.distiller.legacy_api.take() {
                 DistillerConfig {
                     active_profile_id: "migrated-api".to_string(),
+                    max_concurrent_analyses: default_max_concurrent_analyses(),
                     profiles: vec![ProviderProfile {
                         id: "migrated-api".to_string(),
                         name: "已迁移 API".to_string(),
@@ -286,6 +293,11 @@ impl AppConfig {
     }
 
     pub fn validate(&self) -> ConfigResult<()> {
+        if !(1..=8).contains(&self.distiller.max_concurrent_analyses) {
+            return Err(ConfigError::Invalid(
+                "并行分析数必须在 1–8 之间".to_string(),
+            ));
+        }
         if self.distiller.profiles.is_empty() {
             return Err(ConfigError::Invalid(
                 "至少需要一套分析 Provider 配置".to_string(),
@@ -466,6 +478,7 @@ mod tests {
         );
         assert_eq!(config.distiller.profiles.len(), 1);
         assert_eq!(config.distiller.active_profile_id, "default");
+        assert_eq!(config.distiller.max_concurrent_analyses, 2);
         assert!(config.sync.scan_on_startup);
     }
 
@@ -532,6 +545,15 @@ mod tests {
         assert!(config.validate().is_err());
     }
 
+    #[test]
+    fn rejects_analysis_concurrency_outside_safe_range() {
+        let mut config = AppConfig::default();
+        config.distiller.max_concurrent_analyses = 0;
+        assert!(config.validate().is_err());
+        config.distiller.max_concurrent_analyses = 9;
+        assert!(config.validate().is_err());
+    }
+
     #[test]
     fn migrates_v01_single_api() {
         let text = r#"
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index a7851fd..c9ee7b2 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -6,8 +6,11 @@ mod path_local;
 mod sidecar;
 mod storage;
 
-use std::sync::{Arc, RwLock};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
 use tauri::Manager;
+use tokio::sync::Notify;
 
 use config::AppConfig;
 use sidecar::SidecarManager;
@@ -24,7 +27,93 @@ pub struct AppState {
     pub db: Arc<Database>,
     pub config: Arc<RwLock<AppConfig>>,
     pub sidecar: Option<Arc<SidecarManager>>,
-    pub job_lock: Arc<tokio::sync::Mutex<()>>,
+    pub job_lock: Arc<tokio::sync::RwLock<()>>,
+    pub analysis_runtime: Arc<AnalysisRuntime>,
+}
+
+pub struct AnalysisRuntime {
+    limit: AtomicUsize,
+    active: Mutex<usize>,
+    notify: Notify,
+    workers: Mutex<HashMap<String, HashMap<String, Arc<SidecarManager>>>>,
+}
+
+pub struct AnalysisPermit {
+    runtime: Arc<AnalysisRuntime>,
+}
+
+impl AnalysisRuntime {
+    pub fn new(limit: usize) -> Self {
+        Self {
+            limit: AtomicUsize::new(limit),
+            active: Mutex::new(0),
+            notify: Notify::new(),
+            workers: Mutex::new(HashMap::new()),
+        }
+    }
+
+    pub fn set_limit(&self, limit: usize) {
+        self.limit.store(limit, Ordering::Release);
+        self.notify.notify_waiters();
+    }
+
+    pub async fn acquire(self: &Arc<Self>) -> AnalysisPermit {
+        loop {
+            let notified = self.notify.notified();
+            {
+                let mut active = self.active.lock().expect("analysis active lock poisoned");
+                if *active < self.limit.load(Ordering::Acquire) {
+                    *active += 1;
+                    return AnalysisPermit {
+                        runtime: self.clone(),
+                    };
+                }
+            }
+            notified.await;
+        }
+    }
+
+    pub fn register_worker(&self, job_id: &str, item_id: &str, worker: Arc<SidecarManager>) {
+        self.workers
+            .lock()
+            .expect("analysis workers lock poisoned")
+            .entry(job_id.to_string())
+            .or_default()
+            .insert(item_id.to_string(), worker);
+    }
+
+    pub fn unregister_worker(&self, job_id: &str, item_id: &str) {
+        let mut workers = self.workers.lock().expect("analysis workers lock poisoned");
+        if let Some(items) = workers.get_mut(job_id) {
+            items.remove(item_id);
+            if items.is_empty() {
+                workers.remove(job_id);
+            }
+        }
+    }
+
+    pub fn stop_job(&self, job_id: &str) -> Result<(), String> {
+        let workers = self
+            .workers
+            .lock()
+            .map_err(|_| "分析任务锁异常，请重启应用".to_string())?
+            .get(job_id)
+            .map(|items| items.values().cloned().collect::<Vec<_>>())
+            .unwrap_or_default();
+        for worker in workers {
+            worker.cancel().map_err(|error| error.to_string())?;
+        }
+        Ok(())
+    }
+}
+
+impl Drop for AnalysisPermit {
+    fn drop(&mut self) {
+        if let Ok(mut active) = self.runtime.active.lock() {
+            *active = active.saturating_sub(1);
+        }
+        self.runtime.notify.notify_one();
+    }
 }
 
 impl AppState {
@@ -73,11 +162,15 @@ pub fn run() {
         log::warn!("Sidecar 未就绪：提炼功能将不可用，直至构建或安装 chattake-sidecar");
     }
 
+    let analysis_runtime = Arc::new(AnalysisRuntime::new(
+        config.distiller.max_concurrent_analyses,
+    ));
     let state = AppState {
         db: Arc::new(db),
         config: Arc::new(RwLock::new(config)),
         sidecar,
-        job_lock: Arc::new(tokio::sync::Mutex::new(())),
+        job_lock: Arc::new(tokio::sync::RwLock::new(())),
+        analysis_runtime,
     };
 
     tauri::Builder::default()
@@ -94,6 +187,7 @@ pub fn run() {
                     state.config_snapshot(),
                     state.sidecar.clone(),
                     state.job_lock.clone(),
+                    state.analysis_runtime.clone(),
                     None,
                 ) {
                     log::error!("启动扫描任务创建失败: {}", error);
@@ -138,3 +232,26 @@ pub fn run() {
         .run(context)
         .expect("Tauri 应用启动失败");
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn analysis_runtime_applies_limit_updates() {
+        let runtime = Arc::new(AnalysisRuntime::new(1));
+        let first = runtime.acquire().await;
+        assert!(
+            tokio::time::timeout(std::time::Duration::from_millis(20), runtime.acquire())
+                .await
+                .is_err()
+        );
+
+        runtime.set_limit(2);
+        let second = tokio::time::timeout(std::time::Duration::from_millis(100), runtime.acquire())
+            .await
+            .expect("提高并发上限后应立即获得许可");
+
+        drop((first, second));
+    }
+}
diff --git a/apps/desktop/src-tauri/src/sidecar/mod.rs b/apps/desktop/src-tauri/src/sidecar/mod.rs
index a605d3f..b445460 100644
--- a/apps/desktop/src-tauri/src/sidecar/mod.rs
+++ b/apps/desktop/src-tauri/src/sidecar/mod.rs
@@ -16,7 +16,8 @@ pub mod rpc;
 
 use std::path::PathBuf;
 use std::process::{Child, Command, Stdio};
-use std::sync::Mutex;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
 
 use rpc::{RpcClient, RpcError};
 use serde::de::DeserializeOwned;
@@ -29,20 +30,37 @@ pub struct SidecarManager {
     /// 运行中的子进程
     process: Mutex<Option<Child>>,
     /// RPC 客户端（进程启动后创建）
-    client: Mutex<Option<RpcClient>>,
+    client: Mutex<Option<Arc<RpcClient>>>,
     /// sidecar 二进制路径
     binary_path: PathBuf,
+    /// 任务取消后禁止 RPC 自动重启该 worker。
+    cancelled: AtomicBool,
+    /// 独立分析 worker 退出后必须让当前条目失败，不能无 init 自动重启。
+    restartable: bool,
+    started: AtomicBool,
 }
 
 impl SidecarManager {
     pub fn new(binary_path: PathBuf) -> Self {
+        Self::with_restart(binary_path, true)
+    }
+
+    fn with_restart(binary_path: PathBuf, restartable: bool) -> Self {
         Self {
             process: Mutex::new(None),
             client: Mutex::new(None),
             binary_path,
+            cancelled: AtomicBool::new(false),
+            restartable,
+            started: AtomicBool::new(false),
         }
     }
 
+    /// 为一个分析条目创建独立进程管理器，隔离超时、取消与 Provider 状态。
+    pub fn worker(&self) -> Self {
+        Self::with_restart(self.binary_path.clone(), false)
+    }
+
     /// 查找 sidecar 二进制路径。
     ///
     /// `package_info` 来自 [`tauri::generate_context!`]，用于与 Tauri CLI 相同的 `resource_dir` 解析（跨平台）。
@@ -124,10 +142,16 @@ impl SidecarManager {
             .lock()
             .map_err(|_| RpcError::Internal("process lock poisoned".into()))?;
 
+        if self.cancelled.load(Ordering::Acquire) {
+            return Err(RpcError::Internal("Sidecar 任务已取消".into()));
+        }
         if proc_guard.is_some() {
             log::debug!("Sidecar 已在运行中");
             return Ok(());
         }
+        if self.started.load(Ordering::Acquire) && !self.restartable {
+            return Err(RpcError::Internal("Sidecar worker 已退出".into()));
+        }
 
         log::info!("启动 sidecar: {}", self.binary_path.display());
         let mut child = Command::new(&self.binary_path)
@@ -154,12 +178,19 @@ impl SidecarManager {
             .client
             .lock()
             .map_err(|_| RpcError::Internal("client lock poisoned".into()))?;
-        *client_guard = Some(rpc_client);
+        *client_guard = Some(Arc::new(rpc_client));
+        self.started.store(true, Ordering::Release);
 
         log::info!("Sidecar 启动成功");
         Ok(())
     }
 
+    /// 取消任务并永久停止当前 worker，避免并发竞态触发自动重启。
+    pub fn cancel(&self) -> Result<(), RpcError> {
+        self.cancelled.store(true, Ordering::Release);
+        self.stop()
+    }
+
     /// 停止 sidecar 进程
     pub fn stop(&self) -> Result<(), RpcError> {
         let mut proc_guard = self
@@ -246,13 +277,12 @@ impl SidecarManager {
             self.start()?;
         }
 
-        let client_guard = self
+        let client = self
             .client
             .lock()
-            .map_err(|_| RpcError::Internal("client lock poisoned".into()))?;
-
-        let client = client_guard
+            .map_err(|_| RpcError::Internal("client lock poisoned".into()))?
             .as_ref()
+            .cloned()
             .ok_or_else(|| RpcError::Internal("RPC 客户端未就绪".into()))?;
 
         client.call(method, params)
@@ -269,16 +299,14 @@ impl SidecarManager {
             self.start()?;
         }
 
-        let result = {
-            let client_guard = self
-                .client
-                .lock()
-                .map_err(|_| RpcError::Internal("client lock poisoned".into()))?;
-            let client = client_guard
-                .as_ref()
-                .ok_or_else(|| RpcError::Internal("RPC 客户端未就绪".into()))?;
-            client.call_with_timeout(method, params, timeout)
-        };
+        let client = self
+            .client
+            .lock()
+            .map_err(|_| RpcError::Internal("client lock poisoned".into()))?
+            .as_ref()
+            .cloned()
+            .ok_or_else(|| RpcError::Internal("RPC 客户端未就绪".into()))?;
+        let result = client.call_with_timeout(method, params, timeout);
         if matches!(result, Err(RpcError::Timeout(_))) {
             let _ = self.stop();
         }
@@ -291,3 +319,27 @@ impl Drop for SidecarManager {
         let _ = self.stop();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn cancelled_worker_cannot_restart() {
+        let worker = SidecarManager::new(PathBuf::from("missing-sidecar"));
+        worker.cancel().unwrap();
+        assert!(
+            matches!(worker.start(), Err(RpcError::Internal(message)) if message.contains("已取消"))
+        );
+    }
+
+    #[test]
+    fn analysis_worker_does_not_restart_without_init() {
+        let root = SidecarManager::new(PathBuf::from("missing-sidecar"));
+        let worker = root.worker();
+        worker.started.store(true, Ordering::Release);
+        assert!(
+            matches!(worker.start(), Err(RpcError::Internal(message)) if message.contains("已退出"))
+        );
+    }
+}
diff --git a/apps/desktop/src-tauri/src/sidecar/rpc.rs b/apps/desktop/src-tauri/src/sidecar/rpc.rs
index 4ce3bb4..75bdb81 100644
--- a/apps/desktop/src-tauri/src/sidecar/rpc.rs
+++ b/apps/desktop/src-tauri/src/sidecar/rpc.rs
@@ -5,23 +5,24 @@
 //!
 //! 注意：call() 是同步阻塞的，Tauri command 层需用 spawn_blocking 包装。
 
+use std::collections::HashMap;
 use std::io::{BufRead, BufReader, Write};
 use std::process::{ChildStdin, ChildStdout};
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::{mpsc, Mutex};
-use std::time::{Duration, Instant};
+use std::sync::{mpsc, Arc, Mutex};
+use std::time::Duration;
 
 use serde::de::DeserializeOwned;
 use serde_json::Value;
 
 /// 默认 RPC 调用超时（秒），LLM 提炼可能需要较长时间
 const DEFAULT_TIMEOUT_SECS: u64 = 120;
+type PendingResponses = Arc<Mutex<HashMap<u64, mpsc::Sender<Result<String, String>>>>>;
 
 /// JSON-RPC 2.0 客户端，持有 sidecar 进程的 stdin/stdout
 pub struct RpcClient {
-    calls: Mutex<()>,
     stdin: Mutex<ChildStdin>,
-    responses: Mutex<mpsc::Receiver<Result<String, String>>>,
+    pending: PendingResponses,
     request_id: AtomicU64,
     /// RPC 调用默认超时时间
     timeout: Duration,
@@ -29,32 +30,32 @@ pub struct RpcClient {
 
 impl RpcClient {
     pub fn new(stdin: ChildStdin, stdout: ChildStdout) -> Self {
-        let (tx, rx) = mpsc::channel();
+        let pending = PendingResponses::default();
+        let reader_pending = pending.clone();
         std::thread::spawn(move || {
             let mut reader = BufReader::new(stdout);
             loop {
                 let mut line = String::new();
                 match reader.read_line(&mut line) {
                     Ok(0) => {
-                        let _ = tx.send(Err("Sidecar stdout 已关闭".into()));
+                        fail_pending(&reader_pending, "Sidecar stdout 已关闭");
                         break;
                     }
                     Ok(_) => {
-                        if tx.send(Ok(line)).is_err() {
-                            break;
+                        if let Err(error) = dispatch_response(&reader_pending, line) {
+                            log::warn!("Sidecar 响应分发失败: {error}");
                         }
                     }
                     Err(error) => {
-                        let _ = tx.send(Err(error.to_string()));
+                        fail_pending(&reader_pending, &error.to_string());
                         break;
                     }
                 }
             }
         });
         Self {
-            calls: Mutex::new(()),
             stdin: Mutex::new(stdin),
-            responses: Mutex::new(rx),
+            pending,
             request_id: AtomicU64::new(1),
             timeout: Duration::from_secs(DEFAULT_TIMEOUT_SECS),
         }
@@ -80,11 +81,6 @@ impl RpcClient {
         params: Value,
         timeout: Duration,
     ) -> Result<T, RpcError> {
-        // Sidecar 允许并发处理请求，但桌面端当前不需要并发；整体串行可避免响应串线。
-        let _call_guard = self
-            .calls
-            .lock()
-            .map_err(|_| RpcError::Internal("call lock poisoned".into()))?;
         let id = self.request_id.fetch_add(1, Ordering::SeqCst);
 
         let request = serde_json::json!({
@@ -104,42 +100,44 @@ impl RpcClient {
             timeout.as_secs()
         );
 
+        let (response_tx, response_rx) = mpsc::channel();
+        self.pending
+            .lock()
+            .map_err(|_| RpcError::Internal("pending response lock poisoned".into()))?
+            .insert(id, response_tx);
+
         // 写 stdin
-        {
+        let write_result = (|| -> Result<(), RpcError> {
             let mut stdin = self
                 .stdin
                 .lock()
                 .map_err(|_| RpcError::Internal("stdin lock poisoned".into()))?;
             writeln!(stdin, "{}", request_str).map_err(|e| RpcError::Io(e.to_string()))?;
-            stdin.flush().map_err(|e| RpcError::Io(e.to_string()))?;
+            stdin.flush().map_err(|e| RpcError::Io(e.to_string()))
+        })();
+        if let Err(error) = write_result {
+            self.remove_pending(id);
+            return Err(error);
         }
 
-        // 超时请求的迟到响应可能仍在队列中；按 id 丢弃，直到拿到本次响应。
-        let deadline = Instant::now() + timeout;
-        let response = loop {
-            let remaining = deadline.saturating_duration_since(Instant::now());
-            if remaining.is_zero() {
+        let response_str = match response_rx.recv_timeout(timeout) {
+            Ok(Ok(line)) => line,
+            Ok(Err(error)) => return Err(RpcError::Io(error)),
+            Err(mpsc::RecvTimeoutError::Timeout) => {
+                self.remove_pending(id);
                 return Err(RpcError::Timeout(timeout.as_secs()));
             }
-            let response_str = self.read_response_with_timeout(remaining)?;
-            if response_str.trim().is_empty() {
-                return Err(RpcError::Io("Sidecar 返回空响应（进程可能已退出）".into()));
-            }
-            let response: Value = serde_json::from_str(response_str.trim()).map_err(|e| {
-                RpcError::Deserialize(format!(
-                    "响应解析失败: {} - {}",
-                    e,
-                    &response_str[..response_str.len().min(200)]
-                ))
-            })?;
-            if response.get("id").and_then(Value::as_u64) == Some(id) {
-                break response;
+            Err(mpsc::RecvTimeoutError::Disconnected) => {
+                return Err(RpcError::Io("读取线程异常退出".into()));
             }
-            log::warn!(
-                "丢弃非当前 RPC 响应: expected_id={id}, actual_id={:?}",
-                response.get("id")
-            );
         };
+        let response: Value = serde_json::from_str(response_str.trim()).map_err(|e| {
+            RpcError::Deserialize(format!(
+                "响应解析失败: {} - {}",
+                e,
+                &response_str[..response_str.len().min(200)]
+            ))
+        })?;
 
         // 检查 error 字段
         if let Some(err) = response.get("error") {
@@ -160,25 +158,64 @@ impl RpcClient {
             .map_err(|e| RpcError::Deserialize(format!("result 反序列化失败: {}", e)))
     }
 
-    /// 带超时的 stdout 读取。
-    ///
-    /// stdout 由常驻读取线程持有；当前线程只在 channel 上等待，因此超时会立即返回。
-    fn read_response_with_timeout(&self, timeout: Duration) -> Result<String, RpcError> {
-        let responses = self
-            .responses
-            .lock()
-            .map_err(|_| RpcError::Internal("response lock poisoned".into()))?;
-        match responses.recv_timeout(timeout) {
-            Ok(Ok(line)) => Ok(line),
-            Ok(Err(error)) => Err(RpcError::Io(error)),
-            Err(mpsc::RecvTimeoutError::Timeout) => Err(RpcError::Timeout(timeout.as_secs())),
-            Err(mpsc::RecvTimeoutError::Disconnected) => {
-                Err(RpcError::Io("读取线程异常退出".into()))
-            }
+    fn remove_pending(&self, id: u64) {
+        if let Ok(mut pending) = self.pending.lock() {
+            pending.remove(&id);
         }
     }
 }
 
+fn dispatch_response(pending: &PendingResponses, line: String) -> Result<(), String> {
+    let response: Value = serde_json::from_str(line.trim()).map_err(|error| error.to_string())?;
+    let id = response
+        .get("id")
+        .and_then(Value::as_u64)
+        .ok_or_else(|| "响应缺少数字 id".to_string())?;
+    let sender = pending
+        .lock()
+        .map_err(|_| "pending response lock poisoned".to_string())?
+        .remove(&id)
+        .ok_or_else(|| format!("响应 id={id} 已超时或不存在"))?;
+    sender
+        .send(Ok(line))
+        .map_err(|_| format!("响应 id={id} 的接收端已关闭"))
+}
+
+fn fail_pending(pending: &PendingResponses, error: &str) {
+    let senders = pending
+        .lock()
+        .map(|mut pending| {
+            pending
+                .drain()
+                .map(|(_, sender)| sender)
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    for sender in senders {
+        let _ = sender.send(Err(error.to_string()));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dispatches_out_of_order_responses_to_matching_calls() {
+        let pending = PendingResponses::default();
+        let (first_tx, first_rx) = mpsc::channel();
+        let (second_tx, second_rx) = mpsc::channel();
+        pending.lock().unwrap().insert(1, first_tx);
+        pending.lock().unwrap().insert(2, second_tx);
+
+        dispatch_response(&pending, r#"{"jsonrpc":"2.0","id":2,"result":"b"}"#.into()).unwrap();
+        dispatch_response(&pending, r#"{"jsonrpc":"2.0","id":1,"result":"a"}"#.into()).unwrap();
+
+        assert!(second_rx.recv().unwrap().unwrap().contains("\"b\""));
+        assert!(first_rx.recv().unwrap().unwrap().contains("\"a\""));
+    }
+}
+
 /// RPC 调用错误
 #[derive(Debug, thiserror::Error)]
 pub enum RpcError {
diff --git a/apps/desktop/src-tauri/src/storage/cards.rs b/apps/desktop/src-tauri/src/storage/cards.rs
index f383122..1584dda 100644
--- a/apps/desktop/src-tauri/src/storage/cards.rs
+++ b/apps/desktop/src-tauri/src/storage/cards.rs
@@ -685,6 +685,10 @@ mod tests {
                 tech_stack: &technologies,
             })
             .unwrap();
+        assert_eq!(
+            db.get_session(&session_id).unwrap().card_id,
+            Some(high_id.clone())
+        );
         let draft_id = db
             .insert_card(&NewCard {
                 session_id: &session_id,
diff --git a/apps/desktop/src-tauri/src/storage/jobs.rs b/apps/desktop/src-tauri/src/storage/jobs.rs
index feaa15c..b863295 100644
--- a/apps/desktop/src-tauri/src/storage/jobs.rs
+++ b/apps/desktop/src-tauri/src/storage/jobs.rs
@@ -1,5 +1,6 @@
 use chrono::Utc;
 use rusqlite::{params, OptionalExtension, Row};
+use std::collections::HashSet;
 use uuid::Uuid;
 
 use super::db::{Database, DbError, DbResult};
@@ -61,6 +62,29 @@ impl Database {
         let now = Utc::now().to_rfc3339();
         let mut conn = self.conn();
         let tx = conn.transaction()?;
+        if kind == "analysis" {
+            let mut seen = HashSet::new();
+            for session_id in items.iter().filter_map(|item| item.session_id) {
+                if !seen.insert(session_id) {
+                    return Err(DbError::Invalid(format!(
+                        "同一会话不能重复加入分析任务：{session_id}"
+                    )));
+                }
+                let active = tx
+                    .query_row(
+                        "SELECT 1 FROM job_items WHERE session_id=?1 AND status IN ('queued','running') LIMIT 1",
+                        params![session_id],
+                        |_| Ok(()),
+                    )
+                    .optional()?
+                    .is_some();
+                if active {
+                    return Err(DbError::Invalid(format!(
+                        "会话已在分析队列中：{session_id}"
+                    )));
+                }
+            }
+        }
         let (profile_id, provider, base_url, model) = profile
             .map(|value| (Some(value.0), Some(value.1), Some(value.2), Some(value.3)))
             .unwrap_or((None, None, None, None));
@@ -329,6 +353,100 @@ mod tests {
         assert!(!columns.iter().any(|column| column == "api_key"));
     }
 
+    #[test]
+    fn rejects_duplicate_active_analysis_sessions() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = Database::open(&dir.path().join("jobs.db")).unwrap();
+        let session = db
+            .insert_session(
+                "codex",
+                "duplicate",
+                "local",
+                None,
+                None,
+                0,
+                None,
+                "/tmp/x",
+                "2026-01-01T00:00:00Z",
+                "2026-01-01T00:00:00Z",
+                None,
+            )
+            .unwrap();
+        let items = [NewJobItem {
+            session_id: Some(&session),
+            source_id: None,
+            raw_path: None,
+        }];
+        let duplicate_items = [
+            NewJobItem {
+                session_id: Some(&session),
+                source_id: None,
+                raw_path: None,
+            },
+            NewJobItem {
+                session_id: Some(&session),
+                source_id: None,
+                raw_path: None,
+            },
+        ];
+        let error = db
+            .create_job("analysis", "queued", None, &duplicate_items)
+            .unwrap_err();
+        assert!(error.to_string().contains("重复加入"));
+
+        db.create_job("analysis", "queued", None, &items).unwrap();
+
+        let error = db
+            .create_job("analysis", "queued", None, &items)
+            .unwrap_err();
+        assert!(error.to_string().contains("已在分析队列中"));
+    }
+
+    #[test]
+    fn cancelling_running_item_releases_session_for_retry() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = Database::open(&dir.path().join("jobs.db")).unwrap();
+        let session = db
+            .insert_session(
+                "codex",
+                "cancelled",
+                "local",
+                None,
+                None,
+                0,
+                None,
+                "/tmp/x",
+                "2026-01-01T00:00:00Z",
+                "2026-01-01T00:00:00Z",
+                None,
+            )
+            .unwrap();
+        let items = [NewJobItem {
+            session_id: Some(&session),
+            source_id: None,
+            raw_path: None,
+        }];
+        let job = db.create_job("analysis", "queued", None, &items).unwrap();
+        db.mark_job_running(&job.id, "judging").unwrap();
+        db.mark_item_running(&job.items[0].id, "judging").unwrap();
+        db.request_job_cancel(&job.id).unwrap();
+        db.finish_item(
+            &job.id,
+            &job.items[0].id,
+            "cancelled",
+            "cancelled",
+            0,
+            Some("用户取消"),
+        )
+        .unwrap();
+        db.finish_job(&job.id, "cancelled", None).unwrap();
+
+        let cancelled = db.get_job(&job.id).unwrap();
+        assert_eq!(cancelled.done, cancelled.total);
+        assert_eq!(cancelled.items[0].status, "cancelled");
+        assert!(db.create_job("analysis", "queued", None, &items).is_ok());
+    }
+
     #[test]
     fn progress_snapshot_caps_file_items() {
         let dir = tempfile::tempdir().unwrap();
diff --git a/apps/desktop/src-tauri/src/storage/models.rs b/apps/desktop/src-tauri/src/storage/models.rs
index ee20a09..9d1369d 100644
--- a/apps/desktop/src-tauri/src/storage/models.rs
+++ b/apps/desktop/src-tauri/src/storage/models.rs
@@ -44,6 +44,9 @@ pub struct Session {
     pub analyzed_at: Option<String>,
     /// 分析失败时的错误信息
     pub error_message: Option<String>,
+    /// 当前会话最新生成的知识卡片
+    #[serde(default)]
+    pub card_id: Option<String>,
 }
 
 /// 会话列表轻量版（列表所需路径 / 首条 user 预览等；不含 content_hash）
diff --git a/apps/desktop/src-tauri/src/storage/sessions.rs b/apps/desktop/src-tauri/src/storage/sessions.rs
index ce1189d..cd4b73f 100644
--- a/apps/desktop/src-tauri/src/storage/sessions.rs
+++ b/apps/desktop/src-tauri/src/storage/sessions.rs
@@ -246,7 +246,9 @@ impl Database {
         conn.query_row(
             "SELECT id, source_id, external_session_id, source_host, project_path, project_name,
                     message_count, content_hash, raw_path, created_at, updated_at,
-                    status, value, has_updates, analyzed_at, error_message, analysis_title
+                    status, value, has_updates, analyzed_at, error_message, analysis_title,
+                    (SELECT c.id FROM cards c WHERE c.session_id = sessions.id
+                     ORDER BY c.created_at DESC, c.id DESC LIMIT 1)
              FROM sessions WHERE id = ?1",
             params![id],
             |row| {
@@ -268,6 +270,7 @@ impl Database {
                     analyzed_at: row.get(14)?,
                     error_message: row.get(15)?,
                     analysis_title: row.get(16)?,
+                    card_id: row.get(17)?,
                 })
             },
         )
diff --git a/apps/desktop/src/components/AnalysisQueuePanel.vue b/apps/desktop/src/components/AnalysisQueuePanel.vue
index 3455f05..b9aba02 100644
--- a/apps/desktop/src/components/AnalysisQueuePanel.vue
+++ b/apps/desktop/src/components/AnalysisQueuePanel.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue'
+import { computed, onMounted, ref } from 'vue'
 import { storeToRefs } from 'pinia'
 import { NButton, NDropdown, NEmpty, NModal, NProgress, NSpin, NTag } from 'naive-ui'
 import { useAnalysisQueueStore } from '../stores/analysisQueue'
@@ -7,9 +7,10 @@ import { api } from '../lib/tauri'
 import type { Job, JobItem } from '../types'
 
 const queue = useAnalysisQueueStore()
-const { jobs, clock, isIdle } = storeToRefs(queue)
+const { jobs, clock } = storeToRefs(queue)
 const show = defineModel<boolean>('show', { default: false })
 const providerOptions = ref<Array<{ label: string; key: string }>>([])
+const hasCompleted = computed(() => jobs.value.some((job) => isTerminal(job)))
 
 const statusLabel: Record<string, string> = {
   queued: '排队中', running: '执行中', succeeded: '已完成', failed: '失败',
@@ -25,6 +26,7 @@ const phaseLabel: Record<string, string> = {
 function progress(job: Job) { return job.total ? Math.round(job.done / job.total * 100) : 0 }
 function itemTitle(item: JobItem) { return item.sourceId || item.sessionId || item.rawPath || item.id }
 function canCancel(job: Job) { return job.status === 'queued' || job.status === 'running' }
+function isTerminal(job: Job) { return ['succeeded', 'failed', 'cancelled', 'interrupted'].includes(job.status) }
 function canRetry(item: JobItem) { return ['failed', 'cancelled', 'interrupted'].includes(item.status) }
 function visibleItems(job: Job) { return job.kind === 'sync' ? job.items.slice(-40) : job.items }
 function elapsed(job: Job) {
@@ -33,13 +35,18 @@ function elapsed(job: Job) {
   const seconds = Math.max(0, Math.floor((end - Date.parse(start)) / 1000))
   return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`
 }
-function currentItemTitle(job: Job) {
-  const item = job.items.find((candidate) => candidate.status === 'running')
-  return item ? itemTitle(item) : null
+function currentItemSummary(job: Job) {
+  const items = job.items.filter((candidate) => candidate.status === 'running')
+  if (!items.length) return null
+  if (items.length === 1) return `当前：${itemTitle(items[0])}`
+  return `正在并行处理 ${items.length} 项：${items.slice(0, 2).map(itemTitle).join('、')}${items.length > 2 ? '…' : ''}`
 }
-function clearAndClose() {
-  queue.clear()
-  show.value = false
+function jobPhase(job: Job) {
+  if (job.kind === 'analysis' && job.status === 'running') {
+    const running = job.items.filter((item) => item.status === 'running').length
+    return running === 0 ? '等待执行' : running === 1 ? '处理中' : '并行处理中'
+  }
+  return phaseLabel[job.phase] ?? job.phase
 }
 
 onMounted(async () => {
@@ -53,11 +60,13 @@ onMounted(async () => {
 
 <template>
   <n-modal v-model:show="show">
-    <section class="task-center" aria-live="polite" aria-label="进度中心">
+    <section class="task-center" role="dialog" aria-modal="true" aria-labelledby="progress-center-title">
       <header class="task-header">
-        <div class="flex items-center gap-2"><span class="i-lucide-activity w-4 h-4" /><strong>进度中心</strong></div>
+        <div class="flex items-center gap-2"><span class="i-lucide-activity w-4 h-4" /><strong id="progress-center-title">进度中心</strong></div>
         <div class="flex items-center gap-1">
-          <n-button v-if="isIdle" quaternary size="tiny" aria-label="清除已完成任务" @click="clearAndClose"><span class="i-lucide-trash-2 w-4 h-4" /></n-button>
+          <n-button v-if="hasCompleted" quaternary size="tiny" @click="queue.clear()">
+            <span class="inline-flex items-center gap-1"><span class="i-lucide-trash-2 w-3.5 h-3.5" />清除已完成</span>
+          </n-button>
           <n-button quaternary size="tiny" aria-label="关闭进度中心" @click="show = false"><span class="i-lucide-x w-4 h-4" /></n-button>
         </div>
       </header>
@@ -74,13 +83,16 @@ onMounted(async () => {
                 <n-tag size="tiny" :type="job.status === 'failed' ? 'error' : job.status === 'succeeded' ? 'success' : 'default'">{{ statusLabel[job.status] }}</n-tag>
               </div>
               <p class="job-meta">
-                {{ phaseLabel[job.phase] ?? job.phase }} · {{ job.done }}/{{ job.total }}
+                {{ jobPhase(job) }} · {{ job.done }}/{{ job.total }}
                 <template v-if="job.provider"> · {{ job.provider }} / {{ job.model }}</template>
                 · {{ elapsed(job) }}
               </p>
-              <p v-if="currentItemTitle(job)" class="job-current">当前：{{ currentItemTitle(job) }}</p>
+              <p v-if="currentItemSummary(job)" class="job-current">{{ currentItemSummary(job) }}</p>
+            </div>
+            <div class="job-actions">
+              <n-button v-if="canCancel(job)" size="tiny" secondary type="warning" @click="queue.cancel(job.id)">取消</n-button>
+              <n-button v-else-if="isTerminal(job)" size="tiny" quaternary @click="queue.clear(job.id)">清除</n-button>
             </div>
-            <n-button v-if="canCancel(job)" size="tiny" secondary type="warning" @click="queue.cancel(job.id)">取消</n-button>
           </div>
 
           <n-progress type="line" :percentage="progress(job)" :height="5" :show-indicator="false" class="mt-2" />
@@ -123,6 +135,7 @@ onMounted(async () => {
 .job-card:last-child { border-bottom:0; }
 .job-meta { margin-top: 4px; color: var(--muted); font-size: 11px; overflow-wrap: anywhere; }
 .job-current { margin-top:3px; overflow:hidden; color:var(--ink-soft); font-size:11px; text-overflow:ellipsis; white-space:nowrap; }
+.job-actions { display:flex; flex-shrink:0; align-items:center; gap:4px; }
 .item-list { margin-top: 9px; max-height: 230px; overflow-y: auto; }
 .item-row { display: flex; align-items: flex-start; gap: 7px; padding: 7px 0; font-size: 11px; border-top: 1px solid rgba(122,125,117,.12); }
 .item-error { margin-top: 2px; color: var(--vermilion); overflow-wrap: anywhere; }
diff --git a/apps/desktop/src/components/SettingsModal.vue b/apps/desktop/src/components/SettingsModal.vue
index 783bab1..64f810e 100644
--- a/apps/desktop/src/components/SettingsModal.vue
+++ b/apps/desktop/src/components/SettingsModal.vue
@@ -243,6 +243,19 @@ function close() { emit('update:show', false) }
             <n-alert type="info" :bordered="false" class="!text-xs mb-3">
               每个分析任务固定使用启动时选中的配置；失败后不会自动跨供应商切换。
             </n-alert>
+            <div class="concurrency-setting">
+              <div>
+                <strong class="text-sm">并行分析数</strong>
+                <p class="text-xs text-neutral-400 mt-1">全局同时处理的会话数量；提高后会增加 API 请求或本地 CLI 进程占用。</p>
+              </div>
+              <n-input-number
+                v-model:value="workingConfig.distiller.maxConcurrentAnalyses"
+                :min="1"
+                :max="8"
+                :precision="0"
+                aria-label="并行分析数"
+              />
+            </div>
             <div class="profile-layout">
               <aside class="profile-list" aria-label="分析 Provider 配置列表">
                 <button
@@ -392,6 +405,8 @@ function close() { emit('update:show', false) }
 <style scoped>
 .settings-shell { width: min(860px, calc(100vw - 32px)); max-height: 84vh; overflow: hidden; border-radius: 16px; }
 .settings-scroll { max-height: calc(76vh - 190px); overflow-y: auto; }
+.concurrency-setting { display:flex; align-items:center; justify-content:space-between; gap:20px; margin-bottom:16px; padding:2px 0 14px; border-bottom:1px solid var(--n-border-color); }
+.concurrency-setting :deep(.n-input-number) { width:112px; flex-shrink:0; }
 .profile-layout { display: grid; grid-template-columns: 190px minmax(0, 1fr); gap: 16px; }
 .profile-list { display: flex; flex-direction: column; gap: 6px; padding-right: 12px; border-right: 1px solid var(--n-border-color); }
 .profile-item { display: flex; align-items: center; justify-content: space-between; gap: 8px; min-height: 38px; padding: 8px 10px; border: 1px solid transparent; border-radius: 10px; text-align: left; color: inherit; }
diff --git a/apps/desktop/src/stores/analysisQueue.ts b/apps/desktop/src/stores/analysisQueue.ts
index 1174e4c..f938b6e 100644
--- a/apps/desktop/src/stores/analysisQueue.ts
+++ b/apps/desktop/src/stores/analysisQueue.ts
@@ -39,7 +39,6 @@ export const useAnalysisQueueStore = defineStore('analysisQueue', () => {
         ? Math.max(0, Math.floor((clock.value - Date.parse(item.startedAt)) / 1000)) : 0,
     }))))
 
-  const currentTask = computed(() => tasks.value.find((task) => task.status === 'running') ?? null)
   const pendingCount = computed(() => tasks.value.filter((task) => task.status === 'pending').length)
   const totalCount = computed(() => jobs.value.reduce((sum, job) => sum + job.total, 0))
   const doneCount = computed(() => jobs.value.reduce((sum, job) => sum + job.done, 0))
@@ -64,8 +63,8 @@ export const useAnalysisQueueStore = defineStore('analysisQueue', () => {
 
   async function startAnalysis(sessionIds: string[], providerProfileId?: string) {
     const sessions = useSessionsStore()
-    sessionIds.forEach((id) => sessions.patchItem(id, { status: 'analyzing' }))
     const job = await api.startAnalysis(sessionIds, providerProfileId)
+    sessionIds.forEach((id) => sessions.patchItem(id, { status: 'analyzing' }))
     upsert(job)
     return job
   }
@@ -87,7 +86,11 @@ export const useAnalysisQueueStore = defineStore('analysisQueue', () => {
     return job
   }
 
-  function clear() { jobs.value = jobs.value.filter((job) => !terminal.has(job.status)) }
+  function clear(jobId?: string) {
+    jobs.value = jobs.value.filter((job) =>
+      !terminal.has(job.status) || (jobId != null && job.id !== jobId),
+    )
+  }
 
   function dispose() {
     unlisten?.()
@@ -98,7 +101,7 @@ export const useAnalysisQueueStore = defineStore('analysisQueue', () => {
   }
 
   return {
-    jobs, clock, tasks, currentTask, pendingCount, totalCount, doneCount, hasAny, isIdle,
+    jobs, clock, tasks, pendingCount, totalCount, doneCount, hasAny, isIdle,
     progressPercent, initialize, startAnalysis, startSync, cancel, retry, clear, dispose,
   }
 })
diff --git a/apps/desktop/src/types/index.ts b/apps/desktop/src/types/index.ts
index 3a9836f..e8616f5 100644
--- a/apps/desktop/src/types/index.ts
+++ b/apps/desktop/src/types/index.ts
@@ -102,6 +102,7 @@ export interface Session {
   hasUpdates: boolean
   analyzedAt: string | null
   errorMessage: string | null
+  cardId: string | null
 }
 
 export interface Message {
@@ -240,6 +241,7 @@ export interface AppConfigDto {
 
 export interface DistillerConfigDto {
   activeProfileId: string
+  maxConcurrentAnalyses: number
   profiles: ProviderProfileDto[]
 }
 
diff --git a/apps/desktop/src/views/SessionDetailView.vue b/apps/desktop/src/views/SessionDetailView.vue
index c0f05a2..12ae1cb 100644
--- a/apps/desktop/src/views/SessionDetailView.vue
+++ b/apps/desktop/src/views/SessionDetailView.vue
@@ -21,7 +21,7 @@ const message = useMessage()
 const dialog = useDialog()
 
 const queue = useAnalysisQueueStore()
-const { currentTask, tasks } = storeToRefs(queue)
+const { tasks } = storeToRefs(queue)
 
 const session = ref<Session | null>(null)
 const messages = ref<Message[]>([])
@@ -42,10 +42,11 @@ const typeOptions = [
   { label: '片段', value: 'snippet' },
 ]
 
-/** 当前会话是否正在执行 distill（队列头） */
-const analyzing = computed(
-  () => currentTask.value?.sessionId === props.sessionId,
+/** 当前会话是否正在执行 distill。 */
+const activeTask = computed(() =>
+  tasks.value.find((task) => task.sessionId === props.sessionId && task.status === 'running') ?? null,
 )
+const analyzing = computed(() => activeTask.value != null)
 
 /** 已在队列中但尚未轮到 */
 const analyzeQueued = computed(() =>
@@ -54,12 +55,12 @@ const analyzeQueued = computed(() =>
 
 /** 耗时超过 150s 提示「分析较慢」 */
 const analyzeSlow = computed(
-  () => analyzing.value && (currentTask.value?.elapsedSec ?? 0) > 150,
+  () => analyzing.value && (activeTask.value?.elapsedSec ?? 0) > 150,
 )
 
 // ────────────── 数据加载 ──────────────
 
-async function load() {
+async function load(preferLatest = false) {
   loading.value = true
   loadError.value = null
   try {
@@ -71,10 +72,14 @@ async function load() {
     messages.value = page.items
     nextCursor.value = page.nextCursor
 
-    const cardId = typeof route.query.cardId === 'string' ? route.query.cardId : null
+    const routeCardId = typeof route.query.cardId === 'string' ? route.query.cardId : null
+    const cardId = preferLatest ? sess.cardId : routeCardId ?? sess.cardId
     if (cardId) {
       card.value = await api.getCard(cardId)
       mode.value = 'note'
+      if (preferLatest && cardId !== routeCardId) {
+        void router.replace({ query: { ...route.query, cardId } })
+      }
     } else {
       card.value = null
     }
@@ -96,9 +101,18 @@ async function loadMoreMessages() {
 }
 
 onMounted(load)
-watch(() => [props.sessionId, route.query.cardId], () => {
+watch(() => [props.sessionId, route.query.cardId], ([sessionId, cardId], previous) => {
+  if (sessionId === previous?.[0] && typeof cardId === 'string' && card.value?.id === cardId) return
   void load()
 })
+watch(
+  () => tasks.value.find((task) => task.sessionId === props.sessionId)?.status,
+  (status, previous) => {
+    if ((previous === 'pending' || previous === 'running') && (status === 'done' || status === 'error')) {
+      void load(true)
+    }
+  },
+)
 
 // ────────────── 操作 ──────────────
 
@@ -125,13 +139,12 @@ async function onExportMarkdown() {
 
 async function analyze() {
   analyzeError.value = null
-  if (session.value) session.value.status = 'analyzing'
   try {
     await queue.startAnalysis([props.sessionId])
-    analyzeError.value = '分析任务已创建；完成后可从对话列表打开生成的知识项。'
+    if (session.value) session.value.status = 'analyzing'
+    message.success('分析任务已创建，可在顶部「进度中心」查看进度')
   } catch (error) {
     analyzeError.value = appendDistillHint(error instanceof Error ? error.message : String(error))
-    if (session.value) session.value.status = 'error'
   }
 }
 
@@ -324,7 +337,7 @@ const valueColors: Record<string, string> = {
         <n-result v-else-if="loadError" status="error" :title="loadError" class="py-12">
           <template #footer>
             <n-button @click="close">返回列表</n-button>
-            <n-button class="ml-2" @click="load">重试</n-button>
+            <n-button class="ml-2" @click="load()">重试</n-button>
           </template>
         </n-result>
 
@@ -350,7 +363,7 @@ const valueColors: Record<string, string> = {
           >
             <span class="i-lucide-clock w-4 h-4 text-neutral-500 shrink-0" />
             <p class="text-sm text-neutral-600 dark:text-neutral-300">
-              已加入分析队列，等待前面的任务完成…（见右下角面板）
+              已加入分析队列，等待执行；可在顶部「进度中心」查看进度。
             </p>
           </div>
 
@@ -369,11 +382,13 @@ const valueColors: Record<string, string> = {
 
           <div
             v-if="analyzeError"
+            role="alert"
+            aria-live="assertive"
             class="mb-4 flex items-center gap-2 rounded-lg border border-red-200 dark:border-red-900/50 bg-red-50 dark:bg-red-950/30 px-3 py-2 text-sm text-red-600 dark:text-red-400"
           >
             <span class="i-lucide-alert-circle w-4 h-4 shrink-0" />
             <span class="flex-1">{{ analyzeError }}</span>
-            <button class="opacity-60 hover:opacity-100" type="button" @click="analyzeError = null">✕</button>
+            <button class="opacity-60 hover:opacity-100" type="button" aria-label="关闭错误提示" @click="analyzeError = null">✕</button>
           </div>
 
           <NoteCard
@@ -417,17 +432,19 @@ const valueColors: Record<string, string> = {
           >
             <span class="i-lucide-clock w-4 h-4 text-neutral-500 shrink-0" />
             <p class="text-sm text-neutral-600 dark:text-neutral-300">
-              已加入分析队列，等待前面的任务完成…（见右下角面板）
+              已加入分析队列，等待执行；可在顶部「进度中心」查看进度。
             </p>
           </div>
 
           <div
             v-if="analyzeError"
+            role="alert"
+            aria-live="assertive"
             class="mb-4 flex items-center gap-2 rounded-lg border border-red-200 dark:border-red-900/50 bg-red-50 dark:bg-red-950/30 px-3 py-2 text-sm text-red-600 dark:text-red-400"
           >
             <span class="i-lucide-alert-circle w-4 h-4 shrink-0" />
             <span class="flex-1">{{ analyzeError }}</span>
-            <button class="opacity-60 hover:opacity-100" type="button" @click="analyzeError = null">✕</button>
+            <button class="opacity-60 hover:opacity-100" type="button" aria-label="关闭错误提示" @click="analyzeError = null">✕</button>
           </div>
 
           <div
diff --git a/apps/desktop/src/views/SessionsView.vue b/apps/desktop/src/views/SessionsView.vue
index 9311a38..c116e68 100644
--- a/apps/desktop/src/views/SessionsView.vue
+++ b/apps/desktop/src/views/SessionsView.vue
@@ -131,7 +131,7 @@ function onSelectionChange(id: string, checked: boolean) {
 }
 
 /**
- * 批量分析：全部入队，由全局队列串行执行；通过 callbacks 统计完成后 Toast
+ * 批量分析：全部入队，由全局并发限制控制执行数量。
  */
 async function startBatchAnalyze() {
   const ids = [...selectedIds.value]
@@ -178,6 +178,8 @@ function openSearchHit(cardId: string, sessionId: string) {
     >
       <div
         v-if="toast"
+        :role="toast.type === 'error' ? 'alert' : 'status'"
+        :aria-live="toast.type === 'error' ? 'assertive' : 'polite'"
         class="fixed top-4 left-1/2 -translate-x-1/2 z-50 rounded-lg border px-3 py-2 shadow-lg flex items-center gap-2 text-sm"
         :class="{
           'border-red-200 bg-red-50 dark:bg-red-950/80 dark:border-red-800 text-red-800 dark:text-red-200': toast.type === 'error',
@@ -287,8 +289,8 @@ function openSearchHit(cardId: string, sessionId: string) {
           </n-button>
         </div>
 
-        <p v-if="batchRunning" class="text-xs text-slate-500 dark:text-slate-400 mb-2">
-          已加入全局分析队列，进度见右下角面板；请勿关闭应用。
+        <p v-if="batchRunning" role="status" aria-live="polite" class="text-xs text-slate-500 dark:text-slate-400 mb-2">
+          已加入全局分析队列，可在顶部「进度中心」查看进度；任务执行期间请保持应用运行。
         </p>
 
         <!-- 会话卡片列表 -->
diff --git a/docs/config.example.toml b/docs/config.example.toml
index e10e981..2998631 100644
--- a/docs/config.example.toml
+++ b/docs/config.example.toml
@@ -2,6 +2,7 @@
 
 [distiller]
 active_profile_id = "siliconflow-main"
+max_concurrent_analyses = 2
 
 [[distiller.profiles]]
 id = "siliconflow-main"
diff --git "a/docs/\345\274\200\345\217\221\350\257\264\346\230\216-Tauri\345\221\275\344\273\244\344\270\216\345\211\215\347\253\257.md" "b/docs/\345\274\200\345\217\221\350\257\264\346\230\216-Tauri\345\221\275\344\273\244\344\270\216\345\211\215\347\253\257.md"
index 9f6c3f2..c9e7d9f 100644
--- "a/docs/\345\274\200\345\217\221\350\257\264\346\230\216-Tauri\345\221\275\344\273\244\344\270\216\345\211\215\347\253\257.md"
+++ "b/docs/\345\274\200\345\217\221\350\257\264\346\230\216-Tauri\345\221\275\344\273\244\344\270\216\345\211\215\347\253\257.md"
@@ -70,7 +70,8 @@
 
 ## 全局分析队列（Pinia）
 
-- **Store**：`stores/analysisQueue.ts` — `enqueue` / `cancel` / `clear`，内部**串行**调用 `distill_session`（与 Sidecar 单通道一致）。
-- **入口统一**：会话列表单条「分析」、批量「开始分析」、详情页「提炼笔记 / 重新分析」均通过 `enqueue` 入队。
-- **UI**：`components/AnalysisQueuePanel.vue` 由顶栏「进度中心」入口打开，任意页面可在弹窗中查看进度、耗时与失败明细，并取消或重试任务；不再使用会遮挡正文或分页的右下角悬浮层。
-- **批量完成 Toast**：`SessionsView` 对批量入队的任务在 callbacks 中计数，全部结束后提示成功/失败条数。
+- **调度**：Rust 任务层按 `distiller.max_concurrent_analyses`（1–8，默认 2）限制全局并发；每个运行中的分析条目使用独立 Sidecar 进程，超时、取消与 Provider 配置互不影响，同步任务仍与分析任务互斥。
+- **Store**：`stores/analysisQueue.ts` 统一接收后端任务快照，支持取消、重试、清除全部已完成任务或单独清除某个任务。
+- **入口统一**：会话列表单条「分析」、批量「开始分析」、详情页「提炼笔记 / 重新分析」均通过 `startAnalysis` 创建后端任务。
+- **UI**：`components/AnalysisQueuePanel.vue` 由顶栏「进度中心」入口打开，任意页面可在弹窗中查看并行进度、耗时与失败明细，并取消、重试或单独清除同步任务；不再使用会遮挡正文或分页的右下角悬浮层。并行数在「设置 → AI 配置」中热更新。
+- **批量入队 Toast**：`SessionsView` 在任务创建成功或失败时即时反馈；后续阶段与结果统一在进度中心展示。