weflow-cli 1.9.0 → 1.11.0

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))
@@ -146,50 +182,76 @@ def get_name_map(contact_db, contact_key, contact_salt):
     return name_map
 
 
-def collect_chat_messages(conn, name_map, days=90):
-    """Collect chat messages for indexing."""
-    c = conn.cursor()
+def collect_chat_messages(conns, name_map, days=90, per_talker=500):
+    """Collect chat messages for indexing. `conns` 是**分片连接列表**，不是单个连接。
+
+    微信 4.x 的消息按分片存，而且**每片要自己派生的钥匙**才打得开（`nt_decrypt.
+    derive_database_key`）。本机实测四片：`message_3.db` 里是近两天的消息，而配置指向的
+    `message_0.db` 最新一条是 44 天前的。这里原来只开 `ntDbPath` 一个文件、还用裸的全局钥匙 ——
+    于是索引的聊天半边会**静默地收进旧数据**（症状与 issue #10 的"只读到半个月前"同形）。
+    索引是要花钱嵌的，收错数据比报错更贵。
+
+    三处随之改动，各有理由：
+      · 会话清单从所有分片取并集 —— 新会话的表可能只存在于新分片里；
+      · 不再 `[:100]` 截断：本机 122 个会话，而且那 100 个是**无排序取前 100**（等于随机）；
+      · id 里带 `rowid`：实测一张表里 12,106 条消息只落在 12,058 个不同秒上，只按 `talker:ts`
+        去重会静默顶掉同秒的多条。
+    """
     now = datetime.now(TZ)
     start_ts = int((now - timedelta(days=days)).timestamp())
 
-    try:
-        c.execute("SELECT user_name FROM Name2Id WHERE is_session = 1")
-        sessions = [r[0] for r in c.fetchall()]
-    except:
-        c.execute("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'Msg_%'")
-        sessions = [r[0] for r in c.fetchall()]
-
-    items = []
-    for talker in sessions[:100]:  # Limit to avoid too many
-        tbl = f"Msg_{hashlib.md5(talker.encode()).hexdigest()}"
+    sessions = []
+    for conn in conns:
+        c = conn.cursor()
         try:
-            c.execute(f'SELECT COUNT(*) FROM sqlite_master WHERE name="{tbl}"')
-            if c.fetchone()[0] == 0:
+            c.execute("SELECT user_name FROM Name2Id WHERE is_session = 1")
+            rows = [r[0] for r in c.fetchall()]
+        except Exception:
+            try:
+                c.execute("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'Msg_%'")
+                rows = [r[0] for r in c.fetchall()]
+            except Exception:
+                rows = []
+        for name in rows:
+            if name not in sessions:
+                sessions.append(name)
+
+    items, seen = [], set()
+    for talker in sessions:
+        tbl = f"Msg_{hashlib.md5(talker.encode()).hexdigest()}"
+        for conn in conns:
+            c = conn.cursor()
+            try:
+                c.execute('SELECT COUNT(*) FROM sqlite_master WHERE name=?', (tbl,))
+                if c.fetchone()[0] == 0:
+                    continue
+                c.execute(f'''
+                    SELECT rowid, create_time, real_sender_id, message_content
+                    FROM "{tbl}"
+                    WHERE create_time >= ?
+                    ORDER BY create_time DESC
+                    LIMIT ?
+                ''', (start_ts, per_talker))
+                rows = c.fetchall()
+            except Exception:
                 continue
-
-            c.execute(f'''
-                SELECT create_time, real_sender_id, message_content
-                FROM "{tbl}"
-                WHERE create_time >= ?
-                ORDER BY create_time DESC
-                LIMIT 500
-            ''', (start_ts,))
-
-            for ts, sender, content in c.fetchall():
+            for rid, ts, sender, content in rows:
                 if not content or not isinstance(content, str) or len(content) < 10:
                     continue
+                item_id = f"chat:{talker}:{ts}:{rid}"
+                if item_id in seen:
+                    continue
+                seen.add(item_id)
                 sender_name = name_map.get(sender, sender) if sender else name_map.get(talker, talker)
                 dt = datetime.fromtimestamp(ts, tz=TZ)
                 items.append({
-                    "id": f"chat:{talker}:{ts}",
+                    "id": item_id,
                     "type": "chat",
                     "talker": name_map.get(talker, talker),
                     "sender": sender_name,
                     "time": dt.strftime('%Y-%m-%d %H:%M'),
                     "text": content[:500],
                 })
-        except:
-            pass
 
     return items
 
@@ -289,11 +351,25 @@ def build_index(api_key: str, full: bool = False, days: int = 90, article_days:
 
     # Collect items
     items = []
+    shards_failed = []
     try:
-        conn = open_db(nt_db, nt_key, nt_salt)
-        chat_items = collect_chat_messages(conn, name_map, days=days)
-        items.extend(chat_items)
-        conn.close()
+        import nt_decrypt  # 懒加载：纯逻辑路径（关键词/重排/测试）不该被它拖住
+        passphrase = decrypt_lock(config.get('favPassphrase') or config.get('decryptKey') or '')
+        pairs, failures = nt_decrypt.connect_message_shards_detailed(
+            nt_db, nt_key, nt_salt, passphrase)
+        shards_failed = [f['name'] for f in failures]
+        if shards_failed:
+            print(f"[WARN] {len(shards_failed)} 个分片读不了: {', '.join(shards_failed)}",
+                  file=sys.stderr)
+        try:
+            chat_items = collect_chat_messages([c for _p, c in pairs], name_map, days=days)
+            items.extend(chat_items)
+        finally:
+            for _p, c in pairs:
+                try:
+                    c.close()
+                except Exception:
+                    pass
     except Exception as e:
         print(f"[WARN] 聊天消息收集失败: {e}", file=sys.stderr)
 
@@ -306,7 +382,8 @@ def build_index(api_key: str, full: bool = False, days: int = 90, article_days:
 
     if not new_items:
         return {"status": "up_to_date", "total": len(items),
-                "chatDays": days, "articleDays": article_days}
+                "chatDays": days, "articleDays": article_days,
+                "shardsFailed": shards_failed}
 
     # Generate embeddings
     print("生成 embeddings...", file=sys.stderr)
@@ -345,22 +422,31 @@ def build_index(api_key: str, full: bool = False, days: int = 90, article_days:
         "new": len(new_items),
         "chatDays": days,
         "articleDays": article_days,
+        # 分片读不全时**要报出来**：`shardsFailed` 是"全读了"与"读了能读到的"之差，
+        # 正是覆盖度报告存在的理由（nt_decrypt.connect_message_shards_detailed 的原话）。
+        "shardsFailed": shards_failed,
     }
 
 
-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 +473,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]
@@ -458,7 +545,9 @@ def rerank(query, results, client=None, pool_size=RERANK_CANDIDATES):
     try:
         answers, _usage = client.decide(state, questions)
     except Exception as error:
-        print('  [WARN] 重排失败（%s），保持原检索顺序：%s' % (type(error).__name__, error))
+        # `file=sys.stderr`：`--json` 时 stdout 是机器在解析的那一份（同文件其它 WARN 早就这样）
+        print('  [WARN] 重排失败（%s），保持原检索顺序：%s' % (type(error).__name__, error),
+              file=sys.stderr)
         return results
 
     scored = []
@@ -471,7 +560,7 @@ def rerank(query, results, client=None, pool_size=RERANK_CANDIDATES):
         scored.append((value, i, item))
 
     if all(value is None for value, _i, _item in scored):
-        print('  [WARN] 重排没有返回任何可用分数，保持原检索顺序')
+        print('  [WARN] 重排没有返回任何可用分数，保持原检索顺序', file=sys.stderr)
         return results
 
     # 没拿到分数的按原序垫在最后，而不是当成 0 分——"未知"和"不相关"不是一回事。
@@ -480,7 +569,7 @@ def rerank(query, results, client=None, pool_size=RERANK_CANDIDATES):
     top = scored[0]
     if best is not None and best != '候选%d' % top[1]:
         print('  [WARN] 重排自检不一致：逐条打分最高的是候选%d，单选却答 %s'
-              % (top[1], best))
+              % (top[1], best), file=sys.stderr)
 
     ordered = []
     for value, i, item in scored:
@@ -492,8 +581,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 +605,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 +629,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 +699,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 +719,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}"}
 

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)