dsh-deepmoyu 2.7.1 → 2.7.2

package/lib/asr.py

@@ -18,6 +18,7 @@ import argparse
 import os
 import re
 import sys
+import time
 import uuid
 
 # ⚠️ 临时目录必须待在家目录里：值班那一轮跑在沙箱里（只允许写工作区/cwd），
@@ -56,6 +57,25 @@ def cleanup_download(tmp: str, tag: str) -> None:
         pass
 
 
+def sweep_stale_downloads(tmp: str = _TMP, max_age_hours: float = 24.0) -> None:
+    """P3-33: 异常中断（进程被杀/断电）会留下 tag.* 碎片，且只有成功路径会清 ——
+    启动时把 tmp/asr 下超过 24h 的下载碎片一并回收（当前这次的文件是新的，不受影响）。"""
+    cutoff = time.time() - max_age_hours * 3600
+    try:
+        with os.scandir(tmp) as entries:
+            for entry in entries:
+                try:
+                    # 只回收普通文件与失效链接，目录一律不碰；删不掉就留给下一次。
+                    if not (entry.is_file(follow_symlinks=False) or entry.is_symlink()):
+                        continue
+                    if entry.stat(follow_symlinks=False).st_mtime < cutoff:
+                        os.remove(entry.path)
+                except OSError:
+                    pass
+    except OSError:
+        pass
+
+
 def to_url(target: str) -> str:
     t = target.strip()
     if t.upper().startswith('BV') and len(t) <= 20:
@@ -99,6 +119,8 @@ def main() -> int:
     ap.add_argument('--lang', default='zh', help='语言（默认 zh；不给就自动判断请传 auto）')
     args = ap.parse_args()
     prepare_runtime()
+    # P3-33: 每次启动顺手清扫超龄碎片（只在真的要下载时才需要目录，清扫本身静默失败无妨）
+    sweep_stale_downloads()
 
     src = args.target
     # ⚠️ 不用 mkdtemp：沙箱只允许写"子进程启动前就存在"的目录，新建的会被拒 ✗

package/lib/favops.py

@@ -11,6 +11,14 @@ import os
 import re
 import sys
 
+# P3-31: Windows 管道默认 GBK —— 错误 JSON 里的中文/emoji 会把 print 打挂
+#（UnicodeEncodeError 连 JSON 都出不来），先钉 UTF-8 + replace（写法照 lib/pv.py:41-46）
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 # 凭证找两处：优先**当前工作目录**（宿主 spawn 时 cwd = 插件家，凭证就在那儿），
@@ -23,10 +31,32 @@ CRED_FILE = next((p for p in CRED_CANDIDATES if os.path.exists(p)), CRED_CANDIDA
 
 
 def out(obj):
+    # P3-31: stdout 已钉 utf-8 + errors="replace"，任何字符都出得去，不再 UnicodeEncodeError
     print(json.dumps(obj, ensure_ascii=False))
     sys.exit(0)
 
 
+def _classify(error):
+    """P3-32: 错误分类 —— code 取 bilibili_api 异常自带的 API code（ResponseCodeException.code），
+    kind 让宿主分得清「要重扫码」（auth = -101/-111）、「等风控」（risk = 412/-352）、
+    「已经收藏过」（dup，幂等成功）和其余失败（unknown）。"""
+    code = getattr(error, 'code', None)
+    try:
+        code = int(code) if code is not None else None
+    except (TypeError, ValueError):
+        code = None
+    msg = str(error)
+    if code in (-101, -111):
+        kind = 'auth'
+    elif code in (412, -352):
+        kind = 'risk'
+    elif '已经' in msg or 'already' in msg.lower():
+        kind = 'dup'
+    else:
+        kind = 'unknown'
+    return code, kind, msg
+
+
 def load():
     from bilibili_api import Credential
     if not os.path.exists(CRED_FILE):
@@ -65,11 +95,11 @@ async def add(bvid, fid):
     try:
         await favorite_list.FavoriteListResource(aid, type_=2, credential=cred).add(fid)
     except Exception as error:  # noqa: BLE001
-        msg = str(error)
-        # 已经收藏过不算失败
-        if '已经' in msg or 'already' in msg.lower():
-            out({'ok': True, 'already': True})
-        out({'ok': False, 'error': msg[:200]})
+        code, kind, msg = _classify(error)
+        # 已经收藏过不算失败：幂等判断保留子串兜底，但优先按 code 分好的类走
+        if kind == 'dup':
+            out({'ok': True, 'already': True, 'code': code, 'kind': kind})
+        out({'ok': False, 'error': msg[:200], 'code': code, 'kind': kind})
     out({'ok': True})
 
 
@@ -87,7 +117,9 @@ def main():
         else:
             out({'ok': False, 'error': '子命令不认识：' + ' '.join(args)})
     except Exception as error:  # noqa: BLE001
-        out({'ok': False, 'error': str(error)[:300]})
+        # P3-32: 兜底出口同样带 code/kind，宿主不用再猜错误文本
+        code, kind, msg = _classify(error)
+        out({'ok': False, 'error': msg[:300], 'code': code, 'kind': kind})
 
 
 if __name__ == '__main__':

package/lib/learn-review.mjs

@@ -40,6 +40,11 @@ export function buildLearningReviewPrompt(items, { tokenBudget = 12000 } = {}) {
 export function learningReviewRetryAllowed(previous = {}, { batchKey, model = '', now = Date.now() } = {}) {
   const last = Number(previous.lastAttemptAt) || 0
   if (now - last < 180_000) return false
+  /* 审计 P3-11（2026-11-12）：人工停止（stopReason='user'）以前与错误同样进退避——
+   * 180 秒后 automationTick 又把同一批拉起来，"点了停止"实际停不住。现在同一批
+   * （batchKey+model 都没变）被人工停过就不再自动重启；队列内容变化（batchKey 变）
+   * 或换了模型才算新任务。手动 startLearningReview('manual') 不走这里，不受影响。 */
+  if (previous.userStop && previous.userStop.batchKey === batchKey && String(previous.userStop.model || '') === model) return false
   if (previous.batchKey !== batchKey || String(previous.model || '') !== model) return true
   return now >= (Number(previous.nextRetryAt) || last + 180_000)
 }
@@ -55,7 +60,12 @@ export function summarizeLearningReview(items, ledger, { code, error = '', stopR
   const failures = complete ? 0 : (same ? Number(previous.failures) || 0 : 0) + 1
   const delay = Math.min(30 * 60_000, 180_000 * 2 ** Math.min(4, Math.max(0, failures - 1)))
   const lastError = redactRecordText(error || (stopReason ? `审核已停止：${stopReason}` : code !== 0 ? `审核进程退出码 ${code}` : remaining ? `进程已退出，但本批仍有 ${remaining} 条未审核；已保留待审，稍后重试` : ''), { maxLength: 800 })
-  return { approved, rejected, remaining, complete, failures, nextRetryAt: complete ? 0 : now + delay, lastError }
+  // 审计 P3-11：人工停止记下本批指纹（batchKey+model），同批不再被 automationTick 自动重拉；
+  // 非人工停止时若本批没变，沿用之前的 userStop 标记（一次人工停止对同一批持续有效）。
+  const userStop = stopReason === 'user'
+    ? { batchKey, model }
+    : (previous.userStop && previous.userStop.batchKey === batchKey ? previous.userStop : undefined)
+  return { approved, rejected, remaining, complete, failures, nextRetryAt: complete ? 0 : now + delay, lastError, userStop }
 }
 
 export function decideLearningReview(ledger, batch, args = {}) {

package/lib/login.mjs

@@ -15,7 +15,7 @@
  * ============================================================================
  */
 import { spawn } from 'node:child_process'
-import { existsSync, mkdirSync } from 'node:fs'
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { atomicWriteFileSync } from './record-storage.mjs'
 import { randomUUID } from 'node:crypto'
@@ -93,14 +93,31 @@ export function saveCredential(stateDir, credential) {
 
 /** 用 Python 的 qrcode 画一张 PNG，返回**文件路径**（拿不到就返回 null）
  *  ⭐ 2026-10-26：加 20 秒超时 —— python 挂住时（"既不起来也不退出"）这个 Promise 以前永远不 settle，
- *    `/login/start` 那个 HTTP 请求就永远挂着（probeCmd 那批同型问题修过，这里漏了）。 */
+ *    `/login/start` 那个 HTTP 请求就永远挂着（probeCmd 那批同型问题修过，这里漏了）。
+ *  审计 P3-13（2026-11-12）：失败/超时以前不清理半成品 PNG，成功路径也没人删——
+ *    每次登录尝试都在家目录留一个 qrcode_login.*.png（key 一次性且 180s 过期，无安全风险，纯卫生）。
+ *    现在失败即删；每次出码顺手清掉 24h 前的旧文件。 */
 export function renderQrPng(pythonPath, stateDir, url, { timeoutMs = 20_000 } = {}) {
   return new Promise((resolve) => {
     const png = join(stateDir, `qrcode_login.${process.pid}.${randomUUID()}.png`)
+    try {
+      const cutoff = Date.now() - 24 * 3600_000
+      for (const entry of readdirSync(stateDir)) {
+        if (!/^qrcode_login\..+\.png$/.test(entry)) continue
+        const old = join(stateDir, entry)
+        try { if (statSync(old).mtimeMs < cutoff) rmSync(old, { force: true }) } catch { /* 占用中就留给下次 */ }
+      }
+    } catch { /* 扫不了目录就算了 */ }
     const code = 'import sys, qrcode; qrcode.make(sys.argv[1]).save(sys.argv[2])'
     let child
     let settled = false
-    const finish = (v) => { if (!settled) { settled = true; clearTimeout(timer); resolve(v) } }
+    const finish = (v) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (!v) { try { rmSync(png, { force: true }) } catch { /* 半成品也留给 24h 清扫 */ } }
+      resolve(v)
+    }
     const timer = setTimeout(() => {
       try { child?.kill('SIGKILL') } catch { /* 已经没了 */ }
       finish(null)

package/lib/mirror.mjs

@@ -44,8 +44,22 @@ export function resolveMirrorDir(stateDir, explicit = '') {
   return ''
 }
 
+/** 审计 P3-9（2026-11-12）：state.json 镜像里 `sendReview[].args.text`（bili_dm_reply）
+ *  是待审私信的明文正文——活动流水对私信整行剔除，镜像却原样带走，两处口径不一致。
+ *  镜像定位是"脱敏的只读副本"，这里对齐：DM 待审正文以占位符替换，其余字段照常。 */
+function stripPendingDmText(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const rows = Array.isArray(value.sendReview) ? value.sendReview : null
+  if (!rows) return value
+  return { ...value, sendReview: rows.map((row) => {
+    if (!row || typeof row !== 'object' || row.tool !== 'bili_dm_reply') return row
+    if (!row.args || typeof row.args !== 'object' || typeof row.args.text !== 'string') return row
+    return { ...row, args: { ...row.args, text: '[私信正文已隐去——待审私信不进镜像]' } }
+  }) }
+}
+
 function mirrorText(fromDir, name, source) {
-  if (name.endsWith('.json')) return JSON.stringify(sanitizeRecord(JSON.parse(source), { maxKeys: 10000, maxLength: 16000, maxDepth: 10 }), null, 2) + '\n'
+  if (name.endsWith('.json')) return JSON.stringify(sanitizeRecord(stripPendingDmText(JSON.parse(source)), { maxKeys: 10000, maxLength: 16000, maxDepth: 10 }), null, 2) + '\n'
   if (name === 'activity.jsonl') {
     const tail = readActivityTail(fromDir, { maxBytes: MIRROR_MAX_BYTES, limit: 5000 })
     if (tail.truncated) throw new Error('MIRROR_ACTIVITY_NEEDS_ROTATION')

package/lib/model-relay.mjs

@@ -1,7 +1,7 @@
 /** Local, per-run capability bridge to the parent's already configured LLM adapters.
  * No credentials/profile copies, no route fallback, no public web endpoint. */
 import { createServer } from 'node:http'
-import { randomBytes, timingSafeEqual } from 'node:crypto'
+import { randomBytes } from 'node:crypto'
 import { once } from 'node:events'
 import { redactRecordText } from './record-privacy.mjs'
 import { summarizeBackgroundDiagnostic } from './background-output.mjs'
@@ -56,8 +56,12 @@ export function createModelRelay({ getLlm, onError } = {}) {
     // No browser origins, CORS or ambient cookie auth. Each child gets a revocable capability.
     if (req.method !== 'POST' || req.url !== '/call' || req.headers.origin) return jsonReply(res, 403, { error: { code: 'RELAY_FORBIDDEN', message: '模型桥接拒绝此请求' } })
     const token = String(req.headers.authorization || '').replace(/^Bearer /, '')
+    /* 审计 P3-25（2026-11-12）：`grants.get(token)` 本身就是按 token 精确匹配——命中后
+     * 再 timingSafeEqual 比较的两个 buffer 恒等，这段比较从不起作用（错误长度的 token
+     * 走 `!grant` → 403 短路）。Map 键比较在此处是时间安全的（V8 字符串哈希桶查找，
+     * 键只在本进程内生成且不可枚举），直接删除冗余比较并留注说明。 */
     const grant = grants.get(token)
-    if (!grant || !timingSafeEqual(Buffer.from(token), Buffer.from(grant.token)) || Date.now() >= grant.expiresAt) return jsonReply(res, 403, { error: { code: 'RELAY_EXPIRED', message: '后台模型凭据已撤销或过期，请重新开跑' } })
+    if (!grant || Date.now() >= grant.expiresAt) return jsonReply(res, 403, { error: { code: 'RELAY_EXPIRED', message: '后台模型凭据已撤销或过期，请重新开跑' } })
     const abort = new AbortController()
     grant.controllers.add(abort)
     const disconnected = () => { if (!res.writableEnded) abort.abort() }

package/lib/persona.mjs

@@ -170,7 +170,9 @@ export function ensureSoul(stateDir, log = () => {}) {
   const file = soulFileOf(stateDir)
   try {
     if (existsSync(file)) return false
-    writeFileSync(file, soulTemplate(), 'utf8')
+    // 审计 P3-18（2026-11-12）：初始铺模板也走原子写——裸 write 半篇留档会被 existsSync
+    // 永久当成"用户写过"，残缺模板就再也修不回来了。
+    atomicWriteFileSync(file, soulTemplate(), 'utf8')
     log(`已铺好：${file}`)
     return true
   } catch (e) {

package/lib/pet-session.mjs

@@ -62,10 +62,16 @@ function inheritPermissions(ctx, source, target) {
   if (source.sandbox && source.sandbox !== before.sandbox) target.append('sandbox/mode', { mode: source.sandbox })
   if (source.approval && source.approval !== before.approval) target.append('approval/policy', { policy: source.approval })
   const after = permissionsOf(ctx, target)
-  for (const key of ['sandbox', 'approval']) if (source[key] && after[key] && after[key] !== source[key]) {
-    throw new Error(`会话已创建，但 ${key} 权限继承未生效；请手动检查该会话权限`)
+  // 审计 P3-22（2026-11-12）：读回为 undefined（宿主缺 sessionProjections 等服务）时，
+  // 以前整个校验被跳过却返回"继承成功"——append 发出了但未经读回验证。现在把这种
+  // 情况显式标成 unverified，由调用方（HTTP 回执/日志）如实呈现。
+  let unverified = false
+  for (const key of ['sandbox', 'approval']) {
+    if (!source[key]) continue
+    if (after[key] === undefined) { unverified = true; continue }
+    if (after[key] !== source[key]) throw new Error(`会话已创建，但 ${key} 权限继承未生效；请手动检查该会话权限`)
   }
-  return true
+  return unverified ? 'unverified' : true
 }
 
 /**

package/lib/pv-session.mjs

@@ -118,6 +118,13 @@ export function createVideoStudio({ ctx, pv, stateDir, config, publicSources = (
     const current = pv.status(), row = sessionRow(sessionId) || (!sessionId && rows.find(item => item.productionId && item.productionId === current.id))
     if (sessionId && !row) return { ok: true, stopped: false, hint: '没有找到这个制作会话' }
     if (!row) return pv.stop()
+    /* 审计 P2-8（2026-11-12）：终态不可逆——已交付回执（done + terminalDelivered）的会话
+     * 再收到 stop 时，以前会被无条件改写成 stopped，会话侧的「目标终态」丢失（磁盘成片
+     * 不受影响，但 status 从此显示"已手动停止"）。现在对已交付终态的行直接原样返回。 */
+    if (row.stage === 'done' || row.terminalDelivered) {
+      return { ok: true, stopped: false, sessionId: row.sessionId, stage: row.stage,
+        hint: '该会话已交付终态（成片已完成且回执已送达），没有可停止的任务。' }
+    }
     const before = row.stage
     row.stage = 'stopped'; row.error = ''; remember(row) // Fence completion callbacks before cancellation.
     const result = row.productionId && row.productionId === current.id ? pv.stop() : { ok: true, stopped: false }
@@ -132,7 +139,13 @@ export function createVideoStudio({ ctx, pv, stateDir, config, publicSources = (
   const settled = async result => {
     if (disposed || !result.id) return
     const row = rows.find(item => item.productionId === result.id)
-    if (!row || row.stage === 'stopped' || row.terminalDelivered === result.id || delivering.has(result.id)) return
+    if (!row) {
+      // 审计 P3-19（2026-11-12）：行索引只留 60 条，被裁剪行的渲染完成事件以前无声丢失——
+      // 至少留一条可发现的记录（AGENTS：终态回传原会话一次；回传不了也要说清为什么）。
+      log(`⚠️ 渲染 ${result.id}（${result.date || '?'}）完成，但对应的制作会话已被裁剪出列表——终态无法回传原会话，成片与回执见 productions 列表`)
+      return
+    }
+    if (row.stage === 'stopped' || row.terminalDelivered === result.id || delivering.has(result.id)) return
     delivering.add(result.id)
     try {
       const verified = result.ok === true && result.stage === 'done' && !result.verificationSkipped
@@ -214,6 +227,8 @@ export function createVideoStudio({ ctx, pv, stateDir, config, publicSources = (
     } finally { creating = false }
   }
   const prepare = (args = {}, sessionId = '') => {
+    // 审计 P3-24：preview/render 都有 disposed 闸，prepare 漏了——卸载竞态窗口内仍可返回素材快照。
+    if (disposed) return { ok: false, error: '视频制作服务已关闭' }
     const saved = sessionRow(sessionId)
     const request = saved || videoRequest(args)
     if (saved && args.date && args.date !== saved.date) throw new Error('日期与当前制作会话不一致')

package/lib/pv.mjs

@@ -2,7 +2,7 @@
 import { spawn } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
 import { appendFileSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { isAbsolute, join, relative, resolve } from 'node:path'
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path'
 import { normalizeProduction } from './pv-production.mjs'
 
 export const PV_PREFIX = '大肥鱼日报'
@@ -72,12 +72,23 @@ const usableVideo = (file) => {
 /** Keep the historical date-indexed list compatible; studio jobs have productions(). */
 export function listPv(outDir, legacyDirs = outDir) {
   const byDate = new Map()
+  const verificationOk = (date, dir) => {
+    // 审计 P3-20（2026-11-12）：legacy 列表以前只看「文件存在且 >1KB」——手工放进 out 的
+    // 任意 mp4 也会以成片身份进列表/播放端点（studio 的 productions() 严格要求校验回执）。
+    // 现在给每行带上 verified 标记：旁边有 ok:true 的 verification.json 才算验证过，
+    // 消费端（bili_pv list / 设置页）可以区分「校验过」与「只是个视频文件」。
+    try {
+      const receipt = JSON.parse(readFileSync(join(dateDir(dir, date), 'verification.json'), 'utf8'))
+      return receipt?.ok === true
+    } catch { return false }
+  }
   const add = (date, file, canonical) => {
     if (!pvDateOk(date) || !usableVideo(file)) return
     const old = byDate.get(date)
     if (!old || (!old.canonical && canonical)) {
       const s = statSync(file)
-      byDate.set(date, { date, file, size: s.size, at: s.mtime.toISOString(), canonical })
+      byDate.set(date, { date, file, size: s.size, at: s.mtime.toISOString(), canonical,
+        verified: verificationOk(date, canonical ? outDir : dirname(file)) })
     }
   }
   try {
@@ -170,7 +181,11 @@ const productionRow = (outDir, id) => {
 export function createPv(o) {
   const { stateDir, pluginDir, python, dirs, env = null } = o
   const say = (s) => { try { o.log?.(s) } catch { /* host logger */ } }
-  const timeoutMs = Number(o.timeoutMs) > 0 ? Number(o.timeoutMs) : 20 * 60_000
+  /* 审计 P2-12（2026-11-12）：默认任务总时限 20 分钟 < py 侧 GSV 批处理自己的 60 分钟预算
+   * （pv.py:776 timeout=3600，且 pv_gsv.py 强制 CPU 推理，模型加载就要 30-50s）——长批处理
+   * 到点被 JS 强杀整树，py 的预算形同虚设。默认提到 75 分钟（> py 60 分钟 + 模型加载余量），
+   * py 侧超时先到、报错更有指向性；显式传 timeoutMs 的调用方不受影响。 */
+  const timeoutMs = Number(o.timeoutMs) > 0 ? Number(o.timeoutMs) : 75 * 60_000
   const gsvOf = () => { try { return o.gsv?.() || null } catch { return null } }
   let job = null
   const settledListeners = new Set()

package/lib/pv.py

@@ -720,7 +720,14 @@ def ffmpeg_exe():
         import imageio_ffmpeg
         return imageio_ffmpeg.get_ffmpeg_exe()
     except Exception:
-        return shutil.which("ffmpeg") or "ffmpeg"
+        pass
+    found = shutil.which("ffmpeg")
+    if not found:
+        # P3-35: 裸 FileNotFoundError 排不了障 —— 报错带安装指引
+        raise RuntimeError(
+            "找不到 ffmpeg —— imageio_ffmpeg 会随渲染依赖自动安装（uv/pip 装依赖时带上），"
+            "或手动安装 ffmpeg 并加入 PATH 后重试")
+    return found
 
 
 def gsv_batch(texts, out_dir: Path, voice: dict, log=print):
@@ -763,6 +770,20 @@ def gsv_batch(texts, out_dir: Path, voice: dict, log=print):
            "--top-p", str(voice.get("gsvTopP", 0.9)),
            "--temp", str(voice.get("gsvTemp", 0.75)),
            "--repetition-penalty", str(voice.get("gsvRepPen", 1.3))]
+    # P2-11: gsvPython 漏配时会落到渲染 venv（sys.executable）—— 它没有 torch/soundfile，
+    #   子进程必死在 _patch_torchaudio 的 ModuleNotFoundError 上且报错不指向根因。
+    #   启动前先用同一个解释器跑一次 import 预检（首次冷盘导入也可能要十几秒，给 120s）。
+    try:
+        probe = subprocess.run([py, "-c", "import torch, soundfile"], capture_output=True, timeout=120)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise RuntimeError(
+            f"gsvPython（{py}）预检失败（{type(exc).__name__}）——在设置页把 gsvPython "
+            "指到 GPT-SoVITS 自带的 python，或换一个能用的解释器") from exc
+    if probe.returncode != 0:
+        tail = (probe.stderr or b"").decode("utf-8", "ignore").strip().splitlines()
+        raise RuntimeError(
+            f"gsvPython（{py}）缺少 torch/soundfile（{(tail[-1] if tail else 'import 失败')}）——"
+            "在设置页把 gsvPython 指到 GPT-SoVITS 自带的 python，或在其环境里 pip install torch soundfile")
     log(f"🎙  GPT-SoVITS 批处理：{len(texts)} 句（加载模型要 30~50 秒）")
     t0 = time.time()
     # ⚠️ 必须给子进程钉死 UTF-8：它会往管道里打中文和 emoji，Windows 默认 GBK 会炸
@@ -798,7 +819,9 @@ def tts(text: str, out_mp3: Path, voice="zh-CN-XiaoyiNeural", rate="+8%", pitch=
 
         async def go():
             c = edge_tts.Communicate(text, voice, rate=rate, pitch=pitch)
-            await c.save(str(out_mp3))
+            # P2-14: 主合成路径此前没有任何超时 —— websocket 半开时 save() 永久挂起，
+            #   prepare_audio 停摆到 JS 强杀。120s 墙钟；TimeoutError 落到下面的 SAPI 兜底。
+            await asyncio.wait_for(c.save(str(out_mp3)), timeout=120)
 
         asyncio.run(go())
         # ⭐ 2026-10-26：阈值 1200→600 —— "嗯。"这种极短句的 mp3 可能不足 1200 字节，
@@ -903,6 +926,71 @@ def squeeze_silence(pcm, rate, max_gap=0.42, keep=0.30, th=450.0, edge=0.12):
     return out
 
 
+def weight_len(s) -> float:
+    """P3-27: 加权字符数 —— CJK=1、数字=0.5、拉丁字母=0.35、其他=1。
+
+    等权字符数会让「数字/英文读得快」的句子字幕切得慢（探针 F：英文估 3 倍偏差）。
+    """
+    total = 0.0
+    for ch in str(s or ""):
+        if "\u4e00" <= ch <= "\u9fff":
+            total += 1
+        elif ch.isascii() and ch.isdigit():
+            total += 0.5
+        elif ch.isascii() and ch.isalpha():
+            total += 0.35
+        else:
+            total += 1
+    return total
+
+
+def spoken_chars(text) -> float:
+    """P1-5: 有效字数（去标点/空白）：CJK 记 1，连续英文/数字串整段记 0.5。
+
+    与 bili-video/build.py 的 0.32s/字守卫同一套「字数观」——标点不占口播时长。
+    """
+    total, run = 0.0, 0
+    for ch in str(text or ""):
+        if ch.isascii() and ch.isalnum():
+            run += 1          # 连续英文/数字串攒着，断开时整段记 0.5
+            continue
+        if run:
+            total += 0.5
+            run = 0
+        if "\u4e00" <= ch <= "\u9fff":
+            total += 1
+    if run:
+        total += 0.5
+    return total
+
+
+# P1-5 上限的短句开销余量（秒）：「嗯。」这类一两个字的句子有起振/收音固定开销，
+# 纯 0.32s/字会误杀 —— build.py 只跑长句所以没这问题，插件的单句可以很短。
+GSV_TAKE_MIN_RATE = 0.15   # s/有效字，低于即截断（真机 GSV 正常 0.20~0.25）
+GSV_TAKE_MAX_RATE = 0.32   # s/字（含标点），超过即复读/拖长（与 bili-video/build.py:85-95 同口径）
+GSV_TAKE_OVERHEAD = 1.0    # 上限的固定余量
+
+
+def gsv_take_guard(index: int, text: str, dur: float) -> None:
+    """P1-5: GSV 句级时长守卫 —— 截断/复读 take 拦在渲染前，别烧几十分钟渲废片。
+
+    真机实测（bili-work 各 timeline.json）：正常 GSV ≈0.20~0.25s/有效字；
+    探针实测的截断形态是 15 字句只出 0.8s（0.053s/字），复读形态是时长成倍超上限。
+    """
+    text = str(text or "")
+    eff = spoken_chars(text)
+    raw = max(1, len(text.strip()))
+    if eff > 0 and dur < eff * GSV_TAKE_MIN_RATE:
+        raise RuntimeError(
+            f"第 {index+1} 句 GSV 音频异常偏短（疑似截断）：{dur:.2f}s / {eff:g} 有效字"
+            f"= {dur / eff:.2f}s/字（下限 {GSV_TAKE_MIN_RATE}s/字）——句首：「{text[:12]}」")
+    if dur > raw * GSV_TAKE_MAX_RATE + GSV_TAKE_OVERHEAD:
+        raise RuntimeError(
+            f"第 {index+1} 句 GSV 音频异常偏长（疑似复读）：{dur:.2f}s / {raw} 字"
+            f"= {dur / raw:.2f}s/字（上限 {GSV_TAKE_MAX_RATE}s/字，同 bili-video/build.py）"
+            f"——句首：「{text[:12]}」")
+
+
 def envelope(pcm, rate, fps):
     """把波形压成每帧一个 0~1 的响度包络（口型用）。"""
     step = rate / fps
@@ -1962,17 +2050,40 @@ def split_sentences(text, maxlen=18):
 
     用户说「字幕对不上」⇒ 根因是字幕显示的是摘要、语音念的是全文。
     现在一句话一个镜头、字幕就是这句原话，字幕自然对得上。
+
+    ⭐ P3-26（2026-11-12 审计）：连续省略号（……）合并成一个边界，不再逐字切出
+    孤立「…」碎句；句末标点后紧跟闭引号（」』"'）时不当断句 —— 引号里的
+    「你好。」是引语的一部分，句子续到真正的结尾（探针 A 实测）。
     """
     text = str(text or "").strip()
     if not text:
         return []
+    closing = "」』\"'"
     # 先按句末标点切
     parts, buf = [], ""
-    for ch in text:
+    i, n = 0, len(text)
+    while i < n:
+        ch = text[i]
         buf += ch
+        if ch == "…":
+            # 连续省略号（……）并成一个边界单位
+            while i + 1 < n and text[i + 1] == "…":
+                i += 1
+                buf += "…"
         if ch in "。！？…；!?;":
-            parts.append(buf)
-            buf = ""
+            j = i + 1
+            while j < n and text[j] in closing:
+                j += 1
+            if j > i + 1 and j < n:
+                # 句末标点后紧跟闭引号且后面还有正文 ⇒ 引语内标点，不断句，引号吸进本句
+                buf += text[i + 1:j]
+                i = j
+                continue
+            # 有实词才落句：开头就是省略号（buf 只剩标点）时不切出孤立「…」碎句
+            if buf.strip(closing + "。！？…；!?;，,、：: \u3000\t"):
+                parts.append(buf)
+                buf = ""
+        i += 1
     if buf.strip():
         parts.append(buf)
     out = []
@@ -1996,11 +2107,11 @@ def split_sentences(text, maxlen=18):
     return out
 
 
-def subtitle(img, text, t, dur, words):
+def subtitle(img, text, t, dur):
     """底部字幕：只占左栏内容列（SUB_W），永不盖到右侧的角色。
 
     ⚠️ 「字幕对不上」的根因：以前字幕显示的是整段摘要，语音念的是全文。
-    现在按句切分、按字数分配时长，字幕只显示「此刻正在念的那一句」。
+    现在按句切分、按加权字数分配时长，字幕只显示「此刻正在念的那一句」。
     浅色主题 ⇒ 白色圆角条 + 深墨字，念过的字变浅。
     """
     if not text:
@@ -2009,10 +2120,11 @@ def subtitle(img, text, t, dur, words):
     # —— 选出当前这句 ——
     sents = split_sentences(text, maxlen=22) or [text]
     if len(sents) > 1 and dur > 0:
-        total_chars = sum(max(1, len(s)) for s in sents)
+        # P3-27: 按 weight_len 分摊 —— 数字/英文读得快，等权字符数会把它们切慢
+        total_chars = sum(max(1.0, weight_len(s)) for s in sents)
         acc, cur = 0.0, sents[-1]
         for s in sents:
-            span = dur * max(1, len(s)) / total_chars
+            span = dur * max(1.0, weight_len(s)) / total_chars
             if t < acc + span:
                 cur = s
                 break
@@ -2033,13 +2145,7 @@ def subtitle(img, text, t, dur, words):
                          outline=(150, 190, 226, 175), width=2)
     paste_rgba(img, box, (x0, y0 - 14))
     done_chars = len(cur)
-    if words:
-        done_chars = 0
-        for wd in words:
-            if t * 10_000_000 >= wd["offset"]:
-                done_chars = min(len(cur), done_chars + len(wd["text"]))
-            else:
-                break
+    # 2026-11-12 审计移除：words 逐字卡拉OK高亮是无生产者的死路径，且 100ns ticks 单位无文档
     idx = 0
     for i, ln in enumerate(lines):
         yy = y0 + i * lh
@@ -2232,6 +2338,12 @@ def prepare_audio(shots, base_voice, work, fps):
                         pass
             pcm,rate = to_wav(source,wav_path)
             if engine == "gsv":
+                # P2-10: 全静音/近静音的 take 要拦在合成后 —— 以前一路渲完整片才在 verify
+                #   报「缺少有效对白或口型帧」，不指向根因句，白烧几十分钟。
+                _rms = math.sqrt(sum(v * v for v in pcm) / max(1, len(pcm))) if pcm else 0.0
+                if _rms < 100.0:   # 16bit 满幅 32767；正常语音 RMS 在千级
+                    raise RuntimeError(
+                        f"第 {index+1} 句 GSV 输出为静音（RMS {_rms:.0f} < 100）——句首：「{text[:12]}」")
                 # ⭐ 2026-10-26：把 squeeze_silence 真正接上 —— 这个函数当初就是为
                 #   「GPT-SoVITS 分句边界偶发几秒死寂」写的，但一直没有任何调用点。
                 #   压缩后**写回 wav_path**：timeline 的时长和最终混音（重读 wav/xx.wav）
@@ -2242,6 +2354,8 @@ def prepare_audio(shots, base_voice, work, fps):
                     w.setsampwidth(2)
                     w.setframerate(rate)
                     w.writeframes(pcm.tobytes())
+                # P1-5: 压完静音再按最终时长判 —— squeeze 能救回的（句中长死寂）不误杀
+                gsv_take_guard(index, text, len(pcm) / rate)
             dur = len(pcm) / rate
             if dur <= .02:
                 raise RuntimeError(f"第 {index+1} 句音频为空")
@@ -2293,6 +2407,12 @@ def build(plan: dict, out_path: Path, work: Path, fps=FPS, scale=1.0, still=None
         raise ValueError("fps must be 1..60; scale must be 0.1..2")
     t_start = time.time()
     shots = plan["shots"]
+    # P2-13: 含空文本镜头的 plan 会把整片渲完才在 verify 必挂 —— 开头就拦，报错指向第几镜
+    for _i, _shot in enumerate(shots):
+        if not str((_shot or {}).get("text") or "").strip():
+            raise ValueError(
+                f"第 {_i+1} 镜（id={(_shot or {}).get('id', '?')}）没有台词"
+                "——纯视觉镜头暂不支持，给它一句旁白或删掉")
     # Editorial v2 and dialogue plans use the 1080p stage. Legacy cards remain 720p.
     editorial_plan = plan.get("schema") == "deepmoyu-editorial-v2"
     editorial_renderer = None
@@ -2381,7 +2501,8 @@ def build(plan: dict, out_path: Path, work: Path, fps=FPS, scale=1.0, still=None
         elif shot.get("kind") == "dialogue":
             frame = dialogue_subtitle(frame,shot,active,max(0,local))
         else:
-            frame = subtitle(frame,str(shot.get("text","")),max(0,local),duration,shot.get("words"))
+            # 2026-11-12 审计移除：words 字段读取随卡拉OK死路径一并删掉（无生产者）
+            frame = subtitle(frame,str(shot.get("text","")),max(0,local),duration)
             if frame.size != (NAT_W,NAT_H):
                 frame = frame.resize((NAT_W,NAT_H),Image.Resampling.LANCZOS)
         if (W2,H2) != (NAT_W,NAT_H):
@@ -2481,7 +2602,10 @@ def build(plan: dict, out_path: Path, work: Path, fps=FPS, scale=1.0, still=None
                         frame = Image.blend(prev, frame, amount)
             # 片头片尾各 600ms 淡入淡出（像一段真正剪过的短片，而不是突然开始）
             if dialogue_plan:
-                head = clamp(tnow / .60, 0, 1)
+                # P3-34: 淡入 0.60s 会盖过 0.18s lead 的开头语音（开头两个字有声音没画面）
+                #   —— 淡入时长不得超过 lead；lead=0 时直接不做淡入（避免除零）。
+                fade_in = min(.60, lead) if lead > 0 else 0.0
+                head = 1.0 if fade_in <= 0 else clamp(tnow / fade_in, 0, 1)
                 tailf = clamp((total - tnow) / .60, 0, 1)
                 alpha = min(head, tailf)
                 if alpha < 1:

package/lib/pv_cover.py

@@ -16,11 +16,20 @@ import argparse
 import json
 import os
 import re
+import sys
 from pathlib import Path
 from typing import Any
 
 from PIL import Image, ImageDraw, ImageFilter
 
+# P3-31: Windows 管道默认 GBK —— 中文日志会乱码甚至把 print 打挂，先钉 UTF-8
+#（写法照 lib/pv.py:41-46）
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
 try:  # Loaded as a top-level module by the CLI and tests.
     from pv import F, NF, Fish, Portrait, bg_ocean
 except ImportError:  # pragma: no cover - package import fallback
@@ -436,7 +445,8 @@ def main() -> int:
             if drawn != title:
                 print(f"  {ratio} 排不下全文，封面用：{drawn}", flush=True)
         return 0
-    except (OSError, ValueError, TypeError, json.JSONDecodeError, RuntimeError) as exc:
+    except (OSError, ValueError, TypeError, KeyError, json.JSONDecodeError, RuntimeError) as exc:
+        # P3-29: KeyError 补进兜底 —— plan 带未知 theme 时给一行人话，不再裸 traceback
         parser.exit(1, f"封面生成失败：{exc}\n")