weflow-cli 1.6.4 → 1.8.0

package/scripts/create_reading_notes.py

@@ -26,6 +26,39 @@ TOPIC_ORDER = ['AI', '学术', '新闻', '文学', '投资', '政治']
 
 # ====== V2 模板 ======
 
+# 阅读笔记里"相关文章"那一段的查询。**单独抽出来，是因为它有两个使用方**：模板（写新笔记）
+# 与 `refresh_dataview_blocks()`（重写老笔记）。写成两份就会漂移，而漂移的表现是
+# "新笔记的查询是对的、老笔记的还是坏的"——不报错。
+#
+# 三处修正（2026-09-27，都是实测出来的坏查询）：
+# - `SORT date DESC` → `SORT published DESC`：笔记里**没有 `date` 这个字段**（是 `published`），
+#   原查询排不出来。
+# - 加了 `file.name != this.file.name`：否则一篇笔记的"相关文章"里会列出它自己。
+# - 首列从 `rating` 改成 `published`：`rating` 是留给用户打分的，全库默认空；
+#   拿它当首列，表格十行全是空格。
+# - `contains(hasTopic, "…")` → **`contains(string(hasTopic), "…")`**：笔记里写的是
+#   `hasTopic: [[新闻]]`，而 YAML 把它解析成**嵌套列表** `[['新闻']]`——对它做
+#   `contains(…, "新闻")` 是在拿字符串比一个子列表。外面套一层 `string()` 对形状不敏感
+#   （字符串、列表、链接都成立），代价是万一有主题名互为子串会多匹配——本库的六个主题
+#   （AI/学术/新闻/文学/投资/政治）之间没有这种关系。
+RELATED_QUERY = '''```dataview
+TABLE published AS 日期, source AS 来源, rating
+FROM "002_Literature"
+WHERE contains(string(hasTopic), "{topic}") AND file.name != this.file.name
+SORT published DESC
+LIMIT 10
+```'''
+
+# 日记里"概念连接"那一段的查询。**判日期必须用 `published`（文章日期），不能用 `created`**：
+# `created` 是**生成这篇笔记的日期**，而一次回填会把几万篇的 `created` 全写成同一天
+# （实测：25,676 篇全是 2026-09-26）。用 `created` 判，结果是 175 天的日记全空、
+# 唯独生成那天把两万多篇一次性列出来。
+DAILY_QUERY = '''```dataview
+LIST
+FROM "002_Literature"
+WHERE published = date("{date}")
+```'''
+
 NOTE_TEMPLATE = '''---
 title: "{title}"
 aliases: [{aliases}]
@@ -120,13 +153,7 @@ reading-progress: 0
 
 ## 📊 相关文章
 
-```dataview
-TABLE rating, importance, reading-progress
-FROM "002_Literature"
-WHERE contains(hasTopic, "{topic}")
-SORT date DESC
-LIMIT 10
-```
+{related_query}
 
 ---
 
@@ -177,11 +204,7 @@ energy:
 
 ## 🔗 概念连接
 
-```dataview
-LIST
-FROM "002_Literature"
-WHERE created = date({date})
-```
+{daily_query}
 
 ---
 
@@ -204,7 +227,16 @@ VAULT_DIRS = [
     '005_Reference/Tools',
     '005_Reference/Methods',
     '006_Projects',
-    '007_Wiki/Concepts',
+    # **这里原先写的是 `007_Wiki/Concepts`，2026-09-27 改成顶层的 `Wiki/Concepts`。**
+    # 概念页一直实际写在顶层（`compile_wiki.OUTPUT_ROOT`，另有 `vault_rag` / `vault_search` /
+    # `wiki_lint` / 助手的知识检索 / CLI 两个选项共 6 处读那里），模板却声明在 007_Wiki，
+    # 于是每次 init 都建出一个**永远空着**的 `007_Wiki/`——用户在 Obsidian 里看到它，
+    # 得到的结论是"知识库没更新"。一条路径写在两处就会这样：不报错，只是一个目录永远空着。
+    # `test/compile_wiki_test.py` 现在钉住两者必须一致。
+    # **两个知识库各一个目录**（用户 2026-09-27 要求分开）：`Wiki/Concepts` 是公众号文章线的，
+    # `Chat/Concepts` 是聊天线的。这里的清单要与 `_utils.CONCEPT_DIRS` 一致——有测试盯着。
+    'Wiki/Concepts',
+    'Chat/Concepts',
     '008_MOC',
     '999_Archive',
     '_attachments',
@@ -243,6 +275,11 @@ def extract_summary(body: str, max_len=300) -> str:
         line = line.replace('[[', '').replace(']]', '')
         if line:
             lines.append(line)
+    # **界面残留要在这里清掉**：正文来自微信，带着阅读器自己的文字与文末的原创标记。
+    # 实测 1633 篇里 330 篇的摘要在这一步之前就混进了它（写笔记这条路此前没清洗）。
+    from _utils import strip_wx_ads
+    lines = [strip_wx_ads(line) for line in lines]
+    lines = [line for line in lines if line]
     summary = ' '.join(lines[:10])
     if len(summary) > max_len:
         summary = summary[:max_len] + '...'
@@ -311,20 +348,167 @@ def create_reading_note(article_path, vault_path, date_str):
         source=source, url=url, local_source=local_source, published=published,
         topic=topic, topic_tag=topic_tag,
         summary=summary, concepts=concepts,
+        # 查询要先自己 format 好再传进去：`str.format` **不会**回头再扫一遍替换进去的值，
+        # 直接传带 `{topic}` 的原文，那对大括号会原样留在笔记里。
+        related_query=RELATED_QUERY.format(topic=topic),
     )
     note_path.write_text(note_content, encoding='utf-8')
     return 'created', title
 
 
+DV_BLOCK_RE = re.compile(r'```dataview\b.*?```', re.DOTALL)
+
+
+def refresh_dataview_blocks(vault: str) -> dict:
+    """把**已有**笔记里的 dataview 查询重写成上面那两份当前模板。**本地重算，不调用模型。**
+
+    为什么非要有它：`create_reading_note()` 遇到已存在的笔记是 `skip`，所以改模板只影响
+    **以后**生成的笔记——库里已有的那批会永远停在旧查询上。2026-09-27 修那两处坏查询时，
+    库里已经有 25,852 个文件带着它们（阅读笔记 25,676 + 日记 176），光改模板一个都修不到。
+
+    用哪一份按笔记的位置定：
+    - `001_Daily/<日期>.md` → 日记那份，日期取自文件名；
+    - `002_Literature/**` → 阅读笔记那份，主题取自 frontmatter 的 `topic`/`hasTopic`。
+
+    **判不出来就不动**（没主题、没查询块），并分类计数报出来——不猜、不静默。
+    """
+    vault_path = Path(vault)
+    targets = []
+    daily_dir = vault_path / '001_Daily'
+    if daily_dir.is_dir():
+        targets += [('daily', p, p.stem) for p in sorted(daily_dir.glob('*.md'))]
+    literature = vault_path / '002_Literature'
+    if literature.is_dir():
+        targets += [('note', p, None) for p in sorted(literature.rglob('*.md'))]
+
+    rewritten, no_block, skipped, topicless = [], [], [], []
+    for kind, path, value in targets:
+        try:
+            content = path.read_text(encoding='utf-8')
+        except (OSError, UnicodeDecodeError):
+            # 读不出来就**不碰它**并计数。`UnicodeDecodeError` 要一起接住：它不是 OSError，
+            # 漏了它就会让一个坏文件把整趟重写打断——而这一趟要处理两万多个文件。
+            skipped.append(path.name)
+            continue
+        if kind == 'note':
+            frontmatter, _ = parse_frontmatter(content)
+            # **必须先取 `raw[0]`**。笔记里写的是 `hasTopic: [[新闻]]`，YAML 把它解析成
+            # **嵌套列表** `[['新闻']]`；直接 `str()` 整个列表会得到 `"['[新闻]']"`，
+            # 剥掉方括号就成了 `"'[新闻]'"`——一个带着引号和方括号的主题值被塞进查询，
+            # 而且**不报错**，表格只是永远空着。2026-09-27 我第一版就是这么写的，
+            # 25,669 篇被写坏。
+            #
+            # 这段与 `compile_wiki.article_topic` 是同一条规则。**没有直接调它**，是因为
+            # `create_reading_notes` 刻意不引 `_utils`（本仓库记过：加了导入边会让命令能否
+            # 运行取决于调用方的工作目录），而 `compile_wiki` 会传递地引入它。
+            raw = frontmatter.get('topic') or frontmatter.get('hasTopic') or ''
+            if isinstance(raw, (list, tuple)):
+                raw = raw[0] if raw else ''
+            value = str(raw).strip().strip('[]').strip()
+            # **主题为空也照改，只是单独计数**：那 7 篇（实测）本来就是空主题，
+            # 它们的查询里写着 `hasTopic, ""`。跳过它们等于让它们继续留着
+            # `SORT date` 那个排不出来的写法——而"语法对、结果如实为空"比
+            # "语法错、看不出为什么"要好。计数是给人看的：这 7 篇确实没有主题。
+            if not value:
+                topicless.append(path.name)
+            fresh = RELATED_QUERY.format(topic=value)
+        else:
+            fresh = DAILY_QUERY.format(date=value)
+        if not DV_BLOCK_RE.search(content):
+            no_block.append(path.name)
+            continue
+        updated = DV_BLOCK_RE.sub(lambda _match: fresh, content, count=1)
+        if updated != content:
+            path.write_text(updated, encoding='utf-8')
+            rewritten.append(path.name)
+    return {'rewritten': rewritten, 'noBlock': no_block,
+            'skipped': skipped, 'topicless': topicless}
+
+
+SUMMARY_BLOCK_RE = re.compile(r'(##\s*[^\n]*摘要\s*\n)(.*?)(?=\n##\s|\Z)', re.DOTALL)
+
+
+def clean_summaries(vault: str) -> dict:
+    """把已有笔记**摘要段**里的微信界面残留洗掉。本地，不调模型。
+
+    为什么需要单独一趟：清洗是**读时做**的（`create_reading_notes` 生成摘要时才调
+    `strip_wx_ads`），所以**那条逻辑生效之前写好的笔记永远不会被清** —— 实测 25,676 篇
+    里有 1,484 篇的摘要带着 `继续滑动看下一个`、`去阅读`、`轻触阅读原文` 这些**页面按钮
+    文字**（不是文章内容）。改生成逻辑只影响以后写的笔记，与 `--refresh-queries` 同一个
+    道理。好消息是不会有新的：新写的本来就干净。
+
+    **只动摘要段，正文一个字不碰。** 正文是原文，清它等于改素材 —— 而残留对正文的害处
+    只是"翻原文时看着乱"，不值这个代价。
+    """
+    from _utils import _AD_PHRASES, strip_wx_ads
+    # **只扫阅读笔记那一层**（`002_Literature`），与 `refresh_dataview_blocks` 同一套目录。
+    # 第一版写的是 `Path(vault).rglob('*.md')` —— 那会扫**整个库**，实测把 `Sources/` 的
+    # 10,949 篇**原文**也洗了（2026-09-28）。那些原文是素材，清洗它们不是这条命令的职责：
+    # 下游生成读的是笔记（`create_reading_notes` 已经读过原文并清过摘要），所以动素材
+    # 只有"翻原文时看着干净"这一个好处，却要付"改素材"的代价。
+    cleaned, untouched, skipped = [], [], []
+    root = Path(vault) / '002_Literature'
+    for path in sorted(root.rglob('*.md')):
+        try:
+            text = path.read_text(encoding='utf-8')
+        except (OSError, UnicodeDecodeError):
+            skipped.append(path.name)
+            continue
+        match = SUMMARY_BLOCK_RE.search(text)
+        if not match:
+            continue
+        segment = match.group(2)
+        # **判据必须是"真的含界面短语"，不能是"文本变了"**：`strip_wx_ads` 末尾还有空白
+        # 规整与 `.strip()`，任何首尾带空白的段落都会"变"，拿它当判据会全量重写（2026-09-28
+        # 我在测量时正好踩过这一脚：判据恒真，于是报出 25,676 篇全部命中）。
+        if not any(phrase in segment for phrase in _AD_PHRASES):
+            untouched.append(path.name)
+            continue
+        fresh = strip_wx_ads(segment)
+        if fresh == segment:
+            untouched.append(path.name)
+            continue
+        path.write_text(text[:match.start(2)] + fresh + text[match.end(2):], encoding='utf-8')
+        cleaned.append(path.name)
+    return {'cleaned': cleaned, 'untouched': untouched, 'skipped': skipped}
+
+
 def main():
     sys.stdout.reconfigure(encoding='utf-8', errors='replace')
     import argparse
     parser = argparse.ArgumentParser(description='创建 Obsidian 阅读笔记 V2')
-    parser.add_argument('--date', required=True, help='日期 YYYY-MM-DD')
+    parser.add_argument('--date', help='日期 YYYY-MM-DD（--refresh-queries 时不需要）')
     parser.add_argument('--source', default=DEFAULT_SOURCE, help='文章目录')
     parser.add_argument('--vault', default=DEFAULT_VAULT, help='Vault 目录')
+    parser.add_argument('--clean-summaries', action='store_true',
+                        help='只把已有笔记摘要段里的微信界面残留洗掉（本地，不调模型）')
+    parser.add_argument('--refresh-queries', action='store_true',
+                        help='只做这件事：把已有笔记里的 dataview 查询重写成当前模板（本地，不调模型）')
     args = parser.parse_args()
 
+    if args.clean_summaries:
+        # 本地清洗：动的是本地就能算出来的东西，不必把两万多篇重问一遍
+        result = clean_summaries(args.vault)
+        print('清洗摘要：%d 篇；本来就干净、没动的 %d 篇；读不出来的 %d 篇'
+              % (len(result['cleaned']), len(result['untouched']), len(result['skipped'])))
+        for name in result['skipped'][:5]:
+            print('   跳过:', name[:70])
+        return
+
+    if args.refresh_queries:
+        result = refresh_dataview_blocks(args.vault)
+        print('重写 %d 篇；没有查询块、没动的 %d 篇；读不出来的 %d 篇'
+              % (len(result['rewritten']), len(result['noBlock']), len(result['skipped'])))
+        if result['topicless']:
+            print('   其中主题为空（照改，但表会是空的）: %d 篇' % len(result['topicless']))
+        for name in result['skipped'][:5]:
+            print('   跳过:', name[:70])
+        return
+
+    if not args.date:
+        print('[ERROR] 要 --date（或用 --refresh-queries 只重写查询）')
+        sys.exit(1)
+
     date_dir = os.path.join(args.source, args.date)
     if not os.path.isdir(date_dir):
         print(f'[ERROR] 目录不存在: {date_dir}')
@@ -361,6 +545,7 @@ def main():
         daily_content = DAILY_TEMPLATE.format(
             date=args.date, total=total, created=created,
             reading_list='\n'.join(titles[:20]) if titles else '(无)',
+            daily_query=DAILY_QUERY.format(date=args.date),
         )
         daily_path.write_text(daily_content, encoding='utf-8')
         print(f'  日记: {daily_path}')

package/scripts/decide.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""本机判断层 —— 一个 state、一批类型化问题、一次调用，返回带概率的答案。
+
+**它解决的不是"判断得更好"，是"判断得起"。** 调用方自己的模型当然也能判断，
+但那是按 token 收费、按次往返、还要把散文解析回结构。这里一次请求问 20 个问题
+实测约 1 秒，且问题数几乎不影响成本（2 个 0.84s / 12 个 0.91s），所以
+**"给 N 个条目各打一批标签"这件事第一次变得便宜**。
+
+典型用法是一个 Agent 在批量处理时把判断外包出来：
+
+    echo '{"state": "...", "questions": {"相关": {"type": "noul",
+           "instructions": "这段是否与大气污染有关？"}}}' | python scripts/decide.py
+
+    python scripts/decide.py --request req.json
+    python scripts/decide.py --request req.json --dry-run   # 只校验不调用
+
+输出（stdout，JSON）：
+
+    {"success": true, "model": "jev-1.13.0", "answers": {...},
+     "usage": {"input_tokens": 1200, "output_tokens": 60}, "costUsd": 5.04e-05}
+
+请求格式**本地先校验**：形状不对就在本机报错，不让它变成一个来自服务端的 422——
+那种错误只告诉你"哪里不对"里最不重要的那部分。
+
+    state     : 字符串 / JSON 对象 / 数组（共享给所有问题）
+    questions : {名字: {type, instructions, criteria}}
+                choice → criteria 是对象 {选项名: 何时选它}
+                score  → criteria 是有序数组，**位置即分值，从 0 开始**
+                noul   → 不需要 criteria（可选 {true, false}）
+
+批量模式把最常用的那层展开做掉了——一个 glob × 一批问题，自动变成 N×M 个问题：
+
+    python scripts/decide.py --over "scripts/*.py" --ask "会写本地文件吗" --ask "会出网吗" --yes
+
+**这是出境调用**：state 会被发到 api.typesafe.ai。读不读本地由输入方式决定：
+`--request`/stdin **完全由调用方给**，命令自己不读任何文件；`--over` 会读匹配到的
+文件（所以它是一条读本地数据的路径，`capabilities` 里也如实分开写了）。
+"""
+import argparse
+import glob
+import json
+import os
+import sys
+import urllib.error
+
+sys.path.insert(0, __import__('os').path.dirname(__import__('os').path.abspath(__file__)))
+from jev_client import INPUT_USD_PER_TOKEN, JevError, create_client  # noqa: E402
+
+QUESTION_TYPES = ('choice', 'score', 'noul')
+
+
+def expand_batch(patterns, asks, max_chars, limit):
+    """把「一批文件 × 一批问题」展开成一次请求的 state 与 questions。
+
+    问题名是 `f<序号>|q<序号>` 而不是把文件名编进去：文件名里有 `|`、空格、中文标点，
+    编进去之后调用方要靠解析字符串才能还原。序号 + 响应里的 `batch.files` 是显式的映射。
+
+    **喂多少字符要能看见**：实测同一批问题，只喂每个文件前 14 行和喂前 1500 字符，
+    与基准的一致率从 77.3% 变成 88.6%——证据量决定上限。所以它由参数给出，
+    并且写进返回里，而不是藏在实现里。
+    """
+    paths = []
+    for pattern in patterns:
+        paths.extend(glob.glob(pattern, recursive=True))
+    # 排序 + 去重：同一批文件两次跑应该展开成同样的顺序，否则问题名对不上。
+    paths = sorted({p for p in paths if os.path.isfile(p)})
+    if limit:
+        paths = paths[:limit]
+    if not paths:
+        return None, None, None, '没有匹配到任何文件：%s' % ', '.join(patterns)
+
+    blocks = []
+    for index, path in enumerate(paths):
+        try:
+            with open(path, encoding='utf-8', errors='replace') as handle:
+                body = handle.read()
+        except OSError as error:
+            return None, None, None, '读不到 %s：%s' % (path, error)
+        blocks.append('【f%d】%s\n%s' % (index, os.path.basename(path), body[:max_chars]))
+
+    names = [os.path.basename(p) for p in paths]
+    state = ('下面是 %d 个文件，每个只给出前 %d 个字符：\n\n%s'
+             % (len(paths), max_chars, '\n\n'.join(blocks)))
+    questions = {}
+    for index, name in enumerate(names):
+        for ask_index, instruction in enumerate(asks):
+            questions['f%d|q%d' % (index, ask_index)] = {
+                'type': 'noul',
+                'instructions': '【f%d】（%s）%s' % (index, name, instruction),
+            }
+    return state, questions, {'files': names, 'asks': list(asks),
+                              'maxChars': max_chars}, None
+
+
+def validate_request(payload):
+    """返回 (state, questions, error_message)。error 非空时调用方应当拒绝。
+
+    宁可在这里啰嗦，也不要把一个形状不对的请求发出去换一个 422：
+    服务端的校验错误只说得出"哪个字段不合法"，说不出"你本来想干什么"。
+    """
+    if not isinstance(payload, dict):
+        return None, None, '请求必须是一个 JSON 对象'
+    state = payload.get('state')
+    if state is None or (isinstance(state, str) and not state.strip()):
+        return None, None, '缺少 state（字符串 / 对象 / 数组都可以，但不能为空）'
+    if not isinstance(state, (str, dict, list)):
+        return None, None, 'state 只能是字符串、JSON 对象或数组'
+
+    questions = payload.get('questions')
+    if not isinstance(questions, dict) or not questions:
+        return None, None, 'questions 必须是一个非空对象：{名字: {type, ...}}'
+
+    for name, question in questions.items():
+        if not isinstance(question, dict):
+            return None, None, '问题 %r 必须是一个对象' % name
+        kind = question.get('type')
+        if kind not in QUESTION_TYPES:
+            return None, None, ('问题 %r 的 type 必须是 %s 之一，收到 %r'
+                                % (name, '/'.join(QUESTION_TYPES), kind))
+        criteria = question.get('criteria')
+        if kind == 'choice':
+            if not isinstance(criteria, dict) or not criteria:
+                return None, None, ('choice 问题 %r 需要非空 criteria 对象 '
+                                    '{选项名: 何时选它}' % name)
+        elif kind == 'score':
+            # 位置即分值，只有一个档位的话 score 恒等于 0，毫无信息量。
+            if not isinstance(criteria, list) or len(criteria) < 2:
+                return None, None, ('score 问题 %r 的 criteria 需要至少两个有序档位'
+                                    '（位置即分值）' % name)
+        elif criteria is not None and not isinstance(criteria, dict):
+            return None, None, 'noul 问题 %r 的 criteria 若要给，必须是对象' % name
+    return state, questions, None
+
+
+def read_request(args):
+    if args.request and args.request != '-':
+        try:
+            with open(args.request, encoding='utf-8') as handle:
+                return handle.read()
+        except OSError as error:
+            raise SystemExit('读不到请求文件：%s' % error)
+    return sys.stdin.read()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='本机判断层：一个 state + 一批类型化问题，一次调用返回带概率的答案')
+    parser.add_argument('--request', help='请求 JSON 的路径，或 - 表示读 stdin（默认读 stdin）')
+    parser.add_argument('--over', action='append', default=[], metavar='GLOB',
+                        help='批量模式：对匹配到的每个文件问 --ask 里的每个问题（可重复）')
+    parser.add_argument('--ask', action='append', default=[], metavar='TEXT',
+                        help='批量模式下的一个是非题，逐文件展开（可重复）')
+    parser.add_argument('--max-chars', type=int, default=1500, metavar='N',
+                        help='批量模式下每个文件喂多少字符（默认 1500；它决定上限）')
+    parser.add_argument('--limit', type=int, default=50, metavar='N',
+                        help='批量模式最多取多少个文件（默认 50，0 表示不限）')
+    parser.add_argument('--model', default='', help='模型别名，默认 jev-latest')
+    parser.add_argument('--dry-run', action='store_true', help='只校验并回显请求，不调用')
+    args = parser.parse_args()
+
+    batch_meta = None
+    if args.over:
+        if not args.ask:
+            print(json.dumps({'success': False, 'code': 'INVALID_REQUEST',
+                              'error': '批量模式需要至少一个 --ask（否则没有问题可问）'},
+                             ensure_ascii=False))
+            return 2
+        state, questions, batch_meta, error = expand_batch(
+            args.over, args.ask, args.max_chars, args.limit)
+        if error:
+            print(json.dumps({'success': False, 'code': 'NO_FILES', 'error': error},
+                             ensure_ascii=False))
+            return 2
+        payload = {'state': state, 'questions': questions}
+    elif args.request or not sys.stdin.isatty():
+        raw = read_request(args)
+        if not raw.strip():
+            print(json.dumps({'success': False, 'code': 'EMPTY_REQUEST',
+                              'error': 'stdin 或 --request 里没有内容'}, ensure_ascii=False))
+            return 2
+        try:
+            payload = json.loads(raw)
+        except json.JSONDecodeError as error:
+            print(json.dumps({'success': False, 'code': 'INVALID_JSON',
+                              'error': '请求不是合法 JSON: %s' % error}, ensure_ascii=False))
+            return 2
+    else:
+        print(json.dumps({'success': False, 'code': 'EMPTY_REQUEST',
+                          'error': '没有输入：用 --request/--over，或把请求接到 stdin'},
+                         ensure_ascii=False))
+        return 2
+
+    state, questions, error = validate_request(payload)
+    if error:
+        print(json.dumps({'success': False, 'code': 'INVALID_REQUEST',
+                          'error': error}, ensure_ascii=False))
+        return 2
+
+    size = len(state) if isinstance(state, str) else len(
+        json.dumps(state, ensure_ascii=False))
+
+    if args.dry_run:
+        body = {
+            'success': True, 'dryRun': True, 'action': 'decide',
+            'questions': list(questions), 'questionCount': len(questions),
+            'stateChars': size,
+            # 批量模式下这两件事必须报出来：读了本地什么、每份喂了多少（决定上限）。
+            'readsLocalData': bool(args.over),
+            'invokesAI': True,
+        }
+        if batch_meta:
+            body['batch'] = batch_meta
+            body['fileCount'] = len(batch_meta['files'])
+            body['maxChars'] = batch_meta['maxChars']
+        print(json.dumps(body, ensure_ascii=False))
+        return 0
+
+    client = create_client(model=args.model) if args.model else create_client()
+    if client is None:
+        print(json.dumps({'success': False, 'code': 'NO_KEY',
+                          'error': '缺少 TypeSafe key：weflow-cli config set '
+                                   'typesafeApiKey "..."'}, ensure_ascii=False))
+        return 2
+
+    try:
+        answers, usage = client.decide(state, questions)
+    except JevError as err:
+        print(json.dumps({'success': False, 'code': 'DECIDE_FAILED',
+                          'error': str(err)}, ensure_ascii=False))
+        return 1
+    except urllib.error.URLError as err:  # 兜底：客户端应当已经包好了
+        print(json.dumps({'success': False, 'code': 'DECIDE_FAILED',
+                          'error': str(err)}, ensure_ascii=False))
+        return 1
+
+    tokens = usage.get('input_tokens') or 0
+    body = {
+        'success': True,
+        'model': client.model,
+        'answers': answers,
+        'usage': usage,
+        # 把成本一起回给调用方：一个 Agent 要能自己决定"再问一批"划不划算。
+        'costUsd': round(tokens * INPUT_USD_PER_TOKEN, 8),
+    }
+    if batch_meta:
+        # 序号到文件/问题的映射由这里给出，调用方不必去解析问题名。
+        body['batch'] = batch_meta
+    print(json.dumps(body, ensure_ascii=False))
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())