weflow-cli 1.11.1 → 1.13.0

package/scripts/_utils.py

@@ -648,6 +648,30 @@ def load_config():
         return json.load(f)
 
 
+# ---- 「不说话地失败」的最小护栏 ---------------------------------------------
+# 这个文件里有一批函数**故意不抛**（跨机器拷配置时，解不开的密文该表现为"没配"，
+# 而不是让整条命令崩）。但"不抛"不等于"不说"：`except: return ''` 会让调用方
+# 与用户都以为"本来就没有"，而真实原因是**解密失败/配置坏了**。
+# 所以这里只做一件事：同一条原因**说一次**，然后照旧返回空值。
+# 只说一次是必须的——这些函数每次请求/每次重排都会被调用，刷屏等于没警告。
+_WARNED_ONCE = set()
+
+
+def warn_once(tag, message):
+    """同一条原因只往 stderr 说一次（tag 相同即视为同一条）。"""
+    if tag in _WARNED_ONCE:
+        return
+    _WARNED_ONCE.add(tag)
+    import sys as _sys
+    print('[WARN] ' + message, file=_sys.stderr)
+    _sys.stderr.flush()
+
+
+def reset_warn_once():
+    """测试用：清空去重表。"""
+    _WARNED_ONCE.clear()
+
+
 # 配置里"不想在日报里看到的主题"的键名。值形如 `新闻,投资,学术`。
 EXCLUDED_TOPICS_KEY = 'dailyExcludeTopics'
 
@@ -876,11 +900,15 @@ def get_dashscope_key(config=None) -> str:
     if config is None:
         try:
             config = load_config()
-        except Exception:
+        except Exception as exc:
+            warn_once('load_config', '读不到配置文件 %s（%s: %s）—— 本次当作空配置，需要配置的功能会退化成默认行为'
+                      % (CONFIG_PATH, type(exc).__name__, exc))
             return ''
     try:
         return decrypt_lock(config.get('dashscopeApiKey', ''))
-    except Exception:
+    except Exception as exc:
+        warn_once('dashscopeApiKey', '配置项 dashscopeApiKey 解不开（%s: %s）—— 当作"没配"，语义检索会退成关键词'
+                  % (type(exc).__name__, exc))
         return ''
 
 
@@ -895,14 +923,102 @@ def get_typesafe_key(config=None) -> str:
     if config is None:
         try:
             config = load_config()
-        except Exception:
+        except Exception as exc:
+            warn_once('load_config', '读不到配置文件 %s（%s: %s）—— 本次当作空配置，需要配置的功能会退化成默认行为'
+                      % (CONFIG_PATH, type(exc).__name__, exc))
             return ''
     try:
         return decrypt_lock(config.get('typesafeApiKey', ''))
-    except Exception:
+    except Exception as exc:
+        warn_once('typesafeApiKey', '配置项 typesafeApiKey 解不开（%s: %s）—— 当作"没配"，决策模型退回 LLM 解析'
+                  % (type(exc).__name__, exc))
         return ''
 
 
+def get_openrouter_key(config=None) -> str:
+    """读取 OpenRouter 的 key（决策模型的第二条通路，D-120），自动解密 lock: 前缀。
+
+    与 `get_typesafe_key` 逐字同一条规矩：**跨机器拷配置时表现为"没配"，不是崩**。
+    解密失败回空串之后，`create_client()` 会返回 None，调用方按老路退回 ——
+    这是"这条路没配好"的**安全**失效方向。
+    """
+    if config is None:
+        try:
+            config = load_config()
+        except Exception as exc:
+            warn_once('load_config', '读不到配置文件 %s（%s: %s）—— 本次当作空配置，需要配置的功能会退化成默认行为'
+                      % (CONFIG_PATH, type(exc).__name__, exc))
+            return ''
+    try:
+        return decrypt_lock(config.get('openrouterApiKey', ''))
+    except Exception as exc:
+        warn_once('openrouterApiKey', '配置项 openrouterApiKey 解不开（%s: %s）—— 当作"没配"，OpenRouter 那条路会停用'
+                  % (type(exc).__name__, exc))
+        return ''
+
+
+def get_judge_provider(config=None) -> str:
+    """决策模型走哪条通路：`native`（默认）、`chat`（国内对话模型）或 `openrouter`。
+
+    **默认必须是 native**：这个开关存在的意义是"本机原生被地区封锁时换条路"，
+    而不是替所有用户改行为。取值不认识时也回 native —— 打错的配置项不该把判断整层关掉。
+    """
+    if config is None:
+        try:
+            config = load_config()
+        except Exception:
+            return 'native'
+    value = str((config or {}).get('judgeProvider') or '').strip().lower()
+    return value if value in ('native', 'chat', 'openrouter') else 'native'
+
+
+def get_chat_endpoint(config=None):
+    """`judgeProvider=chat` 时该往哪个 (base_url, model) 发 —— 与"中转站"同一条口径。
+
+    故意只做一件事：**委托 `_custom_endpoint()`**。那个函数是 `aiBaseUrl`/`aiModel` 的权威读法
+    （base 与 model 成对出现），判断器另写一份就会在"只配了 base 没配 model"这类组合上分叉，
+    而分叉的表现是"发去了错的端点"——不报错、只是判断质量变了。没配 `aiBaseUrl` 时返回 (None, None)。
+    """
+    try:
+        return _custom_endpoint()
+    except Exception:
+        return None, None
+
+
+def get_ai_engine(config=None) -> str:
+    """配置里选的对话引擎：`local` / `deepseek`（默认）/ `claude` / `ollama`。
+
+    **决策模型的 `chat` 通路必须读它**：`judgeProvider=chat` 的语义是"用**配置里的**对话模型"，
+    而"配置里的"到底指谁只有 `aiEngine` 说得清。2026-10-18 之前那条路无条件用 `deepseekApiKey`，
+    于是 `aiEngine=local` 的用户一开 `judgeProvider=chat` 就会把文章正文发去 DeepSeek ——
+    这不是"多花点钱"，是**用户明确选了不出境之后又被送出境**。
+    """
+    if config is None:
+        try:
+            config = load_config()
+        except Exception as exc:
+            warn_once('load_config', '读不到配置文件 %s（%s: %s）—— 本次当作空配置，需要配置的功能会退化成默认行为'
+                      % (CONFIG_PATH, type(exc).__name__, exc))
+            return 'deepseek'
+    return str((config or {}).get('aiEngine') or 'deepseek').strip().lower()
+
+
+def get_openrouter_model(config=None) -> str:
+    """OpenRouter 上用的模型 id（默认 `typesafe/jev-router`，即 TypeSafe 发布的决策模型）。
+
+    ⚠️ **地区限制是逐模型的**（实测 2026-10-17）：`typesafe/jev-router` 与 `:free` 模型能通，
+    付费通用模型（`openai/gpt-4o-mini`）在本地区返回 403。换模型必须重测，见 D-120。
+    """
+    if config is None:
+        try:
+            config = load_config()
+        except Exception as exc:
+            warn_once('load_config', '读不到配置文件 %s（%s: %s）—— 本次当作空配置，需要配置的功能会退化成默认行为'
+                      % (CONFIG_PATH, type(exc).__name__, exc))
+            return ''
+    return str((config or {}).get('openrouterJudgeModel') or '').strip()
+
+
 # ======================================================================
 # Markdown / Frontmatter
 # ======================================================================

package/scripts/backfill_articles.py

@@ -54,7 +54,8 @@ from _utils import load_config  # noqa: E402
 from biz_daily import (DEFAULT_RELEVANCE, DEFAULT_TOPIC, TOPICS,  # noqa: E402
                        _group_by_topic, _guess_topic, _serializable_article,
                        _tags_for_write, extract_article_info, fetch_article,
-                       get_db_keys, sanitize_filename, summary_section)
+                       fetch_article_cached, get_db_keys, sanitize_filename,
+                       summary_section)
 from _utils import strip_wx_ads_document, write_with_frontmatter  # noqa: E402
 
 TZ = timezone(timedelta(hours=8))
@@ -159,20 +160,32 @@ def select_topics(articles, topics):
     return [a for a in articles if a.get('topic') in topics]
 
 
-def fetch_bodies(articles, workers: int, log=None):
+def fetch_bodies(articles, workers: int, log=None, use_cache: bool = True):
     """并发把这批文章的正文抓回来，写进 `fetched_md`。
 
     **只抓正文，不碰图片**——`fetch_article` 返回的 markdown 里图片是链接，本脚本
     就此打住，不再像 `biz_daily` 那样逐张下到本地（那一步占了实测 30 秒/篇里的绝大部分）。
+
+    **走 `fetch_article_cached`（日报那条同一个缓存）**，理由是把"补历史"和"正日报"
+    接起来：补完的正文落在 `output/.cache/fetch/<md5(url)>.md`，随后逐天
+    `daily --date X` 全是缓存命中——而日报的 8–12 秒节流在它的**调用循环**里
+    （`biz_daily` 抓取那一段），命中缓存既不联网也不睡，所以正式路径能快速产出
+    与平常完全一样的完整日报（含摘要与配图）。反过来也一样：日报跑过的天，这里重抓
+    时直接命中，不会再去打扰上游。
+
+    `use_cache=False`（`--no-fetch-cache`）**只跳过"读"**：仍然照常联网，成功结果照常
+    写回缓存。这样"强制重抓"既是"这次不看旧缓存"，也是"把旧缓存刷新成新的"。
+    **失败不写缓存**（由 `fetch_article_cached` 保证），所以重抓失败不会把已有的有效
+    缓存清掉或弄脏。
     """
     todo = [a for a in articles
             if len(body_without_media(a.get('local_text'))) < MIN_BODY_CHARS and a.get('url')]
     if not todo:
-        return {'attempted': 0, 'ok': 0}
+        return {'attempted': 0, 'ok': 0, 'failed': 0}
 
     def one(article):
         try:
-            body = fetch_article(article['url'])
+            body, _hit = fetch_article_cached(article['url'], use_cache=use_cache)
         except Exception:
             return False
         if body:
@@ -184,9 +197,11 @@ def fetch_bodies(articles, workers: int, log=None):
     with ThreadPoolExecutor(max_workers=max(workers, 1)) as pool:
         for result in pool.map(one, todo):
             ok += 1 if result else 0
+    failed = len(todo) - ok
     if log:
-        log('    抓正文: 尝试 %d，成功 %d，并发 %d' % (len(todo), ok, workers))
-    return {'attempted': len(todo), 'ok': ok}
+        log('    抓正文: 尝试 %d，成功 %d%s，并发 %d'
+            % (len(todo), ok, ('，失败 %d' % failed) if failed else '', workers))
+    return {'attempted': len(todo), 'ok': ok, 'failed': failed}
 
 
 def _read_index(day_dir) -> dict:
@@ -226,7 +241,7 @@ def _merge_articles(kept, fresh):
     return sorted(merged.values(), key=lambda e: (str(e.get('time', '')), str(e.get('title', ''))))
 
 
-def write_day(articles, day, out_root, topic_filter=None, truncated=False):
+def write_day(articles, day, out_root, topic_filter=None, truncated=False, fetch_failed=0):
     """落盘：`<日期>/<主题>/<来源>-<标题>.md` + `.articles.json` + README。
 
     格式与 `biz_daily` 一致——`create_reading_notes` 与 `compile_wiki` 都按那个形状读。
@@ -324,6 +339,17 @@ def write_day(articles, day, out_root, topic_filter=None, truncated=False):
     if truncated or prior.get('truncated'):
         # `truncated` 一旦记上就不撤销：这一次没截，不代表上一次截掉的那些补回来了。
         payload['truncated'] = True
+    # **抓取失败要与"正文本来就短"分开记**，否则一句"跳过 N 篇（正文太短）"把两件事混成
+    # 一件：前者这一轮可重试、后者是文章自己的属性。这个标记让 `day_done` 把这一天判成
+    # **没做完**，于是下次重跑会再试一遍——正文命中缓存的那批不花钱，只重试失败的。
+    #
+    # 它**不是 sticky 的**（与 `truncated` 不同）：全量跑完一轮、一篇都没失败，就说明
+    # 上一次失败的那些也补齐了，标记该消失。但**局部**跑（`--topic`）只覆盖一部分文章，
+    # 它没重试到的那些（别的主题）还在，所以那一档只保证"至少还有这么多"，取两轮的较大者。
+    carried_failed = int(prior.get('fetchFailed') or 0)
+    failed_total = fetch_failed if topic_filter is None else max(fetch_failed, carried_failed)
+    if failed_total:
+        payload['fetchFailed'] = failed_total
     (out_dir / '.articles.json').write_text(
         json.dumps(payload, ensure_ascii=False, indent=2), encoding='utf-8')
     if scope_filter:
@@ -333,11 +359,19 @@ def write_day(articles, day, out_root, topic_filter=None, truncated=False):
         scope = ''
     # README 说的是**这一天**有几篇（合并后的），不是这一轮写了几篇 —— 分两次回填的那天，
     # 前者才是读它的人想要的数。
+    failed_note = ''
+    if failed_total:
+        # 让人**看得见**这天没做完：README 是这个目录里唯一给人看的文件，
+        # 只写"共 N 篇"会让"少了 N 篇"读起来像"这天就这些文章"。
+        failed_note = ('\n其中 **%d 篇正文没抓到**（网络/来源问题），这一天不算完成；'
+                       '重跑会只重试这些篇（其余走缓存）。\n' % failed_total)
     (out_dir / 'README.md').write_text(
         '# 公众号文章 — %s（历史回填）\n\n共 %d 篇。正文由 `backfill_articles.py` 抓取，'
-        '**未下载图片、未调用模型**。\n%s' % (day, len(payload['articles']), scope), encoding='utf-8')
+        '**未下载图片、未调用模型**。\n%s%s' % (day, len(payload['articles']), scope, failed_note),
+        encoding='utf-8')
     return {'written': len(written), 'skipped': len(skipped),
-            'fallbackTopics': fallbacks, 'skipSample': skipped[:3]}
+            'fallbackTopics': fallbacks, 'skipSample': skipped[:3],
+            'fetchFailed': failed_total}
 
 
 def copy_to_vault(day: str, out_root: str, vault_root: str) -> dict:
@@ -429,6 +463,11 @@ def day_done(out_root, day, topics=None) -> bool:
         return False
     if payload.get('truncated'):
         return False
+    if payload.get('fetchFailed'):
+        # 上一次这天有文章**抓取失败**（不是"正文本来就短"）。不算做完 ⇒ 下次重跑会再试。
+        # 不计这一条的话，一次网络抖动就会被"这天已回填"永久埋掉：文件在、索引在、md 也有，
+        # 少的那几篇谁都看不出来。仓库里量过同类事故：84 次失败里 28 次重试就能拿到。
+        return False
     stored = payload.get('topicFilter')
     if stored is None:
         return True            # 完整的一天，所有主题都在
@@ -460,7 +499,13 @@ def main():
                         help='只回填这些主题（可重复或逗号分隔，合法值 %s），不写=全部。'
                              '只回填过一部分主题的一天，之后跑全量时不会被跳过。'
                              % '/'.join(TOPICS))
-    parser.add_argument('--refresh', action='store_true', help='已回填过的天也重做（默认跳过）')
+    parser.add_argument('--no-fetch-cache', action='store_true',
+                        help='忽略正文抓取缓存，强制重新抓取（默认命中缓存，用于续跑与重跑）。'
+                             '与日报的同名开关行为一致；**与 --refresh 不是一回事**，'
+                             '后者重做"哪几天"，它重抓"哪几篇的正文"')
+    parser.add_argument('--refresh', action='store_true',
+                        help='已回填过的天也重做（默认跳过）。它决定**处理哪些天**，'
+                             '不改变正文的抓取方式——要绕过缓存重抓正文用 --no-fetch-cache')
     parser.add_argument('--max-days', type=int, default=0, help='最多处理几天（0=不限，用于试跑）')
     parser.add_argument('--dry-run', action='store_true', help='只报到要抓多少，不抓不写')
     parser.add_argument('--yes', action='store_true', help='确认抓取并写入文件')
@@ -592,16 +637,21 @@ def main():
     report = []
     for index, (day, articles, truncated) in enumerate(todo, 1):
         print('\n[%d/%d] %s — 选中 %d 篇' % (index, len(todo), day, len(articles)))
-        fetch = fetch_bodies(articles, args.workers, log=print)
-        result = write_day(articles, day, args.out, topic_filter=topics, truncated=truncated)
+        fetch = fetch_bodies(articles, args.workers, log=print,
+                             use_cache=not args.no_fetch_cache)
+        result = write_day(articles, day, args.out, topic_filter=topics, truncated=truncated,
+                            fetch_failed=fetch['failed'])
         print('    写入 %d 篇，跳过 %d 篇（正文太短），主题兜底 %d 篇'
               % (result['written'], result['skipped'], result['fallbackTopics']))
+        if fetch['failed']:
+            print('    ⚠ 有 %d 篇正文没抓到：这天不算完成，重跑会只重试这些篇'
+                  % fetch['failed'])
         if args.vault_copy:
             sync = copy_to_vault(day, args.out, args.vault_root)
             print('    入 Vault 的 Sources: %d 个 md' % sync['copied'])
         report.append({'date': day, 'inDb': len(articles), 'fetched': fetch['ok'],
-                       'written': result['written'], 'skippedThin': result['skipped'],
-                       'truncated': truncated})
+                       'fetchFailed': fetch['failed'], 'written': result['written'],
+                       'skippedThin': result['skipped'], 'truncated': truncated})
     conn.close()
 
     total_written = sum(r['written'] for r in report)

package/scripts/biz_daily.py

@@ -64,6 +64,7 @@ FETCH_TIMEOUT = 15
 DEEPSEEK_TIMEOUT = 60
 FETCH_DELAY_MIN = 8   # 最小抓取间隔 (秒)
 FETCH_DELAY_MAX = 12  # 最大抓取间隔 (秒)
+PREFETCH_WORKERS = 8  # `--prefetch-bodies` 不带数字时的并发数（预热正文缓存，见 prefetch_bodies）
 
 # TOPICS 现在从 _utils 导入（见文件头的 import）——分类法只有一份定义，
 # 因为"散文写的枚举"已经漂过一次：这里曾硬编码五类，而 TOPICS 是六类。
@@ -141,6 +142,58 @@ def _tags_for_write(article, topic):
     return article.get('tags', [topic])
 
 
+def _article_key(entry):
+    """同一篇文章的合并键：url 优先（微信文章 url 唯一），没有 url 时退回标题+时间。"""
+    url = str(entry.get('url') or '').strip()
+    if url:
+        return url
+    title = str(entry.get('title') or '').strip()
+    if not title:
+        return ''
+    return 'no-url:%s|%s' % (title, entry.get('time') or '')
+
+
+def merge_articles_json(json_path, date_str, serializable, decision_model=None):
+    """把这一批**并进** `.articles.json`，返回落盘的全部条目（按时间排序）。
+
+    为什么必须合并：同一天可能跑两次（午报 13 点 + 日终 24 点）。第二次进来时
+    `.run_state.json` 已经把上午处理过的文章跳过了，所以这批只有下午新到达的那些；
+    若覆盖写，上午那批的标题/摘要/主题/relevance 就从这个文件里消失。而 README 与
+    `index.html` 是**从磁盘上的 md 重建**的 —— 于是"页面是全天、结构化数据只有半天"，
+    下游（AI 报告、daily-stats、知识库统计）静默少一半，没有任何地方会报错。
+    `.image_map.json` 早就是合并写的（`existing_map.update(...)`），这里只是把它缺的那半补上。
+    """
+    merged = {}
+    previous_model = None
+    if json_path.exists():
+        try:
+            old = json.loads(json_path.read_text(encoding='utf-8'))
+            previous_model = old.get('decisionModel')
+            for entry in old.get('articles') or []:
+                key = _article_key(entry)
+                if key:
+                    merged[key] = entry
+        except Exception:
+            # 旧文件坏了不该让今天失败：从空开始（与 `.image_map.json` 同一态度）
+            print('  [WARN] 旧的 .articles.json 读不了，这次从空开始（旧条目不参与合并）')
+    for entry in serializable:
+        key = _article_key(entry)
+        if key:
+            merged[key] = entry
+    articles = sorted(merged.values(), key=lambda e: (e.get('time') or '', e.get('title') or ''))
+    payload = {
+        'generated_at': datetime.now(timezone(timedelta(hours=8))).strftime('%Y-%m-%d %H:%M:%S'),
+        'date': date_str,
+        # 本次没判断（`--no-ai`）时不要用 None 盖掉上一次记下的模型名：那会让
+        # "这天是谁判的"在重跑后凭空消失。
+        'decisionModel': decision_model if decision_model is not None else previous_model,
+        'articles': articles,
+    }
+    json_path.parent.mkdir(parents=True, exist_ok=True)
+    json_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding='utf-8')
+    return articles
+
+
 def _serializable_article(article, date_str):
     """一篇文章 -> `.articles.json` 里的那条记录。
 
@@ -666,6 +719,43 @@ def fetch_article_cached(url: str, use_cache: bool = True) -> tuple[str | None,
     return body, False
 
 
+def prefetch_bodies(articles, workers=PREFETCH_WORKERS, log=None):
+    """**并发**把这一批文章的正文抓进缓存（`output/.cache/fetch/`），只抓不写盘。
+
+    为什么值得有：Phase 1 是**串行**的，而且未命中缓存时每篇要 `sleep` 8~12 秒（节流是为了
+    少打扰上游）——450 篇就是约 75 分钟。而**命中缓存既不联网也不 sleep**（见
+    `fetch_article_cached`），所以先把正文并发抓下来，Phase 1 就变成秒级。
+    对上游的**请求总次数完全相同**，区别只是把同样多的请求压进更短的时间窗 ——
+    这是一个显式取舍，所以默认**关**，由 `--prefetch-bodies` 打开。
+
+    失败**不抛也不报错退出**：Phase 1 还会再试一次（那里才是"这篇到底有没有正文"的判据）。
+    返回 `{'requested', 'ok'}`。
+    """
+    urls = []
+    for a in articles:
+        url = a.get('url')
+        if url and url not in urls:
+            urls.append(url)
+    if not urls:
+        return {'requested': 0, 'ok': 0}
+
+    def _one(url):
+        try:
+            body, _cached = fetch_article_cached(url)
+            return bool(body and body.strip())
+        except Exception:                     # noqa: BLE001  单篇炸了不能拖掉整批
+            return False
+
+    done = ok = 0
+    with ThreadPoolExecutor(max_workers=max(1, int(workers))) as pool:
+        for hit in pool.map(_one, urls):
+            done += 1
+            ok += 1 if hit else 0
+            if log and (done % 50 == 0 or done == len(urls)):
+                log('  预热 %d/%d（成功 %d）' % (done, len(urls), ok))
+    return {'requested': len(urls), 'ok': ok}
+
+
 def _download_one_image(url: str, local_path: Path) -> bool:
     """取一张图。成功返回 True；失败**不抛**——一张图挂了不该影响这一篇的其它图。"""
     try:
@@ -846,6 +936,12 @@ def main():
     parser.add_argument('--no-ai', action='store_true', help='关闭摘要、分类和日报简报的 AI 调用')
     parser.add_argument('--no-fetch-cache', action='store_true',
                         help='忽略正文抓取缓存，强制重新抓取（默认命中缓存，用于续跑与重跑）')
+    parser.add_argument('--prefetch-bodies', nargs='?', type=int, const=PREFETCH_WORKERS, default=0,
+                        metavar='N',
+                        help='Phase 1 之前先**并发**把这一天的正文抓进缓存（N=并发数，默认 %d）——'
+                             'Phase 1 于是全部命中缓存、不再逐篇 sleep（450 篇约 75 分钟 → 秒级）。'
+                             '对上游的请求次数不变，只是压进更短的时间窗，所以默认关（见 prefetch_bodies）'
+                             % PREFETCH_WORKERS)
     parser.add_argument('--no-summary', action='store_true',
                         help='只要判断、不要生成：完全跳过 LLM 调用（摘要/标签/概念/简报），'
                              '主题与相关度仍由 Jev 判断；因此**不需要 DeepSeek key**')
@@ -1003,6 +1099,17 @@ def main():
     # Output folder already created above (with dedup state)
     print(f'输出目录: {out_dir}\n')
 
+    # ====== Phase 0: 并发预热正文缓存（可选，`--prefetch-bodies`）======
+    if args.prefetch_bodies and not args.no_fetch_cache:
+        print(f'=== Phase 0: 并发预热正文缓存（{args.prefetch_bodies} 并发）===\n')
+        prefetch = prefetch_bodies(articles, args.prefetch_bodies, log=print)
+        print(f'预热完成：{prefetch["ok"]}/{prefetch["requested"]} 篇进了缓存'
+              f'（没进的 Phase 1 会再试一次）\n')
+    elif args.prefetch_bodies:
+        # 说清楚为什么没做：`--no-fetch-cache` 让 Phase 1 绕过缓存，预热等于白抓一遍。
+        print('[WARN] 同时给了 --no-fetch-cache 与 --prefetch-bodies：'
+              '前者让 Phase 1 绕过缓存，预热没有意义，已跳过\n')
+
     # ====== Phase 1: Fetch all articles ======
     print(f'=== Phase 1: 抓取 {len(articles)} 篇文章 ===\n')
     cache_hits = 0
@@ -1218,19 +1325,14 @@ def main():
               f'已归入兜底类「{DEFAULT_TOPIC}」（不是判断结果）')
 
     # --- 写入结构化 JSON：一次提取，多次复用（供 AI 报告等下游使用） ---
+    # **合并写**：同一天跑两次（午报 + 日终）时，这一批只有新到达的文章，
+    # 覆盖写会把上一批从文件里抹掉（详解见 `merge_articles_json` 的 docstring）。
     serializable = [_serializable_article(a, date_str) for a in articles]
 
     json_path = out_dir / '.articles.json'
     try:
-        with open(json_path, 'w', encoding='utf-8') as f:
-            json.dump({
-                'generated_at': datetime.now(timezone(timedelta(hours=8))).strftime('%Y-%m-%d %H:%M:%S'),
-                'date': date_str,
-                # 只增字段：老读者不认识它会忽略；但"这次是谁判的"从此有据可查。
-                'decisionModel': decision_model,
-                'articles': serializable,
-            }, f, ensure_ascii=False, indent=2)
-        print(f'  ✓ 结构化数据: {json_path} ({len(serializable)} 篇)')
+        merged_articles = merge_articles_json(json_path, date_str, serializable, decision_model)
+        print(f'  ✓ 结构化数据: {json_path} ({len(merged_articles)} 篇，本次新增 {len(serializable)} 篇)')
     except Exception as e:
         print(f'  [WARN] JSON 写入失败: {e}')
 
@@ -1303,8 +1405,13 @@ def main():
                     if map_file.exists():
                         try:
                             existing_map = json.loads(map_file.read_text(encoding='utf-8'))
-                        except:
-                            pass
+                        except Exception as exc:
+                            # 读不出来的旧映射表会让**之前几天的图片**从 HTML 里消失，
+                            # 而这一篇看起来还是成功的。宁可丢这一批映射，也要说清是什么原因。
+                            print('  [WARN] 旧的 .image_map.json 读不了（%s: %s）—— 这次从空表开始，'
+                                  '旧的图片映射会丢（HTML 里那些图可能显示不出来）'
+                                  % (type(exc).__name__, exc), file=sys.stderr)
+                            existing_map = {}
                     existing_map.update(url_mapping)
                     map_file.write_text(json.dumps(existing_map, ensure_ascii=False, indent=2), encoding='utf-8')
 

package/scripts/daily_task.ps1

@@ -0,0 +1,132 @@
+# Runs a daily report pass, with everything written to logs/daily-<date>.log.
+#
+# Two modes, because a WeChat official-account day only fills up gradually:
+#
+#   daily_task.ps1 noon   -> today so far (run at 13:00; half a day of push messages)
+#   daily_task.ps1        -> yesterday, complete (run at 00:05; same as before)
+#
+# The second pass is incremental by design: `.run_state.json` makes biz_daily skip the
+# articles the noon pass already handled, so 00:05 only fetches/summarises what arrived
+# in the afternoon, while README/index.html are rebuilt from every md on disk.
+#
+# Why this wrapper exists instead of putting the command straight into the scheduled task:
+#
+#  1. The task must not depend on a build artifact. It calls the python layer
+#     (scripts/pipeline.py) directly, which is the same source the repo builds from.
+#  2. A task whose output goes nowhere answers "it failed" and nothing else. One log
+#     file per run, so "why was yesterday short?" has an answer.
+#  3. Redirecting stdout to a FILE changes python's stdout encoding (it stops being the
+#     console and becomes the locale codepage). A title containing a character outside
+#     that codepage would then raise UnicodeEncodeError *after* the day was already
+#     written, i.e. the run looks like a failure while the artifacts are fine. Hence
+#     PYTHONIOENCODING/PYTHONUTF8 below.
+#
+# Extra arguments are appended, so `daily_task.ps1 --help` is a safe smoke test (it
+# prints the pipeline's help into that day's log and exits without touching anything).
+$ErrorActionPreference = 'Stop'
+
+$root = Split-Path -Parent $PSScriptRoot
+$logDir = Join-Path $root 'logs'
+if (-not (Test-Path $logDir)) { New-Item -ItemType Directory -Path $logDir | Out-Null }
+
+# Mode is the first positional word; anything else is forwarded to pipeline.py.
+$mode = 'day'
+$rest = @($args)
+if ($args.Count -gt 0 -and ($args[0] -eq 'noon' -or $args[0] -eq 'day')) {
+    $mode = $args[0]
+    $rest = if ($args.Count -gt 1) { @($args[1..($args.Count - 1)]) } else { @() }
+}
+
+$today = (Get-Date).ToString('yyyy-MM-dd')
+$yesterday = (Get-Date).AddDays(-1).ToString('yyyy-MM-dd')
+$targetDay = if ($mode -eq 'noon') { $today } else { $yesterday }
+
+$stamp = Get-Date -Format 'yyyy-MM-dd'
+$suffix = if ($mode -eq 'noon') { '-noon' } else { '' }
+$out = Join-Path $logDir ('daily-{0}{1}.log' -f $stamp, $suffix)
+$err = Join-Path $logDir ('daily-{0}{1}.err.log' -f $stamp, $suffix)
+
+$env:PYTHONIOENCODING = 'utf-8'
+$env:PYTHONUTF8 = '1'
+
+$python = (Get-Command python.exe).Source
+$script = Join-Path $PSScriptRoot 'pipeline.py'
+$modeArgs = if ($mode -eq 'noon') { @('--date', $today) } else { @('--yesterday') }
+$allArgs = @($script) + $modeArgs + @('--prefetch-bodies') + $rest
+
+# Idempotent "make sure the target day is as complete as it can be right now", not
+# "run at 08:20".
+#
+# Why: this machine slept from 2026-10-17 02:09 to 2026-10-18 15:26 and BOTH 08:20
+# triggers were counted as missed while StartWhenAvailable=On did not start the task
+# on wake (NumberOfMissedRuns=2, no run). A schedule that only fires if the machine
+# happens to be awake at one instant is not a schedule. With the guard below the task
+# can be triggered cheaply and often (schedule + at logon): if the target is already
+# done this exits in milliseconds, otherwise it produces/extends the day.
+#
+# The day-mode guard deliberately does NOT trust index.html alone: the noon pass also
+# writes one, so "index.html exists" would make the 00:05 pass skip the afternoon and
+# leave the day half-done behind a complete-looking page. `.articles.json`'s
+# generated_at tells us when the last pass actually ran; anything during that day
+# (before 23:00) is a mid-day artifact and must be extended.
+#
+# Note the day pass runs at 00:05 **the next day**, so a finished day is one whose
+# generated_at is later than the day itself - not one stamped at 23:xx. Testing
+# `hour -ge 23` alone would have made every 00:05 run redo the whole day (observed
+# while verifying this guard: generated_at 00:20 was judged incomplete).
+function Test-DayComplete([string]$dir, [string]$targetDay) {
+    $idx = Join-Path $dir 'index.html'
+    if (-not (Test-Path $idx)) { return $false }
+    $art = Join-Path $dir '.articles.json'
+    if (-not (Test-Path $art)) { return $true }   # old artifact without json: trust it
+    try {
+        $j = Get-Content $art -Raw -Encoding UTF8 | ConvertFrom-Json
+        $gen = [datetime]::ParseExact([string]$j.generated_at, 'yyyy-MM-dd HH:mm:ss', $null)
+        $genDay = $gen.ToString('yyyy-MM-dd')
+        # finished = generated on a later day (the usual 00:05 pass), or late the same night
+        return (($genDay -gt $targetDay) -or (($genDay -eq $targetDay) -and ($gen.Hour -ge 23)))
+    } catch { return $true }
+}
+
+# Skipped when arguments are passed, so `daily_task.ps1 --help` still works as a
+# smoke test with no side effects.
+if ($rest.Count -eq 0) {
+    $dayDir = Join-Path $root ('output\biz-daily\' + $targetDay)
+    $done = if ($mode -eq 'noon') { Test-Path (Join-Path $dayDir '.noon_done') } else { Test-DayComplete $dayDir $targetDay }
+    if ($done) {
+        $note = '===== {0}  [{1}] {2} already complete - skip =====' -f `
+            (Get-Date -Format 'yyyy-MM-dd HH:mm:ss'), $mode, $targetDay
+        Add-Content -Path (Join-Path $logDir 'daily-task.log') -Value $note -Encoding UTF8
+        exit 0
+    }
+}
+
+# Start-Process OVERWRITES its redirect targets, so a same-day rerun would erase the log
+# of the run that just failed - exactly the one worth keeping. Rotate any existing pair to
+# daily-<date>.run<N>[.err].log first, so every attempt stays on disk. N is the first free
+# index, which also works when several reruns happen in one day.
+if (Test-Path $out) {
+    $n = 1
+    while (Test-Path (Join-Path $logDir ('daily-{0}{1}.run{2}.log' -f $stamp, $suffix, $n))) { $n++ }
+    Move-Item -Path $out -Destination (Join-Path $logDir ('daily-{0}{1}.run{2}.log' -f $stamp, $suffix, $n))
+    if (Test-Path $err) {
+        Move-Item -Path $err -Destination (Join-Path $logDir ('daily-{0}{1}.run{2}.err.log' -f $stamp, $suffix, $n))
+    }
+}
+
+# Start-Process writes the raw bytes through: no PowerShell error-record wrapping, and
+# no shell quoting to get wrong.
+$proc = Start-Process -FilePath $python -ArgumentList $allArgs -NoNewWindow -Wait -PassThru `
+    -RedirectStandardOutput $out -RedirectStandardError $err
+
+if ($proc.ExitCode -eq 0 -and $rest.Count -eq 0) {
+    # Marker for the noon pass only; the day pass is judged by generated_at above.
+    if ($mode -eq 'noon') {
+        $dayDir = Join-Path $root ('output\biz-daily\' + $targetDay)
+        if (Test-Path $dayDir) {
+            Set-Content -Path (Join-Path $dayDir '.noon_done') -Value (Get-Date -Format 'yyyy-MM-dd HH:mm:ss') -Encoding UTF8
+        }
+    }
+}
+
+exit $proc.ExitCode