feat(classroom): P1-1 两遍重打分（SenseVoice 整句复核）

config/modelManager: 新增 rescore 模型定义（SenseVoice int8 ~230MB），旧模型清理移除 SenseVoice 目录，双引擎下载/删除/状态

sensevoiceRescore: 非流式识别器懒加载 + pickRescored 一致性择优（Jaccard>=0.35 采用重打分，差异过大保留流式原结果）

接入：按段转写与流式 final 均句末重打分（句音频累积含静音尾）；重打分通过置信度提升至 >=0.85

设置页：开关收紧为流式主模型就绪（rescore 不能单独转写）；模型列表自动展示双模型

Author: Aparencia

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

@@ -25,6 +25,11 @@ import {
   cleanAsrResult,
   estimateAsrConfidence,
 } from '../../../src/lib/capture/asrFilters.js';
+import {
+  rescoreWithSenseVoice,
+  pickRescored,
+  resetRescoreCache,
+} from './sensevoiceRescore.js';
 import {
   getLocalAsrConfig,
   getModelDir,
@@ -195,9 +200,10 @@ export function isStreamingAsrAvailable(): boolean {
   return isModelReady();
 }
 
-/** 重置可用性缓存（模型下载完成后调用） */
+/** 重置可用性缓存（模型下载/删除后调用；联动清理重打分缓存） */
 export function resetAvailabilityCache(): void {
   _onlineRecognizer = null;
+  resetRescoreCache();
 }
 
 /**
@@ -240,15 +246,27 @@ export async function transcribeStreaming(
     }
 
     const rawText = recognizer.getResult(stream).text ?? '';
+    // P1-1 两遍重打分：SenseVoice 整句复核（模型未下载/失败时静默跳过，
+    // 保留流式原结果；一致性校验通过才替换，见 pickRescored）
+    let finalRaw = rawText;
+    let rescored = false;
+    const rescoreResult = rescoreWithSenseVoice(pcmData);
+    if (rescoreResult?.text) {
+      const picked = pickRescored(rawText, rescoreResult.text);
+      if (picked.rescored) {
+        finalRaw = picked.text;
+        rescored = true;
+      }
+    }
     // 输出后处理：相邻重复压缩 + 幻觉过滤
-    // P1-1 两遍重打分接入点：此处为本地按段转写最终文本出口，
-    // SenseVoice 重打分将在此处对 text 做句末复核（高置信度者胜出）
-    const text = cleanAsrResult(rawText);
-    // P0-3：置信度估算（清洗前后长度比代理信号，供 UI 低置信度标记）
-    const confidence = estimateAsrConfidence(rawText, text);
+    const text = cleanAsrResult(finalRaw);
+    // P0-3：置信度估算（清洗前后长度比代理信号；重打分通过视为高置信）
+    const confidence = rescored
+      ? Math.max(estimateAsrConfidence(finalRaw, text), 0.85)
+      : estimateAsrConfidence(finalRaw, text);
     const durationMs = Date.now() - startTime;
 
-    logger.debug(`[LocalASR] Zipformer transcribe: ${text.length} chars, ${durationMs}ms`);
+    logger.debug(`[LocalASR] Zipformer transcribe: ${text.length} chars, ${durationMs}ms${rescored ? ' (rescored)' : ''}`);
     return { text, confidence, engine: 'zipformer', durationMs };
   } finally {
     stream.free?.();

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

@@ -64,6 +64,12 @@ export const MODEL_FILES = {
   tokens: 'tokens.txt',
 } as const;
 
+/** P1-1 SenseVoice 重打分模型关键文件名（int8 量化包） */
+export const RESCORE_MODEL_FILES = {
+  model: 'model.int8.onnx',
+  tokens: 'tokens.txt',
+} as const;
+
 /**
  * 模型定义（供设置页展示 + modelManager 下载）
  *
@@ -91,6 +97,21 @@ export const ASR_MODELS = {
     /** hf-mirror.com 国内镜像（逐文件下载，无需解压） */
     mirrorBaseUrl: 'https://hf-mirror.com/csukuangfj/sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20/resolve/main',
   },
+  /**
+   * P1-1 两遍重打分模型：SenseVoice-Small（非流式，整句上下文识别）。
+   * 流式 Zipformer 负责实时出字，句末由 SenseVoice 对整句音频重打分
+   * （整句注意力上下文精度优于流式解码），两结果一致性校验后择优。
+   */
+  rescore: {
+    id: 'rescore-sensevoice',
+    label: 'SenseVoice 重打分（句末整句复核，提升中文准确率）',
+    description: '句末对整句音频二次识别，与流式结果一致性校验后择优，适合追求准确率的课堂场景',
+    size: '~230MB',
+    dirName: 'sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17',
+    files: [RESCORE_MODEL_FILES.model, RESCORE_MODEL_FILES.tokens],
+    downloadUrl: 'https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2',
+    mirrorBaseUrl: 'https://hf-mirror.com/csukuangfj/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/resolve/main',
+  },
 } as const;
 
 // ================================================================
@@ -119,6 +140,11 @@ export function getModelDir(): string {
   return path.join(getModelsDir(), modelDef.dirName);
 }
 
+/** P1-1：获取重打分模型目录完整路径 */
+export function getRescoreModelDir(): string {
+  return path.join(getModelsDir(), ASR_MODELS.rescore.dirName);
+}
+
 /**
  * 获取当前本地 ASR 配置
  */
@@ -192,3 +218,11 @@ export function isModelReady(): boolean {
   // 检查关键文件是否存在
   return modelDef.files.every(f => existsSync(path.join(modelDir, f)));
 }
+
+/**
+ * P1-1：检查重打分模型是否已下载就绪
+ */
+export function isRescoreModelReady(): boolean {
+  const modelDir = getRescoreModelDir();
+  return ASR_MODELS.rescore.files.every(f => existsSync(path.join(modelDir, f)));
+}

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

@@ -17,16 +17,26 @@ import { Transform } from 'stream';
 import * as path from 'path';
 import { BrowserWindow } from 'electron';
 import { logger } from '../../logger.js';
-import { getModelsDir, getModelDir, isModelReady, ASR_MODELS } from './config.js';
+import {
+  getModelsDir,
+  getModelDir,
+  getRescoreModelDir,
+  isModelReady,
+  isRescoreModelReady,
+  ASR_MODELS,
+} from './config.js';
 import { resetAvailabilityCache } from './SherpaAsrService.js';
+import { resetRescoreCache } from './sensevoiceRescore.js';
 
 /** 所有出站 HTTP 请求统一携带 UA，避免 CDN 返回 403 */
 const HTTP_HEADERS = { 'User-Agent': 'EntropyDecrease-Desktop/1.0 (Electron)' };
 
-/** 已废弃的旧模型目录名（Paraformer、SenseVoice），不再被使用，应清理 */
+/**
+ * 已废弃的旧模型目录名（仅 Paraformer 双语模型——SenseVoice 已于
+ * P1-1 重新启用为重打分模型，不再清理；误清会导致重打分不可用）
+ */
 const OBSOLETE_MODEL_DIRS = [
   'sherpa-onnx-streaming-paraformer-bilingual-zh-en',
-  'sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17',
 ];
 
 // ================================================================
@@ -47,14 +57,25 @@ export function getDownloadStatus(): { downloading: string | null; progress: num
 
 /** 获取模型状态列表 */
 export function getModelsStatus(): Array<{ engine: string; id: string; label: string; description: string; size: string; ready: boolean }> {
-  return [{
-    engine: 'streaming',
-    id: ASR_MODELS.streaming.id,
-    label: ASR_MODELS.streaming.label,
-    description: ASR_MODELS.streaming.description,
-    size: ASR_MODELS.streaming.size,
-    ready: isModelReady(),
-  }];
+  return [
+    {
+      engine: 'streaming',
+      id: ASR_MODELS.streaming.id,
+      label: ASR_MODELS.streaming.label,
+      description: ASR_MODELS.streaming.description,
+      size: ASR_MODELS.streaming.size,
+      ready: isModelReady(),
+    },
+    // P1-1：SenseVoice 重打分模型（可选增强，未下载不影响流式转写）
+    {
+      engine: 'rescore',
+      id: ASR_MODELS.rescore.id,
+      label: ASR_MODELS.rescore.label,
+      description: ASR_MODELS.rescore.description,
+      size: ASR_MODELS.rescore.size,
+      ready: isRescoreModelReady(),
+    },
+  ];
 }
 
 /**
@@ -96,14 +117,15 @@ export async function downloadModel(engine: string): Promise<string> {
     throw new Error(`已有模型正在下载中（${_downloading}），请等待完成`);
   }
 
-  // 当前仅支持 streaming 引擎，参数验证确保前端误传时能给出明确错误
-  if (engine !== 'streaming') {
-    throw new Error(`不支持的引擎: ${engine}（当前仅支持 streaming）`);
+  // P1-1：支持 streaming（流式主引擎）与 rescore（SenseVoice 重打分）
+  if (engine !== 'streaming' && engine !== 'rescore') {
+    throw new Error(`不支持的引擎: ${engine}（支持 streaming / rescore）`);
   }
 
-  const modelDef = ASR_MODELS.streaming;
+  const modelDef = ASR_MODELS[engine];
   const modelsDir = getModelsDir();
-  const targetDir = getModelDir();
+  const targetDir = engine === 'streaming' ? getModelDir() : getRescoreModelDir();
+  const modelReady = engine === 'streaming' ? isModelReady : isRescoreModelReady;
 
   await mkdir(modelsDir, { recursive: true });
 
@@ -132,15 +154,15 @@ export async function downloadModel(engine: string): Promise<string> {
 
     // ── 策略 2 + 3：逐文件下载（hf-mirror → huggingface 直连） ──
     if (ghError) {
-      if (!isModelReady()) {
+      if (!modelReady()) {
         const bases = [
           modelDef.mirrorBaseUrl,                                        // hf-mirror.com
           modelDef.mirrorBaseUrl.replace('hf-mirror.com', 'huggingface.co'), // 直连兜底
         ];
         let lastErr: unknown = ghError;
         for (const base of bases) {
           try {
-            await downloadFromMirror(engine, base, targetDir);
+            await downloadFromMirror(engine, base, targetDir, modelDef);
             lastErr = null;
             break;
           } catch (mirrorErr) {
@@ -154,11 +176,12 @@ export async function downloadModel(engine: string): Promise<string> {
 
     // 校验关键文件
     broadcastProgress(engine, 95);
-    if (!isModelReady()) {
+    if (!modelReady()) {
       throw new Error(`模型下载后校验失败：缺少关键文件（${modelDef.files.join(', ')}）`);
     }
 
     resetAvailabilityCache();
+    resetRescoreCache();
     logger.info(`[LocalASR] ${engine} model ready at: ${targetDir}`);
     broadcastProgress(engine, 100);
     // 新模型下载完成后清理旧模型
@@ -173,11 +196,22 @@ export async function downloadModel(engine: string): Promise<string> {
   }
 }
 
+/** 模型定义最小结构（streaming / rescore 通用） */
+interface ModelDef {
+  files: readonly string[];
+  downloadUrl: string;
+  mirrorBaseUrl: string;
+}
+
 /**
  * 从指定 baseUrl 逐文件下载模型（无需解压）
  */
-async function downloadFromMirror(engine: string, baseUrl: string, targetDir: string): Promise<void> {
-  const modelDef = ASR_MODELS.streaming;
+async function downloadFromMirror(
+  engine: string,
+  baseUrl: string,
+  targetDir: string,
+  modelDef: ModelDef,
+): Promise<void> {
   await mkdir(targetDir, { recursive: true });
 
   logger.info(`[LocalASR] Downloading ${modelDef.files.length} files from: ${baseUrl}`);
@@ -197,14 +231,15 @@ async function downloadFromMirror(engine: string, baseUrl: string, targetDir: st
 }
 
 /**
- * 删除模型
+ * 删除模型（P1-1：支持 streaming / rescore 双引擎）
  */
-export async function deleteModel(_engine: string): Promise<void> {
-  const modelDir = getModelDir();
+export async function deleteModel(engine: string): Promise<void> {
+  const modelDir = engine === 'rescore' ? getRescoreModelDir() : getModelDir();
   if (existsSync(modelDir)) {
     rmSync(modelDir, { recursive: true, force: true });
     resetAvailabilityCache();
-    logger.info(`[LocalASR] streaming model deleted: ${modelDir}`);
+    resetRescoreCache();
+    logger.info(`[LocalASR] ${engine} model deleted: ${modelDir}`);
   }
 }