fix(classroom): P0-4/P0-5/P0-6 离线ASR重复/CPU/准确率修复

P0-4: 端点规则调优（rule2 静音1.2s→2.0s、minUtteranceLength 8→10）+ 跨final重叠去重 + 跨标点两字词重复压缩（确认语白名单）+ flush尾句去重

P0-5: 线程数默认min(4,cpuCount)上限8 + 静音块隔块喂入 + 非16kHz前置阻断

P0-6: AI课程识别术语动态热词注入 + local_asr_stream_set_hotwords（下一断句重建流生效）+ P1-1重打分接入点标注

Author: Aparencia

client/electron/ai/local-asr/SherpaAsrService.ts

@@ -126,9 +126,10 @@ export function getOnlineRecognizer(): OnlineRecognizer | null {
   const modelDir = getModelDir();
   const config = getLocalAsrConfig();
   const cpuCount = Math.max(1, os.cpus().length);
-  const rawThreads = config.threads > 0 ? config.threads : Math.max(1, cpuCount - 1);
-  // 线程数上限：不超过 CPU 核心数（防止用户配置过大值导致 CPU 过载）
-  const threads = Math.min(rawThreads, cpuCount);
+  // P0-5 CPU 优化：默认 min(4, cpuCount)（zipformer 小模型线程扩展性差，
+  // 占满 CPU-1 线程是内测「离线 ASR CPU 100%」主因），用户配置硬上限 8
+  const rawThreads = config.threads > 0 ? config.threads : Math.min(4, cpuCount);
+  const threads = Math.min(rawThreads, 8);
 
   try {
     _onlineRecognizer = instantiateOnline(sherpa, {
@@ -151,10 +152,11 @@ export function getOnlineRecognizer(): OnlineRecognizer | null {
       enableEndpoint: true,
       endpointConfig: {
         rule1: { minTrailingSilence: 2.4 },
-        // rule2 必须配 minUtteranceLength：仅给 minTrailingSilence 时默认 0，
-        // 等于"1.2s 停顿即断句"——中文口语停顿频繁，短句被切碎会导致
-        // 相邻句边界词重复观感。8s 覆盖绝大多数短句，兼顾实时性
-        rule2: { minTrailingSilence: 1.2, minUtteranceLength: 8 },
+        // P0-4 重复修复：rule2 静音 1.2s→2.0s、minUtteranceLength 8→10——
+        // 中文口语句内停顿普遍 1-2s，1.2s 阈值误断句会把同一句切成两段、
+        // 段首重复段尾（内测「识别偶发重复」主要来源）；2.0s 覆盖绝大多数
+        // 句内停顿，minUtteranceLength=10 保证短句不被切碎
+        rule2: { minTrailingSilence: 2.0, minUtteranceLength: 10 },
         rule3: { minUtteranceLength: 20 },
       },
     });
@@ -236,6 +238,8 @@ export async function transcribeStreaming(
 
     const result = recognizer.getResult(stream);
     // 输出后处理：相邻重复压缩 + 幻觉过滤
+    // P1-1 两遍重打分接入点：此处为本地按段转写最终文本出口，
+    // SenseVoice 重打分将在此处对 text 做句末复核（高置信度者胜出）
     const text = cleanAsrResult(result.text ?? '');
     const durationMs = Date.now() - startTime;
 
@@ -259,9 +263,11 @@ export async function transcribeLocal(
   const config = getLocalAsrConfig();
   const language = options?.language ?? config.language;
 
-  // 防御性校验：非 16kHz 采样率会严重降低识别质量
+  // P0-5 前置阻断：非 16kHz 采样率会严重降低识别质量（模型按 16k 训练），
+  // 此前仅 warn 放行——内测「离线 ASR 识别不准确」的隐性来源之一。
+  // 此处直接拒绝，渲染进程在采集启动前亦有前置校验（asrTranscriber）
   if (options?.sampleRate && options.sampleRate !== 16000) {
-    logger.warn(`[LocalASR] 非预期采样率: ${options.sampleRate}Hz，本地 ASR 要求 16kHz 单声道 Float32 PCM`);
+    throw new Error(`本地 ASR 要求 16kHz 单声道 Float32 PCM，收到 ${options.sampleRate}Hz`);
   }
 
   // base64 → Float32Array

client/electron/ai/local-asr/index.ts

@@ -29,6 +29,7 @@ import {
 import {
   startStreamingAsr,
   stopStreamingAsr,
+  updateStreamingHotwords,
 } from './streamingAsr.js';
 import {
   downloadModel,
@@ -108,6 +109,16 @@ export function registerLocalAsrHandlers(): void {
     return { success: true };
   });
 
+  // P0-6：会话热词动态更新——课程识别成功后渲染进程调用，
+  // 下一个端点断句时以最新热词重建流（无需重启、不丢当前句）
+  safeHandle(
+    'local_asr_stream_set_hotwords',
+    async (_event, args: { hotwords?: string }) => {
+      updateStreamingHotwords(args?.hotwords);
+      return { success: true };
+    },
+  );
+
   // ── 模型管理 ──
   safeHandle('local_asr_get_models', async () => {
     return {

client/electron/ai/local-asr/streamingAsr.ts

@@ -12,11 +12,17 @@
 
 import type { BrowserWindow } from 'electron';
 import { logger } from '../../logger.js';
-import { cleanAsrResult } from '../../../src/lib/capture/asrFilters.js';
+import { cleanAsrResult, computeRms, SILENCE_RMS_THRESHOLD } from '../../../src/lib/capture/asrFilters.js';
 import { getOnlineRecognizer, feedWaveform, type OnlineStream } from './SherpaAsrService.js';
 
 /** partial 推送节流：两次 partial 推送的最小间隔（ms） */
 const PARTIAL_EMIT_INTERVAL_MS = 150;
+/**
+ * P0-5 CPU 优化：静音块隔块喂入——静音期模型反复 decode 无新内容却持续
+ * 消耗 CPU，每隔 1 个静音块喂 1 次（端点检测延迟最多增加一个采集块粒度，
+ * 可接受）；非静音块全部喂入保证识别实时性。
+ */
+const SILENT_FEED_SKIP_COUNT = 1;
 
 // ================================================================
 // 单例状态
@@ -28,6 +34,16 @@ let _sampleRate = 16000;
 /** 当前已识别文本（用于变化检测，reset 后清空） */
 let _lastPartialText = '';
 let _lastPartialEmitAt = 0;
+/**
+ * 会话级最新热词（P0-6）：渲染进程课程识别成功后经
+ * local_asr_stream_set_hotwords 更新；每个端点断句后以最新热词重建流
+ * （createStream(hotwords)），无需重启即可让新词条生效。
+ */
+let _latestHotwords: string | undefined;
+/** 最近一次推送的 final 文本（停止 flush 时与尾句去重） */
+let _lastFinalText = '';
+/** 静音块跳过计数（隔块喂入，P0-5） */
+let _silentSkipCounter = 0;
 
 /** 流式 ASR 是否激活 */
 export function isStreamingActive(): boolean {
@@ -66,11 +82,14 @@ export function startStreamingAsr(
 
   try {
     // 透传热词增强字符串（zipformer-transducer 支持 createStream(hotwords)）
+    _latestHotwords = hotwords;
     _stream = recognizer.createStream(hotwords);
     _win = win;
     _sampleRate = sampleRate;
     _lastPartialText = '';
     _lastPartialEmitAt = 0;
+    _lastFinalText = '';
+    _silentSkipCounter = 0;
     logger.info(`[StreamingASR] 已启动 (sampleRate=${sampleRate}${hotwords ? `, hotwords=${hotwords}` : ''})`);
     return { success: true, sampleRate };
   } catch (err) {
@@ -80,6 +99,15 @@ export function startStreamingAsr(
   }
 }
 
+/**
+ * 更新会话热词（P0-6）：渲染进程课程识别成功后调用。
+ * 不立即重启流（会丢当前句），在下一个端点断句时以最新热词重建流生效。
+ */
+export function updateStreamingHotwords(hotwords: string | undefined): void {
+  _latestHotwords = hotwords;
+  logger.info(`[StreamingASR] 热词已更新，将在下一断句生效${hotwords ? ` (${hotwords.length} chars)` : ''}`);
+}
+
 /**
  * 喂入一个音频块（Float32 PCM，16k 单声道）：解码并推送 partial / final。
  *
@@ -100,18 +128,30 @@ export function feedStreamingAsr(audioBuffer: ArrayBuffer, sampleRate?: number):
   if (samples.length === 0) return;
   const rate = sampleRate ?? _sampleRate;
 
+  // P0-5 静音隔块喂入：静音块每隔 1 块喂 1 次（端点检测延迟 +1 块粒度），
+  // 降低静音期（课堂大部分时间）无效 decode 的 CPU 占用
+  if (computeRms(audioBuffer) < SILENCE_RMS_THRESHOLD) {
+    _silentSkipCounter++;
+    if (_silentSkipCounter <= SILENT_FEED_SKIP_COUNT) return;
+    _silentSkipCounter = 0;
+  } else {
+    _silentSkipCounter = 0;
+  }
+
   try {
     // 统一适配层：新旧版 sherpa-onnx-node 的 acceptWaveform 签名不同
     feedWaveform(_stream, rate, samples);
     while (recognizer.isReady(_stream)) {
       recognizer.decode(_stream);
     }
 
-    // 端点检测：断句 → 推送 final 并 reset
+    // 端点检测：断句 → 推送 final 并以最新热词重建流（P0-6 热词生效点）
     if (recognizer.isEndpoint(_stream)) {
       // 输出后处理：相邻重复压缩 + 幻觉过滤（静音段重复输出防护）
       const finalText = cleanAsrResult(recognizer.getResult(_stream).text ?? '');
-      recognizer.reset(_stream);
+      _lastFinalText = finalText;
+      // 重建流：以会话最新热词 createStream（热词变化无需重启即可生效）
+      _stream = recognizer.createStream(_latestHotwords);
       _lastPartialText = '';
       _lastPartialEmitAt = 0;
       if (finalText) {
@@ -153,7 +193,9 @@ export function stopStreamingAsr(): void {
         const tailText = recognizer
           ? cleanAsrResult(recognizer.getResult(_stream).text ?? '')
           : '';
-        if (tailText) {
+        // P0-4 flush 去重：尾句与最近一次 final 完全一致时不再推送
+        // （端点已推送过该句，flush 重复上屏是停止瞬间重复的兜底场景）
+        if (tailText && tailText !== _lastFinalText) {
           emit('asr_stream_final', { text: tailText, timestamp: Date.now() });
         }
       }
@@ -167,5 +209,7 @@ export function stopStreamingAsr(): void {
   _win = null;
   _lastPartialText = '';
   _lastPartialEmitAt = 0;
+  _lastFinalText = '';
+  _silentSkipCounter = 0;
   logger.info('[StreamingASR] 已停止');
 }

client/electron/preload.ts

@@ -132,6 +132,8 @@ const ALLOWED_CHANNELS = [
   'local_asr_stream_available',
   'local_asr_stream_start',
   'local_asr_stream_stop',
+  // 本地 ASR 流式会话热词动态更新（P0-6）
+  'local_asr_stream_set_hotwords',
   // 本地 Silero VAD（主进程 onnxruntime 推理，P0-2）
   'vad_silero_process',
   // MCP 学习记忆服务器应用内授权开关

client/src/env.d.ts

@@ -97,6 +97,8 @@ declare global {
       audio_capture_start: (options: { microphone: boolean; chunkDurationMs?: number; sampleRate?: number; channels?: number }) => Promise<{ success: boolean; error?: string }>;
       local_asr_stream_start: (options: { sampleRate?: number }) => Promise<{ success: boolean; error?: string }>;
       local_asr_stream_stop: () => Promise<{ success: boolean }>;
+      /** P0-6: 会话热词动态更新（课程识别成功后调用，下一断句生效） */
+      local_asr_stream_set_hotwords: (args: { hotwords?: string }) => Promise<{ success: boolean }>;
       audio_capture_stop: () => Promise<{ success: boolean }>;
       /** P0-2: 本地 Silero VAD 推理（主进程 onnxruntime，16kHz Float32 PCM 块） */
       vad_silero_process: (args: { samples: ArrayBuffer; sampleRate?: number; reset?: boolean }) => Promise<{ probability: number | null; available: boolean }>;

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

@@ -33,8 +33,8 @@ 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 } from '../utils/hotwordRuntime';
-import { cleanAsrResult } from '@/lib/capture/asrFilters';
+import { applySessionReplaces, getSessionHotwordsString, addDynamicBoosts } from '../utils/hotwordRuntime';
+import { cleanAsrResult, dedupeAcrossFinals } from '@/lib/capture/asrFilters';
 
 /** 触发一次增量分析所需的关键帧数 */
 const INCREMENTAL_BATCH_SIZE = 5;
@@ -94,6 +94,8 @@ export function useClassroomEvents({
   /** 真流式激活标志的 ref 桥接：供按段转写订阅器读取（避免重订阅） */
   const streamingAsrActiveRef = useRef(streamingAsrActive);
   streamingAsrActiveRef.current = streamingAsrActive;
+  /** P0-4 跨 final 去重：上一 final 清洗后文本（端点误断句时前句尾=后句头） */
+  const lastFinalTextRef = useRef('');
   /** 会话状态 ref 桥接：流式 partial/final 仅在 capturing 时上屏（暂停时不更新） */
   const statusRef = useRef(status);
   statusRef.current = status;
@@ -173,6 +175,15 @@ export function useClassroomEvents({
             .then((detected) => {
               if (detected) {
                 setCourseMeta((prev) => ({ ...prev, ...detected, detectedBy: 'ai' }));
+                // P0-6 准确率即时提升：识别出的术语注入动态热词
+                // （课程名/学科/建议术语），并通知主进程流式 ASR 更新
+                // 会话热词（下一断句重建流生效，无需重启、不丢当前句）
+                if (detected.customTerms?.length) {
+                  addDynamicBoosts(detected.customTerms);
+                  const hotwords = getSessionHotwordsString();
+                  window.electronAPI?.local_asr_stream_set_hotwords({ hotwords })
+                    .catch(() => { /* 静默：热词更新失败不阻断识别 */ });
+                }
               }
             })
             .catch(() => { /* 静默降级到规则模式 */ });
@@ -321,7 +332,12 @@ export function useClassroomEvents({
       const data = args[0] as { text: string; timestamp: number };
       setPartialText('');
       // 双保险：主进程已 clean，此处兜底云端/旧版本主进程的未清洗输出
-      const text = cleanAsrResult(data?.text ?? '');
+      const cleaned = cleanAsrResult(data?.text ?? '');
+      if (!cleaned) return;
+      // P0-4 跨 final 重叠去重：端点误断句时前句尾词重复出现在后句开头
+      // （"今天讲矩阵"+"矩阵的特征值"），去重截断后句重叠前缀
+      const text = dedupeAcrossFinals(lastFinalTextRef.current, cleaned);
+      lastFinalTextRef.current = text || lastFinalTextRef.current;
       if (!text) return;
       const id = crypto.randomUUID();
       const timestamp = data.timestamp || Date.now();

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

@@ -73,3 +73,20 @@ export function getSessionHotwordsString(): string {
   const joined = activeBoosts.join(' ');
   return joined.length > 200 ? joined.slice(0, 200) : joined;
 }
+
+/**
+ * P0-6：动态注入课程热词（AI 课程识别成功后调用）。
+ * 与用户静态词表（hotwordStore）区分：动态词不持久化、会话结束清空；
+ * 去重 + 上限保护（30 条），防止 AI 识别返回超长术语表撑爆 200 字符热词串。
+ */
+export function addDynamicBoosts(terms: string[]): void {
+  const cleaned = [
+    ...new Set(
+      (terms ?? [])
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0 && t.length <= 20),
+    ),
+  ];
+  if (cleaned.length === 0) return;
+  activeBoosts = [...new Set([...activeBoosts, ...cleaned])].slice(0, 30);
+}

client/src/lib/capture/asrFilters.test.ts

@@ -10,6 +10,7 @@ import {
   isLikelyHallucination,
   collapseAdjacentDuplicates,
   cleanAsrResult,
+  dedupeAcrossFinals,
   SILENCE_RMS_THRESHOLD,
 } from './asrFilters';
 
@@ -79,10 +80,20 @@ describe('collapseAdjacentDuplicates', () => {
     expect(collapseAdjacentDuplicates('这个知识点知识点很重要')).toBe('这个知识点很重要');
   });
 
-  it('标点分隔的重复不压缩（真实语言确认语："对，对""好，好"）', () => {
+  it('标点分隔的单字确认语不压缩（真实语言："对，对""好，好"）', () => {
     expect(collapseAdjacentDuplicates('对，对，你说得对')).toBe('对，对，你说得对');
     expect(collapseAdjacentDuplicates('好，好，我知道了')).toBe('好，好，我知道了');
-    expect(collapseAdjacentDuplicates('就是，就是，那这样吧')).toBe('就是，就是，那这样吧');
+  });
+
+  it('形态 3（P0-4）：跨单个标点的两字词重复压缩（"就是，就是"→"就是"）', () => {
+    expect(collapseAdjacentDuplicates('就是，就是')).toBe('就是');
+    expect(collapseAdjacentDuplicates('就是，就是，那这样吧')).toBe('就是，那这样吧');
+    expect(collapseAdjacentDuplicates('矩阵，矩阵的特征值')).toBe('矩阵的特征值');
+  });
+
+  it('形态 3 白名单：两字确认语不压缩（"是的，是的"是真实确认强调）', () => {
+    expect(collapseAdjacentDuplicates('是的，是的')).toBe('是的，是的');
+    expect(collapseAdjacentDuplicates('好的，好的')).toBe('好的，好的');
   });
 
   it('正常文本不受影响', () => {
@@ -125,3 +136,29 @@ describe('cleanAsrResult', () => {
     expect(cleanAsrResult('软腭和咽部肌肉松弛导致气流受阻')).toBe('软腭和咽部肌肉松弛导致气流受阻');
   });
 });
+
+describe('dedupeAcrossFinals（P0-4 跨 final 重叠去重）', () => {
+  it('完全一致的重复推送丢弃', () => {
+    expect(dedupeAcrossFinals('今天讲矩阵', '今天讲矩阵')).toBe('');
+  });
+
+  it('后缀-前缀重叠截断（端点误断句："…矩阵"+"矩阵的特征值…"）', () => {
+    expect(dedupeAcrossFinals('今天讲矩阵', '矩阵的特征值很重要')).toBe('的特征值很重要');
+    expect(dedupeAcrossFinals('特征值', '特征值和特征向量')).toBe('和特征向量');
+  });
+
+  it('单字重叠（长度 1）不截断——避免误伤正常连接', () => {
+    expect(dedupeAcrossFinals('我们开始', '始解这个问题')).toBe('始解这个问题');
+  });
+
+  it('截断后与前句高度相似视为整体重复丢弃', () => {
+    expect(dedupeAcrossFinals('矩阵的特征值', '矩阵的特征值矩阵的特征值')).toBe('');
+    expect(dedupeAcrossFinals('线性代数很重要', '线性代数很重要线性代数很重要')).toBe('');
+  });
+
+  it('无重叠时原样返回', () => {
+    expect(dedupeAcrossFinals('今天讲矩阵', '接下来看特征值')).toBe('接下来看特征值');
+    expect(dedupeAcrossFinals('', '新句子')).toBe('新句子');
+    expect(dedupeAcrossFinals('前句', '')).toBe('');
+  });
+});