weflow-cli 1.8.2 → 1.10.0

package/scripts/vault_rag.py

@@ -16,17 +16,35 @@ DEFAULT_VAULT = os.path.join(PROJECT_ROOT, 'output', 'wechat-vault')
 DEFAULT_BIZ = os.path.join(PROJECT_ROOT, 'output', 'biz-daily')
 
 sys.path.insert(0, SCRIPTS_DIR)
-from _utils import CONCEPT_DIRS, call_deepseek
+from _utils import CONCEPT_DIRS, LINE_LABELS, call_deepseek, line_for_relative_concepts
 
+LINE_CHOICES = ('all', 'wiki', 'chat')
 
-def collect_context(vault: str, biz_daily: str, question: str, top_k: int) -> list[dict]:
-    """从 Vault + biz-daily 检索相关上下文。"""
+
+def line_label(line: str) -> str:
+    return '两条线' if line == 'all' else LINE_LABELS.get(line, line)
+
+
+def collect_context(vault: str, biz_daily: str, question: str, top_k: int,
+                    line: str = 'all') -> list[dict]:
+    """从 Vault + biz-daily 检索相关上下文。
+
+    `line` 把**材料也分开**：概念页按目录分线，而用户的笔记层与日报文章都属于**文章线**
+    （`--line chat` 只给聊天线的概念页）。不这么分的话，"只看聊天知识库"仍然会从阅读笔记里
+    捞结果进来——那正是"两条线分开"要避免的事。
+
+    **函数默认 `all`（不缩小范围）**，用户看到的默认（文章线）在 CLI 那一层：忘了传 `line`
+    的调用方会多搜一条线，而不是静默少搜一半。
+    """
     results = []
     search_terms = question.lower().split()
+    want = (lambda which: line == 'all' or line == which)
 
-    # 1. 概念页（权重最高）——**两个目录都要读**：文章知识库与聊天知识库是分开的
+    # 1. 概念页（权重最高）——不传 `--line` 时两个目录都读：文章知识库与聊天知识库是分开的
     # （`_utils.CONCEPT_DIRS`），只读一个的话分出去的那一半会静默地搜不到。
     for relative in CONCEPT_DIRS:
+        if not want(line_for_relative_concepts(relative)):
+            continue
         concepts_dir = Path(vault) / relative
         if not concepts_dir.is_dir():
             continue
@@ -41,7 +59,8 @@ def collect_context(vault: str, biz_daily: str, question: str, top_k: int) -> li
 
     # 2. 阅读笔记 —— **`Notes/` 这个目录在本仓库里从来不存**（2026-09-27 实测：
     # Vault 里没有它），所以这一段一直搜的是空气。笔记实际住在 `002_Literature`。
-    for relative in ('002_Literature', '003_Ideas', '008_MOC'):
+    # 这是**用户自己的**层（文章线），所以 `--line chat` 时整段跳过。
+    for relative in (('002_Literature', '003_Ideas', '008_MOC') if want('wiki') else ()):
         notes_dir = Path(vault) / relative
         if not notes_dir.is_dir():
             continue
@@ -57,9 +76,9 @@ def collect_context(vault: str, biz_daily: str, question: str, top_k: int) -> li
             if score > 0:
                 results.append({'source': 'note', 'title': md.stem[:60], 'content': text, 'score': score})
 
-    # 3. 最新文章
-    biz_path = Path(biz_daily)
-    for date_dir in sorted(biz_path.glob('20*'), reverse=True)[:7]:  # 最近 7 天
+    # 3. 最新文章（日报 = 文章线，`--line chat` 时跳过）
+    biz_path = Path(biz_daily) if want('wiki') else None
+    for date_dir in (sorted(biz_path.glob('20*'), reverse=True)[:7] if biz_path else []):  # 最近 7 天
         for md in date_dir.rglob('*.md'):
             if md.name == 'README.md' or 'README' in md.name:
                 continue
@@ -75,7 +94,7 @@ def collect_context(vault: str, biz_daily: str, question: str, top_k: int) -> li
     return results[:top_k]
 
 
-def build_prompt(question: str, context: list[dict]) -> str:
+def build_prompt(question: str, context: list[dict], line: str = 'all') -> str:
     sources_text = ''
     for i, ctx in enumerate(context):
         label = {'concept': '概念', 'note': '笔记', 'article': '文章'}.get(ctx['source'], ctx['source'])
@@ -83,6 +102,9 @@ def build_prompt(question: str, context: list[dict]) -> str:
 
     return f'''你是个人知识助手，基于用户笔记库回答问题。
 
+**这一趟只检索了：{line_label(line)}**（另外的范围里可能有相关内容）。没有段落时按
+"**这个范围里**没有相关信息"说，别说成"知识库里没有"。
+
 知识库内容：
 {sources_text}
 
@@ -99,6 +121,8 @@ def main():
     parser.add_argument('--vault', default=DEFAULT_VAULT, help='Vault 路径')
     parser.add_argument('--biz-daily', default=DEFAULT_BIZ, help='biz-daily 路径')
     parser.add_argument('--api-key', default='', help='DeepSeek API key')
+    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()
 
@@ -113,21 +137,23 @@ def main():
         sys.exit(1)
 
     top_k = int(args.top_k)
-    context = collect_context(args.vault, args.biz_daily, question, top_k)
+    context = collect_context(args.vault, args.biz_daily, question, top_k, line=args.line)
 
     if args.json:
-        output = {'question': question, 'sources': [{'source': c['source'], 'title': c['title'], 'score': c['score']} for c in context]}
+        output = {'question': question, 'line': args.line, 'lineLabel': line_label(args.line),
+                  'sources': [{'source': c['source'], 'title': c['title'], 'score': c['score']} for c in context]}
         if context:
-            prompt = build_prompt(question, context)
+            prompt = build_prompt(question, context, args.line)
             output['answer'] = call_deepseek(prompt, api_key, max_tokens=800)
         else:
-            output['answer'] = '知识库中没有相关信息'
+            # **说清是哪个范围里没有**：`知识库中没有相关信息` 会被读成"整库都没有"
+            output['answer'] = '%s里没有相关信息' % line_label(args.line)
         print(json.dumps(output, ensure_ascii=False, indent=2))
         return
 
-    print(f'🔍 "{question}"\n')
+    print(f'🔍 "{question}"（范围：{line_label(args.line)}）\n')
     if not context:
-        print('未找到相关内容')
+        print('%s里没有相关信息（`--line all` 两条一起看）' % line_label(args.line))
         return
 
     print(f'检索到 {len(context)} 条相关内容:\n')
@@ -135,7 +161,7 @@ def main():
         icon = {'concept': '🧠', 'note': '📝', 'article': '📄'}.get(c['source'], '📎')
         print(f'  {i+1}. {icon} [{c["source"]}] {c["title"]}')
 
-    prompt = build_prompt(question, context)
+    prompt = build_prompt(question, context, args.line)
     print(f'\n{"="*50}')
     answer = call_deepseek(prompt, api_key, max_tokens=800)
     print(answer)

package/scripts/vault_search.py

@@ -13,11 +13,24 @@ from datetime import datetime, timedelta
 
 SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, SCRIPTS_DIR)
-from _utils import CONCEPT_DIRS  # noqa: E402
+from _utils import (CONCEPT_DIRS, LINE_LABELS, line_for_relative_concepts)  # noqa: E402
 PROJECT_ROOT = os.path.dirname(SCRIPTS_DIR)
 DEFAULT_VAULT = os.path.join(PROJECT_ROOT, 'output', 'wechat-vault')
 DEFAULT_BIZ = os.path.join(PROJECT_ROOT, 'output', 'biz-daily')
 
+LINE_CHOICES = ('all', 'wiki', 'chat')
+
+# 笔记层里**哪些属于聊天线**。其余笔记层是用户自己写的/读的（文章线）。
+#
+# 两个知识库分开之后，`--line` 要能真的把材料也分开，否则"只看聊天线"仍然会从用户的
+# 阅读笔记里捞结果——那不是聊天知识库里的东西。`Sources/Chat` 是 `chat_notes --vault-copy`
+# 放聊天卡的地方（`scripts/chat_notes.py`），只有它是聊天线的。
+CHAT_NOTE_DIRS = ('Sources/Chat',)
+
+
+def line_label(line: str) -> str:
+    return '两条线' if line == 'all' else LINE_LABELS.get(line, line)
+
 
 def search_text(query: str, files: list[tuple], top_k: int) -> list[dict]:
     """关键词搜索 + 简单排序。"""
@@ -43,10 +56,19 @@ def search_text(query: str, files: list[tuple], top_k: int) -> list[dict]:
     return scored[:top_k]
 
 
-def collect_files(vault: str, biz_daily: str, search_type: str, days: int) -> list[tuple]:
-    """收集可搜索文件。"""
+def collect_files(vault: str, biz_daily: str, search_type: str, days: int,
+                  line: str = 'all') -> list[tuple]:
+    """收集可搜索文件。
+
+    `line` 在**收集这一步**就过滤（而不是收完再筛）：三条来源各自属于哪条线是这里才知道的
+    —— 日报文章与用户的笔记层是文章线、`Sources/Chat` 的聊天卡是聊天线、概念页按目录分。
+
+    **函数默认 `all`（不缩小范围）**，用户看到的默认（文章线）在 CLI 那一层：忘了传 `line`
+    的调用方会多搜一条线，而不是静默少搜一半。
+    """
     files = []
     cutoff = datetime.now() - timedelta(days=days)
+    want = (lambda which: line == 'all' or line == which)
 
     def parse_fm(text):
         if not text.startswith('---'):
@@ -61,7 +83,7 @@ def collect_files(vault: str, biz_daily: str, search_type: str, days: int) -> li
                 fm[k.strip()] = v.strip().strip('"').strip("'")
         return fm
 
-    if search_type in ('all', 'article'):
+    if search_type in ('all', 'article') and want('wiki'):
         # biz-daily 文章
         biz_dir = Path(biz_daily)
         for date_dir in sorted(biz_dir.glob('20*'), reverse=True):
@@ -86,6 +108,10 @@ def collect_files(vault: str, biz_daily: str, search_type: str, days: int) -> li
         # ——命令照样返回结果，只是少了一半。
         vault_path = Path(vault)
         for relative in CONCEPT_DIRS:
+            # 概念页**按目录分线**（清单里每条线一个概念目录），而不是按库根——
+            # 测试的临时库、或 `--vault` 指到别处时，库根对不上但"这串相对路径属于哪条线"仍在
+            if not want(line_for_relative_concepts(relative)):
+                continue
             concepts_dir = vault_path / relative
             if not concepts_dir.is_dir():
                 continue
@@ -96,7 +122,7 @@ def collect_files(vault: str, biz_daily: str, search_type: str, days: int) -> li
                     fm = {}
                 files.append((md, 'concept', fm))
 
-    if search_type in ('all', 'note'):
+    if search_type in ('all', 'note') and (want('wiki') or want('chat')):
         # **`Notes/` 这个目录在本仓库里从来不存。** 2026-09-27 实测：Vault 里没有它，
         # 于是 `--type note` 一直搜的是空气——而它本该覆盖的阅读笔记有 25,676 篇，
         # 是最大的一层。笔记实际住在下面这几个目录里。
@@ -105,6 +131,9 @@ def collect_files(vault: str, biz_daily: str, search_type: str, days: int) -> li
         # `Sources/WeChat`（两万六千篇原始文章，走 biz-daily 那条路）不是一回事：
         # 这里面是一百多张**已经提炼过的**卡——会话里聊了什么、有哪些人、欠着什么。
         for sub in ('002_Literature', '001_Daily', '003_Ideas', '008_MOC', 'Sources/Chat'):
+            # 笔记层也分线：`Sources/Chat` 是聊天卡（聊天线），其余是用户自己的笔记（文章线）
+            if not want('chat' if sub in CHAT_NOTE_DIRS else 'wiki'):
+                continue
             notes_dir = vault_path / sub
             if not notes_dir.is_dir():
                 continue
@@ -127,6 +156,8 @@ def main():
     parser.add_argument('--top-k', default='10', help='返回数量')
     parser.add_argument('--type', default='all', choices=['all', 'article', 'concept', 'note'])
     parser.add_argument('--days', type=int, default=90, help='搜索天数范围')
+    parser.add_argument('--line', choices=list(LINE_CHOICES), default='wiki',
+                        help='只看一条知识库：wiki=文章线（默认）、chat=聊天线、all=两条都看')
     parser.add_argument('--vault', default=DEFAULT_VAULT, help='Vault 路径')
     parser.add_argument('--biz-daily', default=DEFAULT_BIZ, help='biz-daily 路径')
     parser.add_argument('--json', action='store_true', help='JSON 输出')
@@ -136,14 +167,19 @@ def main():
         print('请提供搜索关键词')
         sys.exit(1)
 
-    files = collect_files(args.vault, args.biz_daily, args.type, args.days)
+    files = collect_files(args.vault, args.biz_daily, args.type, args.days, line=args.line)
     results = search_text(args.query, files, int(args.top_k))
 
     if args.json:
-        print(json.dumps(results, ensure_ascii=False, indent=2))
+        # **带上范围**：`--line chat` 搜空了和"知识库里真没有"是两回事，而这一支的输出
+        # 就是 JSON 本身（CLI 直接把它打给人看），没有别的地方能写这句。
+        print(json.dumps({'line': args.line, 'lineLabel': line_label(args.line),
+                          'type': args.type, 'results': results},
+                         ensure_ascii=False, indent=2))
         return
 
-    print(f'🔍 搜索 "{args.query}" 找到 {len(results)} 条 (类型: {args.type}, {args.days}天内)\n')
+    print(f'🔍 搜索 "{args.query}" 找到 {len(results)} 条 '
+          f'(类型: {args.type}, 范围: {line_label(args.line)}, {args.days}天内)\n')
     for i, r in enumerate(results):
         icon = {'article': '📄', 'concept': '🧠', 'note': '📝'}.get(r['category'], '📎')
         num = str(i + 1).rjust(2)

package/scripts/wechat_emoticon.py

@@ -20,8 +20,14 @@ import glob
 import hashlib
 import os
 import subprocess
+import sys
 import tempfile
 
+# 手跑或被重定向时 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')
+
 try:
     from cryptography.hazmat.primitives import padding
     from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

package/scripts/wechat_voice.py

@@ -33,6 +33,15 @@ EMPTY_MARKER = '\x00empty'
 
 DEFAULT_MODEL = 'small'
 
+# **转写缓存的家**，由这个模块定义，别处一律引用它。
+#
+# 2026-10-01 踩过一次：`chat_notes` 拿自己的输出目录（`output/chat-notes`）去拼缓存路径，于是
+# 它读到的是 `output/chat-notes/.voice-cache` —— 一个刚被它自己建出来的空目录，而真正的缓存
+# 在 `output/.voice-cache`（1,788 条）。它「命中 16 条」那个数字是自洽的，只是与真缓存不相通，
+# 报告看不出来。位置只要有两份定义就会漂，所以从这里定一份。
+# 可用 `WEFLOW_VOICE_CACHE` 覆盖（测试与自定义布局用）。
+DEFAULT_CACHE_DIR = os.environ.get('WEFLOW_VOICE_CACHE') or os.path.join('output', '.voice-cache')
+
 # A Cantonese-tuned model, fetched separately (see the README note in
 # OPERATIONS.md). Worth preferring automatically when present: stock Whisper
 # answers Cantonese speech with fluent-looking Mandarin nonsense - text that

package/scripts/wiki_lint.py

@@ -25,12 +25,17 @@ import sys
 from pathlib import Path
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import CONCEPT_DIRS, normalize_concept_name, parse_frontmatter  # noqa: E402
-
-DEFAULT_PAGES_DIR = 'output/wechat-vault/Wiki/Concepts'
-VAULT_ROOT = 'output/wechat-vault'
-# 体检要看的**全部**概念页目录（Vault 相对路径那份清单在 `_utils.CONCEPT_DIRS`）。
-VAULT_CONCEPT_DIRS = tuple(str(Path(VAULT_ROOT) / d) for d in CONCEPT_DIRS)
+from _utils import (CONCEPT_DIRS, KNOWLEDGE_LINES, is_line_qualified, line_for_concept_dir,  # noqa: E402
+                    line_label, link_target_name, normalize_concept_name, parse_frontmatter)
+
+# 这里原来还有一份 `DEFAULT_PAGES_DIR = 'output/wechat-vault/Wiki/Concepts'`：**没人用**，
+# 而它是文章线概念目录的第二份拷贝 —— 谁哪天顺手用了它，聊天线就会静默地不被体检
+# （"体检通过"于是成了假话）。默认值现在只有一个来源：`--dir` 不传就是清单里的全部线。
+# 文章线的根（材料目录 `002_Literature`/`Sources/WeChat` 都在它下面）。取自清单的**第一条线**，
+# 不再自己写一遍字符串 —— 两条线各自一个根之后，这里会跟着清单变。
+VAULT_ROOT = KNOWLEDGE_LINES[0][1]
+# 体检要看的**全部**概念页目录：由清单拼出（每条线 = 根 + 线内概念目录）。
+VAULT_CONCEPT_DIRS = tuple(str(Path(root) / concepts) for _line, root, concepts in KNOWLEDGE_LINES)
 # 链接可能指向的「材料」层（与卡片目录一起参与可解析性判断）
 MATERIAL_DIRS = tuple(str(Path(VAULT_ROOT) / d) for d in
                       ('002_Literature', '001_Daily', 'Sources/Chat', 'Sources/WeChat'))
@@ -69,19 +74,40 @@ def links_by_section(body: str) -> list:
     才真的建了页。所以那一节里的"还没有页"是**扩张候选**，不是坏掉的东西；
     而 `## 来源` 里的 `[[<卡片>.md]]` 断了就是**真断了**（卡片被删或改名）。
     一视同仁地报"40 条死链"，看的人只会以为这里烂掉了。
+
+    名字一律经 `link_target_name` **归一化**（去掉 `|显示文本`、去掉线的路径前缀）：
+    跨线同名的链接写的是 `[[Chat/Concepts/DeepSeek|DeepSeek]]`，不归一化的话这些链接
+    会被当成"带路径的卡片链接"报成断链——而它们其实解析得好好的。
     """
     section, out = '', []
     for line in (body or '').split('\n'):
         if line.strip().startswith('## '):
             section = line.strip()[3:].strip()
             continue
-        for name in _LINK.findall(line):
-            name = name.strip()
+        for raw in _LINK.findall(line):
+            name = link_target_name(raw)
             if name:
                 out.append((section, name))
     return out
 
 
+def raw_links_by_section(body: str) -> list:
+    """和 `links_by_section` 一样，但**保留原始写法**：`(小节, 原文, 归一化后的名字)`。
+
+    体检要判"这条链接消歧了没有"，而那是**原文**才有的信息（归一化之后两种写法一模一样）。
+    """
+    section, out = '', []
+    for line in (body or '').split('\n'):
+        if line.strip().startswith('## '):
+            section = line.strip()[3:].strip()
+            continue
+        for raw in _LINK.findall(line):
+            raw = raw.strip()
+            if raw:
+                out.append((section, raw, link_target_name(raw)))
+    return out
+
+
 def collect_card_stems(card_dirs) -> set:
     """卡片文件名（不带 `.md`）。`## 来源` 那节的链接就是这些名字。"""
     stems = set()
@@ -138,21 +164,48 @@ def inspect(pages: list, exists, card_links=()) -> dict:
     - `aspirational`：`## 相关概念` 那节里指向"还没建页"的概念——**扩张候选，不是错误**；
     - `orphans`：连卡片都没提到过它的页面（卡片链接也算入链，否则每张页都会被误报成孤儿）；
     - `empty`：没有定义也没有要点；
-    - `duplicateTitles`：同名页；
+    - `duplicateTitles`：**同一条线内**撞了名字的页（跨线同名不算，另见下一条）；
+    - `crossLineSameName`：两条线都有这个名字（**设计使然，不是错误**）—— 合并视图里
+      就是靠它看两条线在哪重叠；
+    - `ambiguousLinks`：**指向**"两条线都有"那个名字、又**没带路径**的链接 —— 在 Obsidian
+      里点它会命中哪一张是不确定的。这一项**能修**（`wiki compile --qualify-links`），
+      所以它和上一条不同：上一条不用改，这一条要改；
     - `nearDuplicates`：`{'sameNode': [...], 'contained': [...]}` 两档，可信度差一个量级
       —— 见 `near_duplicate_titles`。
     """
     stems = {page['stem'] for page in pages}
     inbound = {stem: 0 for stem in stems}
+    # 哪条线有哪些名字：下面判"跨线同名""二义链接"都要用，所以先算一次。
+    lines_of = {}
+    for page in pages:
+        lines_of.setdefault(page['stem'], set()).add(page.get('dir', ''))
+    ambiguous_names = {name for name, where in lines_of.items() if len(where) > 1}
+    # **别名要归位到它那一页，否则那张页永远被报成孤儿。** 文件名是概念名的一个有损变换
+    # （`:` `/ ? * " < > |` 换成 `_`，再截到 60 字符），而指向它的链接用的是**原名**：
+    # `resolvable_names` 早就把别名算进"存在"了（所以断链是 0），但**入链计数**这里原来只认页码
+    # —— 名字对不上，卡片那条链接既不计入链也不报断链，那一页于是在图里是孤岛。
+    # （2026-10-01 实测：`[[Qwen3.5:9B]]` → `Qwen3.5_9B.md`，49,953 页里有 28 张。）
+    alias_to_stem = {str(alias): page['stem']
+                     for page in pages
+                     for alias in (page.get('aliases') or [])
+                     if str(alias) not in stems}
+
+    def stem_of(name: str) -> str:
+        return alias_to_stem.get(name, name)
+
     for name in card_links:                       # 卡片 → 概念，这是主要入链
-        if not (name.endswith('.md') or '/' in name) and name in inbound:
-            inbound[name] += 1
-    broken, aspirational, empty = [], [], []
+        if not (name.endswith('.md') or '/' in name) and stem_of(name) in inbound:
+            inbound[stem_of(name)] += 1
+    broken, aspirational, empty, ambiguous_links = [], [], [], []
     for page in pages:
-        for section, name in links_by_section(page['body']):
+        # 走**保留原文**的那一份：判"消歧了没有"只有原文里有信息（归一化之后两种写法一样）
+        for section, raw, name in raw_links_by_section(page['body']):
+            if name in ambiguous_names and not is_line_qualified(raw):
+                ambiguous_links.append({'page': page['stem'], 'dir': page.get('dir', ''),
+                                        'target': name})
             if exists(name):
-                if not (name.endswith('.md') or '/' in name) and name in inbound:
-                    inbound[name] += 1
+                if not (name.endswith('.md') or '/' in name) and stem_of(name) in inbound:
+                    inbound[stem_of(name)] += 1
                 continue
             entry = {'page': page['stem'], 'target': name, 'section': section}
             if any(section.startswith(prefix) for prefix in RELATED_SECTIONS):
@@ -164,10 +217,24 @@ def inspect(pages: list, exists, card_links=()) -> dict:
     orphans = sorted(stem for stem, count in inbound.items() if count == 0)
     titles = {}
     for page in pages:
-        titles.setdefault(page['title'] or page['stem'], []).append(page['stem'])
-    duplicates = {title: stems for title, stems in titles.items() if len(stems) > 1}
+        # **同名要按线分组判**。两条线各有一张同名页是设计使然（用户 2026-10-10 要求两个
+        # 概念命名空间分开），它不是"同名页"这一项要找的东西；真该报的是**同一条线里**
+        # 撞了名字 —— 那会让 `[[名字]]` 在那一棵目录里就没有确定目标。
+        titles.setdefault(page.get('dir', ''), {}).setdefault(
+            page['title'] or page['stem'], []).append(page['stem'])
+    duplicates = {}
+    for _where, by_title in sorted(titles.items()):
+        for title, stems in by_title.items():
+            if len(stems) > 1:
+                duplicates.setdefault(title, []).extend(stems)
+    # **跨线同名另立一节**：它不是错误，是"这两条线在哪些概念上有重叠"——合并视图里
+    # 唯一想看的那个数（2026-10-10 实测 36 个）。混进 `duplicateTitles` 的话，
+    # 读的人会去"修"一个设计如此的东西。
+    cross_line = sorted(ambiguous_names)
     return {'pages': len(pages), 'broken': broken, 'aspirational': aspirational,
             'orphans': orphans, 'empty': empty, 'duplicateTitles': duplicates,
+            'crossLineSameName': cross_line,
+            'ambiguousLinks': ambiguous_links,
             'degenerateFields': degenerate_fields(pages),
             'nearDuplicates': near_duplicate_titles(pages)}
 
@@ -214,7 +281,7 @@ def near_duplicate_titles(pages: list) -> dict:
     # **按目录分开比。** 两个概念目录是**两个知识库**（D-051），同一个名字两边各有一张页是
     # 设计使然、不是重复；`compile_wiki --merge-duplicates` 也是按目录跑的，永远动不了跨线的
     # 组。2026-09-28 实测：合并跑完后还剩 2 组（`AI 工具`、`GLORIA`）全是跨线的 —— 而报告
-    # 写着"这些就是合并会合并的"，是句假话。跨线同名另有 `duplicateTitles` 那一节在报。
+    # 写着"这些就是合并会合并的"，是句假话。跨线同名另有 `crossLineSameName` 那一节在报。
     named = sorted({(p.get('dir', ''), p['title'] or p['stem']) for p in pages})
     same, contained = [], []
     for where in sorted({w for w, _ in named}):
@@ -326,12 +393,16 @@ def collect(pages_dir: str, card_dirs) -> list:
                       # 判重按目录分开比（两个目录是两个知识库），所以要记住这张页住哪儿
                       'dir': str(pages_dir),
                       'topic': compile_frontmatter_topic(frontmatter),
-                      'title': str(frontmatter.get('title') or '').strip('"'),
+                      # `parse_frontmatter` 已经把外层引号拆掉了，**这里不能再剥一次**：
+                      # `strip('"')` 会连名字**自己末尾**的引号一起吃掉，`AI 长出"手脚"` 变成
+                      # `AI 长出"手脚` —— 然后它与卡片里那条链接差一个字符，永远匹配不上，
+                      # 那页就被报成孤儿（2026-10-01 实测，49,953 页里 1 张）。
+                      'title': str(frontmatter.get('title') or ''),
                       # **别名也算"指向这一页的名字"**：`--merge-duplicates` 把
                       # `GPT-5.6` 并进 `GPT 5.6` 时就是靠 aliases 让旧链接不断的，
                       # Obsidian 认它。体检不认的话，会把这些名字报成"还没建页、
                       # 建议再跑 compile" —— 而它们已经有页了。
-                      'aliases': [str(a).strip().strip('"').strip("'") for a in raw_aliases],
+                      'aliases': [str(a).strip() for a in raw_aliases],
                       'links': extract_links(body),
                       'body': body})
     return pages
@@ -364,12 +435,24 @@ def main():
     # 只查卡片目录会把这类全报成断链——实测 1,950 条，而它们在 Obsidian 里都是好的
     # （两边文件名本来就不同：卡片保留完整标题，阅读笔记截到 50 字）。
     card_stems = collect_card_stems(tuple(CARD_DIRS) + MATERIAL_DIRS)
+    resolvable = resolvable_names(pages)   # 只算一次（见下面那条注释）
     report = inspect(pages,
-                     lambda name: resolve(name, resolvable_names(pages), CARD_DIRS, card_stems),
+
+                     # **注意别把它写回 lambda 里**：闭包体是**调用时**求值的，
+                     # 写在里面等于每条链接都重建一次全部页名的集合 —— 实测文章线
+                     # （3,623 页）因此要 9 分 29 秒，聊天线（1,527 页）只要 3.2 秒。
+                     # 提出来算一次之后是同一条线的秒级。
+                     lambda name: resolve(name, resolvable, CARD_DIRS, card_stems),
                      card_links)
     report['success'] = True
     report['pagesDir'] = existing
     report['cardLinks'] = len(card_links)
+    # **这一趟体检的是哪条线**：读的人（助手的 `wiki_health`）要按线分栏报，而它原来是从
+    # 路径里找 `Chat` 这个词猜的 —— 两条线各自一个根之后聊天线很可能不再叫 `Chat`，
+    # 于是它会**把聊天线报成文章线**，且不报错。所以由这一侧给出（认不出线就给 null）。
+    lines = [line_for_concept_dir(d) for d in existing]
+    report['line'] = lines[0] if len(set(lines)) == 1 else None
+    report['lineLabel'] = line_label(report['line'])
 
     if args.json:
         print(json.dumps(report, ensure_ascii=False, indent=2))
@@ -392,9 +475,25 @@ def main():
             print('  %s（%d 字）' % (item['page'], item['chars']))
         print('  重新跑一次 wiki compile 通常就好了（那次模型返回不完整）')
     if report['duplicateTitles']:
-        print('\n同名页 %d 组：' % len(report['duplicateTitles']))
+        print('\n同名页 %d 组（**同一条线内**撞了名字）：' % len(report['duplicateTitles']))
         for title, stems in list(report['duplicateTitles'].items())[:5]:
             print('  %s ← %s' % (title, '、'.join(stems)))
+    if report.get('crossLineSameName'):
+        # 不当成问题报：两条线各留一张同名页是设计（用户要求两个命名空间分开）。
+        # 列出来是因为"哪些概念两条线都有"本身有信息量，而它**只能从这里看到**。
+        print('\n两条线都有的概念 %d 个（**设计如此，不用改**）：%s'
+              % (len(report['crossLineSameName']), '、'.join(report['crossLineSameName'][:12])))
+        print('  在 Obsidian 里这些名字的裸链接是**二义的**（官方：可能命中的不是你想要的'
+              '那一张）。要精确指着某一条线就用带路径的链接 `[[Wiki/Concepts/名字]]`')
+    if report.get('ambiguousLinks'):
+        rows = report['ambiguousLinks']
+        pages_hit = len({r['page'] for r in rows})
+        print('\n**二义的链接 %d 条**（指向"两条线都有"的名字、又没带路径；%d 张页）：'
+              % (len(rows), pages_hit))
+        for item in rows[:5]:
+            print('  %s → [[%s]]' % (item['page'], item['target']))
+        print('  修：`weflow-cli wiki compile --qualify-links`（本地重写、不调模型；'
+              '先加 `--dry-run` 看条数）')
     if report['aspirational']:
         names = sorted({item['target'] for item in report['aspirational']})
         print('\n还没建页的相关概念 %d 个（**扩张候选，不是错误**）：%s'
@@ -420,8 +519,9 @@ def main():
         for field, info in report['degenerateFields'].items():
             print('  %s: %s（%s/%s 页）' % (field, info['值'], info['页数'], info.get('总页数', report['pages'])))
         print('  多半是上游分类器把整批语料扔进了一个桶——不改分类器的话，别信这个字段')
-    if not any((report['broken'], report['orphans'], report['empty'], report['duplicateTitles'])):
-        print('\n没有需要修的问题（断链/孤儿/空页/同名）')
+    if not any((report['broken'], report['orphans'], report['empty'], report['duplicateTitles'],
+                report.get('ambiguousLinks'))):
+        print('\n没有需要修的问题（断链/孤儿/空页/同名/二义链接）')
     return 0
 
 

package/src/core/dbPathService.ts

@@ -183,7 +183,18 @@ export class DbPathService {
   /**
    * 自动检测微信数据库根目录
    */
-  async autoDetect(options: { searchDrives?: boolean; fullScan?: boolean } = {}): Promise<{ success: boolean; path?: string; error?: string }> {
+  /**
+   * 找一个可用的数据根。
+   *
+   * `hintedRoots` 是**调用方拿到的线索**，会被**最先**试（见 bin 里的 init：它把客户端
+   * 命令行自报的 `--wechat-files-path` 放进来）。为什么值得优先：下面那两条都是**按目录名猜**
+   * （常见路径 / 全盘扫 `xwechat_files`），而这一条是**客户端自己说的** —— 也是唯一一条
+   * 不受"目录被建在别处、名字还不一样"影响的来源。
+   *
+   * 线索**同样要过 `resolveDataRoot` 验证**（找到账户目录才算数）：拿到一个路径 ≠ 它能用。
+   */
+  async autoDetect(options: { searchDrives?: boolean; fullScan?: boolean; hintedRoots?: string[] } = {}):
+    Promise<{ success: boolean; path?: string; error?: string; source?: 'client' | 'known' | 'scan' }> {
     try {
       const possiblePaths: string[] = []
       const home = homedir()
@@ -227,10 +238,17 @@ export class DbPathService {
         }
       }
 
+      // 1) **客户端自己说的**（命令行里的 `--wechat-files-path`）。取不到就走下面的老路。
+      for (const hint of options.hintedRoots ?? []) {
+        const dataRoot = this.resolveDataRoot(hint)
+        if (dataRoot) return { success: true, path: dataRoot, source: 'client' }
+      }
+
+      // 2) 常见路径（含按目录名在几个已知位置里找）
       for (const path of possiblePaths) {
         const dataRoot = this.resolveDataRoot(path)
         if (dataRoot) {
-          return { success: true, path: dataRoot }
+          return { success: true, path: dataRoot, source: 'known' }
         }
       }
 
@@ -238,7 +256,7 @@ export class DbPathService {
         for (const volumeRoot of this.getVolumeRoots()) {
           for (const dataRootPath of this.findKnownDataRoots(volumeRoot, 12)) {
             const dataRoot = this.resolveDataRoot(dataRootPath)
-            if (dataRoot) return { success: true, path: dataRoot }
+            if (dataRoot) return { success: true, path: dataRoot, source: 'scan' }
           }
         }
       }
@@ -246,7 +264,7 @@ export class DbPathService {
       if (options.fullScan) {
         for (const volumeRoot of this.getVolumeRoots()) {
           const accountPath = this.findAccountDescendant(volumeRoot, 32)
-          if (accountPath) return { success: true, path: dirname(accountPath) }
+          if (accountPath) return { success: true, path: dirname(accountPath), source: 'scan' }
         }
       }