weflow-cli 1.8.2 → 1.10.0

package/scripts/pipeline.py

@@ -43,8 +43,11 @@ def main():
     parser.add_argument('--interest', default='AI', help='兴趣主题（默认 AI）')
     parser.add_argument('--wiki-limit', type=int, default=20, help='概念编译数量（默认 20）')
     parser.add_argument('--skip-classify', action='store_true', help='跳过后处理')
-    parser.add_argument('--skip-wiki', action='store_true', help='跳过概念编译')
-    parser.add_argument('--skip-vault', action='store_true', help='跳过 Vault 同步')
+    parser.add_argument('--with-wiki', action='store_true',
+                        help='把概念页写进 Obsidian Vault。**默认不做** —— Obsidian 自带的图谱\n'
+                             '视图是实时的，写一次 vault 图谱就重画一次，所以只有你明确要它重建时才写')
+    parser.add_argument('--with-vault', action='store_true',
+                        help='把当天的内容副本同步进 Obsidian Vault（Sources/WeChat/<日期>/）。**默认不做**')
     parser.add_argument('--skip-html', action='store_true', help='跳过 HTML 生成')
     parser.add_argument('--skip-ai-report', action='store_true', help='跳过 AI 深度阅读报告')
     parser.add_argument('--no-ai', action='store_true', help='关闭所有 AI 调用，但保留抓取和本地输出')
@@ -52,7 +55,7 @@ def main():
                         help='biz_daily 只做判断不做生成（不调 LLM 写摘要/标签/简报，'
                              '主题与相关度仍由 Jev 判断），因此**不需要 DeepSeek key**。'
                              '注意：下游步骤（行动建议/概念编译/AI 报告）仍会用 LLM，'
-                             '要全关请再加 --skip-classify --skip-wiki --skip-ai-report')
+                             '要全关请再加 --skip-classify --skip-ai-report')
     parser.add_argument('--ai-report-range', type=int, default=1, help='AI 报告覆盖最近 N 天（默认 1=仅当天）')
     parser.add_argument('--source', action='append', default=[], metavar='NAME',
                         help='仅处理指定公众号，可重复或用逗号分隔')
@@ -71,10 +74,10 @@ def main():
     #
     # **只算真的会调 LLM 的那两步**（行动建议、概念编译）：`generate_ai_report.py` 虽然
     # 叫 AI 报告，但一次 LLM 都不调（它读已落盘的概率与判断），把它算进来会让
-    # `--no-summary --skip-classify --skip-wiki` 仍然索要 DeepSeek key——那正是这条
+    # `--no-summary --skip-classify` 仍然索要 DeepSeek key——那正是这条
     # 路要摆脱的东西。
     api_key = args.api_key or ''
-    downstream_ai = not (args.skip_classify and args.skip_wiki)
+    downstream_ai = (not args.skip_classify) or args.with_wiki
     needs_key = args.engine in ('deepseek', 'claude') and not args.no_ai and (
         not args.no_summary or downstream_ai)
     if needs_key and not api_key:
@@ -104,7 +107,7 @@ def main():
             print('  [提示] --no-summary 只关掉本步骤的 LLM 生成；下游仍会调 LLM 的步骤：'
                   '%s。要全关请补上对应 --skip-*'
                   % '、'.join(n for n, skipped in (('classify_daily（行动建议）', args.skip_classify),
-                                                   ('compile_wiki（概念编译）', args.skip_wiki))
+                                                   ('compile_wiki（概念编译）', not args.with_wiki))
                               if not skipped))
     if not run_step('biz_daily — 抓取+摘要', step1_args):
         sys.exit(1)
@@ -121,8 +124,8 @@ def main():
         if not run_step('classify_daily — 后处理', step2_args):
             print('[WARN] classify_daily 失败，继续后续步骤')
 
-    # Step 3: Vault sync（可选）
-    if not args.skip_vault:
+    # Step 3: Vault sync（**默认不做**，见 --help）
+    if args.with_vault:
         date_str = args.date or time.strftime('%Y-%m-%d')
         source_dir = os.path.join(SOURCE_ROOT, date_str)
         vault_dir = os.path.join(os.path.dirname(SCRIPTS_DIR), 'output', 'wechat-vault',
@@ -134,14 +137,22 @@ def main():
             file_count = sum(1 for _ in Path(vault_dir).rglob('*.md'))
             print(f'\n  Vault 同步: {file_count} 个文件 → {vault_dir}')
 
-    # Step 4: wiki compile（可选）
-    if not args.skip_wiki and not args.no_ai:
+    # Step 4: wiki compile（**默认不做**，见 --help）
+    if args.with_wiki and not args.no_ai:
         step3_args = [
             os.path.join(SCRIPTS_DIR, 'compile_wiki.py'),
             '--limit', str(args.wiki_limit),
         ]
         run_step('wiki compile — 概念编译', step3_args)
 
+    # 默认不写 Vault：**Obsidian 自带的图谱视图是实时的** —— 它盯着 vault 里的文件，文件一变
+    # 就重画，所以"内容一更新图谱就重建"只在"自动改 vault"时发生。要它变，显式加那两个开关。
+    if not args.with_vault or not args.with_wiki:
+        missing = [name for name, on in (('--with-vault（当天内容副本）', args.with_vault),
+                                        ('--with-wiki（概念页）', args.with_wiki)) if not on]
+        print('\n  Obsidian 那边没有动：%s。要写进去就显式加上 —— 图谱只在你要它重建时才变。'
+              % '、'.join(missing))
+
     # Step 5: HTML 生成（可选）
     if not args.skip_html:
         date_str = args.date or time.strftime('%Y-%m-%d')

package/scripts/quality_eval.py

@@ -44,6 +44,11 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from _utils import TOPICS, RELEVANCE_NAMES  # noqa: E402
 from jev_client import create_client  # noqa: E402
 
+# 手跑或被重定向时 stdout 走本机编码（Windows 是 GBK）：非 GBK 字符（本文件里的 `⚠️`）会
+# UnicodeEncodeError、整次输出没了；桥接跑有 PYTHONIOENCODING=utf-8 所以看不出来。
+# 这条让两条路的输出一致（同 docs/EXTENDING.md Recipe E，守它的测试是 test/script_stdout_encoding_test.py）。
+sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
 TZ = timezone(timedelta(hours=8))
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 DAILY_ROOT = os.path.join(ROOT, 'output', 'biz-daily')

package/scripts/rag_chat.py

@@ -19,7 +19,8 @@ import sys, os, json
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from _utils import load_config, create_engine, get_api_key, get_dashscope_key
-from semantic_search import search as semantic_search, build_index, INDEX_DIR, VECTORS_FILE
+from semantic_search import (search as semantic_search, build_index, INDEX_DIR, VECTORS_FILE,
+                             LINE_CHOICES, line_label)
 
 PROMPT_TEMPLATE = """你是一个个人知识助手，可以访问用户的微信聊天记录和公众号文章。
 
@@ -36,8 +37,12 @@ PROMPT_TEMPLATE = """你是一个个人知识助手，可以访问用户的微
 请用中文简洁回答，在关键信息处引用来源编号（如 [1]、[2]）。"""
 
 
-def format_context(results: list[dict]) -> str:
-    """将搜索结果格式化为 RAG context。"""
+def format_context(results: list[dict], line: str = 'all') -> str:
+    """将搜索结果格式化为 RAG context。
+
+    没有内容时**说清是"这条线里没有"**：`（未找到相关信息）` 会被模型读成"用户的知识库里
+    没有"，而它其实只是"这一条线里没有"——答案的事实性就错在这里。
+    """
     chunks = []
     for i, item in enumerate(results, 1):
         if item.get('type') == 'article':
@@ -55,12 +60,13 @@ def format_context(results: list[dict]) -> str:
             chunks.append(
                 f"[{i}] 内容: {item.get('text', str(item)[:500])}"
             )
-    return '\n\n'.join(chunks) if chunks else '（未找到相关信息）'
+    return '\n\n'.join(chunks) if chunks else '（**%s**里没找到相关信息）' % line_label(line)
 
 
-def build_prompt(question: str, results: list[dict], history: list[dict] = None) -> str:
+def build_prompt(question: str, results: list[dict], history: list[dict] = None,
+                 line: str = 'all') -> str:
     """构建 RAG prompt。"""
-    context = format_context(results)
+    context = format_context(results, line)
 
     if history and len(history) > 0:
         history_text = '\n'.join(
@@ -73,10 +79,14 @@ def build_prompt(question: str, results: list[dict], history: list[dict] = None)
 
 
 def query_rag(question: str, embed_key: str, chat_key: str, top_k: int = 10,
-              talker: str = None, history: list[dict] = None) -> dict:
-    """执行一次 RAG 查询。"""
+              talker: str = None, history: list[dict] = None, line: str = 'all') -> dict:
+    """执行一次 RAG 查询。
+
+    `line` 一路透到语义检索。**答案里要写清搜的是哪条线**：RAG 的坏法不是报错，是
+    "这条线里没有"被说成"你的知识库里没有"。函数默认 `all`，用户看到的默认在 CLI 那一层。
+    """
     # 1. 语义检索
-    results = semantic_search(question, embed_key, top_k=top_k)
+    results = semantic_search(question, embed_key, top_k=top_k, line=line)
 
     # 2. 过滤 talker（如果指定）
     if talker:
@@ -88,7 +98,7 @@ def query_rag(question: str, embed_key: str, chat_key: str, top_k: int = 10,
             }
 
     # 3. 构建 prompt
-    prompt = build_prompt(question, results, history)
+    prompt = build_prompt(question, results, history, line)
 
     # 4. 调用 AI
     config = load_config()
@@ -104,15 +114,17 @@ def query_rag(question: str, embed_key: str, chat_key: str, top_k: int = 10,
         else:
             sources.append(f"[{i}] {item.get('title', item.get('id', '?'))[:60]}")
 
-    return {'answer': answer, 'sources': sources}
+    return {'answer': answer, 'sources': sources, 'line': line, 'lineLabel': line_label(line)}
 
 
-def interactive_mode(embed_key: str, chat_key: str):
+def interactive_mode(embed_key: str, chat_key: str, line: str = 'all'):
     """交互式多轮对话。"""
     config = load_config()
     engine_type = config.get('aiEngine', 'deepseek')
 
     print(f'\n🤖 RAG 智能助手 ({engine_type})')
+    # **把范围写在脸上**：交互模式一开就是十几轮，用户中途改了 `--line` 是看不到的
+    print(f'  检索范围: {line_label(line)}（`all` 才两条线一起搜）')
     print('  输入问题开始对话，输入 /help 查看帮助，输入 /exit 退出\n')
 
     history: list[dict] = []
@@ -143,7 +155,7 @@ def interactive_mode(embed_key: str, chat_key: str):
             print(f'✓ {result}\n')
             continue
 
-        result = query_rag(question, embed_key, chat_key, top_k=10, history=history)
+        result = query_rag(question, embed_key, chat_key, top_k=10, history=history, line=line)
         history.append({'question': question, 'answer': result['answer']})
 
         print(f'\n🤖 助手:\n{result["answer"]}')
@@ -161,6 +173,8 @@ def main():
     parser.add_argument('--top-k', type=int, default=10, help='检索数量（默认 10）')
     parser.add_argument('--talker', help='限定联系人/群聊')
     parser.add_argument('--api-key', help='DeepSeek API key（优先从 config 读取）')
+    parser.add_argument('--line', choices=list(LINE_CHOICES), default='wiki',
+                        help='只看一条知识库：wiki=文章线（默认）、chat=聊天线、all=两条都看')
     parser.add_argument('--json', action='store_true', help='JSON 输出')
     args = parser.parse_args()
 
@@ -179,13 +193,16 @@ def main():
         sys.exit(1)
 
     if args.interactive or not question:
-        interactive_mode(embed_key, chat_key)
+        interactive_mode(embed_key, chat_key, line=args.line)
     else:
-        result = query_rag(question, embed_key, chat_key, top_k=args.top_k, talker=talker)
+        result = query_rag(question, embed_key, chat_key, top_k=args.top_k, talker=talker,
+                           line=args.line)
         if args.json:
             print(json.dumps(result, ensure_ascii=False, indent=2))
         else:
-            print(f'\n{result["answer"]}')
+            # 范围写在这句话里：`--line chat` 没答上来时，读的人要能一眼看出
+            # 是"聊天线里没有"还是"整个知识库里没有"
+            print(f'\n（检索范围：{result["lineLabel"]}）\n{result["answer"]}')
             if result.get('sources'):
                 print(f"\n📎 来源: {' | '.join(result['sources'])}")
 

package/scripts/reply_debt.py

@@ -327,9 +327,20 @@ def main():
     try:
         picked = collect_conversations(conns, name_map, own_wxid, args.days, args.limit)
         if not picked:
-            print('最近 %d 天没有活跃会话' % args.days)
+            # `--json` 时 stdout 必须是一整份 JSON。这条早退原来只打散文 ⇒ 机器消费者**拿不到任何
+            # 可解析的东西**（空目录/闲置机器上就会撞到）。形状与下面的 dry-run 预览一致，只是计数为 0。
+            if args.json:
+                print(json.dumps({'success': True, 'dryRun': args.dry_run,
+                                  'action': 'reply-debt.scan', 'days': args.days,
+                                  'conversations': 0, 'stateChars': 0,
+                                  'readsLocalChat': True, 'invokesAI': True,
+                                  'writesNothing': True}, ensure_ascii=False))
+            else:
+                print('最近 %d 天没有活跃会话' % args.days)
             return 0
-        print('扫描 %d 个最近 %d 天有动静的会话…\n' % (len(picked), args.days))
+        # 进度走 stderr（同文件下面两处 `file=sys.stderr` 的写法）：`--json` 时 stdout 只放结果，
+        # 这一行原来无条件打 stdout ⇒ `awaiting --dry-run --json | jq` 会断在第一个字符上。
+        print('扫描 %d 个最近 %d 天有动静的会话…\n' % (len(picked), args.days), file=sys.stderr)
 
         # 每个会话的最近若干条消息，一次读完（连接只开一次）
         transcripts = {}
@@ -389,7 +400,8 @@ def main():
                         verdict, transcripts.get(item['talker'], []))
                     verdict['evidence'] = proofs.get(item['talker'], {})
                     rows.append(verdict)
-        print('判断完成 %d/%d，耗时 %.1fs\n' % (len(rows), len(futures), time.time() - started))
+        print('判断完成 %d/%d，耗时 %.1fs\n' % (len(rows), len(futures), time.time() - started),
+              file=sys.stderr)   # 进度：`--json` 时不许进 stdout（本机跑不到这条路径，按读码改的）
     finally:
         for conn in conns:
             conn.close()
@@ -413,6 +425,8 @@ def main():
     noise = [r for r in rows if r['kind'] == '服务']
     uncertain = [r for r in rows if 0.3 <= (r['waiting'] or 0) < args.min_prob]
 
+    report_path = None      # 只有真的写了 HTML 才有值；json 模式下它会进输出
+
     if args.html:
         # 名字是外部数据，转义由 render_html 负责；这里只保证目录存在。
         target = os.path.abspath(args.html)
@@ -424,11 +438,17 @@ def main():
                 'days': args.days, 'minProb': args.min_prob,
                 'generatedAt': now.strftime('%Y-%m-%d %H:%M'),
             }))
-        print('已写出：%s（不含聊天内容，可直接分享）' % target)
+        report_path = target
+        # 人在看时打这一行；机器在看时**同一件事进 JSON**（`report` 那格）—— 只把它挪到 stderr 会
+        # 让机器消费者再也拿不到"写到哪了"，那不是修，是换一种丢。
+        if not args.json:
+            print('已写出：%s（不含聊天内容，可直接分享）' % target)
 
     if args.json:
-        print(json.dumps({'debts': debts, 'excluded_service': len(noise),
-                          'uncertain': uncertain}, ensure_ascii=False, indent=2))
+        payload = {'debts': debts, 'excluded_service': len(noise), 'uncertain': uncertain}
+        if report_path:
+            payload['report'] = report_path
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
         return 0
 
     print('=' * 62)

package/scripts/semantic_search.py

@@ -12,10 +12,13 @@
   # 搜索（有索引用向量，否则关键词 fallback）
   python scripts/semantic_search.py search "有人推荐过遥感的工具吗" --top-k 10
 
+  # 只看一条知识库（默认 wiki=文章线；`all` 才两条都看）
+  python scripts/semantic_search.py search "项目排期" --line chat
+
   # 增量更新（只处理新数据）
   python scripts/semantic_search.py update
 
-输出: JSON 格式
+输出: JSON 格式（`search` 这一支是一个对象：`line` / `results` / `indexCounts` / 有时 `note`）
 """
 
 import sys, os, json, hashlib, re, argparse
@@ -59,7 +62,7 @@ except:
     pass
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import load_config, decrypt_lock, get_dashscope_key
+from _utils import load_config, decrypt_lock, get_dashscope_key, LINE_LABELS  # noqa: E402
 from jev_client import create_client
 
 OUTPUT_ROOT = 'output'
@@ -70,6 +73,39 @@ EMBEDDING_DIM = 1024  # 阿里云 text-embedding-v4
 BATCH_SIZE = 10  # 阿里云 text-embedding-v4 单次最多 10 条
 TZ = timezone(timedelta(hours=8))
 
+# 两条知识库线在**索引里**的 `type` 值。索引是一份，这是**故意的**：两条线在同一次嵌入里
+# 一起算，线靠记录上的 `type` 分（`article` / `chat`）——所以"按线检索"就是给相似度加一个
+# 掩码，不需要第二份索引、也不用重新嵌入。
+#
+# 对外（`--line`、图谱、体检）一律说 `wiki` / `chat`，索引内部叫 `article` / `chat`，
+# **翻译只在这里做一次**。散着写的话改词只会改到一半，而两条线的名字漂了不会报错。
+LINE_TYPES = {'wiki': ('article',), 'chat': ('chat',)}
+LINE_CHOICES = ('all', 'wiki', 'chat')
+
+
+def line_types(line: str):
+    """线 → 索引里允许的 `type` 集合；`all` 返回 None（不过滤）。
+
+    认不出的线**报错**，不悄悄当 all：`--line wik` 静默搜两条线的话，读的人会以为
+    自己限定住了，而那正是"分开"没生效的样子。
+    """
+    if line == 'all':
+        return None
+    if line not in LINE_TYPES:
+        raise ValueError('未知的线：%s（可选 %s）' % (line, '、'.join(LINE_CHOICES)))
+    return LINE_TYPES[line]
+
+
+def line_label(line: str) -> str:
+    return LINE_LABELS.get(line, '两条线') if line != 'all' else '两条线'
+
+
+def add_line_arg(parser):
+    """三条线共用的 `--line`（默认**文章线**：两条线分开之后，不传就是只看文章那条，
+    要合起来看显式给 `all`）。"""
+    parser.add_argument('--line', choices=list(LINE_CHOICES), default='wiki',
+                        help='只看一条知识库：wiki=文章线（默认）、chat=聊天线、all=两条都看')
+
 
 def json_output(data):
     print(json.dumps(data, ensure_ascii=False, indent=2))
@@ -348,19 +384,25 @@ def build_index(api_key: str, full: bool = False, days: int = 90, article_days:
     }
 
 
-def keyword_search(query: str, top_k: int = 10, root=None):
+def keyword_search(query: str, top_k: int = 10, root=None, line: str = 'all'):
     """Simple keyword fallback: scan articles + messages for keyword matches.
 
     `root` 只为可测而参数化（默认就是日报目录）。它原先硬编码成相对路径，
     于是这条路径只能靠 chdir 才能测，也就一直没被测过——而它正是检索不可用时
     真正跑着的那条（本机索引从未构建过）。
+
+    `line` 在这里**必须真的把两条路分开**：这一段的两个来源正好一人一条线
+    （日报文章 = 文章线、`mcp_bridge` 的聊天消息 = 聊天线）。
     """
     results = []
     keywords = query.lower().split()
+    types = line_types(line)
+    want_article = types is None or 'article' in types
+    want_chat = types is None or 'chat' in types
 
     # Scan biz-daily articles
     biz_dir = Path(root or 'output/biz-daily')
-    if biz_dir.exists():
+    if want_article and biz_dir.exists():
         for md_file in sorted(biz_dir.rglob('*.md'), reverse=True):
             # **只收真文章。** 日报目录里还躺着 <天>/README.md、<天>/行动建议.md
             # 这类**生成产物**，它们会被当成检索结果返回（实测搜到过
@@ -387,19 +429,20 @@ def keyword_search(query: str, top_k: int = 10, root=None):
                 })
 
     # Scan chat messages from mcp_bridge
-    try:
-        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-        from mcp_bridge import search_messages as _search_msg
-        msg_results = _search_msg(query, 50)
-        for r in msg_results.get('results', [])[:top_k]:
-            results.append({
-                'title': f"[{r.get('time','')}] {r.get('talker','')} > {r.get('sender','')}",
-                'source': '微信聊天',
-                'score': len(query),
-                'text': r.get('content', '')[:200],
-            })
-    except:
-        pass
+    if want_chat:
+        try:
+            sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+            from mcp_bridge import search_messages as _search_msg
+            msg_results = _search_msg(query, 50)
+            for r in msg_results.get('results', [])[:top_k]:
+                results.append({
+                    'title': f"[{r.get('time','')}] {r.get('talker','')} > {r.get('sender','')}",
+                    'source': '微信聊天',
+                    'score': len(query),
+                    'text': r.get('content', '')[:200],
+                })
+        except:
+            pass
 
     results.sort(key=lambda x: -x['score'])
     return results[:top_k]
@@ -492,8 +535,19 @@ def rerank(query, results, client=None, pool_size=RERANK_CANDIDATES):
     return ordered
 
 
-def search(query: str, api_key: str, top_k: int = 10, rerank_results: bool = True):
-    """Semantic search with keyword fallback."""
+def search(query: str, api_key: str, top_k: int = 10, rerank_results: bool = True,
+           line: str = 'all'):
+    """Semantic search with keyword fallback.
+
+    `line` 在**取候选之前**就把不属于这条线的记录挡掉（把它们的相似度压成 -inf 再
+    argsort）。反过来的做法——先取 top-k 再过滤——看着也行，但那会把条数算错：
+    `--top-k 10 --line chat` 可能只回 3 条，而"为什么只有 3 条"没有任何地方会说。
+
+    **函数这一层的默认是 `all`（不缩小范围）**，用户看到的默认（文章线）在 CLI 那一层
+    （`add_line_arg`）。这样某个调用方忘了传 `line` 时结果是"多搜了一条线"，而不是
+    "静默少搜一半"——后者在这个仓库里是最贵的那类 bug。
+    """
+    types = line_types(line)   # 认不出的线在这里就报错，不静默当 all
     # Try embedding-based search first
     if VECTORS_FILE.exists() and META_FILE.exists():
         try:
@@ -505,11 +559,21 @@ def search(query: str, api_key: str, top_k: int = 10, rerank_results: bool = Tru
                 query_vec = np.array(query_embeddings[0], dtype=np.float32)
                 query_vec = query_vec / np.linalg.norm(query_vec)
                 similarities = np.dot(vectors, query_vec)
+                if types is not None:
+                    in_scope = np.array([str(m.get('type', '')) in types for m in meta], dtype=bool)
+                    if not in_scope.any():
+                        # 一条都没有：**说出来**，别让它长成"搜了但没有结果"
+                        return []
+                    similarities = np.where(in_scope, similarities, -np.inf)
                 # 先取一个比重排池更大的候选集，重排才有可以换的空间。
                 pool_size = max(top_k, RERANK_CANDIDATES) if rerank_results else top_k
+                if types is not None:
+                    pool_size = min(pool_size, int(in_scope.sum()))
                 top_indices = np.argsort(similarities)[::-1][:pool_size]
                 results = []
                 for idx in top_indices:
+                    if not np.isfinite(similarities[idx]):
+                        continue   # 掩码挡掉的（-inf）不许混进结果
                     item = meta[idx]
                     results.append({**item, 'score': float(similarities[idx])})
                 if rerank_results:
@@ -519,13 +583,39 @@ def search(query: str, api_key: str, top_k: int = 10, rerank_results: bool = Tru
             pass
 
     # Fallback: keyword search
-    results = keyword_search(query, max(top_k, RERANK_CANDIDATES) if rerank_results else top_k)
+    results = keyword_search(query, max(top_k, RERANK_CANDIDATES) if rerank_results else top_k,
+                             line=line)
     if rerank_results:
         # 关键词打分比余弦更粗，重排在这里的收益反而更大。
         results = rerank(query, results, create_client())
     return results[:top_k]
 
 
+def line_counts() -> dict:
+    """索引里每条线各有多少条记录（`all` 也算一份总数）。
+
+    **只读 meta**（不解锁向量文件、不调任何服务、不花一分钱），所以"这一趟为什么是空的"
+    可以在返回之前就答上来：`--line chat` 空成一片时，先得能分清是"没命中"还是
+    "这条线在索引里根本没有记录"——后者要重新建索引，前者不用。
+    """
+    counts = {line: 0 for line in LINE_CHOICES}
+    if not META_FILE.exists():
+        return counts
+    try:
+        meta = json.loads(META_FILE.read_text(encoding='utf-8'))
+    except Exception:
+        return counts
+    for item in meta:
+        t = str(item.get('type', ''))
+        for line, types in LINE_TYPES.items():
+            if t in types:
+                counts[line] += 1
+    # `all` 是**索引里的总条数**，不是两条线相加：以后要是多出第三种 type，
+    # 它会被 `all` 带上、而不属于任何一条线，两条线相加就少算了。
+    counts['all'] = len(meta)
+    return counts
+
+
 # ====== Main ======
 
 def add_window_args(parser):
@@ -563,6 +653,7 @@ def main():
     p.add_argument('--top-k', type=int, default=10)
     p.add_argument('--no-rerank', action='store_true',
                    help='不调用决策模型重排，只按向量/关键词相似度返回（回退到引入重排之前）')
+    add_line_arg(p)
 
     args = parser.parse_args()
     # 手动跑时的第二道闸门（CLI 那条路已经按 1-36500 校验过）：0 天等于建一个空库，
@@ -582,8 +673,25 @@ def main():
         if not query:
             result = {"error": "missing search query"}
         else:
-            result = search(query, api_key, top_k=args.top_k,
-                            rerank_results=not args.no_rerank)
+            # **输出带上是哪条线**（`--line` 默认文章线）。少了这一层，`--line chat`
+            # 空成一片时读的人分不清"没命中"和"这条线根本没进索引"——而两者的下一步
+            # （换个词 / 重建索引）是两回事。
+            rows = search(query, api_key, top_k=args.top_k,
+                          rerank_results=not args.no_rerank, line=args.line)
+            counts = line_counts()
+            result = {
+                'success': True,
+                'line': args.line,
+                'lineLabel': line_label(args.line),
+                'results': rows,
+                'indexCounts': counts,
+            }
+            if not rows and counts['all'] == 0:
+                result['note'] = ('语义索引还没建（output/.semantic_index 不存在）——'
+                                  '先跑 weflow-cli search-index')
+            elif not rows and args.line != 'all' and counts[args.line] == 0:
+                result['note'] = ('索引里一条「%s」的记录都没有（建索引那天的窗口可能没覆盖到），'
+                                  '先看 --line all' % line_label(args.line))
     else:
         result = {"error": f"未知命令: {args.command}"}