@@ -11,7 +11,7 @@
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::thread::{self, JoinHandle};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use windows::core::GUID;
 use windows::Win32::Media::Audio::{
@@ -33,6 +33,10 @@ const CLSID_MM_DEVICE_ENUMERATOR: GUID = GUID::from_u128(0xBCDE0395_E52F_467C_8E
 ///              （windows crate 未导出，按 MSDN 定义；用于 EXTENSIBLE 格式识别，审查 S1 修复）。
 const KSDATAFORMAT_SUBTYPE_IEEE_FLOAT: GUID = GUID::from_u128(0x00000003_0000_0010_8000_00AA00389B71);
 
+/// 停止 join 有界等待（REQ-174 v0.7.5）：WASAPI GetBuffer 卡在驱动层时
+/// 捕获线程无法及时退出，裸 join 永久阻塞停止链路；超时 detach 兜底。
+const STOP_JOIN_TIMEOUT: Duration = Duration::from_secs(2);
+
 /// 捕获输出块（16kHz 单声道，定长 200ms）。
 #[derive(Debug, Clone)]
 pub struct AudioChunk {
@@ -106,16 +110,35 @@ impl AudioLoopbackCapture {
         Ok(Self { stop_flag, handle: Some(handle) })
     }
 
-    /// 停止捕获并等待线程退出（join 超时保护：线程异常时不阻塞调用方）。
-    ///
-    /// @ai-context: 结构体实现 Drop 不能整体 move，故用 &mut + Option::take。
-    pub fn stop(&mut self) {
-        self.stop_flag.store(true, Ordering::SeqCst);
-        if let Some(handle) = self.handle.take() {
-            let _ = handle.join();
+/// 停止捕获并等待线程退出（join 超时保护：线程异常/卡死时不阻塞调用方）。
+///
+/// @ai-context: REQ-174（v0.7.5）：WASAPI GetBuffer 卡在驱动层时捕获线程
+///              无法及时退出——裸 join 会永久卡死会话停止链路（会话31 实证：
+///              finish_session 未执行、live:status stopped 未发出、前端"采集中"
+///              残留至重启兜底翻案）。改为有界等待 + 超时 detach（线程最终
+///              由系统回收，资源不泄漏）。
+/// @ai-context: 结构体实现 Drop 不能整体 move，故用 &mut + Option::take。
+pub fn stop(&mut self) {
+    self.stop_flag.store(true, Ordering::SeqCst);
+    if let Some(handle) = self.handle.take() {
+        // REQ-174：有界等待替代裸 join——2s 内线程未退出即 detach（停止
+        // 响应不被 WASAPI 阻塞拖死；已置 stop_flag，线程恢复后自行退出）
+        let deadline = Instant::now() + STOP_JOIN_TIMEOUT;
+        while !handle.is_finished() && Instant::now() < deadline {
+            std::thread::sleep(Duration::from_millis(50));
+        }
+        if handle.is_finished() {
+            let _ = handle.join(); // 已退出：join 立即返回（取回线程结果）
+        } else {
+            // 超时 detach：不阻塞调用方（join 句柄 drop 即 detach）
+            eprintln!(
+                "[AudioLoopback] 捕获线程 {:.1}s 内未退出，已 detach（WASAPI 阻塞，资源由系统回收）",
+                STOP_JOIN_TIMEOUT.as_secs_f32()
+            );
         }
     }
 }
+}
 
 impl Drop for AudioLoopbackCapture {
     fn drop(&mut self) {
@@ -441,4 +464,51 @@ mod tests {
         assert_eq!(d6, d5);
         assert_eq!(d100, d5);
     }
+
+    /// 构造捕获句柄（测试用：注入自定义线程）。
+    fn make_capture(stop_flag: Arc<AtomicBool>, handle: JoinHandle<()>) -> AudioLoopbackCapture {
+        AudioLoopbackCapture { stop_flag, handle: Some(handle) }
+    }
+
+    #[test]
+    fn stop_returns_promptly_when_thread_stuck() {
+        // Arrange：模拟 WASAPI GetBuffer 卡死的捕获线程（不检查 stop_flag，
+        // 永不退出）——REQ-174 场景：裸 join 会永久阻塞停止链路
+        let stop_flag = Arc::new(AtomicBool::new(false));
+        let handle = thread::Builder::new()
+            .name("stuck-capture".into())
+            .spawn(|| loop {
+                std::thread::sleep(Duration::from_millis(100));
+            })
+            .unwrap();
+        let mut cap = make_capture(stop_flag, handle);
+        // Act：stop 有界等待（2s 超时 detach）
+        let started = Instant::now();
+        cap.stop();
+        // Assert：有界返回（不永久阻塞）、句柄已 take（detach 不泄漏）
+        assert!(started.elapsed() < Duration::from_secs(3), "stop 阻塞了 {:?}", started.elapsed());
+        assert!(cap.handle.is_none());
+    }
+
+    #[test]
+    fn stop_joins_when_thread_exits_promptly() {
+        // Arrange：正常捕获线程——stop_flag 置位后快速退出
+        let stop_flag = Arc::new(AtomicBool::new(false));
+        let flag = stop_flag.clone();
+        let handle = thread::Builder::new()
+            .name("healthy-capture".into())
+            .spawn(move || {
+                while !flag.load(Ordering::SeqCst) {
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+            })
+            .unwrap();
+        let mut cap = make_capture(stop_flag, handle);
+        // Act：正常路径——join 立即返回（不等满超时）
+        let started = Instant::now();
+        cap.stop();
+        // Assert：远小于超时阈值（正常 join 而非 detach）
+        assert!(started.elapsed() < Duration::from_millis(500), "正常 join 耗时 {:?}", started.elapsed());
+        assert!(cap.handle.is_none());
+    }
 }
@@ -59,6 +59,14 @@ pub async fn list_sessions(
     offset: Option<u64>,
 ) -> Result<Vec<SessionListItem>, String> {
     let limit = limit.unwrap_or(50).min(LIST_LIMIT_MAX);
+    // REQ-176（v0.7.5）：残留 recording 会话兜底——线程已死但 DB 停留
+    // recording（停止链路异常/崩溃，会话31 实证）→ 列表拉取即翻案，
+    // 无需重启（running_session_id 排除进行中会话，绝不误标）
+    let running_id = state.live_session.running_session_id();
+    state
+        .db
+        .mark_stale_recording(running_id)
+        .map_err(|e| e.to_string())?;
     state
         .db
         .list_sessions(keyword.as_deref(), limit, offset.unwrap_or(0))
 
@@ -324,6 +324,30 @@ impl Db {
         )?;
         Ok(affected)
     }
+
+    /// 残留 recording 会话兜底标记（REQ-176 v0.7.5）：跳过进行中的会话 id。
+    ///
+    /// @ai-context: 与 mark_interrupted_sessions 同语义，但**无需重启**——列表
+    ///              拉取即翻案。会话31 实证：停止链路异常（audio.stop join 无
+    ///              超时卡死）时线程未走完 finish_session，DB 停留 recording、
+    ///              前端"采集中"残留，此前只能等下次启动兜底。running_id 为
+    ///              真正运行中的会话 id（live_session.running_session_id），
+    ///              进行中会话绝不误标。
+    pub fn mark_stale_recording(&self, running_id: Option<i64>) -> Result<usize> {
+        let conn = self.conn.lock().expect("db lock poisoned");
+        let affected = match running_id {
+            Some(id) => conn.execute(
+                "UPDATE sessions SET status = ?1, ended_at = COALESCE(ended_at, ?2)
+                 WHERE status = ?3 AND id != ?4",
+                params![SESSION_STATUS_FAILED, unix_seconds(), SESSION_STATUS_RECORDING, id],
+            )?,
+            None => conn.execute(
+                "UPDATE sessions SET status = ?1, ended_at = COALESCE(ended_at, ?2) WHERE status = ?3",
+                params![SESSION_STATUS_FAILED, unix_seconds(), SESSION_STATUS_RECORDING],
+            )?,
+        };
+        Ok(affected)
+    }
 }
 
 /// 转义 LIKE 通配符（复用 db.rs 实现，审查 L7 收敛）。
 
@@ -221,6 +221,52 @@ fn mark_interrupted_sessions_flags_recording() {
     assert!(fetched.ended_at.is_some());
 }
 
+#[test]
+fn mark_stale_recording_skips_running() {
+    // Arrange：running_id 对应的 recording 会话不得误标（REQ-176 防御）
+    let db = mem_db();
+    let running = db.create_session(&new_session("进行中")).unwrap();
+    let stale = db.create_session(&new_session("残留")).unwrap();
+    // Act：running_id=Some(running.id)——残留标 failed，进行中不动
+    let affected = db.mark_stale_recording(Some(running.id)).expect("mark");
+    let running_fetched = db.get_session(running.id).unwrap().unwrap();
+    let stale_fetched = db.get_session(stale.id).unwrap().unwrap();
+    // Assert
+    assert_eq!(affected, 1);
+    assert_eq!(running_fetched.status, "recording");
+    assert!(running_fetched.ended_at.is_none());
+    assert_eq!(stale_fetched.status, "failed");
+    assert!(stale_fetched.ended_at.is_some());
+}
+
+#[test]
+fn mark_stale_recording_no_running_flags_all() {
+    // Arrange：无运行中会话（running_id=None）——全部 recording 标 failed
+    let db = mem_db();
+    let a = db.create_session(&new_session("残留A")).unwrap();
+    let b = db.create_session(&new_session("残留B")).unwrap();
+    // Act
+    let affected = db.mark_stale_recording(None).expect("mark");
+    // Assert
+    assert_eq!(affected, 2);
+    assert_eq!(db.get_session(a.id).unwrap().unwrap().status, "failed");
+    assert_eq!(db.get_session(b.id).unwrap().unwrap().status, "failed");
+}
+
+#[test]
+fn mark_stale_recording_idempotent() {
+    // Arrange：重复调用不重复计数（同 mark_interrupted_sessions 幂等）
+    let db = mem_db();
+    let stale = db.create_session(&new_session("残留")).unwrap();
+    // Act
+    let first = db.mark_stale_recording(None).expect("mark");
+    let second = db.mark_stale_recording(None).expect("mark again");
+    // Assert
+    assert_eq!(first, 1);
+    assert_eq!(second, 0);
+    assert_eq!(db.get_session(stale.id).unwrap().unwrap().status, "failed");
+}
+
 #[test]
 fn session_notes_tables_coexist() {
     // Arrange：会话与笔记共享同一数据库（向后兼容验证）
 
@@ -382,6 +382,20 @@ impl LiveSessionManager {
             None => None,
         }
     }
+
+    /// 真正在运行的会话 id（REQ-176 v0.7.5）：线程已退出的残留返回 None。
+    ///
+    /// @ai-context: 与 active_session_id 的区别——active_session_id 对已退出
+    ///              残留返回其 id（供上层"刚结束"语义使用）；本方法只认
+    ///              "线程未退出"。残留回收（mark_stale_recording）用它区分
+    ///              进行中会话与会话31 类残留（线程异常退出但 DB 停留 recording）。
+    pub fn running_session_id(&self) -> Option<i64> {
+        let guard = self.active.lock().expect("live session lock poisoned");
+        match guard.as_ref() {
+            Some(a) if !a.thread.is_finished() => Some(a.session_id),
+            _ => None,
+        }
+    }
 }
 
 /// 有界等待预备线程就绪（P3）：Ready→Ok；Failed/超时→Err（原因）。
 
@@ -53,6 +53,17 @@ function App() {
           }
         }),
       );
+      // REQ-175（v0.7.5）：停止残留兜底——融合开始 = 采集已停的可靠信号
+      // （session:fusing 在会话停止后无条件发出；live:status stopped 可能
+      // 因线程卡死/事件丢失而不到达——会话31 实证"采集中"残留至重启翻案）
+      unlisteners.push(
+        await listen<number>("session:fusing", () => {
+          if (disposed) return;
+          setCapturing(false);
+          setRecovering(false);
+          setPaused(false);
+        }),
+      );
       // 2026-08 A1：暂停/恢复（全局徽标显示"⏸ 已暂停"）
       unlisteners.push(
         await listen("live:paused", () => {