weflow-cli 1.11.1 → 1.13.0

package/scripts/jev_client.py

@@ -23,6 +23,7 @@
 """
 import json
 import os
+import sys
 import time
 import urllib.error
 import urllib.request
@@ -102,6 +103,122 @@ def _check_choice(key, question, answer):
                            % (key, picked, top))
 
 
+# ===== OpenRouter（第二条决策模型通路，D-120）=====
+#
+# **为什么需要它**：原生 `api.typesafe.ai` 在本机所在地区被挡（实测 HTTP 451
+# "not available in your region"），于是整层判断静默退化——最近 40 个完整天里
+# 0 篇带 relevanceScore。OpenRouter 上 TypeSafe 把同一个决策模型发布成了
+# `typesafe/jev-router`，从这里能通（实测 200）。
+#
+# ⚠️ **地理限制是逐模型的**（实测 2026-10-17）：
+#   · `typesafe/jev-router` → 通；
+#   · `:free` 的模型 → 通（零成本，但免费额度 50 次/天）；
+#   · 付费通用模型（如 `openai/gpt-4o-mini`）→ **HTTP 403 "This model is not available
+#     in your region."**，失败在路由的 "Gate Endpoints with Geo Restrictions" 一步。
+#   所以换模型时这条路必须重测，不能假定"能调一个就能调所有"。
+OPENROUTER_BASE = 'https://openrouter.ai/api/v1'
+OPENROUTER_ENDPOINT = OPENROUTER_BASE + '/chat/completions'
+OPENROUTER_MODELS_ENDPOINT = OPENROUTER_BASE + '/models'
+# 国内端点：这两条是本机实测能通、且都已有 key 的（D-120）。DeepSeek 是默认选择：
+# 1.0 秒/篇、key 已在配置里、无需新厂商，成本量级 ¥1/天（500 篇）。
+DEEPSEEK_BASE = 'https://api.deepseek.com/v1'
+DASHSCOPE_BASE = 'https://dashscope.aliyuncs.com/compatible-mode/v1'
+OPENROUTER_DEFAULT_MODEL = 'typesafe/jev-router'
+# OpenRouter 的两个归属头（可选，但官方文档建议带；不含任何用户数据）。
+OPENROUTER_REFERER = 'https://github.com/zhuobichen/weflow-cli'
+OPENROUTER_TITLE = 'weflow-cli'
+# 预算给得**大**是有原因的：jev-router 会路由到推理模型（实测 `x-ai/grok-4.7`、
+# `z-ai/glm-5.3-flash`），推理 token 会把预算吃光、正文留空。实测 max_tokens=800 时
+# 一个免费推理模型 finish_reason=length、content 为空 —— 那不是"模型不会"，是预算给少了。
+# 反过来，这个值也是 OpenRouter 预检额度的依据（额度不足会 402 并报"你只能负担 N tokens"）。
+OPENROUTER_MAX_TOKENS = 4000
+
+
+def _check_score(key, question, answer):
+    """`score` 答案必须是数字（`score_to_relevance` 会拿它取整索引）。
+
+    没有这一条会怎样：`score` 缺失时 `score_to_relevance` 抛的是 `JevError('缺少 score')`，
+    但一个**字符串**分数（模型回 "高"）会一路走到 `int(float('高'))` 抛 `ValueError`——
+    调用方的 `except JevError` 接不住，整天日报挂掉。所以在这里挡住。
+    """
+    if question.get('type') != 'score':
+        return
+    value = answer.get('score')
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise JevError('%s：score 答案里的 score 不是数字：%r' % (key, value))
+
+
+def _check_noul(key, question, answer):
+    """`noul` 答案必须是 [0,1] 的概率 —— **不是布尔**。
+
+    仓库里踩过同型的坑（D-034 附近）：把 noul 的浮点当布尔读，每个问题都读成"否"，
+    而输出还把责任推给模型。所以这里既挡 `true/false`，也挡越界的数。
+    """
+    if question.get('type') != 'noul':
+        return
+    value = answer.get('noul')
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise JevError('%s：noul 答案是概率（0~1 的小数），不是布尔：%r' % (key, value))
+    if not 0.0 <= float(value) <= 1.0:
+        raise JevError('%s：noul 概率不在 [0,1]：%r' % (key, value))
+
+
+def build_openrouter_prompt(state, questions):
+    """把类型化的问题渲染成一段 chat 提示，要求**只输出一个 JSON 对象**。
+
+    形状必须与原生 `systemone` 的 answers 一致，因为下游七个调用方读的是同一套键：
+    `choice` → `{probabilities, choice}`、`score` → `{score}`、`noul` → `{noul}`（概率）。
+    渲染的是**同一份** `questions`（含 criteria 与判据文本），所以换通路不换判据。
+    """
+    lines = ['你是判断器。读下面的材料，逐题作答，**只输出一个 JSON 对象**：',
+             '不要解释、不要 markdown 代码块、不要在 JSON 前后加任何其它字。', '', '题目（每题都要答，键名照抄）：']
+    shape = []
+    for name, question in (questions or {}).items():
+        kind = (question or {}).get('type')
+        instructions = (question or {}).get('instructions') or ''
+        if kind == 'choice':
+            criteria = (question or {}).get('criteria') or {}
+            lines.append('- %s（choice）：%s' % (name, instructions))
+            lines.append('  候选（probabilities 的键必须就是这些，且和等于 1）：')
+            for option, criterion in criteria.items():
+                lines.append('    · %s：%s' % (option, criterion))
+            shape.append('"%s": {"probabilities": {%s}, "choice": "<概率最大的候选>"}'
+                         % (name, ', '.join('"%s": 0.0' % o for o in criteria)))
+        elif kind == 'score':
+            criteria = (question or {}).get('criteria') or []
+            lines.append('- %s（score）：%s' % (name, instructions))
+            for index, criterion in enumerate(criteria):
+                lines.append('    %d = %s' % (index, criterion))
+            shape.append('"%s": {"score": 0}' % name)
+        elif kind == 'noul':
+            lines.append('- %s（noul）：%s' % (name, instructions))
+            lines.append('    noul 是"该陈述成立"的概率（0~1 的小数），**不是** true/false。')
+            shape.append('"%s": {"noul": 0.0}' % name)
+    lines += ['', '输出结构（严格照抄形状，数字自己填）：',
+              '{%s}' % ', '.join(shape),
+              '', '规则：probabilities 的键集与候选完全一致、和等于 1；choice 必须等于概率最大的键；',
+              'score 按上面的刻度取值；noul 是 0~1 的小数。', '', '材料：', str(state)]
+    return '\n'.join(lines)
+
+
+def _parse_json_object(content, label='响应'):
+    """从模型输出里取一个 JSON 对象。取不到就抛 `JevError`，**不猜、不修补**。"""
+    text = (content or '').strip()
+    if not text:
+        raise JevError('%s 里没有正文（空 content）——常见原因是推理 token 吃光了预算，'
+                       '把 OPENROUTER_MAX_TOKENS 调大再试' % label)
+    start, end = text.find('{'), text.rfind('}')
+    if start < 0 or end <= start:
+        raise JevError('%s 里没有 JSON 对象：%s' % (label, text[:200]))
+    try:
+        parsed = json.loads(text[start:end + 1])
+    except ValueError as error:
+        raise JevError('%s 不是合法 JSON（%s）：%s' % (label, error, text[start:end + 1][:200]))
+    if not isinstance(parsed, dict):
+        raise JevError('%s 的 JSON 顶层不是对象' % label)
+    return parsed
+
+
 def resolve_key(explicit='', config=None):
     """key 的取值顺序：显式传入 → `TYPESAFE_API_KEY` → 配置里（自动解密）。
 
@@ -286,9 +403,224 @@ class JevClient:
         }
 
 
-def create_client(api_key='', model=DEFAULT_MODEL, timeout=120, config=None):
-    """拿到 key 就返回客户端，没有就返回 None（调用方据此走老路）。"""
+class ChatJevClient(JevClient):
+    """**用任意 OpenAI 兼容的对话模型**充当决策模型（默认指 OpenRouter）。
+
+    与 `JevClient` **同一个鸭子类型**（`decide` / `decide_article` / `last_model`），所以
+    日报判断、检索重排、草稿回复、欠话台账那些调用方不需要知道换了通路。差别只有两处：
+
+      · 传输是 chat/completions（原生是 TypeSafe 自己的 `systemone` 端点）；
+      · 契约由**我们**在提示里写死、再由 `_check_choice` / `_check_score` / `_check_noul`
+        逐条验（原生是服务端直接给结构化答案，客户端只做校验）。多出来的这条"自己保证契约"
+        正是**换通路真正的代价**：它不该被藏起来，所以提示词与校验都在这里，且漂移会当场抛。
+
+    **base_url 可换，是这条路的核心价值**：同一个实现既能指 OpenRouter，也能指**中国地区能通的**
+    国内端点（`https://api.deepseek.com/v1`、`https://dashscope.aliyuncs.com/compatible-mode/v1`）。
+    【实测 2026-10-17】契约都对得上：
+
+      · `typesafe/jev-router`（OpenRouter）→ 过；· `openai/gpt-4o-mini` → **403 地区封锁**；
+      · `deepseek-chat` → 过（**1.0s**/篇）；· `deepseek-reasoner` → 过（7.2s）；
+      · `qwen-plus`（百炼）→ 过（2.3s）。
+
+    ⚠️ **契约一致不等于判断一致**：同一篇文章上 `deepseek-chat` 给 relevance=1 / noul=0.15，
+    `qwen-plus` 给 2 / 0.85。换判断器会改变取值分布，而下游阈值是对着 Jev 拍的——
+    这就是为什么原始分与 `usage.model` 都要落盘。
+    """
+
+    def __init__(self, api_key, model=OPENROUTER_DEFAULT_MODEL, timeout=120,
+                 max_tokens=OPENROUTER_MAX_TOKENS, base_url=OPENROUTER_BASE,
+                 extra_headers=None, provider='openrouter', engine=None):
+        super().__init__(api_key, model=model, timeout=timeout)
+        self.base_url = (base_url or OPENROUTER_BASE).rstrip('/')
+        self.extra_headers = dict(extra_headers or {})
+        self.max_tokens = max_tokens
+        # 记录自己是谁，方便落盘/报错时区分"哪条通路判的"。
+        self.provider = provider
+        # `engine` 不为空时**走它**（`AIEngine.chat()`）—— 本地 Ollama / LM Studio 就是这条。
+        # 这条存在的原因：`judgeProvider=chat` 必须尊重 `aiEngine=local`（见 D-124）。
+        self.engine = engine
+
+    def _endpoint(self):
+        return self.base_url + '/chat/completions'
+
+    def _post_once(self, url, payload=None):
+        """与原生同形，多带一份可配的头（OpenRouter 的归属头由预设给），并把**地区封锁**单独报出来。"""
+        data = None if payload is None else json.dumps(payload, ensure_ascii=False).encode('utf-8')
+        headers = {'Content-Type': 'application/json',
+                   'Authorization': f'Bearer {self.api_key}'}
+        headers.update(self.extra_headers)
+        request = urllib.request.Request(
+            url, data=data, method='POST' if data else 'GET', headers=headers)
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                return json.loads(response.read())
+        except urllib.error.HTTPError as error:
+            detail = ''
+            try:
+                detail = error.read().decode('utf-8', 'replace')[:400]
+            except Exception:
+                pass
+            # 403 在 OpenRouter 上有**两种**含义，混在一起会让人以为是 key 不对：
+            #   "not available in your region"（地区封锁，换模型才有用）vs 鉴权被拒。
+            if error.code == 403 and 'region' in detail.lower():
+                raise JevError(f'这个模型在当前地区不可用（HTTP 403）：{detail}')
+            if error.code == 402:
+                # 这条最容易被误读成"模型坏了"。实际是**预检额度**：OpenRouter 按
+                # max_tokens×单价 估一个上界，额度不够就拒，并告诉你负担得起多少。
+                raise JevError(f'OpenRouter 余额/额度不足（HTTP 402）：{detail}')
+            if error.code in (401, 403):
+                raise JevError(f'鉴权被拒（HTTP {error.code}）。key 可能不对或已过期：{detail}')
+            failure = JevError(f'HTTP {error.code}: {detail}')
+            failure.retryable = error.code in RETRY_STATUS
+            raise failure
+        except urllib.error.URLError as error:
+            failure = JevError(f'连不上 {url}: {error.reason}')
+            failure.retryable = True
+            raise failure
+
+    def models(self):
+        """OpenRouter 的模型清单（id 列表）。换地区/换模型时先在这里确认名字。
+
+        只有 OpenRouter 有这条接口；国内端点没有同形的清单，所以命中非 OpenRouter 时返回空列表
+        而不是报错 —— 调用方（`jev_probe`）本来就只用它做"名字写错了吗"的自检。
+        """
+        if 'openrouter.ai' not in self.base_url:
+            return []
+        body = self._post(OPENROUTER_MODELS_ENDPOINT)
+        return [m.get('id') for m in (body.get('data') or []) if isinstance(m, dict)]
+
+    def decide(self, state, questions):
+        """返回 `(answers, usage)`，形状与原生一致；**任何契约不成立都抛 `JevError`**。
+
+        `usage` 多带一个 `cost`（OpenRouter 直接回报美元成本，原生没有这个字段），
+        并把 OpenRouter 的 token 键名对齐成原生那套（`prompt_tokens`→`input_tokens`）——
+        `decide.py` 与 `jev_probe.py` 读的是后一个名字，名字对不上会让成本统计静默变成 0。
+        """
+        prompt = build_openrouter_prompt(state, questions)
+        content, usage = self._chat_once(prompt)
+        answers = _parse_json_object(content, 'chat 响应')
+        for key, question in (questions or {}).items():
+            if not isinstance(question, dict):
+                continue
+            answer = answers.get(key)
+            if not isinstance(answer, dict):
+                raise JevError('%s：响应里缺这一题的答案（%r）——契约漂移' % (key, answer))
+            _check_choice(key, question, answer)
+            _check_score(key, question, answer)
+            _check_noul(key, question, answer)
+        return answers, usage
+
+    def _chat_once(self, prompt):
+        """取一次文字回复，返回 `(content, usage)`。
+
+        有 `engine` 就走它（`AIEngine.chat()`，本地 Ollama / LM Studio 是这条）：那种情况
+        **拿不到 usage 里的 token 数与成本** —— 这是引擎层既有的边界（它只回字符串），
+        不是这里漏了；`model` 仍然会落盘，所以"谁判的"依然可查。
+        没有 `engine` 时走 OpenAI 兼容端点，token 与 cost 都能拿到。
+        """
+        if self.engine is not None:
+            content = self.engine.chat(prompt, max_tokens=self.max_tokens)
+            served = getattr(self.engine, 'model', '') or self.model
+            self.last_model = served
+            return content or '', {'model': served}
+        body = self._post(self._endpoint(), {
+            'model': self.model,
+            'messages': [{'role': 'user', 'content': prompt}],
+            'temperature': 0,
+            'max_tokens': self.max_tokens,
+        })
+        message = ((body.get('choices') or [{}])[0] or {}).get('message') or {}
+        usage = dict(body.get('usage') or {})
+        if 'prompt_tokens' in usage and 'input_tokens' not in usage:
+            usage['input_tokens'] = usage['prompt_tokens']
+        if 'completion_tokens' in usage and 'output_tokens' not in usage:
+            usage['output_tokens'] = usage['completion_tokens']
+        if body.get('model'):
+            # 路由到谁**每次都可能不同**（实测 grok-4.7 / glm-5.3-flash），所以落盘这个值
+            # 才有意义：不然"线上跑的和测过的不是同一个东西"永远不可见。
+            usage['model'] = body['model']
+            self.last_model = body['model']
+        return message.get('content') or '', usage
+
+
+def create_client(api_key='', model='', timeout=120, config=None):
+    """拿到 key 就返回客户端，没有就返回 None（调用方据此走老路）。
+
+    走哪条通路由配置 `judgeProvider` 决定，**默认 `native`**（与引入这个开关之前完全一致）：
+
+    · `native`     → `api.typesafe.ai`（本机被地区封锁，见 D-120）；
+    · `chat`       → **中国地区能通的对话模型**，走配置里已有的那套（`aiBaseUrl` 中转站 /
+      `aiModel` / `deepseekApiKey`）——一句话就能打开，不需要新厂商、新 key。
+      实测 `deepseek-chat` 1.0 秒/篇且契约通过，成本量级 ¥1/天；
+    · `openrouter` → OpenRouter 的 chat/completions，模型取 `openrouterJudgeModel`
+      （默认 `typesafe/jev-router`），key 取 `openrouterApiKey`。
+    """
+    judge_provider = ''
+    openrouter_key = openrouter_model = ''
+    chat_key = ''
+    chat_base = chat_model = None
+    try:
+        import _utils
+        judge_provider = (getattr(_utils, 'get_judge_provider')(config) or '').strip().lower()
+        openrouter_key = (getattr(_utils, 'get_openrouter_key')(config) or '').strip()
+        openrouter_model = (getattr(_utils, 'get_openrouter_model')(config) or '').strip()
+        # 中转站口径与"配置了 aiBaseUrl 的对话模型"同源（`_utils.get_chat_endpoint` 委托
+        # `_custom_endpoint`）：只配了 base 没配 model 时它会补 `deepseek-chat`。
+        chat_base, chat_model = getattr(_utils, 'get_chat_endpoint')(config) or (None, None)
+        chat_key = (getattr(_utils, 'get_api_key')(config) or '').strip()
+    except Exception:
+        # 配置读不出来就当没配（与 `get_typesafe_key` 同一态度：跨机器拷配置不该崩）。
+        # `judge_provider` 若已经读到而这里抛了，后面的分支会因为没有 key 返回 None ——
+        # 那是安全的方向（退回老路），不是静默用错通路。
+        pass
+    if judge_provider == 'chat':
+        # **先看用户选的是哪个引擎**：`judgeProvider=chat` 的语义是"用配置里的对话模型"。
+        # 无条件用 `deepseekApiKey` 会让 `aiEngine=local` 的用户被送出境外（D-124）。
+        engine_type = 'deepseek'
+        local_detect = None
+        try:
+            engine_type = (getattr(_utils, 'get_ai_engine')(config) or 'deepseek').strip().lower()
+            local_detect = getattr(_utils, 'detect_local_engine', None)
+        except Exception:
+            pass
+        if engine_type in ('local', 'ollama'):
+            ok, local_engine, desc = (False, None, '检测函数不可用')
+            if local_detect is not None:
+                try:
+                    ok, local_engine, desc = local_detect()
+                except Exception as error:               # noqa: BLE001
+                    desc = '%s: %s' % (type(error).__name__, error)
+            if not ok:
+                # **不退回云端**：宁可这次没有判断，也不把正文发去用户没选的地方。
+                print('[WARN] aiEngine=%s 但没检测到本地推理服务（%s）：判断器不会退回云端，'
+                      '这次不可用，判断将走 LLM 路径' % (engine_type, desc), file=sys.stderr)
+                return None
+            return ChatJevClient('local', model=getattr(local_engine, 'model', '') or 'local',
+                                 base_url=getattr(local_engine, 'base_url', '') or '',
+                                 engine=local_engine, timeout=timeout, provider='chat-local')
+        if engine_type == 'claude':
+            print('[WARN] judgeProvider=chat 只支持 OpenAI 兼容端点，aiEngine=claude 不行：'
+                  '要云端判断请用 judgeProvider=openrouter，或把 aiEngine 设回 deepseek',
+                  file=sys.stderr)
+            return None
+        if not chat_key:
+            print('[WARN] judgeProvider=chat 但没配对话模型的 key（deepseekApiKey）：'
+                  '决策模型这次不可用，判断将退回 LLM 路径', file=sys.stderr)
+            return None
+        # 配了 `aiBaseUrl`（中转站）就用它，否则直连 DeepSeek。
+        return ChatJevClient(chat_key, model=model or chat_model or 'deepseek-chat',
+                             base_url=chat_base or DEEPSEEK_BASE, timeout=timeout, provider='chat')
+    if judge_provider == 'openrouter':
+        if not openrouter_key:
+            print('[WARN] judgeProvider=openrouter 但没配 openrouterApiKey：'
+                  '决策模型这次不可用，判断将退回 LLM 路径', file=sys.stderr)
+            return None
+        return ChatJevClient(openrouter_key,
+                             model=model or openrouter_model or OPENROUTER_DEFAULT_MODEL,
+                             timeout=timeout, provider='openrouter',
+                             extra_headers={'HTTP-Referer': OPENROUTER_REFERER,
+                                            'X-Title': OPENROUTER_TITLE})
     key = resolve_key(api_key, config)
     if not key:
         return None
-    return JevClient(key, model=model, timeout=timeout)
+    return JevClient(key, model=model or DEFAULT_MODEL, timeout=timeout)

package/scripts/nt_decrypt.py

@@ -795,6 +795,51 @@ def get_favorites(db_path, key_hex, limit=100, offset=0, keyword=None, fav_type=
         return {"error": str(e).split('\n')[0][:200]}
 
 
+#: 非文本消息在**列表预览**里的显示形态。与 `sqlcipherCore.processMessage` 的口径一致。
+#: 列表预览只需要回答"这是什么"，不需要内容 —— 而 49 类的 `source` 往往是被压缩的
+#: appmsg，硬去剥 XML 标签只会得到 `(/`$` 这种碎片（2026-10-19 用户在 `sessions` 里看到）。
+_PREVIEW_LABELS = {
+    3: '[图片]', 34: '[语音]', 43: '[视频]', 47: '[表情]', 48: '[位置]',
+    42: '[名片]', 49: '[链接/文件]', 10000: '[系统消息]', 10002: '[系统消息]',
+}
+
+
+def _clean_preview(text, limit=50):
+    """预览用：清掉控制字符、压掉换行/连续空白、去掉行首的二进制残渣、截断。
+
+    行首清洗只针对 **ASCII 标点**：群消息的 `source` 有时前面带三四个字节的碎片
+    （实测一条广告消息长这样：`(/ }25984981651785937@openim:🔰周黑鸭…`），
+    不处理的话列表第一列就是这堆符号。中文标点与 emoji 开头**不动**——
+    `？好的`、`😂收到` 都是正常消息。
+    """
+    if not isinstance(text, str):
+        return ''
+    cleaned = ''.join(ch for ch in text if ch >= ' ' or ch == '\t')
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    # 空格也要算在"垃圾前缀"里：实测前缀是 `(/ }`，中间那个空格会把
+    # 「连续 ASCII 标点」这条匹配打断，于是整段清理失效（2026-10-19 实测）。
+    cleaned = re.sub(r'^[\x20-\x2f\x3a-\x40\x5b-\x60\x7b-\x7e]{1,8}(?=[A-Za-z0-9\u4e00-\u9fff])', '', cleaned)
+    return cleaned[:limit]
+
+
+def _looks_broken(text):
+    """这段"文本"其实是被当成文本的二进制吗？
+
+    判据只看两样：UTF-8 解码时留下的替换字符、以及不可打印字符的占比。
+    实测样本：一条 openim 消息的 `message_content` 解出来是
+    `(/ }25984981651785937@openim:` 加一个替换字符 —— 直接显示就是垃圾。
+    """
+    if not text:
+        return False
+    # 出现**任何**替换字符就说明原始字节不是合法 UTF-8 —— 正常中文/emoji 不会产生它。
+    # 阈值不能是"两个以上"：实测那条 openim 消息只在结尾丢了一个字节，
+    # 前面全是可打印的压缩碎片，比例判据根本拦不住。
+    if '\ufffd' in text:
+        return True
+    printable = sum(1 for ch in text if ch.isprintable())
+    return printable / max(1, len(text)) < 0.9
+
+
 def _summarise(row):
     """(last_time, summary) from the newest message row of a conversation."""
     last_time = row[0] or 0
@@ -803,22 +848,42 @@ def _summarise(row):
     content_text = row[2]
 
     if msg_type == 1:
-        # Text message: use message_content
-        if isinstance(content_text, str) and content_text:
-            return last_time, content_text[:50]
-        if isinstance(content_text, bytes):
-            return last_time, content_text.decode('utf-8', errors='ignore')[:50]
-        return last_time, ""
-
-    if isinstance(source_text, str) and source_text:
-        # Non-text: try to extract from source, stripping XML tags
+        # 文本：`message_content` 与 `source` 里**哪个更像人话就用哪个**。
+        # 只认 `message_content` 会踩到"这一列其实是二进制"的消息（见 `_looks_broken`）。
+        candidates = []
+        for value in (content_text, source_text):
+            if isinstance(value, bytes):
+                value = value.decode('utf-8', errors='ignore')
+            if isinstance(value, str) and value.strip():
+                candidates.append(value)
+        if not candidates:
+            return last_time, ""
+        best = min(candidates, key=lambda s: s.count('\ufffd') / max(1, len(s)))
+        if _looks_broken(best):
+            return last_time, '[内容无法显示]'
+        return last_time, _clean_preview(best)
+
+    # 非文本：先按类型给标签。**不再从 `source` 里剥标签抠文字** —— 那条路只有在
+    # XML 是明文 appmsg 时才成立，而 4.x 上它经常是压缩的，抠出来就是二进制碎片。
+    #
+    # `local_type` 在 4.x 里是**打包值**：高位放 subtype，低 32 位才是基础类型
+    # （实测 `25769803825` = 0x6_00000031，低 8 位 0x31 = 49 = 链接/文件）。
+    # 不 mask 的话，一张「链接卡片」会被报成 `[消息类型 25769803825]`。
+    raw_type = int(msg_type) if msg_type else 0
+    base_type = raw_type & 0xFFFFFFFF
+    label = _PREVIEW_LABELS.get(base_type)
+    if label:
+        return last_time, label
+
+    if isinstance(source_text, str) and source_text.strip():
         clean = re.sub(r'<[^>]+>', '', source_text)
-        lines = clean.split('\n')
-        if len(lines) > 1 and lines[1].strip():
-            return last_time, lines[1].strip()[:50]
         if clean.strip():
-            return last_time, clean.strip()[:50]
-    return last_time, ""
+            # 兜底也要过一遍"这其实是二进制吗"：某些消息两列都是压缩数据，
+            # 剥掉尖括号后看着像文字，实际是 `(/ }25984...` 这种碎片。
+            if _looks_broken(clean):
+                return last_time, '[内容无法显示]'
+            return last_time, _clean_preview(clean)
+    return last_time, ('[消息类型 %d]' % base_type) if base_type else ''
 
 
 def get_sessions(conns):

package/scripts/pipeline.py

@@ -13,6 +13,7 @@
   python scripts/pipeline.py --date 2026-06-09 --skip-classify
 """
 import sys, os, subprocess, time, shutil
+from datetime import datetime, timedelta
 from pathlib import Path
 
 SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -40,6 +41,10 @@ def main():
     parser.add_argument('--engine', default='deepseek',
                         help='AI 引擎: deepseek(默认) / claude / ollama / local')
     parser.add_argument('--date', help='日期 YYYY-MM-DD')
+    parser.add_argument('--yesterday', action='store_true',
+                        help='跑**昨天**（等价于 --date 昨天）。给计划任务用的：公众号发到 24:00 才停，'
+                             '当晚跑的那一天永远不全；而"跑昨天"与时刻无关 —— 机器当时在睡觉、'
+                             '起来补跑，结果完全相同（见 OPERATIONS「让它每天自己跑」）')
     parser.add_argument('--interest', default='AI', help='兴趣主题（默认 AI）')
     parser.add_argument('--wiki-limit', type=int, default=20, help='概念编译数量（默认 20）')
     parser.add_argument('--skip-classify', action='store_true', help='跳过后处理')
@@ -57,10 +62,20 @@ def main():
                              '注意：下游步骤（行动建议/概念编译/AI 报告）仍会用 LLM，'
                              '要全关请再加 --skip-classify --skip-ai-report')
     parser.add_argument('--ai-report-range', type=int, default=1, help='AI 报告覆盖最近 N 天（默认 1=仅当天）')
+    parser.add_argument('--prefetch-bodies', nargs='?', type=int, const=8, default=0, metavar='N',
+                        help='只转发给 biz_daily：Phase 1 之前先并发把这一天的正文抓进缓存'
+                             '（N=并发数，默认 8），让 Phase 1 走缓存命中、不再逐篇 sleep。'
+                             '450 篇约 75 分钟 → 秒级；对上游的请求次数不变（见 biz_daily.prefetch_bodies）')
     parser.add_argument('--source', action='append', default=[], metavar='NAME',
                         help='仅处理指定公众号，可重复或用逗号分隔')
     args = parser.parse_args()
 
+    if args.yesterday:
+        if args.date:
+            print('[ERROR] --date 与 --yesterday 不能同时给（前者是明确的一天，后者是"昨天"）')
+            sys.exit(1)
+        args.date = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
+
     sys.path.insert(0, SCRIPTS_DIR)
     from _utils import load_config, get_api_key
     config = load_config()
@@ -109,6 +124,12 @@ def main():
                   % '、'.join(n for n, skipped in (('classify_daily（行动建议）', args.skip_classify),
                                                    ('compile_wiki（概念编译）', not args.with_wiki))
                               if not skipped))
+    if args.prefetch_bodies:
+        # 原样转发：`--prefetch-bodies` 不带数字时 biz_daily 用自己的默认并发数，
+        # 所以这里不加数字（免得两处默认值各写一份、迟早漂移）。
+        step1_args += ['--prefetch-bodies']
+        if args.prefetch_bodies != 8:            # 显式给了数字才转发数字
+            step1_args += [str(args.prefetch_bodies)]
     if not run_step('biz_daily — 抓取+摘要', step1_args):
         sys.exit(1)