@@ -17,6 +17,9 @@ import { getGoldenErrorRecords } from '@/features/flashcards/lib/goldenErrorQuer
 const WEAK_POINT_LIMIT = 20;
 /** 黄金错误取最近 N 条参与摘要 */
 const GOLDEN_ERROR_LIMIT = 10;
+/** dismiss key 前缀与保留上限：避免 localStorage 按 noteId 无限累积 */
+const DISMISS_PREFIX = 'feynman_precheck_dismissed_';
+const DISMISS_KEEP = 100;
 
 interface ConceptPrecheckCardProps {
   concept: string;
@@ -39,8 +42,8 @@ async function buildWeakHistory(): Promise<string> {
 }
 
 export function ConceptPrecheckCard({ concept, noteId }: ConceptPrecheckCardProps) {
-  const dismissKey = `feynman_precheck_dismissed_${noteId}`;
-  const [dismissed, setDismissed] = useState(() => localStorage.getItem(dismissKey) === '1');
+  const dismissKey = `${DISMISS_PREFIX}${noteId}`;
+  const [dismissed, setDismissed] = useState(() => localStorage.getItem(dismissKey) !== null);
   const [intentOpen, setIntentOpen] = useState(false);
   const { result, loading, error, precheck } = useAIConceptPrecheck();
 
@@ -54,16 +57,32 @@ export function ConceptPrecheckCard({ concept, noteId }: ConceptPrecheckCardProp
   }, [concept, dismissed, precheck]);
 
   const dismiss = () => {
-    localStorage.setItem(dismissKey, '1');
+    localStorage.setItem(dismissKey, String(Date.now()));
     setDismissed(true);
+    // 控制总量：超出保留上限时淘汰最旧的 dismiss 记录
+    const entries: Array<{ key: string; ts: number }> = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(DISMISS_PREFIX)) {
+        entries.push({ key, ts: Number(localStorage.getItem(key)) || 0 });
+      }
+    }
+    if (entries.length > DISMISS_KEEP) {
+      entries
+        .sort((a, b) => a.ts - b.ts)
+        .slice(0, entries.length - DISMISS_KEEP)
+        .forEach((e) => localStorage.removeItem(e.key));
+    }
   };
 
   const questions = result?.questions ?? [];
-  // 静默场景：已关闭 / 加载中 / 失败 / 无问题 → 不渲染（可选增强不打扰）
-  if (dismissed || loading || !!error || questions.length === 0) return null;
+  // 静默场景：已关闭 / 加载中 / 失败 / 无问题 → 不渲染（可选增强不打扰）。
+  // 条件置于 AnimatePresence 内部，关闭时才能播放 exit 动画
+  const hidden = dismissed || loading || !!error || questions.length === 0;
 
   return (
     <AnimatePresence>
+      {!hidden && (
       <motion.div
         initial={{ opacity: 0, y: -8 }}
         animate={{ opacity: 1, y: 0 }}
@@ -121,6 +140,7 @@ export function ConceptPrecheckCard({ concept, noteId }: ConceptPrecheckCardProp
           </ul>
         )}
       </motion.div>
+      )}
     </AnimatePresence>
   );
 }
@@ -16,6 +16,9 @@ interface FeynmanRecorderProps {
   onExplanationChange: (v: string) => void;
 }
 
+/** 单次录音时长上限：防止 PCM 累积无限增长（10 分钟 ≈ 19MB） */
+const MAX_RECORD_MS = 10 * 60 * 1000;
+
 /** base64 → Blob（会话内回放用） */
 function base64ToBlob(base64: string, type: string): Blob {
   const binary = atob(base64);
@@ -38,9 +41,13 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
   onChangeRef.current = onExplanationChange;
 
   const recordingRef = useRef(false);
+  const startingRef = useRef(false);
   const samplesRef = useRef<Float32Array[]>([]);
   const sampleRateRef = useRef(16000);
   const unsubsRef = useRef<Array<() => void>>([]);
+  const recordLimitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // ref 同步最新 playback URL：卸载闭包只捕获初始值，必须经 ref 才能正确 revoke
+  const playbackUrlRef = useRef<string | null>(null);
 
   // 可用性探测：ASR 模型未就绪则隐藏入口
   useEffect(() => {
@@ -56,13 +63,28 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
     unsubsRef.current = [];
   }, []);
 
+  /** 更新回放 URL 并回收旧的（ref 同步，保证卸载时可回收） */
+  const updatePlaybackUrl = useCallback((next: string | null) => {
+    if (playbackUrlRef.current) URL.revokeObjectURL(playbackUrlRef.current);
+    playbackUrlRef.current = next;
+    setPlaybackUrl(next);
+  }, []);
+
   const stop = useCallback(async () => {
     if (!recordingRef.current) return;
-    recordingRef.current = false;
-    cleanupIpc();
+    if (recordLimitTimerRef.current) {
+      clearTimeout(recordLimitTimerRef.current);
+      recordLimitTimerRef.current = null;
+    }
     const api = window.electronAPI;
     try {
+      // 先停 ASR：主进程会 flush 最后一段 final，此时订阅仍在且
+      // recordingRef 仍为 true，最后一句话能正常追加进讲解文本
       await api?.invoke('local_asr_stream_stop');
+    } catch { /* 静默降级 */ }
+    recordingRef.current = false;
+    cleanupIpc();
+    try {
       await api?.invoke('audio_capture_stop');
     } catch { /* 静默降级 */ }
     setRecording(false);
@@ -78,18 +100,18 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
       for (const c of chunks) { merged.set(c, offset); offset += c.length; }
       try {
         const wavBase64 = encodeWavBase64(merged, sampleRateRef.current, 1);
-        setPlaybackUrl((prev) => {
-          if (prev) URL.revokeObjectURL(prev);
-          return URL.createObjectURL(base64ToBlob(wavBase64, 'audio/wav'));
-        });
+        updatePlaybackUrl(URL.createObjectURL(base64ToBlob(wavBase64, 'audio/wav')));
       } catch { /* 编码失败不影响转写文本 */ }
     }
-  }, [cleanupIpc]);
+  }, [cleanupIpc, updatePlaybackUrl]);
 
   const start = useCallback(async () => {
     const api = window.electronAPI;
-    if (!api || recordingRef.current) return;
+    // startingRef 同步上锁：防止异步启动期间双击重复启动（监听器泄漏/文本重复追加）
+    if (!api || recordingRef.current || startingRef.current) return;
+    startingRef.current = true;
     setError(null);
+    let captureStarted = false;
     try {
       const status = await api.invoke('audio_capture_status') as { active: boolean };
       if (status?.active) {
@@ -103,15 +125,20 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
         setError(capture?.error || '麦克风启动失败，请检查设备与权限');
         return;
       }
+      captureStarted = true;
       const asrStart = await api.invoke('local_asr_stream_start', { sampleRate: 16000 }) as { success: boolean };
       if (!asrStart?.success) {
-        await api.invoke('audio_capture_stop');
+        await api.invoke('audio_capture_stop').catch(() => {});
         setError('语音识别启动失败，请重试');
         return;
       }
     } catch {
+      // 异常若发生在本组件已启动采集之后，必须回收麦克风，避免残留占用阻塞其他音频功能
+      if (captureStarted) api.invoke('audio_capture_stop').catch(() => {});
       setError('录音启动失败，请重试');
       return;
+    } finally {
+      startingRef.current = false;
     }
 
     samplesRef.current = [];
@@ -141,13 +168,19 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
 
     recordingRef.current = true;
     setRecording(true);
-  }, []);
+    // 时长上限自动停止：避免长时间录音 PCM 内存无限增长
+    recordLimitTimerRef.current = setTimeout(() => { void stop(); }, MAX_RECORD_MS);
+  }, [stop]);
 
   // 卸载兜底：释放麦克风与 ASR 流、回收 blob URL
   useEffect(() => {
     return () => {
-      if (recordingRef.current) {
+      if (recordLimitTimerRef.current) clearTimeout(recordLimitTimerRef.current);
+      // startingRef 覆盖"启动中途卸载"竞态：capture 已在主进程启动但
+      // recordingRef 尚未置 true，此时也必须释放，否则麦克风残留占用
+      if (recordingRef.current || startingRef.current) {
         recordingRef.current = false;
+        startingRef.current = false;
         cleanupIpc();
         const api = window.electronAPI;
         api?.invoke('local_asr_stream_stop').catch(() => {});
@@ -156,8 +189,7 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
     };
   }, [cleanupIpc]);
   useEffect(() => {
-    return () => { if (playbackUrl) URL.revokeObjectURL(playbackUrl); };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    return () => { if (playbackUrlRef.current) URL.revokeObjectURL(playbackUrlRef.current); };
   }, []);
 
   // 可选增强：ASR 不可用时隐藏入口
@@ -189,7 +221,7 @@ export function FeynmanRecorder({ explanation, onExplanationChange }: FeynmanRec
             <Play className="w-3.5 h-3.5" strokeWidth={1.5} />
             <audio src={playbackUrl} controls className="h-7 max-w-[200px]" />
             <button
-              onClick={() => { URL.revokeObjectURL(playbackUrl); setPlaybackUrl(null); }}
+              onClick={() => updatePlaybackUrl(null)}
               className="p-1 rounded hover:text-red-500 transition-colors"
               title="删除录音"
             >
 
@@ -249,35 +249,41 @@ export function useSocraticFlow() {
 
   const handleDeepeningSubmit = useCallback(async (answers: Record<string, string>) => {
     setSavingNote(true);
-    try {
-      const explanation = [
-        `## 苏格拉底式学习：${topic}\n`,
-        `### 发散思考`,
-        ...selected.map(s => `- ${s}`),
-        '',
-        `### 追问对话摘要`,
-        ...rounds.map(r => `**Q${r.roundNumber}**: ${r.aiQuestion}\n**A**: ${r.userAnswer}`),
-        '',
-        `### 深化理解`,
-        ...Object.entries(answers).map(([key, val]) => `**${key}**: ${val}`),
-      ].join('\n');
+    const explanation = [
+      `## 苏格拉底式学习：${topic}\n`,
+      `### 发散思考`,
+      ...selected.map(s => `- ${s}`),
+      '',
+      `### 追问对话摘要`,
+      ...rounds.map(r => `**Q${r.roundNumber}**: ${r.aiQuestion}\n**A**: ${r.userAnswer}`),
+      '',
+      `### 深化理解`,
+      ...Object.entries(answers).map(([key, val]) => `**${key}**: ${val}`),
+    ].join('\n');
 
-      const noteId = await createNote(topic);
+    let noteId: string;
+    try {
+      noteId = await createNote(topic);
       await updateNote(noteId, { explanation, status: 'completed', currentStep: 4 });
+    } catch {
+      toast({ type: 'error', message: '保存失败，请稍后重试' });
+      setSavingNote(false);
+      return;
+    }
 
-      // E4 苏格拉底-费曼数据互通：对话评估中得分 <6 的维度写入该笔记薄弱点
+    // E4 苏格拉底-费曼数据互通：对话评估中得分 <6 的维度写入该笔记薄弱点。
+    // 独立静默失败：薄弱点是可选增强，若混入主 try 会在笔记已落库后
+    // 误报"保存失败"，用户重试将创建重复笔记
+    try {
       for (const text of collectWeakDimensions(rounds)) {
         await addWeakPoint(noteId, { text, position: { start: 0, end: 0 }, mastered: false });
       }
+    } catch { /* 可选增强静默降级 */ }
 
-      toast({ type: 'success', message: '已保存为浮出水面概念！' });
+    toast({ type: 'success', message: '已保存为浮出水面概念！' });
 
-      setExiting(true);
-      phaseTimerRef.current = setTimeout(() => { navigate(`/feynman/${noteId}`); }, PHASE_TRANSITION_MS);
-    } catch {
-      toast({ type: 'error', message: '保存失败，请稍后重试' });
-      setSavingNote(false);
-    }
+    setExiting(true);
+    phaseTimerRef.current = setTimeout(() => { navigate(`/feynman/${noteId}`); }, PHASE_TRANSITION_MS);
   }, [topic, selected, rounds, createNote, updateNote, addWeakPoint, toast, navigate]);
 
   const handleGoBack = useCallback(() => {
 
@@ -80,7 +80,7 @@ function FeynmanGraphInner() {
             edges={edges}
             nodeTypes={nodeTypes}
             onNodeClick={(_e, node: Node) => navigate(`/feynman/${node.id}`)}
-            nodesDraggable
+            nodesDraggable={false}
             nodesConnectable={false}
             fitView
             fitViewOptions={{ padding: 0.2 }}
 
@@ -12,6 +12,7 @@ import { Sparkles, X, PlayCircle } from 'lucide-react';
 import { Button } from '@/components/ui';
 import { loadRecoveryPack, type RecoveryPack } from '../lib/recoveryPack';
 import { fetchRecallQuestion } from '@/features/dashboard/lib/ritualRecallService';
+import { extractNoteText } from '@/features/notes/lib/extractNoteText';
 import { noteStore } from '@/lib/storage';
 
 /** 收起后本次应用会话内不再展示 */
@@ -45,7 +46,8 @@ export default function RecoveryPackPanel() {
         const latest = [...notes].sort(
           (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
         )[0];
-        const plain = latest.content.replace(/<[^>]+>/g, ' ').slice(0, 1500);
+        // content 为 TipTap JSON 字符串，需递归提取 text 节点（HTML 正则无效）
+        const plain = extractNoteText(latest.content).slice(0, 1500);
         const q = await fetchRecallQuestion(latest.id, latest.title, plain);
         if (!cancelled && q) setEchoQuestion(q.question);
       } catch {
 
@@ -72,10 +72,14 @@ export async function loadRecoveryPack(): Promise<RecoveryPack | null> {
   const selected = selectRecoveryCards(allCards, now);
   if (selected.length === 0) return null;
 
-  // 统计到期卡最多的牌组作为 CTA 跳转目标
+  // 到期总数含新卡（与 UI 文案"共 X 张卡片到了复习时间"一致）；
+  // 牌组 CTA 仍只统计旧卡（repetitions>0，恢复场景针对旧知识）
+  let totalDue = 0;
   const dueByDeck = new Map<string, number>();
   for (const c of allCards) {
-    if (c.repetitions > 0 && new Date(c.dueDate).getTime() <= now) {
+    if (new Date(c.dueDate).getTime() > now) continue;
+    totalDue += 1;
+    if (c.repetitions > 0) {
       dueByDeck.set(c.deckId, (dueByDeck.get(c.deckId) ?? 0) + 1);
     }
   }
@@ -88,7 +92,7 @@ export async function loadRecoveryPack(): Promise<RecoveryPack | null> {
   return {
     gapDays,
     cards: selected,
-    totalDue: maxDue > 0 ? [...dueByDeck.values()].reduce((a, b) => a + b, 0) : 0,
+    totalDue,
     topDeckId,
   };
 }
@@ -47,8 +47,12 @@ export function ContentTierModal({ open, onClose, noteText }: ContentTierModalPr
   const copyCore = async () => {
     if (!tier) return;
     const text = tier.core.map((item, i) => `${i + 1}. ${item.text}`).join('\n');
-    await navigator.clipboard.writeText(text);
-    toast({ type: 'success', message: '核心概念已复制到剪贴板' });
+    try {
+      await navigator.clipboard.writeText(text);
+      toast({ type: 'success', message: '核心概念已复制到剪贴板' });
+    } catch {
+      toast({ type: 'error', message: '复制失败，请手动选择复制' });
+    }
   };
 
   const renderTier = (key: 'core' | 'support' | 'detail', items: ContentTierItem[]) => {
 
@@ -9,6 +9,7 @@ import { useEffect, useRef, useState, useCallback } from 'react';
 import type { Note } from '@/types/models';
 import type { ConceptConflict } from '@/lib/ai/types';
 import { useAIConflictDetect } from '@/lib/ai/hooks/useAIConflictDetect';
+import { extractNoteText } from '../lib/extractNoteText';
 
 /** 触发检测的最少当前笔记字数 */
 const MIN_NOTE_LEN = 100;
@@ -19,23 +20,6 @@ const HISTORY_NOTE_COUNT = 5;
 /** 单篇历史笔记截取长度 */
 const HISTORY_SLICE_LEN = 600;
 
-/** 从 TipTap JSON 或纯文本中提取纯文本 */
-function extractText(content: string): string {
-  try {
-    const json = JSON.parse(content);
-    if (json?.content) {
-      const walk = (nodes: unknown[]): string => nodes.map((n) => {
-        const node = n as { text?: string; content?: unknown[] };
-        return (node.text ?? '') + (node.content ? walk(node.content) : '');
-      }).join('');
-      return walk(json.content);
-    }
-    return '';
-  } catch {
-    return content;
-  }
-}
-
 /**
  * 概念冲突自动检测 hook
  */
@@ -60,7 +44,7 @@ export function useConceptConflict(noteId: string | null, noteText: string, allN
         .filter((n) => n.id !== noteId)
         .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
         .slice(0, HISTORY_NOTE_COUNT)
-        .map((n) => `【${n.title || '未命名'}】\n${extractText(n.content).slice(0, HISTORY_SLICE_LEN)}`)
+        .map((n) => `【${n.title || '未命名'}】\n${extractNoteText(n.content).slice(0, HISTORY_SLICE_LEN)}`)
         .join('\n\n');
       if (history.trim().length < 30) return; // 无历史可比对