weflow-cli 1.12.0 → 1.13.1

package/package.json

@@ -1,86 +1,88 @@
-{
-  "name": "weflow-cli",
-  "version": "1.12.0",
-  "description": "让 AI 读懂你的微信 — 公众号日报·聊天导出·知识库搜索·MCP Server",
-  "type": "module",
-  "bin": {
-    "weflow-cli": "cli.cjs"
-  },
-  "files": [
-    "cli.cjs",
-    "dist/",
-    "scripts/**/*.py",
-    "scripts/data/",
-    "mcp-server/",
-    "bin/",
-    "src/",
-    "resources/",
-    "docs/images/",
-    "docs/*.md",
-    "logo.png",
-    "README.md",
-    "OPERATIONS.md",
-    "ARCHITECTURE.md",
-    "CONTRIBUTING.md",
-    "SECURITY.md",
-    "CHANGELOG.md",
-    "requirements*.txt",
-    "LICENSE"
-  ],
-  "keywords": [
-    "wechat",
-    "weixin",
-    "mcp",
-    "rss",
-    "daily",
-    "公众号",
-    "聊天记录",
-    "ai",
-    "deepseek",
-    "claude"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/zhuobichen/weflow-cli.git"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "node --import tsx --test \"test/**/*.test.ts\"",
-    "dev": "npx tsx bin/weflow-cli.ts",
-    "start": "node cli.cjs",
-    "prepublishOnly": "npm run build",
-    "eval:assistant": "node --import tsx scripts/assistant_eval.ts"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@wenyan-md/core": "^3.0.10",
-    "chalk": "^5.4.1",
-    "commander": "^13.1.0",
-    "css-tree": "^3.2.1",
-    "exceljs": "^4.4.0",
-    "form-data-encoder": "^4.1.0",
-    "formdata-node": "^6.0.3",
-    "front-matter": "^4.0.2",
-    "fzstd": "^0.1.1",
-    "highlight.js": "^11.11.1",
-    "inquirer": "^13.4.3",
-    "jsdom": "^27.4.0",
-    "koffi": "^2.9.0",
-    "marked": "^18.0.4",
-    "marked-highlight": "^2.2.4",
-    "qrcode-terminal": "^0.12.0"
-  },
-  "optionalDependencies": {
-    "lz4": "^0.6.5"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@types/qrcode-terminal": "^0.12.2",
-    "electron": "^42.0.1",
-    "tsx": "^4.19.0",
-    "typescript": "^5.7.0"
-  },
-  "engines": {
-    "node": ">=22.13.0"
-  }
-}
+{
+  "name": "weflow-cli",
+  "version": "1.13.1",
+  "description": "让 AI 读懂你的微信 — 公众号日报·聊天导出·知识库搜索·MCP Server",
+  "type": "module",
+  "bin": {
+    "weflow-cli": "cli.cjs"
+  },
+  "files": [
+    "cli.cjs",
+    "dist/",
+    "scripts/**/*.py",
+    "scripts/**/*.ps1",
+    "scripts/**/*.cmd",
+    "scripts/data/",
+    "mcp-server/",
+    "bin/",
+    "src/",
+    "resources/",
+    "docs/images/",
+    "docs/*.md",
+    "logo.png",
+    "README.md",
+    "OPERATIONS.md",
+    "ARCHITECTURE.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CHANGELOG.md",
+    "requirements*.txt",
+    "LICENSE"
+  ],
+  "keywords": [
+    "wechat",
+    "weixin",
+    "mcp",
+    "rss",
+    "daily",
+    "公众号",
+    "聊天记录",
+    "ai",
+    "deepseek",
+    "claude"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhuobichen/weflow-cli.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --import tsx --test \"test/**/*.test.ts\"",
+    "dev": "npx tsx bin/weflow-cli.ts",
+    "start": "node cli.cjs",
+    "prepublishOnly": "npm run build",
+    "eval:assistant": "node --import tsx scripts/assistant_eval.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@wenyan-md/core": "^3.0.10",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "css-tree": "^3.2.1",
+    "exceljs": "^4.4.0",
+    "form-data-encoder": "^4.1.0",
+    "formdata-node": "^6.0.3",
+    "front-matter": "^4.0.2",
+    "fzstd": "^0.1.1",
+    "highlight.js": "^11.11.1",
+    "inquirer": "^13.4.3",
+    "jsdom": "^27.4.0",
+    "koffi": "^2.9.0",
+    "marked": "^18.0.4",
+    "marked-highlight": "^2.2.4",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "optionalDependencies": {
+    "lz4": "^0.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "electron": "^42.0.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=22.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/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