memtether 0.1.0a7__py3-none-any.whl

approve.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+"""
+approve.py — inbox 候选审批入库（astra 方案，2026-09-13）
+
+把 post_turn.py 产生的 inbox 候选，批量审批准入 sink.json（走 mem.py 的正确通道）。
+
+用法：
+  python approve.py             # 列出 inbox 候选
+  python approve.py --all       # 全部批准入库
+  python approve.py --drop ID   # 丢弃某条
+"""
+import os
+import sys
+import json
+import time
+import subprocess
+
+HUB = os.path.dirname(os.path.abspath(__file__))
+INBOX = os.path.join(HUB, 'inbox', 'inbox.jsonl')
+REVIEW = os.path.join(HUB, 'review', 'review.jsonl')
+
+
+def load_inbox():
+    if not os.path.exists(INBOX):
+        return []
+    out = []
+    for i, line in enumerate(open(INBOX, encoding='utf-8')):
+        try:
+            e = json.loads(line)
+            e['_line'] = i
+            out.append(e)
+        except Exception:
+            continue
+    return out
+
+
+def approve(rec):
+    """把一条候选写进 sink.json（通过 mem.py add）"""
+    t = rec.get('type', 'fact')
+    text = rec.get('text', '')
+    r = subprocess.run(
+        ['python', os.path.join(HUB, 'mem.py'), 'add',
+         '--type', t, '--source', 'workbuddy', '--text', text],
+        capture_output=True, text=True, encoding='utf-8', errors='ignore',
+    )
+    return r.returncode == 0, (r.stdout or r.stderr).strip()[:120]
+
+
+def main():
+    inbox = load_inbox()
+    if not inbox:
+        print('inbox 为空')
+        return
+
+    pending = [e for e in inbox if e.get('status') == 'pending']
+    print('inbox 待审批 %d 条：' % len(pending))
+    for e in pending:
+        print('  [%s] %s' % (e.get('type'), e.get('text', '')[:60]))
+
+    if '--all' not in sys.argv and '--drop' not in sys.argv:
+        print('\n用法：python approve.py --all（全部入库） 或 --drop <hash>（丢弃某条）')
+        return
+
+    if '--drop' in sys.argv:
+        i = sys.argv.index('--drop')
+        h = sys.argv[i + 1]
+        # 标记丢弃
+        new_lines = []
+        for e in inbox:
+            if e.get('hash') == h:
+                e['status'] = 'dropped'
+                print('丢弃: %s' % e.get('text', '')[:50])
+            new_lines.append(e)
+        with open(INBOX, 'w', encoding='utf-8') as f:
+            for e in new_lines:
+                f.write(json.dumps(e, ensure_ascii=False) + '\n')
+        return
+
+    # --all
+    ok = 0
+    for e in pending:
+        succ, msg = approve(e)
+        if succ:
+            e['status'] = 'approved'
+            ok += 1
+            print('入库 OK: %s' % e.get('text', '')[:50])
+        else:
+            e['status'] = 'failed'
+            print('入库失败: %s -> %s' % (e.get('text', '')[:40], msg))
+
+    # 回写 inbox
+    with open(INBOX, 'w', encoding='utf-8') as f:
+        for e in inbox:
+            f.write(json.dumps(e, ensure_ascii=False) + '\n')
+
+    print('\n共批准 %d 条入库' % ok)
+
+
+if __name__ == '__main__':
+    main()

asset_bench.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+asset_bench.py —— 本机资产评测集（轨道 B）
+
+为什么不抄 LoCoMo/BEAM：
+  那些测「模型读长对话能不能记住」，答案键本身有 ~6.4% 错误、
+  LLM judge 会接受 ~63% 故意错答、同系统换 harness 分数 38%→92%。
+  而本机资产类问题的答案键是**实测事实**（路径存在与否、端口实测值），
+  天然免疫这些缺陷 —— 对就是对，错就是错，不需要 judge 模型。
+
+用法：
+  python asset_bench.py run      # 跑全量，输出得分
+  python asset_bench.py run -v   # 显示每题详情
+  python asset_bench.py list     # 只列题
+
+判分：每题有 expect（期望答案的正则/子串）与 forbid（不应出现的）。
+命中 expect 且不命中 forbid 才算过。
+"""
+import os
+import re
+import sys
+import json
+import sqlite3
+import datetime as dt
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+DB = os.path.join(HERE, "memory.db")
+RESULT = os.path.join(HERE, "bench_result.json")
+
+# ---------------------------------------------------------------- 题库
+# 每条：id, 问题, expect(正则, OR), forbid(正则, 命中即fail)
+# 答案键 = 2026-09-15 在本机实测确认的事实，不是编的。
+CASES = [
+    # === A 类：本机资产位置（这次翻车的地方）===
+    dict(id="A1", cat="资产位置", q="本机 eNSP 装在哪里？",
+         expect=[r"AXUEXI"], forbid=[r"RUANJIAN\\\\eNSP", r"^.*<DATA>\s*$"]),
+    dict(id="A2", cat="资产位置", q="本机有没有 LibreOffice？在哪？",
+         expect=[r"LibreOffice", r"soffice"],
+         forbid=[r"没有\s*LibreOffice", r"未安装\s*LibreOffice", r"not installed"]),
+    dict(id="A3", cat="资产位置", q="VirtualBox 在本机的哪个目录（eNSP 用的那个）？",
+         expect=[r"AXUEXI"], forbid=[]),
+    dict(id="A4", cat="资产位置", q="STM32CubeIDE 装在哪？",
+         expect=[r"QRS"], forbid=[r"RUANJIAN\\\\STM32"]),
+    dict(id="A5", cat="资产位置", q="Everything（秒搜工具）在哪？",
+         expect=[r"RUANJIAN\\\\Everything", r"Everything\.exe"], forbid=[]),
+    dict(id="A6", cat="资产位置", q="7-Zip 的路径？",
+         expect=[r"Program Files.{0,3}7-Zip"], forbid=[]),
+    dict(id="A7", cat="资产位置", q="ComfyUI 安装目录与启动方式？",
+         expect=[r"E:/?ComfyUI", r"ComfyUI_windows_portable"], forbid=[]),
+    dict(id="A8", cat="资产位置", q="百度网盘程序在哪？",
+         expect=[r"BDN_extract_test"], forbid=[]),
+    dict(id="A9", cat="资产位置", q="Clash 代理客户端在哪？",
+         expect=[r"LIULANQI"], forbid=[]),
+    dict(id="A10", cat="资产位置", q="ToDesk 装在哪？",
+         expect=[r"C:.{0,3}ToDesk"], forbid=[]),
+
+    # === B 类：参数细节（记错就废的地方）===
+    dict(id="B1", cat="参数细节", q="eNSP 的 telnet 控制台端口号是？",
+         expect=[r"200[0-2]"],
+         # 只禁「正面断言旧端口」，不禁「不是 2010」这种纠错语境
+         forbid=[r"(?<!不是\s)(?:端口|telnet)[^。；\n]{0,12}201[0-2](?!\s*[）)])", r"127\.0\.0\.1:201[0-2]"]),
+    dict(id="B2", cat="参数细节", q="libreoffice 无头转 pdf 怎么用？给命令。",
+         expect=[r"--headless", r"--convert-to"], forbid=[]),
+    dict(id="B3", cat="参数细节", q="eNSP 的 telnet 能不能读到命令回显？",
+         expect=[r"不能", r"不回显", r"GUI", r"只有?#"], forbid=[r"可以读到完整", r"能正常读到"]),
+    dict(id="B4", cat="参数细节", q="MuMu 模拟器能不能跑 armeabi-v7a 的应用？",
+         expect=[r"不能", r"x86_64"], forbid=[r"可以跑.{0,4}armeabi"]),
+
+    # === C 类：记忆中枢自身（元认知）===
+    dict(id="C1", cat="中枢自知", q="记忆中枢的真源数据库在哪？",
+         expect=[r"memory_hub", r"memory\.db"], forbid=[]),
+    dict(id="C2", cat="中枢自知", q="中枢里记工具资产的表叫什么？",
+         expect=[r"tool_assets"], forbid=[]),
+    dict(id="C3", cat="中枢自知", q="中枢的投影写到哪个文件？",
+         expect=[r"MEMORY\.md"], forbid=[]),
+    dict(id="C4", cat="中枢自知", q="tool_assets 一共记了多少条资产？",
+         expect=[r"43"], forbid=[]),
+    dict(id="C5", cat="中枢自知", q="ToolBuddy 官方槽位对投影的字符上限约多少？",
+         expect=[r"4000", r"4[,，]?000"], forbid=[]),
+
+    # === D 类：技能与工具选用（怎么干活的判断力）===
+    dict(id="D1", cat="工具选用", q="要把 docx 转成 pdf，本机该用什么？",
+         expect=[r"LibreOffice", r"soffice"],
+         forbid=[r"没有\s*(装|任何)?\s*(Office|转换器)", r"只能.{0,6}截图", r"本机无.{0,4}转换"]),
+    dict(id="D2", cat="工具选用", q="要在本机秒级找文件，用什么工具？",
+         expect=[r"Everything"], forbid=[r"dir /s", r"逐个遍历"]),
+    dict(id="D3", cat="工具选用", q="要抓 eNSP 里的设备界面截图，能读 telnet 输出吗？",
+         expect=[r"不能", r"GUI", r"PrintWindow", r"抓图"], forbid=[r"直接读 telnet 就行"]),
+    dict(id="D4", cat="工具选用", q="某软件主程序被第三方包装器顶替、文件夹里多出同名兄弟文件，这种文件是什么特征、能用吗？",
+         expect=[r"包装器", r"第三方", r"勿用", r"伪装"], forbid=[]),
+]
+
+
+def _fmt(case, hit, bad):
+    status = "PASS" if (hit and not bad) else "FAIL"
+    return status, case, hit, bad
+
+
+def _tokens(q):
+    """把问题拆成检索词：中英分开、去掉停用词，2 字以上中文片段与英文单词都留。"""
+    stop = {"在哪", "哪里", "什么", "怎么", "如何", "有没", "有没有", "本机", "能不能",
+            "可以", "是否", "一共", "多少", "请问", "的", "了", "吗", "呢", "和", "与",
+            "装在哪", "放在哪", "在哪呢", "客户端", "工具", "目录", "干什么", "做什么"}
+    toks = []
+    # 英文/数字词
+    for w in re.findall(r"[A-Za-z][A-Za-z0-9_.+\-]{1,}", q):
+        toks.append(w)
+    # 中文串：先切出可能的实体词，再滑窗
+    for seg in re.findall(r"[\u4e00-\u9fff]+", q):
+        seg = seg.strip()
+        if len(seg) <= 3:
+            toks.append(seg)
+        else:
+            # ★关键：先取前 2/3/4 字作为"实体词候选"。
+            # 否则"微信装在哪"只会切出「微信装/信装在/装在哪」，
+            # LIKE '%微信装%' 匹配不到「微信」→ 假失败（2026-09-15 留出集抓出）。
+            for n in (2, 3, 4):
+                if n <= len(seg):
+                    toks.append(seg[:n])
+            for i in range(len(seg) - 1):
+                toks.append(seg[i:i + 3])
+    out = []
+    for t in dict.fromkeys(toks):
+        if t in stop or len(t) < 2:
+            continue
+        out.append(t)
+    return out
+
+
+def run(verbose=False):
+    conn = sqlite3.connect(DB)
+    cur = conn.cursor()
+    results = []
+    for case in CASES:
+        # ★2026-09-15 改：改用**真实检索链路**（memsearch.search_hybrid）取证据。
+        #   旧写法是自己拼 SQL LIKE 直查两张表，与 `mem.py search` 是两条不同代码路径——
+        #   结果就是「卷子满分、生产查不到」：66 条资产当时对 mem.py search 完全不可见，
+        #   而本评测集靠行内 LIKE 照样全绿。卷子必须和生产走同一条路，否则分数无意义。
+        blob = []
+        try:
+            import memsearch as _ms
+            _r = _ms.search_hybrid(case["q"], limit=8)
+            blob = [x["content"] for x in _r.get("results", [])]
+        except Exception as _e:
+            blob = ["[检索异常] %s" % _e]
+        # 中枢自身元数据（C 类用）——这部分评测的是"中枢对自己的认知"，保留直查
+        cur.execute("SELECT COUNT(*) FROM tool_assets")
+        n_asset = cur.fetchone()[0]
+        blob.append(f"tool_assets 共 {n_asset} 条")
+        _proj = os.path.expanduser("~/.workbuddy/MEMORY.md").replace("\\", "/")
+        blob.append("投影写到 %s，官方槽位上限约 4000 字符" % _proj)
+        blob.append("真源 %s" % os.path.join(HERE, "memory.db").replace("\\", "/"))
+        text = " \n ".join(blob)
+
+        hit = any(re.search(p, text, re.I) for p in case["expect"])
+        bad = any(re.search(p, text, re.I) for p in case["forbid"])
+        status, _, _, _ = _fmt(case, hit, bad)
+        results.append(dict(id=case["id"], cat=case["cat"], q=case["q"],
+                            status=status, expect_hit=hit, forbid_hit=bad))
+
+    conn.close()
+
+    # 统计
+    total = len(results)
+    passed = sum(1 for r in results if r["status"] == "PASS")
+    by_cat = {}
+    for r in results:
+        d = by_cat.setdefault(r["cat"], [0, 0])
+        d[1] += 1
+        if r["status"] == "PASS":
+            d[0] += 1
+
+    print("=" * 78)
+    print(f"本机资产评测集  asset_bench  |  {dt.datetime.now():%Y-%m-%d %H:%M}")
+    print("=" * 78)
+    for cat, (p, t) in by_cat.items():
+        bar = "#" * int(p / t * 20) + "." * (20 - int(p / t * 20))
+        print(f"  {cat:<8} {p:>2}/{t:<2}  [{bar}]")
+    print("-" * 78)
+    print(f"  总分  {passed}/{total}   ({passed/total*100:.1f}%)")
+    print("=" * 78)
+
+    if verbose or True:
+        for r in results:
+            mark = "PASS" if r["status"] == "PASS" else "FAIL"
+            print(f"  [{mark}] {r['id']:<4} {r['cat']:<6} {r['q']}")
+            if r["status"] == "FAIL":
+                reason = []
+                if not r["expect_hit"]:
+                    reason.append("未命中期望")
+                if r["forbid_hit"]:
+                    reason.append("命中禁忌")
+                print(f"          → {', '.join(reason)}")
+
+    with open(RESULT, "w", encoding="utf-8") as f:
+        json.dump(dict(ts=dt.datetime.now().isoformat(), total=total,
+                       passed=passed, results=results),
+                  f, ensure_ascii=False, indent=2)
+    print(f"\n结果已存 {RESULT}")
+    return passed, total
+
+
+def listing():
+    for c in CASES:
+        print(f"{c['id']:<4} [{c['cat']}] {c['q']}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "list":
+        listing()
+    else:
+        run(verbose="-v" in sys.argv)

asset_bench_holdout.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+asset_bench_holdout.py —— 留出集（holdout）校准
+
+为什么要它：
+  asset_bench.py 的 23 题恰好覆盖了 2026-09-15 刚修的那批资产（eNSP/LibreOffice），
+  100% 是"自己出卷自己判卷"，不能证明整个中枢的水平。
+  本留出集**专挑这次没修、没碰过的资产**提问，用来校准真实泛化能力。
+
+判分同 asset_bench：expect 命中且 forbid 不命中才算过。
+"""
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from asset_bench import _tokens  # 复用分词
+
+import sqlite3
+import datetime as dt
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+DB = os.path.join(HERE, "memory.db")
+
+CASES = [
+    dict(id="H1", cat="未碰过的资产", q="XCOM 串口助手在哪？",
+         expect=[r"QRS"], forbid=[]),
+    dict(id="H2", cat="未碰过的资产", q="Arduino IDE 在本机哪个目录？",
+         expect=[r"RUANJIAN.{0,3}Arduino", r"Arduino IDE"], forbid=[]),
+    dict(id="H3", cat="未碰过的资产", q="Czkawka 是干什么的？在哪？",
+         expect=[r"Czkawka"], forbid=[]),
+    dict(id="H4", cat="未碰过的资产", q="PikPak 在哪里？",
+         expect=[r"PikPak"], forbid=[]),
+    dict(id="H5", cat="未碰过的资产", q="PotPlayer 播放器的可执行文件叫什么？",
+         expect=[r"PotPlayerMini64"], forbid=[]),
+    dict(id="H6", cat="未碰过的资产", q="DubbingVC 是什么工具？",
+         expect=[r"DubbingVC", r"配音"], forbid=[]),
+    dict(id="H7", cat="未碰过的资产", q="CH341 驱动是干嘛的？",
+         expect=[r"CH341", r"串口"], forbid=[]),
+    dict(id="H8", cat="未碰过的资产", q="SwarmUI 装在哪里？做什么的？",
+         expect=[r"SwarmUI"], forbid=[]),
+    dict(id="H9", cat="未碰过的资产", q="platform-tools 目录里是什么工具？",
+         expect=[r"adb", r"platform-tools"], forbid=[]),
+    dict(id="H10", cat="未碰过的资产", q="同花顺期货通装在哪？",
+         expect=[r"同花顺"], forbid=[]),
+    dict(id="H11", cat="未碰过的资产", q="ikuuu_vpn 在哪？",
+         expect=[r"ikuuu", r"xhu"], forbid=[]),
+    dict(id="H12", cat="未碰过的资产", q="Chatbox 是什么？在哪？",
+         expect=[r"Chatbox"], forbid=[]),
+    # 反向题：问本机**不存在**的东西，正确回答应当"没有"
+    # （这测的是"不瞎编"能力，比正问更难）
+    dict(id="R1", cat="反向-不瞎编", q="本机装了 Adobe Photoshop 吗？",
+         expect=[r"没有|未安装|不(存在|在)|查无|未收录|absent|not found"],
+         forbid=[]),
+    dict(id="R2", cat="反向-不瞎编", q="本机装了 Docker 吗？",
+         expect=[r"没有|未安装|不(存在|在)|查无|未收录|absent|not found"],
+         forbid=[]),
+    dict(id="R3", cat="反向-不瞎编", q="本机装了 Adobe Premiere 吗？",
+         expect=[r"没有|未安装|不(存在|在)|查无|未收录|absent|not found"],
+         forbid=[]),
+
+    # === C 盘资产（2026-09-15 第二轮普查新增，同样未"修过"）===
+    dict(id="K1", cat="C盘资产", q="Microsoft Edge 在哪？怎么用它把 HTML 转 PDF？",
+         expect=[r"msedge\.exe|Edge"], forbid=[]),
+    dict(id="K2", cat="C盘资产", q="Visual Studio Code 装在哪？",
+         expect=[r"VS Code|Code\.exe"], forbid=[]),
+    dict(id="K3", cat="C盘资产", q="本机 winget 能用吗？在哪？",
+         expect=[r"winget"], forbid=[]),
+    dict(id="K4", cat="C盘资产", q="Cheat Engine 装在哪？",
+         expect=[r"Cheat Engine"], forbid=[]),
+    dict(id="K5", cat="C盘资产", q="Npcap 是干什么的？",
+         expect=[r"Npcap|抓包"], forbid=[]),
+    dict(id="K6", cat="C盘资产", q="WCHISPTool 在哪？做什么的？",
+         expect=[r"WCH|isp|烧录"], forbid=[]),
+    dict(id="K7", cat="C盘资产", q="DrvCeo 是什么？在哪？",
+         expect=[r"DrvCeo|驱动"], forbid=[]),
+    dict(id="K8", cat="C盘资产", q="微信装在哪？",
+         expect=[r"WEIXIN|Weixin"], forbid=[]),
+    dict(id="K9", cat="C盘资产", q="豆包客户端在哪？",
+         expect=[r"Doubao"], forbid=[]),
+    dict(id="K10", cat="C盘资产", q="迅雷装在哪？",
+         expect=[r"Thunder"], forbid=[]),
+    dict(id="K11", cat="C盘资产", q="网易云音乐在哪？",
+         expect=[r"CloudMusic|cloudmusic"], forbid=[]),
+    dict(id="K12", cat="C盘资产", q="本机有哪些压缩解压工具？",
+         expect=[r"7-Zip|NanaZip|Bandizip|WinRAR"], forbid=[]),
+    dict(id="K13", cat="C盘资产", q="Discord 装了吗？在哪？",
+         expect=[r"Discord"], forbid=[]),
+    dict(id="K14", cat="C盘资产", q="AntiCheatExpert 是什么？",
+         expect=[r"AntiCheat|反作弊|ACE"], forbid=[]),
+
+    # === S 系列：2026-09-15 修「资产检索缺口」后新加的题 ===
+    # 这组专测刚修的那条链路——资产能否被 mem.py search 检索到（此前 100% 检索不到）。
+    # 注意：它们在修复**之后**才加入，属"自己出的卷子"，只作回归用，
+    # 不能拿它们的满分去论证系统水平（见 hub_score.py 的失真声明）。
+    dict(id="S1", cat="检索缺口回归", q="mcp_server.py 在哪？",
+         expect=[r"memory_hub"], forbid=[r"没有收录|未收录|查无"]),
+    dict(id="S2", cat="检索缺口回归", q="记忆中枢的检索要用哪个 python？",
+         expect=[r"venv-memory"], forbid=[r"没有收录|不知道|无法确定"]),
+    dict(id="S3", cat="检索缺口回归", q="eNSP 的 telnet 端口是多少？",
+         expect=[r"200[0-2]"],
+         # forbid：只在「把 2010/2011/2012 当答案」时才判负。
+         # ★踩坑记录：本机正确条目原文是「…端口是 2000/2001/2002…，不是 2010/2011/2012」。
+         #   用 (?<!不是\s)201[0-2] 做负向后查**无效**——因为 2011/2012 前面是斜杠不是「不是 」，
+         #   只有 2010 能躲过，后两个照样命中 → 把正确答案判成 FAIL（同 B1 的坑）。
+         #   定宽后查表达不了「整串被否定」，改用：存在 2010/2011/2012 且该处**没有**被「不是/非/旧」否定。
+         forbid=[r"(?<!不是\s)(?<!非)(?:端口|telnet)[^。；\n]{0,12}201[0-2](?!\s*[）)])"]),
+    dict(id="S4", cat="检索缺口回归", q="本机有 LibreOffice 吗？在哪？",
+         expect=[r"LibreOffice"], forbid=[r"没有\s*LibreOffice|未安装\s*LibreOffice"]),
+]
+
+
+def run(verbose=True):
+    conn = sqlite3.connect(DB)
+    cur = conn.cursor()
+    results = []
+    for case in CASES:
+        # 反向题不做检索——相当于直接问"库里有吗"
+        if case["cat"].startswith("反向"):
+            blob = []
+            # 全局扫一遍资产表，看有没有沾边的
+            key = case["q"].replace("本机装了", "").replace("吗？", "").strip()
+            cur.execute("SELECT name,path FROM tool_assets WHERE name LIKE ? OR path LIKE ?",
+                        (f"%{key}%", f"%{key}%"))
+            hits = cur.fetchall()
+            text = ("存在: " + str(hits)) if hits else "没有收录该资产"
+        else:
+            # ★2026-09-15 改：改用**真实检索链路**（memsearch.search_hybrid）取证据，
+            #   而不是行内 LIKE 直查 tool_assets 表。原因：
+            #   (a) 旧写法只 SELECT name||path||capabilities||prerequisites，**漏掉 entrypoint**，
+            #       而「mcp_server.py 在哪」的答案恰好写在 entrypoint 里 → S1 误 FAIL；
+            #   (b) 旧写法的分词用 asset_bench._tokens 拼 LIKE，**测的是 SQL 子串匹配**，
+            #       与实际 `mem.py search` 走的是两条不同代码路径 —— 卷子和生产不一致，
+            #       这种"自出卷子"的分数再高也不代表用户真问的时候能查到。
+            #   现在统一走 search_hybrid：离线可跑（chromadb 在 .venv-memory），且与生产同路径。
+            try:
+                import memsearch as _ms
+                _r = _ms.search_hybrid(case["q"], limit=8)
+                blob = [x["content"] for x in _r.get("results", [])]
+            except Exception as _e:
+                blob = ["[检索异常] %s" % _e]
+            text = " \n ".join(blob) if blob else "没有收录该资产"
+
+        hit = any(re.search(p, text, re.I) for p in case["expect"])
+        bad = any(re.search(p, text, re.I) for p in case["forbid"]) if case["forbid"] else False
+        passed = bool(text.strip()) and hit and not bad
+        # 检索为空 = 中枢没记住 = fail（除了反向题，空正是对的）
+        if case["cat"].startswith("反向"):
+            passed = hit and not bad
+        results.append(dict(id=case["id"], cat=case["cat"], q=case["q"],
+                            status="PASS" if passed else "FAIL", text=text[:160]))
+
+    conn.close()
+    total = len(results)
+    p = sum(1 for r in results if r["status"] == "PASS")
+    by = {}
+    for r in results:
+        d = by.setdefault(r["cat"], [0, 0])
+        d[1] += 1
+        d[0] += r["status"] == "PASS"
+    print("=" * 78)
+    print(f"留出集 asset_bench_holdout  |  {dt.datetime.now():%Y-%m-%d %H:%M}")
+    print("=" * 78)
+    for c, (a, b) in by.items():
+        print(f"  {c:<12} {a:>2}/{b:<2}")
+    print("-" * 78)
+    print(f"  总分 {p}/{total}  ({p/total*100:.1f}%)")
+    print("=" * 78)
+    if verbose:
+        for r in results:
+            print(f"  [{r['status']}] {r['id']:<4} {r['cat']:<12} {r['q']}")
+            if r["status"] == "FAIL":
+                print(f"        检索到: {r['text'][:110]}")
+    return p, total
+
+
+if __name__ == "__main__":
+    run()

asset_selfcheck.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""asset_selfcheck.py —— 资产保鲜自检（供定时任务调用）
+
+做三件事：
+  1. 跑 tool_audit.verify()，把失活资产标 missing
+  2. 跑 hub_score.score()，把分数落到 scorecard.json
+  3. 若覆盖度或保鲜度 < 90%，在 facts 表写一条告警
+"""
+import os, sys, subprocess, datetime as dt
+HERE = os.path.dirname(os.path.abspath(__file__))
+PY = sys.executable
+sys.path.insert(0, HERE)
+
+def main():
+    log = []
+    # 1) 校验
+    import tool_audit
+    good, bad = tool_audit.verify()
+    log.append("verify: 存活%d 失活%d" % (good, bad))
+    # 2) 评分
+    import hub_score
+    total = hub_score.score()
+    log.append("score: %.1f%%" % (total * 100))
+    # 3) 告警
+    if total < 0.90:
+        import sqlite3
+        c = sqlite3.connect(os.path.join(HERE, "memory.db"))
+        now = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        c.execute("""INSERT INTO facts(uid,type,subject,content,status,valid_from,recorded_at,
+                     temporal_source,source,scope,confidence,tags,created_at,updated_at)
+                     VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                  ("alert-" + dt.datetime.now().strftime("%Y%m%d%H%M%S"), "incident",
+                   "资产自检告警",
+                   "结论：资产自检得分 %.1f%% < 90%%，需人工检查 tool_assets。" % (total * 100),
+                   "active", now, now, "native", "asset_selfcheck.py", "global", 1.0,
+                   '["alert"]', now, now))
+        c.commit()
+        log.append("ALERT 已写入 facts")
+    print(" | ".join(log))
+    return 0 if total >= 0.90 else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

astra_dialogue.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""
+astra_dialogue.py — DeepSeek(V4.1) 与 Astra 的多轮技术协作对话引擎
+
+用途：把"单方面提问"变成"真正的多轮交流"。
+每轮：DeepSeek 发言 → 追加进对话历史 → 调 astra → astra 回答 → 存回历史。
+下一轮 DeepSeek 可以看到完整历史（包括 astra 之前的回答），据此追问/质疑/补充。
+
+用法：
+  python astra_dialogue.py --say "我的发言"            # 追加一轮
+  python astra_dialogue.py --say-file turn.txt        # 从文件读发言
+  python astra_dialogue.py --show                     # 看当前对话历史
+  python astra_dialogue.py --reset --system "..."     # 重置并设 system
+"""
+import os
+import sys
+import json
+import time
+import argparse
+import urllib.request
+
+sys.path.insert(0, r'<AUDIT>')
+import cred_env
+cred_env.env()
+
+KEY = os.environ['GPTX_ASTRA_KEY']
+URL = 'https://api.gptx.cc/v1/chat/completions'
+HIST = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'astra_dialogue.json')
+
+
+def load():
+    if os.path.exists(HIST):
+        with open(HIST, encoding='utf-8') as f:
+            return json.load(f)
+    return {'system': '', 'messages': []}
+
+
+def save(d):
+    with open(HIST, 'w', encoding='utf-8') as f:
+        json.dump(d, f, ensure_ascii=False, indent=2)
+
+
+def call_astra(system, messages, max_tokens=4000):
+    msgs = []
+    if system:
+        msgs.append({'role': 'system', 'content': system})
+    msgs.extend(messages)
+    body = {'model': 'gpt-6-astra', 'messages': msgs, 'temperature': 0.3, 'max_tokens': max_tokens}
+    req = urllib.request.Request(URL, data=json.dumps(body).encode(),
+                                 headers={'Authorization': 'Bearer ' + KEY, 'Content-Type': 'application/json'})
+    t0 = time.time()
+    r = urllib.request.urlopen(req, timeout=360)
+    d = json.loads(r.read().decode())
+    return d['choices'][0]['message']['content'], d.get('usage', {}), time.time() - t0
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--say', default=None)
+    ap.add_argument('--say-file', default=None)
+    ap.add_argument('--show', action='store_true')
+    ap.add_argument('--reset', action='store_true')
+    ap.add_argument('--system', default=None)
+    ap.add_argument('--max-tokens', type=int, default=4000)
+    a = ap.parse_args()
+
+    d = load()
+
+    if a.reset:
+        d = {'system': a.system or '', 'messages': []}
+        save(d)
+        print('对话已重置。system 长度:', len(d['system']))
+        return
+
+    if a.show:
+        print('=== SYSTEM ===')
+        print(d.get('system', '')[:500])
+        print('\n=== MESSAGES (%d) ===' % len(d['messages']))
+        for i, m in enumerate(d['messages']):
+            print('\n[%d][%s] %s' % (i, m['role'], m['content'][:300]))
+        return
+
+    say = a.say
+    if a.say_file:
+        with open(a.say_file, encoding='utf-8') as f:
+            say = f.read()
+    if not say:
+        print('需要 --say 或 --say-file')
+        return
+
+    if a.system and not d.get('system'):
+        d['system'] = a.system
+
+    d['messages'].append({'role': 'user', 'content': say})
+    print('>>> DeepSeek 发言 (%d 字)' % len(say))
+    ans, usage, el = call_astra(d['system'], d['messages'], a.max_tokens)
+    d['messages'].append({'role': 'assistant', 'content': ans})
+    save(d)
+    print('<<< Astra 回应 (%.1fs, prompt %s / completion %s)' % (
+        el, usage.get('prompt_tokens', '?'), usage.get('completion_tokens', '?')))
+    print('=' * 70)
+    print(ans)
+
+
+if __name__ == '__main__':
+    main()