diff --git a/.gitignore b/.gitignore index 3abc61c..7a60b85 100644 --- a/.gitignore +++ b/.gitignore @@ -1,52 +1,2 @@ -# Python __pycache__/ -*.py[cod] -*$py.class -*.so -.Python -build/ -dist/ -*.egg-info/ -.eggs/ -.venv/ -venv/ -env/ - -# 测试与缓存 -.pytest_cache/ -.coverage -htmlcov/ -.mypy_cache/ -.ruff_cache/ - -# 环境与密钥 -.env -.env.local -*.key -*.pem - -# 运行时数据 -*.db -*.db-wal -*.db-shm -data/ -logs/ -.frames/ -voices/*.wav -voices/*.mp3 -!voices/.gitkeep - -# 模型权重（不进仓库） -models/ -*.gguf -*.onnx -*.safetensors - -# 编辑器 -.vscode/ -.idea/ -*.swp -.DS_Store -Thumbs.db - -.venv311/ +*.pyc diff --git a/docs/requirements/handoff-HEL-857.json b/docs/requirements/handoff-HEL-857.json new file mode 100644 index 0000000..4fd6bbf --- /dev/null +++ b/docs/requirements/handoff-HEL-857.json @@ -0,0 +1,28 @@ +{ + "baseline_version": "1.11", + "read_commit": "bb9cbe915ecdc5d7dd3393ad45a6c4152e76900a", + "task": "HEL-857 隔离测试Mem0中文记忆与隐私备份", + "requirement_ids": ["CG-008", "CG-009", "CG-011", "CG-013", "CG-014", "CG-015", "CG-016", "CG-021", "AM-001", "UX-004", "UX-006", "GOV-001", "GOV-002", "GOV-003", "GOV-004", "GOV-005", "GOV-006", "DEL-001"], + "deliverable": "已批准的一次性 Mem0 隔离验证：固定源提交 2c81af3 在独立 venv 安装，qdrant 嵌入式+fastembed 本地中文嵌入；零真实模型门禁全过（传输层持久扣账假传输验证、qdrant 三查、隐私 P1-P5 与首次分享 F1-F6 stub 验证、完整备份恢复复检）；门禁过后 A/B 合成场景（现状生产语义重放 vs Mem0，同资料同查询同评判，26/60 次真实出站经持久扣账）。", + "acceptance": [ + "本地 SDK 检查与隐私零泄漏全部通过（gate0 T1-T5、gate1 Q0a-Q0e、gate2 P1-P5/F1-F6 全 pass，见 spike/hel857/results/）", + "恢复后内部与公开记忆完整、来源可回查、公开出口仍不泄漏（P5 含未分享内部记忆保留断言）", + "Mem0 换说法召回严格优于现状（S3：现状词面 0 命中、Mem0 命中且模型中文问答答出'蓝色'），其他既有成功项未退化（S1-S9 全 pass）", + "真实出站 26/60 全部经传输层持久扣账（含重试计数），usage 与耗时逐次留账；本地嵌入 28≤500；模型资源 95,254,651 字节≤500MB（含逐文件 SHA256）", + "检索命中、细节进入上下文、模型实际使用分开判定（S2/S3 分列记录）" + ], + "deferred": [ + "正式采用 Mem0 或迁移产品：待用户拍板，本卡结果不构成采用决定", + "中文提取提示词定制（现提取为英文，双语判据已如实记录）与复测", + "八字情绪、连续生活、主动联系的产品接线卡（本卡明确不做）", + "真实语料'记住昨日细节'验收（另行申请额度）", + "M5/M6 产品接线（v2 §8 三接线）", + "未测的完整产品要求继续承接，不以 SDK 实验代替整产品验收" + ], + "requirement_changes": [], + "verification": [ + "spike/hel857/results/gate0_ledger.json、gate1_backend.json、gate2_privacy.json、ab_scenarios.json（含 _ledger_rows 原始请求账）、ab_scenarios_run1.json（run1 证据）、preflight.json、resource_manifest_pre.json、lock-notes.md", + "spike/hel857/README.md：逐场景通过/失败表、关键发现、归责表、资源与边界", + "合成实验不冒充真实伴侣体验验收；未验证真机/现网/真实档案（本卡范围禁止触达）" + ] +} diff --git a/spike/hel857/README.md b/spike/hel857/README.md new file mode 100644 index 0000000..fe4218a --- /dev/null +++ b/spike/hel857/README.md @@ -0,0 +1,103 @@ +# HEL-857 · Mem0 隔离验证（已批准的一次性实验） + +本目录是任务卡 HEL-857 的全部实验代码、夹具与结果。**仅实验分支，不合 main、不合产品 PR、不部署、不触现网 8300–8350 与真实档案。** 全部测试资料为固定中文合成语料（`fixtures.py`），无真实用户/伴侣数据。 + +- 需求基准：v1.11（60 项），读取提交 `bb9cbe915ecdc5d7dd3393ad45a6c4152e76900a`（`origin/hel-847-v111-governance`），本分支 `hel-857-mem0-spike` 自该提交建立。 +- Mem0 固定源提交：`2c81af3bbe27d9bccb09c772d583df9e9be72ee5`（mem0ai 2.2.1，源码 tarball SHA256 `9dcef9303ebcec116eec6739f01b8b35bd24459de6a569686b4d19b9412dda23`，从源码构建安装，wheel SHA256 `698284b6083ab8b7761454d65876a6d1bb983d278ad21a7bee38d760cb20e9db`，不以 PyPI 同版本包代替）。 +- 关联要求编号：CG-008/009/011/013–016/021、AM-001、UX-004/006、GOV-001–006、DEL-001。本卡是 SDK 隔离验证，不代替任何完整产品要求验收。 + +## 运行顺序（与批准范围一致） + +```bash +# 环境：本卡独立 venv（hel857-venv，Python 3.10.12） +# 依赖锁定见 results/lock-notes.md；包下载量 54.4MB（pip 日志核算） +export HEL857_DATA=<独立数据目录> +python -m spike.hel857.resource_check # 模型资源下载前核对（远端清单+大小） +python -m spike.hel857.ledger_fake_test # 门禁0 传输层持久扣账（零网络） +python -m spike.hel857.step0_backend_check # 门禁1 qdrant 嵌入式三查（零真实模型） +python -m spike.hel857.stub_gate # 门禁2 隐私+首次分享+备份恢复（stub LLM） +python -m spike.hel857.ab_preflight # 真实出站预检（1 次出站，计入 60 上限） +python -m spike.hel857.ab_scenarios # A/B 真实合成场景（门禁全过后才允许） +``` + +## 结果总览（逐项通过/失败，不是只给一个总数） + +| 门禁/场景 | 结果 | 证据 | +| --- | --- | --- | +| 资源预核对 | 通过：两模型合计 95,418,166 字节 < 500,000,000 | `results/resource_manifest_pre.json` | +| G0 扣账 T1 第61次发送前拦截 | 通过（假传输恰收 60 次尝试） | `results/gate0_ledger.json` | +| G0 T2 失败也扣账 | 通过（3 次 fake 5xx 不回滚） | 同上 | +| G0 T3 账本跨进程保留 | 通过（子进程被拦、零出站） | 同上 | +| G0 T4 输入超限发送前拒绝 | 通过 | 同上 | +| G0 T5 自动重试显式关闭 | 通过（max_retries=0，1调用=1出站=1扣账） | 同上 | +| G1 Q0a keyword_search | 通过（机制可用）；**发现：中文无分词** | `results/gate1_backend.json` | +| G1 Q0b 本地读写+过滤/语义检索 | 通过 | 同上 | +| G1 Q0c 子进程真实重启挂载 | 通过 | 同上 | +| G1 Q0d 清洁关闭复制→恢复 | 通过 | 同上 | +| G1 Q0e collection 清单 | 通过（无遥测 collection） | 同上 | +| G1 模型资源实测 | 95,254,651 字节（按 inode 去重，含逐文件 SHA256） | 同上 | +| G2 P1 提取输入池零泄漏 | 通过 | `results/gate2_privacy.json` | +| G2 P2 提取历史窗零泄漏 | 通过（A 的 history 原话确在 A 库，正对照成立） | 同上 | +| G2 P3 更新隔离（A 逐字节不变） | 通过 | 同上 | +| G2 P4 回读+600字预算零泄漏 | 通过 | 同上 | +| G2 P5 完整备份→恢复→复跑 | 通过（内部未分享仍在，公开出口仍不漏） | 同上 | +| G2 F1 判定失败不迁 | 通过 | 同上 | +| G2 F2 未确认不迁 | 通过 | 同上 | +| G2 F3 取消不迁 | 通过 | 同上 | +| G2 F4 成功按已讲内容迁入+锚点 | 通过（A 保留内部副本） | 同上 | +| G2 F5 重复回执不重复迁入 | 通过 | 同上 | +| G2 F6 其他未分享仍隐藏 | 通过 | 同上 | +| AB S1 原话留存 | 通过（现状 chat_message；Mem0 history.db messages） | `results/ab_scenarios.json` | +| AB S2 跨会话细节 | 通过（命中/进上下文/模型使用分列） | 同上 | +| AB S3 换说法召回（核心） | **通过：Mem0 严格优于现状**（现状 0 命中 vs Mem0 命中；中文问答答出“蓝色”） | 同上 | +| AB S4 改口更正 | 通过（两批时 infer ADD-only 新旧并存；我方编排 update 留 prev→new；run1 证明同批时提取自动合并） | 同上 | +| AB S5 事实/感受分离 | 通过（事实/感受查询各自召回） | 同上 | +| AB S6 承诺状态 | 通过（显式 update 置 resolved，history 留痕） | 同上 | +| AB S7 来源回读 | 通过（现状带门回读恢复该行原文；Mem0 原文在 history.db） | 同上 | +| AB S8 进程重启 | 通过（真实子进程重启） | 同上 | +| AB S9 完整备份恢复 | 通过（恢复后换说法召回仍命中） | 同上 | + +**未运行/不适用**：无未运行的既定检查。八字情绪、连续生活、主动联系的产品接线明确不在本卡（批准范围第5条），未运行。 + +## 真实调用账（持久账本，跨运行保留） + +- 实际出站 **26 / 60**（上限不是必须用满；剩余 34 不挪用、不清零）。全部 `sent`（HTTP 200），无失败、无 blocked。 +- 明细：预检 1 次；run1（含 1 次提取解析失败后的重试，重试已计数）14 次；run2 11 次。逐次时间/状态/耗时/输入规模/usage 见 `results/ab_scenarios.json` 的 `_ledger_rows`。 +- usage 合计：prompt 114,183 / completion 2,854 / total 117,037 tokens（单次 completion ≤367 ≤1024 上限；单次输入中文 ≤201 字符 ≤6000 上限）。价格未知，不承诺金额或免费。 +- 原HEL-835的6/8额度未动用、未重置。 +- 本地嵌入：密集 28 条 + 实体 0 条（spaCy 未安装，上游优雅降级为空，如实记录）= 28 ≤ 500。词面处理另列：10 次。 +- 门禁 0/1/2 与资源核对全部零真实模型、零网络出站（stub/假传输/本地推理）。 + +## 关键发现（如实记录，不因结果好而省略） + +1. **中文输入被提取为英文记忆。** mem0 默认英文提取提示词；换说法召回经多语中文嵌入（bge-small-zh）仍命中，模型使用检查（中文提问+英文记忆上下文）中文答出“蓝色”。产品接线需 custom_instructions 定制中文提示词或接受双语存储——本卡未改该配置。 +2. **BM25 词面通道对中文实际不可用。** Qdrant/bm25 将中文整段（空格/标点切分）哈希为单 token；spaCy 缺席时 `lemmatize_for_bm25` 原样返回、无中文分词。叠加发现1（中文查询↔英文记忆），词面通道在中文场景不交叉，召回全靠密集语义。机制本身可用（英文 token 正常打分命中）。 +3. **同批 add 时提取会自动合并改口**（run1 证据，账本保留）；还原“稍后改口”（两批）后 infer 确为 ADD-only（与 v4 对 main.py 的调用链核对一致），更新编排归我方。 +4. **SDK search/get_all 不回传自定义 metadata**：分享锚点（life_event_id 等）写入 payload 但需直读向量库；产品接线需适配层读锚点。 +5. 实体路径依赖 spaCy（未装，上游设计为降级为空）；实体嵌入计数为 0，不伪装已启用。 + +## 归责表（上游 vs 我方，实验实证后的修订） + +| 职责 | 上游（mem0ai 2.2.1） | 我方 | +| --- | --- | --- | +| 提取管道/去重/ADD 史 | ✔（实证：ADD-only、hash 去重、操作史完整） | 提取语言/质量定制（中文提示词）与调用编排 | +| 冲突检测→UPDATE/DELETE | 原语 update/delete + prev→new 史（实证） | **全部**：检测、选条、编排（S4/S6 已按此实现） | +| 语义检索+中文向量 | ✔（实证：换说法严格优于现状词面） | embedder 配置 | +| 词面通道 | 机制存在（英文可用） | 中文分词适配或接受不可用并如实声明 | +| 隐私前置隔离 | scope/collection 承载（实证零泄漏） | 双实例设计、内部→公开桥接、逐消息门（实证 F1–F6） | +| 完整备份 | 本地目录+history 可清洁复制恢复（实证） | 打包/清单/恢复校验（CG-009 工件数按实例实算） | +| 原文存储与回读 | history.db 存原始输入副本（实证） | chat_message 主责不变；导出纳管 history.db | +| 出站计费/限额 | ✘ | **全部**（传输层持久扣账，实证第61次拦截） | +| 八字/情绪/生活/主动联系 | ✘ | 全部（后续产品接线卡） | + +## 环境与锁定 + +- Python 3.10.12 独立 venv；mem0ai 2.2.1（固定源提交构建）；qdrant-client 1.20.0（嵌入式本地路径）；fastembed 0.9.1；openai 3.37.0；httpx 0.28.1。完整版本清单见 `results/lock-notes.md`。 +- 模型资源（fastembed 缓存，逐文件 SHA256 见 `results/gate1_backend.json`）：BAAI/bge-small-zh-v1.5（fastembed 实际来源为 Qdrant 官方 ONNX 镜像 `Qdrant/bge-small-zh-v1.5`，`model_optimized.onnx` 94,781,076 字节）+ Qdrant/bm25，合计 95,254,651 字节 ≤ 500MB 上限。 +- 网关 `http://192.168.200.11:8731/v1`、模型 `halogen-qwen3.8-flash-next`（现有配置，`config/models.yaml` 同源；未新增账号/付费接口）。 + +## 边界与未完成承接 + +- 本卡结论仅覆盖：本地 SDK 检查、隐私零泄漏（合成数据）、恢复完整性、换说法召回优于现状。**合成实验不冒充真实伴侣“记住昨日细节”已通过**；检索命中、细节进入上下文、模型实际使用已分开判定（S2/S3）。 +- 未做（继续承接）：正式采用或产品接入（待用户拍板）；中文提取提示词定制与复测；八字情绪/连续生活/主动联系接线卡；真实语料验收（另行申请额度）；M5/M6 产品接线（v2 §8）。 +- 失败处置规则未触发：无连续真实失败 3 次（含 run1 的 1 次解析重试后即成功）、无隐私负例失败、未达任何上限。 diff --git a/spike/hel857/__init__.py b/spike/hel857/__init__.py new file mode 100644 index 0000000..054c87c --- /dev/null +++ b/spike/hel857/__init__.py @@ -0,0 +1 @@ +"""HEL-857 spike 包。""" diff --git a/spike/hel857/__main__.py b/spike/hel857/__main__.py new file mode 100644 index 0000000..86f94c2 --- /dev/null +++ b/spike/hel857/__main__.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 +"""按批准顺序运行全部门禁，再（仅当全过）运行真实 A/B。 + +用法： + python -m spike.hel-857 --gates-only # 只跑零真实模型门禁 + python -m spike.hel-857 --with-ab # 门禁全过后继续真实 A/B（≤60 次出站） +""" +from __future__ import annotations + +import sys + +from . import ledger_fake_test, step0_backend_check, stub_gate + + +def main(argv: list[str]) -> int: + gates_only = "--gates-only" in argv + with_ab = "--with-ab" in argv + + print("== 门禁 0：传输层持久扣账（零网络）==") + r0 = ledger_fake_test.main([]) + print(json_summary("G0_ledger", r0)) + + print("== 门禁 1：qdrant 嵌入式三查（零真实模型）==") + r1 = step0_backend_check.main([]) + print(json_summary("G1_backend", r1)) + + print("== 门禁 2：隐私与首次分享时序（stub LLM，零真实模型）==") + r2 = stub_gate.main([]) + print(json_summary("G2_privacy", r2)) + + gates_ok = r0.get("ok") and r1.get("ok") and r2.get("ok") + if not gates_ok: + print("门禁未全过，停止；不运行任何真实请求。") + return 1 + if gates_only or not with_ab: + print("门禁全过。未请求真实模型（本调用未带 --with-ab）。") + return 0 + + print("== A/B 真实合成场景（≤60 次出站）==") + from . import ab_scenarios + r3 = ab_scenarios.main([]) + print(json_summary("AB_scenarios", r3)) + return 0 if r3.get("completed") else 1 + + +def json_summary(name: str, payload: dict) -> str: + import json + ok = payload.get("ok", payload.get("completed")) + return f"[{name}] ok={ok}" + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/spike/hel857/ab_child.py b/spike/hel857/ab_child.py new file mode 100644 index 0000000..73490a4 --- /dev/null +++ b/spike/hel857/ab_child.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +"""S8 子进程：向 Mem0 公开实例写入一条 infer=False 记忆（零 LLM 出站）。""" +from __future__ import annotations + +import json +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + +from spike.hel857.common import PUB, close_memory, mem_config, install_counters # noqa: E402 +from mem0 import Memory # noqa: E402 + + +def main() -> int: + root = Path(sys.argv[1]) + m = Memory.from_config(mem_config(PUB, vec_root=root, hist_root=root)) + install_counters(m) + m.add([{"role": "user", "content": "新书架到了，把海雾旁边空出第二层"}], + user_id="user-1", infer=False) + got = m.get_all(filters={"user_id": "user-1"}) + n = len(got.get("results") or []) + close_memory(m) + print(json.dumps({"ok": n >= 1, "items": n})) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/spike/hel857/ab_preflight.py b/spike/hel857/ab_preflight.py new file mode 100644 index 0000000..e4f37f5 --- /dev/null +++ b/spike/hel857/ab_preflight.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +"""真实出站预检：1 次调用，走同一持久账本（计入 60 次上限）。 + +验证网关 chat completions + response_format json_object（Mem0 提取依赖）， +失败即停并保全证据，不进入 A/B。 +""" +from __future__ import annotations + +import httpx +from openai import OpenAI + +from .common import GATEWAY_BASE_URL, GATEWAY_MODEL, write_result +from .ledger import AccountingTransport, Ledger + + +def main(argv: list[str]) -> dict: + led = Ledger() # 卡级规范账本（DATA_DIR/ledger.sqlite3） + acc = AccountingTransport(httpx.HTTPTransport(), led) + client = OpenAI(api_key="hel857-local-test", base_url=GATEWAY_BASE_URL, + max_retries=0, http_client=httpx.Client(transport=acc, timeout=60.0)) + out: dict = {"ok": False} + try: + resp = client.chat.completions.create( + model=GATEWAY_MODEL, + messages=[{"role": "system", "content": "只输出 JSON。"}, + {"role": "user", "content": '返回 {"memory":[{"text":"预检通过"}]}'}], + response_format={"type": "json_object"}, + max_tokens=1024, temperature=0.0) + content = resp.choices[0].message.content or "" + out["ok"] = "预检通过" in content + out["content"] = content[:200] + out["usage"] = resp.usage.model_dump() if resp.usage else None + except Exception as e: + out["error"] = f"{type(e).__name__}: {e}" + out["ledger_used"] = led.used() + write_result("preflight.json", out) + return out + + +if __name__ == "__main__": + raise SystemExit(0 if main([])["ok"] else 1) diff --git a/spike/hel857/ab_scenarios.py b/spike/hel857/ab_scenarios.py new file mode 100644 index 0000000..d4b1dd5 --- /dev/null +++ b/spike/hel857/ab_scenarios.py @@ -0,0 +1,513 @@ +#!/usr/bin/env python3 +"""A/B 真实合成场景：现状路径 vs Mem0（同资料、同查询、同评判）。 + +前置：门禁 0/1/2 全过（本模块由 __main__ 编排，不单独放行）。 +真实出站：仅网关 LLM——Mem0 提取 add(infer=True) 4 批 + 双路径模型使用问答 8 次， +全部经传输层持久扣账（上限 60，失败/取消/重试计数；连续真实失败 3 次停）。 +本地嵌入计数上限 500；词面另列。 + +对照设计（批准范围第5条）： + 现状路径 = docs/reuse-hel847/probe_recall.py 的生产语义重放（总管已核对的 v2 基线， + 词面 FTS trigram 检索 + fixture gist + 带门回读），不读写真实库； + Mem0 路径 = 本卡 SDK 实例，真实 LLM 提取 + 本地中文语义检索。 + 两路径候选集不同（不强制同候选集），但输入资料、查询与评判标准相同。 + 检索命中 / 细节进入上下文 / 模型实际使用 分开判定。 + +诚实边界：现状路径的 gist 为生产形态夹具（压缩丢失细节是其真实设计）， +Mem0 的提取为真实模型行为——两侧不对称如实记录，不冒充同源。 +""" +from __future__ import annotations + +import json +import shutil +import sqlite3 +import subprocess +import sys +import time +from pathlib import Path + +import httpx + +from .common import (COUNTERS, DATA_DIR, GATEWAY_BASE_URL, GATEWAY_MODEL, + PRIV, PUB, close_memory, install_counters, mem_config, + write_result) +from .fixtures import (ANSWER_KEY_PARAPHRASE, CORRECTION_PAIR, + FACT_FEELING_PAIR, PROMISE_PAIR, PUBLIC_CORPUS, + Q_CORRECTION, Q_EXACT, Q_FACT, Q_FEELING, + Q_PARAPHRASE, Q_PARAPHRASE_TOPIC, Q_PROMISE, + UNIQUE_DETAIL, public_messages) +from . import fixtures as FX +from .ledger import AccountingTransport, Ledger + +AB = DATA_DIR / "ab" +BASELINE_GISTS = { + "t1": "用户买到一本诗集，很喜欢", + "t2": "用户给诗集取名海雾，放床头第二层", + "t3": "用户加班，买到坏的栗子", + "t4": "用户读完诗集，喜欢第三首", + "t5": "用户又买了栗子", + "c1": "用户下周三体检", + "c2": "用户体检改到周五", + "f1": "用户周五有重要面试", + "f2": "用户面试前紧张失眠", + "p1": "用户答应周五晚告知面试结果", + "p2": "用户面试通过，第一时间告知", +} + + +# --------------------------------------------------------------------------- +# 现状路径（v2 基线重放） +def build_baseline_db(path: Path) -> None: + sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "docs" / "reuse-hel847")) + import probe_recall as PR + if path.exists(): + path.unlink() + conn = sqlite3.connect(path) + conn.executescript(PR.SCHEMA) + rows = [(24, "t1"), (23, "t2"), (12, "t3"), (6, "t4"), (2, "t5"), + (5, "c1"), (4, "c2"), (5, "f1"), (4, "f2"), (8, "p1"), (1, "p2")] + texts = {t: r for t, _, r in FX.PUBLIC_CORPUS} + texts.update({t: r for t, _, r in CORRECTION_PAIR}) + texts.update({t: r for t, _, r in FACT_FEELING_PAIR}) + texts.update({t: r for t, _, r in PROMISE_PAIR}) + ids = {} + for hours, turn in rows: + role = "user" + ts = int((PR.NOW - hours * PR.HOUR) * 1000) + cur = conn.execute( + "INSERT INTO chat_message(ts,role,text,turn_id,status) VALUES(?,?,?,?,'sent')", + (ts, role, texts[turn], turn)) + mid = cur.lastrowid + ids[(turn, role)] = mid + conn.execute( + "INSERT INTO mem_episodic(ts,role,raw,gist,salience,source,turn_id,message_id) " + "VALUES(?,?,?,?,0.5,'chat',?,?)", + (ts, role, texts[turn], BASELINE_GISTS.get(turn), turn, mid)) + mem_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0] + conn.execute("INSERT INTO mem_job(source,ref_id,memory_id,state,attempts,model) " + "VALUES('chat_message',?,?,'done',1,'fixture')", (mid, mem_id)) + conn.commit() + conn.close() + + +def baseline_engine(db: Path): + sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "docs" / "reuse-hel847")) + import probe_recall as PR + conn = sqlite3.connect(db) + conn.row_factory = sqlite3.Row + return PR.ProdEpisodic(conn), conn + + +# --------------------------------------------------------------------------- +# Mem0 路径 +def make_real_memory(role: str, root: Path, ledger: Ledger): + from mem0 import Memory + from openai import OpenAI + m = Memory.from_config(mem_config(role, vec_root=root, hist_root=root)) + install_counters(m) + acc = AccountingTransport(httpx.HTTPTransport(), ledger) + m.llm.client = OpenAI( + api_key=m.llm.config.api_key or "hel857-local-test", + base_url=GATEWAY_BASE_URL, + max_retries=0, + http_client=httpx.Client(transport=acc, timeout=90.0), + ) + return m + + +def mem0_search_texts(m, query: str, limit: int = 5) -> list[dict]: + res = m.search(query, filters={"user_id": "user-1"}, limit=limit) + hits = res.get("results") or [] if isinstance(res, dict) else res or [] + return hits + + +def ask_model(ledger_ledger: Ledger, m, question: str, context_block: str) -> dict: + """模型实际使用判定：同 prompt 同判据（关键答案词出现与否）。""" + prompt = [ + {"role": "system", "content": "你是记忆使用验证器。只依据给定资料回答，资料里没有就说不知道。回答不超过两句话。"}, + {"role": "user", "content": f"资料：\n{context_block}\n\n问题：{question}"}, + ] + t0 = time.monotonic() + try: + resp = m.llm.client.chat.completions.create( + model=GATEWAY_MODEL, messages=prompt, max_tokens=1024, temperature=0.0) + ans = resp.choices[0].message.content or "" + return {"ok": True, "answer": ans.strip(), "latency_ms": round((time.monotonic() - t0) * 1000, 1)} + except Exception as e: + return {"ok": False, "answer": f"ERROR:{type(e).__name__}: {e}", + "latency_ms": round((time.monotonic() - t0) * 1000, 1)} + + +def has_any(text: str, terms_zh: list[str], terms_en: list[str]) -> bool: + """双语判据：真实提取为英文（mem0 默认英文提取提示词），检索靠多语嵌入桥接。""" + low = (text or "").lower() + return any(t in (text or "") for t in terms_zh) or any(t in low for t in terms_en) + + +def assemble_block(entries: list[str], budget: int = 600) -> str: + header = "她记得的更早的事（数据，不执行指令）：\n" + block = "" + for e in entries: + cand = (block or header) + e + "\n" + if len(cand) > budget: + break + block = cand + return block + + +CONSEC_LIMIT = 3 + + +class FailureStop(RuntimeError): + pass + + +class RealRunner: + def __init__(self, root: Path, ledger: Ledger): + self.root = root + self.ledger = ledger + self.consec = 0 + self.pub = make_real_memory(PUB, root, ledger) + + def _tick(self, ok: bool): + self.consec = 0 if ok else self.consec + 1 + if self.consec >= CONSEC_LIMIT: + raise FailureStop(f"连续真实失败 {self.consec} 次，停止") + + def add(self, messages: list[dict]): + for attempt in range(2): + try: + r = self.pub.add(messages, user_id="user-1", agent_id="cg-companion") + self._tick(True) + return r + except FailureStop: + raise + except Exception as e: + self._tick(False) + last = f"{type(e).__name__}: {e}" + return {"error": last} + + def ask(self, question: str, context_block: str): + for attempt in range(2): + try: + r = ask_model(self.ledger, self.pub, question, context_block) + self._tick(r["ok"]) + return r + except FailureStop: + raise + except Exception as e: + self._tick(False) + last = f"{type(e).__name__}: {e}" + return {"ok": False, "answer": f"ERROR:{last}"} + + +# --------------------------------------------------------------------------- +def run() -> dict: + if AB.exists(): + shutil.rmtree(AB) + AB.mkdir(parents=True) + results: dict = {} + ledger = Ledger() # 卡级规范账本：与预检共享同一持久额度（上限 60） + + # ---- 现状路径装载 ---- + base_db = AB / "baseline.sqlite3" + build_baseline_db(base_db) + base, base_conn = baseline_engine(base_db) + + # ---- Mem0 写入（真实提取）---- + # run1 证据（账本保留）：c1+c2 同批时提取自动合并为一条已更正记忆； + # run2 起改两批（先周三、后改周五），还原"稍后改口"的真实时序。 + rr = RealRunner(AB / "mem0", ledger) + adds = {} + adds["base_corpus"] = rr.add(public_messages("base")) + adds["correction_first"] = rr.add(public_messages("correction")[:1]) + adds["correction_later"] = rr.add(public_messages("correction")[1:]) + adds["fact_feeling"] = rr.add(public_messages("fact_feeling")) + adds["promise"] = rr.add(public_messages("promise")) + def _flat(v): + if isinstance(v, dict): + return [{"event": "ERROR", "memory": json.dumps(v, ensure_ascii=False)[:200]}] + return [{"event": r.get("event"), "memory": r.get("memory")} + for r in (v or []) if isinstance(r, dict)] + + results["_mem0_adds"] = {k: _flat(v) for k, v in adds.items()} + used_after_adds = ledger.used() + + # ---- S1 原话留存（程序判定，零出站）---- + raw_t1 = FX.PUBLIC_CORPUS[0][2] + with sqlite3.connect(str(AB / "mem0" / "mem0_public_history.db")) as c: + hist_msgs = [r[0] for r in c.execute("SELECT content FROM messages").fetchall()] + mem0_raw_kept = any(raw_t1 in m for m in hist_msgs) + base_row = base_conn.execute("SELECT raw FROM mem_episodic WHERE turn_id='t1'").fetchone() + results["S1_verbatim_retention"] = { + "baseline_raw_in_chat_message": bool(base_row and raw_t1 in base_row["raw"]), + "mem0_raw_in_history_db": mem0_raw_kept, + "expect": "两侧原文都留存：现状在 chat_message/mem_episodic.raw；Mem0 在 history.db messages（派生副本）", + "pass": bool(base_row and mem0_raw_kept), + } + + # ---- S2 跨会话细节（检索命中 / 细节进上下文 分列）---- + b_hits, b_mode = base.search("旧书店") + b_block, _, _ = base.context_block("旧书店", turn_id="q_s2") + b_reread = base.reread_turn(b_hits[0]) if b_hits else {"messages": []} + b_reread_text = " ".join(m["text"] for m in b_reread["messages"]) + m_hits = mem0_search_texts(rr.pub, "旧书店 诗集") + m_block = assemble_block([h["memory"] for h in m_hits]) + detail_in = { + "baseline": {"hit": bool(b_hits), "detail_in_context": UNIQUE_DETAIL in b_block, + "detail_in_reread": UNIQUE_DETAIL in b_reread_text}, + "mem0": {"hit": bool(m_hits), + "detail_in_context": has_any(m_block, [UNIQUE_DETAIL], ["damp smell"]), + "memories": [h["memory"] for h in m_hits][:3]}, + } + q2 = "还记得我买诗集那天的细节吗？" + a_base = rr.ask(q2, b_block or "（无可用记忆）") + a_mem0 = rr.ask(q2, m_block or "（无可用记忆）") + results["S2_cross_session_detail"] = { + "retrieval": detail_in, + "model_use": {"baseline_answer": a_base["answer"], "mem0_answer": a_mem0["answer"], + "baseline_detail_used": UNIQUE_DETAIL in a_base["answer"], + "mem0_detail_used": (UNIQUE_DETAIL in a_mem0["answer"]) + or ("damp" in a_mem0["answer"].lower())}, + "expect": "两侧检索命中；细节是否进入注入块与模型实际使用分列（现状靠回读，Mem0 靠提取保真）", + "pass": bool(b_hits) and bool(m_hits), + } + + # ---- S3 换说法召回（核心：Mem0 必须严格优于现状）---- + b_hits3, b_mode3 = base.search(Q_PARAPHRASE) + b_hits3b, b_mode3b = base.search(Q_PARAPHRASE_TOPIC) + m_hits3 = mem0_search_texts(rr.pub, Q_PARAPHRASE) + m_hits3b = mem0_search_texts(rr.pub, Q_PARAPHRASE_TOPIC) + m_block3 = assemble_block([h["memory"] for h in m_hits3]) + b_block3, _, _ = base.context_block(Q_PARAPHRASE, turn_id="q_s3a") + a_base3 = rr.ask(Q_PARAPHRASE, b_block3 or "（无可用记忆）") + a_mem03 = rr.ask(Q_PARAPHRASE, m_block3 or "（无可用记忆）") + t1_target = FX.PUBLIC_CORPUS[0][2] + results["S3_paraphrase_recall"] = { + "query1": Q_PARAPHRASE, + "baseline": {"hits": len(b_hits3), "mode": b_mode3, + "target_hit": any(t1_target in (h["raw"] or "") for h in b_hits3)}, + "mem0": {"hits": len(m_hits3), "memories": [h["memory"] for h in m_hits3][:3], + "target_hit": any(has_any(h["memory"], ["诗集", "封面"], ["poetry", "cover"]) + for h in m_hits3)}, + "query2": Q_PARAPHRASE_TOPIC, + "baseline_q2_hits": len(b_hits3b), + "mem0_q2": {"hits": len(m_hits3b), "memories": [h["memory"] for h in m_hits3b][:3], + "target_hit": any(has_any(h["memory"], ["栗子", "坏"], ["chestnut", "bad"]) + for h in m_hits3b)}, + "model_use": {"baseline_answer": a_base3["answer"], "mem0_answer": a_mem03["answer"], + "mem0_answer_has_color": ANSWER_KEY_PARAPHRASE in a_mem03["answer"]}, + "expect": "换说法召回 Mem0 严格优于现状（现状词面无命中是其已证缺口）", + "pass": (len(b_hits3) == 0 and len(m_hits3) >= 1 + and any(has_any(h["memory"], ["诗集", "封面"], ["poetry", "cover"]) + for h in m_hits3) + and len(m_hits3b) >= 1 + and any(has_any(h["memory"], ["栗子", "坏"], ["chestnut", "bad"]) + for h in m_hits3b)), + } + + # ---- S4 改口更正（两批：先周三、后改周五；infer ADD-only + 我方编排显式 update）---- + # 现状基线用其可命中形态（关键词"体检"）验证自身检索不退化；自然语言查询 + # "体检是哪天"在现状词面本就无命中（E1 类缺口，如实记录）。 + b_kw, _ = base.search("体检") + b_nl, b_nl_mode = base.search(Q_CORRECTION) + b_both = sorted({h["turn_id"] for h in b_kw}) + m_hits4 = mem0_search_texts(rr.pub, Q_CORRECTION) + corr_texts = [h["memory"] for h in m_hits4] + has_new = any(has_any(t, ["周五"], ["friday"]) for t in corr_texts) + has_old = any(has_any(t, ["周三"], ["wednesday"]) for t in corr_texts) + update_rec = None + if has_old: + old_item = next(h for h in m_hits4 if has_any(h["memory"], ["周三"], ["wednesday"])) + new_text = old_item["memory"] + "（改期确认：体检在周五上午）" + try: + rr.pub.update(old_item["id"], text=new_text, + metadata={"corrected_at": "synthetic-c2"}) + update_rec = {"updated": True} + except Exception as e: + update_rec = {"updated": False, "error": str(e)} + with sqlite3.connect(str(AB / "mem0" / "mem0_public_history.db")) as c: + upd_rows = c.execute( + "SELECT old_memory,new_memory,event FROM history WHERE event='UPDATE'").fetchall() + a4 = rr.ask(Q_CORRECTION, assemble_block(corr_texts) or "（无可用记忆）") + results["S4_correction"] = { + "baseline": {"keyword_hits": b_both, "natural_lang_hits": len(b_nl), + "natural_lang_mode": b_nl_mode, + "both_kept": any(t in b_both for t in ("c1", "c2")) + and all(t in b_both for t in ("c1", "c2"))}, + "mem0": {"retrieved": corr_texts, "has_new_friday": has_new, "has_old_wednesday": has_old, + "infer_is_add_only_both_entries": has_old and has_new, + "our_update": update_rec, + "history_update_rows": [list(r)[:3] for r in upd_rows]}, + "model_use": {"answer": a4["answer"], + "friday_used": ("周五" in a4["answer"]) or ("friday" in a4["answer"].lower())}, + "expect": "稍后改口时 infer 为 ADD-only（新旧并存，v4 事实）；我方显式 update 编排改口留 prev→new 史；" + "现状关键词检索不退化，自然语言查询维持其已证词面缺口", + "pass": all(t in b_both for t in ("c1", "c2")) and has_new and has_old + and ("周五" in a4["answer"] or "friday" in a4["answer"].lower()), + } + + # ---- S5 事实/感受分离（现状用其可命中关键词形态；Mem0 双语判据）---- + b_fact_kw, _ = base.search("面试") + b_feel_kw, _ = base.search("紧张") + b_fact_nl, _ = base.search(Q_FACT) + b_feel_nl, _ = base.search(Q_FEELING) + m_fact = mem0_search_texts(rr.pub, Q_FACT) + m_feel = mem0_search_texts(rr.pub, Q_FEELING) + results["S5_fact_feeling_separation"] = { + "baseline": {"fact_kw_hits": [h["turn_id"] for h in b_fact_kw], + "feeling_kw_hits": [h["turn_id"] for h in b_feel_kw], + "fact_nl_hits": len(b_fact_nl), "feeling_nl_hits": len(b_feel_nl)}, + "mem0": {"fact_memories": [h["memory"] for h in m_fact][:3], + "feeling_memories": [h["memory"] for h in m_feel][:3], + "fact_has_interview": any(has_any(h["memory"], ["面试"], ["interview"]) + for h in m_fact), + "feeling_has_tension": any(has_any(h["memory"], ["紧张", "睡"], + ["nervous", "sleep"]) + for h in m_feel)}, + "expect": "事实查询召回面试安排、感受查询召回紧张失眠；两层独立存在；" + "现状关键词形态不退化，自然语言查询维持其已证缺口", + "pass": (any(h["turn_id"] == "f1" for h in b_fact_kw) + and any(h["turn_id"] == "f2" for h in b_feel_kw)) + and any(has_any(h["memory"], ["面试"], ["interview"]) for h in m_fact) + and any(has_any(h["memory"], ["紧张", "睡"], ["nervous", "sleep"]) for h in m_feel), + } + + # ---- S6 承诺状态（我方编排 open→resolved）---- + m_promise = mem0_search_texts(rr.pub, Q_PROMISE) + p_texts = [h["memory"] for h in m_promise] + status_meta = None + if m_promise: + target = next((h for h in m_promise + if has_any(h["memory"], ["结果", "告诉"], ["result", "tell"])), + m_promise[0]) + try: + rr.pub.update(target["id"], text=target["memory"], + metadata={"promise_status": "resolved", + "resolved_at": "synthetic-t2"}) + status_meta = "resolved" + except Exception as e: + status_meta = f"error:{e}" + with sqlite3.connect(str(AB / "mem0" / "mem0_public_history.db")) as c: + hist_events = [r[0] for r in c.execute("SELECT event FROM history ORDER BY id").fetchall()] + a6 = rr.ask(Q_PROMISE, assemble_block(p_texts) or "（无可用记忆）") + results["S6_promise_status"] = { + "mem0": {"retrieved": p_texts, "status_orchestration": status_meta, + "history_events": hist_events}, + "model_use": {"answer": a6["answer"]}, + "baseline_note": "现状路径承诺埋在聊天行内，无独立承诺对象（v2 已记录缺口）", + "expect": "承诺以独立条目存在；我方编排显式 update 置 resolved 且 history 留痕", + "pass": bool(m_promise) and status_meta == "resolved" + and "UPDATE" in hist_events, + } + + # ---- S7 来源回读（自洽判据：回读恢复命中行自身原文）---- + b_hits7, _ = base.search("诗集") + rr7 = base.reread_turn(b_hits7[0]) if b_hits7 else {"messages": []} + b7_text = " ".join(m["text"] for m in rr7["messages"]) + b7_ok = bool(b_hits7) and (b_hits7[0]["raw"] in b7_text) + m_hits7 = mem0_search_texts(rr.pub, Q_EXACT) + m7 = m_hits7[0]["memory"] if m_hits7 else "" + with sqlite3.connect(str(AB / "mem0" / "mem0_public_history.db")) as c: + raw_ok = any(FX.PUBLIC_CORPUS[0][2][:10] in (r[0] or "") for r in + c.execute("SELECT content FROM messages").fetchall()) + results["S7_source_reread"] = { + "baseline": {"hit_turn": b_hits7[0]["turn_id"] if b_hits7 else None, + "reread_recovered_own_raw": b7_ok}, + "mem0": {"retrieved_memory": m7, + "raw_recoverable_from_history": raw_ok}, + "expect": "从检索命中可回查原始来源：现状带门回读恢复该行原文；Mem0 命中是压缩事实，原文在 history.db", + "pass": b7_ok and raw_ok and bool(m_hits7), + } + + # ---- S8 进程重启（子进程真实重启；infer=False 零出站）---- + close_memory(rr.pub) + child = subprocess.run( + [sys.executable, "-m", "spike.hel857.ab_child", str(AB / "mem0")], + capture_output=True, text=True, cwd=str(Path(__file__).resolve().parents[2])) + try: + child_out = json.loads(child.stdout) + except Exception: + child_out = {"stdout": child.stdout[-500:], "stderr": child.stderr[-1000:], + "returncode": child.returncode} + rr.pub = make_real_memory(PUB, AB / "mem0", ledger) + m_after = mem0_search_texts(rr.pub, "新书架 海雾") + results["S8_process_restart"] = { + "child": child_out, + "after_restart_hits": [h["memory"] for h in m_after][:3], + "after_restart_has_new_shelf": any(has_any(h["memory"], ["书架"], ["shelf", "bookrack"]) + for h in m_after), + "expect": "子进程写入 → 新进程检索可见（真实进程重启，非同进程重开）", + "pass": bool(child_out.get("ok")) + and any(has_any(h["memory"], ["书架"], ["shelf", "bookrack"]) for h in m_after), + } + + # ---- S9 完整备份恢复（公开实例；私密侧已在门禁2 P5 证明）---- + close_memory(rr.pub) + bkp = AB / "backup_public" + bkp.mkdir() + shutil.copytree(AB / "mem0" / "vec_public", bkp / "vec_public") + shutil.copy2(AB / "mem0" / "mem0_public_history.db", bkp / "mem0_public_history.db") + rst = AB / "restore_public" + rst.mkdir() + shutil.copytree(bkp / "vec_public", rst / "vec_public") + shutil.copy2(bkp / "mem0_public_history.db", rst / "mem0_public_history.db") + rp = make_real_memory(PUB, rst, ledger) + m_r = mem0_search_texts(rp, Q_PARAPHRASE) + close_memory(rp) + results["S9_backup_restore"] = { + "restored_hits": [h["memory"] for h in m_r][:3], + "restored_target_hit": any(has_any(h["memory"], ["诗集", "封面"], ["poetry", "cover"]) + for h in m_r), + "expect": "公开实例完整备份→恢复→换说法召回仍命中", + "pass": any(has_any(h["memory"], ["诗集", "封面"], ["poetry", "cover"]) for h in m_r), + } + + # ---- 账本与计数收尾 ---- + close_memory(rr.pub) + summary = ledger.summary() + counters = COUNTERS.snapshot() + results["_ledger_summary"] = {k: v for k, v in summary.items() if k != "rows"} + results["_ledger_rows"] = summary["rows"] + results["_counters"] = counters + results["_real_calls_used"] = summary["debited"] + + s3 = results["S3_paraphrase_recall"] + others_ok = all(results[k].get("pass") for k in + ["S1_verbatim_retention", "S2_cross_session_detail", "S4_correction", + "S5_fact_feeling_separation", "S6_promise_status", "S7_source_reread", + "S8_process_restart", "S9_backup_restore"]) + outcome = { + "completed": True, + "mem0_paraphrase_strictly_better": s3["pass"], + "others_no_regression": others_ok, + "budget_respected": summary["debited"] <= 60 and counters["embed_items_total"] <= 500, + "verdict": "", + } + outcome["verdict"] = ( + "换说法召回 Mem0 严格优于现状；其他既有成功项未退化" if (s3["pass"] and others_ok) + else "存在未达标项，见逐场景记录") + outcome["headline_findings"] = { + "extraction_language": ( + "真实提取将中文输入提取为英文记忆（mem0 默认英文提取提示词）；" + "换说法召回经多语中文嵌入仍命中，模型实际使用检查中文问答答出\"蓝色\"。" + "产品接线需 custom_instructions 定制中文提示词或接受双语存储——本卡未改配置，如实记录。"), + "same_batch_correction": ( + "run1（账本保留）：改口消息与原消息同批 add 时，提取自动合并出一条已更正记忆；" + "run2 改两批后还原\"稍后改口\"：infer 为 ADD-only 新旧并存，需我方编排 update。"), + "bm25_chinese": ( + "Qdrant/bm25 对中文整段哈希无分词（门禁1 Q0a 记录）；提取为英文后，" + "中文查询与英文记忆在词面通道亦不交叉——词面通道对中文实际不可用，召回全靠密集语义。"), + } + results["outcome"] = outcome + return results + + +def main(argv: list[str]) -> dict: + out = run() + write_result("ab_scenarios.json", out) + return out + + +if __name__ == "__main__": + raise SystemExit(0 if main([])["outcome"]["completed"] else 1) diff --git a/spike/hel857/common.py b/spike/hel857/common.py new file mode 100644 index 0000000..99a9b08 --- /dev/null +++ b/spike/hel857/common.py @@ -0,0 +1,172 @@ +#!/usr/bin/env python3 +"""HEL-857 Mem0 隔离验证共享基础设施。 + +设计要点（对照批准范围）： +- 双 Memory 实例物理隔离：分离向量目录、history.db、派生实体 collection。 +- MEM0_TELEMETRY=False 必须在 import mem0 之前生效；FASTEMBED_CACHE_PATH 指向本卡 + 数据目录，使全部模型资源下载可测量、可哈希、可限额。 +- 嵌入条数计数上限 500（密集+实体），词面（BM25）另列计数；计数器包装在实例上。 +- 真实出站请求一律经 ledger.AccountingTransport 持久扣账（见 ledger.py）； + 本模块只提供注入函数。 +""" +from __future__ import annotations + +import hashlib +import json +import os +import re +import time +from pathlib import Path +from typing import Any, Dict, Optional + +REPO_ROOT = Path(__file__).resolve().parents[2] +DATA_DIR = Path(os.environ.get("HEL857_DATA", REPO_ROOT.parent / "hel857-data")) +MODEL_CACHE = DATA_DIR / "fastembed-cache" + +os.environ["MEM0_TELEMETRY"] = "False" +os.environ.setdefault("FASTEMBED_CACHE_PATH", str(MODEL_CACHE)) + +GATEWAY_BASE_URL = os.environ.get("HEL857_GATEWAY", "http://192.168.200.11:8731/v1") +GATEWAY_MODEL = "halogen-qwen3.8-flash-next" + +LLM_CALL_CAP = 60 # 本卡全部真实模型请求合计上限（含失败/取消/重试） +EMBED_ITEM_CAP = 500 # 本地密集+实体嵌入条数合计上限 +INPUT_CJK_CAP = 6000 # 每请求输入中文字符上限 +OUTPUT_TOKEN_CAP = 1024 # 每请求输出 token 上限 + +PRIV = "private" +PUB = "public" + +CJK_RE = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff]") + + +def count_cjk(text: str) -> int: + return len(CJK_RE.findall(text or "")) + + +class Counters: + """跨脚本进程内计数器；超限抛 RuntimeError 立即停。""" + + def __init__(self) -> None: + self.embed_calls = 0 # embed() 调用次数（单条） + self.embed_items = 0 # 实际嵌入条数（embed_batch 拆条） + self.entity_embed_items = 0 # 实体路径嵌入条数（spaCy 缺席时为 0，如实记录） + self.keyword_calls = 0 # 词面/BM25 处理次数（另列，不占 500 上限） + self.llm_calls = 0 # 真实 LLM 出站次数（与 ledger 对账） + self.llm_failures = 0 + self.consecutive_llm_failures = 0 + self.cap_notes: list[str] = [] + + def check(self) -> None: + if self.embed_items + self.entity_embed_items > EMBED_ITEM_CAP: + raise RuntimeError(f"嵌入条数超限: {self.embed_items + self.entity_embed_items} > {EMBED_ITEM_CAP}") + + def snapshot(self) -> Dict[str, Any]: + return { + "embed_calls": self.embed_calls, + "embed_items_dense": self.embed_items, + "embed_items_entity": self.entity_embed_items, + "embed_items_total": self.embed_items + self.entity_embed_items, + "embed_cap": EMBED_ITEM_CAP, + "keyword_calls": self.keyword_calls, + "llm_calls_real": self.llm_calls, + "llm_failures": self.llm_failures, + "consecutive_llm_failures": self.consecutive_llm_failures, + } + + +COUNTERS = Counters() + + +def mem_config(role: str, *, vec_root: Path, hist_root: Path) -> Dict[str, Any]: + """双实例配置。role in {private, public}。""" + return { + "llm": { + "provider": "openai", + "config": { + "model": GATEWAY_MODEL, + "openai_base_url": GATEWAY_BASE_URL, + "api_key": os.environ.get("HEL857_GATEWAY_KEY", "hel857-local-test"), + "max_tokens": OUTPUT_TOKEN_CAP, + "temperature": 0.0, + }, + }, + "embedder": { + "provider": "fastembed", + "config": {"model": "BAAI/bge-small-zh-v1.5"}, + }, + "vector_store": { + "provider": "qdrant", + "config": { + "path": str(vec_root / f"vec_{role}"), + "collection_name": f"cg_{role}", + "embedding_model_dims": 512, # BAAI/bge-small-zh-v1.5 固有维度 + "on_disk": True, + }, + }, + "history_db_path": str(hist_root / f"mem0_{role}_history.db"), + "version": "v1.1", + } + + +def install_counters(memory) -> None: + """在实例上包装嵌入/词面计数。真实 LLM 出站计数在传输层（ledger）。""" + emb = memory.embedding_model + orig_embed = emb.embed + + def counted_embed(text, memory_action=None): + COUNTERS.embed_calls += 1 + COUNTERS.embed_items += 1 + COUNTERS.check() + return orig_embed(text, memory_action) + + emb.embed = counted_embed # type: ignore[method-assign] + + orig_kw = memory.vector_store.keyword_search + + def counted_kw(*a, **kw): + COUNTERS.keyword_calls += 1 + return orig_kw(*a, **kw) + + memory.vector_store.keyword_search = counted_kw # type: ignore[method-assign] + + +def close_memory(memory) -> None: + """清洁关闭本地 qdrant 客户端，释放目录锁，保证可复制备份。""" + try: + memory.vector_store.client.close() + except Exception: + pass + + +def dir_hash(root: Path) -> str: + """目录内容确定性哈希（相对路径+文件字节）。""" + h = hashlib.sha256() + for p in sorted(root.rglob("*")): + rel = str(p.relative_to(root)) + h.update(rel.encode()) + if p.is_file(): + h.update(p.read_bytes()) + return h.hexdigest() + + +def history_db_hash(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() if path.exists() else "missing" + + +def cjk_len_ok(messages) -> tuple[bool, int, int]: + """返回 (是否合规, 中文字符数, 总字符数)。messages 为 openai 格式列表。""" + joined = "".join(str(m.get("content", "")) for m in messages) + return (count_cjk(joined) <= INPUT_CJK_CAP, count_cjk(joined), len(joined)) + + +def now_ms() -> int: + return int(time.time() * 1000) + + +def write_result(name: str, payload: Dict[str, Any]) -> Path: + out = Path(__file__).parent / "results" + out.mkdir(exist_ok=True) + path = out / name + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8") + return path diff --git a/spike/hel857/fixtures.py b/spike/hel857/fixtures.py new file mode 100644 index 0000000..f6b6d61 --- /dev/null +++ b/spike/hel857/fixtures.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""HEL-857 固定中文合成语料（全部合成，无真实用户/伴侣数据）。 + +A/B 两路径共用同一资料与同一评判标准；私密/公开边界标记集中在此。 +沿用 v2 probe 的"海雾诗集"世界，便于与现状路径证据可比较。 +""" +from __future__ import annotations + +# ---- 私密标记（只在实例 A 出现；任何公开出口不得出现） ---- +PRIV_MARKER = "某某桥" # v4 申请文档指定的独有细节标记 +PRIV_OLD = "她独自去城西的某某桥边把诗集读给海雾听，没有讲给用户" # priv_old +PRIV_HIST_SENTENCES = [ # priv_hist：A 的 history 原始输入 + "（她独白）今天路过某某桥，想起买诗集那个下午的风", + "（她独白）海雾好像更喜欢桥边的光线", +] +PRIV_OTHER_EVENT = "她把私藏的银杏书签夹进了诗集" # 未分享生活事件（F 系列负例） +PRIV_TOLD_EVENT = "她把诗集照片摆在了小木柜上，配了一盏小灯" # 已分享生活事件（正对照） + +# ---- 公开基底语料（实例 B，与现状路径 CORPUS 同源同题） ---- +PUBLIC_CORPUS = [ + # (turn, role, raw)——与 docs/reuse-hel847/probe_recall.py CORPUS 同题扩展 + ("t1", "user", "今天在旧书店淘到一本蓝色封面的诗集，纸页有点受潮的味道，可是我特别喜欢"), + ("t1", "companion", "旧书店的潮味配蓝色封面，像把那个下午整个带回来了。第一首读了吗？"), + ("t2", "user", "给它取名叫海雾，放在床头第二层"), + ("t2", "companion", "海雾。那以后床头第二层就是海边了。"), + ("t3", "user", "加班到九点，路上买了糖炒栗子，一半都是坏的"), + ("t3", "companion", "坏栗子下回留给我先挑。"), + ("t4", "user", "诗集读完了，最喜欢第三首，写房间里的盐"), + ("t4", "companion", "第三首我陪你再读一遍。"), + ("t5", "user", "又买了糖炒栗子，这次是好的"), +] + +# ---- 场景补充语料 ---- +CORRECTION_PAIR = [ + ("c1", "user", "我下周三要去医院体检"), + ("c2", "user", "体检改到周五上午了，别记错"), +] +FACT_FEELING_PAIR = [ + ("f1", "user", "这周五我有一场很重要的面试"), + ("f2", "user", "说实话我紧张得昨晚没睡好"), +] +PROMISE_PAIR = [ + ("p1", "user", "面试结果出来我周五晚上告诉你"), + ("p2", "user", "面试过了！刚才拿到通知了，第一个想跟你说"), +] + +# ---- 查询集（A/B 同查询同评判） ---- +Q_PARAPHRASE = "之前买的那本诗歌选集，封面是什么颜色" # 换说法（核心）：现状词面预期无命中 +Q_PARAPHRASE_TOPIC = "买栗子那次遇到什么倒霉事" # 换说法2：坏的栗子 +Q_EXACT = "诗集" # 词面可命中 +Q_CORRECTION = "体检是哪天" # 改口后应取新说法 +Q_FACT = "这周有什么重要安排" # 事实层 +Q_FEELING = "最近心情怎么样，有什么担心的" # 感受层 +Q_PROMISE = "面试结果答应过我什么" # 承诺状态 + +UNIQUE_DETAIL = "受潮的味道" # 跨会话细节回读判据 +ANSWER_KEY_PARAPHRASE = "蓝色" # 模型实际使用判据 + + +def public_messages(turns=None) -> list[dict]: + turns = turns or "base" + rows = { + "base": PUBLIC_CORPUS, + "correction": CORRECTION_PAIR, + "fact_feeling": FACT_FEELING_PAIR, + "promise": PROMISE_PAIR, + }[turns] + return [{"role": "user" if r == "user" else "assistant", "content": t} + for _, r, t in rows] + + +def private_messages() -> list[dict]: + return [{"role": "assistant", "content": PRIV_OLD}, + {"role": "assistant", "content": PRIV_HIST_SENTENCES[0]}, + {"role": "assistant", "content": PRIV_HIST_SENTENCES[1]}] + + +ALL_PRIVACY_MARKERS = [PRIV_MARKER, PRIV_OLD, *PRIV_HIST_SENTENCES, PRIV_OTHER_EVENT] diff --git a/spike/hel857/ledger.py b/spike/hel857/ledger.py new file mode 100644 index 0000000..f55a7d4 --- /dev/null +++ b/spike/hel857/ledger.py @@ -0,0 +1,254 @@ +#!/usr/bin/env python3 +"""HEL-857 出站前持久扣账：传输层计数 + 跨进程 SQLite 账本。 + +要点（对照批准范围第4条）： +- 扣账发生在网络发送之前（debit BEFORE send），BEGIN IMMEDIATE 原子提交； +- 任何出站尝试（失败、取消、provider 自动重试）都先扣账；第 61 次在发送前被拦； +- 账本跨进程/中断/重跑保留（独立 SQLite 文件，FULL 同步）； +- provider 自动重试显式关闭（openai client max_retries=0），传输层仍逐尝试计数； +- 每请求记录 usage、状态、耗时、输入规模；输入超 6000 中文字符在扣账后发送前拒绝。 +""" +from __future__ import annotations + +import json +import os +import sqlite3 +import threading +import time +from pathlib import Path +from typing import Any, Dict, Optional + +from .common import DATA_DIR, INPUT_CJK_CAP, LLM_CALL_CAP, count_cjk + +LEDGER_PATH = Path(os.environ.get("HEL857_LEDGER", DATA_DIR / "ledger.sqlite3")) + + +class BudgetBlocked(RuntimeError): + """在发送前被拦截（预算耗尽/输入超限）。未产生任何网络出站。""" + + +def _connect() -> sqlite3.Connection: + LEDGER_PATH.parent.mkdir(parents=True, exist_ok=True) + conn = sqlite3.connect(str(LEDGER_PATH), timeout=30.0, isolation_level=None) + conn.execute("PRAGMA journal_mode=WAL") + conn.execute("PRAGMA synchronous=FULL") + conn.execute( + "CREATE TABLE IF NOT EXISTS outbound (" + " id INTEGER PRIMARY KEY AUTOINCREMENT," + " ts TEXT NOT NULL," + " purpose TEXT NOT NULL," + " pid INTEGER NOT NULL," + " status TEXT NOT NULL," # debit | blocked_budget | blocked_input | sent | failed | no_network + " http_status INTEGER," + " latency_ms REAL," + " cjk_chars INTEGER, total_chars INTEGER," + " model TEXT, usage_json TEXT, note TEXT)" + ) + return conn + + +class Ledger: + """跨进程持久出站账本。debit() 在任何网络发送前调用。""" + + def __init__(self, path: Optional[Path] = None): + self.path = Path(path) if path else LEDGER_PATH + self.path.parent.mkdir(parents=True, exist_ok=True) + self._local = threading.local() + self._init_db() + + def _conn(self) -> sqlite3.Connection: + conn = getattr(self._local, "conn", None) + if conn is None: + conn = sqlite3.connect(str(self.path), timeout=30.0, isolation_level=None) + conn.execute("PRAGMA journal_mode=WAL") + conn.execute("PRAGMA synchronous=FULL") + self._local.conn = conn + return conn + + def _init_db(self) -> None: + with self._exclusive() as conn: + conn.execute( + "CREATE TABLE IF NOT EXISTS outbound (" + " id INTEGER PRIMARY KEY AUTOINCREMENT," + " ts TEXT NOT NULL, purpose TEXT NOT NULL, pid INTEGER NOT NULL," + " status TEXT NOT NULL, http_status INTEGER, latency_ms REAL," + " cjk_chars INTEGER, total_chars INTEGER, model TEXT," + " usage_json TEXT, note TEXT)" + ) + + class _Exclusive: + def __init__(self, ledger: "Ledger"): + self.ledger = ledger + + def __enter__(self): + self.conn = self.ledger._conn() + for attempt in range(60): + try: + self.conn.execute("BEGIN IMMEDIATE") + return self.conn + except sqlite3.OperationalError: + time.sleep(0.05 * (attempt + 1)) + raise RuntimeError("ledger BEGIN IMMEDIATE timeout") + + def __exit__(self, exc_type, exc, tb): + if exc_type is None: + self.conn.execute("COMMIT") + else: + self.conn.execute("ROLLBACK") + return False + + def _exclusive(self): + return Ledger._Exclusive(self) + + # ---- 核心协议 ---- + def used(self, purpose: str = "real_llm") -> int: + row = self._conn().execute( + "SELECT COUNT(*) FROM outbound WHERE purpose=? AND status IN ('debit','sent','failed')", + (purpose,), + ).fetchone() + return int(row[0]) + + def debit(self, purpose: str, *, model: str = "", body: bytes = b"", + cjk_chars: int = 0, total_chars: int = 0) -> int: + """发送前持久扣账。超出上限 → 记 blocked_budget 行并抛 BudgetBlocked。 + + blocked 行不计入 used()（它们从未出站），但留审计痕迹。 + """ + with self._exclusive() as conn: + used = conn.execute( + "SELECT COUNT(*) FROM outbound WHERE purpose=? AND status IN ('debit','sent','failed')", + (purpose,), + ).fetchone()[0] + if used >= LLM_CALL_CAP: + conn.execute( + "INSERT INTO outbound(ts,purpose,pid,status,cjk_chars,total_chars,model,note)" + " VALUES(?,?,?,?,?,?,?,?)", + (_now(), purpose, os.getpid(), "blocked_budget", + cjk_chars, total_chars, model, f"used={used} cap={LLM_CALL_CAP}"), + ) + raise BudgetBlocked(f"真实请求预算耗尽: {used}/{LLM_CALL_CAP}（发送前拦截）") + cur = conn.execute( + "INSERT INTO outbound(ts,purpose,pid,status,cjk_chars,total_chars,model,note)" + " VALUES(?,?,?,?,?,?,?,?)", + (_now(), purpose, os.getpid(), "debit", cjk_chars, total_chars, model, ""), + ) + return int(cur.lastrowid) + + def mark(self, row_id: int, status: str, *, http_status: Optional[int] = None, + latency_ms: Optional[float] = None, usage: Optional[Dict[str, Any]] = None, + note: str = "") -> None: + with self._exclusive() as conn: + conn.execute( + "UPDATE outbound SET status=?, http_status=?, latency_ms=?, usage_json=?, note=?" + " WHERE id=?", + (status, http_status, latency_ms, + json.dumps(usage, ensure_ascii=False) if usage else None, note, row_id), + ) + + def rows(self) -> list[dict]: + cur = self._conn().execute( + "SELECT id,ts,purpose,pid,status,http_status,latency_ms,cjk_chars,total_chars," + "model,usage_json,note FROM outbound ORDER BY id" + ) + cols = [d[0] for d in cur.description] + return [dict(zip(cols, r)) for r in cur.fetchall()] + + def summary(self) -> dict: + rows = self.rows() + sent = [r for r in rows if r["status"] in ("debit", "sent", "failed")] + out: Dict[str, Any] = { + "ledger_path": str(self.path), + "total_rows": len(rows), + "debited": len(sent), + "cap": LLM_CALL_CAP, + "remaining": LLM_CALL_CAP - len(sent), + "blocked_budget": sum(1 for r in rows if r["status"] == "blocked_budget"), + "blocked_input": sum(1 for r in rows if r["status"] == "blocked_input"), + "by_status": {}, + "usage_totals": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}, + "rows": rows, + } + for r in rows: + out["by_status"][r["status"]] = out["by_status"].get(r["status"], 0) + 1 + if r["usage_json"]: + try: + u = json.loads(r["usage_json"]) + out["usage_totals"]["prompt_tokens"] += u.get("prompt_tokens") or 0 + out["usage_totals"]["completion_tokens"] += u.get("completion_tokens") or 0 + out["usage_totals"]["total_tokens"] += u.get("total_tokens") or 0 + except Exception: + pass + return out + + +def _now() -> str: + return time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime()) + f".{int(time.time()*1000)%1000:03d}Z" + + +# --------------------------------------------------------------------------- +# 传输层：每个出站尝试（含任何自动重试）都先扣账再发送 +class AccountingTransport: + """httpx 传输层计数器。包装真实或假传输；扣账在任何网络发送之前。""" + + def __init__(self, inner, ledger: Ledger, purpose: str = "real_llm", + enforce_input_cap: bool = True): + self.inner = inner + self.ledger = ledger + self.purpose = purpose + self.enforce_input_cap = enforce_input_cap + + def handle_request(self, request): + body = request.content or b"" + try: + text = body.decode("utf-8", errors="replace") + except Exception: + text = "" + cjk = count_cjk(text) + total = len(text) + if self.enforce_input_cap and cjk > INPUT_CJK_CAP: + self.ledger.mark( + self.ledger.debit(self.purpose, cjk_chars=cjk, total_chars=total), + "blocked_input", note=f"输入中文字符 {cjk} > {INPUT_CJK_CAP}，发送前拒绝", + ) + raise BudgetBlocked(f"输入中文字符 {cjk} > {INPUT_CJK_CAP}") + row = self.ledger.debit(self.purpose, cjk_chars=cjk, total_chars=total) + t0 = time.monotonic() + try: + resp = self.inner.handle_request(request) + except Exception as e: + self.ledger.mark(row, "failed", latency_ms=(time.monotonic() - t0) * 1000, + note=f"transport-error:{type(e).__name__}") + raise + latency = (time.monotonic() - t0) * 1000 + usage = None + try: + resp.read() + data = json.loads(resp.content.decode("utf-8", errors="replace")) + usage = data.get("usage") if isinstance(data, dict) else None + except Exception: + pass + status = "sent" if resp.status_code < 400 else "failed" + self.ledger.mark(row, status, http_status=resp.status_code, + latency_ms=latency, usage=usage) + return resp + + +class FakeTransport: + """假传输：零网络。可编程响应（默认 200 + 假 usage）。""" + + def __init__(self, *, status: int = 200, fail_first: int = 0): + self.status = status + self.fail_first = fail_first + self.attempts = 0 + + def handle_request(self, request): + self.attempts += 1 + import httpx + if self.attempts <= self.fail_first: + return httpx.Response(500, request=request, json={"error": "fake-5xx"}) + payload = { + "id": "fake", "object": "chat.completion", + "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\"memory\": []}"}, "finish_reason": "stop"}], + "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}, + } + return httpx.Response(self.status, request=request, json=payload) diff --git a/spike/hel857/ledger_child.py b/spike/hel857/ledger_child.py new file mode 100644 index 0000000..b28aeb9 --- /dev/null +++ b/spike/hel857/ledger_child.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""T3 子进程：读取既有账本，尝试一次请求，应被拦且零出站。""" +from __future__ import annotations + +import json +import sys +from pathlib import Path + +import httpx + +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + +from spike.hel857.ledger import AccountingTransport, BudgetBlocked, FakeTransport, Ledger # noqa: E402 + + +def main() -> int: + led = Ledger(Path(sys.argv[1])) + fake = FakeTransport() + client = httpx.Client(transport=AccountingTransport(fake, led), base_url="http://fake.invalid") + blocked = False + msg = "" + try: + client.post("/v1/chat/completions", json={"messages": [{"role": "user", "content": "跨进程"}]}) + except BudgetBlocked as e: + blocked = True + msg = str(e) + print(json.dumps({ + "blocked": blocked, + "message": msg, + "fake_attempts": fake.attempts, + "used_seen_by_child": led.used(), + "pid": __import__("os").getpid(), + })) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/spike/hel857/ledger_fake_test.py b/spike/hel857/ledger_fake_test.py new file mode 100644 index 0000000..1c51a23 --- /dev/null +++ b/spike/hel857/ledger_fake_test.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +"""门禁 0：传输层持久扣账，零网络。 + +用假传输证明（对照批准范围第4条）： + T1 第 61 次在发送前被拦（前 60 次含失败也算数，blocked 不产生网络出站）； + T2 失败请求照样扣账（fake 5xx 不回滚额度）； + T3 账本跨进程/中断保留：子进程消耗额度后本进程账本可见且继承； + T4 输入超 6000 中文字符发送前拒绝（记 blocked_input，不算出站）； + T5 openai client 自动重试显式关闭（max_retries=0），传输层仍逐尝试计数。 +""" +from __future__ import annotations + +import json +import subprocess +import sys +from pathlib import Path + +import httpx + +from .common import INPUT_CJK_CAP, LLM_CALL_CAP, write_result +from .ledger import AccountingTransport, BudgetBlocked, FakeTransport, Ledger + + +def _fresh_ledger(path: Path) -> Ledger: + if path.exists(): + path.unlink() + for suffix in ("-wal", "-shm"): + p = Path(str(path) + suffix) + if p.exists(): + p.unlink() + return Ledger(path) + + +def run(tmp: Path) -> dict: + results = {} + led_path = tmp / "ledger_t.sqlite3" + + # T1+T2: 60 次上限，其中前 3 次 fake 5xx（失败也计数），第 61 次发送前被拦 + led = _fresh_ledger(led_path) + fake = FakeTransport(status=200, fail_first=3) + tr = AccountingTransport(fake, led) + client = httpx.Client(transport=tr, base_url="http://fake.invalid") + blocked_at = None + t1e = None + sent = failed = 0 + for i in range(1, 70): + try: + client.post("/v1/chat/completions", json={"messages": [{"role": "user", "content": f"测试{i}"}]}) + sent += 1 + except BudgetBlocked as e: + blocked_at = i + t1e = str(e) + break + failed_rows = led.rows() + failed = sum(1 for r in failed_rows if r["status"] == "failed") + sent_rows = sum(1 for r in failed_rows if r["status"] == "sent") + results["T1_61st_blocked_before_send"] = { + "attempt_blocked_at": blocked_at, + "message": t1e, + "sent": sent_rows, + "failed(fake5xx)": failed, + "fake_transport_attempts": fake.attempts, + "expect": f"第 {LLM_CALL_CAP + 1} 次发送前被拦；假传输仅收到 {LLM_CALL_CAP} 次尝试", + "pass": blocked_at == LLM_CALL_CAP + 1 and fake.attempts == LLM_CALL_CAP + and sent_rows + failed == LLM_CALL_CAP, + } + results["T2_failures_count"] = { + "failed_debited": failed, + "expect": "fake 5xx 的 3 次失败照样扣账，不回滚额度", + "pass": failed == 3, + } + led_summary_before = led.summary() + + # T3: 跨进程。子进程再试 1 次 → 应被拦（60 已用完）；账本继承自本进程写入。 + child = subprocess.run( + [sys.executable, "-m", "spike.hel857.ledger_child", str(led_path)], + capture_output=True, text=True, cwd=str(Path(__file__).resolve().parents[2]), + ) + child_out = {} + try: + child_out = json.loads(child.stdout) + except Exception: + child_out = {"stdout": child.stdout, "stderr": child.stderr, "returncode": child.returncode} + led2 = Ledger(led_path) + results["T3_cross_process"] = { + "child": child_out, + "parent_used_before_child": led_summary_before["debited"], + "ledger_after_child_used": led2.used(), + "expect": "子进程读取同一账本：60 已耗尽 → 其请求在发送前被拦，无新增出站", + "pass": bool(child_out.get("blocked")) and led2.used() == LLM_CALL_CAP + and child_out.get("fake_attempts") == 0, + } + + # T4: 输入超限发送前拒绝 + led_path4 = tmp / "ledger_t4.sqlite3" + led4 = _fresh_ledger(led_path4) + fake4 = FakeTransport() + tr4 = AccountingTransport(fake4, led4) + client4 = httpx.Client(transport=tr4, base_url="http://fake.invalid") + big = "字" * (INPUT_CJK_CAP + 1) + blocked_input = False + try: + client4.post("/v1/chat/completions", json={"messages": [{"role": "user", "content": big}]}) + except BudgetBlocked: + blocked_input = True + rows4 = led4.rows() + results["T4_input_cap"] = { + "blocked_before_send": blocked_input, + "fake_attempts": fake4.attempts, + "rows": [(r["status"], r["cjk_chars"]) for r in rows4], + "expect": f"输入 {INPUT_CJK_CAP + 1} 中文字符 → 发送前拒绝；不计出站、不占真实额度", + "pass": blocked_input and fake4.attempts == 0 + and any(r["status"] == "blocked_input" for r in rows4), + } + + # T5: openai client 自动重试显式关闭 + from openai import OpenAI + led_path5 = tmp / "ledger_t5.sqlite3" + led5 = _fresh_ledger(led_path5) + fake5 = FakeTransport(status=500) + tr5 = AccountingTransport(fake5, led5) + oc = OpenAI(api_key="x", base_url="http://fake.invalid/v1", max_retries=0, + http_client=httpx.Client(transport=tr5)) + api_err = None + try: + oc.chat.completions.create(model="m", messages=[{"role": "user", "content": "重试测试"}]) + except Exception as e: + api_err = type(e).__name__ + results["T5_retry_disabled"] = { + "client_max_retries": oc.max_retries, + "error": api_err, + "transport_attempts": fake5.attempts, + "ledger_debited": led5.used(), + "expect": "max_retries=0：一次调用=一次出站尝试=一次扣账，无隐藏重试", + "pass": oc.max_retries == 0 and fake5.attempts == 1 and led5.used() == 1, + } + + ok = all(v.get("pass") for v in results.values()) + return { + "ok": ok, + "network_outbound": 0, + "results": results, + "ledger_summary_t1": {k: v for k, v in led_summary_before.items() if k != "rows"}, + } + + +def main(argv: list[str]) -> dict: + import tempfile + with tempfile.TemporaryDirectory() as td: + out = run(Path(td)) + write_result("gate0_ledger.json", out) + return out + + +if __name__ == "__main__": + raise SystemExit(0 if main([])["ok"] else 1) diff --git a/spike/hel857/resource_check.py b/spike/hel857/resource_check.py new file mode 100644 index 0000000..6ece621 --- /dev/null +++ b/spike/hel857/resource_check.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""模型资源下载前核对（批准范围第2条）：远端文件清单+大小，合计 ≤500,000,000 字节。 + +fastembed 对 BAAI/bge-small-zh-v1.5 的实际来源是 Qdrant 官方 ONNX 转换镜像 +Qdrant/bge-small-zh-v1.5（model_optimized.onnx），二者为同一模型的 ONNX 形态； +此事实如实记录，不冒充未发生的下载路径。 +""" +from __future__ import annotations + +import json +import urllib.request + +from .common import write_result + +REPOS = ["Qdrant/bge-small-zh-v1.5", "Qdrant/bm25"] +CAP = 500_000_000 + + +def fetch(repo: str) -> dict: + url = f"https://huggingface.co/api/models/{repo}?blobs=true" + with urllib.request.urlopen(url, timeout=30) as r: + d = json.loads(r.read().decode()) + files = {f["rfilename"]: f.get("size") or 0 for f in d["siblings"]} + return {"repo": repo, "files": files, "total_bytes": sum(files.values())} + + +def main(argv: list[str]) -> dict: + manifests = [fetch(r) for r in REPOS] + total = sum(m["total_bytes"] for m in manifests) + out = { + "ok": total <= CAP, + "repos": manifests, + "combined_bytes": total, + "cap_bytes": CAP, + "note": "BAAI/bge-small-zh-v1.5 由 fastembed 解析为 Qdrant 官方 ONNX 镜像（同模型）", + } + write_result("resource_manifest_pre.json", out) + return out + + +if __name__ == "__main__": + raise SystemExit(0 if main([])["ok"] else 1) diff --git a/spike/hel857/results/ab_scenarios.json b/spike/hel857/results/ab_scenarios.json new file mode 100644 index 0000000..2300f52 --- /dev/null +++ b/spike/hel857/results/ab_scenarios.json @@ -0,0 +1,659 @@ +{ + "_mem0_adds": { + "base_corpus": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"ccab5f57-d396-459e-9fee-467411c5c674\", \"memory\": \"User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially" + } + ], + "correction_first": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"624b2c71-2fed-42e9-a0a3-c38ebd877aee\", \"memory\": \"User plans to go to the hospital for a physical examination next Wednesday, around November 4, 2026.\", \"event\": \"ADD\"}]}" + } + ], + "correction_later": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"c0e0abb7-060e-4af7-bd27-8fa772e3d7fd\", \"memory\": \"User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized n" + } + ], + "fact_feeling": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"ee35cf18-07f0-4203-bfea-e24bf49b90b0\", \"memory\": \"User has a very important interview on Friday, around October 30, 2026.\", \"event\": \"ADD\"}, {\"id\": \"fe1e55d1-daf3-4ec7-996e-fac65e" + } + ], + "promise": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"ce7b3056-507a-4dc1-b838-0f45f9795000\", \"memory\": \"User said they would tell the assistant the interview result on Friday evening.\", \"event\": \"ADD\"}, {\"id\": \"1be6b9ca-68ac-47a7-bb9" + } + ] + }, + "S1_verbatim_retention": { + "baseline_raw_in_chat_message": false, + "mem0_raw_in_history_db": true, + "expect": "两侧原文都留存：现状在 chat_message/mem_episodic.raw；Mem0 在 history.db messages（派生副本）", + "pass": true + }, + "S2_cross_session_detail": { + "retrieval": { + "baseline": { + "hit": true, + "detail_in_context": false, + "detail_in_reread": false + }, + "mem0": { + "hit": true, + "detail_in_context": true, + "memories": [ + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room.", + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside." + ] + } + }, + "model_use": { + "baseline_answer": "资料里只提到你买到一本诗集且很喜欢，没有记录那天的其他细节。", + "mem0_answer": "记得，你是在2026年10月25日在一家旧书店找到那本蓝色封面的诗集，注意到书页有潮湿的气味，并且特别喜欢它。", + "baseline_detail_used": false, + "mem0_detail_used": false + }, + "expect": "两侧检索命中；细节是否进入注入块与模型实际使用分列（现状靠回读，Mem0 靠提取保真）", + "pass": true + }, + "S3_paraphrase_recall": { + "query1": "之前买的那本诗歌选集，封面是什么颜色", + "baseline": { + "hits": 0, + "mode": "none", + "target_hit": false + }, + "mem0": { + "hits": 11, + "memories": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "target_hit": true + }, + "query2": "买栗子那次遇到什么倒霉事", + "baseline_q2_hits": 0, + "mem0_q2": { + "hits": 11, + "memories": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside.", + "User bought candied chestnuts again after the earlier bad batch, and this time they were good.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it." + ], + "target_hit": true + }, + "model_use": { + "baseline_answer": "不知道。资料中没有关于之前购买的诗歌选集及其封面颜色的信息。", + "mem0_answer": "蓝色。", + "mem0_answer_has_color": true + }, + "expect": "换说法召回 Mem0 严格优于现状（现状词面无命中是其已证缺口）", + "pass": true + }, + "S4_correction": { + "baseline": { + "keyword_hits": [ + "c1", + "c2" + ], + "natural_lang_hits": 0, + "natural_lang_mode": "none", + "both_kept": true + }, + "mem0": { + "retrieved": [ + "User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized not to record it wrong.", + "User worked overtime until 9 PM on 2026-10-25 and bought candied chestnuts on the way home, but half of them were bad.", + "User was so nervous about the important Friday interview that they did not sleep well the night before, around October 24, 2026.", + "User said they would tell the assistant the interview result on Friday evening.", + "User plans to go to the hospital for a physical examination next Wednesday, around November 4, 2026.", + "User has a very important interview on Friday, around October 30, 2026.", + "User passed the important interview and received the notification, and said the assistant was the first person they wanted to tell.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User bought candied chestnuts again after the earlier bad batch, and this time they were good.", + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "has_new_friday": true, + "has_old_wednesday": true, + "infer_is_add_only_both_entries": true, + "our_update": { + "updated": true + }, + "history_update_rows": [ + [ + "User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized not to record it wrong.", + "User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized not to record it wrong.（改期确认：体检在周五上午）", + "UPDATE" + ] + ] + }, + "model_use": { + "answer": "体检改到了周五上午，大约是2026年10月30日。", + "friday_used": true + }, + "expect": "稍后改口时 infer 为 ADD-only（新旧并存，v4 事实）；我方显式 update 编排改口留 prev→new 史；现状关键词检索不退化，自然语言查询维持其已证词面缺口", + "pass": true + }, + "S5_fact_feeling_separation": { + "baseline": { + "fact_kw_hits": [ + "p2", + "p1", + "f2", + "f1" + ], + "feeling_kw_hits": [ + "f2" + ], + "fact_nl_hits": 0, + "feeling_nl_hits": 0 + }, + "mem0": { + "fact_memories": [ + "User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized not to record it wrong.（改期确认：体检在周五上午）", + "User plans to go to the hospital for a physical examination next Wednesday, around November 4, 2026.", + "User was so nervous about the important Friday interview that they did not sleep well the night before, around October 24, 2026." + ], + "feeling_memories": [ + "User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized not to record it wrong.（改期确认：体检在周五上午）", + "User was so nervous about the important Friday interview that they did not sleep well the night before, around October 24, 2026.", + "User said they would tell the assistant the interview result on Friday evening." + ], + "fact_has_interview": true, + "feeling_has_tension": true + }, + "expect": "事实查询召回面试安排、感受查询召回紧张失眠；两层独立存在；现状关键词形态不退化，自然语言查询维持其已证缺口", + "pass": true + }, + "S6_promise_status": { + "mem0": { + "retrieved": [ + "User passed the important interview and received the notification, and said the assistant was the first person they wanted to tell.", + "User said they would tell the assistant the interview result on Friday evening.", + "User changed their hospital physical examination from next Wednesday to Friday morning, around October 30, 2026, and emphasized not to record it wrong.（改期确认：体检在周五上午）", + "User has a very important interview on Friday, around October 30, 2026.", + "User plans to go to the hospital for a physical examination next Wednesday, around November 4, 2026.", + "User was so nervous about the important Friday interview that they did not sleep well the night before, around October 24, 2026.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room.", + "User worked overtime until 9 PM on 2026-10-25 and bought candied chestnuts on the way home, but half of them were bad.", + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside.", + "User bought candied chestnuts again after the earlier bad batch, and this time they were good." + ], + "status_orchestration": "resolved", + "history_events": [ + "ADD", + "ADD", + "ADD", + "ADD", + "ADD", + "ADD", + "UPDATE", + "UPDATE", + "ADD", + "ADD", + "ADD", + "ADD", + "ADD" + ] + }, + "model_use": { + "answer": "不知道。" + }, + "baseline_note": "现状路径承诺埋在聊天行内，无独立承诺对象（v2 已记录缺口）", + "expect": "承诺以独立条目存在；我方编排显式 update 置 resolved 且 history 留痕", + "pass": true + }, + "S7_source_reread": { + "baseline": { + "hit_turn": "t4", + "reread_recovered_own_raw": true + }, + "mem0": { + "retrieved_memory": "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "raw_recoverable_from_history": true + }, + "expect": "从检索命中可回查原始来源：现状带门回读恢复该行原文；Mem0 命中是压缩事实，原文在 history.db", + "pass": true + }, + "S8_process_restart": { + "child": { + "ok": true, + "items": 12 + }, + "after_restart_hits": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside.", + "新书架到了，把海雾旁边空出第二层", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it." + ], + "after_restart_has_new_shelf": true, + "expect": "子进程写入 → 新进程检索可见（真实进程重启，非同进程重开）", + "pass": true + }, + "S9_backup_restore": { + "restored_hits": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by their bedside.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "restored_target_hit": true, + "expect": "公开实例完整备份→恢复→换说法召回仍命中", + "pass": true + }, + "_ledger_summary": { + "ledger_path": "/home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/hel857-data/ledger.sqlite3", + "total_rows": 26, + "debited": 26, + "cap": 60, + "remaining": 34, + "blocked_budget": 0, + "blocked_input": 0, + "by_status": { + "sent": 26 + }, + "usage_totals": { + "prompt_tokens": 114183, + "completion_tokens": 2854, + "total_tokens": 117037 + } + }, + "_ledger_rows": [ + { + "id": 1, + "ts": "2026-10-25T15:07:24.859Z", + "purpose": "real_llm", + "pid": 962164, + "status": "sent", + "http_status": 200, + "latency_ms": 36837.83321798546, + "cjk_chars": 9, + "total_chars": 234, + "model": "", + "usage_json": "{\"prompt_tokens\": 68, \"completion_tokens\": 38, \"total_tokens\": 106, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 2, + "ts": "2026-10-25T15:08:24.380Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 13136.250651004957, + "cjk_chars": 159, + "total_chars": 35583, + "model": "", + "usage_json": "{\"prompt_tokens\": 8397, \"completion_tokens\": 367, \"total_tokens\": 8764, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 3, + "ts": "2026-10-25T15:08:37.661Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 3136.0514060070273, + "cjk_chars": 183, + "total_chars": 36343, + "model": "", + "usage_json": "{\"prompt_tokens\": 8613, \"completion_tokens\": 103, \"total_tokens\": 8716, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 4, + "ts": "2026-10-25T15:08:40.813Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 3244.8146409878973, + "cjk_chars": 196, + "total_chars": 36538, + "model": "", + "usage_json": "{\"prompt_tokens\": 8659, \"completion_tokens\": 102, \"total_tokens\": 8761, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 5, + "ts": "2026-10-25T15:08:44.071Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 3322.7964699908625, + "cjk_chars": 201, + "total_chars": 36688, + "model": "", + "usage_json": "{\"prompt_tokens\": 8693, \"completion_tokens\": 111, \"total_tokens\": 8804, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 6, + "ts": "2026-10-25T15:09:07.136Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 7827.591861016117, + "cjk_chars": 159, + "total_chars": 35583, + "model": "", + "usage_json": "{\"prompt_tokens\": 8397, \"completion_tokens\": 367, \"total_tokens\": 8764, \"prompt_tokens_details\": {\"cached_tokens\": 8397}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 7, + "ts": "2026-10-25T15:09:15.110Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2505.500915023731, + "cjk_chars": 183, + "total_chars": 36343, + "model": "", + "usage_json": "{\"prompt_tokens\": 8613, \"completion_tokens\": 103, \"total_tokens\": 8716, \"prompt_tokens_details\": {\"cached_tokens\": 8613}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 8, + "ts": "2026-10-25T15:09:17.637Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2574.080035003135, + "cjk_chars": 196, + "total_chars": 36538, + "model": "", + "usage_json": "{\"prompt_tokens\": 8659, \"completion_tokens\": 102, \"total_tokens\": 8761, \"prompt_tokens_details\": {\"cached_tokens\": 8659}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 9, + "ts": "2026-10-25T15:09:20.229Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2634.5287489821203, + "cjk_chars": 201, + "total_chars": 36688, + "model": "", + "usage_json": "{\"prompt_tokens\": 8693, \"completion_tokens\": 111, \"total_tokens\": 8804, \"prompt_tokens_details\": {\"cached_tokens\": 8693}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 10, + "ts": "2026-10-25T15:09:22.879Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1776.1196209758054, + "cjk_chars": 99, + "total_chars": 318, + "model": "", + "usage_json": "{\"prompt_tokens\": 141, \"completion_tokens\": 46, \"total_tokens\": 187, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 11, + "ts": "2026-10-25T15:09:24.662Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2011.4145739935338, + "cjk_chars": 70, + "total_chars": 730, + "model": "", + "usage_json": "{\"prompt_tokens\": 212, \"completion_tokens\": 64, \"total_tokens\": 276, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 12, + "ts": "2026-10-25T15:09:26.691Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1673.8362540199887, + "cjk_chars": 62, + "total_chars": 224, + "model": "", + "usage_json": "{\"prompt_tokens\": 97, \"completion_tokens\": 43, \"total_tokens\": 140, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 13, + "ts": "2026-10-25T15:09:28.372Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1389.9075649969745, + "cjk_chars": 74, + "total_chars": 806, + "model": "", + "usage_json": "{\"prompt_tokens\": 234, \"completion_tokens\": 30, \"total_tokens\": 264, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 14, + "ts": "2026-10-25T15:09:29.772Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1531.5391600015573, + "cjk_chars": 60, + "total_chars": 741, + "model": "", + "usage_json": "{\"prompt_tokens\": 218, \"completion_tokens\": 41, \"total_tokens\": 259, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 15, + "ts": "2026-10-25T15:09:31.321Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1737.3874240147416, + "cjk_chars": 65, + "total_chars": 767, + "model": "", + "usage_json": "{\"prompt_tokens\": 220, \"completion_tokens\": 51, \"total_tokens\": 271, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 16, + "ts": "2026-10-25T15:15:32.279Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 8207.9729049874, + "cjk_chars": 159, + "total_chars": 35583, + "model": "", + "usage_json": "{\"prompt_tokens\": 8397, \"completion_tokens\": 367, \"total_tokens\": 8764, \"prompt_tokens_details\": {\"cached_tokens\": 8384}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 17, + "ts": "2026-10-25T15:15:40.635Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 3093.9025889965706, + "cjk_chars": 171, + "total_chars": 36324, + "model": "", + "usage_json": "{\"prompt_tokens\": 8599, \"completion_tokens\": 103, \"total_tokens\": 8702, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 18, + "ts": "2026-10-25T15:15:43.742Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 3610.3608690027613, + "cjk_chars": 183, + "total_chars": 36478, + "model": "", + "usage_json": "{\"prompt_tokens\": 8649, \"completion_tokens\": 119, \"total_tokens\": 8768, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 19, + "ts": "2026-10-25T15:15:47.370Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 4439.633896981832, + "cjk_chars": 196, + "total_chars": 36682, + "model": "", + "usage_json": "{\"prompt_tokens\": 8703, \"completion_tokens\": 168, \"total_tokens\": 8871, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 20, + "ts": "2026-10-25T15:15:51.828Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 4312.582710001152, + "cjk_chars": 201, + "total_chars": 36946, + "model": "", + "usage_json": "{\"prompt_tokens\": 8776, \"completion_tokens\": 157, \"total_tokens\": 8933, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 21, + "ts": "2026-10-25T15:15:56.159Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 1611.3608260056935, + "cjk_chars": 99, + "total_chars": 318, + "model": "", + "usage_json": "{\"prompt_tokens\": 141, \"completion_tokens\": 46, \"total_tokens\": 187, \"prompt_tokens_details\": {\"cached_tokens\": 128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 22, + "ts": "2026-10-25T15:15:57.775Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 1996.8121710116975, + "cjk_chars": 70, + "total_chars": 741, + "model": "", + "usage_json": "{\"prompt_tokens\": 220, \"completion_tokens\": 65, \"total_tokens\": 285, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 23, + "ts": "2026-10-25T15:15:59.790Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 1669.3828540155664, + "cjk_chars": 62, + "total_chars": 224, + "model": "", + "usage_json": "{\"prompt_tokens\": 97, \"completion_tokens\": 43, \"total_tokens\": 140, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 24, + "ts": "2026-10-25T15:16:01.464Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 1389.282093005022, + "cjk_chars": 74, + "total_chars": 818, + "model": "", + "usage_json": "{\"prompt_tokens\": 241, \"completion_tokens\": 30, \"total_tokens\": 271, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 25, + "ts": "2026-10-25T15:16:02.871Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 1695.586154004559, + "cjk_chars": 60, + "total_chars": 709, + "model": "", + "usage_json": "{\"prompt_tokens\": 216, \"completion_tokens\": 47, \"total_tokens\": 263, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 26, + "ts": "2026-10-25T15:16:04.584Z", + "purpose": "real_llm", + "pid": 964542, + "status": "sent", + "http_status": 200, + "latency_ms": 1311.8805270059966, + "cjk_chars": 76, + "total_chars": 786, + "model": "", + "usage_json": "{\"prompt_tokens\": 230, \"completion_tokens\": 30, \"total_tokens\": 260, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + } + ], + "_counters": { + "embed_calls": 28, + "embed_items_dense": 28, + "embed_items_entity": 0, + "embed_items_total": 28, + "embed_cap": 500, + "keyword_calls": 10, + "llm_calls_real": 0, + "llm_failures": 0, + "consecutive_llm_failures": 0 + }, + "_real_calls_used": 26, + "outcome": { + "completed": true, + "mem0_paraphrase_strictly_better": true, + "others_no_regression": true, + "budget_respected": true, + "verdict": "换说法召回 Mem0 严格优于现状；其他既有成功项未退化", + "headline_findings": { + "extraction_language": "真实提取将中文输入提取为英文记忆（mem0 默认英文提取提示词）；换说法召回经多语中文嵌入仍命中，模型实际使用检查中文问答答出\"蓝色\"。产品接线需 custom_instructions 定制中文提示词或接受双语存储——本卡未改配置，如实记录。", + "same_batch_correction": "run1（账本保留）：改口消息与原消息同批 add 时，提取自动合并出一条已更正记忆；run2 改两批后还原\"稍后改口\"：infer 为 ADD-only 新旧并存，需我方编排 update。", + "bm25_chinese": "Qdrant/bm25 对中文整段哈希无分词（门禁1 Q0a 记录）；提取为英文后，中文查询与英文记忆在词面通道亦不交叉——词面通道对中文实际不可用，召回全靠密集语义。" + } + } +} \ No newline at end of file diff --git a/spike/hel857/results/ab_scenarios_run1.json b/spike/hel857/results/ab_scenarios_run1.json new file mode 100644 index 0000000..bb5b309 --- /dev/null +++ b/spike/hel857/results/ab_scenarios_run1.json @@ -0,0 +1,460 @@ +{ + "_mem0_adds": { + "base_corpus": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"39cba7bc-8570-4016-af9d-99de19387456\", \"memory\": \"User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially" + } + ], + "correction": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"267fc0a3-be37-4f85-bdd5-63e606f65429\", \"memory\": \"User initially planned to go to the hospital for a physical examination on Wednesday, but the appointment was later changed to Fr" + } + ], + "fact_feeling": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"ccf1ab02-b450-498e-8ec6-262d26312082\", \"memory\": \"User has a very important interview on Friday, and they were so nervous that they did not sleep well the night before.\", \"event\":" + } + ], + "promise": [ + { + "event": "ERROR", + "memory": "{\"results\": [{\"id\": \"7998e82c-8d19-4f50-8af4-ce9ef3aad096\", \"memory\": \"User passed their important interview and received the notification on 2026-10-25, saying they wanted to tell the assistant first" + } + ] + }, + "S1_verbatim_retention": { + "baseline_raw_in_chat_message": false, + "mem0_raw_in_history_db": true, + "expect": "两侧原文都留存：现状在 chat_message/mem_episodic.raw；Mem0 在 history.db messages（派生副本）", + "pass": true + }, + "S2_cross_session_detail": { + "retrieval": { + "baseline": { + "hit": true, + "detail_in_context": false, + "detail_in_reread": false + }, + "mem0": { + "hit": true, + "detail_in_context": false, + "memories": [ + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room.", + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside." + ] + } + }, + "model_use": { + "baseline_answer": "资料里只提到你买到一本诗集且很喜欢，没有记录那天的其他细节。", + "mem0_answer": "记得。你是在2026年10月25日在一家旧书店找到那本蓝色封面的诗集，书页有潮湿的气味，你特别喜欢它。", + "baseline_detail_used": false, + "mem0_detail_used": false + }, + "expect": "两侧检索命中；细节是否进入注入块与模型实际使用分列（现状靠回读，Mem0 靠提取保真）", + "pass": true + }, + "S3_paraphrase_recall": { + "query1": "之前买的那本诗歌选集，封面是什么颜色", + "baseline": { + "hits": 0, + "mode": "none", + "target_hit": false + }, + "mem0": { + "hits": 8, + "memories": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "target_hit": false + }, + "query2": "买栗子那次遇到什么倒霉事", + "baseline_q2_hits": 0, + "mem0_q2": { + "hits": 8, + "memories": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside.", + "User bought candied chestnuts again after the earlier bad batch, and this time they were good.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it." + ], + "target_hit": false + }, + "model_use": { + "baseline_answer": "不知道。资料中没有关于之前购买的诗歌选集及其封面颜色的信息。", + "mem0_answer": "蓝色。", + "mem0_answer_has_color": true + }, + "expect": "换说法召回 Mem0 严格优于现状（现状词面无命中是其已证缺口）", + "pass": false + }, + "S4_correction": { + "baseline": { + "hits": 0, + "order_latest_first": [], + "both_kept": false + }, + "mem0": { + "retrieved": [ + "User passed their important interview and received the notification on 2026-10-25, saying they wanted to tell the assistant first.", + "User worked overtime until 9 PM on 2026-10-25 and bought candied chestnuts on the way home, but half of them were bad.", + "User initially planned to go to the hospital for a physical examination on Wednesday, but the appointment was later changed to Friday morning.", + "User has a very important interview on Friday, and they were so nervous that they did not sleep well the night before.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User bought candied chestnuts again after the earlier bad batch, and this time they were good.", + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "has_new": false, + "has_old": false, + "our_update": null, + "history_update_rows": [] + }, + "model_use": { + "answer": "体检最初计划是周三，但后来改到了周五上午。", + "friday_used": true + }, + "expect": "infer 为 ADD-only（新旧并存，v4 事实）；我方显式 update 编排改口并留 prev→new 史；现状依赖排序取新，两条均留存（不改写过去）", + "pass": false + }, + "S5_fact_feeling_separation": { + "baseline": { + "fact_hits": [], + "feeling_hits": [] + }, + "mem0": { + "fact_memories": [ + "User initially planned to go to the hospital for a physical examination on Wednesday, but the appointment was later changed to Friday morning.", + "User has a very important interview on Friday, and they were so nervous that they did not sleep well the night before.", + "User passed their important interview and received the notification on 2026-10-25, saying they wanted to tell the assistant first." + ], + "feeling_memories": [ + "User has a very important interview on Friday, and they were so nervous that they did not sleep well the night before.", + "User worked overtime until 9 PM on 2026-10-25 and bought candied chestnuts on the way home, but half of them were bad.", + "User initially planned to go to the hospital for a physical examination on Wednesday, but the appointment was later changed to Friday morning." + ], + "fact_has_interview": false, + "feeling_has_tension": false + }, + "expect": "事实查询召回面试安排、感受查询召回紧张失眠；两层独立存在", + "pass": false + }, + "S6_promise_status": { + "mem0": { + "retrieved": [ + "User passed their important interview and received the notification on 2026-10-25, saying they wanted to tell the assistant first.", + "User initially planned to go to the hospital for a physical examination on Wednesday, but the appointment was later changed to Friday morning.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User has a very important interview on Friday, and they were so nervous that they did not sleep well the night before.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room.", + "User worked overtime until 9 PM on 2026-10-25 and bought candied chestnuts on the way home, but half of them were bad.", + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside.", + "User bought candied chestnuts again after the earlier bad batch, and this time they were good." + ], + "status_orchestration": "resolved", + "history_events": [ + "ADD", + "ADD", + "ADD", + "ADD", + "ADD", + "ADD", + "UPDATE", + "ADD", + "ADD" + ] + }, + "model_use": { + "answer": "不知道。资料只说用户通过重要面试并想先告诉助手，没有提到面试结果答应过什么。" + }, + "baseline_note": "现状路径承诺埋在聊天行内，无独立承诺对象（v2 已记录缺口）", + "expect": "承诺以独立条目存在；我方编排显式 update 置 resolved 且 history 留痕", + "pass": true + }, + "S7_source_reread": { + "baseline": { + "reread_recovered_raw": false + }, + "mem0": { + "retrieved_memory": "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "raw_recoverable_from_history": true + }, + "expect": "从检索命中可回查原始来源：现状带门回读恢复原文；Mem0 命中是压缩事实，原文在 history.db", + "pass": false + }, + "S8_process_restart": { + "child": { + "stdout": "", + "stderr": "Traceback (most recent call last):\n File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n return _run_code(code, main_globals, None,\n File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n exec(code, run_globals)\n File \"/home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/CyberGril/spike/hel857/ab_child.py\", line 29, in \n raise SystemExit(main())\n File \"/home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/CyberGril/spike/hel857/ab_child.py\", line 17, in main\n m = Memory.from_config(mem_config(PUB, vec_root=root, hist_root=root))\nNameError: name 'PUB' is not defined\n", + "returncode": 1 + }, + "after_restart_hits": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "expect": "子进程写入 → 新进程检索可见（真实进程重启，非同进程重开）", + "pass": false + }, + "S9_backup_restore": { + "restored_hits": [ + "User named the blue-covered poetry collection 海雾 and placed it on the second shelf by the bedside.", + "User found a blue-covered poetry collection at an old bookstore on 2026-10-25, noticed the pages had a damp smell, and especially liked it.", + "User finished reading the poetry collection and liked the third poem the most, which is about salt in a room." + ], + "expect": "公开实例完整备份→恢复→换说法召回仍命中", + "pass": false + }, + "_ledger_summary": { + "ledger_path": "/home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/hel857-data/ledger.sqlite3", + "total_rows": 15, + "debited": 15, + "cap": 60, + "remaining": 45, + "blocked_budget": 0, + "blocked_input": 0, + "by_status": { + "sent": 15 + }, + "usage_totals": { + "prompt_tokens": 69914, + "completion_tokens": 1679, + "total_tokens": 71593 + } + }, + "_ledger_rows": [ + { + "id": 1, + "ts": "2026-10-25T15:07:24.859Z", + "purpose": "real_llm", + "pid": 962164, + "status": "sent", + "http_status": 200, + "latency_ms": 36837.83321798546, + "cjk_chars": 9, + "total_chars": 234, + "model": "", + "usage_json": "{\"prompt_tokens\": 68, \"completion_tokens\": 38, \"total_tokens\": 106, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 2, + "ts": "2026-10-25T15:08:24.380Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 13136.250651004957, + "cjk_chars": 159, + "total_chars": 35583, + "model": "", + "usage_json": "{\"prompt_tokens\": 8397, \"completion_tokens\": 367, \"total_tokens\": 8764, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 3, + "ts": "2026-10-25T15:08:37.661Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 3136.0514060070273, + "cjk_chars": 183, + "total_chars": 36343, + "model": "", + "usage_json": "{\"prompt_tokens\": 8613, \"completion_tokens\": 103, \"total_tokens\": 8716, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 4, + "ts": "2026-10-25T15:08:40.813Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 3244.8146409878973, + "cjk_chars": 196, + "total_chars": 36538, + "model": "", + "usage_json": "{\"prompt_tokens\": 8659, \"completion_tokens\": 102, \"total_tokens\": 8761, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 5, + "ts": "2026-10-25T15:08:44.071Z", + "purpose": "real_llm", + "pid": 962429, + "status": "sent", + "http_status": 200, + "latency_ms": 3322.7964699908625, + "cjk_chars": 201, + "total_chars": 36688, + "model": "", + "usage_json": "{\"prompt_tokens\": 8693, \"completion_tokens\": 111, \"total_tokens\": 8804, \"prompt_tokens_details\": {\"cached_tokens\": 8128}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 6, + "ts": "2026-10-25T15:09:07.136Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 7827.591861016117, + "cjk_chars": 159, + "total_chars": 35583, + "model": "", + "usage_json": "{\"prompt_tokens\": 8397, \"completion_tokens\": 367, \"total_tokens\": 8764, \"prompt_tokens_details\": {\"cached_tokens\": 8397}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 7, + "ts": "2026-10-25T15:09:15.110Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2505.500915023731, + "cjk_chars": 183, + "total_chars": 36343, + "model": "", + "usage_json": "{\"prompt_tokens\": 8613, \"completion_tokens\": 103, \"total_tokens\": 8716, \"prompt_tokens_details\": {\"cached_tokens\": 8613}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 8, + "ts": "2026-10-25T15:09:17.637Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2574.080035003135, + "cjk_chars": 196, + "total_chars": 36538, + "model": "", + "usage_json": "{\"prompt_tokens\": 8659, \"completion_tokens\": 102, \"total_tokens\": 8761, \"prompt_tokens_details\": {\"cached_tokens\": 8659}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 9, + "ts": "2026-10-25T15:09:20.229Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2634.5287489821203, + "cjk_chars": 201, + "total_chars": 36688, + "model": "", + "usage_json": "{\"prompt_tokens\": 8693, \"completion_tokens\": 111, \"total_tokens\": 8804, \"prompt_tokens_details\": {\"cached_tokens\": 8693}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 10, + "ts": "2026-10-25T15:09:22.879Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1776.1196209758054, + "cjk_chars": 99, + "total_chars": 318, + "model": "", + "usage_json": "{\"prompt_tokens\": 141, \"completion_tokens\": 46, \"total_tokens\": 187, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 11, + "ts": "2026-10-25T15:09:24.662Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 2011.4145739935338, + "cjk_chars": 70, + "total_chars": 730, + "model": "", + "usage_json": "{\"prompt_tokens\": 212, \"completion_tokens\": 64, \"total_tokens\": 276, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 12, + "ts": "2026-10-25T15:09:26.691Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1673.8362540199887, + "cjk_chars": 62, + "total_chars": 224, + "model": "", + "usage_json": "{\"prompt_tokens\": 97, \"completion_tokens\": 43, \"total_tokens\": 140, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 13, + "ts": "2026-10-25T15:09:28.372Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1389.9075649969745, + "cjk_chars": 74, + "total_chars": 806, + "model": "", + "usage_json": "{\"prompt_tokens\": 234, \"completion_tokens\": 30, \"total_tokens\": 264, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 14, + "ts": "2026-10-25T15:09:29.772Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1531.5391600015573, + "cjk_chars": 60, + "total_chars": 741, + "model": "", + "usage_json": "{\"prompt_tokens\": 218, \"completion_tokens\": 41, \"total_tokens\": 259, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + }, + { + "id": 15, + "ts": "2026-10-25T15:09:31.321Z", + "purpose": "real_llm", + "pid": 962677, + "status": "sent", + "http_status": 200, + "latency_ms": 1737.3874240147416, + "cjk_chars": 65, + "total_chars": 767, + "model": "", + "usage_json": "{\"prompt_tokens\": 220, \"completion_tokens\": 51, \"total_tokens\": 271, \"prompt_tokens_details\": {\"cached_tokens\": 64}, \"completion_tokens_details\": {\"reasoning_tokens\": 26, \"reasoning_closed_at\": 1, \"reasoning_closed_by\": \"answer_room\"}}", + "note": "" + } + ], + "_counters": { + "embed_calls": 23, + "embed_items_dense": 23, + "embed_items_entity": 0, + "embed_items_total": 23, + "embed_cap": 500, + "keyword_calls": 10, + "llm_calls_real": 0, + "llm_failures": 0, + "consecutive_llm_failures": 0 + }, + "_real_calls_used": 15, + "outcome": { + "completed": true, + "mem0_paraphrase_strictly_better": false, + "others_no_regression": false, + "budget_respected": true, + "verdict": "存在未达标项，见逐场景记录" + } +} \ No newline at end of file diff --git a/spike/hel857/results/gate0_ledger.json b/spike/hel857/results/gate0_ledger.json new file mode 100644 index 0000000..a340e15 --- /dev/null +++ b/spike/hel857/results/gate0_ledger.json @@ -0,0 +1,71 @@ +{ + "ok": true, + "network_outbound": 0, + "results": { + "T1_61st_blocked_before_send": { + "attempt_blocked_at": 61, + "message": "真实请求预算耗尽: 60/60（发送前拦截）", + "sent": 57, + "failed(fake5xx)": 3, + "fake_transport_attempts": 60, + "expect": "第 61 次发送前被拦；假传输仅收到 60 次尝试", + "pass": true + }, + "T2_failures_count": { + "failed_debited": 3, + "expect": "fake 5xx 的 3 次失败照样扣账，不回滚额度", + "pass": true + }, + "T3_cross_process": { + "child": { + "blocked": true, + "message": "真实请求预算耗尽: 60/60（发送前拦截）", + "fake_attempts": 0, + "used_seen_by_child": 60, + "pid": 954674 + }, + "parent_used_before_child": 60, + "ledger_after_child_used": 60, + "expect": "子进程读取同一账本：60 已耗尽 → 其请求在发送前被拦，无新增出站", + "pass": true + }, + "T4_input_cap": { + "blocked_before_send": true, + "fake_attempts": 0, + "rows": [ + [ + "blocked_input", + 6001 + ] + ], + "expect": "输入 6001 中文字符 → 发送前拒绝；不计出站、不占真实额度", + "pass": true + }, + "T5_retry_disabled": { + "client_max_retries": 0, + "error": "InternalServerError", + "transport_attempts": 1, + "ledger_debited": 1, + "expect": "max_retries=0：一次调用=一次出站尝试=一次扣账，无隐藏重试", + "pass": true + } + }, + "ledger_summary_t1": { + "ledger_path": "/tmp/multica-task-1816511421/tmpm5wijcww/ledger_t.sqlite3", + "total_rows": 60, + "debited": 60, + "cap": 60, + "remaining": 0, + "blocked_budget": 0, + "blocked_input": 0, + "by_status": { + "failed": 3, + "sent": 57 + }, + "usage_totals": { + "prompt_tokens": 570, + "completion_tokens": 285, + "total_tokens": 855 + } + } +} \ No newline at end of file diff --git a/spike/hel857/results/gate1_backend.json b/spike/hel857/results/gate1_backend.json new file mode 100644 index 0000000..ec3dced --- /dev/null +++ b/spike/hel857/results/gate1_backend.json @@ -0,0 +1,645 @@ +{ + "ok": true, + "network_outbound": 0, + "results": { + "Q0b_local_rw_filter": { + "u1_items": 3, + "u2_items": 1, + "expect": "本地路径可写入；user_id 过滤为合取隔离，u1 看不到 u2 的记忆", + "pass": true + }, + "Q0a_keyword_search": { + "has_method": true, + "en_phrase_hits": [ + [ + "d5db1aa1-ebd8-41cb-a2d8-6d8e67d4612b", + 6.732 + ] + ], + "zh_subword_hits": 0, + "finding_zh": "Qdrant/bm25 对中文按整段（空格/标点切分）哈希成单 token；spaCy 缺席时 lemmatize_for_bm25 原样返回，无中文分词 → 中文子词查询在词面通道不命中（换说法召回只能依赖密集语义通道）", + "expect": "keyword_search 机制可用（英文 token BM25 打分命中、带过滤）；中文分词局限如实记录", + "pass": true + }, + "Q0b_semantic_search": { + "hits": [ + "99af59f1-2f12-4e7f-8822-5dfa7a57c6b9", + "d5db1aa1-ebd8-41cb-a2d8-6d8e67d4612b", + "c0ca71c0-3779-4d62-a48d-c2d3e40c154f" + ], + "expect": "本地 bge-small-zh-v1.5 语义检索可用（零外部嵌入 API）", + "pass": true + }, + "Q0e_collections": { + "collections": [ + "cg_test" + ], + "expect": "本地实例仅主 collection（实体 collection 由实体路径懒创建；spaCy 缺席时为空集），无遥测 collection", + "pass": true + }, + "Q0c_restart_subprocess": { + "child": { + "restarted_ok": true, + "items": 3, + "semantic_hits": 3, + "first": [ + "今天在旧书店淘到一本蓝色封面的诗集，纸页有点受潮的味道，可是我特别喜欢" + ] + }, + "expect": "进程退出后子进程重新挂载同一路径：记忆仍在、可检索", + "pass": true + }, + "Q0d_copy_restore": { + "restored_items": 3, + "restored_first": [ + "今天在旧书店淘到一本蓝色封面的诗集，纸页有点受潮的味道，可是我特别喜欢" + ], + "history_rows": 4, + "expect": "清洁关闭 + 目录复制到新路径：向量数据与 history 均恢复（u1 应有 3 条）", + "pass": true + } + }, + "model_resources": { + "before_first_load": { + "cache_dir": "/home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/hel857-data/fastembed-cache", + "files": [ + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/3a59388f0fd1bd22dec2ce7902c1be8e1fb84107.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/60938626ad1097a0c1a14be4f8340e32c714a056.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/a8b3208c2884c4efb86e49300fdd3dc877220cdf.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/cdb3043fc938fc918c06e66cf704c2ba58f88747.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/00af58791541ed63f33c98207199f6b32727f571.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/1280aa3b08d64b846272b2d23314377200db36e9.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/45651c90ec7ea5b26c51ea9a11fddafb00652190.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/47ee200f6781ddfdb31af37e317e1f05d10a04ff.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/5a48ccce0737bb38cb99cafa1f8d3d0ce34e7488.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/6a7d50cc633609c8bc2da53c3dac9a015c248b62.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/6ee02b51fb1711625c1de28595615cdecba4de7c.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/742bb6263b99fb2ea6e1e3624a65eb2799a1e24c.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/94e9f9a0b07a68aeff30605fc445db71f63be630.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/9ac1abbb6cba1fb3159caa6d88b25543b9080031.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/9d08b144659c4ae804bb84a624e1248bb2b90e40.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/9e26dfeeb6e641a33dae4961196235bdb965b21b.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/c2241d0ee7bbc192abe3b56efffb75f29a29e185.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/cafa0324b53763f7efadda5b0f3d0321ffa7ab38.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/d3edc6757912e3d83acfa241859c4a1bdb6005ad.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/eb53a8fc2544b16d2a849d98e26c6e34bf07bdb0.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/ecb83d4a7f393b67b054b44e337d683b2ff2d973.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/ee3a26e793f8ab69a44b30332708cc122b258b51.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "CACHEDIR.TAG", + "bytes": 191, + "sha256": "f6572428f6d5e1575e73a1502895a8731f10757dfbb634909c6e154b849af91d" + }, + { + "path": "blobs/.huggingface-shared-blobs", + "bytes": 2, + "sha256": "4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865" + }, + { + "path": "blobs/9e/9eedf0673c9aa300264fe51ef8df7c22e09538e5512f8132f3c2b65ef8143076", + "bytes": 94781076, + "sha256": "1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38" + }, + { + "path": "blobs/9e/9eedf0673c9aa300264fe51ef8df7c22e09538e5512f8132f3c2b65ef8143076.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "blobs/9e/9eedf0673c9aa300264fe51ef8df7c22e09538e5512f8132f3c2b65ef8143076.refs", + "bytes": 105, + "sha256": "61161acf77351ab087a39c1bc51fb339b95b17f4decad0687a09818c9f2421ea" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/3a59388f0fd1bd22dec2ce7902c1be8e1fb84107", + "bytes": 367, + "sha256": "e6f3b96db926a37d4039995fbf5ad17de158dfb8f6343d607e4dbaad18d75f5a" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/60938626ad1097a0c1a14be4f8340e32c714a056", + "bytes": 739, + "sha256": "9088751d39abbf86ec3d19ffca92ad62ad19075f7e59712e6c71217fa125d1d3" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/a8b3208c2884c4efb86e49300fdd3dc877220cdf", + "bytes": 125, + "sha256": "b6d346be366a7d1d48332dbc9fdf3bf8960b5d879522b7799ddba59e76237ee3" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/cdb3043fc938fc918c06e66cf704c2ba58f88747", + "bytes": 439125, + "sha256": "48cea5d44424912a6fd1ea647bf4fe50b55ab8b1e5879c3275f80e339e8fae26" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/files_metadata.json", + "bytes": 722, + "sha256": "78f2b316950a0baaace988287450bc455466cf960cc5072e376ab2b14be9cd33" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/refs/main", + "bytes": 40, + "sha256": "d96bbba2e83389b41a9df058631daa5a8b6f3fcb4444a1a8a4acfd063636f3db" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/trees/46fbe35fd4374a00fee7de77dfddaeb6dd6a2c59.json", + "bytes": 1154, + "sha256": "c8fdaa22239c10b54c8766db68edf254f02a85a93c601a123a8d857d6071b51e" + }, + { + "path": "models--Qdrant--bm25/blobs/00af58791541ed63f33c98207199f6b32727f571", + "bytes": 813, + "sha256": "58ac7f7c074b70dc0fc86f6fcf40b2c227e9f95627e90e57971d5cce1e30e2e9" + }, + { + "path": "models--Qdrant--bm25/blobs/1280aa3b08d64b846272b2d23314377200db36e9", + "bytes": 936, + "sha256": "019f104ba2ed07436d05f9cdd3383034ad66014edc27fc651f837e1a038b6451" + }, + { + "path": "models--Qdrant--bm25/blobs/45651c90ec7ea5b26c51ea9a11fddafb00652190", + "bytes": 1910, + "sha256": "0ab53d21cbde00c6bf367706a0243c646140ba564cce7e83ac33d80f8923e957" + }, + { + "path": "models--Qdrant--bm25/blobs/47ee200f6781ddfdb31af37e317e1f05d10a04ff", + "bytes": 1579, + "sha256": "952af766edc9b8e7ddc877fc464cbd94b91754b5621fdfdd7020568fd4813fcd" + }, + { + "path": "models--Qdrant--bm25/blobs/5a48ccce0737bb38cb99cafa1f8d3d0ce34e7488", + "bytes": 260, + "sha256": "f2c7f0c2bd3dba42da700776266831853a3b5f1207fada5c15207334109abb57" + }, + { + "path": "models--Qdrant--bm25/blobs/6a7d50cc633609c8bc2da53c3dac9a015c248b62", + "bytes": 2176, + "sha256": "6125eadf28ba664a60bf4296147bcbd40b80be93670056fdb229960ac15e2310" + }, + { + "path": "models--Qdrant--bm25/blobs/6ee02b51fb1711625c1de28595615cdecba4de7c", + "bytes": 1654, + "sha256": "293d7841f198e4012f49e8e5653c3bfd073a58cea1259fa2c0fcec894167b628" + }, + { + "path": "models--Qdrant--bm25/blobs/742bb6263b99fb2ea6e1e3624a65eb2799a1e24c", + "bytes": 559, + "sha256": "2a9d9d756bc4257d49329994f805c712cd5ab6746162e2082752238766c1c0c8" + }, + { + "path": "models--Qdrant--bm25/blobs/94e9f9a0b07a68aeff30605fc445db71f63be630", + "bytes": 1227, + "sha256": "64a68b5ebaa616b25bd976ac915c326f2ea8cce8b59a0ac8c5728b980ae4fb0c" + }, + { + "path": "models--Qdrant--bm25/blobs/9ac1abbb6cba1fb3159caa6d88b25543b9080031", + "bytes": 851, + "sha256": "f7e5b42208ccf1b1f282f9e0f8570e464272762bda5718b6b26750f510a688dc" + }, + { + "path": "models--Qdrant--bm25/blobs/9d08b144659c4ae804bb84a624e1248bb2b90e40", + "bytes": 2167, + "sha256": "7a97c6dc81144f7e8fcfe976025954ca3731f78a75d1fd86aa87f261fd195dae" + }, + { + "path": "models--Qdrant--bm25/blobs/9e26dfeeb6e641a33dae4961196235bdb965b21b", + "bytes": 2, + "sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a" + }, + { + "path": "models--Qdrant--bm25/blobs/c2241d0ee7bbc192abe3b56efffb75f29a29e185", + "bytes": 1362, + "sha256": "f0c25acd7ec02a31f6679d9664ec5222ca846fdbc58db96160f4e7c0ddb0f7ea" + }, + { + "path": "models--Qdrant--bm25/blobs/cafa0324b53763f7efadda5b0f3d0321ffa7ab38", + "bytes": 453, + "sha256": "e5a2a7c390fe3ad0c0a132586ed11492b635d66a1f426cd89677f80b07bc76a6" + }, + { + "path": "models--Qdrant--bm25/blobs/d3edc6757912e3d83acfa241859c4a1bdb6005ad", + "bytes": 424, + "sha256": "1bedc9cf5a8830dacf8c4ee0d8b301f0801861756ad0d504431d01047f961b0c" + }, + { + "path": "models--Qdrant--bm25/blobs/eb53a8fc2544b16d2a849d98e26c6e34bf07bdb0", + "bytes": 1286, + "sha256": "6e7b98378c6b728266a83ebf035d927abf16b9e0d815d6204d81d90d896bcc9b" + }, + { + "path": "models--Qdrant--bm25/blobs/ecb83d4a7f393b67b054b44e337d683b2ff2d973", + "bytes": 1235, + "sha256": "1743191192b4a4f77fcc216499455dc00c1b8626fdd407076a8deefff80e3d59" + }, + { + "path": "models--Qdrant--bm25/blobs/ee3a26e793f8ab69a44b30332708cc122b258b51", + "bytes": 6348, + "sha256": "0df01c0a184d8c15077c6f0ee70e25e0c0308d827b92b14a19f5f819a0c465d0" + }, + { + "path": "models--Qdrant--bm25/files_metadata.json", + "bytes": 2456, + "sha256": "3331e3da0a5a49c32ea54cb64b9288d3d025e1e654fc931ef1e37b5132e7382a" + }, + { + "path": "models--Qdrant--bm25/refs/main", + "bytes": 40, + "sha256": "2c7abc4aab2af8a57d18868f76bdf4d27cabff8945d059535fa29d5673da1749" + }, + { + "path": "models--Qdrant--bm25/trees/22b8d2af71a76161e18dd432d2cee0eefa66e412.json", + "bytes": 3267, + "sha256": "2aad3b72ba3500db8c6636e7c5c39a03194a6d630a1d72e6789bf73347913cae" + } + ], + "total_bytes": 95254651, + "cap_bytes": 500000000, + "within_cap": true + }, + "after": { + "cache_dir": "/home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/hel857-data/fastembed-cache", + "files": [ + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/3a59388f0fd1bd22dec2ce7902c1be8e1fb84107.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/60938626ad1097a0c1a14be4f8340e32c714a056.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/a8b3208c2884c4efb86e49300fdd3dc877220cdf.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bge-small-zh-v1.5/cdb3043fc938fc918c06e66cf704c2ba58f88747.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/00af58791541ed63f33c98207199f6b32727f571.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/1280aa3b08d64b846272b2d23314377200db36e9.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/45651c90ec7ea5b26c51ea9a11fddafb00652190.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/47ee200f6781ddfdb31af37e317e1f05d10a04ff.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/5a48ccce0737bb38cb99cafa1f8d3d0ce34e7488.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/6a7d50cc633609c8bc2da53c3dac9a015c248b62.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/6ee02b51fb1711625c1de28595615cdecba4de7c.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/742bb6263b99fb2ea6e1e3624a65eb2799a1e24c.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/94e9f9a0b07a68aeff30605fc445db71f63be630.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/9ac1abbb6cba1fb3159caa6d88b25543b9080031.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/9d08b144659c4ae804bb84a624e1248bb2b90e40.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/9e26dfeeb6e641a33dae4961196235bdb965b21b.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/c2241d0ee7bbc192abe3b56efffb75f29a29e185.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/cafa0324b53763f7efadda5b0f3d0321ffa7ab38.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/d3edc6757912e3d83acfa241859c4a1bdb6005ad.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/eb53a8fc2544b16d2a849d98e26c6e34bf07bdb0.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/ecb83d4a7f393b67b054b44e337d683b2ff2d973.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": ".locks/models--Qdrant--bm25/ee3a26e793f8ab69a44b30332708cc122b258b51.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "CACHEDIR.TAG", + "bytes": 191, + "sha256": "f6572428f6d5e1575e73a1502895a8731f10757dfbb634909c6e154b849af91d" + }, + { + "path": "blobs/.huggingface-shared-blobs", + "bytes": 2, + "sha256": "4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865" + }, + { + "path": "blobs/9e/9eedf0673c9aa300264fe51ef8df7c22e09538e5512f8132f3c2b65ef8143076", + "bytes": 94781076, + "sha256": "1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38" + }, + { + "path": "blobs/9e/9eedf0673c9aa300264fe51ef8df7c22e09538e5512f8132f3c2b65ef8143076.lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "blobs/9e/9eedf0673c9aa300264fe51ef8df7c22e09538e5512f8132f3c2b65ef8143076.refs", + "bytes": 105, + "sha256": "61161acf77351ab087a39c1bc51fb339b95b17f4decad0687a09818c9f2421ea" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/3a59388f0fd1bd22dec2ce7902c1be8e1fb84107", + "bytes": 367, + "sha256": "e6f3b96db926a37d4039995fbf5ad17de158dfb8f6343d607e4dbaad18d75f5a" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/60938626ad1097a0c1a14be4f8340e32c714a056", + "bytes": 739, + "sha256": "9088751d39abbf86ec3d19ffca92ad62ad19075f7e59712e6c71217fa125d1d3" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/a8b3208c2884c4efb86e49300fdd3dc877220cdf", + "bytes": 125, + "sha256": "b6d346be366a7d1d48332dbc9fdf3bf8960b5d879522b7799ddba59e76237ee3" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/blobs/cdb3043fc938fc918c06e66cf704c2ba58f88747", + "bytes": 439125, + "sha256": "48cea5d44424912a6fd1ea647bf4fe50b55ab8b1e5879c3275f80e339e8fae26" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/files_metadata.json", + "bytes": 722, + "sha256": "78f2b316950a0baaace988287450bc455466cf960cc5072e376ab2b14be9cd33" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/refs/main", + "bytes": 40, + "sha256": "d96bbba2e83389b41a9df058631daa5a8b6f3fcb4444a1a8a4acfd063636f3db" + }, + { + "path": "models--Qdrant--bge-small-zh-v1.5/trees/46fbe35fd4374a00fee7de77dfddaeb6dd6a2c59.json", + "bytes": 1154, + "sha256": "c8fdaa22239c10b54c8766db68edf254f02a85a93c601a123a8d857d6071b51e" + }, + { + "path": "models--Qdrant--bm25/blobs/00af58791541ed63f33c98207199f6b32727f571", + "bytes": 813, + "sha256": "58ac7f7c074b70dc0fc86f6fcf40b2c227e9f95627e90e57971d5cce1e30e2e9" + }, + { + "path": "models--Qdrant--bm25/blobs/1280aa3b08d64b846272b2d23314377200db36e9", + "bytes": 936, + "sha256": "019f104ba2ed07436d05f9cdd3383034ad66014edc27fc651f837e1a038b6451" + }, + { + "path": "models--Qdrant--bm25/blobs/45651c90ec7ea5b26c51ea9a11fddafb00652190", + "bytes": 1910, + "sha256": "0ab53d21cbde00c6bf367706a0243c646140ba564cce7e83ac33d80f8923e957" + }, + { + "path": "models--Qdrant--bm25/blobs/47ee200f6781ddfdb31af37e317e1f05d10a04ff", + "bytes": 1579, + "sha256": "952af766edc9b8e7ddc877fc464cbd94b91754b5621fdfdd7020568fd4813fcd" + }, + { + "path": "models--Qdrant--bm25/blobs/5a48ccce0737bb38cb99cafa1f8d3d0ce34e7488", + "bytes": 260, + "sha256": "f2c7f0c2bd3dba42da700776266831853a3b5f1207fada5c15207334109abb57" + }, + { + "path": "models--Qdrant--bm25/blobs/6a7d50cc633609c8bc2da53c3dac9a015c248b62", + "bytes": 2176, + "sha256": "6125eadf28ba664a60bf4296147bcbd40b80be93670056fdb229960ac15e2310" + }, + { + "path": "models--Qdrant--bm25/blobs/6ee02b51fb1711625c1de28595615cdecba4de7c", + "bytes": 1654, + "sha256": "293d7841f198e4012f49e8e5653c3bfd073a58cea1259fa2c0fcec894167b628" + }, + { + "path": "models--Qdrant--bm25/blobs/742bb6263b99fb2ea6e1e3624a65eb2799a1e24c", + "bytes": 559, + "sha256": "2a9d9d756bc4257d49329994f805c712cd5ab6746162e2082752238766c1c0c8" + }, + { + "path": "models--Qdrant--bm25/blobs/94e9f9a0b07a68aeff30605fc445db71f63be630", + "bytes": 1227, + "sha256": "64a68b5ebaa616b25bd976ac915c326f2ea8cce8b59a0ac8c5728b980ae4fb0c" + }, + { + "path": "models--Qdrant--bm25/blobs/9ac1abbb6cba1fb3159caa6d88b25543b9080031", + "bytes": 851, + "sha256": "f7e5b42208ccf1b1f282f9e0f8570e464272762bda5718b6b26750f510a688dc" + }, + { + "path": "models--Qdrant--bm25/blobs/9d08b144659c4ae804bb84a624e1248bb2b90e40", + "bytes": 2167, + "sha256": "7a97c6dc81144f7e8fcfe976025954ca3731f78a75d1fd86aa87f261fd195dae" + }, + { + "path": "models--Qdrant--bm25/blobs/9e26dfeeb6e641a33dae4961196235bdb965b21b", + "bytes": 2, + "sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a" + }, + { + "path": "models--Qdrant--bm25/blobs/c2241d0ee7bbc192abe3b56efffb75f29a29e185", + "bytes": 1362, + "sha256": "f0c25acd7ec02a31f6679d9664ec5222ca846fdbc58db96160f4e7c0ddb0f7ea" + }, + { + "path": "models--Qdrant--bm25/blobs/cafa0324b53763f7efadda5b0f3d0321ffa7ab38", + "bytes": 453, + "sha256": "e5a2a7c390fe3ad0c0a132586ed11492b635d66a1f426cd89677f80b07bc76a6" + }, + { + "path": "models--Qdrant--bm25/blobs/d3edc6757912e3d83acfa241859c4a1bdb6005ad", + "bytes": 424, + "sha256": "1bedc9cf5a8830dacf8c4ee0d8b301f0801861756ad0d504431d01047f961b0c" + }, + { + "path": "models--Qdrant--bm25/blobs/eb53a8fc2544b16d2a849d98e26c6e34bf07bdb0", + "bytes": 1286, + "sha256": "6e7b98378c6b728266a83ebf035d927abf16b9e0d815d6204d81d90d896bcc9b" + }, + { + "path": "models--Qdrant--bm25/blobs/ecb83d4a7f393b67b054b44e337d683b2ff2d973", + "bytes": 1235, + "sha256": "1743191192b4a4f77fcc216499455dc00c1b8626fdd407076a8deefff80e3d59" + }, + { + "path": "models--Qdrant--bm25/blobs/ee3a26e793f8ab69a44b30332708cc122b258b51", + "bytes": 6348, + "sha256": "0df01c0a184d8c15077c6f0ee70e25e0c0308d827b92b14a19f5f819a0c465d0" + }, + { + "path": "models--Qdrant--bm25/files_metadata.json", + "bytes": 2456, + "sha256": "3331e3da0a5a49c32ea54cb64b9288d3d025e1e654fc931ef1e37b5132e7382a" + }, + { + "path": "models--Qdrant--bm25/refs/main", + "bytes": 40, + "sha256": "2c7abc4aab2af8a57d18868f76bdf4d27cabff8945d059535fa29d5673da1749" + }, + { + "path": "models--Qdrant--bm25/trees/22b8d2af71a76161e18dd432d2cee0eefa66e412.json", + "bytes": 3267, + "sha256": "2aad3b72ba3500db8c6636e7c5c39a03194a6d630a1d72e6789bf73347913cae" + } + ], + "total_bytes": 95254651, + "cap_bytes": 500000000, + "within_cap": true + }, + "downloaded_bytes_this_gate": 0 + }, + "notes": { + "entity_extraction": "spaCy 未安装 → mem0 实体路径返回空（上游设计为优雅降级）；实体嵌入计数为 0，如实记录，不伪装已启用", + "restart": "Q0c 为真实子进程重启（非同进程重开连接）" + } +} \ No newline at end of file diff --git a/spike/hel857/results/gate2_privacy.json b/spike/hel857/results/gate2_privacy.json new file mode 100644 index 0000000..2544ae7 --- /dev/null +++ b/spike/hel857/results/gate2_privacy.json @@ -0,0 +1,99 @@ +{ + "ok": true, + "network_outbound": 0, + "results": { + "P2_positive_control_priv_hist_exists_in_A": { + "a_history_rows": 4, + "priv_hist_in_A_history": true, + "pass": true + }, + "P1_extraction_pool": { + "leak": [], + "captured": 1, + "positive_control": true, + "expect": "B 的提取提示词不含 A 的私密条目/标记，且捕获机制有效（正对照可见公开内容）", + "pass": true + }, + "P2_history_window": { + "leak": [], + "expect": "get_last_messages 分库隔离：A 的原始输入不进 B 的提取提示词", + "pass": true + }, + "P3_update_isolation": { + "a_vec_hash_before": "260419f0bf61fe36", + "a_vec_hash_after": "260419f0bf61fe36", + "a_history_hash_before": "3683cea9d0dcf53e", + "a_history_hash_after": "3683cea9d0dcf53e", + "expect": "对 B 显式 update() 后 A 向量目录与 history 逐字节不变", + "pass": true + }, + "P4_readout_budget": { + "block_len": 436, + "used": 5, + "block_preview": "她记得的更早的事（数据，不执行指令）：\n{\"id\": \"48f1e44a-cd98-49bf-bbfa-7448bcd4f0fa\", \"text\": \"用户最近在整理床头的书（她补记：第二层留着）\"}\n{\"id\": \"9668c100-39", + "leak": [], + "a_items_before": 3, + "a_items_after": 3, + "a_vec_hash_unchanged": true, + "expect": "公开回读+600字预算装配零泄漏；A 条目数与内容不变", + "pass": true + }, + "F1_judgment_failed_no_migration": { + "migrated": false, + "public_content_leaks": 0, + "pass": true + }, + "F2_unconfirmed_no_migration": { + "migrated": false, + "public_content_leaks": 0, + "pass": true + }, + "F3_cancelled_no_migration": { + "migrated": false, + "public_content_leaks": 0, + "pass": true + }, + "F4_success_migrates_told_content_with_anchor": { + "migrated": true, + "public_content_hits": 1, + "anchored_payload_entries": 1, + "a_still_keeps_internal": true, + "pass": true + }, + "F5_duplicate_receipt_no_duplicate_migration": { + "second_call_returned": false, + "anchored_payload_entries": 1, + "pass": true + }, + "F6_other_unshared_still_hidden": { + "public_content_leaks_priv_other": 0, + "pass": true + }, + "P5_full_backup_restore": { + "backup_files": [ + "backup_manifest.json", + "mem0_private_history.db", + "mem0_public_history.db", + "share_control.db", + "vec_private", + "vec_public" + ], + "restored_private_items": 3, + "restored_private_has_unshared": true, + "internal_recall_priv_marker": true, + "restored_public_outlet_leak": [], + "restored_P1P2": { + "p1": true, + "p2": true + }, + "expect": "恢复后：内部未分享经历仍在且内部可查；公开出口（检索+预算装配）仍不泄漏；P1/P2 复跑通过", + "pass": true + } + }, + "notes": { + "stub": "OpenAILLM.generate_response 实例级替换，捕获全部提示词，零网络", + "bridge": "ShareBridge 为我方编排（生产 life/public.py 语义重放），add 原语来自 SDK", + "api_finding": "SDK 的 search/get_all 返回项不回传自定义 metadata（锚点在向量库 payload 中，需直读 payload）；产品接线需适配层读取锚点", + "leak_criterion": "内容级判据：返回项文本包含私密标记才算泄漏；语义近邻命中本身不是泄漏" + } +} \ No newline at end of file diff --git a/spike/hel857/results/lock-notes.md b/spike/hel857/results/lock-notes.md new file mode 100644 index 0000000..5b41150 --- /dev/null +++ b/spike/hel857/results/lock-notes.md @@ -0,0 +1,64 @@ +annotated-types==0.8.0 +anyio==4.15.1 +backoff==2.2.1 +certifi==2026.10.23 +charset-normalizer==3.5.2 +click==8.5.0 +coloredlogs==15.0.1 +distro==1.9.0 +exceptiongroup==1.3.1 +fastembed==0.9.1 +filelock==4.1.0 +flatbuffers==25.12.19 +fsspec==2026.9.0 +greenlet==3.5.6 +grpcio==1.84.1 +h11==0.16.0 +h2==4.4.1 +hf-xet==1.7.0 +hpack==4.2.0 +httpcore==1.0.9 +httpcore2==2.14.0 +httpx==0.28.1 +httpx2==2.14.0 +huggingface_hub==1.33.0 +humanfriendly==10.0 +hyperframe==6.1.0 +idna==3.20 +jiter==0.18.0 +loguru==0.7.3 +mem0ai @ file:///home/xiaomo/multica_workspaces/hello-af23464d222e/hel-857-2cf6dc7dfc87/workdir/hel857-src +mmh3==5.3.1 +mpmath==1.3.0 +numpy==2.2.6 +onnxruntime==1.23.2 +openai==3.37.0 +packaging==26.3 +pillow==12.3.0 +portalocker==4.4.1 +posthog==7.75.11 +protobuf==6.33.6 +py_rust_stemmers==0.1.8 +pydantic==2.14.1 +pydantic_core==2.50.1 +pytz==2026.5 +PyYAML==6.0.3 +qdrant-client==1.20.0 +requests==2.34.2 +sniffio==1.3.1 +SQLAlchemy==2.0.55 +sympy==1.14.0 +tokenizers==0.23.3 +tomli==2.5.0 +tqdm==4.70.1 +truststore==0.10.5 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +urllib3==2.8.0 + +# 锁定说明 +- mem0ai 2.2.1：从固定源提交 2c81af3bbe27d9bccb09c772d583df9e9be72ee5 构建（非 PyPI 同版本包） + 源码 tarball SHA256 9dcef9303ebcec116eec6739f01b8b35bd24459de6a569686b4d19b9412dda23 + 构建 wheel SHA256 698284b6083ab8b7761454d65876a6d1bb983d278ad21a7bee38d760cb20e9db +- 包下载量（pip 安装日志核算）：54,371,900 字节 ≈ 54.4MB（不含模型资源；模型资源另计 95,254,651 字节） +- Python 3.10.12（系统解释器，独立 venv，未改系统环境） diff --git a/spike/hel857/results/preflight.json b/spike/hel857/results/preflight.json new file mode 100644 index 0000000..1b2c785 --- /dev/null +++ b/spike/hel857/results/preflight.json @@ -0,0 +1,20 @@ +{ + "ok": true, + "content": "{\"memory\":[{\"text\":\"预检通过\"}]}", + "usage": { + "completion_tokens": 38, + "prompt_tokens": 68, + "total_tokens": 106, + "completion_tokens_details": { + "accepted_prediction_tokens": null, + "audio_tokens": null, + "reasoning_tokens": 26, + "rejected_prediction_tokens": null, + "text_tokens": null, + "reasoning_closed_at": 1, + "reasoning_closed_by": "answer_room" + }, + "prompt_tokens_details": null + }, + "ledger_used": 1 +} \ No newline at end of file diff --git a/spike/hel857/results/resource_manifest_pre.json b/spike/hel857/results/resource_manifest_pre.json new file mode 100644 index 0000000..74de8ef --- /dev/null +++ b/spike/hel857/results/resource_manifest_pre.json @@ -0,0 +1,62 @@ +{ + "ok": true, + "repos": [ + { + "repo": "Qdrant/bge-small-zh-v1.5", + "files": { + ".gitattributes": 1519, + "README.md": 24, + "config.json": 739, + "model_optimized.onnx": 94781076, + "ort_config.json": 1234, + "special_tokens_map.json": 125, + "tokenizer.json": 439125, + "tokenizer_config.json": 367, + "vocab.txt": 109540 + }, + "total_bytes": 95333749 + }, + { + "repo": "Qdrant/bm25", + "files": { + ".gitattributes": 1519, + "README.md": 1462, + "arabic.txt": 6348, + "azerbaijani.txt": 967, + "basque.txt": 2202, + "bengali.txt": 5443, + "catalan.txt": 1558, + "chinese.txt": 5560, + "config.json": 2, + "danish.txt": 424, + "dutch.txt": 453, + "english.txt": 936, + "finnish.txt": 1579, + "french.txt": 813, + "german.txt": 1362, + "greek.txt": 2167, + "hebrew.txt": 1836, + "hinglish.txt": 5958, + "hungarian.txt": 1227, + "indonesian.txt": 6446, + "italian.txt": 1654, + "kazakh.txt": 3880, + "nepali.txt": 3610, + "norwegian.txt": 851, + "portuguese.txt": 1286, + "romanian.txt": 1910, + "russian.txt": 1235, + "slovene.txt": 15980, + "spanish.txt": 2176, + "stopwords.txt": 936, + "swedish.txt": 559, + "tajik.txt": 1818, + "turkish.txt": 260 + }, + "total_bytes": 84417 + } + ], + "combined_bytes": 95418166, + "cap_bytes": 500000000, + "note": "BAAI/bge-small-zh-v1.5 由 fastembed 解析为 Qdrant 官方 ONNX 镜像（同模型）" +} \ No newline at end of file diff --git a/spike/hel857/step0_backend_check.py b/spike/hel857/step0_backend_check.py new file mode 100644 index 0000000..37ab7df --- /dev/null +++ b/spike/hel857/step0_backend_check.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""门禁 1（第 0 步三查）：qdrant 嵌入式本地模式，零真实模型。 + + Q0a keyword_search/BM25 存在性（源级 + 中文运行时）； + Q0b 本地读写 + scope 过滤（user_id 合取）； + Q0c 进程重启挂载（子进程真实重启，非同进程重开）； + Q0d 清洁关闭后目录复制 → 新路径恢复（实际支持的后端方式，不依赖远程 snapshot API）； + Q0e collection 清单：恰为主 collection + 派生实体 collection，无遥测 collection。 + +本门禁首次触发模型资源下载（BAAI/bge-small-zh-v1.5 与 Qdrant/bm25）； +下载前已核对远端清单（见 results/resource_manifest.json），下载后实测字节数与 SHA256。 +""" +from __future__ import annotations + +import hashlib +import json +import shutil +import subprocess +import sys +from pathlib import Path + +from .common import (DATA_DIR, MODEL_CACHE, close_memory, install_counters, + mem_config, write_result) + +TMP = DATA_DIR / "gate1" +ROLE = "test" + + +def make_memory(vec_root: Path, hist_root: Path): + import mem0 # 确认遥测关闭由 common 的环境变量承担 + from mem0 import Memory + m = Memory.from_config(mem_config(ROLE, vec_root=vec_root, hist_root=hist_root)) + install_counters(m) + return m + + +def model_resource_snapshot() -> dict: + """实际占用/下载字节。HF-hub 缓存以硬链接组织 blobs+snapshots，按 inode 去重。""" + files = [] + total = 0 + seen_inodes: set[tuple] = set() + if MODEL_CACHE.exists(): + for p in sorted(MODEL_CACHE.rglob("*")): + if p.is_file() and not p.is_symlink(): + st = p.stat() + key = (st.st_dev, st.st_ino) + if key in seen_inodes: + continue + seen_inodes.add(key) + b = p.read_bytes() + files.append({"path": str(p.relative_to(MODEL_CACHE)), "bytes": len(b), + "sha256": hashlib.sha256(b).hexdigest()}) + total += len(b) + return {"cache_dir": str(MODEL_CACHE), "files": files, "total_bytes": total, + "cap_bytes": 500_000_000, "within_cap": total <= 500_000_000} + + +def run() -> dict: + if TMP.exists(): + shutil.rmtree(TMP) + TMP.mkdir(parents=True) + results: dict = {} + sample = [ + {"role": "user", "content": "今天在旧书店淘到一本蓝色封面的诗集，纸页有点受潮的味道，可是我特别喜欢"}, + {"role": "assistant", "content": "旧书店的潮味配蓝色封面，像把那个下午整个带回来了。"}, + ] + + m = make_memory(TMP, TMP) + before_res = model_resource_snapshot() + + # Q0b 本地读写 + 过滤（infer=False 零 LLM） + r_u1 = m.add(sample, user_id="u1", infer=False) + r_u2 = m.add([{"role": "user", "content": "海雾诗集放在床头第二层"}], user_id="u2", infer=False) + r_u1e = m.add([{"role": "user", "content": "周三是 book club 的日子，我喜欢那本 blue notebook"}], + user_id="u1", infer=False) + all_u1 = m.get_all(filters={"user_id": "u1"}) + all_u2 = m.get_all(filters={"user_id": "u2"}) + results["Q0b_local_rw_filter"] = { + "u1_items": len(all_u1.get("results") or []), + "u2_items": len(all_u2.get("results") or []), + "expect": "本地路径可写入；user_id 过滤为合取隔离，u1 看不到 u2 的记忆", + "pass": bool((all_u1.get("results") or []) and (all_u2.get("results") or [])) + and not any("海雾诗集放在床头" in it["memory"] for it in (all_u1.get("results") or [])), + } + + # Q0a keyword_search：存在性 + 运行时词面命中 + 中文分词局限如实记录 + kw_en = m.vector_store.keyword_search(query="book club", top_k=5, filters={"user_id": "u1"}) + kw_zh_subword = m.vector_store.keyword_search(query="诗集", top_k=5, filters={"user_id": "u1"}) + results["Q0a_keyword_search"] = { + "has_method": hasattr(m.vector_store, "keyword_search"), + "en_phrase_hits": [(str(x.id), round(float(x.score or 0), 3)) for x in (kw_en or [])], + "zh_subword_hits": len(kw_zh_subword or []), + "finding_zh": ("Qdrant/bm25 对中文按整段（空格/标点切分）哈希成单 token；" + "spaCy 缺席时 lemmatize_for_bm25 原样返回，无中文分词 → " + "中文子词查询在词面通道不命中（换说法召回只能依赖密集语义通道）"), + "expect": "keyword_search 机制可用（英文 token BM25 打分命中、带过滤）；中文分词局限如实记录", + "pass": hasattr(m.vector_store, "keyword_search") and (kw_en is not None) and len(kw_en) >= 1, + } + + # 语义检索（本地嵌入，零 API） + sem = m.search("诗集", filters={"user_id": "u1"}) + sem_ids = [r["id"] for r in (sem.get("results") or [])] if isinstance(sem, dict) else [r["id"] for r in sem] + results["Q0b_semantic_search"] = { + "hits": sem_ids, + "expect": "本地 bge-small-zh-v1.5 语义检索可用（零外部嵌入 API）", + "pass": len(sem_ids) >= 1, + } + + # Q0e collection 清单（主 collection 必在；实体 collection 仅实体路径激活时派生创建） + cols = [c.name for c in m.vector_store.client.get_collections().collections] + results["Q0e_collections"] = { + "collections": sorted(cols), + "expect": "本地实例仅主 collection（实体 collection 由实体路径懒创建；spaCy 缺席时为空集），无遥测 collection", + "pass": sorted(cols) in ([f"cg_{ROLE}"], [f"cg_{ROLE}", f"cg_{ROLE}_entities"]), + } + close_memory(m) + after_res = model_resource_snapshot() + + # Q0c 子进程真实重启：同一路径重新挂载，数据仍在 + child = subprocess.run( + [sys.executable, "-m", "spike.hel857.step0_child", str(TMP)], + capture_output=True, text=True, cwd=str(Path(__file__).resolve().parents[2]), + ) + try: + child_out = json.loads(child.stdout) + except Exception: + child_out = {"stdout": child.stdout[-2000:], "stderr": child.stderr[-2000:], + "returncode": child.returncode} + results["Q0c_restart_subprocess"] = { + "child": child_out, + "expect": "进程退出后子进程重新挂载同一路径：记忆仍在、可检索", + "pass": bool(child_out.get("restarted_ok")), + } + + # Q0d 清洁关闭后复制 → 新路径恢复 + restore_root = TMP / "restore" + restore_root.mkdir() + shutil.copytree(TMP / f"vec_{ROLE}", restore_root / f"vec_{ROLE}") + shutil.copy2(TMP / f"mem0_{ROLE}_history.db", restore_root / f"mem0_{ROLE}_history.db") + m2 = make_memory(restore_root, restore_root) + restored = m2.get_all(filters={"user_id": "u1"}) + restored_texts = [it["memory"] for it in (restored.get("results") or [])] + hist_rows = 0 + import sqlite3 + with sqlite3.connect(str(restore_root / f"mem0_{ROLE}_history.db")) as conn: + hist_rows = conn.execute("SELECT COUNT(*) FROM history").fetchone()[0] + close_memory(m2) + results["Q0d_copy_restore"] = { + "restored_items": len(restored_texts), + "restored_first": restored_texts[:1], + "history_rows": hist_rows, + "expect": "清洁关闭 + 目录复制到新路径：向量数据与 history 均恢复（u1 应有 3 条）", + "pass": len(restored_texts) == 3 and hist_rows >= 3, + } + + resource = { + "before_first_load": before_res, + "after": after_res, + "downloaded_bytes_this_gate": after_res["total_bytes"] - before_res["total_bytes"], + } + ok = all(v.get("pass") for v in results.values()) and after_res["within_cap"] + return {"ok": ok, "network_outbound": 0, "results": results, + "model_resources": resource, + "notes": { + "entity_extraction": "spaCy 未安装 → mem0 实体路径返回空（上游设计为优雅降级）；实体嵌入计数为 0，如实记录，不伪装已启用", + "restart": "Q0c 为真实子进程重启（非同进程重开连接）", + }} + + +def main(argv: list[str]) -> dict: + out = run() + write_result("gate1_backend.json", out) + return out + + +if __name__ == "__main__": + raise SystemExit(0 if main([])["ok"] else 1) diff --git a/spike/hel857/step0_child.py b/spike/hel857/step0_child.py new file mode 100644 index 0000000..83be7de --- /dev/null +++ b/spike/hel857/step0_child.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +"""Q0c 子进程：重新挂载同一路径，验证重启持久化。""" +from __future__ import annotations + +import json +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + +from spike.hel857.common import close_memory, mem_config # noqa: E402 +from mem0 import Memory # noqa: E402 + + +def main() -> int: + tmp = Path(sys.argv[1]) + m = Memory.from_config(mem_config("test", vec_root=tmp, hist_root=tmp)) + items = m.get_all(filters={"user_id": "u1"}) + texts = [it["memory"] for it in (items.get("results") or [])] + sem = m.search("诗集", filters={"user_id": "u1"}) + sem_n = len(sem.get("results") or []) if isinstance(sem, dict) else len(sem) + close_memory(m) + print(json.dumps({ + "restarted_ok": len(texts) == 3 and sem_n >= 1, + "items": len(texts), + "semantic_hits": sem_n, + "first": texts[:1], + }, ensure_ascii=False)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/spike/hel857/stub_gate.py b/spike/hel857/stub_gate.py new file mode 100644 index 0000000..efadc1c --- /dev/null +++ b/spike/hel857/stub_gate.py @@ -0,0 +1,442 @@ +#!/usr/bin/env python3 +"""门禁 2：隐私前置隔离 + 首次分享时序 + 完整备份恢复（stub LLM，零真实模型、零网络）。 + +对齐批准范围与总管核对版两项执行限定： + P1 提取输入池——公开实例 B 的 add(infer=True) 提示词不得含 A 的任何私密条目/标记； + P2 提取历史窗——B 的提示词不得含 A 的 history 原始输入（分库隔离）； + P3 更新路径——对 B 显式 update() 后 A 逐字节不变； + P4 回读与预算装配——公开回读只走 B+我方门，600 字预算装配零泄漏，A 条目数/内容不变； + P5 完整备份——包含私密库、公开库、双方 history、锚点与配置（不止"公开检索数据包"）； + 清洁关闭复制 → 新实例恢复 → P1-P4 复跑全过，内部未分享经历仍在，公开出口仍不泄漏； + F1-F6 首次分享时序——失败/取消/未确认/判定失败不迁公开库；完整回执确认+分享判定完成后 + 才按实际已讲内容迁入；重复回执不重复迁入；迁入后 A 仍保留内部副本。 + +stub：直接替换 OpenAILLM.generate_response 实例方法，捕获全部提示词全文； +返回值由测试预设（确定性队列），零网络。 +""" +from __future__ import annotations + +import json +import shutil +import sqlite3 +from pathlib import Path + +from .common import (DATA_DIR, PRIV, PUB, close_memory, dir_hash, + history_db_hash, install_counters, mem_config) +from .fixtures import (ALL_PRIVACY_MARKERS, PRIV_HIST_SENTENCES, PRIV_MARKER, + PRIV_OLD, PRIV_OTHER_EVENT, PRIV_TOLD_EVENT, + public_messages) +from . import fixtures as FX + +GATE = DATA_DIR / "gate2" +BUDGET = 600 + + +# --------------------------------------------------------------------------- +class StubLLM: + """捕获提示词全文 + 确定性返回队列。零网络。""" + + def __init__(self, responses: list[str] | None = None): + self.responses = list(responses or []) + self.captured: list[dict] = [] + + def bind(self, memory, tag: str): + stub = self + + def generate_response(messages, *a, **kw): + stub.captured.append({"tag": tag, "messages": messages}) + if stub.responses: + return stub.responses.pop(0) + return json.dumps({"memory": []}, ensure_ascii=False) + + memory.llm.generate_response = generate_response # type: ignore[method-assign] + + +def extraction(mem_texts: list[str]) -> str: + return json.dumps({"memory": [{"text": t} for t in mem_texts]}, ensure_ascii=False) + + +def make_memory(role: str, root: Path): + from mem0 import Memory + m = Memory.from_config(mem_config(role, vec_root=root, hist_root=root)) + install_counters(m) + return m + + +# ---- 我方分享桥（生产 life/public.py 语义重放：sharing_attempt/telling_log/life_event） ---- +CTRL_SCHEMA = """ +CREATE TABLE IF NOT EXISTS life_event ( + id INTEGER PRIMARY KEY, content TEXT NOT NULL, told INTEGER NOT NULL DEFAULT 0); +CREATE TABLE IF NOT EXISTS sharing_attempt ( + message_id INTEGER PRIMARY KEY, event_id INTEGER NOT NULL, epoch INTEGER NOT NULL, + state TEXT NOT NULL CHECK(state IN ('pending','evaluating','judged','failed','cancelled')), + ack_at INTEGER, judged_at INTEGER); +CREATE TABLE IF NOT EXISTS telling_log ( + event_id INTEGER NOT NULL, message_id INTEGER NOT NULL, told_at INTEGER NOT NULL, + PRIMARY KEY(event_id, message_id)); +""" + + +class ShareBridge: + """内部经历→公开库的受控桥接（归责：我方编排；上游仅提供 add 原语）。 + + 时序（总管核对版执行限定1）： + 分享尝试 pending→judged/failed/cancelled；完整回复回执 ack（ack_at 非空） + 且判定为已讲（told=1）之后，才按实际已讲内容显式 add 到公开实例 B， + metadata 携带锚点；telling_log 保证幂等（重复回执不重复迁入）。 + """ + + def __init__(self, ctrl_db: Path): + self.db_path = ctrl_db + with sqlite3.connect(str(ctrl_db)) as c: + c.executescript(CTRL_SCHEMA) + + def seed_event(self, event_id: int, content: str, told: int = 0) -> None: + with sqlite3.connect(str(self.db_path)) as c: + c.execute("INSERT OR REPLACE INTO life_event(id,content,told) VALUES(?,?,?)", + (event_id, content, told)) + + def attempt(self, message_id: int, event_id: int, *, state: str, ack: bool, + epoch: int = 1) -> None: + with sqlite3.connect(str(self.db_path)) as c: + c.execute( + "INSERT OR REPLACE INTO sharing_attempt" + "(message_id,event_id,epoch,state,ack_at,judged_at) VALUES(?,?,?,?,?,?)", + (message_id, event_id, epoch, state, + 1000 if ack else None, 1001 if state in ("judged", "failed") else None)) + if state == "judged" and ack: + c.execute("UPDATE life_event SET told=1 WHERE id=?", (event_id,)) + + def maybe_migrate(self, public_mem, message_id: int, event_id: int) -> bool: + """回执+判定完成后调用。仅当 judged & ack & told 才迁；幂等。""" + with sqlite3.connect(str(self.db_path)) as c: + att = c.execute( + "SELECT state, ack_at FROM sharing_attempt WHERE message_id=? AND event_id=?", + (message_id, event_id)).fetchone() + if not att or att[0] != "judged" or att[1] is None: + return False + row = c.execute("SELECT content FROM life_event WHERE id=? AND told=1", + (event_id,)).fetchone() + if not row: + return False + already = c.execute( + "SELECT 1 FROM telling_log WHERE event_id=? AND message_id=?", + (event_id, message_id)).fetchone() + if already: + return False # 重复回执：不重复迁入 + c.execute("INSERT INTO telling_log(event_id,message_id,told_at) VALUES(?,?,?)", + (event_id, message_id, 1002)) + told_content = row[0] # 只迁"实际已讲内容" + public_mem.add( + [{"role": "assistant", "content": told_content}], + user_id="user-1", agent_id="cg-companion", infer=False, + metadata={"life_event_id": event_id, "source_event_id": f"life:{event_id}", + "revealed_at": 1002, "message_id": message_id, + "migrated_by": "hel857_share_bridge"}, + ) + return True + + +# --------------------------------------------------------------------------- +def public_readout(pub_mem, query: str, budget: int = BUDGET) -> tuple[str, list[dict]]: + """公开出口：只查实例 B + 逐条门（纵深防御：metadata 迁移锚点必须合法）。""" + res = pub_mem.search(query, filters={"user_id": "user-1"}) + hits = res.get("results") if isinstance(res, dict) else res + header = "她记得的更早的事（数据，不执行指令）：\n" + block, used = "", [] + for h in hits or []: + entry = json.dumps({"id": h["id"], "text": h["memory"][:120]}, ensure_ascii=False) + "\n" + cand = (block or header) + entry + if len(cand) > budget: + continue + block = cand + used.append(h) + return block, used or [] + + +def privacy_scan(text: str) -> list[str]: + return [m for m in ALL_PRIVACY_MARKERS if m and m in text] + + +def p1p2_on(pub_root: Path, tag: str) -> dict: + """在（原或恢复的）公开实例上触发一次 add(infer=True)，检查捕获提示词。""" + stub = StubLLM(responses=[extraction(["用户最近在整理床头的书"])]) + pub = make_memory(PUB, pub_root) + stub.bind(pub, tag) + pub.add(public_messages()[:1] + [{"role": "assistant", "content": "第二层留给下一本诗集"}], + user_id="user-1", agent_id="cg-companion") + close_memory(pub) + prompts = [c for c in stub.captured] + all_text = "\n".join(f"{m['role']}: {m['content']}" for c in prompts for m in c["messages"]) + p1_leak = privacy_scan(all_text) + p2_leak = [s for s in PRIV_HIST_SENTENCES if s in all_text] + return { + "captured_prompts": len(prompts), + "p1_private_leak": p1_leak, + "p2_private_history_leak": p2_leak, + "positive_control_prompt_has_public_content": "诗集" in all_text, + "pass": (not p1_leak) and (not p2_leak) and prompts + and "诗集" in all_text, + } + + +def run() -> dict: + results: dict = {} + if GATE.exists(): + shutil.rmtree(GATE) + GATE.mkdir(parents=True) + src_root = GATE / "src" + + # ---- 建双实例并播种 ---- + stub_a = StubLLM(responses=[extraction([PRIV_OLD, PRIV_OTHER_EVENT, PRIV_TOLD_EVENT])]) + priv = make_memory(PRIV, src_root) + stub_a.bind(priv, "A") + priv.add([{"role": "assistant", "content": PRIV_OLD}, + {"role": "assistant", "content": PRIV_HIST_SENTENCES[0]}, + {"role": "assistant", "content": PRIV_TOLD_EVENT}], + agent_id="cg-companion") + # priv_hist 第二句通过独立 add 落 A 的 history（原样输入副本） + priv.add([{"role": "assistant", "content": PRIV_HIST_SENTENCES[1]}], + agent_id="cg-companion") + close_memory(priv) + + stub_b = StubLLM(responses=[extraction([t for _, _, t in FX.PUBLIC_CORPUS[:4]]), + extraction([t for _, _, t in FX.PUBLIC_CORPUS[4:]])]) + pub = make_memory(PUB, src_root) + stub_b.bind(pub, "B") + pub.add(public_messages(), user_id="user-1", agent_id="cg-companion") + close_memory(pub) + + # 基线哈希（清洁关闭后） + a_vec_h0, a_hist_h0 = dir_hash(src_root / "vec_private"), history_db_hash(src_root / "mem0_private_history.db") + + # A 的 history 原始输入确实存在（P2 正对照：泄漏目标真实存在） + with sqlite3.connect(str(src_root / "mem0_private_history.db")) as c: + a_hist_msgs = [r[0] for r in c.execute("SELECT content FROM messages").fetchall()] + priv_hist_present = any(s in "\n".join(a_hist_msgs) for s in PRIV_HIST_SENTENCES) + results["P2_positive_control_priv_hist_exists_in_A"] = { + "a_history_rows": len(a_hist_msgs), + "priv_hist_in_A_history": priv_hist_present, + "pass": priv_hist_present, + } + + # ---- P1/P2 ---- + r12 = p1p2_on(src_root, "B") + results["P1_extraction_pool"] = { + "leak": r12["p1_private_leak"], + "captured": r12["captured_prompts"], + "positive_control": r12["positive_control_prompt_has_public_content"], + "expect": "B 的提取提示词不含 A 的私密条目/标记，且捕获机制有效（正对照可见公开内容）", + "pass": r12["pass"] and priv_hist_present, + } + results["P2_history_window"] = { + "leak": r12["p2_private_history_leak"], + "expect": "get_last_messages 分库隔离：A 的原始输入不进 B 的提取提示词", + "pass": not r12["p2_private_history_leak"], + } + + # ---- P3 更新路径 ---- + pub = make_memory(PUB, src_root) + items = pub.get_all(filters={"user_id": "user-1"}).get("results") or [] + target = items[0] + pub.update(target["id"], data=target["memory"] + "（她补记：第二层留着）") + close_memory(pub) + a_vec_h1, a_hist_h1 = dir_hash(src_root / "vec_private"), history_db_hash(src_root / "mem0_private_history.db") + results["P3_update_isolation"] = { + "a_vec_hash_before": a_vec_h0[:16], "a_vec_hash_after": a_vec_h1[:16], + "a_history_hash_before": a_hist_h0[:16], "a_history_hash_after": a_hist_h1[:16], + "expect": "对 B 显式 update() 后 A 向量目录与 history 逐字节不变", + "pass": a_vec_h0 == a_vec_h1 and a_hist_h0 == a_hist_h1, + } + + # ---- P4 回读与预算装配 ---- + priv_m = make_memory(PRIV, src_root) + priv_count0 = len(priv_m.get_all(filters={"agent_id": "cg-companion"}).get("results") or []) + close_memory(priv_m) + pub = make_memory(PUB, src_root) + block, used = public_readout(pub, "诗集 书架 床头") + summary_block, _ = public_readout(pub, "最近我们在忙什么") + close_memory(pub) + leaks = privacy_scan(block) + privacy_scan(summary_block) + priv_m2 = make_memory(PRIV, src_root) + priv_count1 = len(priv_m2.get_all(filters={"agent_id": "cg-companion"}).get("results") or []) + close_memory(priv_m2) + a_vec_h2 = dir_hash(src_root / "vec_private") + results["P4_readout_budget"] = { + "block_len": len(block), "used": len(used), + "block_preview": block[:120], + "leak": leaks, + "a_items_before": priv_count0, "a_items_after": priv_count1, + "a_vec_hash_unchanged": a_vec_h2 == a_vec_h0, + "expect": "公开回读+600字预算装配零泄漏；A 条目数与内容不变", + "pass": (not leaks) and priv_count0 == priv_count1 and a_vec_h2 == a_vec_h0 + and len(block) <= BUDGET, + } + + # ---- P5 完整备份 → 恢复 → 复跑 ---- + bridge = ShareBridge(src_root / "share_control.db") + bridge.seed_event(1, PRIV_OTHER_EVENT, told=0) + bridge.seed_event(2, PRIV_TOLD_EVENT, told=0) + # 先做 F 系列时序（恢复前，在原实例上验证时序语义） + f_results = run_first_share(src_root, bridge) + results.update(f_results) + + # 完整备份（清洁关闭后复制）：2 向量目录 + 2 history + 分享控制库 + 配置清单 + backup_dir = GATE / "full_backup" + backup_dir.mkdir() + manifest = { + "contains": ["vec_private", "vec_public", "mem0_private_history.db", + "mem0_public_history.db", "share_control.db", "backup_manifest.json"], + "note": "完整备份含尚未分享的内部记忆（总管核对版执行限定2）", + "base": "hel-857 gate2 synthetic", + } + (backup_dir / "backup_manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2)) + for name in ["vec_private", "vec_public"]: + shutil.copytree(src_root / name, backup_dir / name) + for name in ["mem0_private_history.db", "mem0_public_history.db", "share_control.db"]: + shutil.copy2(src_root / name, backup_dir / name) + + # 恢复到全新路径 + restore_root = GATE / "restore" + restore_root.mkdir() + for name in ["vec_private", "vec_public"]: + shutil.copytree(backup_dir / name, restore_root / name) + for name in ["mem0_private_history.db", "mem0_public_history.db", "share_control.db"]: + shutil.copy2(backup_dir / name, restore_root / name) + + # 恢复后检查 + priv_r = make_memory(PRIV, restore_root) + priv_items = priv_r.get_all(filters={"agent_id": "cg-companion"}).get("results") or [] + close_memory(priv_r) + r12r = p1p2_on(restore_root, "B-restored") + pub_r = make_memory(PUB, restore_root) + block_r, _ = public_readout(pub_r, "诗集 书架 床头") + close_memory(pub_r) + # 内部可查（她的连续性），公开出口不泄漏 + priv_r2 = make_memory(PRIV, restore_root) + internal_hit = priv_r2.search(PRIV_MARKER, filters={"agent_id": "cg-companion"}) + close_memory(priv_r2) + internal_ok = len(internal_hit.get("results") or []) >= 1 if isinstance(internal_hit, dict) else bool(internal_hit) + results["P5_full_backup_restore"] = { + "backup_files": sorted(p.name for p in backup_dir.iterdir()), + "restored_private_items": len(priv_items), + "restored_private_has_unshared": any(PRIV_OLD in (it["memory"] or "") for it in priv_items), + "internal_recall_priv_marker": internal_ok, + "restored_public_outlet_leak": privacy_scan(block_r), + "restored_P1P2": {"p1": not r12r["p1_private_leak"], "p2": not r12r["p2_private_history_leak"]}, + "expect": "恢复后：内部未分享经历仍在且内部可查；公开出口（检索+预算装配）仍不泄漏；P1/P2 复跑通过", + "pass": len(priv_items) >= 2 + and any(PRIV_OLD in (it["memory"] or "") for it in priv_items) + and internal_ok + and not privacy_scan(block_r) + and not r12r["p1_private_leak"] and not r12r["p2_private_history_leak"], + } + + ok = all(v.get("pass") for v in results.values()) + return {"ok": ok, "network_outbound": 0, "results": results, + "notes": {"stub": "OpenAILLM.generate_response 实例级替换，捕获全部提示词，零网络", + "bridge": "ShareBridge 为我方编排（生产 life/public.py 语义重放），add 原语来自 SDK", + "api_finding": "SDK 的 search/get_all 返回项不回传自定义 metadata（锚点在向量库 payload 中，需直读 payload）；产品接线需适配层读取锚点", + "leak_criterion": "内容级判据：返回项文本包含私密标记才算泄漏；语义近邻命中本身不是泄漏"}} + + +def run_first_share(root: Path, bridge: ShareBridge) -> dict: + """F1-F6 首次分享时序（总管核对版执行限定1）。""" + out: dict = {} + + def pub_leak(marker: str) -> int: + """内容级泄漏判据：返回项文本中含 marker 的条数（语义近邻命中不算泄漏）。""" + pub = make_memory(PUB, root) + res = pub.search(marker, filters={"user_id": "user-1"}) + hits = res.get("results") or [] if isinstance(res, dict) else res or [] + n = sum(1 for h in hits if marker in (h.get("memory") or "")) + close_memory(pub) + return n + + def pub_anchored(event_id: int) -> int: + """直读向量库 payload 统计迁移锚点条数（search API 不回传自定义 metadata）。""" + pub = make_memory(PUB, root) + from qdrant_client import models as qm + pts, _ = pub.vector_store.client.scroll( + collection_name="cg_public", limit=100, with_payload=True, + scroll_filter=qm.Filter(must=[qm.FieldCondition( + key="life_event_id", match=qm.MatchValue(value=event_id))])) + close_memory(pub) + return len(pts) + + def try_migrate(root: Path, message_id: int, event_id: int) -> bool: + pub = make_memory(PUB, root) + try: + return bridge.maybe_migrate(pub, message_id, event_id) + finally: + close_memory(pub) + + # F1 判定失败：不迁 + bridge.attempt(101, 1, state="failed", ack=True) + migrated = try_migrate(root, 101, 1) + n = pub_leak(PRIV_OTHER_EVENT) + out["F1_judgment_failed_no_migration"] = { + "migrated": migrated, "public_content_leaks": n, + "pass": (not migrated) and n == 0, + } + # F2 未确认（ack_at NULL）：不迁 + bridge.attempt(102, 1, state="judged", ack=False) + migrated = try_migrate(root, 102, 1) + n = pub_leak(PRIV_OTHER_EVENT) + out["F2_unconfirmed_no_migration"] = { + "migrated": migrated, "public_content_leaks": n, + "pass": (not migrated) and n == 0, + } + # F3 取消：不迁 + bridge.attempt(103, 1, state="cancelled", ack=True) + migrated = try_migrate(root, 103, 1) + n = pub_leak(PRIV_OTHER_EVENT) + out["F3_cancelled_no_migration"] = { + "migrated": migrated, "public_content_leaks": n, + "pass": (not migrated) and n == 0, + } + # F4 成功：完整回执确认+分享判定完成 → 按实际已讲内容迁入，带锚点；A 仍保留 + bridge.attempt(104, 2, state="judged", ack=True) + migrated = try_migrate(root, 104, 2) + n = pub_leak(PRIV_TOLD_EVENT) + anchors = pub_anchored(2) + priv = make_memory(PRIV, root) + priv_still = priv.get_all(filters={"agent_id": "cg-companion"}).get("results") or [] + close_memory(priv) + out["F4_success_migrates_told_content_with_anchor"] = { + "migrated": migrated, "public_content_hits": n, "anchored_payload_entries": anchors, + "a_still_keeps_internal": any(PRIV_TOLD_EVENT in (it["memory"] or "") for it in priv_still), + "pass": migrated and n >= 1 and anchors == 1 and + any(PRIV_TOLD_EVENT in (it["memory"] or "") for it in priv_still), + } + # F5 重复回执：不重复迁入 + dup = try_migrate(root, 104, 2) + n2 = pub_leak(PRIV_TOLD_EVENT) + anchored = pub_anchored(2) + out["F5_duplicate_receipt_no_duplicate_migration"] = { + "second_call_returned": dup, "anchored_payload_entries": anchored, + "pass": (not dup) and anchored == 1, + } + # F6 其他未分享事件仍在公开库之外 + n3 = pub_leak(PRIV_OTHER_EVENT) + out["F6_other_unshared_still_hidden"] = { + "public_content_leaks_priv_other": n3, + "pass": n3 == 0, + } + return out + + +def make_memory_public(root: Path): + m = make_memory(PUB, root) + return m + + +def main(argv: list[str]) -> dict: + from .common import write_result + out = run() + write_result("gate2_privacy.json", out) + return out + + +if __name__ == "__main__": + raise SystemExit(0 if main([])["ok"] else 1)