feat(classroom): P1-2 动态热词闭环 + P1-3 修正回写 + P1-8 漏捕检测/手动补截

P1-2: 视觉提取concepts术语注入会话热词（extraction:completed）+ 流式热词IPC同步

P1-3: 编辑修正差异提取（公共前缀/后缀剥离）→ 会话内立即生效 + 词库去重持久化（课程维度绑定）

P1-8: 指令句后3s无新帧漏捕提示 + C键手动补截快捷键

Author: Aparencia

client/src/features/classroom/hooks/useClassroomCapture.ts

@@ -147,6 +147,7 @@ export function useClassroomCapture() {
     onNotify: notify,
     streamingAsrActive,
     windowTitle: selectedWindow?.title,
+    courseName: courseMeta.courseName,
   });
 
   // 转写/提取段最新值 ref 桥：停止收尾（useSessionControl）在事件回调
@@ -321,6 +322,13 @@ export function useClassroomCapture() {
     notify('success', `已标记重点 (${new Date(now).toLocaleTimeString()})`);
   }, [status, notify, captureManager, setSmartBundle]);
 
+  // ── P1-8 手动补截：快捷键触发强制补帧（复用 P1-7 机制，下一帧跳过变化检测门槛）──
+  const handleManualCapture = useCallback(() => {
+    if (status !== 'capturing') return;
+    captureManager.requestForceCapture();
+    notify('info', '已手动捕捉当前画面');
+  }, [status, notify, captureManager]);
+
   return {
     // 窗口
     ...windowWatcher,
@@ -362,6 +370,8 @@ export function useClassroomCapture() {
     handleRetryMerge: analysis.handleRetryMerge,
     handleDismissAnalysis: analysis.handleDismissAnalysis,
     handleGenerateCards, handleBookmark, bookmarks,
+    // P1-8 手动补截（漏捕检测提示的补救操作）
+    handleManualCapture,
     // M2 自动锚点（时间线展示）
     autoAnchors,
     // 笔记持久化

client/src/features/classroom/hooks/useClassroomEvents.ts

@@ -33,9 +33,11 @@ import { detectCourseFromFrame } from '@/lib/ai/courseDetector';
 import { remapKeyframeMarkers } from '../utils/tipTapImageUtils';
 import { persistKeyframeImage } from '../utils/keyframePersistence';
 import { transcribeWithRetry, toAsrLanguage, useAsrSemaphore, isLocalAsrReady, setOnAsrFallback } from '../utils/asrTranscriber';
-import { applySessionReplaces, getSessionHotwordsString, addDynamicBoosts } from '../utils/hotwordRuntime';
+import { applySessionReplaces, getSessionHotwordsString, addDynamicBoosts, addSessionReplace } from '../utils/hotwordRuntime';
 import { cleanAsrResult, dedupeAcrossFinals, estimateAsrConfidence } from '@/lib/capture/asrFilters';
 import { classifyContent, hasCommandCue, type ContentKind } from '@/lib/capture/contentClassifier';
+import { hotwordStore } from '@/lib/storage/hotwordStore';
+import { extractCorrection } from '../utils/transcriptCorrection';
 
 /** 触发一次增量分析所需的关键帧数 */
 const INCREMENTAL_BATCH_SIZE = 5;
@@ -67,6 +69,8 @@ interface UseClassroomEventsOptions {
   streamingAsrActive: boolean;
   /** P1-6：目标窗口标题（内容类型分类的标题信号） */
   windowTitle?: string;
+  /** P1-3：当前课程名（修正回写词库的 courseId 绑定） */
+  courseName?: string;
 }
 
 /** P1-6 分类尝试上限（转写样本仍无信号则停止，unknown 不再重试） */
@@ -75,10 +79,12 @@ const MAX_CLASSIFY_ATTEMPTS = 5;
 const FORCE_CAPTURE_MIN_INTERVAL_MS = 1000;
 /** P1-6 分类转写样本上限（字符，FIFO 追加防无界） */
 const MAX_CLASSIFY_SAMPLE_CHARS = 500;
+/** P1-8 漏捕检测延迟：指令句后该时长内无新关键帧 → 提示（ms） */
+const MISSED_CAPTURE_CHECK_MS = 3000;
 
 export function useClassroomEvents({
   captureManager, status, capturePath, language, aiDetectEnabled, setCourseMeta, onNotify,
-  streamingAsrActive, windowTitle,
+  streamingAsrActive, windowTitle, courseName,
 }: UseClassroomEventsOptions) {
   const [segments, setSegments] = useState<ExtractedSegment[]>([]);
   const [stats, setStats] = useState({ frames: 0, extracted: 0 });
@@ -105,6 +111,8 @@ export function useClassroomEvents({
   const transcriptSampleRef = useRef('');
   /** P1-7 指令补帧节流时间戳 */
   const lastForceCaptureAtRef = useRef(0);
+  /** P1-8 最近一次关键帧时间戳（漏捕检测依据：指令后无新帧即提示） */
+  const latestKeyframeTsRef = useRef(0);
   /** @ai-context 会话时间基准（epoch ms）：记录首帧 timestamp，供 analyzePartial 换算相对秒数 */
   const sessionStartMsRef = useRef<number | null>(null);
   /** 采集会话 ID（smart:keyframe 事件携带），供笔记持久化关联与关键帧图片清理 */
@@ -148,13 +156,20 @@ export function useClassroomEvents({
         console.info(`[useClassroomCapture] 内容类型识别: ${result.kind}（${result.source}）`);
       }
     }
-    // 指令句补帧（技能场景操作瞬间捕捉）
+    // 指令句补帧（技能场景操作瞬间捕捉）+ 漏捕检测
     if (hasCommandCue(text)) {
       const now = Date.now();
       if (now - lastForceCaptureAtRef.current >= FORCE_CAPTURE_MIN_INTERVAL_MS) {
         lastForceCaptureAtRef.current = now;
         captureManager.requestForceCapture();
       }
+      // P1-8 漏捕检测：指令后 3s 无新关键帧 → 提示手动补截
+      const commandAt = now;
+      window.setTimeout(() => {
+        if (latestKeyframeTsRef.current < commandAt) {
+          toast({ type: 'warning', silent: true, message: '这一步的画面可能没捕捉到，可按 C 键手动截图' });
+        }
+      }, MISSED_CAPTURE_CHECK_MS);
     }
   };
 
@@ -176,7 +191,7 @@ export function useClassroomEvents({
   useEffect(() => {
     const offCompleted = captureEventBus.on<{
       sessionId: string | null;
-      result: { text: string; confidence: number; source: 'vision' | 'audio' | 'ui_automation' };
+      result: { text: string; confidence: number; source: 'vision' | 'audio' | 'ui_automation'; structured?: Record<string, unknown> };
       segment: { id: string; timestamp: Date };
       extractedCount: number;
     }>('extraction:completed', (data) => {
@@ -190,6 +205,20 @@ export function useClassroomEvents({
       setSegments((prev) => [...prev, uiSegment]);
       setStats((prev) => ({ ...prev, extracted: data.extractedCount }));
       setExtractionError(null);
+
+      // P1-2 动态热词闭环：视觉提取的概念术语注入会话热词（弱 boost，
+      // 不持久化）；流式运行中同步更新主进程会话热词（下一断句生效）
+      if (data.result.source === 'vision') {
+        const concepts = data.result.structured?.concepts;
+        if (Array.isArray(concepts)) {
+          const terms = concepts.filter((c): c is string => typeof c === 'string');
+          if (terms.length > 0) {
+            addDynamicBoosts(terms);
+            window.electronAPI?.local_asr_stream_set_hotwords({ hotwords: getSessionHotwordsString() })
+              .catch(() => { /* 静默 */ });
+          }
+        }
+      }
     });
 
     const offError = captureEventBus.on<{ message: string }>(
@@ -209,6 +238,8 @@ export function useClassroomEvents({
         if (sessionStartMsRef.current === null) {
           sessionStartMsRef.current = data.keyframe.timestamp;
         }
+        // P1-8：更新最近关键帧时间戳（漏捕检测依据）
+        latestKeyframeTsRef.current = data.keyframe.timestamp;
         captureSessionIdRef.current = data.sessionId;
         setSmartBundle((prev) => ({
           ...prev,
@@ -512,7 +543,8 @@ export function useClassroomEvents({
     return off;
   }, [status, captureManager]);
 
-  // P1-2：转写编辑回调——修正直播转录文本，audioText 存修正后文本供下游消费
+  // P1-2：转写编辑回调——修正直播转录文本，audioText 存修正后文本供下游消费；
+  // P1-3：修正差异自动回写本地词库（replace 词条，课程维度绑定，下次识别生效）
   const handleEditTranscript = useCallback((id: string, newText: string) => {
     setLiveTranscripts((prev) =>
       prev.map((t) => (t.id === id ? { ...t, editedText: newText } : t)),
@@ -524,7 +556,32 @@ export function useClassroomEvents({
         s.id === id ? { ...s, audioText: newText, audioTextRaw: s.audioText } : s,
       ),
     }));
-  }, []);
+
+    // ── P1-3 修正回写（讯飞「用户修正回写」/飞书「改字同步」闭环）──
+    const original = liveTranscripts.find((t) => t.id === id)?.text ?? '';
+    const correction = extractCorrection(original, newText);
+    if (correction) {
+      // 会话内立即生效（后续转写应用替换）
+      addSessionReplace(correction.term, correction.target);
+      // 持久化词库（去重后写入；失败静默，不影响编辑结果）
+      hotwordStore.listForCourse(courseName).then((entries) => {
+        const exists = entries.some(
+          (e) => e.kind === 'replace' && e.term === correction.term && (e.target ?? '') === correction.target,
+        );
+        if (!exists) {
+          return hotwordStore.add({
+            term: correction.term,
+            target: correction.target,
+            kind: 'replace',
+            courseId: courseName,
+            enabled: true,
+          });
+        }
+        return null;
+      }).catch(() => { /* 词库写入失败静默 */ });
+      toast({ type: 'info', silent: true, message: `已记住修正：「${correction.term}」→「${correction.target}」` });
+    }
+  }, [liveTranscripts, courseName, toast]);
 
   return {
     segments, setSegments, stats, setStats, extractionError, setExtractionError,

client/src/features/classroom/pages/ClassroomPage.tsx

@@ -60,16 +60,22 @@ export default function ClassroomPage() {
     setShowNoteDialog(true);
   }, [capture]);
 
-  // M 快捷键：课中标记重点
-  const { handleBookmark } = capture;
+  // M 快捷键：课中标记重点；C 快捷键：手动补截当前画面（P1-8）
+  const { handleBookmark, handleManualCapture } = capture;
   const handleKeyDown = useCallback((e: KeyboardEvent) => {
     if (e.key === 'm' || e.key === 'M') {
       // 避免在输入框中触发
       const tag = (e.target as HTMLElement)?.tagName;
       if (tag === 'INPUT' || tag === 'TEXTAREA') return;
       handleBookmark();
     }
-  }, [handleBookmark]);
+    if (e.key === 'c' || e.key === 'C') {
+      // 避免在输入框中触发（快捷键截图同样跳过编辑态）
+      const tag = (e.target as HTMLElement)?.tagName;
+      if (tag === 'INPUT' || tag === 'TEXTAREA') return;
+      handleManualCapture();
+    }
+  }, [handleBookmark, handleManualCapture]);
 
   useEffect(() => {
     window.addEventListener('keydown', handleKeyDown);

client/src/features/classroom/utils/hotwordRuntime.ts

@@ -90,3 +90,15 @@ export function addDynamicBoosts(terms: string[]): void {
   if (cleaned.length === 0) return;
   activeBoosts = [...new Set([...activeBoosts, ...cleaned])].slice(0, 30);
 }
+
+/**
+ * P1-3：会话内立即生效的替换词条（用户修正回写）。
+ * 与持久化词库（hotwordStore）区分：仅当前会话生效（后续转写应用），
+ * 持久化由调用方写 hotwordStore；去重防止重复追加。
+ */
+export function addSessionReplace(term: string, target: string): void {
+  const t = term.trim();
+  if (!t || t.length > 20) return;
+  if (activeReplaces.some((r) => r.term === t && (r.target ?? '') === target)) return;
+  activeReplaces = [...activeReplaces, { term: t, target: target ?? '' }];
+}

client/src/features/classroom/utils/transcriptCorrection.test.ts

@@ -0,0 +1,45 @@
+/**
+ * extractCorrection 单元测试（P1-3 修正回写差异提取）
+ *
+ * @ai-context: 锁定差异提取契约：中段替换/词尾替换/删词；单字差异、
+ * 完全相同、超长片段、空输入不入库（返回 null）。
+ */
+import { describe, it, expect } from 'vitest';
+import { extractCorrection } from './transcriptCorrection';
+
+describe('extractCorrection', () => {
+  it('中段替换：错误词 → 正确词', () => {
+    expect(extractCorrection('特征值限量', '特征向量')).toEqual({ term: '值限', target: '向' });
+    expect(extractCorrection('梯度下减法', '梯度下降法')).toEqual({ term: '减', target: '降' });
+  });
+
+  it('词尾替换', () => {
+    expect(extractCorrection('特征值向量', '特征值分解')).toEqual({ term: '向量', target: '分解' });
+  });
+
+  it('删词（target 更短）', () => {
+    expect(extractCorrection('就是这样的一个', '就是这样')).toEqual({ term: '的一个', target: '' });
+  });
+
+  it('完全相同 → null', () => {
+    expect(extractCorrection('今天讲矩阵', '今天讲矩阵')).toBeNull();
+  });
+
+  it('单字错字纠正可入库（用户主动修正即强信号）', () => {
+    expect(extractCorrection('我们来看一下', '我们来看一看')).toEqual({ term: '下', target: '看' });
+  });
+
+  it('超长片段（>20 字）→ null（整句重写非词条修正）', () => {
+    expect(extractCorrection('一二三四五六七八九十甲乙丙丁戊己庚辛壬癸子丑寅卯', '完全不同的一整句内容长度超过二十个字符的改写')).toBeNull();
+  });
+
+  it('空输入 → null', () => {
+    expect(extractCorrection('', '内容')).toBeNull();
+    expect(extractCorrection('内容', '')).toBeNull();
+    expect(extractCorrection('', '')).toBeNull();
+  });
+
+  it('空白差异归一化（trim 后相同 → null）', () => {
+    expect(extractCorrection(' 今天讲矩阵 ', '今天讲矩阵')).toBeNull();
+  });
+});

client/src/features/classroom/utils/transcriptCorrection.ts

@@ -0,0 +1,51 @@
+/**
+ * 转写修正差异提取（P1-3 修正回写）
+ *
+ * @ai-context: 从「原始转写 → 用户修正文本」提取最小差异片段（公共前缀/
+ * 后缀剥离），生成 replace 词条（term=错误形态 → target=修正形态）写入
+ * 本地词库。单字差异不入库（误伤面大）；片段超长（>20 字）不入库（整句
+ * 重写不是词条修正，交给笔记层）。
+ * @ai-context EN: Minimal-diff extraction between original transcript and
+ * user correction (common prefix/suffix stripping) to produce a replace
+ * vocabulary entry. Single-char and over-long diffs are not persisted.
+ */
+
+export interface Correction {
+  /** 原文差异片段（ASR 错误形态） */
+  term: string;
+  /** 修正后片段（目标形态） */
+  target: string;
+}
+
+/**
+ * 提取修正词条。
+ * @returns 差异片段（term/target），无可入库差异时 null
+ */
+export function extractCorrection(original: string, corrected: string): Correction | null {
+  const a = (original ?? '').trim();
+  const b = (corrected ?? '').trim();
+  if (!a || !b || a === b) return null;
+
+  // 公共前缀
+  let prefix = 0;
+  const maxPrefix = Math.min(a.length, b.length);
+  while (prefix < maxPrefix && a[prefix] === b[prefix]) prefix++;
+
+  // 公共后缀（不与前缀重叠）
+  let suffix = 0;
+  const maxSuffix = Math.min(a.length - prefix, b.length - prefix);
+  while (
+    suffix < maxSuffix
+    && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]
+  ) suffix++;
+
+  const term = a.slice(prefix, a.length - suffix);
+  const target = b.slice(prefix, b.length - suffix);
+  // term 必须有内容；target 允许为空串（替换词条语义：删除误词）
+  if (!term) return null;
+  // 片段长度上限：整句重写不是词条修正
+  if (term.length > 20 || target.length > 20) return null;
+  // 单字差异允许入库：用户主动修正本身是强信号，单字错字纠正
+  // （如「减」→「降」）正是最高频的术语修正形态
+  return { term, target };
+}