weflow-cli 1.9.0 → 1.11.0

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/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,12 +164,22 @@ 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），但**入链计数**这里原来只认页码
@@ -160,9 +196,13 @@ def inspect(pages: list, exists, card_links=()) -> dict:
     for name in card_links:                       # 卡片 → 概念，这是主要入链
         if not (name.endswith('.md') or '/' in name) and stem_of(name) in inbound:
             inbound[stem_of(name)] += 1
-    broken, aspirational, empty = [], [], []
+    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 stem_of(name) in inbound:
                     inbound[stem_of(name)] += 1
@@ -177,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)}
 
@@ -227,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}):
@@ -393,6 +447,12 @@ def main():
     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))
@@ -415,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'
@@ -443,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' }
         }
       }
 

package/src/panel/server.ts

@@ -77,6 +77,29 @@ const STATIC_FILES: Record<string, string> = {
   // 它的左边**必须是一条笔直的切边**（内容贴着画布 x=0），贴上去才跟屏幕边严丝合缝——
   // 所以半隐时球的 `border-radius` 也要去掉（圆会把那条切边剪成弧）。
   '/panel/mascot-peek.png': 'mascot-peek.png',
+  // 被拎起来那套动作的 12 张（2026-10-02）：6 帧拎起来 + 6 帧落回去。
+  // 静止帧就是 `mascot-base.png`，不新增。同上：**漏一张，那一段动作里球会闪成空图**，
+  // 而 PANEL_ASSET_MISSING 只写在响应体里、页面上看不到。
+  '/panel/mascot-lift-up-1.png': 'mascot-lift-up-1.png',
+  '/panel/mascot-lift-up-2.png': 'mascot-lift-up-2.png',
+  '/panel/mascot-lift-up-3.png': 'mascot-lift-up-3.png',
+  '/panel/mascot-lift-up-4.png': 'mascot-lift-up-4.png',
+  '/panel/mascot-lift-up-5.png': 'mascot-lift-up-5.png',
+  '/panel/mascot-lift-up-6.png': 'mascot-lift-up-6.png',
+  '/panel/mascot-lift-down-1.png': 'mascot-lift-down-1.png',
+  '/panel/mascot-lift-down-2.png': 'mascot-lift-down-2.png',
+  '/panel/mascot-lift-down-3.png': 'mascot-lift-down-3.png',
+  '/panel/mascot-lift-down-4.png': 'mascot-lift-down-4.png',
+  '/panel/mascot-lift-down-5.png': 'mascot-lift-down-5.png',
+  '/panel/mascot-lift-down-6.png': 'mascot-lift-down-6.png',
+  // 眨眼那 2 帧（2026-10-04）：眼睛以外与静止帧逐像素相同，只把眼睛带贴回来。
+  '/panel/mascot-blink-1.png': 'mascot-blink-1.png',
+  '/panel/mascot-blink-2.png': 'mascot-blink-2.png',
+  // 挠痒痒那 4 张（2026-10-02）：鼠标在球身上晃过时循环的姿势帧。同上：漏一张就闪空图。
+  '/panel/mascot-tickle-1.png': 'mascot-tickle-1.png',
+  '/panel/mascot-tickle-2.png': 'mascot-tickle-2.png',
+  '/panel/mascot-tickle-3.png': 'mascot-tickle-3.png',
+  '/panel/mascot-tickle-4.png': 'mascot-tickle-4.png',
 }
 const CONTENT_TYPES: Record<string, string> = {
   '.html': 'text/html; charset=utf-8',
@@ -318,6 +341,16 @@ export async function startPanelServer(options: PanelServerOptions): Promise<Pan
       return
     }
 
+    if (url.pathname === '/api/memory') {
+      // **只读**，而且这份数据**不经过模型**：它是给用户在面板里审计"你记住了什么"用的，
+      // 与 `buildSystemPrompt` 里注入的那份上下文是两件事（各有各的预算与脱敏）。
+      // 桶由服务端决定（上面那个 `memoryBucket`），**不接受客户端指定** —— 否则这就是一个
+      // 能读别的记忆桶的口子。
+      if (req.method !== 'GET') { json(res, 405, { ok: false, code: 'METHOD_NOT_ALLOWED' }); return }
+      json(res, 200, { ok: true, bucket: memoryBucket, ...service.memorySnapshot(memoryBucket) })
+      return
+    }
+
     if (url.pathname === '/api/ask') {
       if (req.method !== 'POST') { json(res, 405, { ok: false, code: 'METHOD_NOT_ALLOWED' }); return }
       const contentType = String(req.headers['content-type'] ?? '')

package/src/services/assistantService.ts

@@ -955,6 +955,32 @@ export class AssistantService {
     return { used: this.dailyCount, limit: DAILY_LIMIT }
   }
 
+  /**
+   * 面板里那个"记忆"按钮要的：**它记住了什么**。只读，且**不经过模型**。
+   *
+   * 为什么不复用微信里那条 `记忆` 指令的文本：聊天那条路给的是"最近 5 条"的摘要（那是给对话用的），
+   * 面板要按时间列全、还要看得出每条是从哪句话来的，所以带上 `sourceQuote`。两边读的是同一份 memory，
+   * 只是呈现不同 —— 不各存一份。
+   *
+   * 桶（`userId`）由**调用方**决定：面板那条路传的是服务端自己那个 `memoryBucket`，不接受客户端指定。
+   */
+  memorySnapshot(userId: string): {
+    facts: { content: string; ts: number; sourceQuote: string }[]
+    summary: string
+    workingTurns: number
+    saveError: string
+  } {
+    return {
+      facts: this.memory.facts(userId).map(f => ({
+        content: f.content, ts: f.ts, sourceQuote: f.sourceQuote ?? '',
+      })),
+      summary: this.memory.summary(userId),
+      workingTurns: this.memory.workingWindow(userId).length,
+      // 落盘失败要传出去：用户问"你记住了什么"时，若上次根本没存上，那份答案就是假的
+      saveError: this.memory.lastSaveError ?? '',
+    }
+  }
+
   stop(): void {
     this.running = false
     this.svc?.stop()