dsh-deepmoyu 2.7.1 → 2.7.2

package/lib/pv_editorial.py

@@ -173,14 +173,32 @@ def caption_parts(text, limit=23):
     return parts
 
 
+def weight_len(s) -> float:
+    """P3-27: 加权字符数（CJK=1、数字=0.5、拉丁字母=0.35、其他=1）—— 与 lib/pv.py 同款。
+
+    等权字符数会让「数字/英文读得快」的短语字幕切得慢（探针 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 active_caption(text, t, duration):
     """Phrase timing is proportional within the measured utterance, not ASR."""
     if not text or not 0 <= t < duration:
         return ""
     parts = caption_parts(text)
-    position = t / max(.01, duration) * sum(len(part) for part in parts)
+    position = t / max(.01, duration) * sum(max(1.0, weight_len(part)) for part in parts)
     for part in parts:
-        position -= len(part)
+        position -= max(1.0, weight_len(part))
         if position < 0:
             return part
     return parts[-1]
@@ -232,6 +250,9 @@ def place_host(image, draw, state, t, colors, compact=False):
 
 def render(shot, t, duration, state):
     theme = state.get("theme", "paper")
+    if theme not in THEMES:
+        # P3-29: 未知 theme 直接 KeyError 裸崩（探针 I）—— 回退 paper，渲染继续而不是渲到一半炸
+        theme = "paper"
     colors = THEMES[theme]
     image = backdrop(theme).copy().convert("RGBA")
     draw = ImageDraw.Draw(image)

package/lib/pv_plan.py

@@ -256,9 +256,27 @@ CLOSING_LINES = ("所以，这碗白米饭终于能吃了？",      # ⚠️ 收
                  "等本鱼把笔记放好。饭要趁热，脑袋也要开工。")  # auto_plan 各出现一次，改时两处同步
 
 
+def weight_len(s) -> float:
+    """P3-27: 加权字符数（CJK=1、数字=0.5、拉丁字母=0.35、其他=1）—— 与 lib/pv.py 同款。
+
+    等权 len() 会给英文/数字多的镜头多算时长（它们读得快），规划预算随之虚高。
+    """
+    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 est_dur(shot: dict) -> float:
-    """单镜时长估算：max(2.0, 字数/3.8) + 0.35。"""
-    return max(MIN_SHOT_SPEECH, len(str(shot.get("text") or "")) / SPEECH_RATE) + SHOT_OVERHEAD
+    """单镜时长估算：max(2.0, 加权字数/4.4) + 0.35。"""
+    return max(MIN_SHOT_SPEECH, weight_len(str(shot.get("text") or "")) / SPEECH_RATE) + SHOT_OVERHEAD
 
 
 def plan_seconds(shots: list) -> float:

package/lib/pv_verify.py

@@ -11,11 +11,19 @@ import json
 import math
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 import imageio_ffmpeg
 from PIL import Image
 
+# P3-31: Windows 管道默认 GBK —— 错误 JSON 里的中文会乱码，先钉 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
+
 
 def _probe(video: Path) -> tuple[dict, int]:
     # imageio-ffmpeg bundles ffmpeg, not ffprobe. Decode without frame duplication
@@ -24,10 +32,16 @@ def _probe(video: Path) -> tuple[dict, int]:
     reader = imageio_ffmpeg.read_frames(
         str(video), pix_fmt="rgb24", input_params=["-xerror"], output_params=["-vsync", "0"]
     )
+    started = time.monotonic()
     try:
         metadata = next(reader)
         for _ in reader:
             frame_count += 1
+            if frame_count % 500 == 0 and time.monotonic() - started > 90.0:
+                # P3-30: 全帧解码没有看门狗会挂到 JS 任务级强杀（对照 _decode_frames 的 120s）
+                raise TimeoutError  # 哨兵：下面的分支原样转成带上下文的 TimeoutError
+    except TimeoutError:
+        raise TimeoutError(f"视频解码超时（>90s，已解 {frame_count} 帧）：{video.name}") from None
     except Exception as exc:
         raise ValueError(f"视频无法完整解码：{str(exc)[-300:]}") from exc
     finally:

package/lib/state.mjs

@@ -79,11 +79,15 @@ export function ensureHomeFiles(pluginDir, stateDir, log = () => {}) {
     [join(pluginDir, 'vendor', 'bilibili-mcp', 'runtime_guard.py'), join(stateDir, 'runtime_guard.py'), true],
     [join(pluginDir, 'lib', 'asr.py'), join(stateDir, 'asr.py'), true],
     [join(pluginDir, 'lib', 'favops.py'), join(stateDir, 'favops.py'), true],
-    // 🎬 「昨日冲浪报告」视频（2026-10-22）：pv.mjs 起的是**家目录**那两个脚本，
-    //    所以它们必须跟 mcp_server.py 一样铺过来；不铺 ⇒ 家目录没有、渲染直接报「脚本没铺好」。
+    // 🎬 「昨日冲浪报告」视频（2026-10-22）：pv.mjs 优先起插件 lib 下的脚本，家目录副本是
+    //    pluginDir/lib 不可用时的回退 —— 回退形态也要能独立跑全。审计 P3-21（2026-11-12）
+    //    补齐 pv_verify.py / pv_editorial.py：pv.py 渲染中段 `import pv_editorial`，verify 阶段
+    //    独立跑 pv_verify.py —— 这两个以前没铺，回退部署会在 plan/cover 都跑完之后才崩。
     [join(pluginDir, 'lib', 'pv.py'), join(stateDir, 'pv.py'), true],
     [join(pluginDir, 'lib', 'pv_plan.py'), join(stateDir, 'pv_plan.py'), true],
     [join(pluginDir, 'lib', 'pv_cover.py'), join(stateDir, 'pv_cover.py'), true],
+    [join(pluginDir, 'lib', 'pv_verify.py'), join(stateDir, 'pv_verify.py'), true],
+    [join(pluginDir, 'lib', 'pv_editorial.py'), join(stateDir, 'pv_editorial.py'), true],
     // 🎙 真·本鱼音色（2026-10-22）：pv.py 用 subprocess 调它跑 GPT-SoVITS 批量合成，
     //    同样必须在家目录里 —— 不然设置页填了音色也会报「找不到 pv_gsv.py」。
     [join(pluginDir, 'lib', 'pv_gsv.py'), join(stateDir, 'pv_gsv.py'), true],

package/lib/sticker-automation.mjs

@@ -84,7 +84,18 @@ export function createStickerAutomation({ stateDir, getConfig, now = Date.now, r
     if (veto) return { suitable: false, score: 0, description: '', tags: [], reason: veto, source: 'lexicon' }
     if (!enabled || typeof judge !== 'function') return { suitable: true, score: null, description: '', tags: [], reason: '', source: 'off' }
     try {
-      const verdict = await judge({ candidate, signal })
+      /* 审计 P2-7（2026-11-12）：20s 超时全靠 judge 内部把 signal 传播给宿主 llm——宿主
+       * 不理会 AbortSignal 时 judge 永不 settle，drain 的 active 永不释放，后续 offer 全部
+       * 静默拒绝，自动收集停摆到重启。这里加一道**独立墙钟**兜底（judge 自己的 20s + 1s 余量）：
+       * 超时按 fail-open 记 'error'，队列照常流动——与文件头的 fail-open 约定一致。 */
+      const verdict = await Promise.race([
+        Promise.resolve(judge({ candidate, signal })),
+        new Promise((resolve) => {
+          const timer = setTimeout(() => resolve(null), 21_000)
+          timer.unref?.()
+        }),
+      ])
+      if (verdict === null) return { suitable: true, score: null, description: '', tags: [], reason: '判图 21 秒无响应（宿主线路挂起），本轮 fail-open 跳过', source: 'timeout' }
       if (!verdict || typeof verdict !== 'object') return { suitable: true, score: null, description: '', tags: [], reason: '', source: 'off' }
       return { suitable: verdict.suitable !== false, score: Number.isFinite(Number(verdict.score)) ? Number(verdict.score) : null,
         description: String(verdict.description || '').slice(0, 60), tags: Array.isArray(verdict.tags) ? verdict.tags.slice(0, 4).map(String) : [],
@@ -99,8 +110,11 @@ export function createStickerAutomation({ stateDir, getConfig, now = Date.now, r
   }
   const schedule = () => {
     if (disposed || active || immediate || !queue.length) return
+    /* 审计 P3-12（2026-11-12）：unref 的 immediate 在事件循环只靠长 timer 空转时会被推迟。
+     * 修复 = **去掉 unref**：ref 的 setImmediate 在同一轮 check 相位就执行（不引入 timer 相位的
+     * 延迟，测试时序不变），并且会把事件循环拽醒——空闲进程里排队项不再被无限期搁置。
+     * stop() 的 clearImmediate 取消语义不变。 */
     immediate = setImmediate(() => { immediate = null; void drain() })
-    immediate.unref?.()
   }
   const drain = async () => {
     if (active || disposed) return

package/lib/sticker.mjs

@@ -177,7 +177,10 @@ export function snapshotStickerForSend(stateDir, input) {
         const bytes = readFileSync(info.file)
         const hash = sha256(bytes)
         // A stale ledger hash fails closed; never send bytes that changed after review.
-        if (meta.hash && meta.hash !== hash) return null
+        // 审计 P3-5（2026-11-12）：缺 hash 的历史条目以前 fail-open（同名换字节发现不了）——
+        // 现在 fail-closed，与「发送绑定已批准字节快照」一致。恢复路径：重新 collect + 过审
+        //（decideSticker 落库时必写 hash）。
+        if (meta.hash !== hash) return null
         return { name, source: 'collected', bytes: bytes.length, hash, ...makeSendSnapshot(bytes, info.fmt) }
       }
       // Builtins are read-only and always approved.

package/lib/uvfetch.mjs

@@ -46,23 +46,49 @@ export async function extractArchive(name, archive, into, run = nativeRun) {
   return null
 }
 
+/** 审计 P3-23：允许的下载源与其合法跳转目标（GitHub release 会 302 到
+ *  objects/release-assets.githubusercontent.com——这两个必须在清单里，否则正常下载全挂）。 */
+const ALLOWED_REDIRECT_HOSTS = ['github.com', 'objects.githubusercontent.com', 'release-assets.githubusercontent.com',
+  'gh-proxy.com', 'ghproxy.net', 'files.pythonhosted.org', 'pypi.org']
+
 /** The deadline covers headers and the whole streamed response, including slow bodies. */
 async function consumeUvResponse(url, { fetchImpl = globalThis.fetch, timeoutMs = 120_000, maxBytes = MAX_ARCHIVE } = {}, consume) {
   const controller = new AbortController()
   const timer = setTimeout(() => controller.abort(new Error('UV_DOWNLOAD_TIMEOUT')), timeoutMs)
   try {
-    const response = await fetchImpl(url, { signal: controller.signal, redirect: 'follow' })
-    if (!response.ok) throw new Error('UV_HTTP_' + response.status)
-    if (Number(response.headers.get('content-length')) > maxBytes) throw new Error('UV_DOWNLOAD_TOO_LARGE')
-    if (!response.body) throw new Error('UV_EMPTY_RESPONSE')
-    let total = 0
-    for await (const chunk of response.body) {
-      total += chunk.length
-      if (total > maxBytes) { controller.abort(); throw new Error('UV_DOWNLOAD_TOO_LARGE') }
-      await consume(chunk)
+    /* 审计 P3-23（2026-11-12）：以前 `redirect:'follow'`——镜像被劫持时可 302 到任意主机
+     * （下载源固定为 github/gh-proxy/pythonhosted/pypi，跳转目标却不受限）。SHA-256 兜底
+     * 挡住了投毒，但挡不住拿下载器当内网探测器。现在手动跟跳，每跳的目标主机都必须
+     * 仍在允许的下载源清单里，最多 5 跳。 */
+    let target = String(url)
+    for (let hop = 0; hop <= 5; hop++) {
+      const response = await fetchImpl(target, { signal: controller.signal, redirect: 'manual' })
+      const location = response.headers.get('location')
+      if (response.status >= 300 && response.status < 400 && location) {
+        if (!ALLOWED_REDIRECT_HOSTS.some((host) => new URL(target).hostname === host || new URL(target).hostname.endsWith('.' + host))) {
+          throw new Error('UV_REDIRECT_HOST_BLOCKED')
+        }
+        target = new URL(location, target).toString()
+        const next = new URL(target)
+        if (!/^https?:$/.test(next.protocol)) throw new Error('UV_REDIRECT_SCHEME_BLOCKED')
+        if (!ALLOWED_REDIRECT_HOSTS.some((host) => next.hostname === host || next.hostname.endsWith('.' + host))) {
+          throw new Error('UV_REDIRECT_HOST_BLOCKED: ' + next.hostname)
+        }
+        continue
+      }
+      if (!response.ok) throw new Error('UV_HTTP_' + response.status)
+      if (Number(response.headers.get('content-length')) > maxBytes) throw new Error('UV_DOWNLOAD_TOO_LARGE')
+      if (!response.body) throw new Error('UV_EMPTY_RESPONSE')
+      let total = 0
+      for await (const chunk of response.body) {
+        total += chunk.length
+        if (total > maxBytes) { controller.abort(); throw new Error('UV_DOWNLOAD_TOO_LARGE') }
+        await consume(chunk)
+      }
+      if (!total) throw new Error('UV_EMPTY_RESPONSE')
+      return total
     }
-    if (!total) throw new Error('UV_EMPTY_RESPONSE')
-    return total
+    throw new Error('UV_REDIRECT_LOOP')
   } finally { clearTimeout(timer); controller.abort() }
 }
 
@@ -188,4 +214,4 @@ export function ensureUv({ dir, log = () => {}, fetchImpl = globalThis.fetch, ru
   const pending = installUv({ dir: destination, log, asset, fetchImpl, run, timeoutMs }).finally(() => inflight.delete(key))
   inflight.set(key, pending)
   return pending
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-deepmoyu",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "private": false,
   "description": "🐋 DeepMoYu 鲸鱼摸鱼 —— 让一只鲸鱼娘自己逛 B站：自主搜片、读字幕、发评论、发动态、回私信，还能写日报、做视频的 DSH 插件（dsh-bili-scroll 0.1.19 分叉；内置 npm 更新通道，对本地分叉自动锁定）",
   "keywords": [

package/vendor/bilibili-mcp/mcp_server.py

@@ -149,8 +149,10 @@ def _guard_blocked(reservation, kind="send", why=""):
         return json.dumps({
             "success": False, "already_replied": True, "retry_blocked": True,
             "guard_status": "unknown", "seen_at": at,
+            "slot_key": reservation.get("key", ""),
             "error": "上一次发出去的结果不确定（超时 / 回执不明）—— 不许自动重发",
-            "hint": "先自己去评论区 / 私信里看一眼到底发出去没有；确认没有，再手工重试",
+            "hint": ("先自己去评论区 / 私信里看一眼到底发出去没有；**确认没发出去**后，用 "
+                     "bili_guard_status(release=['这条的 slot_key']) 人工解除 unknown 槽位（P1-2），再重试"),
         }, ensure_ascii=False)
     if status == "pending":
         return json.dumps({
@@ -167,6 +169,18 @@ def _guard_blocked(reservation, kind="send", why=""):
     }, ensure_ascii=False)
 
 
+# P3-46: 守卫库被锁（SQLite busy>15s）时的统一 fail-closed 话术，措辞对齐 bili_subtitle
+# 的「判重账本不可用」兜底回执 —— 原始 traceback 绝不能直接漏给模型。
+_GUARD_LOCKED_ERROR = "判重账本暂不可用（可能被锁），先别重发；稍后用 bili_guard_status 核对坑位状态"
+
+
+def _guard_unavailable(exc) -> str:
+    """占坑阶段守卫异常 → JSON 错误回执（此时还没发任何东西，可以稍后重试）。"""
+    return json.dumps({"success": False, "error": _GUARD_LOCKED_ERROR,
+                       "detail": f"{type(exc).__name__}: {exc}",
+                       "guard_status": "not_sent", "retry_blocked": False}, ensure_ascii=False)
+
+
 async def _guarded_send(guard, reservation, runner, record=None):
     """在**已经占好坑**的前提下真正发出去，并如实落账。
 
@@ -196,7 +210,13 @@ async def _guarded_send(guard, reservation, runner, record=None):
             return None
 
     def _rejected(error, result, code):
-        pace = guard.reject_send(reservation, code)
+        try:
+            pace = guard.reject_send(reservation, code)
+        except Exception as exc:
+            # P3-46: 拒绝落账失败（库被锁）不能裸抛 —— 事务已回滚、坑位留在 pending 正好挡重发，
+            # 回执转 fail-closed（guard_status=unknown ⇒ 调用方会回「别自动重发」的话术）。
+            return {"guard_status": "unknown", "error": _GUARD_LOCKED_ERROR, "retry_blocked": True,
+                    "result": result, "code": code, "ledger_detail": f"{type(exc).__name__}: {exc}"}
         out = {"guard_status": "rejected", "error": error, "retry_blocked": False,
                "result": result, "code": code}
         if code == 49044:
@@ -232,7 +252,13 @@ async def _guarded_send(guard, reservation, runner, record=None):
         return {"guard_status": "unknown", "error": str(result.get("error") or "没有确定的回执"),
                 "retry_blocked": True, "result": result, "code": code}
 
-    guard.commit_send(reservation, record)
+    try:
+        guard.commit_send(reservation, record)
+    except Exception as exc:
+        # P3-46: 落账失败（库被锁 >15s）不能裸抛 —— 发送本身可能已成功，坑位留在 pending
+        # 挡住重发；回执转 fail-closed JSON 并指引去 bili_guard_status 核对，而不是 traceback。
+        return {"guard_status": "unknown", "error": _GUARD_LOCKED_ERROR, "retry_blocked": True,
+                "result": result, "code": None, "ledger_detail": f"{type(exc).__name__}: {exc}"}
     return {"guard_status": "sent", "error": "", "retry_blocked": False, "result": result, "code": None}
 
 
@@ -407,10 +433,13 @@ async def bili_login_check() -> str:
 
     elif state == QrCodeLoginEvents.TIMEOUT:
         _login_session = None
-        # 清理二维码文件
+        # 清理二维码文件（P3-47: Windows 下 PNG 被看图程序占用会 PermissionError，别让它炸回执）
         qr_file = Path(__file__).parent / "qrcode_login.png"
         if qr_file.exists():
-            qr_file.unlink()
+            try:
+                qr_file.unlink()
+            except OSError as e:
+                print(f"[bili-mcp] 二维码文件删不掉（{type(e).__name__}: {e}）：{qr_file}", file=sys.stderr)
         return json.dumps({
             "status": "timeout",
             "message": "二维码已过期，请重新调用 bili_login 生成新二维码",
@@ -431,10 +460,13 @@ async def bili_login_check() -> str:
             }, f)
         os.replace(tmp_cred, CRED_FILE)
         _login_session = None
-        # 清理二维码文件
+        # 清理二维码文件（P3-47: 删失败只记 stderr —— DONE 分支反复重入比带着孤儿 PNG 重坏了）
         qr_file = Path(__file__).parent / "qrcode_login.png"
         if qr_file.exists():
-            qr_file.unlink()
+            try:
+                qr_file.unlink()
+            except OSError as e:
+                print(f"[bili-mcp] 二维码文件删不掉（{type(e).__name__}: {e}）：{qr_file}", file=sys.stderr)
         return json.dumps({
             "status": "done",
             "message": "登录成功！凭证已保存，现在可以使用所有B站功能了",
@@ -992,13 +1024,17 @@ async def bili_reply(bvid: str, text: str, rpid: IdInput = "0", root: IdInput =
                            "guard_status": "not_sent", "retry_blocked": False}, ensure_ascii=False)
 
     # ② 占坑：同一条评论（rpid）全机器只允许发一次；新评论按 BV 也只允许留一条
-    guard = _get_runtime_guard()
     try:
         key = key_video_reply(bvid, rpid)
     except Exception as e:
         return json.dumps({"success": False, "error": str(e),
                            "guard_status": "not_sent", "retry_blocked": False}, ensure_ascii=False)
-    reservation = guard.reserve_send(key, cross_channel_keys(rpid))
+    try:
+        guard = _get_runtime_guard()
+        # P3-46: SQLite busy>15s 的原始异常不能外泄 —— 包成 fail-closed JSON 回执
+        reservation = guard.reserve_send(key, cross_channel_keys(rpid))
+    except Exception as e:
+        return _guard_unavailable(e)
     if not reservation.get("allowed"):
         return _guard_blocked(reservation, "send",
                               "这条评论已经回过了" if rpid != "0" else "这条视频已经留过一条评论了")
@@ -1193,10 +1229,14 @@ async def bili_send_dynamic(
 
     text = text.strip()
     image_paths = [str(path).strip() for path in (images or [])[:9] if str(path or "").strip()]
-    guard = _get_runtime_guard()
-    reservation = guard.reserve_send(key_moment("dynamic", {
-        "text": text, "images": image_paths, "topic_id": str(topic_id), "schedule_time": schedule_time,
-    }))
+    try:
+        guard = _get_runtime_guard()
+        # P3-46: 占坑异常包成 fail-closed JSON，原始 traceback 不外泄
+        reservation = guard.reserve_send(key_moment("dynamic", {
+            "text": text, "images": image_paths, "topic_id": str(topic_id), "schedule_time": schedule_time,
+        }))
+    except Exception as exc:
+        return _guard_unavailable(exc)
     if not reservation["allowed"]:
         return _guard_blocked(reservation)
     try:
@@ -1272,6 +1312,7 @@ async def bili_upload_video(
 
     Returns:
         上传结果，包含BV号
+    ⚠️ 直跑无判重账本与节奏闸——仅限手动运行，自动化请走插件的 bili_pv（P2-17）
     """
     # ---- 参数校验 ----
     if not video_path or not video_path.strip():
@@ -1333,12 +1374,20 @@ async def bili_upload_video(
         async def on_event(data: dict):
             progress_info["phase"] = str(data)
 
-        result = await uploader.start()
+        # P2-17: uploader.start() 没有超时的话，挂死的上传在客户端超时后仍在后台继续，
+        # 公开投稿完成却无任何记录 —— 这里给 15 分钟墙钟，超时明确报错。
+        result = await asyncio.wait_for(uploader.start(), timeout=900)
         return json.dumps({
             "success": True,
             "message": "视频上传成功",
             "data": result if isinstance(result, dict) else str(result),
         }, ensure_ascii=False)
+    except asyncio.TimeoutError:
+        return json.dumps({
+            "success": False,
+            "error": "投稿上传超时（15 分钟）——网络或 B站 分片接口卡住；注意客户端超时后上传可能仍在后台进行，重试前先到创作中心确认有没有半截投稿",
+            "last_phase": progress_info.get("phase", "unknown") if "progress_info" in dir() else "init",
+        }, ensure_ascii=False)
     except Exception as e:
         return json.dumps({
             "success": False,
@@ -1375,6 +1424,7 @@ async def bili_upload_video_multi(
 
     Returns:
         上传结果
+    ⚠️ 直跑无判重账本与节奏闸——仅限手动运行，自动化请走插件的 bili_pv（P2-17）
     """
     cred = get_cred()
 
@@ -1418,12 +1468,18 @@ async def bili_upload_video_multi(
 
         uploader = VideoUploader(pages=pages, meta=meta, credential=cred)
 
-        result = await uploader.start()
+        # P2-17: 同 bili_upload_video —— 15 分钟墙钟，挂死的上传不能在后台无人知晓地继续
+        result = await asyncio.wait_for(uploader.start(), timeout=900)
         return json.dumps({
             "success": True,
             "message": f"多P视频上传成功（共{len(pages)}P）",
             "data": result if isinstance(result, dict) else str(result),
         }, ensure_ascii=False)
+    except asyncio.TimeoutError:
+        return json.dumps({
+            "success": False,
+            "error": "投稿上传超时（15 分钟）——网络或 B站 分片接口卡住；注意客户端超时后上传可能仍在后台进行，重试前先到创作中心确认有没有半截投稿",
+        }, ensure_ascii=False)
     except Exception as e:
         return json.dumps({"success": False, "error": str(e)}, ensure_ascii=False)
 
@@ -1450,10 +1506,14 @@ async def bili_send_opus(
         发布结果
     """
     image_paths = [str(path).strip() for path in (images or []) if str(path or "").strip()]
-    guard = _get_runtime_guard()
-    reservation = guard.reserve_send(key_moment("opus", {
-        "title": title, "content": content, "images": image_paths, "category_id": str(category_id),
-    }))
+    try:
+        guard = _get_runtime_guard()
+        # P3-46: 占坑异常包成 fail-closed JSON，原始 traceback 不外泄
+        reservation = guard.reserve_send(key_moment("opus", {
+            "title": title, "content": content, "images": image_paths, "category_id": str(category_id),
+        }))
+    except Exception as exc:
+        return _guard_unavailable(exc)
     if not reservation["allowed"]:
         return _guard_blocked(reservation)
     try:
@@ -1798,11 +1858,14 @@ async def bili_favorite_lists(uid: int = 0) -> str:
     """
     cred = get_cred()
     if uid == 0:
-        # 从凭证获取自己的UID
-        import json as _json
-        with open(CRED_FILE) as f:
-            data = _json.load(f)
-        uid = int(data.get("dedeuserid", 0))
+        # 从凭证获取自己的UID（P3-43: 改走硬化的 load_credential —— 原来裸 open 读凭证文件，
+        # dedeuserid 空串 → ValueError、文件中途被删 → FileNotFoundError，整工具裸 traceback）
+        own = load_credential()
+        dede = str(own.dedeuserid).strip() if own else ""
+        if not dede.isdigit():
+            return json.dumps({"error": "未登录或凭证不可读：拿不到自己的 UID（dedeuserid 为空或缺失），"
+                                        "请先调用 bili_login 重新扫码登录"}, ensure_ascii=False)
+        uid = int(dede)
 
     result = await favorite_list.get_video_favorite_list(uid=uid, credential=cred)
     fav_lists = []
@@ -1890,13 +1953,17 @@ async def bili_send_message(receiver_uid: IdInput, text: str, msg_seqno: IdInput
         return json.dumps({"success": False, "error": str(e),
                            "guard_status": "not_sent", "retry_blocked": False}, ensure_ascii=False)
 
-    guard = _get_runtime_guard()
     try:
         key = key_dm_reply(receiver_uid, body, msg_seqno)
     except Exception as e:
         return json.dumps({"success": False, "error": str(e),
                            "guard_status": "not_sent", "retry_blocked": False}, ensure_ascii=False)
-    reservation = guard.reserve_send(key, legacy_dm_keys(msg_seqno))
+    try:
+        guard = _get_runtime_guard()
+        # P3-46: 占坑异常（含账本库打不开）包成 fail-closed JSON，原始 traceback 不外泄
+        reservation = guard.reserve_send(key, legacy_dm_keys(msg_seqno))
+    except Exception as e:
+        return _guard_unavailable(e)
     if not reservation.get("allowed"):
         return _guard_blocked(reservation, "send", f"这条私信已经回过了（UID:{receiver_uid}）")
 
@@ -2483,7 +2550,6 @@ async def bili_reply_opus(opus_id: IdInput, text: str, rpid: IdInput = "0", root
         return json.dumps({"success": False, "error": f"取不到这条动态的评论区：{e}",
                            "guard_status": "not_sent", "retry_blocked": False}, ensure_ascii=False)
 
-    guard = _get_runtime_guard()
     try:
         key = key_opus_reply(oid_str, rpid)
     except Exception as e:
@@ -2493,7 +2559,12 @@ async def bili_reply_opus(opus_id: IdInput, text: str, rpid: IdInput = "0", root
     # 否则升级那一刻，昨天回过的那些今天会再回一遍。
     # 🔁 2026-10-25（使用者报「回一个人一条评论两条消息」）：**视频通道回过的同号 rpid 也认**
     #    —— 同一条评论只回一次，不管上一次走的是 bili_reply 还是 bili_reply_opus。
-    reservation = guard.reserve_send(key, [*legacy_opus_keys(rpid, root), *cross_channel_keys(rpid)])
+    try:
+        guard = _get_runtime_guard()
+        # P3-46: 占坑异常（含账本库打不开）包成 fail-closed JSON，原始 traceback 不外泄
+        reservation = guard.reserve_send(key, [*legacy_opus_keys(rpid, root), *cross_channel_keys(rpid)])
+    except Exception as e:
+        return _guard_unavailable(e)
     if not reservation.get("allowed"):
         return _guard_blocked(reservation, "send", "这条动态评论已经回过了")
 
@@ -2689,24 +2760,37 @@ async def bili_my_video_comments(num: int = 10, videos: int = 3) -> str:
 # ========== Tool: 判重账本状态（只读） ==========
 
 @tool()
-async def bili_guard_status(bvids: list = None, limit: int = 200) -> str:
+async def bili_guard_status(bvids: list = None, limit: int = 200, release: list = None) -> str:
     """
     看一眼**永久判重账本**（SQLite，重启不丢、跨进程共用）
 
     Args:
         bvids: 想核对的 BV 号列表（给了就只查这几条；不给就返回最近刷过的一批）
         limit: 最多返回几条（默认 200，上限 500）
+        release: 【unknown 槽位的人工解除入口】要解除的坑位 key 列表。只在人工核实
+                 「那次结果不明的发送确实没发出去」之后才用 —— 只有 status='unknown'
+                 的行会被删（pending/sent 绝不碰）；非空时本工具不再纯只读。
 
     Returns:
         counts（seen / sent / pending / unknown 各多少）、seenVideos（已刷过的 BV）、
-        activeReads（正在读的）、recentSends（最近发过什么 —— 只有键和元信息，**不含正文**）
+        activeReads（正在读的）、recentSends（最近发过什么 —— 只有键和元信息，**不含正文**）；
+        传了 release 时额外带 released：每个 key 是否真的解除了一行
     """
     guard = _get_runtime_guard()
+    released = []
+    if release:
+        # P1-2: unknown 槽位的人工解除入口 —— release_unknown 只删 unknown 行，
+        # 误传 pending/sent 的 key 时返回 false 并原样保留那行，绝不误删。
+        for key in release:
+            try:
+                released.append({"key": str(key), "released": bool(guard.release_unknown(str(key)))})
+            except Exception as e:
+                released.append({"key": str(key), "released": False, "error": str(e)})
     try:
         data = guard.snapshot(bvids=bvids, limit=limit)
     except Exception as e:
-        return json.dumps({"ok": False, "error": str(e)}, ensure_ascii=False)
-    return json.dumps({"ok": True, **data}, ensure_ascii=False)
+        return json.dumps({"ok": False, "error": str(e), "released": released}, ensure_ascii=False)
+    return json.dumps({"ok": True, "released": released, **data}, ensure_ascii=False)
 
 
 # ========== 启动 ==========

package/vendor/bilibili-mcp/runtime_guard.py

@@ -122,8 +122,12 @@ def stringify_ids(value):
                     result[key] = str(item)  # Python SDK integers are exact, unlike JSON numbers in JS.
                 elif isinstance(item, str) and re.fullmatch(r"[0-9]+", item.strip()):
                     result[key] = item.strip().lstrip("0") or "0"
+                elif isinstance(item, str):
+                    # P3-44: 非数值字符串原样保留（{"id":"hot-word-12"} 不能被静默清成 ""，
+                    # 模型会把「有数据」误读成「没有」）；空串在这里自然仍是空串（缺失）。
+                    result[key] = item
                 else:
-                    result[key] = ""  # unavailable/malformed is never guessed as another ID
+                    result[key] = ""  # 空值/非字符串仍按「缺失」处理，绝不猜成另一个 ID
             else:
                 result[key] = stringify_ids(item)
         return result
@@ -238,10 +242,15 @@ class RuntimeGuard:
             conn.close()
 
     def _connect(self):
-        conn = sqlite3.connect(str(self.db_path), timeout=15, isolation_level=None)
-        conn.row_factory = sqlite3.Row
-        conn.execute("PRAGMA busy_timeout=15000")
-        conn.execute("PRAGMA synchronous=FULL")
+        try:
+            conn = sqlite3.connect(str(self.db_path), timeout=15, isolation_level=None)
+            conn.row_factory = sqlite3.Row
+            conn.execute("PRAGMA busy_timeout=15000")
+            conn.execute("PRAGMA synchronous=FULL")
+        except sqlite3.OperationalError as exc:
+            # E2: node/python 临时目录解析不一致时这里报「unable to open database file」
+            # 且不带路径，排障只能盲猜 —— 报错必须带上 db_path 本身。
+            raise RuntimeError(f"runtime guard 打不开账本库 {self.db_path}: {exc}") from exc
         return conn
 
     @contextmanager
@@ -636,10 +645,27 @@ class RuntimeGuard:
                                    (reservation["key"], reservation["token"])).rowcount
             if changed != 1:
                 raise RuntimeError("guard reservation was lost; refusing an unsafe retry")
-            conn.execute("DELETE FROM guard_pace_events WHERE event_key=?", ("send:" + reservation["token"],))
+            # P2-16: 节奏事件不再删，改标 rejected 并保留 at/next —— burst/hour/gap
+            # （_pace_check 按 at/next 统计、不看 status）要把「确定没发出去」的尝试也计入，
+            # 否则坏凭据下模型可以对 B站 无限速连打（探针实测 12 连发全放行，
+            # 而 -352 的最短触发路径恰恰就是高频尝试）。
+            conn.execute("UPDATE guard_pace_events SET status='rejected' WHERE event_key=?",
+                         ("send:" + reservation["token"],))
             self._note_rejection(conn, code, now)
             return self._pace_check(conn, pace_kind(reservation["key"]), now)
 
+    def release_unknown(self, key):
+        """P1-2: unknown 槽位的**人工**解除入口。
+
+        只删 status='unknown' 的行（pending/sent 绝不可删：前者正被某个进程占着，
+        后者是发出去的铁账）；返回是否真的解除了一行。
+        调用前提是人工核实「那次结果不明的发送确实没发出去」—— 这不是自动重试的后门。
+        """
+        with self._transaction() as conn:
+            changed = conn.execute("DELETE FROM guard_entries WHERE key=? AND status='unknown'",
+                                   (str(key),)).rowcount
+            return changed == 1
+
     def pace_status(self, action):
         """Read the current common floor without reserving or consuming a send slot."""
         with self._transaction() as conn: