weflow-cli 1.7.0 → 1.8.0

package/scripts/_utils.py

@@ -1,8 +1,7 @@
 """
 weflow-cli 公共工具函数 — 供 biz_daily / classify_daily / chat_report 等共用。
 """
-import os, json, base64, socket, urllib.request, hashlib, time
-from concurrent.futures import ThreadPoolExecutor, as_completed
+import os, json, base64, socket, urllib.request, hashlib
 from functools import wraps
 
 
@@ -340,68 +339,237 @@ def clear_cache(cache_subdir: str = ''):
         fpath = os.path.join(target, fname)
         if os.path.isfile(fpath):
             os.unlink(fpath)
-
-
 # ======================================================================
-# 并发 API 调用 — 替代串行 + time.sleep() 模式
+# Config Decrypt
 # ======================================================================
 
-def parallel_map(func, items, max_workers: int = 3, delay: float = 0.1,
-                 desc: str = '') -> list:
-    """并发执行函数，自动控制并发数和速率。
-
-    Args:
-        func: 接受单个 item 的函数，返回结果
-        items: 待处理的列表
-        max_workers: 最大并发数（默认 3，避免 API 限流）
-        delay: 每个任务提交后的延迟（秒），用于速率控制
-        desc: 进度描述（用于日志输出）
-
-    Returns:
-        与 items 顺序对应的结果列表
-    """
-    results = [None] * len(items)
-    errors = [None] * len(items)
-
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_idx = {}
-        for idx, item in enumerate(items):
-            future = executor.submit(func, item)
-            future_to_idx[future] = idx
-            if delay > 0:
-                time.sleep(delay)
-
-        done_count = 0
-        total = len(items)
-        for future in as_completed(future_to_idx):
-            idx = future_to_idx[future]
-            try:
-                results[idx] = future.result()
-            except Exception as e:
-                errors[idx] = e
-                if desc:
-                    print(f'  [{desc}] 第 {idx+1}/{total} 项失败: {e}')
-            done_count += 1
-            if desc and done_count % 10 == 0:
-                print(f'  [{desc}] 进度: {done_count}/{total}')
-
-    # 报告错误统计
-    fail_count = sum(1 for e in errors if e is not None)
-    if fail_count > 0 and desc:
-        print(f'  [{desc}] 完成: {total - fail_count} 成功, {fail_count} 失败')
-
-    return results
-
-
-# ======================================================================
-# Config Decrypt
 # ======================================================================
+# 主题分类法 —— **唯一一处定义**
+#
+# 列表与定义都收在这里，因为「散文写的枚举会漂」在这个仓库里已经真的发生过：
+# `biz_daily.TOPIC_PROMPT` 的第一行按 TOPICS 生成了六类，但同一段提示词后面两处
+# 提醒是硬编码的五类（少了政治），判断规则里也没有政治那一栏——而政治在语料里占 26%。
+# 两条路径（LLM 提示词 / 决策模型的判据）现在读同一张表，所以它们不可能再对不上。
+#
+# **顺序有意义**：`generate_ai_report` 按这个顺序给报告分栏。
+TOPICS = ['AI', '学术', '新闻', '文学', '投资', '政治']
+
+# 聊天卡拷进 Vault `Sources/Chat/` 时的文件名前缀。**必须共享**：`chat_notes` 用它写文件、
+# `compile_wiki` 用它把概念页的"来源"链接指过去——两处各写一份就是"同一条信息写两处"，
+# 而这个仓库已经因为这类分叉吃过亏。
+# 为什么要有这个前缀：聊天卡的名字**就是会话名**（`白马非马`、`老表亲戚群`），而概念页
+# 也可能叫同一个名字；两个文件同名时 `[[白马非马]]` 在 Obsidian 里是二义的。
+CHAT_CARD_PREFIX = '会话-'
+
+# 知识页住在哪几个目录（**Vault 相对路径**）。**分成两个是有意的**：用户明确要求
+# 聊天知识库与公众号文章知识库分开（2026-09-27），所以是"一条线一个目录"而不是混在一起。
+# 顺序即展示顺序：文章在前。
+#
+# 读的一方（`wiki_lint` / `vault_search` / `vault_rag` / 助手的 `search_knowledge`）
+# 都要把**两个都读**，否则新分出去的那一半会静默地搜不到——而这个仓库已经因为
+# "同一个事实写在两处"栽过好几次，所以 TS 那边有一份平行的列表，有测试钉住两者一致。
+CONCEPT_DIRS = ('Wiki/Concepts', 'Chat/Concepts')
+
+# 一篇文章**没能被分类**时落到哪一类。
+#
+# 收成一处是因为它曾经在写入路径上有两个不同的答案、相隔七行：
+# `.articles.json` 那条路默认 `''`（空主题），而分组/落 md 那条路默认 `'学术'`。
+# 于是一篇文章在 md 里写 `topic: 学术`、在 json 里写 `topic: ""`——
+# **同一次运行、同一篇文章，两个产物给出不同的主题**，而且都不报错。
+#
+# 真实后果（2026-09-04 的产出，178 篇）：md 全落在 `学术/` 目录、frontmatter 写
+# `topic: 学术`（其中两篇是「OpenAI 深夜发布 GPT-6」「专为高管准备的 AI 助手」，
+# 明显不该是学术），而 json 里同一批全是 `""` —— 报告那条路读 json，
+# 判据 `topic != FOCUS_TOPIC and relevance != '高'` 就把它们整批静默排除了。
+#
+# 什么情况下会走到这里：`daily --no-ai`、或者没配 API key 时，Phase 2（分类）整段
+# 不跑，文章 dict 里**根本没有 `topic` 键**，而 Phase 3 照常写文件。
+#
+# 这个值是**兜底不是判断**：落到这里的文章其实是"未分类"。之所以不新造一个
+# `未分类` 类别，是因为它要额外维护一个目录、一处 HTML 分栏、以及下游对
+# 主题字面量的比较；改用 `未分类` 属于改既有契约，得单独决策。
+DEFAULT_TOPIC = '学术'
+
+# 每一类的判据。既生成提示词里的判断规则，也直接作为 Jev 的 choice criteria。
+TOPIC_CRITERIA = {
+    'AI': 'AI大模型/Agent/编程/开源/科技产品/工具教程',
+    '投资': '股票基金/融资/经济分析/商业市场',
+    '新闻': '时事政策/社会热点/娱乐/招聘促销/会议通知',
+    '文学': '散文小说/美食旅游/生活随笔/历史文化',
+    '学术': '科研论文/期刊文章/实验室成果/学术会议/高校研究',
+    '政治': '党政理论/政策解读/领导人讲话/官方评论',
+}
+
+# 相关度的三个档位。与 `TOPICS` 一样是**下游按字面量比较**的封闭词表：
+# `generate_ai_report.py`、`enrich_backlinks.py`、`generate_html.py` 都在比
+# `'高'`/`'中'`/`'低'` 这三个字。定义收在这里，`jev_client` 与 `biz_daily`
+# 都从这里取——原先 `jev_client` 一份、`biz_daily` 的成员校验里再写一份。
+#
+# **顺序即语义**：`jev_client.RELEVANCE_LEVELS` 是给模型看的判据文本，按下标与
+# 这个列表一一对应（有测试钉住），所以不要重排。
+RELEVANCE_NAMES = ['低', '中', '高']
+
+# 一篇文章**没能被判相关度**时落到哪一档。和 `DEFAULT_TOPIC` 是同一类东西：
+# 兜底不是判断。之所以要具名，是因为"全库 2199/2201 篇都是「中」"这件事的答案
+# 就在这里——分类失败的每条路径最终都落到这个值，而 `'中'` 读起来是
+# 「有启发性」（正面评价），不是「没判断」。值不变更（改档位会动到下游的
+# 收录判据），只是把它写在一处，好让它可被搜索、可被讨论。
+DEFAULT_RELEVANCE = '中'
+
 
 def load_config():
     with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
         return json.load(f)
 
 
+# 配置里"不想在日报里看到的主题"的键名。值形如 `新闻,投资,学术`。
+EXCLUDED_TOPICS_KEY = 'dailyExcludeTopics'
+
+
+def excluded_topics(config=None, explicit='', protected=()):
+    """用户不想在日报里看到的主题集合。`explicit`（命令行）覆盖配置。
+
+    **这是展示层的开关，不是抓取层的**：正文照常抓取、照常归档，只是不出现在
+    日报里。理由是实测：拉之前只有来源+标题+摘要，按它判类型**不可靠**（与来源级
+    比对一致率仅 60%、误伤 48/217），而**排除是不可逆的**——没抓取就没归档。
+    放在展示层还换来一件事：改主意不用重抓，改个配置重新生成报告即可。
+
+    写错的主题名会被忽略并**打一行 WARN**（静默忽略会让人以为过滤生效了）。
+
+    `protected` 是不许被排除的主题（呼叫方传自己的「焦点主题」）。它比「未知主题名」
+    更值得拦一下：把焦点主题排掉，报告要么没有主体、要么直接报「未找到文章」
+    **指错方向**（那句话说去跑 biz_daily，可文章其实在）。同样 WARN 后忽略。
+    """
+    raw = explicit or (config or {}).get(EXCLUDED_TOPICS_KEY, '') or ''
+    names = [t.strip() for t in str(raw).replace('，', ',').split(',') if t.strip()]
+    out = set()
+    for name in names:
+        if name in TOPICS:
+            if name in protected:
+                print('[WARN] %s 里的「%s」是这份报告的主体，不能排除，已忽略'
+                      % (EXCLUDED_TOPICS_KEY, name))
+                continue
+            out.add(name)
+        else:
+            print('[WARN] %s 里的「%s」不是已知主题，已忽略（可选：%s）'
+                  % (EXCLUDED_TOPICS_KEY, name, '/'.join(TOPICS)))
+    return out
+
+
+# === 来源级先验："哪个号稳定发哪一类"从真实判断里长出来 ===
+#
+# 为什么不写死一张表：拉取之前只有来源+标题+摘要，按它判类型实测只有 60% 一致率、
+# 误伤 48/217（见 excluded_topics 的说明）。但**抓回来之后**每次都有 Jev 按正文判的
+# 主题，日积月累就看得出某个号一贯发什么。这张表因此是长出来的，不是我编的。
+#
+# 它现在只用来**报数**，不用来跳过任何东西：跳过是不可逆的。
+SOURCE_TOPICS_FILE = 'source_topics.json'
+SOURCE_PRIOR_MIN_SAMPLES = 8   # 少于这么多篇不下结论
+SOURCE_PRIOR_SHARE = 0.8       # 某一类占比到这个数才算"稳定地只发这一路"
+
+
+def source_topics_path(path=None):
+    """先验表的落盘位置。默认与 config.json 同目录（家目录）。"""
+    return path or os.path.join(os.path.dirname(CONFIG_PATH), SOURCE_TOPICS_FILE)
+
+
+def load_source_topics(path=None):
+    """读先验表：`{来源: {主题: 次数}}`。
+
+    读不出、坏掉、不是字典——一律返回 `{}`。这是**辅助**数据，坏了不该让日报挂掉。
+    """
+    try:
+        with open(source_topics_path(path), encoding='utf-8') as f:
+            data = json.load(f)
+    except (OSError, ValueError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    out = {}
+    for source, counts in data.items():
+        if isinstance(source, str) and source.strip() and isinstance(counts, dict):
+            out[source] = counts
+    return out
+
+
+def record_source_topics(pairs, path=None):
+    """把这一批 `(来源, 主题)` 累加进先验表，返回摘要 dict。
+
+    **只增不减**（与 frontmatter 的 only-increase 同一个纪律）：累计次数是你事后判断
+    "这个号到底稳不稳"的唯一依据，抹掉就回不来了。
+    来源为空、主题不在 TOPICS 里的都不计——计了会污染分母，让占比算错。
+    """
+    import tempfile as _tmp   # 模块顶没导入它：本文件里它是函数内导入的
+    store = load_source_topics(path)
+    added = skipped = 0
+    for source, topic in pairs:
+        source = (source or '').strip()
+        topic = (topic or '').strip()
+        if not source or topic not in TOPICS:
+            skipped += 1
+            continue
+        bucket = store.setdefault(source, {})
+        try:
+            bucket[topic] = int(bucket.get(topic, 0)) + 1
+        except (TypeError, ValueError):
+            bucket[topic] = 1      # 值被改坏了，从 1 重新数，别让它把整个文件废掉
+        added += 1
+    target = source_topics_path(path)
+    try:
+        os.makedirs(os.path.dirname(target) or '.', exist_ok=True)
+        fd, tmp_path = _tmp.mkstemp(suffix='.json', dir=os.path.dirname(target) or '.')
+        try:
+            with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                json.dump(store, f, ensure_ascii=False, indent=1, sort_keys=True)
+            os.replace(tmp_path, target)
+        except Exception:
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+            raise
+    except OSError as exc:
+        # 写不进去（权限、磁盘）不能让日报失败——它只是记个账。
+        return {'sources': len(store), 'added': added, 'skipped': skipped,
+                'error': str(exc)}
+    return {'sources': len(store), 'added': added, 'skipped': skipped, 'error': ''}
+
+
+def stable_source_topic(counts, min_samples=SOURCE_PRIOR_MIN_SAMPLES,
+                        share=SOURCE_PRIOR_SHARE):
+    """某个来源是不是已经**稳定地只发某一类**。
+
+    返回 `(主题, 占比, 样本数)`；还判不了返回 `None`。
+    **`None` 是"还不知道"，不是"没有主题"**——调用方必须把这两种情况分开，
+    别把 `None` 当成某个默认主题用（那正好是"来源判不准"最坏的那种错）。
+    """
+    clean = {}
+    for topic, count in (counts or {}).items():
+        try:
+            value = int(count)
+        except (TypeError, ValueError):
+            continue
+        if value > 0:
+            clean[topic] = value
+    total = sum(clean.values())
+    if total < min_samples:
+        return None
+    topic, top = max(clean.items(), key=lambda kv: kv[1])
+    ratio = top / total
+    if ratio < share:
+        return None
+    return (topic, ratio, total)
+
+
+def source_prior_candidates(store, exclude, **kwargs):
+    """先验里"已经稳到能判"且落在排除集里的来源，按样本数从多到少。
+
+    只报出来给人看，**不据此跳过任何东西**：跳过是不可逆的，而这张表还在长。"""
+    rows = []
+    for source, counts in (store or {}).items():
+        stable = stable_source_topic(counts, **kwargs)
+        if stable and stable[0] in (exclude or ()):
+            rows.append((source, stable[0], stable[1], stable[2]))
+    return sorted(rows, key=lambda row: (-row[3], row[0]))
+
 def decrypt_lock(locked_str: str) -> str:
     if not locked_str or not locked_str.startswith('lock:'):
         return locked_str
@@ -440,6 +608,43 @@ def get_api_key(config=None) -> str:
     return decrypt_lock(config.get('deepseekApiKey', ''))
 
 
+def get_dashscope_key(config=None) -> str:
+    """读取阿里云百炼（DashScope）的 embedding key，自动解密 lock: 前缀。
+
+    和 `get_api_key` / `get_typesafe_key` 同一形状：**不要直接 config.get**——
+    这个键进了 `ENCRYPTED_KEYS`，磁盘上是密文。解密失败回空串而不是抛，
+    理由同 get_typesafe_key（跨机器拷配置时它该表现为"没配"，不是崩）。
+    """
+    if config is None:
+        try:
+            config = load_config()
+        except Exception:
+            return ''
+    try:
+        return decrypt_lock(config.get('dashscopeApiKey', ''))
+    except Exception:
+        return ''
+
+
+def get_typesafe_key(config=None) -> str:
+    """读取 TypeSafe (Jev) 决策模型的 key，自动解密 lock: 前缀。
+
+    解密失败**回空串而不是抛**：TS 侧 lockDecrypt() 失败就是静默回 ''，而
+    decrypt_lock() 是抛的。两份 config.json 一跨机器拷贝，同一份密文在
+    TS 侧表现为"没配 key"、在这里表现为崩——那会让日报整个挂掉，而它本该
+    只是退回到 LLM 解析路径。
+    """
+    if config is None:
+        try:
+            config = load_config()
+        except Exception:
+            return ''
+    try:
+        return decrypt_lock(config.get('typesafeApiKey', ''))
+    except Exception:
+        return ''
+
+
 # ======================================================================
 # Markdown / Frontmatter
 # ======================================================================
@@ -558,3 +763,147 @@ def generate_action_suggestion(title: str, source: str, topic: str,
     )
     engine = create_engine(engine_type, api_key)
     return engine.chat(prompt, max_tokens=max_tokens)
+
+# ---------------------------------------------------------------- 知识卡片的公共件
+#
+# `chat_notes.py`（对话线）与 `article_notes.py`（文章线）产出的是**同一种卡片**：
+# 带 frontmatter + `## AI 摘要` + `[[概念]] — 说明` 的 markdown，都喂给 `compile_wiki`。
+# 所以这几样放在这里，一份实现两边用——两处各写一份，早晚有一处会漏。
+
+SEPARATOR = '—'   # 与 `compile_wiki` 认的破折号一致（那条描述要能被它读回描述）
+
+# 文件名里不许出现的字符（Windows 一套 + 控制字符）
+_ILLEGAL_IN_NAME = set('\\/:*?"<>|') | {chr(code) for code in range(0, 32)}
+
+
+def plain(text) -> str:
+    """自由文本里的 `[[…]]` 一律拆掉。
+
+    纪律是「wikilink 只由我们的代码渲染，不由模型写」：`compile_wiki.scan_articles` 收正文里
+    **所有** wikilink，它不会问这是谁写的——模型在摘要里随手一个 `[[X]]`，就会凭空长出一个概念。
+    """
+    out, index = [], 0
+    source = str(text or '')
+    while True:
+        start = source.find('[[', index)
+        if start < 0:
+            out.append(source[index:])
+            break
+        end = source.find(']]', start)
+        if end < 0:
+            out.append(source[index:])
+            break
+        out.append(source[index:start])
+        out.append(source[start + 2:end])
+        index = end + 2
+    return ''.join(out).replace('[[', '').replace(']]', '')
+
+
+def note_path(out_root, name: str, fallback: str = '未命名'):
+    """一张卡一个文件。名字要过文件名安全：会话/文章名里有 `/` 会写到别的目录去。"""
+    from pathlib import Path as _Path
+    cleaned = ''.join('_' if ch in _ILLEGAL_IN_NAME else ch for ch in str(name))
+    cleaned = ' '.join(cleaned.split())[:80].strip().strip('.')
+    return _Path(out_root) / ('%s.md' % (cleaned or fallback))
+
+
+# ---------------------------------------------------------------- 微信正文里的界面残留
+
+# 微信文章正文会带**阅读器自己的界面文字**（"在小说阅读器读本章"那一串），以及文末的
+# 原创标记与公众号名重复。实测：库里 1633 篇笔记，**1484 篇（91%）**的摘要里混着它
+# （先按"整份文件里出现某条短语"数是 330，那是数漏了——短语有好几种写法，按摘要层数才对）。
+# 这份清理在真库上跑过：1484 篇 → 清理后 **0 篇**仍带残留。
+#
+# `classify_daily.py` 里本来有一份 `AD_PATTERNS`，但它只用在日报那条路上，
+# **写笔记那条路（`create_reading_notes.py`）一次都没清洗**——而且对着真串比对，
+# 那份表还漏了一条：真串是「在**公众号**小说中沉浸阅读」，表里写的是
+# 「在小说阅读器**中**沉浸阅读」。所以这里一次列全，各处共用。
+_AD_PHRASES = (
+    '在小说阅读器读本章',
+    '在小说阅读器中沉浸阅读',
+    '在公众号小说中沉浸阅读',
+    '去阅读',
+    'Scan to Follow',
+    '轻触阅读原文',
+    '预览时标签不可点',
+    '继续滑动看下一个',
+)
+
+_UNDERSCORE_RUN = None      # 惰性编译，避免在 import 期做什么重活
+_JS_LINK = None
+
+
+def strip_wx_ads(text: str) -> str:
+    """去掉微信正文里那几样界面残留。
+
+    处理顺序有讲究：先删短语，再删下划线长串，最后收拾"原创 + 公众号名重复 N 遍"。
+    只动**已知的**几样——这是给摘要与提示词做清洁，不是改写正文；
+    拿不准的一律留着（宁可留一点噪音，也不要把用户的话删掉）。
+    """
+    import re as _re
+    global _UNDERSCORE_RUN
+    if _UNDERSCORE_RUN is None:
+        _UNDERSCORE_RUN = _re.compile(r'_{4,}')
+    out = str(text or '')
+    for phrase in _AD_PHRASES:
+        out = out.replace(phrase, ' ')
+    out = _UNDERSCORE_RUN.sub(' ', out)
+    global _JS_LINK
+    if _JS_LINK is None:
+        _JS_LINK = _re.compile(r'\[.*?\]\(javascript:void\(0\);?\)')
+    out = _JS_LINK.sub(' ', out)
+    # 「原创 开源星探 开源星探 开源星探」：公众号名在文末被重复粘了几遍，压成一个
+    out = _re.sub(r'原创\s+(\S{2,12})(?:\s+\1\b){1,}\s*', ' ', out)
+    out = _re.sub(r'原创\s+[一-龥A-Za-z0-9]{2,12}\s*$', '', out)
+    out = _re.sub(r'\b(\S{2,12})(?:\s+\1\b)+', r'\1', out)
+    out = _re.sub(r'[ \t]{2,}', ' ', out)
+    out = _re.sub(r'\n{3,}', '\n\n', out)
+    # 短语被删掉之后可能留下孤零零的空白或行首标点
+    out = _re.sub(r'[ \t]+([，。、；：！？])', r'\1', out)
+    return out.strip()
+
+
+_FENCED_BLOCK = None
+
+
+def strip_wx_ads_document(text: str) -> str:
+    """整篇原文用的清洗：**frontmatter 与围栏代码块一个字不动**，其余同 `strip_wx_ads`。
+
+    删短语的规则**完全复用** `strip_wx_ads`，不另写一套 —— 两处各写一份，迟早会对
+    "什么算残留"给出不同答案（本仓库因为这类分叉吃过亏）。
+
+    两处防护各有实测理由：
+
+    - **frontmatter**：`去阅读` 是**短词**，完全可能出现在标题里（"如何去阅读一本书"）。
+      标题被改就等于改文件名对齐关系 —— 笔记靠 `日期-标题` 找原文，改了就对不上了。
+      实测当前 35,060 篇里 0 篇的 frontmatter 含短语，所以这一条是**防未来**，不是修现在。
+    - **围栏代码块**：`strip_wx_ads` 末尾那几条空白规整（`[ \\t]{2,}` → ' '、`\\n{3,}` → `\\n\\n`）
+      对摘要是无损的，对**原文**却会吃掉代码缩进 —— 实测 20 篇带围栏、其中 10 篇围栏内容会变
+      （HTML/JS 示例）。原文是素材，缩进就是内容。
+    """
+    if text.startswith('---'):
+        end = text.find('\n---', 3)
+        front, body = (text[:end + 4], text[end + 4:]) if end != -1 else ('', text)
+    else:
+        front, body = '', text
+    # `strip_wx_ads` 末尾带 `.strip()`，会把正文首尾空白吃掉。frontmatter 与正文之间那两行
+    # 空行是正文的一部分，所以这里把首尾空白单独摘出来、洗完再放回去。
+    lead = body[:len(body) - len(body.lstrip())]
+    tail = body[len(body.rstrip()):]
+    core = body.strip()
+    global _FENCED_BLOCK
+    if _FENCED_BLOCK is None:
+        import re as _re
+        _FENCED_BLOCK = _re.compile(r'^```.*?^```', _re.S | _re.M)
+    # 占位符用 chr(0) 拼，不写字面反斜杠：本仓有"JSON 层吃掉转义"的前科，能避开就避开。
+    mark = chr(0) + 'FENCE' + chr(0)
+    blocks = []
+
+    def stash(match):
+        blocks.append(match.group(0))
+        return mark + str(len(blocks) - 1) + mark
+
+    cleaned = strip_wx_ads(_FENCED_BLOCK.sub(stash, core))
+    for index, block in enumerate(blocks):
+        cleaned = cleaned.replace(mark + str(index) + mark, block)
+    return front + lead + cleaned + tail

package/scripts/annual_report.py

@@ -21,7 +21,7 @@ except ImportError:
     sys.exit(1)
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import load_config, decrypt_lock, parse_frontmatter, call_deepseek
+from _utils import load_config, decrypt_lock, parse_frontmatter, call_deepseek, get_api_key
 
 TZ = timezone(timedelta(hours=8))
 OUTPUT_ROOT = 'output'
@@ -733,7 +733,9 @@ def main():
 
     year = args.year
     config = load_config()
-    api_key = args.api_key or os.environ.get('DEEPSEEK_API_KEY', '') or config.get('deepseekApiKey', '')
+    # 一律走 get_api_key：它会解密 lock: 前缀，而直接 config.get 拿到的是密文。
+    # 原先这四处直接读，恰好因为本机那把 key 是明文而没暴露。
+    api_key = args.api_key or os.environ.get('DEEPSEEK_API_KEY', '') or get_api_key(config)
 
     print(f'📊 正在生成 {year} 年度报告...')