weflow-cli 1.6.4 → 1.8.0

package/scripts/fav_notes.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""
+收藏知识卡 — 把微信收藏里的文章变成知识卡，喂给 wiki compile。
+
+用法:
+  python scripts/fav_notes.py --dry-run --json      # 看代价（只读本地；有哪些要联网抓也报出来）
+  python scripts/fav_notes.py --limit 10 --yes      # 先试水 10 条
+  python scripts/compile_wiki.py --source output/fav-notes
+
+## 为什么收藏值得单独一条来源
+
+日报那条线吃的是"你今天读了什么"，而**收藏是你明确留下的**——两者不是一回事：
+收藏里常有日报窗口之外的文章，而且"我主动存过"本身就是兴趣的最强信号。
+（另外这条线自带一个好处：收藏的文章多半日报已经抓过，`fetch_article_cached` 会命中缓存，
+所以联网这一步常常是零成本。）
+
+## 与另外两条线的关系
+
+同一形状、同一消费者（`wiki_compile` 的 `--source`）：文章线 `article_notes.py`、
+对话线 `chat_notes.py`、收藏线就是本脚本。共用的件在 `_utils.py`。
+
+**一处不同，必须写清**：文章的卡里"摘要"是**照抄**原笔记的，而收藏记录里**没有摘要**
+（只有标题/来源/链接）——所以这条线的摘要**是模型写的**。卡片里会标出来
+（frontmatter 的 `summary_by: model`），免得它看起来像抄来的原文。
+"""
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _utils import (SEPARATOR, call_deepseek, decrypt_lock, get_api_key, load_config,  # noqa: E402
+                    note_path, plain, strip_wx_ads, write_with_frontmatter)
+
+TZ = timezone(timedelta(hours=8))
+OUTPUT_ROOT = 'output/fav-notes'
+DEFAULT_LIMIT = 10
+MAX_ARTICLE_CHARS = 3000
+MIN_ARTICLE_CHARS = 200
+LINK_CHARS = 6 * 1024 * 1024      # 单篇正文上限（缓存来的 markdown 一般远小于它）
+
+FAV_PROMPT = """你是知识库的**编译者，不是作者**。下面是一篇用户**收藏**的公众号文章。
+
+请只依据它，返回一个 JSON 对象（不要解释、不要代码块围栏）：
+{{"summary": "这篇文章在说什么（2-3 句，只写文章里有的）",
+  "concepts": [{{"name": "概念名（2-12 字，不要带书名号引号方括号）", "desc": "这篇文章关于它说了什么（一句话，具体）"}}]}}
+
+要求：
+1. **只写文章里有的**。没讲到的不许补；拿不准的宁可不写。
+2. `concepts` 2-6 条、按重要度排序；**概念要具体**（"MCP 协议"可以，"技术"不行），
+   也不是分类词（"AI"、"新闻"这种主题标签不算概念）。
+3. 每条 desc 是"这篇文章关于它的说法"，不是百科定义。
+4. 全部中文，不要 markdown 语法（不要 #、*、-）。
+
+文章：{title}（来源：{source}）
+
+正文：
+{body}
+"""
+
+
+def read_favorites(limit: int):
+    """读收藏列表（本地、只读）。返回 (条目列表, 错误原因)。"""
+    import nt_decrypt
+    config = load_config()
+    fav_db = config.get('favDbPath', '')
+    if not fav_db:
+        return [], '配置里没有 favDbPath（收藏库还没连上）'
+    got = nt_decrypt.get_favorites(fav_db, decrypt_lock(config.get('favKey', '')), limit=limit)
+    if isinstance(got, dict) and got.get('error'):
+        return [], str(got['error'])
+    items = got.get('favorites') if isinstance(got, dict) else got
+    return list(items or []), None
+
+
+def local_text(item: dict) -> str:
+    """收藏**自带**的正文（笔记/文本类有，文章类没有）。**不碰网络。**
+
+    与 `favorite_text` 分开，是为了让 `--dry-run` 能说清"哪几条要联网抓"而**不去抓**：
+    预览是只读的（它的说明里写着"只读本地"），自己去打网络就名不副实了——我第一版
+    就是这么写的，跑 dry-run 时看见它在抓文章才发现。
+    """
+    for key in ('desc', 'content', 'summary'):
+        text = strip_wx_ads(str(item.get(key) or '')).strip()
+        if len(text) >= MIN_ARTICLE_CHARS:
+            return text
+    return ''
+
+
+def classify_source(item: dict) -> str:
+    """这条收藏的正文从哪来（**只看本地信息**）：local / fetch / none。"""
+    if local_text(item):
+        return 'local'
+    return 'fetch' if str(item.get('link') or '').strip() else 'none'
+
+
+def favorite_text(item: dict, fetch=None):
+    """一条收藏的正文：本地文本优先，没有（或太短）就抓链接。返回 (正文, 来源说明)。
+
+    收藏分两种：笔记/文本类**自带内容**（`desc`/`content`），文章类只有 `link`。
+    抓取复用日报那条线的 `fetch_article_cached`——不重写第二份（那套微信 UA 绕 WAF、
+    gzip、重试是踩出来的），而且**带缓存**：日报抓过的文章这里零网络。
+
+    `fetch` 是**可注入的口子**：默认走 `biz_daily.fetch_article_cached`，测试传桩进来——
+    否则单元测试会真去联网（我第一版就是这么写的，跑测试时才发现）。
+    """
+    for key in ('desc', 'content', 'summary'):
+        text = strip_wx_ads(str(item.get(key) or '')).strip()
+        if len(text) >= MIN_ARTICLE_CHARS:
+            return text, 'local'
+    link = str(item.get('link') or '').strip()
+    if not link:
+        return '', 'no-text'
+    if fetch is None:
+        try:
+            import biz_daily
+            fetch = biz_daily.fetch_article_cached
+        except Exception as error:
+            return '', 'fetch-failed: %s' % type(error).__name__
+    try:
+        got = fetch(link)
+    except Exception as error:
+        return '', 'fetch-failed: %s' % type(error).__name__
+    if not got:
+        return '', 'fetch-failed'
+    text, cached = got
+    if not text:
+        return '', 'fetch-failed'
+    return strip_wx_ads(str(text))[:LINK_CHARS], ('cache' if cached else 'network')
+
+
+def parse_note(raw: str):
+    """解出 `{summary, concepts}`。解不出来返回 None（**不猜**）。"""
+    if not isinstance(raw, str) or not raw.strip():
+        return None
+    text = raw.strip()
+    start, end = text.find('{'), text.rfind('}')
+    if start < 0 or end <= start:
+        return None
+    try:
+        data = json.loads(text[start:end + 1])
+    except Exception:
+        return None
+    if not isinstance(data, dict) or not isinstance(data.get('concepts'), list):
+        return None
+    summary = plain(data.get('summary')).strip()
+    if not summary:
+        return None
+    concepts = []
+    for item in data['concepts']:
+        if not isinstance(item, dict):
+            continue
+        name = plain(item.get('name')).strip().strip('[]')
+        desc = plain(item.get('desc')).strip()
+        if name and desc:
+            concepts.append({'name': name, 'desc': desc})
+        if len(concepts) >= 6:
+            break
+    return {'summary': summary, 'concepts': concepts}
+
+
+def build_card(item: dict, note: dict, body_len: int, saved: str, updated: str):
+    """卡片 → (frontmatter, body)。摘要这次**是模型写的**，所以标出来。"""
+    title = str(item.get('title') or '无标题').strip()
+    source = str(item.get('source_name') or '').strip()
+    frontmatter = {
+        'title': title,
+        'type': 'fav-card',
+        'source': source or '收藏',
+        'topic': '收藏',
+        'tags': ['收藏'],
+        # **收藏时间**不是发布时间——别把它叫 published，那是另一回事
+        'saved': saved,
+        'url': str(item.get('link') or ''),
+        'summary_by': 'model',      # 这条线的摘要不是抄的，标出来
+        'bodyChars': body_len,
+        'updated': updated,
+    }
+    parts = ['# %s\n' % title, '## AI 摘要\n', note['summary'] + '\n']
+    if note['concepts']:
+        parts.append('## 概念\n')
+        for concept in note['concepts']:
+            parts.append('- [[%s]] %s %s' % (concept['name'], SEPARATOR, concept['desc']))
+        parts.append('')
+    return frontmatter, '\n'.join(parts)
+
+
+def already_carded(item: dict, out_dir: str) -> bool:
+    """这条收藏已经有卡了吗（按标题落成的文件名）。"""
+    title = str(item.get('title') or '').strip()
+    return bool(title) and note_path(out_dir, title).exists()
+
+
+def exit_code(written: int) -> int:
+    """部分成功算成功——与另外两条线同一个约定。"""
+    return 0 if written else 1
+
+
+def main():
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    parser = argparse.ArgumentParser(description='收藏知识卡（把收藏变成喂给 wiki compile 的卡）')
+    parser.add_argument('--limit', type=int, default=DEFAULT_LIMIT,
+                        help='最多处理几条收藏（默认 %d）' % DEFAULT_LIMIT)
+    parser.add_argument('--out', default=OUTPUT_ROOT, help='卡片输出目录')
+    parser.add_argument('--refresh', action='store_true', help='已有卡的也重做')
+    parser.add_argument('--dry-run', action='store_true', help='只报要发多少给模型，不调用')
+    parser.add_argument('--yes', action='store_true', help='确认调用云端模型')
+    parser.add_argument('--json', action='store_true')
+    args = parser.parse_args()
+
+    if args.limit < 1:
+        print(json.dumps({'success': False, 'error': '--limit 要 ≥ 1'}))
+        return 1
+
+    favorites, error = read_favorites(args.limit)
+    if error:
+        message = '读收藏失败：%s' % error
+        print(json.dumps({'success': False, 'error': message}, ensure_ascii=False)
+              if args.json else message)
+        return 1
+
+    runnable, thin, existing = [], [], []
+    for item in favorites:
+        if args.refresh or not already_carded(item, args.out):
+            runnable.append(item)
+        else:
+            existing.append(item)
+
+    if args.dry_run:
+        # **只看本地信息**：预览是只读的，不替用户去打网络（抓取留给真跑那一步）
+        counts = {'local': 0, 'fetch': 0, 'none': 0}
+        for item in runnable:
+            counts[classify_source(item)] += 1
+        preview = {
+            'success': True, 'dryRun': True, 'action': 'fav-notes',
+            'favorites': len(favorites), 'calls': len(runnable),
+            'alreadyCarded': len(existing), 'noText': counts['none'],
+            'textSource': {'local': counts['local'], 'needsFetch': counts['fetch']},
+            'model': 'DeepSeek（生成）', 'readsLocalData': True, 'fetchArticleUrls': False,
+            'invokesAI': False,
+            'note': '每条一次调用；正文优先用收藏自带的文本，文章类走日报那条线的抓取（带缓存）'
+                    '——抓取发生在真跑时，预览不联网',
+        }
+        if args.json:
+            print(json.dumps(preview, ensure_ascii=False, indent=2))
+        else:
+            print('收藏 %d 条，会调用模型 %d 次（已有卡 %d 条跳过）'
+                  % (len(favorites), len(runnable), len(existing)))
+            print('正文：自带 %d 条、要联网抓 %d 条、取不到 %d 条（预览不联网，抓取在 --yes 之后）'
+                  % (counts['local'], counts['fetch'], counts['none']))
+        return 0
+
+    if not runnable:
+        message = '没有要处理的收藏（%d 条都已有卡）' % len(favorites)
+        print(json.dumps({'success': False, 'error': message}, ensure_ascii=False)
+              if args.json else message, file=sys.stdout if args.json else sys.stderr)
+        return 1
+
+    if not args.yes:
+        print('会把 %d 条收藏的正文发给 DeepSeek（每条一次调用）。加 --yes 确认。' % len(runnable),
+              file=sys.stderr)
+        return 1
+
+    config = load_config()
+    api_key = get_api_key(config)
+    if not api_key:
+        print('没有配置 deepseekApiKey（weflow-cli config set deepseekApiKey "..."）', file=sys.stderr)
+        return 1
+
+    updated = datetime.now(TZ).strftime('%Y-%m-%d %H:%M')
+    written, failed = [], []
+    for item in runnable:
+        text, how = favorite_text(item)
+        title = str(item.get('title') or '无标题').strip()
+        if not text:
+            failed.append({'title': title[:30], 'reason': '取不到正文（%s）' % how})
+            continue
+        saved = ''
+        if item.get('update_time'):
+            saved = datetime.fromtimestamp(int(item['update_time']), tz=TZ).strftime('%Y-%m-%d')
+        prompt = FAV_PROMPT.format(title=title, source=item.get('source_name') or '未知',
+                                   body=text[:MAX_ARTICLE_CHARS])
+        try:
+            raw = call_deepseek(prompt, api_key, max_tokens=2000, timeout=120)
+        except Exception as error:
+            failed.append({'title': title[:30], 'reason': '调用失败：%s' % error})
+            continue
+        note = parse_note(raw)
+        if note is None:
+            failed.append({'title': title[:30], 'reason': '模型没返回可用 JSON',
+                           'rawTail': str(raw)[-200:] if raw else '(空)'})
+            continue
+        target = note_path(args.out, title)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        frontmatter, body = build_card(item, note, len(text), saved, updated)
+        write_with_frontmatter(str(target), frontmatter, body)
+        written.append({'title': title[:30], 'file': str(target),
+                        'concepts': len(note['concepts']), 'textFrom': how})
+
+    result = {'success': True, 'action': 'fav-notes', 'model': 'DeepSeek（生成）',
+              'sendsNothing': True, 'written': written, 'failed': failed,
+              'alreadyCarded': len(existing), 'favorites': len(favorites), 'calls': len(runnable)}
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        for item in written:
+            print('✓ %s（%d 个概念，正文来自 %s）' % (item['title'], item['concepts'], item['textFrom']))
+        for item in failed:
+            print('✗ %s：%s' % (item['title'], item['reason']), file=sys.stderr)
+        print('\n共 %d 张卡；接着跑 python scripts/compile_wiki.py --source %s'
+              % (len(written), args.out))
+    return exit_code(len(written))
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/scripts/fix_topics.py

@@ -5,8 +5,9 @@ from pathlib import Path
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from biz_daily import _guess_topic
+from _utils import TOPICS
+
 
-TOPICS = ['AI', '学术', '新闻', '文学', '投资', '政治']
 
 def fix_date(date_str: str):
     sys.stdout.reconfigure(encoding='utf-8', errors='replace')

package/scripts/generate_ai_report.py

@@ -23,7 +23,8 @@ from pathlib import Path
 from collections import Counter
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import create_engine, parse_frontmatter
+from _utils import (create_engine, parse_frontmatter, TOPICS, TOPIC_CRITERIA,
+                    load_config, excluded_topics)
 
 SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
 ROOT_DIR = os.path.dirname(SCRIPTS_DIR)
@@ -31,7 +32,7 @@ SOURCE_ROOT = os.path.join(ROOT_DIR, 'output', 'biz-daily')
 OUTPUT_DIR = os.path.join(ROOT_DIR, 'output', 'ai-reports')
 
 TZ = timezone(timedelta(hours=8))
-TOPICS = ['AI', '学术', '新闻', '文学', '投资', '政治']
+
 FOCUS_TOPIC = 'AI'
 
 
@@ -89,7 +90,168 @@ REPORT_PROMPT = """你是一位为忙碌研究生写作的「深度阅读策展
 # DATA LOADING
 # ======================================================================
 
-def load_articles_from_date(date_str: str) -> list[dict]:
+# 「该不该进今天的日报」的切点。**暂定且未经校准**：Jev 问的是
+# `worth_including`（含可直接用上的具体内容吗），返回 0~1 的概率，
+# 原始值存在 frontmatter 的 `includeScore` 里，改这个数不用重跑日报。
+INCLUDE_THRESHOLD = 0.5
+
+
+# 「拿不太准」的区间。收录分落在中间，意味着这次收还是不收都说得过去——
+# 报告不该把这种条目当成确定的事报出去。
+UNCERTAIN_BAND = (0.35, 0.65)
+TOPIC_CONFIDENT = 0.7
+UNCERTAIN_LIST_LIMIT = 8
+
+
+def _num(value):
+    """把 includeScore 之类的概率读成 float；读不出返回 None。
+
+    要认字符串：`.articles.json` 里是数字，md 兜底路径读出来是 YAML 标量文本。
+    """
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _score(article):
+    """读 includeScore。`.articles.json` 里是数字，md 兜底路径读出来是字符串。"""
+    value = article.get('includeScore')
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def build_uncertainty_section(included, everything, include_all=False, exclude=()) -> str:
+    """报告末尾那一段「我拿不准的」。**本地算，不经 LLM** —— 让模型去描述自己的不确定，
+    等于又要它生成一段可能被编圆的散文。
+
+    两种不确定分开说，因为处理方式不同：
+      * 收录卡在阈值上 —— 收与不收都说得过去，你看到的是这次掷硬币的结果；
+      * 主题置信度低 —— 它可能被分到了错误的那一栏，位置都可能是错的。
+
+    **没有概率字段时不能沉默。** 早期生成的文章没有 includeScore，那一段的缺席会被
+    读成"这份报告哪里都很确定"，而事实是"它没告诉你"。所以那种情况要明说。
+    """
+    scored = [a for a in everything if _score(a) is not None]
+    if not scored:
+        return (chr(10) + '---' + chr(10) + chr(10) + '## 我拿不准的' + chr(10) + chr(10)
+                + '本期文章没有概率字段（生成早于该字段引入），所以**这份报告无法告诉你'
+                  '它哪里不确定**——不能把上面的结论读成"都已经过确认"。' + chr(10))
+
+    low, high = UNCERTAIN_BAND
+    in_ids = {id(a) for a in included}
+
+    def band(article):
+        value = _score(article)
+        return value is not None and low <= value <= high
+
+    # 这一段三份清单都不提被排除的主题：否则"不想看新闻"的同一份报告，
+    # 会在这一栏把新闻的标题和分数原样列出来。
+    borderline_in = [a for a in included
+                     if band(a) and not is_excluded_topic(a, exclude)]
+    # 注意：这一栏装的是**没收**的文章，被排除的天然满足"没收"——
+    # 把 exclude 交给 admits 反而会让它们更容易被列进来（我第一版就是这么错的）。
+    # 这里要的是"因为分数而没收"，所以按排除集滤掉。
+    borderline_out = [] if include_all else [a for a in everything
+                                            if not admits(a, include_all) and band(a)
+                                            and not is_excluded_topic(a, exclude)]
+    low_confidence = [a for a in included
+                      if isinstance(a.get('topicConfidence'), (int, float))
+                      and a['topicConfidence'] < TOPIC_CONFIDENT
+                      and not is_excluded_topic(a, exclude)]
+
+    lines = [chr(10) + '---' + chr(10), '## 我拿不准的' + chr(10),
+             '这两处不是漏掉，是**判断本身不确定**。列出来，免得被当成定论。' + chr(10)]
+
+    total_borderline = len(borderline_in) + len(borderline_out)
+    if total_borderline:
+        if include_all:
+            # 收录判据没启用，"收与不收"这个区分根本不存在——照抄阈值两侧的措辞
+            # 会让人以为这里做过一次筛选。
+            lines.append('**收录分落在边界上的 %d 篇**（本次未启用收录判据，全部收录）'
+                         '——这些分数本来就说不准：%s' % (total_borderline, chr(10)))
+        else:
+            lines.append('**收录卡在阈值上的 %d 篇**（收了 %d 篇、没收 %d 篇）——'
+                         '收与不收都说得过去：%s'
+                         % (total_borderline, len(borderline_in),
+                            len(borderline_out), chr(10)))
+        listed = borderline_in + borderline_out
+        for article in listed[:UNCERTAIN_LIST_LIMIT]:
+            kept = '' if include_all else (' · 收' if id(article) in in_ids else ' · 没收')
+            lines.append('- %s（收录分 %.2f%s · 主题 %s）'
+                         % (article.get('title', '(无标题)'), _score(article), kept,
+                            article.get('topic', '?')))
+        if total_borderline > UNCERTAIN_LIST_LIMIT:
+            lines.append('- 另有 %d 篇同样卡在边界，未列。' % (total_borderline - UNCERTAIN_LIST_LIMIT))
+        lines.append('')
+
+    if low_confidence:
+        lines.append('**主题可能归错的 %d 篇**（主题置信度低于 %.1f，分栏位置可能不对）：%s'
+                     % (len(low_confidence), TOPIC_CONFIDENT, chr(10)))
+        for article in low_confidence[:UNCERTAIN_LIST_LIMIT]:
+            lines.append('- %s（标为 %s · 置信 %.2f）'
+                         % (article.get('title', '(无标题)'), article.get('topic', '?'),
+                            article['topicConfidence']))
+        if len(low_confidence) > UNCERTAIN_LIST_LIMIT:
+            lines.append('- 另有 %d 篇同样置信偏低，未列。' % (len(low_confidence) - UNCERTAIN_LIST_LIMIT))
+        lines.append('')
+
+    if not total_borderline and not low_confidence:
+        lines.append('本期没有落在边界上的条目——收录分与主题置信度都不在含糊区间。' + chr(10))
+
+    lines.append('> 这些数字来自决策模型，**没有金标准校准过**；概率在阈值附近还会抖'
+                 '（同一批数据两次跑会有出入），别细究 0.48 与 0.52 的区别。')
+    lines.append('')
+    return chr(10).join(lines)
+
+
+def is_excluded_topic(article: dict, exclude=()) -> bool:
+    """用户是不是明说了不要这个主题。
+
+    单独抽出来是因为它有**两个方向相反**的用处：
+    `admits` 靠它判"不要"，而「我拿不准的」那一栏靠它判"别列出来"——
+    那一栏装的恰好是**没收**的文章，被排除的天然满足"没收"。
+    两处各写一遍早晚会写反，事实上第一版就写反了。
+    """
+    return (article.get('topic') or '') in (exclude or ())
+
+
+def admits(article: dict, include_all: bool = False, exclude=()) -> bool:
+    """这篇文章该不该收录。
+
+    焦点主题永远收。其余看 `includeScore`——那是**专门为这个问题**问出来的概率，
+    比拿 `relevance != '高'` 顶替准：相关度量的是"对读者的实用价值"，回答不了
+    "今天该不该收它"，阈值怎么调都是在调一个问错了的题。
+
+    没有 `includeScore` 的是这个字段出现之前的产物，退回旧规则，行为不变。
+
+    这里要认字符串：`.articles.json` 里的值是数字，但 md 兜底路径读出来的是
+    YAML 标量文本（`'0.8'`）。只认 `int/float` 的话，那条路径上这个新字段
+    就会被静默忽略——测出来正是如此。
+    """
+    # 排除是**正交**的一维，所以放在 include_all 前面：用户明说不要的主题，
+    # 连 --include-all 都不该让它冒出来。
+    if is_excluded_topic(article, exclude):
+        return False
+    if include_all or article.get('topic') == FOCUS_TOPIC:
+        return True
+    score = article.get('includeScore')
+    if score is not None:
+        try:
+            return float(score) >= INCLUDE_THRESHOLD
+        except (TypeError, ValueError):
+            # 值不是数字（乱改过的产物）。退回旧规则，别让报告生成在这里炸掉。
+            pass
+    return article.get('relevance') == '高'
+
+def load_articles_from_date(date_str: str, include_all: bool = False,
+                            exclude=()) -> list[dict]:
     json_path = Path(SOURCE_ROOT) / date_str / '.articles.json'
     if json_path.exists():
         try:
@@ -98,7 +260,26 @@ def load_articles_from_date(date_str: str) -> list[dict]:
             arts = data.get('articles', data) if isinstance(data, dict) else data
             for a in arts:
                 a.setdefault('date', date_str)
-            return arts
+            # 这里原先直接 return，不筛。于是「非焦点主题只收相关度高的文章」
+            # 这条规则**只在下面的 MD 兜底路径里存在**，而 .articles.json 才是
+            # 正常走的那条路 —— 规则因此从未真正生效过。
+            kept = [a for a in arts if admits(a, include_all, exclude)]
+            if len(kept) != len(arts):
+                # 说清**实际**用的是哪条规则：有收录分的按概率筛，早于该字段的产物
+                # 退回旧规则。无脑写"阈值 includeScore >= x"，在后一种情况下是撒谎。
+                parsed = [_num(a.get('includeScore')) for a in arts]
+                scored = sum(1 for v in parsed if v is not None)
+                if scored == 0:
+                    print(f'  收录筛选: {len(arts)} 篇 -> {len(kept)} 篇'
+                          f'（这些产物没有收录分，退回旧的 relevance == 高 规则）')
+                elif scored < len(arts):
+                    print(f'  收录筛选: {len(arts)} 篇 -> {len(kept)} 篇'
+                          f'（{scored} 篇按 includeScore >= {INCLUDE_THRESHOLD}，'
+                          f'其余 {len(arts) - scored} 篇按旧规则）')
+                else:
+                    print(f'  收录筛选: {len(arts)} 篇 -> {len(kept)} 篇'
+                          f'（阈值 includeScore >= {INCLUDE_THRESHOLD}）')
+            return kept
         except Exception:
             pass
     # 回退：扫描 MD 文件
@@ -119,8 +300,7 @@ def load_articles_from_date(date_str: str) -> list[dict]:
             if not fm:
                 continue
             relevance = fm.get('relevance', '中')
-            # 非 AI 主题只收录相关度"高"的文章
-            if topic != FOCUS_TOPIC and relevance != '高':
+            if not admits({**fm, 'topic': topic}, include_all, exclude):
                 continue
             # AI 主题读取完整正文（最多 5000 字），其他主题读取摘要
             if topic == FOCUS_TOPIC:
@@ -148,11 +328,13 @@ def load_articles_from_date(date_str: str) -> list[dict]:
     return articles
 
 
-def load_articles_range(from_date: date, to_date: date) -> list[dict]:
+def load_articles_range(from_date: date, to_date: date, include_all: bool = False,
+                        exclude=()) -> list[dict]:
     all_articles = []
     cur = from_date
     while cur <= to_date:
-        all_articles.extend(load_articles_from_date(cur.strftime('%Y-%m-%d')))
+        all_articles.extend(load_articles_from_date(cur.strftime('%Y-%m-%d'), include_all,
+                                                   exclude))
         cur += timedelta(days=1)
     return all_articles
 
@@ -290,6 +472,11 @@ def main():
     parser.add_argument('--to', dest='to_date', help='结束日期 YYYY-MM-DD，默认今天')
     parser.add_argument('--output', help='输出文件路径（默认 output/ai-reports/）')
     parser.add_argument('--dry-run', action='store_true', help='不调用 AI，仅输出统计骨架')
+    parser.add_argument('--exclude-topics', default='',
+                        help='不在报告里出现的主题，逗号分隔（如 新闻,投资）；'
+                             '展示层开关：不重抓、不改产物，只影响这份报告收谁')
+    parser.add_argument('--include-all', action='store_true',
+                        help='不筛选，收录当天全部文章（回退到引入收录判据之前的行为）')
     args = parser.parse_args()
 
     # 日期解析
@@ -314,7 +501,11 @@ def main():
     print(f'🔧 引擎: {args.engine}' + (' (dry-run)' if args.dry_run else ''))
 
     # 加载文章
-    articles = load_articles_range(from_date, to_date)
+    exclude = excluded_topics(load_config(), args.exclude_topics,
+                                  protected=(FOCUS_TOPIC,))
+    if exclude:
+        print('🚫 已排除主题: ' + '/'.join(t for t in TOPICS if t in exclude))
+    articles = load_articles_range(from_date, to_date, args.include_all, exclude)
     if not articles:
         print(f'\n❌ 未找到 {date_label} 的文章。请先运行：')
         print(f'   python scripts/biz_daily.py')
@@ -353,6 +544,20 @@ def main():
     # 生成报告
     t0 = time.time()
     report = generate_report(articles, engine, date_label, dry_run=args.dry_run)
+    # 不确定那一段在本地算：它必须与"模型有没有写、写得漂不漂亮"无关。
+    # 另外单独加载一次全集——被收录判据筛掉的边界条目也要能看见，
+    # 否则"我拿不准"只报告了收进来的那一半。
+    try:
+        everything = load_articles_range(from_date, to_date, include_all=True,
+                                         exclude=exclude)
+    except Exception:
+        everything = articles
+    section = build_uncertainty_section(articles, everything, include_all=args.include_all,
+                                        exclude=exclude)
+    report += section
+    uncertain_count = section.count(chr(10) + '- ')
+    if uncertain_count:
+        print(f'   不确定条目: {uncertain_count} 条已列入报告末尾')
     elapsed = time.time() - t0
 
     with open(out_path, 'w', encoding='utf-8') as f:

package/scripts/generate_html.py

@@ -14,6 +14,9 @@ SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
 PROJECT_ROOT = os.path.dirname(SCRIPTS_DIR)
 SOURCE_ROOT = os.path.join(PROJECT_ROOT, 'output', 'biz-daily')
 
+sys.path.insert(0, SCRIPTS_DIR)
+from _utils import load_config, excluded_topics  # noqa: E402
+
 
 def _inline_marked_js(html_path: str):
     """Replace CDN marked.js with local inline copy to eliminate network dependency."""
@@ -84,10 +87,16 @@ def get_body_preview(text: str, max_chars=200) -> str:
     return preview
 
 
-def collect_articles(date_dir: str) -> dict:
-    """收集所有文章，按主题分组。"""
+def collect_articles(date_dir: str, exclude=()) -> dict:
+    """收集所有文章，按主题分组。
+
+    `exclude` 里的主题**整个目录都不扫**（不是扫完再滤）：读者页和 AI 报告共用同一份
+    排除集，两边才不会一个说排掉了、另一个还在列。展示层开关，md 产物不动。
+    """
     topics = {}
     for topic in TOPIC_ORDER:
+        if topic in exclude:
+            continue
         topic_dir = Path(date_dir) / topic
         if not topic_dir.is_dir():
             continue
@@ -1597,6 +1606,8 @@ def main():
     parser = argparse.ArgumentParser(description='生成公众号日报 HTML 页面')
     parser.add_argument('--date', help='日期 YYYY-MM-DD, 默认今天')
     parser.add_argument('--output', help='输出路径（默认在日报目录下的 index.html）')
+    parser.add_argument('--exclude-topics', default='',
+                        help='不展示的主题，逗号分隔（如 新闻,投资）；只影响这一页，不改产物')
     args = parser.parse_args()
 
     if args.date:
@@ -1612,7 +1623,11 @@ def main():
         print(f'[ERROR] 目录不存在: {date_dir}')
         sys.exit(1)
 
-    topics = collect_articles(date_dir)
+    exclude = excluded_topics(load_config(), args.exclude_topics,
+                              protected=(TOPIC_ORDER[0],))  # 第一项=这份日报的主体
+    if exclude:
+        print('🚫 已排除主题: ' + '/'.join(t for t in TOPIC_ORDER if t in exclude))
+    topics = collect_articles(date_dir, exclude)
     if not topics:
         print(f'[ERROR] 未找到任何文章')
         sys.exit(1)