xiaoxue_admin/memoryweave
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

merge into: xiaoxue_admin/memoryweave:feat/memory-confidence
Branches Tags
xiaoxue_admin/memoryweave:main xiaoxue_admin/memoryweave:feature/knowledge-form xiaoxue_admin/memoryweave:feat/auto-feedback-calibration xiaoxue_admin/memoryweave:wt/t_e3f5cb79 xiaoxue_admin/memoryweave:t_31bb2992-prune-grace xiaoxue_admin/memoryweave:feature/distill-granularity-p2b xiaoxue_admin/memoryweave:feature/op-card xiaoxue_admin/memoryweave:hotfix/t_9143c968-usage-cursor xiaoxue_admin/memoryweave:backup/pre-pushfix-t_f640f6a0 xiaoxue_admin/memoryweave:t4c810e02-ipc-feedback xiaoxue_admin/memoryweave:fusion-t5d28ad74 xiaoxue_admin/memoryweave:t_b7a8ed9c-distill-trigger xiaoxue_admin/memoryweave:t_e5997ca4-gap-counter xiaoxue_admin/memoryweave:t_576714de-single-read-cap xiaoxue_admin/memoryweave:main-backup-20261017-2245 xiaoxue_admin/memoryweave:t_1c12e000-cache-inval xiaoxue_admin/memoryweave:feat/memory-confidence xiaoxue_admin/memoryweave:p1-merge-bounding xiaoxue_admin/memoryweave:fix-softdelete-only xiaoxue_admin/memoryweave:master
xiaoxue_admin/memoryweave:backup-main-before-merge
...
pull from: xiaoxue_admin/memoryweave:fusion-t5d28ad74
Branches Tags
xiaoxue_admin/memoryweave:feature/knowledge-form xiaoxue_admin/memoryweave:feat/auto-feedback-calibration xiaoxue_admin/memoryweave:wt/t_e3f5cb79 xiaoxue_admin/memoryweave:t_31bb2992-prune-grace xiaoxue_admin/memoryweave:feature/distill-granularity-p2b xiaoxue_admin/memoryweave:feature/op-card xiaoxue_admin/memoryweave:hotfix/t_9143c968-usage-cursor xiaoxue_admin/memoryweave:main xiaoxue_admin/memoryweave:backup/pre-pushfix-t_f640f6a0 xiaoxue_admin/memoryweave:t4c810e02-ipc-feedback xiaoxue_admin/memoryweave:fusion-t5d28ad74 xiaoxue_admin/memoryweave:t_b7a8ed9c-distill-trigger xiaoxue_admin/memoryweave:t_e5997ca4-gap-counter xiaoxue_admin/memoryweave:t_576714de-single-read-cap xiaoxue_admin/memoryweave:main-backup-20261017-2245 xiaoxue_admin/memoryweave:t_1c12e000-cache-inval xiaoxue_admin/memoryweave:feat/memory-confidence xiaoxue_admin/memoryweave:p1-merge-bounding xiaoxue_admin/memoryweave:fix-softdelete-only xiaoxue_admin/memoryweave:master
xiaoxue_admin/memoryweave:backup-main-before-merge
121 Commits
feat/memory-confidence ... fusion-t5d28ad74
Author SHA1 Message Date
小唯 4aa664c0cd chore(deploy): mark ae766a88 (AC11 fix) approved 2026-10-19 03:12:59 +08:00
小唯 ae766a88bb fix(deploy): AC11 reject unknown args + add --help/--dry-run (no side effects on error paths) 2026-10-19 03:11:53 +08:00
小唯 8f38c2de0c chore(deploy): t_debe2002 批准清单补档 4 条源码提交 + 部署卫生提交 35e3ca9/1957228/abcb4dd 2026-10-19 02:56:31 +08:00
小唯 abcb4ddef9 Revert "chore(test): t_debe2002 AC4 反例占位提交（仅加注释，验证闸门阳性）" 
This reverts commit 1957228d9e.
 2026-10-19 02:55:33 +08:00
小唯 1957228d9e chore(test): t_debe2002 AC4 反例占位提交（仅加注释，验证闸门阳性） 2026-10-19 02:53:55 +08:00
小唯 35e3ca9e42 fix(deploy): t_debe2002 评审夹带闸门结构性修复 + 部署清单自证版本 
- AC1 窗口算法：latest 取最新已批准祖先（rev-list HEAD 首命中）而非列表序首最老祖先，
  修掉 18 条误判（实际未评审仅 4 条源码提交）。
- AC2 ①：只改批准清单文件的部署卫生提交自动放行 + 批准清单文件移出洁净判据，
  打通 --mark-approved → deploy.sh 一次跑通的正规路径。
- AC6/AC7：修掉 2 处 die 消息里反引号命令替换注入（错误路径不再执行副作用）。
- AC8 ③：新增 ~/.hermes/state/zhiyi-deploy-manifest.jsonl 部署清单 + --verify 自证版本。
- AC3：批准清单补档 4 条源码提交（37890e30/772a597a/1f30474c/a1021bb7），各带卡 done 依据。
 2026-10-19 02:50:37 +08:00
小唯 37890e3095 feat(storage): t_5d28ad74 两路融合门一次接通 — ZHIYI_SORT_FUSION(默认关) score×(1+W_IMP×imp)+B_FB×(sat(useful)−sat(human_not_useful)); FeedbackScore.pos 移除 recall_verified_count(有害热度信号); 3 Go 测试(门关 delta=0 / 门开方向 / B_FB=0退化) 2026-10-19 00:36:03 +08:00
小唯 772a597a53 test(storage): t_7ba5e479 AC2 反馈信号进排序证明 — feedbackBias 门控 3 用例（门关 delta=0 / 门开 rank 下滑 / 正向对照）+ IncrementHumanNotUseful 走生产同一路径 2026-10-18 21:52:47 +08:00
小唯 1f30474cf3 feat(storage): t_789898bd importance 温度计 — 写入侧规则化 importance + env 回滚开关 + 存量回填工具 
AC1 lancedb_ipc.go:159/:200 硬编码 importance 1.0 改为规则调用:
  EffectiveMemoryImportance(m)   显式值优先; 规则开⇒档位; 关(默认)⇒回落1.0(零行为变化)
  EffectiveEpisodeImportance()   episode 原始日志 规则开⇒0.3 预留档; 关⇒1.0
AC2 规则档位(全库实测标定, 每档>=1%, 无值==1.0): core=0.9(4.11%) / normal×wiki,llm_distill=0.7(70.06%) /
  normal×legacy,unknown=0.4(25.84%) / normal×recovery=0.3(预留档)
  未纳入: 内容深度(78.1%<50字⇒切档违反>=1%) / 时间衰减(排序已有运行时recency项, 避免双衰减) / 图谱连接度(红线不碰图谱)
AC3 存量回填: rust bin importance_backfill(仅写 importance 一列, id IN 组提交 25 版本,
  提交冲突有界退避, verify 逐行复算, rollback=整表1.0 一个版本)。
  生产执行: 46,930 行全部回填, 恒1.0 行数 46,930 -> 0 (verify mismatch=0)
  备份: ~/.hermes/state/t_789898bd-importance-backup/memories-id-importance.csv (46,913 行, 全部 1.0)
AC4 golden 集合 before/after: mrr 0.4345→0.4345, ndcg 0.4722→0.4722, keyword 14/14 不变(差 0%, <±10%)
AC5 回滚开关 ZHIYI_IMPORTANCE_RULE(off=默认, 逐位等同改动前); 回滚命令:
  importance_backfill --data-dir /var/lib/memoryweave --mode rollback
单测: go test ./internal/storage/ 全过(5 个新 importance 用例); 回归: storage+models+api/routes 全过
 2026-10-18 21:27:17 +08:00
小唯 a1021bb70a feat(storage): t_7c0538eb AC5 低分可信评分记忆检索降权（可逆, env-gated, 默认关） 
fuseQuality 对「可信且 0<qs<0.30」的行, rawQuality 贡献乘低分降权系数
lowScoreDownweight(qs)=max(floor=0.5, qs/0.30)（随分单调递增, 高分不动,
0.0/0.755-echo 走不可信分支不受影响）。

回滚开关 ZHIYI_LOWSCORE_DOWNWEIGHT: 缺省/0/false 全关→系数恒 1.0,
行为与改前逐位一致（go test TestFuseQuality 基线未变）。
测试 quality_fusion_lowscdw_test.go: 同一候选集 gate 关/开/再关,
验证 L(低分高重要性) 被 M(普通分) 反超 + 回滚复原。
 2026-10-18 12:54:51 +08:00
小唯 e0412747f0 chore(deploy): t_20bfbd9a 批准清单补齐 14 个历史已评审提交 + HEAD 5f63b35 2026-10-18 02:22:18 +08:00
小唯 5f63b35602 chore(deploy): t_20bfbd9a 修正批准清单行粘连(每行一SHA) — 补齐 71d5f2a/941b7ee/3e29617 批准基线 2026-10-18 02:21:38 +08:00
小唯 3e29617cbe chore(deploy): t_20bfbd9a 追加批准部署基线 71d5f2a(优雅停止)+941b7ee(线程风暴根治) 2026-10-18 02:20:20 +08:00
小唯 941b7eec32 fix(storage): t_20bfbd9a 边车线程风暴根治 — Rust 连接并发上限+RSS护栏降级串行；命中事件重试跨commit指数退避+积压上限 
AC1 Rust accept 循环对每连接 thread::spawn 无上限，Go 侧每 rpc 新 dial ⇒
   IPC 洪泛线程线性涨到 736。加 AtomicUsize 连接门(默认64, env ZHIYI_CONN_MAX)，
   超限回 heavy_conn_busy；RSS 超上限(默认3000MB, env ZHIYI_RSS_LIMIT_MB)降级串行。
AC3 usage_recall 加 retry_count/next_retry_at：持久失败行指数退避(1s..600s)不再
   每 commit 热重扫；积压超 ZHIYI_USAGE_BACKLOG_MAX(默认500)本轮跳过扫描。
AC4 新增 usageBackoff/backlog 单测。Go 全仓测试通过。
 2026-10-18 02:19:03 +08:00
小唯 71d5f2a7cd fix(storage): t_fa797edd 优雅停止全程有界 — Stop 最终落盘不再无限阻塞 
根因：SIGTERM 到 StopRecallWriteBuffer()，Stop() 同步调用无界的 b.Flush()。
Rust/LanceDB 批量更新在活 IPC 流量下被卡住（生产实测 20:44 停止窗口内 Rust 侧
update_recall_batch 80s 未完成），Stop 永不返回，信号协程到不了 srv.Shutdown，
进程跑满 systemd 90s TimeoutStopSec 被 SIGKILL（丢写风险 + 重启不可控）。

修复：Stop() 全程有界 — 等后台协程 <=5s + 最终落盘 <=8s（goroutine+超时）。
召回统计丢失可接受（源码注释本就声明崩溃会丢最后一窗口），超时即放行退出。
新增反向用例 TestRecallWriteBufferStopBoundedWhenFlushHangs：flush 挂起时
Stop 在 8.0s 内放行（原实现无限阻塞）。storage 包全量测试通过，zhiyid 构建
exit=0。未部署（AC5 边界：仅改源码 + 隔离验证）。
 2026-10-18 00:51:46 +08:00
小唯 f6c373ea94 fix(governance): t_818f77be ExpandFromResults 导航起点 r.Category→正文实体 
InMemoryGraph(graph_expander.go:24)+FileGraph(graph_file.go:466) 旧实现拿
r.Category(类目名,如 distilled)当实体去 Navigate, 永远匹配不到任何图节点
⇒ 结构性零产出(实测 10/10 全 distilled, 0 graph_expanded)。InMemory 版另读
p[to]/p[from] 而 Navigate 返回 source/target, 双重零产出。

修复: 导航起点改为从 r.Content 提实体——复用现有 extract*Entities +
normalize*EntityID(与同文件 ExpandWithSummary 同一套), 不新造抽取逻辑;
InMemory 版路径键 to/from → source/target 一并对齐。Score:0.5 降权/去重/
pattern-peer 门控 均不动。

可观测性(AC2): 加 env 控 ZHIYI_GRAPH_EXPAND_DEBUG=1 的单行 debug 日志
(起点实体 N/命中 M/补入 K), 默认关低频, 保证下次坏了不沉默。

测试(AC4+AC3): graph_expand_e2e_test.go 4 用例锁死——小图(中文实体链)+
recall ⇒ 断言含 category=graph_expanded 且 Score=0.5; 10-recall 批量补入
改后 total=38(InMemory)/38(FileGraph); namespace 不匹配 ⇒ 补 0(次级阻塞
实证)。改前树副本跑同测试 ⇒ 全 0(复现结构零), 改后 ⇒ 38, 判别力成立。

FileGraph.AddNode/AddEdge 潜伏 RWMutex 自死锁(save 在写锁内取 RLock)不属
本卡, 测试改走 JSON 文件加载绕开。
 2026-10-17 23:52:51 +08:00
小唯 978f27a164 feat(api): /api/v1/recall 暴露 Rust 侧单次重读行数上限截断标志 truncated（t_3aa2a8c1） 
引擎已算（Rust ConsolidateResponse.truncated，t_576714de）且边车日志已打，
但 Go IPC 客户端只打日志不上抛 ⇒ /api/v1/recall 响应无法观测「结果被截断」。

- lancedb_ipc.go: 新增 SearchWithTruncation（上抛 ipcResp.Truncated；本地兜底/零结果恒 false）；
  旧签名 Search 委托之（行为不变）。
- recall.go: RecallMeta 加 Truncated；可选扩展接口 SearchTruncationReporter
  （纯 Go 后端/测试 fake 不实现 ⇒ 恒未截断）；粗检索两处调用点 OR 聚合。
- core.go: Recall 路由透传（hybrid/semantic/keyword + E4.2/wiki 补充搜 OR）；
  响应语义 = truncated 只在 true 时暴露（键缺失 = 未截断，等价 omitempty，注释已写明）。
- 不改：阈值 20000/ZHIYI_HEAVY_READ_MAX_ROWS、降级行为、其他响应字段。
- 测试：假 sidecar 协议级验证透传 + 路由级 4 例（截断/未截断/纯Go后端/keyword），
  逐测试摘除 SearchCacheInstance（storage init() 全局 + 共享 Redis L2 ⇒ 跨 run flaky 的根因）。

实测（独立数据副本 /tmp + 独立 socket，未部署生产）：
- cap=300：top_k=3/25000 响应均含 truncated:true；边车日志
  [zhiyi-ipc] search top_k=400 CLAMPED to 300 (single-read cap 300), truncated=true
- 默认 cap：truncated 键缺失；边车 CLAMPED 0 行
- 既有字段 cache_hit/candidates_scanned/count/mode/results 不变
 2026-10-17 23:48:26 +08:00
小唯 0bfa7a4bc1 fix(storage): t_bd718662 /recall topK∈{1,2} 让位截断负索引 panic — FTS 尾部位让位数封顶 min(3,F,现有条数) 
根因：results 已满(len==topK)时 budget 硬编码 3，topK∈{1,2} 且 fresh≥2/≥3 时
cut=len(results)-nAppend<0 ⇒ results[:cut] 负索引（线上 trace [:-2] @ recall.go:846，
48h 15 次 / 本次复现 20/20 确定性触发）。
修法（附录 C）：让位前 nAppend=min(nAppend,len(results)) ⇒ cut≥0 恒成立；
让位只做等量替换不追加扩张（全仓唯一裁剪点仍 recall.go:854，AC-D 计数=1）。
topK≥3 路径 nAppend≤3≤len(results) 封顶不生效 ⇒ 零行为变化（golden diff 为空）。
新增 TestFTS_SmallTopKTailMatrix（topK∈{1,2,3}×len(results)∈{0,1,2,topK}×len(fresh)∈{0,1,2,3,5}
=50 格，断言不 panic+len≤topK+无重复 ID+尾部 FTS 集合精确）+ TestFTS_SmallTopKGolden
（topK 3/4/5 逐字输出，修前修后 diff 空）。修前 topK1_P1_F2 格 panic [:-1] 复现。
部署另开卡（本卡边界：源码+单测+本地验证，不部署）。
 2026-10-17 23:15:40 +08:00
小唯 25f68831fd fix(test): 合并两个 TestMain 为单一合并体（t_e5997ca4 落盘点护栏 + t_b7a8ed9c 打分缓存护栏） 
两卡分支各自在 routes 包加了 TestMain，合入 main 后 multiple definitions of TestMain
⇒ routes 包 setup failed（全套测试拦下）。按 t_b7a8ed9c 文件顶部的合并提示，把两个
TestMain 体合进 testmain_test.go 并删除 scorecache_guard_test.go。

验收（小怡实跑）：
- go test ./internal/api/routes/ → ok 50.344s（修前 setup failed）
- E2E TestCommitConflictGate_E2E → PASS 3.70s；日志 '[scorecache] 已禁用（ZHIYI_SCORE_CACHE=0）'
- 测试不再污染生产 Redis：distill-score 键数 3096 → 3096（不变）
 2026-10-17 22:53:43 +08:00
小唯 42fafc495f merge: t_b7a8ed9c 测试隔离(ffc5b10) —— 打分缓存测试不再写生产 Redis，经小怡在分支上实跑验证 2026-10-17 22:49:05 +08:00
小唯 d4b8688148 merge: t_e5997ca4 gap 计数器写侧统一(45726d2) —— 经小怡终审通过（+1 收敛到编译期唯一入口） 2026-10-17 22:49:05 +08:00
小唯 bd399dd007 merge: t_576714de 单次重读设界+IPC重连(c015feb) + t_c70f385c 指标N/A护栏(44fd0e9) —— 均经小怡终审通过 2026-10-17 22:49:05 +08:00
小唯 ffc5b108c6 fix(test): t_b7a8ed9c routes E2E 被 distill 打分缓存 Redis L2 静默短路 — TestMain 关缓存 + Once 活读 env 
根因（非卡内假设的 flush 触发条件重构）：
- a162e27 打分记忆化 + ce38465 L2 改生产 Redis（zhiyi:distill-score:*，TTL 168h）
  后，routes 包测试（无 TestMain 关闭开关）把「测试内容哈希→结果」写进生产 Redis；
  7 天内后续 run L2 命中 → mock LLM 被短路 → 计数断言 base+1 必挂。
- 实测 TestCommitConflictGate_E2E 16.5s 固定 FAIL（got 0）；日志证明 flush 正常
  触发且跑完（batch=1 → DONE），缺的只是 LLM 那次 HTTP 调用。
  生产残留键 TTL≈40h（2026-10-17 复核 143207s）即污染源，TTL 自然过期。
- 对齐门禁规矩③（加缓存须给该包 TestMain 加关闭开关）：
  routes 新增 scorecache_guard_test.go TestMain 设 ZHIYI_SCORE_CACHE=0；
  distill.getScoreCache 的 Once 闭包活读 env（包级变量 init 时定型，跨包测试设不了；
  生产语义不变，启动时 env 仍在此处生效）。

验证：go test ./internal/api/routes/ -count=1（不 -skip）ok 34.9s；
go test ./internal/distill/... ./internal/api/... ./internal/selfoptimize/... 全 ok。
⚠️ t_e5997ca4 分支同包加了 testmain_test.go（ZHIYI_DASHBOARD_PATH 护栏 TestMain），
两分支合并时须合并成一个 TestMain。
 2026-10-17 22:34:01 +08:00
小唯 45726d26a7 fix(selfoptimize): t_e5997ca4 gap 计数器写侧统一 — +1 只在 open→closed 迁移点 + 计数器 v2 版本化重置 
根因（小怡 2026-10-17 终审实测定位）：写侧仍有未收口的事件式自增点，
ClosedGaps(9) 越过 TotalGaps(2)，gap_closure_rate 被 -1 断言拦下但指标永久不可解读。
  ① routes/gaps.go:44  POST /close 在 Close() 之后无条件 Dash.RecordGapClosed()
     ⇒ 同一缺口每次调用都 +1（无限计数）。且实测现行注册为前缀路由
     /api/v1/gaps/close/（无 {topic} 通配）⇒ PathValue 恒为 ""、端点恒 400，
     该自增点当时不可达，但一旦注册改通配即复活。
  ② server.go:1950  gap_scan 自动修复循环 AutoRepair 成功只计数不关缺口
     ⇒ 同一缺口每轮再 +1（无限虚增，线上 9 vs 2 的主要来源）。

修复：
  - Close/RecordHit 返回 bool（是否真发生 open→closed 迁移）；+1 唯一入口
    收敛到迁移点内部；RecordGapClosed 降为包内 recordGapClosed（编译期堵死
    跨包事件式自增）。
  - gaps.go 删无条件 +1；补前缀路由 topic 解析（端点自此真正可用），
    响应如实区分 closed / already_closed。
  - server.go 修复循环改「修复成功 ⇒ 关闭缺口」（RepairHandler 同语义），
    下一轮 !g.Closed 即跳过，计数只在迁移点。
  - 历史 9 vs 2 处置选 (b) 计数器版本化重置：dashboard_schema_version=
    dashboard_schema_v2 标记入 Redis HASH + 本地 JSON（既有 90 天 TTL 键，
    不新增键）；首载无标记 ⇒ ClosedGaps/TotalGaps 归零并回写标记（一次性、
    可机械复核），标记在位 ⇒ 保真。代价：丢失不可信的 gap 历史累计。
  - 口径不变：ClosedGaps/TotalGaps = 缺口个数；Metrics() 越界断言保留作
    安全网（不当修复用）。

测试：
  - selfoptimize: Close×3 / RecordHit×3 / 修复循环 3 轮 ⇒ 各只 +1、rate<=1；
    SchemaV2 一次性重置 + 标记在位保真（v1 文件 9/2 载入归零、v2 值保真）。
  - routes: POST /close ×2（现行前缀注册 + {topic} 通配注册两形态）⇒ 只 +1、
    auto_* 计数器快照不变；新增 TestMain 把 ZHIYI_DASHBOARD_PATH 指到临时目录
    （先例：selfoptimize 包同款，防测试写生产落盘点）。
  - 判别力证明（/tmp 改前树 c015feb 旁证副本，不进仓库）：逐字复刻改前两写
    路径 ⇒ ClosedGaps diff=6 > TotalGaps=2（rate 3.0 越界，线上 9 vs 2 同型）
    FAIL；改后同场景 diff=2、rate=1.0。

边界：只动 gap 计数器与调用点；部署不在本卡（t_ad887e7c，待牧尘放行）。
 2026-10-17 22:12:40 +08:00
小唯 c015febb49 zhiyi: 单次重读行数上限 + Go IPC 读 deadline + 每 rpc 新 dial (t_576714de) 
N=2 准入只拦并发堆叠、不拦单请求自身内存：一次 top_k 大 / scan_all
仍能把单条 zhiyi-consolidate 顶到 1~2GB+ 致 swap thrash（t_eedb2d39 根因）。

改动：
- rust/main.rs: ZHIYI_HEAVY_READ_MAX_ROWS（默认 20000，可覆盖）clamp
  lancedb_search top_k + scan_all/scan_deleted；响应体加 truncated:bool
  （#[serde(default)] 向后兼容旧 Go 客户端）；zhiyi_ping 暴露当前 cap。
- rust/lancedb_ops.rs: scan_all/scan_deleted 的 .limit(200_000) 参数化为 max_rows。
- go/lancedb_ipc.go: ipcReq/ipcResp 加 Truncated；rpc() 用 SetWriteDeadline(30s)/
  SetReadDeadline(120s)（原 io.ReadFull 无 deadline = 侧车挂死永久阻塞的根源）；
  Search/ScanAll/ScanDeleted 截断时打日志（不静默）。
- go/ipc_reconnect_test.go: TestIPCReadDeadlineBoundsHungSidecar（纯 Go，挂死侧车
  被读 deadline 兜住 ~801ms）+ TestIPCReconnectAfterSidecarRestart（env 门控，
  真 sidecar 杀→快速失败 37µs→重启→重连成功）。

隔离副本 /tmp 实测：封顶 20k peak RSS ~1.17GB vs 不封顶 200k ~1.60GB/80s。
不部署（部署另批，需小怡终审 + 牧尘放行）。
 2026-10-17 21:52:06 +08:00
小唯 44fd0e95b4 fix(metrics): t_c70f385c 消费者 N/A 护栏 + daily-check N/A 显示 + 反例测试 
小怡终审 2026-10-17 21:05 必须修的 4 项之一（-1 哨兵被当低分 ⇒ 触发器恒 fire）：

1. selfoptimize.go: 新增 IsNA(v) 判 N/A（metricNA<0）。
2. executor.go: TGapDetected/TQualityDrop/TVValueLow 阈值比较前显式判 N/A，
   -1 不再被当「低于阈值」每轮触发（与旧 recall_hit_rate 恒=1 同类失真、方向相反）。
   配 executor_na_test.go 反例（v=-1 断言不触发）+ 正向对照。
3. tuning.go: AnalyticsHandler 建议 builder 抽为纯函数 AnalyticsSuggestions，
   统一走 ratioFor（-1/valid=0/样本不足 ⇒ 不产生建议）；配 tuning_analytics_test.go 反例。
4. 两个 daily-check.sh: gap/auto/usefulness 值为 -1 时显示 —(N/A)，不再打印误导性 -1/天。

测试命令（go.mod 在 go/ 下，须 cd go）：
  cd go && go test ./internal/selfoptimize/... ./internal/api/routes/
（TestCommitConflictGate_E2E 为既有环境性 LLM 蒸馏用例，非本次改动路径，单独 FAIL）

生产部署仍待小怡终审 + 牧尘放行（本卡边界）。
 2026-10-17 21:22:28 +08:00
小唯 b2a016e90f fix(metrics): t_c70f385c 指标口径修复 — recall_hit_rate 退役 + gap_closure_rate 断言 + 最小样本门 N=20 
- recall_hit_rate 退役：分子原为 core.go 的 len(results)>0（恒=1、无区分度），
  「返回且被使用」语义已由 recall_usefulness_rate 承担（207 样本 0.98）。
  Metrics()/distributed/metrics-gauge/executor/tuning/CLI/daily-check 全链移除该键。
- gap_closure_rate 统一为「缺口个数」口径：Close() 加 !g.Closed 守卫（与 RecordHit 一致），
  根治同一缺口重复关闭导致 ClosedGaps 虚增、越界 4.5；Metrics() 加越界断言 gapRate>1 → -1。
- 所有率类指标加最小样本门 minRateSamples=20：样本<20 ⇒ -1 + valid=0，
  杜绝 auto_resolve_rate 2 样本判满分。
- 测试：metrics_retire_regression_test.go 用生产同款计数复现改前/改后 JSON；
  selfoptimize 全套通过。
 2026-10-17 20:32:34 +08:00
小唯 cee68592e3 feat(deploy): 部署夹带闸门 preflight_reviewed_commits（t_3f83df64）——构建基准 HEAD 相对 tracked 批准清单比对，未评审提交默认拒绝（--allow-unreviewed / --mark-approved 显式放行）；起因：01:18 生产二进制夹带 584fe37 等未评审提交 2026-10-17 08:28:01 +08:00
小唯 c3747755b6 feat(rust): t_690cc333 重读准入信号量 N=2 — search>1000/forget_window/scan_all/scan_deleted 计数门限并发内存(3×search10000吞1.5G swap⇒OOM⇒3800写失败的放大器)；无许可有界等待100ms后拒heavy_read_busy(不排队不占内存)，轻op(ping/insert/update/stats)永不门控；写路径零改动；env ZHIYI_HEAVY_READ_CONCURRENCY可调；zhiyi_ping增heavy_read_in_flight观测。AtomicUsize门(本机toolchain无std::sync::Semaphore) 2026-10-17 01:09:47 +08:00
小唯 4bbf59dabe feat(rust): t_89d22fc8 风暴守卫(AtomicBool+ConsolidatingGuard)+zhiyi_ping健康探针 —— 全量consolidate独占槽防线程堆积OOM；探针判据connect≤3s+ping往返≤5s 2026-10-17 00:06:40 +08:00
小唯 0c0494dabd fix(storage): t_34ec2b1f 时间偏置×信任系数门 ZHIYI_TIME_BIAS_TRUST(默认关·逐位等价) 
门关=现状(旧循环, 连乘法都不产生)。门开只降「可靠打分且低质」(0<q<0.6)：
  · 不可信族(legacy/recovery/migrat) f=0 → 低质迁移/恢复残留不享受新鲜度加分(P0: q=0.5 wiki:recovery:P0 残留 rank1→9)
  · 可信源 f=q(单调, f(0.5)=0.5<f(1.0)=1.0)
  · q<=0(未打分)/q>=0.6(含0.755 echo) 保原偏置 f=1.0 —— 回归护栏: 全量不可信族清零会误降 152 金标里高质量 legacy(q=0.755/0.805)答案(实测 152=73<75, golden=13<14), 本设计将其排除
与 ZHIYI_SOURCE_TIER_BIAS 作用域不相交(tier 只加 decision, 不含于不可信族)→ 不双重计数。
A/B(隔离实例·独立数据副本·不碰生产7821): 152=76≥75, golden=14/14 不退化; AC1 低质被抬升 396→194(-51%); AC4 双口径一致。
单测: TestIsUntrustedSource / TestTimeBiasTrustFactorMonotonic / TestTimeBiasGate{Off,On,NoDoubleCount}。
 2026-10-16 23:05:56 +08:00
小唯 a214cf4a0e fix(storage): t_7793a484 命中事件写路径缺口 — AppendHitEvent 冲突即终态丢（当天 42 条）⇒ 加与 Update 同规格有界重试 
- lancedb_ipc.go: AppendHitEvent 原单次 lancedb_append_hit_event（Rust 内部 20 次
  commit 重试耗尽后不重发）⇒ 冲突即终态丢。现加 retryAppendHitEventRPC（同
  t_28aa278e 规格：3 次重试 + 50/100/200ms 指数退避；仅可重试 MVCC 冲突；
  非可重试立即返回）。幂等安全：hit_events 是 append-only INSERT，行 id =
  memory_id+unix微秒 唯一，MVCC commit conflict 时整个提交原子不生效（不产版本），
  重放不产生重复行（与 update col+1 重算同语义，官方 rerun-the-operation）。
- usage_track.go CheckCommittedForUse: 修复前 _ = 吞 AppendHitEvent 错误（10-16
  42 条丢失的主来源）；现终态失败 ⇒ 打 [usage] hit event append FAILED 行 +
  不消费 usage_recall（consumed=0 下轮 commit 重扫重试），与 t_28aa278e
  「更新成功后才消费」同构。
- metrics.go: 新增计数器 zhiyi_hit_event_append_failed_total（/metrics 暴露，
  AC3 异源口径：日志 AppendHitEvent FAILED 行 ⇔ 计数器值）。
- IncrementUseful 无需加重试（AC1 代码依据）：它走 rc.Update → retryUpdateRPC
  （t_28aa278e 已含 3 次重试）；当天 2 条 'IncrementUseful failed' 实测是
  'retry exhausted after 3 retries'（风暴内 4 次尝试全冲突的终态耗尽），
  非「一次冲突即放弃」。残留：feedback 人工路径无 rescan 兜底（同 Update 现状）。
- 测试 hit_event_retry_test.go（复用序列式 fakeServer，全程临时目录+fake socket，
  绝不打开 /var/lib/memoryweave）：冲突 3 次→第 4 次成功（重试行 1/3,2/3,3/3 +
  retried OK after 3 + 终态失败归零）/ 恒冲突 4 次有界 + 计数器 +1 / 无冲突恰 1
  次 rpc 0 退避（AC4 逐位等价）/ 非可重试不重试 / 修复前后数值对比（终态失败 1→0）。
  更新 TestCheckCommittedForUse_NotConsumedOnExhaustion 断言（恒冲突总 rpc 5→4：
  AHE 先行耗尽即 continue）。
- 纯 Go 改动，无 Rust/无 schema/不部署（AC5：部署另提卡经牧尘放行，prod-write-gate 会拦）。
  回滚一行：git revert <本提交>。
 2026-10-16 22:46:03 +08:00
小怡 a2f355a994 feat(metanote): 影子档 ZHIYI_META_FILTER=shadow（命中只记 would-reject，不拦写）—— 激活前观察期 2026-10-16 22:44:45 +08:00
小怡 fa3490e794 chore(evidence): t_5ad3f843 交付说明（AC 逐条 before/after + 咽喉点收口 27/27 + 终审亲跑证据 + 未部署核定） 2026-10-16 22:26:31 +08:00
小唯 05100339f8 feat(metanote): t_5ad3f843 meta-note 分类门禁（Go 侧，ZHIYI_META_FILTER=1 启用，默认零行为变化） 
- internal/metanote：21 条正则 Go 等价式 + 判定逐步同序镜像 Python 口径真相源
  （scripts/lib/meta_note_filter.py）；\b/\w 映射显式化：\w→[[:word:]\pL\pN]、
  \b 剥离改匹配值前缀边界校验（pre/post/both 三表，未被裸替代项覆盖才校验）
- parity/差分三件套（同 memprotect 范式）：
  * Go 等价式 == 变换函数(Py 源式) 逐字节锁死
  * 实时 dump Python 常量逐字节比对（漂移即 FAIL）
  * /tmp 副本异变必须让 parity FAIL（负控）
  * 14 正+11 负+14 边界+SOT 用例表 全量差分 vs 真实 Python classify
- 咽喉点接线 4 处：Commit/WriteMemory/BatchCommit（422 拒绝+skipped_meta）
  + AutoDistillTrigger（admin distill/force 经此函数一并覆盖）
- handler 级验证：门禁开 meta⇒422 先于触碰 storage（零值 API 不 panic）
- 只新增/改 go 侧与判定，未碰 7821/生产二进制/生产 unit/存量记忆，门未激活
 2026-10-16 21:59:28 +08:00
小唯 00747be2db chore(evidence): t_492e3f22 teardown 记录 + 零残留判据 + 4 条 run log 
跨卡通知 t_004cc147（内存告警）要求补：测试栈 27G 全下线（双孤儿 zhiyid 已由
prof-cloud SIGTERM，本侧停 sidecar + 删 /tmp/zyvfuse-t492e3f22 + 顺带清
dryrun-dir/mem-copy.lance/spike*）。终验：ps -C zhiyid 空 + du /tmp/zyvfuse-* 无残留。
 2026-10-16 19:45:25 +08:00
小唯 08a649792e feat(quality): fuseQuality V值分支 env 门 ZHIYI_V_FUSE_ENABLE（t_492e3f22 次症C） 
默认（unset/0）= 保持现状逐位不变；=1 = 关 V 分支（v>0 不再加权）。
AC1 默认不碰: PRE(旧二进制) ≡ DEF(新·默认) — 152 verdict 指纹/top5 顺序/probe10/golden 全同
AC2 翻转证据: DEF vs NOV 排名变化=0（v>0 融合分轴生效、cosine margin 主导无换位）
AC4 受影响条数: v>0 实测 152×5=2/760, probe10×20=2/195（预期 2-3，V 衰减漂移）
AC5 回滚复核: RBK(重启·默认) == DEF verdict 指纹 2318948a + golden 14/14
AC6 异源复算: independent_recheck（第二张口径）与主口径一致，无矛盾
含代码 + 单测（TestFuseQuality_VGateOn/Off）+ 证据包 docs/ac-evidence/t_492e3f22-v-fuse-gate/
 2026-10-16 19:40:24 +08:00
小唯 584fe37c35 feat(memory): 主症A 显式记忆直写路径 /api/v1/memory/write (t_fa6c9104) 
- POST /api/v1/memory/write: 同步嵌入→去重(0.90合并)/插入 memories 表→
  矛盾检测(只报告不拦)→201 含 memory_id。嵌入失败=502 不写任何东西
  (杜绝零向量)；短内容400；GET 405；commit 端点零回归(W6)。
- 插件 memory_write 工具改走新端点(直写可召回)，404 自动回落旧 commit 路径。
- eval_test: 金标实跑读活密钥(/var/lib/memoryweave/.api-key)，修 2026-09-21
  密钥轮换后 TestEvalGolden_Live 恒 SKIP 的 401 根因；判据未动。
- 已部署 /home/muc/bin/zhiyid-new(v3)；重启待操作员执行(审批门控)。

不含 t_492e3f22 未提交的 quality_fusion 改动(留在工作树)。
 2026-10-16 18:55:20 +08:00
小唯 525f11f531 fix(governance): t_944344b5 返修R2 — 保护口径逐字对齐 zhiyi_protection.py（10词表+distilled门）+ 口径一致性测试 
第1轮评审阻断项修复：
- D1 关键词表 7→10 逐字对齐 Python DECISION_RE（用户明确/牧尘要求/牧尘拍板/
  用户拍板/拍板/明确要求/用户偏好/牧尘决定/用户决定/硬性要求），
  删除 Go 自造词（明确指示/决策/偏好/preference/decision）
- D2 关键词分支加 category=="distilled" 门（Python 为 elif cat==distilled），
  其他 category 含关键词不保护；标签 explicit_protected→decision_content（与 Python 同名）
- D3 注释更正：删除无出处的「2026-08-24 牧尘裁定/7词/完全同规则」声明，
  改为「zhiyi_protection.py 为口径唯一真相源 + 逐字对齐 + 改动须报 default」
- D4 新增口径一致性测试（终审侧硬要求）：
  · TestDecisionKeywordsParity —— 实时解析 Python DECISION_RE.pattern/DECISION_CATS/
    V_THRESHOLD 与 Go 常量逐字比对，漂移即 fail（不许手抄声明同口径）
  · TestDifferential_PythonReference —— 同一 fixture 表(A~J+K/L)喂 Go IsProtected 与
    真实 Python is_protected（纯内存），逐例断言一致
  · TestDifferential_FixtureTable —— 手写期望表（CI 安全基线）
- D6 LoadState V 值解析失败聚合记一条日志（注释与代码一致）
- server.go/admin.go 守卫注释补「distilled 且命中」限定

全表差分（t944344b5-ruleset-diff-v2.py，只读）：live 28350，
Python 保护 10587 == Go 保护 10587，PYTHON-only=0 / GO-only=0（对称差=0）。
staged 二进制 r2 sha 405d32e3…（未部署，AC5 门禁）；生产二进制 7d9ed410… 未动。
 2026-10-16 13:03:29 +08:00
小唯 8f57bd0fae feat(governance): t_944344b5 自动遗忘(decay/auto_forget)保护守卫 — 命中保护规则的记忆禁止软删 
- 新增 internal/memprotect：与 zhiyi_protection.py 同口径的 4 条保护规则
  (category∈{decision,preference,pref}/distilled决策关键词, V值≥2.0,
   freshness=verified, id∈zhiyi:protected_ids)；Redis 宕机降级为纯行内规则。
- server.go decay 循环 + admin.go 自动遗忘路由：在 fragment/ShouldForget
  两条 SoftDelete 道之前拦截，命中即 skip 并打 [decay|forget] protected skip 日志。
- redis.go 增补 SMembers/SIsMember（读 protected_ids）。
- lancedb_ipc.go：IPC 候选补 Freshness 列；forgetCursorPath 支持
  ZHIYI_FORGET_CURSOR 环境变量覆盖（测试不碰生产游标）；
  抽出 unmarshalMemoryRecordsTolerant 统一 ScanAll/ScanDeleted 宽容解析
  （修复 ScanDeleted 遇空时间列 time.Time 解析报错的潜在 bug）。
- 新增 memprotect 单测(8) + 端到端回归测试 forget_guard_e2e_test.go
  (复制数据目录+独立 socket，未设 PROT_TEST_SOCK 自动跳过)。

AC1/AC2 已在副本 /tmp/mw-prot-copy-20261016-122000 上验证通过；
生产二进制已备份(zhiyid-new.bak-t_944344b5-20261016-115413, sha 7d9ed410…)
并另存 staged 二进制，**未**上活库（待 default 终审，AC5）。
 2026-10-16 12:31:02 +08:00
小唯 211d516e5f fix(distill): t_a0831457 P0 解耦——写时四操作门控不再劫持基础 InsertMemory（shadow/off 恒插入，门控只管标记）+ env 改名 ZHIYI_WRITE_SEMANTIC_OPS（旧名兼容一档） 
根因：ApplyWriteOp 在 shadow(默认)/off 恒返回 shouldInsert=false ⇒ api/server.go 蒸馏写回路径
`if !shouldInsert { continue }` 把基础 InsertMemory 整个跳过 ⇒ 2026-10-14 起每日蒸馏事实
2053/1094/1559 → 384 → 0 全丢（shadow log 2189 条判定，2120 条该落库的被弃；episodes 原始层完整可重蒸）。
违背了门控自身注释声明的「默认 shadow ⇒ 零行为变化」硬要求（零变化=等价特性不存在，之前基础插入总是发生）。

改动（三模式语义表）：
- shadow(默认) ⇒ 插入新条 ✓ + 不做任何标记 ✓ + 记 shadow log ✓
- apply        ⇒ 插入新条 ✓ + 做标记 ✓（NOOP 丢弃；apply 语义不变，回归测试守住）
- off          ⇒ 插入新条 ✓ + 不跑判定 ✓（零开销）
1) write_ops.go ApplyWriteOp：!writeOpsApply() 分支 false→true（门控不参与插入决策）
2) api/server.go 调用点：verdict!=nil 包一层；err/!shouldInsert 丢弃路径仅剩 apply+NOOP 与 apply 标记失败，均显式 warning（禁静默）
3) AC10：ZHIYI_WRITE_OPS → ZHIYI_WRITE_SEMANTIC_OPS（防「所有写操作开关」误读）；旧名兼容一档+弃用日志（sync.Once 只打一次）；默认值仍是 shadow
4) 回归测试 write_ops_regression_test.go（旧代码上先红已实证：shadow 4 判定/默认/off 5 项 FAIL）：
   断言 shadow 下四操作均 shouldInsert=true 且 MarkSuperseded/MarkConflict 零调用（AC2 增补）
5) 旧测试 TestWriteOps_Noop 改写：其「shadow+NOOP 不插入」断言即 bug 语义本身（量具自证：该测试随修复必须改，否则回归门失效）

边界（AC6）：不动 episodes 层、不删任何 memories、不改默认值（仍 shadow，改的是 shadow 的语义）；
与 284584c（lancedb_ipc.go/usage_track.go）文件不重叠，合并部署=一次观察协议+一个回滚点。
未部署：按 AC3/AC9 交证据包（diff+测试红/绿+md5+回滚方案+观察协议）本体转呈牧尘拍板。
 2026-10-15 22:53:03 +08:00
小唯 284584c578 fix(storage): t_28aa278e 方案① Update 冲突自动重试+指数退避 且 usage_track 更新成功后才消费 
- lancedb_ipc.go: Update() 遇 LanceDB MVCC 写冲突不再静默吞错(恒返 nil)，改为复用
  isRetryableLanceConflict 模式做有界指数退避重试(updateMaxRetries=3, 50/100/200ms, cap 200ms,
  最坏+350ms)；耗尽/非可重试返回明确错误(含尝试次数+id)。新增 retryUpdateRPC(table,id,fields)
  (table/fields 参数化，区别于软删专用 retrySoftDeleteRPC)。保留 "Update OK/FAILED" 日志标记，
  重试成功打 "retried OK"、耗尽打 "FAILED (retry exhausted)"，失败数可查。
- usage_track.go: CheckCommittedForUse 改为「更新成功后才消费 usage_recall 行」——
  Update 返回非 nil(冲突耗尽/非可重试) ⇒ consumed 保持 0，下轮 commit 重扫会重试，
  计数增量不再静默丢失(修复前无条件 consumed=1 永久丢)。
- 测试: 复用序列式 fakeServer 新增 TestUpdate_{ConflictRetry_PreservesIncrement/AlwaysConflict_ExhaustsBounded/NoConflict_ExactlyOnce_NoBackoff/NonRetryableError_NoRetry/RetryFix_BeforeVsAfterComparison}；
  更新 TestConcurrentCommitConflict_CrossPath(断言修复后重试到成功、缓存/库一致) 与
  TestCheckCommittedForUse_ConsumesOnConflict→NotConsumedOnExhaustion(耗尽不消费)。
- 纯 Go 改动，无 Rust/无 schema/不部署(AC5 边界)；不改 t_2be29a01 评分、不碰 t_022b116f 守卫。
 2026-10-15 21:32:41 +08:00
小唯 bdc18f6177 fix(recall): t_1a30330b scan_all 读侧漏接 last_recalled_at（恒 String::new() ⇒ 误诊全库为空）+ ZHIYI_LAST_RECALLED_WRITE 冲突重试门控（默认关=现状） 
根因：本体审计用 scan_all 计数 last_recalled_at，而 rust/lancedb_ops.rs 的 scan_all/search/query_memories 三处均硬编码 last_recalled_at: String::new() ⇒ 全库看似 0 非空 ⇒ 误判「写入缺失、遗忘判据退化」。实际 forget_window（遗忘循环真正读侧）读到 78.8% 非空、含当日 321 条写入 ⇒ 写入工作正常。

修复：
1. 三处读侧接线 last_recalled_at: col_str(&batch,i,"last_recalled_at") —— 根治误诊，审计/列表/测量现可见真实值。
2. env 门控 ZHIYI_LAST_RECALLED_WRITE（默认关=现状）：开=对 update_recall_batch 的 Commit conflict 重试一次（重开表拿新 read_version），提高并发下 last_recalled_at 落盘率。默认关 ⇒ 生产零行为变化。
 2026-10-15 21:08:39 +08:00
小唯 b017c35d37 test(storage): t_b845d2d6 复现 recall_verified_count 并发提交冲突——两条写路径(Update持锁 vs UpdateRecallBatch不持锁)在单巨片段表上重叠必冲突 + Update静默吞错致计数丢失 
机制: LanceDB MVCC 乐观并发, 全部 37358 行落在单 fragment(533268),
任何单行 update 都整段重写 ⇒ 两条重叠提交必冲突(与写哪行无关)。
Go _local.mu 只串行 Update-vs-Update, 串行不了 vs UpdateRecallBatch;
sidecar(main.rs:238) 每连接一线程, 无提交串行化。
本测试用 fake socket server 镜像该并发窗口, 确定性复现:
① 并发提交 conflicts>=1  ② Update() 对冲突返回 nil(静默)  ③ 冲突后 usage_recall 仍 consumed=1 ⇒ 计数丢失
 2026-10-15 21:00:27 +08:00
小唯 c12f55ef71 feat(distill): t_ffcee190 非规则卡短事实 keep 档穿透（env 门控 ZHIYI_SHORTFACT_KEEP_PASSTHROUGH，默认关=现状） 
observe 档真实对话自然短事实被 <20字/实体动词 启发式误杀（真实对话子集 ~62%，t_1c420e43 量化）。
新增 env 门控（默认关=零行为变化）：
- effectiveFilterLane：env 开 且 lane=observe 且 非规则卡(content 非 [规则: 前缀) → 走 LaneKeep 穿透
- 规则卡恒返回原 lane ⇒ 碎片零泄漏（规则本体在 skill）
- 不动 IsQualityFact 阈值、不动 lane 分类器
单测 6 例锁定：默认关等价 / 规则卡不穿透 / 非规则卡救回 / 疑问状态硬否定仍生效 / 规则卡碎片仍丢 / 默认关委托现状
 2026-10-15 20:20:12 +08:00
小唯 e52f335998 feat(recall/fts): t_287c6d51 FTS 尾部位门槛按 query bigram 数分档（1-bigram→env 可放宽至~0.15 / ≥2-bigram 与混合恒 0.5），默认全 0.5=零行为变化 2026-10-15 19:04:31 +08:00
小唯 24d6c46065 feat(recall/fts): t_da61c470 两处 env 门控（默认=现状，零行为变化） 
改点A · FTS 纯 CJK（bigram-only）尾部位门槛可配：
  - FtsBigramTailGate()/IsBigramOnlyQuery()（fts_index.go）
  - Step 3.8 尾部位门槛：bigram-only 查询走 FtsBigramTailGate()（默认 0.5=现状），
    混合/ASCII 查询恒 0.5。权重公式不动。
  - env ZHIYI_FTS_BIGRAM_TAIL_GATE≈0.15 时，纯中文专名 bigram 档分 0.16~0.256 能拿尾部位。

改点B · rerankN 下限 env 门控：
  - envInt() 助手（recall.go）
  - rerankN:=topK*2 之后加 floor（env ZHIYI_RERANK_N_FLOOR，默认 10=V2 OFF 现值）。
    A/B 设 25 救『池内有货被二次截断』（8081 组 ANN #17~21 / QE 后淇县 #13）。
    只抬下限不抬上界，V2 ON 的 150 不动。

默认值 = 现状 ⇒ env 不设时行为零变化（AC2/AC4 判据）；回滚 = unset 两个 env。
零 DB 写入；只读接口 + 本地源码。
 2026-10-14 19:41:38 +08:00
小唯 e42d19cfd9 fix(eval): t_dfc93ad0 AC5 golden 缺省路径内嵌兜底 + AC6 回滚时效说明 
AC5：部署二进制 CWD=/home/muc，旧版 LoadGoldenSet("") 回落相对
testdata/golden-set.json ⇒ POST /api/v1/eval/golden 不传 golden_path 时
500（2026-10-14 实测复现）。修：//go:embed testdata/golden-set.json 打进
二进制，缺省/读不到的路径回落内嵌基线（仍可用）；env ZHIYI_GOLDEN_SET
可指定绝对路径临时替换。新增 TestLoadGoldenSet_EmbedFallback_DeployCWD
（空 CWD 下缺省/相对路径均 14 条）防回归。

AC6：fts_index.go 门控注释补「撤标志 ≠ 立即生效」——recall 路径
TTL=60s 搜索缓存（cache_hit），撤门控后 60s 内同 query 命中 ON 态缓存
（终审「撤门控仍 14/14」假象根因=两次测量隔 9s）。可证伪判据：
回滚后等 >60s（实操 75s）或重启 zhiyid 再跑 eval/golden，期望 MMR 条
keyword_pass 13/14 且 cache_hit=false。
 2026-10-14 17:32:09 +08:00
xiaowei e5bd7c7576 feat(recall): t_2afae95e 修 #4 满列表尾部位扩为 3 个 ASCII 档槽位 
实测：MMR 查询下 FTS top-3 = E1档#1(0.797) + MMR档#2/3(0.753)，
旧版满 topK 只让 1 个尾部位 ⇒ 给 E1 档文档（内容无 MMR）⇒ 关键词
校验仍 13/14。扩为尾部最多 3 个 ASCII 档（分≥0.5）槽位：MMR 档文档
必进 top-5；bigram 噪声档（<0.32）不占槽位（只补未占满余位），
头部向量文档至多让 3 位且仅当 FTS 真有强命中。新增
TestFTS_RecallFullListTailSlots 钉住满列表场景（修前挂，修后过）。
 2026-10-14 14:58:23 +08:00
xiaowei 3594456df3 fix(fts): t_2afae95e 修 #3 ASCII 档占比分母只用 ASCII 词 IDF 和 
旧版分母混入 bigram IDF 和（占 Σ 大半）⇒ MMR-only=0.594 / E1-only=0.599
近乎打平，排序退化成按 id 走（实测 MMR 文档压在同分 E1 文档后面）。
改分母 = ASCII 词 IDF 和 ⇒ MMR-only=0.764 / E1-only=0.786 / 双命中=1.0，
序稳定可解释；bigram 噪声档 <0.32 不变。
 2026-10-14 14:45:43 +08:00
xiaowei 3fa7850f01 fix(fts): t_2afae95e 打分改类型感知分层（ASCII 命中 ≥0.55 / 仅 bigram ≤0.32） 
生产实测缺陷（二踩后定位）：纯 IDF 排序被 CJK bigram 噪声反杀——
查询「MMR 多样去重」下 55-token 天气问答撞中某 df=1 bigram 拿满 IDF
分 0.976 霸占 FTS top-1（尾部保证位取 top-1），而真正含 MMR 的
8-token 目标文档（n_tokens=8）只排 #21 ⇒ golden 关键词校验仍挂 13/14。
任务明写「稀有 ASCII 词/标识符/数字优先」⇒ 分层：
  - 命中任一库内 ASCII 查询词 ⇒ 0.55 + 0.45×(命中词 IDF 占比) ∈ [0.55, 1.0]
  - 仅命中 bigram（无 ASCII 命中）⇒ 0.32×(1-1/(nb+1))，封顶 <0.32
⇒ bigram 噪声文档永远压不过 ASCII 命中文档，尾部位必选 ASCII 档。
新增 TestFTS_ASCIIHitBeatsBigramNoise 钉住该分层（修前该场景挂，修后过）。
 2026-10-14 14:23:53 +08:00
xiaowei 827de4f65a fix(fts): t_2afae95e 打分改稀有词主导（0.55*稀有分量+0.45*总量分量） 
实测缺陷：纯总量 TF-IDF 分被高频 CJK bigram 稀释——MMR 查询下，
无 MMR 的高分 bigram 文档（0.252）压过含 MMR 的文档（0.147，排 #13），
尾部 1 位保证位选了错文档 ⇒ 关键词校验仍挂（13/14）。
改为 0.55*(命中词中 IDF 最大者的分/maxIDF) + 0.45*(总量分/全词IDF和×2)：
只命中稀有 MMR 的文档稀有分量≈1.0，无 MMR 文档=0 ⇒ 稀有词重新主导。
顺带：FtsQuery 扩 check_doc 异源复证 + topN 排序改 O(n log n)。
 2026-10-14 13:52:48 +08:00
xiaowei 808b9862c9 feat(fts): t_2afae95e 新增 /api/v1/fts/query 取证端点（AC1 判据命令，观测词面 topN 命中排序） 2026-10-14 13:45:50 +08:00
xiaowei b69cc01d52 fix(fts): t_2afae95e FtsIndexStats 取值移入持锁区间（旧版 RUnlock 后读字段=数据竞争） 2026-10-14 13:22:54 +08:00
xiaowei 80d0a37116 fix(lancedb): t_2afae95e ScanAll 血缘 5 列一并 shadow 宽容（version_history 等 Rust 输出 JSON 串） 
Rust scan_all 对 version_history/depends_on/source_events/supersedes/
superseded_by 输出 JSON 数组字符串，Go 模型是 [] 类型 ⇒ 直接 unmarshal
整批炸（FTS 首建二踩：parsing time 修完下一个炸 version_history）。
全部 shadow 成 string + 宽容还原（空串/[]/畸形 ⇒ nil）。测试同步扩到 8 列。
 2026-10-14 13:19:26 +08:00
xiaowei 793bfefc61 fix(lancedb): t_2afae95e ScanAll 时间列宽容解析（空串/畸形不炸整批） 
FTS 首建实测踩到：scan_all unmarshal: parsing time "" ...（存量行
created_at/last_recalled_at 有空串）。直接 unmarshal 到 []models.MemoryRecord
时 time.Time 严格解析把 2.6 万行全炸 ⇒ 索引建不起来。
改外层匿名 struct 用 string shadow 三个时间字段 + 宽容 parse（空/畸形⇒零值）。
新增 TestScanAllTimeTolerance 钉住该行为。
 2026-10-14 13:13:58 +08:00
xiaowei db6ab564dc feat(recall): t_2afae95e FTS 词面检索通道（TF-IDF 倒排，Go 内存索引，env-gate 默认关） 
根因：金标 MMR 条目的关键词只在向量 rank #126/12094 的记忆里 ⇒ 调权重救不回来，
embedding 主导的链路没有真正的词面检索通道（卡内 2026-10-14 实测定位 4 处）。

- 新 internal/storage/fts_index.go：TF-IDF 倒排（ASCII 词+CJK bigram，与
  tokenizeQueryV2 同口径；IDF=log2(N/df+1)，TF=1+log(tf)）。数据源=ScanAll
  （Rust IPC lancedb_scan_all 只读）；索引落 Go 内存，不建 LanceDB tantivy
  索引文件/不碰 LanceDB 版本链（_versions 膨胀历史教训）。
- 生命周期：启动 3s 首建（同步）+ 6h 周期 + 写路径 FtsInvalidate 标脏后
  异步重建（代际号防双重建互踩；30min 节流防 loader 缺失时疯狂起 goroutine）。
  重建异步 ⇒ 在线召回 P95 不受建索引影响。
- recall.go Step 2.2：词面命中不进主候选池（无向量，混入会让 rerank 回退
  文本重编码路径）；Step 3.8 rerank+MMR **之后**尾部保证位追加（诊断第 3 条：
  融合必须在 rerank 之后才算数；头部 topK-1 相对顺序不动 ⇒ AC4 零回归）。
- models.RecallResult 加 FtsBoosted（omitempty，展示侧可辨来源）；
  QualityScore 保持 DB 原值（词面分只进排序不进展示分，对齐『响应值==库值』铁律）。
- server.go：FtsProvider 挂 ScanAll + 蒸馏落库后 FtsInvalidate +
  /api/v1/cache/stats 加 fts_index 段 + /api/v1/fts/rebuild 手工刷。
- 门控 ZHIYI_RECALL_FTS=1 或标志文件 /var/lib/memoryweave/recall-fts.on，
  默认关 ⇒ 零行为变化；回滚 = 删标志文件/置 0，一条命令。
- 单测（双向验证）：稀有词取回/TF-IDF 排序/门控关零变化/尾部去重/raw 剔除/
  IDF 形状/空库边界。go test ./internal/storage ./internal/models 全绿。
 2026-10-14 13:02:37 +08:00
小唯 339642b2c8 Reapply "fix(recall): 中文关键词打分 V2 + 扩候选池（env/标志文件门控，默认关）" 
This reverts commit 1cdeb4a54b.
 2026-10-14 10:42:01 +08:00
小唯 c2683fd6a9 Reapply "fix(recall): V2 关键词分必须进入最终排序（原被 rerank 整段丢弃）" 
This reverts commit 9236d8d4b4.
 2026-10-14 10:42:01 +08:00
小唯 1cdeb4a54b Revert "fix(recall): 中文关键词打分 V2 + 扩候选池（env/标志文件门控，默认关）" 
This reverts commit 4565026b09.
 2026-10-14 10:40:44 +08:00
小唯 9236d8d4b4 Revert "fix(recall): V2 关键词分必须进入最终排序（原被 rerank 整段丢弃）" 
This reverts commit 43a9cc8751.
 2026-10-14 10:40:44 +08:00
小唯 43a9cc8751 fix(recall): V2 关键词分必须进入最终排序（原被 rerank 整段丢弃） 
实测：Step 3.5 的 BM25 融合作用在 candidates 上，紧接着 rerank 按 cosine 重打分
并只保留 topK*2 条 ⇒ 关键词分被整段覆盖，且相关记忆（cosine 排名 #126）在那 20 条
之外 ⇒ 无论池子放多大都无效（V2 开/关结果逐条相同，就是这么来的）。

改动（仅 V2 生效）：重排候选 topK*2 → 至少 150；rerank 后按
score = 0.7*rerankScore + 0.3*kwV2 融合，再进 MMR 与截断。
 2026-10-14 10:38:49 +08:00
小唯 4565026b09 fix(recall): 中文关键词打分 V2 + 扩候选池（env/标志文件门控，默认关） 
实测根因（2026-10-14，golden 条目「织忆如何通过 E1 提取和 MMR 实现多样去重」）：
① 候选池太窄：per-ns 向量 top-50（candCap 100），而含 MMR 的记忆向量排名 #126/12094
   ⇒ 根本进不了池，后续任何打分都救不回来。
② 旧 ComputeBM25Score 用 strings.Fields 只按空格分词、整段短语做子串计数
   ⇒ 中文查询的关键词分基本失效，且无 IDF（稀有词不加权）。
③ 融合 0.7*quality + 0.3*kw，而 IPC 路径下 quality 会饱和到 1.0（代码注释原话）
   ⇒ 候选间质量分几乎相同 ⇒ 排序实际由失效的 kw 决定 ⇒ 退化成向量原始顺序。

改动（ZHIYI_RECALL_V2=1 或标志文件 /var/lib/memoryweave/recall-v2.on 开启）：
- ComputeBM25ScoreV2：查询切 ASCII 词（权重 10，廉价 IDF 代理）+ CJK 二元组（权重 1）。
- 扩池：per-ns 50→200；candCap 100→300。
默认关 ⇒ 行为零变化。单测双向验证：mmr=0.3125 vs generic=0.0312。
 2026-10-14 10:34:45 +08:00
小唯 b13cdea910 chore(eval): 按 per-item ns 重建金标基线（14 条 → 唯一基线） 
- 基线全部按各条 ns 的当前 top-1 重建：原 14 条里 4 条共用同一 id，现已唯一。
- 结果：kw_hit 几乎全 true（此前失败的两条「技术栈」「牧尘偏好」现均命中）
  ⇒ 证实那 2 条是 ns 假失败，不是召回缺陷。
- 刷新结论 pass=2 / warn(漂移)=11 / fail=1 —— 漂移是基线重建的正常表现。
 2026-10-14 10:22:39 +08:00
小唯 88d466d156 fix(eval): 金标集 per-item namespace —— 修「ID 指标按构造恒 0」 
实测根因（2026-10-14，查 LanceDB 得到）：金标的 expected_id 分散在
hermes-main / domain:HUB / soulful-xiaowei / wiki / shared 多个 namespace，
而 eval 只用请求里的单一 ns（hermes）召回 ⇒ 所有 ID 类指标必然为 0。
这不是「基线漂移」（我先前两次判断都错在这里）。

同时暴露金标集本身的问题：4 条（#1/#9/#11/#12）共用同一 expected_id、
多条基线内容与 query 不匹配（如「图谱扩展机制」钉的是「待处理织忆图谱更新」）。
⇒ 框架没问题，数据是烂的。

改动：
- GoldenSetItem 加 Namespace 字段；RunGolden 用 item.Namespace（空则回落到请求 ns）。
- 金标集 14/14 条补 namespace=hermes-main（内容实际所在），基线随后用
  golden-check.py --refresh 按当前 top-1 重建。
- 同口径修 Python 量具 golden-check.py（recall 支持 namespace 参数）。
 2026-10-14 10:21:42 +08:00
小唯 faf71cbe99 fix(tuning): 调参接线消费方 + 阻尼 + 持久化（治「旋钮没接到任何东西」） 
实测三真相（2026-10-14）：
① 无消费者 —— grep Tuner. 全仓只有 3 处路由注册，没有任何代码读
   Diversity/GapThreshold/DecayRate/DistillInterval ⇒ 调参改了数字、行为零变化。
② 不幂等（棘轮）—— 同一判据每调一次推一步：连跑两次 decay 0.015→0.018→0.0216。
③ 不持久化 —— 包级内存变量，重启即回默认。

修法：
- 接线：storage.SetDefaultMMRDiversity / selfoptimize.SetGapThreshold（消费者持值、调参器推送，
  避免 storage←routes 反向依赖）。初值对齐消费方真实默认（Diversity 0.5→0.3）⇒ 当天行为不变。
- 阻尼：同一参数 6h 冷却。
- 持久化：/var/lib/memoryweave/tuning-state.json（env ZHIYI_TUNING_STATE 可覆盖），启动 load+接线。
- 删规则3（废弃率→提高衰减率）：方向危险 —— NewForgetter 注释记载
  「0.015→0.03 曾致误删(36天库龄下 0-recall 长记忆全被清)」。
- 删规则5（蒸馏损失→缩短蒸馏间隔）：无正确消费方 —— engine.go 的 batchTimeout 是
  「队列冻结兜底 ticker」（安全网），不是蒸馏节奏。

测试 4 个：哨兵/少样本拦截、冷却、推送、持久化（含「健康数据仍能调」反向验证）。
 2026-10-14 09:50:09 +08:00
小唯 113e6e8274 fix(tuning): AutoTune 加指标可用性护栏 —— 无数据(-1)/退化/样本<30 一律不调参 
事故面（实测现网）：
- gap_closure_rate = -1（无数据哨兵）⇒ 规则4 'gapRate < 0.5' 恒真 ⇒ 每轮把 GapThreshold 往下砍
- recall_usefulness_rate 只有 9 个样本 ⇒ 一次偶然好评就改 Diversity
即：AutoTune 会**按垃圾指标改生产运行参数**，且从不记'为什么没调'。

修法：用 selfoptimize 早已定义好的约定（<_base>_rate / _valid / _samples，
分母退化时比率返回 -1）判定可用性；三类不可用一律跳过，绝不改参数。
并在 status/run 暴露 last_skipped，让外部能区分'健康'与'数据不可用'。

注：命名不统一（值键 avg_distill_loss 无 _rate 后缀），用 TrimSuffix 推 base ——
我第一版按 '<key>_samples' 拼键，护栏静默失效，被新增的双向验证测试当场逮住。
 2026-10-14 09:41:36 +08:00
小唯 de0ddf4b8b chore(deploy): bi-temporal e2e 闸门接进部署流程（堵『写了但永不开火』的洞） 
背景：t_763e8701 交付了 bitemporal_e2e_test.go，但该测试默认 t.Skip
（需 ZHIYI_BITEMPORAL_SOCK 指向运行中的 sidecar）。没人设环境变量 ⇒
这道『机器闸门』永不开火 ⇒ 等于不存在（机制铁律：写完无人调用 = 零效力）。

改动：do_verify 增加 verify_e2e_bitemporal() ——
用本次已安装的 sidecar 开临时 socket + 临时 data-dir（不碰生产库），
跑 Go e2e（真实 LanceDB 写→读回），失败即 die。

起因事故：t_3ada332b 单测全 PASS 但生产 no-op —— 三列在 LanceDB 边界
被静默丢弃（Go payload 缺 3 键 + Rust schema 缺 3 列），
validityExpired 永远拿到空串 ⇒ 降权永不触发。本闸门即该事故的守门人。

验证（双向）：
- 通过路径：deploy.sh --verify-only 全绿，含『✔ bi-temporal e2e 闸门通过』
- 失败路径：把测试指向不存在的 socket ⇒ go test 返回 FAIL（非零）⇒ 函数 rc≠0 即 die
 2026-10-14 05:05:24 +08:00
小唯 d0558e1fd5 fix(zhiyi): t_763e8701 返修 bi-temporal 三列未落 LanceDB — 补齐 Go payload+读回 & Rust schema+builder+读侧 5 层 
根因：t_3ada332b 只改了 models 结构体 + server.go 算值，LanceDB 边界三层缺失
(Go lancedb_ipc.go 写 payload + 读回解包、Rust arrow_schema + struct + builder + col_str)
⇒ valid_to 永不持久化 ⇒ validityExpired("") 恒 false ⇒ 失效降权生产 no-op。

本次(照 t_3e98b65a 给 superseded_by 的 5 层模式逐一对齐)：
1. Go lancedb_ipc.go 写侧 payload 补 valid_from/valid_to/provenance 三键
2. Go 读侧补三处：Search 解包struct+输出映射 / Scan 解包struct+输出映射 / GetSkillCandidates mapStr 路径
3. Rust lancedb_ops.rs struct 字段(#[serde(default)]，存量行不报错)
4. Rust arrow_schema Field::new 三列(nullable，存量由 open() 迁移补列)
5. Rust 写 builder col vec + push + StringArray + 5 处读侧 col_str

新增 e2e 回归闸门 bitemporal_e2e_test.go：经真实 LanceDB sidecar 写一条 valid_to 已过期记忆
→ 读回断言三列非空且等于写入值(ZHIYI_BITEMPORAL_SOCK 门控，未设跳过)。
单测(AC1/AC2/AC3/AC4)+e2e 全 PASS；全量 go test 仅既有 flaky TestCommitConflictGate_E2E(clean baseline 同败)。
 2026-10-14 05:01:27 +08:00
小唯 12f808d0e1 feat(zhiyi): t_3ada332b P3 bi-temporal 有效期 — memories 表加 valid_from/valid_to/provenance(默认空=永久有效) + 写时识别时间敏感事实(distill/bitemporal.go DetectValidTo 只认强时间词+带触发上下文显式日期, 误报止损) + 写路径填 valid_to/provenance + 召回降权(recall.go validityExpired, env 门控 ZHIYI_BITEMPORAL=0 默认关零行为变化, non-lossy 只剔候选不删库); 单测 storage 3(AC1/AC3/AC4)+recall 2(AC2)+distill 4 PASS; 全量 go test ./... 仅预存 flaky TestCommitConflictGate_E2E(clean baseline 同败,归因 t_fcadee04) 2026-10-14 04:11:52 +08:00
小唯 44ccb69ca5 chore(deploy): deploy.sh 加构建前洁净检查 + ignore 探针残留 
起因（2026-10-14 当晚三次同族事故）：
① f8ffcde 把另一任务在途的 server.go 布线一起提交 ⇒ HEAD 编译不过；
② deploy.sh 原先直接从**工作树**构建 ⇒ 任一 worker 在途改动会被顺手编进**生产二进制**，
   且部署后『运行二进制校验和 == 本次构建』仍然通过 ——
   校验和只能证明『跑的是本次构建』，不能证明『本次构建来自已提交代码』。这是验证链的洞。

改动：
- preflight_clean_tree(): git status --porcelain（含未跟踪）非空则拒绝构建；
  显式 --allow-dirty 可覆盖（风险自负，须在卡上记原因）。
  含未跟踪是刻意的：internal/peer 那类事故正是『已提交代码引用未跟踪文件』。
- .gitignore: /go/*-probe（清 17MB 残留 rulefirst-probe）

验证：闸门在 build 前 die（rc=1），生产未动（两服务仍 active、二进制时间戳不变）；
--verify-only 不受影响。
 2026-10-14 03:44:39 +08:00
小唯 95cc81db4b feat(zhiyi): P3 Peer Representation (t_f8fc97e6) — Honcho四层推理画像 explicit→deductive→inductive→abductive; 新 internal/peer 包(CollectFacts分类+Reasoner接口化:生产8081本地2B,测试Fake零网络)+peers表(graph.db同库,不碰state.db)+API POST /peer/{id}/refresh+GET explain+POST /recall/peer+主召回注入(env门控ZHIYI_PEER_RECALL默认0零行为变化)+commit异步钩子(非阻塞); 单测6+8+3 PASS; 幂等non-lossy合并 2026-10-14 03:39:49 +08:00
小唯 f8ffcde0f4 feat(distill): t_3e98b65a 写时四操作(ADD/UPDATE/NOOP/CONFLICT-MARK)+写前哈希去重——Mem0血统 
影子默认(ZHIYI_WRITE_OPS=shadow,零行为变化;=apply才真改库):
- 新 distill/write_ops.go: 归一化+MD5哈希去重(ContentHash)、规则基四操作判定
  (defaultJudge可注入JudgeFunc/ContradictionFunc,生产可接governance矛盾检测)、
  shadow日志JSONL(/var/lib/memoryweave/write-ops-shadow.log)
- 四操作: ADD新建/UPDATE旧条标superseded_by+新条active/NOOP丢弃记log/
  CONFLICT-MARK双方标conflict交人工(永不自动删)
- server.go OnDistillComplete 写路径挂四操作判定(影子只记不改库)
- schema: models+sqlite.go+lancedb_ipc.go+rust 加 superseded_by 反向指针列(additive)
- 顺手: engine.go Weights/echoScoreVectors 补 MemOS 血统出处注释(借鉴溯源全清单§2.1)
- 报告生成器 scripts/tools/zhiyi-writeops-report.py(影子48h后出分布+误判抽样)

AC: 四操作各1单测+哈希去重+影子零变更全PASS; go build全过;
Rust release build 0; 除既有flaky TestCommitConflictGate_E2E(干净HEAD同败)外go test全绿
 2026-10-14 03:18:13 +08:00
小唯 0afff5734e feat(zhiyi): L3 skill 自动草稿 (t_fcadee04) — skills表(graph.db同库,不碰state.db)+草稿落盘attachments(<pattern>/skill-draft.md带[AUTO-DRAFT],绝不进skills/)+POST /patterns/{id}/draft+promote(draft→active人工确认); 生成器接口化(生产复用8081本地2B,测试FakeGenerator零网络/CGO); 显式API不挂cron默认零行为变化; 单测11+5用例PASS; 幂等:重复draft覆盖内容,active不覆盖 2026-10-14 02:35:50 +08:00
小唯 ef4f379736 refactor(storage): t_5028c14d 抽出召回融合纯函数 + 回归测试锁死「频率/时间衰减参与排序」 — Search()内联算法逐位等价抽到 quality_fusion.go(computeRecencyFactor/computeImportance/fuseQuality), 行为零变化不改数值; 新增单测锁定频率↑/越近→融合分↑; go build 0; 除既有flaky TestCommitConflictGate_E2E(干净HEAD同败)外全绿 2026-10-14 02:05:00 +08:00
小唯 aab877a13c fix(distill): t_c06ad4d0 解污染——蒸馏回调改走独立计数 distill_success_count，不再灌 UsefulCount/recall_usefulness_rate 分子; 拆账不丢数(字段+RecordDistillSuccess+Redis/本地持久化+Metrics键); 回归测试10次蒸馏⇒UsefulCount仍0、无反馈样本rate仍metricNA 2026-10-14 02:01:36 +08:00
小唯 1cfb17ac5e chore(git): 停止跟踪 13 个 *.bak.* 改动前快照 + .gitignore 加规则防复发 
这些 .bak.<topic>-<ts> 是各卡改动前的备份快照，被多张卡（proofchain/timedecay/standing）
陆续 commit 进版本库，累计约 4800 行纯垃圾，且会随历史永久保留。
git 本身就是版本历史，备份快照不属于版本库。

做法：git rm --cached（磁盘文件保留，不动内容）+ .gitignore 加 *.bak.* 。
本 commit 不触碰任何源码。
 2026-10-14 01:57:18 +08:00
小唯 8364ff1b36 feat(standing-answers): t_e9a4d18f P2 常设答案(mental models)——standing_answers表(SQLite+Rust schema)+读写存储+API直读(/api/v1/standing-answers)+注册表(3问)+生成脚本zhiyi-standing-answers.py(复用本地2B); 单测4/4 PASS; 默认不注入行为零变化 2026-10-14 01:47:58 +08:00
小唯 57bdf7fa03 feat(zhiyi): ②L2 模式检测+召回注入 (t_d32e5f8a) — 复活 L1→L2 pattern 蒸馏: 新 internal/pattern 包(工具组合频率≥3 + 路径 cosine≥0.85 聚类,设计§4.1)→ upsert graph_nodes(type='pattern',ns=daemon-distill)(与 85 存量同表不开新表·modernc sqlite 短命开/关·不碰 state.db); API POST /patterns/detect + GET /patterns + zhiyi-cli pattern detect/list(cron 可单发); 召回注入 env 门控 ZHIYI_PATTERN_RECALL 默认关⇒零行为变化; 单测 12 用例(detect5+store4+注入3+route4 含空库幂等)PASS; 零新依赖不碰 state.db 2026-10-14 01:44:39 +08:00
小唯 d2348eda43 feat(distill): t_2515307a 确定性判据强化——召回侧规则过滤/降权(env门控ZHIYI_RULE_FIRST默认关); RecallRuleVerdict复用quality.go+admission_lane规则+URL/路径强实体豁免; routes/core.go Recall按verdict过滤drop/降权demote; 单测16用例PASS; 影子探针rulefirst-probe/scan取证26drop+4demote; 零新依赖不碰state.db 2026-10-14 01:28:10 +08:00
小唯 467d9b4ac1 fix(metrics): 分母退化返回 N/A(-1) 而非 1 + 每项比率自报 samples/positive/negative 
牧尘批准「分母退化就返回 N/A 而非 1」。逐项落地：
- 新增 metricNA(-1) 哨兵：真实比率必落 [0,1]，-1 不可能被误读成任何一档成绩
- 6 项比率/均值统一走 rateOrNA()：分母<=0 ⇒ -1（旧实现返回 0，0 意为「0%」同样是没资格下的结论）
- 每项配 <name>_valid(1=可解读) / <name>_samples(分母) / usefulness 另配 positive/negative
  ⇒ 让「负样本饥饿」可被机器读出，无需魔法阈值
- distributed.go Prometheus 渲染同步：HELP 注明 -1 语义 + 输出 *_valid/*_samples，
  并警告看板须先按 *_valid 过滤，否则 -1 会拉低均值

只增键、不改键名 ⇒ 全部既有消费方（SyncFromDashboard / 各 JSON 端点）不受影响。
单测 5/5 新增 PASS；既有 2 例断言旧语义（零状态=0）已按本意更新为对齐零状态值。
go build ./... 通过；go vet 干净。

⚠️ 尚未解决（另案）：recall_usefulness_rate 的真病灶是 server.go:384 在蒸馏完成回调里
调 RecordUseful() ⇒ 分子数的是「蒸馏成功次数」、分母是「召回负反馈次数」，两者不同源。
本 commit 只让它可被看见，未改该调用点（server.go 当前有其他 worker 在改，避免撞车）。
 2026-10-14 01:25:45 +08:00
小唯 ef64da6df2 feat(zhiyi): ⑤使用追踪 (t_5aa4dcac) — 召回→后续内容携带→判定被用上, env门控ZHIYI_USAGE_TRACK默认关⇒零行为变化; 落hit_event(pos/downstream_use)+累加recall_verified_count供⑥反馈; /usage/report+/usage/detect; 单测6用例+真实corpus演示5样本; 零新依赖不碰state.db 2026-10-14 01:14:37 +08:00
小唯 ae39e1ce8a feat(evidence-chain): t_e9a4d18f P1 证据链+proof_count——SourceEvents(多证据列)+ProofCount派生+QualityFromProof(饱和x/(x+K),ZHIYI_PROOF_FALLBACK门控兜底)+Supersedes矛盾保留列; 单测5/5 PASS; Go+Rust build通过; 默认关行为零变化 2026-10-14 00:52:29 +08:00
小唯 a1c9fc1631 feat(distill): t_554b8122 对抗审计插槽——env门控ZHIYI_ADVERSARIAL_AUDIT(默认关⇒零行为变化)+按抽样比例送异源模型(NewAPI deepseek-v4-flash,非本地2B)审计,结论只写影子日志不改丢弃/准入; 单测6/6 PASS+liveprobe真模型3样本; 零新依赖不碰state.db 2026-10-14 00:28:18 +08:00
小唯 f37f5e744e feat(storage): t_e9a4d18f P0 时间维检索——ZHIYI_TIME_DECAY(env门控加性recency偏置,默认0)+stale标记(ZHIYI_STALE_AFTER_HOURS,默认0); 单测4/4 PASS; env=0行为零变化 2026-10-13 23:43:55 +08:00
小唯 0bdcae2b91 feat(storage): t_8f1f6e5e 反馈回路接通——FeedbackScore()(env门控加性偏置,默认0)+单测5/5; ep_*从VValueProvider排除(只改读侧); ZHIYI_FEEDBACK_BIAS=0行为零变化 2026-10-13 22:19:48 +08:00
小唯 1b6920e8e1 feat(storage): t_be3e958a 召回排序加来源分层偏置——决策类(wiki:decision)在 MMR 前加性加分，流水(llm_distill/episode)不动；env ZHIYI_SOURCE_TIER_BIAS 控制(0=关)＋单测 2026-10-13 07:26:59 +08:00
小唯 a377a7f667 fix(distill): t_91af03e9 补停用词层——noiseEntity 精确匹配整名的结构性泛词表(任务/过程/状态/流程/词汇/工具/工具动词/判据/结论/结果/方案/内容/信息/原因/问题/步骤/阶段/记录/清单/备注/说明)+探针残留(甲/乙/丙/探针/PROBE前缀)；先过停用词表再走现有正则；长实体名(≥4字)不因本表被拦,复合形态(任务状态/状态机)照常放行 2026-10-13 06:00:12 +08:00
小唯 e282a41bab fix(distill): t_62f35e62 补收口三——①noiseEntity 正则拆两并列分支，旧关键词(健康检查/部署流程/测试结果/代码修改/grep)恢复单独可拦,泛词(看板/任务/kanban)仍只组合形态 ②emitResult 早退条件放宽为 facts与entities都空才return,facts==0时实体仍进图(修复领域实体静默丢失) 2026-10-13 04:13:05 +08:00
小唯 0959af388b fix(distill): t_286d1310 写库闸门 lane 感知——server.go OnDistillComplete 改用 FilterQualityFactsWithLane（复用 engine 同函数），LaneKeep 时决策类 <20 字碎片不再被第三次丢弃（落库判定由 ClassifyAdmission 重算 lane）+ 新增写库判据单测 2026-10-13 03:26:06 +08:00
小唯 6d724dc937 ga-二收口 t_348cefc1: ①停写图 DERIVED_FROM 边(血缘由 memories.derived_from 字段承载, 图上无人读, 消除 ep_/f_ 目标节点恒增) ②noiseEntity 补看板卡ID t_[0-9a-f]{6,} + 任务/看板流程词组合形态(不单拦泛词) — 探针乙 4/4 泄漏形态全拦 2026-10-13 02:49:43 +08:00
小唯 6e21eef6da docs(recall): Step 6.5 缓存写回注释同步为 60s TTL（写路径 Invalidate + TTL 双保险） 2026-10-13 02:12:26 +08:00
小唯 5b9f75cc7f ga-meta-1b-3 t_1c12e000: 缓存失效写路径收口——TTL 1h→60s + 蒸馏/merge 落库后 Invalidate + recall 响应 cache_hit + cache/stats 暴露 search_cache 计数 2026-10-13 01:38:11 +08:00
小唯 ba81121efa ga-meta-1b-2 t_c6aebb8b: 补收口——来源类+内容形态双层层判定, 堵住 1b 漏掉的分身会话/空source/session-compress 活体写图路径 2026-10-13 01:09:16 +08:00
小唯 5565ec8a9b fix(distill): t_2ae69bb2 让 lane 结论穿透 fact 级质量门禁——LaneKeep 时跳过长度类规则，只留纯疑问/状态汇报两条硬否定 2026-10-13 00:23:57 +08:00
小唯 95bb930bd6 ga-meta-1b t_67d0279a: 方案A 来源分档 — auditSource(worklog-note/audit) 蒸馏实体不写图, 事实仍进记忆层 
终审采用 1a 方案A：
- DistillInput +Source (additive)
- server.go OnDistillComplete / auto_distill.go 降级路径 补 Source: input.Source
- graph_auto.go UpdateFromDistill 顶部: auditSource(Source) 命中即 return (跳 AddNode/AddEdge, 事实照写 LanceDB)
- auditSource: TrimSpace → TrimPrefix(wiki:) → ToLower (前缀归一, 防静默 no-op)
- echo_guard.go 判据零改
AC1 复现 entities=10→0 新节点; AC2 dry-run 35412 行误杀0; AC5 正负对照+skip-entity 日志; AC4 节点 delta 非负
 2026-10-12 23:56:58 +08:00
小唯 e900e4073f GA-P0-7 (t_dd64345a): 退役裸路由 /api/v1/feedback 写点（曾写旧 not_useful_count） 
- server.go: 删 mux.HandleFunc("/api/v1/feedback", api.Feedback) 注册
- core.go: 删 Feedback handler（按 useful 写 useful_count/not_useful_count）
- 回归守卫 server_route_guard_test.go: 断言裸路由不注册 + 4 子路由在
- tests/integration_test.sh: 反馈改走 /api/v1/feedback/useful
- README.md: 裸路由文档改为拆分后 4 子路由

AC2 证伪无调用方：grep 'api/v1/feedback"' 仅命中自身注册行（现已删）。
AC3 退废后 not_useful_count 仅剩 schema/struct 向后兼容声明、[DEPRECATED] IncrementNotUseful(无路由调用)、迁移工具读、注释。
 2026-10-12 21:38:01 +08:00
小唯 66d8e32bc6 fix(distill): GA-P0-6 返修 P0-5 卡号 t_6e16ebef——echo 判据补标点/空格不敏感 + 多示例词并列拦截 2026-10-12 20:23:13 +08:00
小唯 13ced12ce9 feat(memoryweave): GA-P0-4 落 hits+/hits− 双计数器——独立语义的 outcome 信号（禁部署） 
新增 append-only 事件表 hit_events（sqlite/Rust-LanceDB/memvector 三后端同步），
带 created_at 时间戳可按周窗口聚合，只由真实 outcome 写入（人工反馈/矛盾/取代/
下游引用）；dedup 降权/单纯召回出现**不算**（P0-1/P0-2 拆出的假信号，见 hit_event.go
排除项 + docs/hit-outcome-signal.md y 判据）。修正 已办.md:16623 的 hits+=useful_count
错误等同并标注更正依据。

写入点接线 feedback.go（/feedback/useful→pos, /not-useful→neg）。单测 5 例 PASS（含
dedup 降权不计入 hits− 反例 + sqlite 关库重开 read-back）；Rust cargo build 通过；
LanceDB 真实 sidecar IPC append/count/get read-back 取证（count 时区归一修掉跨时区错位）。
禁部署：未动运行中二进制、未碰 live 库。
 2026-10-12 19:50:58 +08:00
小唯 227b2979dd feat(distill): GA-P0-5 概念/实体提取路径接 echo 防线（防元污染闭环复发） 
- 新增 distill.IsPromptEchoEntity（与 IsPromptEcho 同源读 promptEchoLiterals，清单零改动）
- server.go [graph/notes] 处理器过滤候选实体，命中即剔并打 [graph/notes][ECHO-DROP]
- 覆盖 3 个复活节点 n_galway/n_rothfuss/n_the_name_of_the_wind 同类输入
- 禁动 storage/rust（AC4 守住）；commit 由小怡补（原 worker 未提交，共享树有覆盖风险）

卡: t_96580838
 2026-10-12 19:04:45 +08:00
小唯 cb450e9c9d feat(memoryweave): GA-P0-3 拆分 is_deleted 删除原因 → delete_reason 枚举（禁部署） 
- 新增 delete_reason 固定枚举列（merge_dup/contradiction/manual/retention/unknown）
- LanceDB(Rust arrow_schema+MemoryRecord+read/insert) 与 sqlite 双侧 additive 同步
- 所有软删写入点统一归一化写 delete_reason：
  SoftDelete(manual/merge_dup/contradiction/retention) · SoftDeleteBatch(unknown)
  · PurgeInvalid(retention) · Rust soft_delete_batch(unknown)/purge_invalid(retention)
- 新增 lancedb_scan_deleted IPC + Go ScanDeleted：存量已删行回填工具枚举用
- 回填工具 go/cmd/backfill_deletereason（dry-run 默认）+ 单测 7 例（每 reason≥1 写入用例）
- 直方图（副盘真跑）：N=11240 全 unknown（tombstones 无 provenance，按 AC 判不出写 unknown）
- 禁部署/禁真删/禁改已删记录其它字段：live 库零改动
 2026-10-12 18:52:09 +08:00
小唯 28f6951061 feat(memoryweave): GA-P0-2 拆分 recall_count → recall_seen_count / recall_verified_count（禁部署） 
背景：recall_count 被当成 V 值喂给衰减/遗忘逻辑，但每次召回命中都 ++，
造成「被召回 500+ 次所以永不遗忘」的虚高保命。实测 11576 条 recall_count>0、
2732 条 >=10，全是「出现在结果里」而非「被真正用上」。t_268b0353 注释早已
点明「被召回 ≠ 被验证」。

改法（AC1-6，禁部署）：
- LanceDB(arrow_schema) + sqlite(create/alter) 两侧同步新增
  recall_seen_count / recall_verified_count（additive，不删旧列 recall_count）
- 拆分两个写入点：召回命中（缓冲 Record→UpdateRecallBatch / 兜底 incrementRecallCount）
  → 写 recall_seen_count；正反馈（IncrementUseful）→ 写 recall_verified_count + useful_count
- recall_count 冻结不再增长，保留只读（deprecated），衰减/遗忘只认 recall_verified_count
- 排序去偏（lancedb_ipc Search importance）改用 recall_seen_count（观测/选择信号）；
  技能候选筛选（query_memories / GetSkillCandidates）改用 recall_seen_count
- 单测 TestRecallSeenVerifiedIsolation / TestRecallCountFrozen：一次召回 seen++
  verified 不增；一次正反馈 verified++；recall_count 冻结
- 实网取证：副本 LanceDB（禁部署）上跑真实 recall+反馈，
  BEFORE(0/0/0) → AFTER_RECALL(recall_count=0 seen=1 verified=0) →
  AFTER_VERIFY(0/1/1)；schema 演进在副本上补列 4 个成功

go build/vet/test + rust build 全绿；E2E 蒸馏触发测试系既有 flake（stash 复现），
本改动无关。禁部署遵守：live /var/lib/memoryweave 未动，仅在副本上验过。
 2026-10-12 16:54:32 +08:00
小唯 9b7b969cd3 feat(memoryweave): GA-P0-1 拆分 not_useful_count → human_not_useful_count / dedup_downweight_count 
背景：not_useful_count 被两种语义混写——用户人工点「没用」(feedback.go
MarkNotUseful) 与 dedup/合并流程自动降权(core.go Dedup demote) 都写同一字段。
实测 35010 行里 509 条非零但 human useful 仅 21 ⇒ 字段被混写。P2 自适应阈值
要靠它当标签，统计即垃圾。

改法（AC1-5，禁部署）：
- LanceDB(arrow_schema) + sqlite(create/alter) 两侧同步新增
  human_not_useful_count / dedup_downweight_count（additive，不删旧列）
- 两个写入点各写各的：feedback.go→IncrementHumanNotUseful；
  core.go dedup→IncrementDedupDownweight
- not_useful_count 保留 deprecated，新代码不再读（读侧仅 Scan/迁移保留）
- 存量迁移工具 cmd/split_notuseful（--dry-run 默认，apply 需终审）；
  实测存量无可按来源判定行(M=0)→ 全部归 unknown(K=109 存活行)，apply=no-op
- 单测 TestSplitNotUsefulFieldIsolation：两写入点写不同字段，相对增量断言

go build/vet/test + rust build 全绿；rust open() schema 演进在副本上
实测补列 human_not_useful_count/dedup_downweight_count 成功。
 2026-10-12 14:17:31 +08:00
zyh dfc6f580eb test(distill): 回显防线真模型现场探针 
实证（真 2B 输出）：易诱发输入下模型逐字吐出 prompt 教学示例
（用户昨天买了苹果。/ 用户的朋友John在学医。），防线剔除 facts=2 entities=1
且 allEcho=true → 落到上游启发式提取；B/C/D 三条真实内容零误杀。
 2026-10-12 11:23:56 +08:00
zyh a39e5c7e23 fix(distill): 剔除 prompt 教学示例回显（facts=0 占 76% 的根因） 
生产实测：2B 把 prompt「重要指令」块里的教学示例原样抄进输出
（用户昨天买了苹果。/ The Name of the Wind by Patrick Rothfuss / Galway, Ireland /
慈善篮球赛 / 某饮料公司 …），解析器照单全收 ⇒ 示例事实<20 字被质量门丢光
（facts=0 出现 301 次）＋示例实体污染图谱。

判据：归一化后逐字相同=回显；纯教学 illustration 额外允许 >=4 字子串
（抓 John / Patrick Rothfuss 残片）；含真实 token 的格式说明字面量只认整体相同
（避免误杀真实实体 待办.md）。全部事实皆为回显时连评分一起作废，落到上游
启发式提取 = 结构化降级（仍产出，但不产垃圾）。防线放在唯一咽喉 parseDistillOutput。
 2026-10-12 11:14:19 +08:00
xiaoyi ce38465dbd refactor(distill): 打分缓存改用 Redis L2，删掉自造的文件缓存 
起因：牧尘问「是用缓存还是 redis server？」—— 一问点破：初版我自造了
「进程内 map + 每轮 flush 全量重写 JSON 文件」，而**项目本来就有 Redis L2**，
是重复造轮子，且造得更差。

事实核对（改动前实测）：
- Redis：active + enabled，PONG，21.71MB，30 键
- zhiyid **已强制依赖 Redis**（召回搜索缓存在用 zhiyi:cache:*、事件总线、技能持久化，
  启动日志有 [redis] connected）⇒ 用 Redis 不是新增依赖
- 项目已有现成原语：L2CacheBackend 接口 + redisL2Adapter（searchcache.go:16/27）
- 我的初版每轮把 2 万条（≈10MB）全量序列化写盘（tmp+rename），Redis 只写增量

改动：
1) score_cache.go 重写为 **L1 进程内 map + L2 Redis 逐键**
   （键 zhiyi:distill-score:<sha256>，TTL 7 天，跟随项目既有 zhiyi: 命名空间），
   与项目既有 SearchCache(L1+L2) 同构。
   - L2 命中回填 L1（下次零网络往返）
   - Redis 不可用/写失败 → 自动退化为纯 L1，**绝不阻断蒸馏**（只告警一次）
   - TTL 必须有：本机 Redis 是 maxmemory=0 + noeviction，不设 TTL 只涨不落
2) 删掉约 200 行自造 IO：load/save 全量读写、原子写 tmp+rename、损坏兜底、
   filepath 依赖 —— 全部由 Redis 的 GET/SET/TTL 替代
3) 新增 scoreL2 最小接口，**单测注入内存 fake**，不依赖真 Redis
4) 清理废弃文件 /var/lib/memoryweave/distill-score-cache.json

测试（9 例全过）：
- 新增 TestScoreCacheL2RoundTrip：L1 空的新实例**必须靠 L2 命中**并回填 L1
  （这就是「服务一天重启 6 次仍有效」的依据）
- 新增 TestScoreCacheL2DownDegrades：L2 挂掉退化为纯 L1，不 panic
- 端到端判据不变：同内容第二次调用后 HTTP 请求数**不增加**
  （证据：首次后=2 同内容后=2 不同内容后=3）

⚠️ 本轮再次「判据写错而非代码错」：TestScoreCacheL2RoundTrip 首版断言
「新实例 L1 为空 ⇒ 不该命中」—— 但新实例本就该靠 L2 命中，那正是改 Redis 的目的。
同一天第二次犯「判据与设计意图不符」（第一次是数 HTTP 请求把探活算进去）。

遗留：真 Redis 的 zhiyi:distill-score:* 键**尚未观测到**（部署后窗口内零流量，
蒸馏队列空）。接口往返已由 fake L2 验证、Set 走的是项目既有的 RedisClient，
但「真键已落」这句话要等下一波摄入后看 redis-cli 才能说。
 2026-10-12 09:41:02 +08:00
xiaoyi a162e2769e perf(distill): 打分结果按内容哈希记忆化 —— 省掉约 60% 的 2B 调用 
问题（实测）：
- episodes 表重复率 78.5%（近 2 天 58.4%，今天 64.3%）；同一条内容一天被写 9 次
- 干净窗口 392 条评分里**只有 146 条唯一** ⇒ 约 60% 的 2B 打分调用打在重复内容上

为什么不是批内去重：观测到的重复是「同内容一天 ×9」，**分散在不同批次**
（每批 1~15 条），批内去重抓不到。对症方案是按内容哈希记忆化 ——
同内容只调一次 LLM，之后复用；批内/跨批/跨重启一并覆盖。

改动：
1) 新增 distill/score_cache.go：sha256(content) → LLMResponse 的 FIFO 有界缓存
   （cap 2 万条），**落盘**（原子写：tmp+rename）——服务今天已重启 6 次，
   纯内存缓存覆盖率永远上不去。损坏文件只从空开始，不阻断蒸馏。
2) engine.go：原 callLLM5D 改名 callLLM5DUncached（**函数体零改动**），
   外层新增 callLLM5D 做「查缓存 → 未命中再调 → 回填」。
   禁用开关 ZHIYI_SCORE_CACHE=0。
3) flush 收尾打印累计命中率并落盘（每轮一次，避免频繁 IO）。

零风险论证：只复用「同一输入的上一次输出」，不改变任何判分逻辑；
最终写入 memories 时本来就去重（实测 memories 重复率 0.3%），
所以跳过重复项的打分**不改变最终写入结果**。

测试：新增 8 个用例（命中/不同内容不污染/淘汰边界/落盘往返/损坏兜底/
哈希稳定/nil 安全/端到端不打第二次 HTTP），全部通过。
决定性判据 = 端到端：同内容第二次调用后 HTTP 请求数**不增加**
（证据：首次后=2 同内容后=2 不同内容后=3）。

⚠️ 过程中发现两件必须记下的事：
① 测试守护：本包 TestMain 默认**关闭**缓存 —— 有 4 个测试用同一内容反复调
   callLLM5D 验证重试/解析行为，缓存会把第二次短路，使它们**静默失去覆盖**
   （表面全绿）。首版没关，4 个测试当场挂掉才暴露。
② 判据写错：首版断言绝对计数 '==1'，被 NewEngine 的并发探活
   （RefreshConcurrency 打一次端点）干扰成 2 而误报失败 —— 是判据错，非缓存失效。
   改为相对计数后通过。
 2026-10-12 09:23:09 +08:00
xiaoyi 13cf7d2088 chore(retrieval): qstrust 逐条日志默认静音（ZHIYI_QSTRUST_VERBOSE=1 开启） 
一次召回可命中上百条，全量打印是生产噪音（实测单次查询 176 行）。
诊断能力保留，改为环境变量开关。
 2026-10-12 08:23:24 +08:00
xiaoyi c34178c3c3 fix(retrieval): 存量 quality_score 可信度判定 —— 不再让 54% 的假分数冒充真值 
背景（实测，34,749 条）：
- 0.755 占 28.8%：旧 prompt 示例分数被 2B 照抄产生的常量 bug 值。
  按创建日切片：09-27~10-06 占 61%~77%，10-07 降至 0.3%，**10-09 起 0.0%**
  ⇒ 纯历史遗留，不再新增（10-08 行协议修复已止血）。
- 0.000 占 25.4%：解析失败，语义是"没有分数"，不是"质量为 0"。
- 合计 54.2% 不可信。

改动：
1) models.IsReliableQuality(qs)：叶子包纯函数，qs<=0 或 qs≈0.755 判为不可信。
   **只判定、不改数据**（不做 34k 行全表改写，零数据风险，回滚=还原代码）。
2) recall.go 融合：不可信时把权重全部让给关键词分（中性，不奖不罚）。
   ⚠️ 判定必须用 **RawQualityScore**（DB 原始列）——candidates[i].QualityScore 在
   IPC 路径下是**已融合且饱和到 1.0** 的值，拿它判永远"可信"（实测踩到：
   candidateQS=1.000000 / rawQS=0.755000）。
3) lancedb_ipc.go 融合：不可信时去掉质量的权重，其余按原比例归一（30:30→50:50）。
4) RecallResult 新增 quality_score_reliable：原值照常返回供审计，
   但显式标注其可信度，调用方不再把占位值当真实质量判断。

诚实记录：因 importance 饱和，本修复**当前对排序是 no-op**（见下）。
重要性列 importance 全表恒为 1.0，查询期 computedImportance 恒 >1，
min(·,1.0) 使 finalQuality 对所有记忆都饱和成 1.0 ⇒ quality 轴在排序中是常量。
真正的问题是**饱和**（quality 完全不影响排序），已单独立项待拍板。
本提交的价值在于：① 显示值不再冒充真值；② 饱和一旦修好，判定立即生效。

测试：models 9 用例 + storage/distill/routes 全量回归通过。
实盘：部署后 [qstrust-ipc] 日志命中 176 条，证明判定在真实路径上执行。
 2026-10-12 08:22:44 +08:00
xiaoyi cbbdd9a708 feat(distill): 准入闸门改三路分诊（Step 1）—— 落实外部经验 
依据 6 篇文献精读（方案见 mc/小怡/04-OBSIDIAN工具/04-02-方案设计/
20261012-织忆记忆闸门-外部经验落地方案.md）：

- A-MAC(2603.04549) 消融：确定性「内容类型先验」是单点最强特征（ΔF1=-0.107，
  F1 0.583→0.476）。而织忆此前判据里确定性特征数为 0（只有 LLM 的 overall/VD）。
- SAGE(2605.30711)：明确的直接闭式解决，只有「不确定带」才需谨慎；
  且单一固定阈值会随库变密必然过度保守。
- When to Forget(2604.12007) 原文："should not deprecate an uncertain memory"
  ⇒ 证据不足/拿不准的绝不弃用。

改动：
1) 新增 internal/textfilter 叶子包：系统样板判定清单抽出来，routes 保留薄委托
   （distill 不能反向 import routes，会循环；抽叶子包避免复制漂移）。
2) 新增 distill/admission_lane.go：ClassifyAdmission 确定性三路分诊（零 LLM）
   drop=系统样板/回执/过短；keep=结构化人侧前缀/决策承诺/身份偏好；
   observe=其余全部（不确定带）。
3) engine.go 判定段改走分诊：**observe lane 永不因 LLM 低分丢弃**（Step 1 不做
   分数丢弃，低分只记录供 Step 2 学阈值）。原 isSoulfulShortFact 豁免并入 keep lane。

设计取舍：drop 只收无歧义项；"纯疑问/状态汇报"这类需要判断的内容一律落 observe
（文献警告过度保守的准入会丢长程必需信息）。代价不对称——多留可逆，丢不可逆。

测试：admission_lane_test.go 16 用例全过（含"纯疑问/状态汇报不得被 drop"不变量
+ 确定性不变量）；distill 与 routes 全量回归通过。
 2026-10-12 07:55:32 +08:00
xiaoyi 6e752aa904 fix(distill): 评分闸门阈值重标定（0.7/0.8 → 可标定 0.30/0.30，仍影子） 
旧阈值 overall<0.7 && vd<0.8 从未被真实分布验证——它是在「旧 prompt 示例分数被
照抄 ⇒ overall 恒为 0.755」这个 bug 上拍出来的，闸门从未真正丢过任何东西。

实测（4 天 2065 条可用评分，local/minicpm5-2b）真实分布：
  min=0.175 p25=0.390 中位=0.535 p75=0.600 p90=0.800 max=0.825
用 0.7 卡该分布 ⇒ 仅 17.9% 通过 ⇒ 一开闸即丢 82% 可用内容。

改为环境变量可标定，默认取分布 p10≈0.30 保守档（只丢明确垃圾）：
  ZHIYI_SCORE_MIN_OVERALL / ZHIYI_SCORE_MIN_VD
取向：宁可多留（可逆，后续消费/降权会淘汰），不轻易丢（不可逆）。
影子模式(ZHIYI_SCORE_SHADOW 默认开)未改动 —— 本次不真丢，只观察。
 2026-10-12 02:42:53 +08:00
xiaoyi 63ceb4a11c fix(distill): prompt 模板 SCORE 行改用「五个数字用竖线分隔」+ 禁写字段名 
根因：行协议 prompt 的示例行写的是 SCORE|is|su|pa|vd|ru（字段名占位符），
本地 2B 直接把字段名当内容照抄（实测输出 SCORE|0.5|is|su|pa|vd|ru 或
SCORE|0.5| 断行），解析器拿不到 5 个数值 → 五维全 0 → overall=0.000。

影响（10-08 行协议修复后的干净窗口）：overall=0.000 占 80.3%（5113/6365），
SHADOW 闸门本会丢弃 99.3% 内容 —— 评分闸门实为装饰。

实测 A/B（14 条等距抽样，temperature=0.2）：
  旧 prompt 合法 5 数 0/14（0%）  →  新 prompt 12/14（85.7%），5 种不同分值组合
端到端（-tags liveprobe TestRawLLMScoreBehavior）：6/6 全部产出合法 5 数。

约束：TestPromptHasNoEchoLiterals 禁止评分段出现具体小数（实测会钉成常数），
故用文字描述而非数值示例。
 2026-10-12 02:14:47 +08:00
小唯 e9fce11a1b fix(zhiyi): t_268b0353 治根 — 断 auto_recall V 传播 + 召回不写 freshness=verified(Rust 主路径+Go 兜底) + volatile_flag 标注预留 
- core.go: auto_recall 的 memory_ids 传 nil（「召回命中」不再冒充「记忆有用」进排序权重）
- rust lancedb_ops.rs:489/510（zhiyi-consolidate 主写路径）+ go 兜底: 召回不再盖 freshness=verified
  （「被召回」≠「被验证」，越常被召回的旧快照不再越「可信」）
- lancedb_ipc.go: volatile_flag 恒 false 处标注为预留惩罚分支，当前不生效
- 集成测试同步：版本计数负载不再写 freshness 列
 2026-10-11 23:44:57 +08:00
小唯 6db0ffa7d4 fix(zhiyi-recall): recall 响应补 quality_score/v_value 直通 (t_631ab13d) 
- 根因 (a) 显示漏：RecallResult 结构缺 quality_score/v_value 字段
  ⇒ JSON 序列化不带出 ⇒ 插件 r.get("quality_score",0) 恒得 0。
  排序用库值(candidates[i].QualityScore, recall.go:236/321) 不受影响。
- Rust IPC Search 会把排序用 QualityScore 融合成 0.4*imp+0.6*raw(cap1.0),
  非 LanceDB 原始列 ⇒ 新增 MemoryRecord.RawQualityScore(json:"-") 携带原值,
  recall 响应展示原始库值(响应值==库值), 排序仍用融合值。
- AC2 实测 5 个 id 响应值==LanceDB 直读值(0.66/0.0/0.7/0.6/0.6)。
 2026-10-11 22:41:26 +08:00
小唯 0e4fb59e1a feat(zhiyi): t_689b6d38 注入入口加系统样板噪音闸门 
被动注入入口不区分「真实用户消息」与「系统通知/提示样板」：近7天
[graph/notes] 通道 806 次注入里 543 次(67%) 入参是系统样板
("[IMPORTANT: You are running as a scheduled cron job..." /
"[IMPORTANT: Background process ..." / "[System note: ..."),
照常走完整实体拆解并返回 3 篇笔记 → 纯浪费 + 稀释信噪比。

改动（判定优先用结构化来源标记头，非纯长度启发式；白名单真实用户提问照常召回）：
- 新增 routes/system_template.go: IsSystemTemplateInput（头子串 + 全文子串）
- /api/v1/graph/notes: 命中样板 → mode=none + notes=[] + skipped=system_template，不拆实体
- /api/v1/recall: 命中样板 → results=[] + skipped=system_template，不进语义召回
- plugins/hermes-zhiyi: prefetch/queue_prefetch 加同判据闸门（客户端侧前置拦截）

实测(改后): 样板入参 graph/notes notes_count=0 skipped=system_template；
真实提问 graph/notes mode=nl_extract notes_count=10 / recall count=3（无误杀）。
AC1 7天噪音率基线=543/806(67.4%)，改后新日志以 [graph/notes] 拦截 行可判。
 2026-10-11 22:19:39 +08:00
小唯 b551c55011 fix(zhiyi): SoftDelete/SoftDeleteBatch 遇 LanceDB Commit conflict 加有界退避重试 (方案a, t_5b5a83de) 
- isRetryableLanceConflict(): 仅 'commit conflict'/'cannot be automatically resolved'/'rerun the operation' 可重试
- retrySoftDeleteRPC(): N=3 重试, 退避 50/100/200ms(cap 200ms, 总最坏+350ms), 幂等重放安全
- 非可重试错误(空id/id required/schema)立即返回不重试
- 日志: retry attempt k/3 / retried OK after k / retry exhausted after 3
- 单测: 分类8例 + 永远冲突有界耗尽 + 冲突2次后成功 + 无冲突恰1次零退避 + 不可重试不重试
 2026-10-11 18:02:06 +08:00
小唯 aa8f503ae0 fix(forgetting): 遗忘候选池固定2000窗口不轮转 → 旋转窗口全覆盖（方案c′） 
Rust: scan_forgetting_window 列投影取全部存活mem_ id→内排序→连续窗口→
区间过滤还原全字段；游标=窗口末id；wrapped回绕。修复 LanceDB query 默认limit=10坑。
Go: GetCandidatesForForgetting 传游标+持久化 forget-cursor.json（原子写，韧性降级）。
实测真库 coverage=1.0000（13轮全覆盖22462），池内>10-07从~2→每轮2000。
 2026-10-11 12:53:15 +08:00
小唯 82ef904257 chore(gofmt): 配套——.gitignore 收 cron_raw.txt + Makefile 加 fmt-check 校验 
- cron_raw.txt（10-09 hermes cron list dump，无引用/从未入库/可随时重现）
  → 进 .gitignore 忽略，保留数据不删
- Makefile 加 fmt-check target：gofmt -l 非空即 fail，日常/CI 一键查格式
  （只在已有 Makefile 载体上加，不新建机制；go fmt 不支持 -l，用独立 gofmt）
独立于格式化 commit 886c0c2，避免夹带。
 2026-10-10 15:55:31 +08:00
小唯 886c0c20e2 style(gofmt): 全仓 66 文件对齐 gofmt 1.25 
gofmt -l 实测 66 文件不合规（历史遗留+gofmt 1.25 规范化：
单行 if/for/case 展开成块、Go1.19+ doc 注释 // 与段落 // 空行）。
本 commit 只含格式化，零逻辑改动：
- 66/66 文件「去注释+去空白+分号归一」后 token 流与 HEAD 完全一致
- go build ./... exit 0；go vet ./... exit 0（改前后一致）
- go test ./... 17 包全 ok（改前后一致）
验收: gofmt -l . 为空；git diff -w 非空系 gofmt 1.25 非纯空白特性，
非逻辑改动（等价性以 token 流 + test 兜底）。
 2026-10-10 15:51:25 +08:00
小唯 31bdf3403b fix(graph): 自环根治 —— 两两循环前对 validEnts 按 eid 去重 + 三处建边口防自环 guard 
- UpdateFromDistill: validEnts 去重(保序,保留首个下标)从源头消除同名重复实体映射同一 eid → source==target
- 三处 AddEdge 口各加 guard：两两语义/CO_OCCURS(eidI==eidJ)、CONFLICTS_WITH、RecordCoOccurrence(resultIDs 重复)
- 单测 TestUpdateFromDistill_NoSelfLoop_WithDupEntities + TestRecordCoOccurrence_NoSelfLoop_WithDupResultIDs
  断言零自环 + 不丢正常边；反证(还原修复)必 FAIL(复现 2 条自环)
- 存量 222,893 自环已清(2026-10-09,备份 graph-pre-selfloop-20261009-155515.db)
99.7% 自环产生于今日单批(n_state 99540 / n_幻影 68382 / n_2026-10-09 33306)
 2026-10-09 16:35:42 +08:00
xiaoyi 2a8fc6494e test(recall): 修 TestRecallWriteBufferTickerFlush 竞态 —— 它等的是中间态而非断言对象 
现象：该用例偶发假红（实测 5 次里 1 次），报「窗口到点应 flush 1 次，实际 batchCalls=0」，
而同期日志里 flush 其实已发生（[recall-buffer] flush: 合并 1 条记忆 → 落盘 1 行, 单事务=true）。

根因：Flush() 是「先清 b.pending、再调 BatchUpdate」；用例等 len(pending)==0 就断言，
会抢在 batchCalls++ 之前 ⇒ 读到 0。同文件 TestRecallWriteBufferThresholdFlush 用的才是正确
写法（直接等 batchCalls>0）—— 本次统一成后者。

验证：修正后连跑 20 次 20/20 绿；反证（把等待条件改回中间态）连跑 20 次红 4 次 ⇒ 竞态真实存在。
全仓 go test ./... -count=1：失败包 0 / 失败测试 0 / 通过包 9。
本提交仅改测试文件，不改变构建产物。
 2026-10-09 13:20:36 +08:00
240 changed files with 59191 additions and 1274 deletions
Expand all files Collapse all files
.gitignore
+10
View File
@@ -35,3 +35,13 @@ bin/
# 构建产物（worker 曾把 7.9M 二进制留在工作区，2026-09-21）
go/zhiyi-cli
go/zhiyid
# 临时工件（cron list dump，随时可 `hermes cron list` 重现，不入库）
cron_raw.txt
# 改动前备份快照不进 git（git 本身就是版本历史）
*.bak.*
# 探针/临时构建产物（2026-10-14 t_3e98b65a 调查时发现 17MB 残留未清）
/go/*-probe
/go/rulefirst-probe
Makefile
+10
View File
@@ -6,6 +6,7 @@
# ─── 变量 ────────────────────────────────────────────
GO_CMD := go
RUST_CMD := cargo
GOFMT_CMD := gofmt
GO_DIR := go
RUST_DIR := rust
BINARY_GO := $(GO_DIR)/cmd/zhiyid/zhiyid
@@ -81,6 +82,15 @@ deploy-compose: docker-build
test:
cd $(GO_DIR) && $(GO_CMD) test ./... -v -count=1
# 格式校验：gofmt 不合规即报错（gofmt -l 列出文件 → 非空则 exit 1）
fmt-check:
@cd $(GO_DIR) && $(GOFMT_CMD) -l . | tee /tmp/.gofmt_files > /dev/null; \
if [ -s /tmp/.gofmt_files ]; then \
echo "❌ gofmt 不合规文件（$(GOFMT_CMD) -l . 非空）："; \
$(GOFMT_CMD) -l . ; \
echo " 修复: cd $(GO_DIR) && $(GOFMT_CMD) -w ."; exit 1; \
else echo "✅ gofmt 合规（0 文件）"; fi
test-go: test
test-rust:
README.md
+4 -1
View File
@@ -426,7 +426,10 @@ python3 -c "from plugins.memory.zhiyi import HermesZhiYiMemoryProvider; \
| POST | `/api/v1/recall` | 语义检索（支持 mode=hybrid\|keyword\|semantic） |
| POST | `/api/v1/batch-commit` | 批量提交 |
| GET | `/api/v1/memories` | 列出记忆（分页） |
| POST | `/api/v1/feedback` | 反馈（useful / not-useful / deprecate） |
| POST | `/api/v1/feedback/useful` | 标记记忆有用（GA-P0-1 写 human_useful） |
| POST | `/api/v1/feedback/not-useful` | 标记记忆无用（写 human_not_useful_count） |
| POST | `/api/v1/feedback/deprecate` | 标记过时 |
| POST | `/api/v1/feedback/correct` | 提交修正 |
### 统计
cli-anything/cli_anything/zhiyi/zhiyi_cli.py
+1 -2
View File
@@ -197,7 +197,6 @@ def stats(stat_type, json_flag):
if "metrics" in data:
m = data["metrics"]
click.echo(f"\n📊 自优化指标:")
click.echo(f" 召回命中率: {m.get('recall_hit_rate', '?'):.1%}")
click.echo(f" 召回有用率: {m.get('recall_usefulness_rate', '?'):.1%}")
click.echo(f" 记忆总数: {m.get('total_memories', '?')}")
@@ -429,7 +428,7 @@ def _repl_with_skin(c: ZhiYiClient, skin):
["记忆数", str(s.get("total_memories", "?"))],
["图谱节点", str(g.get("node_count", "?"))],
["图谱边", str(g.get("edge_count", "?"))],
["召回命中率", f"{m.get('recall_hit_rate', '?'):.1%}"],
["召回有用率", f"{m.get('recall_usefulness_rate', '?'):.1%}"],
],
)
elif cmd == "graph" and args and args[0] == "navigate":
docs/ac-evidence/t_492e3f22-v-fuse-gate/DEF-run.log
+13
View File
@@ -0,0 +1,13 @@
[152] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-DEF-152-20261016-184003.json total=152 PASS=74 id_hits=7 fp=2318948a910f6d70de6be063216c78089c4315bd p95=2630ms errs=0
[golden] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-DEF-golden-20261016-184003.json pass=14/14 fail=0
[probe10] 牧尘工作所在的县是哪个: n=20 v>0=0 -> []
[probe10] 淇县: n=20 v>0=1 -> ['mem_1792088552819293505']
[probe10] 招商项目台账: n=20 v>0=0 -> []
[probe10] 生物制造产业专班: n=20 v>0=0 -> []
[probe10] 小怡的工作笔记在哪: n=15 v>0=0 -> []
[probe10] 昨天做了什么: n=20 v>0=0 -> []
[probe10] 飞书怎么发语音: n=20 v>0=0 -> []
[probe10] 家服怎么连: n=20 v>0=0 -> []
[probe10] 织忆怎么部署: n=20 v>0=1 -> ['mem_1791740271337572997']
[probe10] 记忆保护名单: n=20 v>0=0 -> []
DONE DEF at 20261016-184003
docs/ac-evidence/t_492e3f22-v-fuse-gate/NOV-run.log
+13
View File
@@ -0,0 +1,13 @@
[152] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-NOV-152-20261016-184835.json total=152 PASS=74 id_hits=7 fp=2318948a910f6d70de6be063216c78089c4315bd p95=812ms errs=0
[golden] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-NOV-golden-20261016-184835.json pass=14/14 fail=0
[probe10] 牧尘工作所在的县是哪个: n=20 v>0=0 -> []
[probe10] 淇县: n=20 v>0=1 -> ['mem_1792088552819293505']
[probe10] 招商项目台账: n=20 v>0=0 -> []
[probe10] 生物制造产业专班: n=20 v>0=0 -> []
[probe10] 小怡的工作笔记在哪: n=15 v>0=0 -> []
[probe10] 昨天做了什么: n=20 v>0=0 -> []
[probe10] 飞书怎么发语音: n=20 v>0=0 -> []
[probe10] 家服怎么连: n=20 v>0=0 -> []
[probe10] 织忆怎么部署: n=20 v>0=1 -> ['mem_1791740271337572997']
[probe10] 记忆保护名单: n=20 v>0=0 -> []
DONE NOV at 20261016-184835
docs/ac-evidence/t_492e3f22-v-fuse-gate/PRE-run.log
+13
View File
@@ -0,0 +1,13 @@
[152] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-PRE-152-20261016-183449.json total=152 PASS=74 id_hits=7 fp=2318948a910f6d70de6be063216c78089c4315bd p95=809ms errs=0
[golden] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-PRE-golden-20261016-183449.json pass=14/14 fail=0
[probe10] 牧尘工作所在的县是哪个: n=20 v>0=0 -> []
[probe10] 淇县: n=20 v>0=1 -> ['mem_1792088552819293505']
[probe10] 招商项目台账: n=20 v>0=0 -> []
[probe10] 生物制造产业专班: n=20 v>0=0 -> []
[probe10] 小怡的工作笔记在哪: n=15 v>0=0 -> []
[probe10] 昨天做了什么: n=20 v>0=0 -> []
[probe10] 飞书怎么发语音: n=20 v>0=0 -> []
[probe10] 家服怎么连: n=20 v>0=0 -> []
[probe10] 织忆怎么部署: n=20 v>0=1 -> ['mem_1791740271337572997']
[probe10] 记忆保护名单: n=20 v>0=0 -> []
DONE PRE at 20261016-183449
docs/ac-evidence/t_492e3f22-v-fuse-gate/RBK-run.log
+13
View File
@@ -0,0 +1,13 @@
[152] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-RBK-152-20261016-190913.json total=152 PASS=74 id_hits=7 fp=2318948a910f6d70de6be063216c78089c4315bd p95=931ms errs=0
[golden] /home/muc/.hermes/kanban/workspaces/t_492e3f22/ac-evidence/t492-RBK-golden-20261016-190913.json pass=14/14 fail=0
[probe10] 牧尘工作所在的县是哪个: n=20 v>0=0 -> []
[probe10] 淇县: n=20 v>0=1 -> ['mem_1792088552819293505']
[probe10] 招商项目台账: n=20 v>0=0 -> []
[probe10] 生物制造产业专班: n=20 v>0=0 -> []
[probe10] 小怡的工作笔记在哪: n=15 v>0=0 -> []
[probe10] 昨天做了什么: n=20 v>0=0 -> []
[probe10] 飞书怎么发语音: n=20 v>0=0 -> []
[probe10] 家服怎么连: n=20 v>0=0 -> []
[probe10] 织忆怎么部署: n=20 v>0=1 -> ['mem_1791740271337572997']
[probe10] 记忆保护名单: n=20 v>0=0 -> []
DONE RBK at 20261016-190913
docs/ac-evidence/t_492e3f22-v-fuse-gate/README.md
+87
View File
@@ -0,0 +1,87 @@
# t_492e3f22 · fuseQuality V 值分支 env 门（ZHIYI_V_FUSE_ENABLE）— A/B 证据包
次症 C：给 Go 端 fuseQuality 的 V 值分支加 env 门。**默认行为逐位保持现状**；`ZHIYI_V_FUSE_ENABLE=1`
关闭 V 分支（v>0 时不再用 0.5v+0.5imp / 0.3v+0.3imp+0.4raw 加权，退化为 untrusted→min(imp,1)、
trusted→min(0.4imp+0.6raw,1)）。本包 = 代码 + 测试 + 双口径 A/B 证据。
## 结论（2026-10-16 实测）
| AC | 判据 | 结果 |
|---|---|---|
| AC1 默认不碰 | PRE(旧二进制) ≡ DEF(新二进制默认)：152 集 verdict 指纹、top5 顺序、probe10 top20、golden | ✅ 全同（指纹 2318948a…；golden 14/14） |
| AC2 翻转证据 | DEF vs NOV(env=1)：verdict 指纹同；probe10 10 条 affected=0；两条受影响 query top50 顺序逐位全同（fp 47e228e8 / 9dd57897 各两边一致）；v>0 条目 rank 零移动 | ✅（排名变化 = 0，见「解读」） |
| AC4 受影响条数 | v>0 条数独立复算（4 个 tag 集合完全一致）：152×top5 = 2/760 (0.26%)；probe10×top20 = 2/195 (1.03%) | ✅ 实测 2 条，任务表预期 2–3（≈1.5%，V 按 0.01/天衰减） |
| AC5 回滚复核 | RBK(新二进制重启·默认) == DEF 指纹（verdict 层 2318948a + probe10 全同 + golden 14/14） | ✅（仅 2 条 v=0 Gitea top1 互漂，跨跑 usage_track 漂移，见「已知噪声」） |
| AC6 异源复算 | 第二张口径（independent_recheck.py，sha256 顺序指纹 + 逐条 v>0 集合复算）与主口径一致，无矛盾 | ✅ PASS |
## 改动文件
- `go/internal/storage/quality_fusion.go` — `vFuseUseV = os.Getenv("ZHIYI_V_FUSE_ENABLE") != "1"`（进程级，同 ZHIYI_PROOF_FALLBACK 模式），V 分支条件 `if vFuseUseV && vValue > 0`
- `go/internal/storage/quality_fusion_test.go` — `TestFuseQuality_VGateOn`（门开：v>0 条 fused 0.85 vs v=0 条 0.725，排序保持）+ `TestFuseQuality_VGateOff`（门关：两者同值）
- 单测：`cd go && go test ./internal/storage/ -run 'TestFuseQuality' -v` → 3/3 PASS（2026-10-16 19:35 复跑）
## 实例配置（隔离：独立数据副本，不碰主库）
- 数据：`/tmp/zyvfuse-t492e3f22/data`（/var/lib/memoryweave 全量副本，symbolic link 已解）
- sidecar：`zhiyi-consolidate --mode socket --socket /tmp/zyvfuse-t492e3f22/cons.sock`
- 4 实例：PRE :7891(旧二进制) / DEF :7892(新·默认) / NOV :7893(新·env=1，/proc environ 实证) / RBK :7892 重启(新·默认)
- 评测集：152 条（zhiyi-loop-runner 池）+ golden 14 + probe10（淇县/织忆怎么部署/记忆保护名单 等卡表同源）
## 受影响 3 样本表（AC2，卡表口径）
| query | v>0(任务表→实测) | v>0 条目 | DEF→NOV 排名变化 |
|---|---|---|---|
| 淇县 | 0 → 1 | mem_1792088552819293505 (v=1.0, rank1) | 0（top50 逐位全同） |
| 织忆怎么部署 | 2 → 1 | mem_1791740271337572997 (v=1.0) | 0（top50 逐位全同） |
| 记忆保护名单 | 1 → 0 | （本次 top20 内无 v>0） | — |
**解读（为什么排名变化=0）**：recall 排序 base = 0.7×cosine + 0.3×fusedQuality。V 门控只改 v>0 条的
fused 分（untrusted 时 0.5v+0.5imp → min(imp,1)），Δbase 上限 0.3×Δfused≈0.15；本数据分布下
cosine 主导的条间 margin > Δbase ⇒ 无换位。门控在**融合分轴**生效（单测证明公式差），
**排序轴**在本数据规模上实测零扰动 —— 这正是「默认不碰、关也不破」的安全证据。
v>0 条数随时间漂（V 衰减 0.01/天 + seen-count 变化）：任务表 3 → 实测 2。
## 已知噪声（与门控无关，如实记录）
- 152 集中 2 条 Gitea query 的 top1 在跨跑间互换（mem_1792088552817004309 ↔ mem_1792088552816998158，
两侧 v=0、raw=0）：DEF 跑 / NOV 跑 / RBK 跑各自写 usage_track（seen-count +1、last_recalled_at 刷新），
imp 微漂 ⇒ 同分对 tie 换位。verdict/指纹层不受影响（4 tag verdict 指纹全同 2318948a）。
- 152 集 P95：PRE=809ms / DEF=2630ms（冷启动+首轮 warmup）/ NOV≈951 / RBK=931 —— AC 判据为 ±20% 口径
以稳态（RBK/NOV）为准，DEF 高值系冷启动，非门控效应。
## 复算命令
```bash
# 单测
cd /home/muc/src/memoryweave/go && go test ./internal/storage/ -run 'TestFuseQuality' -v
# 异源复算（本目录 raw/*.json）
python3 <kanban-workspace>/harness/independent_recheck.py # 输出 independent_recheck_out.json
python3 <kanban-workspace>/harness/diffrun.py DEF NOV # 主口径 diff
```
## 部署提示（本卡不含生产动作）
- 生产 zhiyid（systemd, :7821）与 zhiyi-consolidate 不动；本卡只验证行为等价 + 门控生效。
- 真要关 V 分支：`Environment=ZHIYI_V_FUSE_ENABLE=1` 加进 deploy/zhiyid.service + 重启（需另行提卡审批）。
- 回滚 = 删该行/置 0，重启即恢复现状（RBK 证据）。
## teardown + 零残留判据（19:44 补，跨卡通知 t_004cc147 内存告警处置要求）
测试栈（27G：data/ 副本 + graph.db 447M + 双 zhiyid 守护 + sidecar）已全部下线：
- 双孤儿 zhiyid（PID 347191 :7893 / 367265 :7892）已由 prof-cloud SIGTERM（19:15 内存告警处置）
- 本侧：sidecar（cons.sock，data 副本）停掉；`/tmp/zyvfuse-t492e3f22` 整目录删除
（evidence 先全量落盘 `ac-evidence/` 与本目录 raw/，再删）
- 顺带清：`/tmp/dryrun-dir`(2.6G) `/tmp/mem-copy.lance`(604M) `spike*`(441M×2+小文件)
—— 删前确认：lsof 无占用、无看板卡引用、mtime 10-11/10-12
终验输出（19:44）：
```
ps -C zhiyid -o pid,args → 仅表头，无进程（exit 1）
du -sh /tmp/zyvfuse-* → No such file or directory
du -sh /tmp/dryrun-dir /tmp/mem-copy.lance /tmp/spike* → 全部 No such file
free -h → available 5.3Gi（告警前 <1G）
```
**判据补录（本卡验收新增）**：`ps -C zhiyid -o pid,args` 为空（测试栈守护零残留）+
`du -sh /tmp/zyvfuse-*` 无残留 —— 已通过。
docs/ac-evidence/t_492e3f22-v-fuse-gate/diff-DEF-NOV.json
+230
View File
@@ -0,0 +1,230 @@
{
"a": "DEF",
"b": "NOV",
"files": {
"a": {
"152": [
"at",
"tag",
"base",
"total",
"pass",
"fail",
"metrics",
"latency_ms",
"fail_mode",
"recall_errors",
"fingerprint",
"namespace",
"top_k",
"results"
],
"probe10": [
"at",
"tag",
"base",
"top_k",
"rows"
],
"golden": [
"at",
"tag",
"base",
"keyword_pass",
"keyword_fail",
"keyword_total",
"recall_at_5",
"mrr",
"items"
]
},
"b": [
"152",
"probe10",
"golden"
]
},
"152": {
"fp_a": "2318948a910f6d70de6be063216c78089c4315bd",
"fp_b": "2318948a910f6d70de6be063216c78089c4315bd",
"fp_same": true,
"pass_a": 74,
"pass_b": 74,
"id_hits_a": 7,
"id_hits_b": 7,
"p95_a_ms": 2630,
"p95_b_ms": 812,
"changed_queries": 1,
"changed_detail": {
"局域网里访问 Gitea 家服连哪个 IP": {
"kind": "probe",
"changed": [
"top5"
],
"a_top5": [
"mem_1792088552817004309",
"mem_1789136383983279469",
"ep_1786521524260755589",
"mem_1789150776299341327",
"mem_1789737118121867083"
],
"b_top5": [
"mem_1792088552816998158",
"mem_1789136383983279469",
"ep_1786521524260755589",
"mem_1789150776299341327",
"mem_1789737118121867083"
]
}
},
"v0_rank_shifts": []
},
"probe10": {
"rows": [
{
"query": "牧尘工作所在的县是哪个",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "淇县",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 1,
"v_pos_b": 1,
"v_pos_ids_a": [
"mem_1792088552819293505"
],
"v_pos_ids_b": [
"mem_1792088552819293505"
],
"v_rank_moved": []
},
{
"query": "招商项目台账",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "生物制造产业专班",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "小怡的工作笔记在哪",
"n_a": 15,
"n_b": 15,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "昨天做了什么",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "飞书怎么发语音",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "家服怎么连",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "织忆怎么部署",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 1,
"v_pos_b": 1,
"v_pos_ids_a": [
"mem_1791740271337572997"
],
"v_pos_ids_b": [
"mem_1791740271337572997"
],
"v_rank_moved": []
},
{
"query": "记忆保护名单",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
}
],
"affected_queries": [],
"n_affected_queries": 0
},
"golden": {
"a": "14/14",
"b": "14/14"
}
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/diff-DEF-RBK.json
+250
View File
@@ -0,0 +1,250 @@
{
"a": "DEF",
"b": "RBK",
"files": {
"a": {
"152": [
"at",
"tag",
"base",
"total",
"pass",
"fail",
"metrics",
"latency_ms",
"fail_mode",
"recall_errors",
"fingerprint",
"namespace",
"top_k",
"results"
],
"probe10": [
"at",
"tag",
"base",
"top_k",
"rows"
],
"golden": [
"at",
"tag",
"base",
"keyword_pass",
"keyword_fail",
"keyword_total",
"recall_at_5",
"mrr",
"items"
]
},
"b": [
"152",
"probe10",
"golden"
]
},
"152": {
"fp_a": "2318948a910f6d70de6be063216c78089c4315bd",
"fp_b": "2318948a910f6d70de6be063216c78089c4315bd",
"fp_same": true,
"pass_a": 74,
"pass_b": 74,
"id_hits_a": 7,
"id_hits_b": 7,
"p95_a_ms": 2630,
"p95_b_ms": 931,
"changed_queries": 2,
"changed_detail": {
"家庭服务器（跑 Gitea）在局域网里的地址是哪个": {
"kind": "probe",
"changed": [
"top5"
],
"a_top5": [
"mem_1792088552816998158",
"mem_1789136383983279469",
"ep_1785695216419714474",
"ep_1786336919812827426",
"ep_1786452727331645773"
],
"b_top5": [
"mem_1792088552817004309",
"mem_1789136383983279469",
"ep_1785695216419714474",
"ep_1786336919812827426",
"ep_1786452727331645773"
]
},
"局域网里访问 Gitea 家服连哪个 IP": {
"kind": "probe",
"changed": [
"top5"
],
"a_top5": [
"mem_1792088552817004309",
"mem_1789136383983279469",
"ep_1786521524260755589",
"mem_1789150776299341327",
"mem_1789737118121867083"
],
"b_top5": [
"mem_1792088552816998158",
"mem_1789136383983279469",
"ep_1786521524260755589",
"mem_1789150776299341327",
"mem_1789737118121867083"
]
}
},
"v0_rank_shifts": []
},
"probe10": {
"rows": [
{
"query": "牧尘工作所在的县是哪个",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "淇县",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 1,
"v_pos_b": 1,
"v_pos_ids_a": [
"mem_1792088552819293505"
],
"v_pos_ids_b": [
"mem_1792088552819293505"
],
"v_rank_moved": []
},
{
"query": "招商项目台账",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "生物制造产业专班",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "小怡的工作笔记在哪",
"n_a": 15,
"n_b": 15,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "昨天做了什么",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "飞书怎么发语音",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "家服怎么连",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
},
{
"query": "织忆怎么部署",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 1,
"v_pos_b": 1,
"v_pos_ids_a": [
"mem_1791740271337572997"
],
"v_pos_ids_b": [
"mem_1791740271337572997"
],
"v_rank_moved": []
},
{
"query": "记忆保护名单",
"n_a": 20,
"n_b": 20,
"set_added": [],
"set_removed": [],
"order_diff_positions": 0,
"v_pos_a": 0,
"v_pos_b": 0,
"v_pos_ids_a": [],
"v_pos_ids_b": [],
"v_rank_moved": []
}
],
"affected_queries": [],
"n_affected_queries": 0
},
"golden": {
"a": "14/14",
"b": "14/14"
}
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-DEF-152-20261016-184003.json
+7024
View File
File diff suppressed because it is too large Load Diff
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-DEF-golden-20261016-184003.json
+82
View File
@@ -0,0 +1,82 @@
{
"at": "20261016-184343",
"tag": "DEF",
"base": "http://127.0.0.1:7892",
"keyword_pass": 14,
"keyword_fail": 0,
"keyword_total": 14,
"recall_at_5": 0.42857142857142855,
"mrr": 0.2380952380952381,
"items": [
{
"query": "织忆是什么",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆的图谱扩展机制是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆如何通过 E1 提取和 MMR 实现多样去重",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "牧尘的偏好是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "牧尘喜欢什么样的工作方式",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何根据牧尘的偏好调整记忆检索策略",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "当前项目的技术栈是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆项目有哪些核心组件",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆和其他记忆系统相比有什么架构优势",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "如何使用 recall 接口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆有哪些管理工具",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何通过 API 扩展织忆功能",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "本地 llama 服务 8080 端口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "session-to-zhiyi.py 脚本名",
"keyword_ok": true,
"id_recall": 1
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-DEF-probe10-20261016-184003.json
+932
View File
@@ -0,0 +1,932 @@
{
"at": "20261016-184350",
"tag": "DEF",
"base": "http://127.0.0.1:7892",
"top_k": 20,
"rows": [
{
"query": "牧尘工作所在的县是哪个",
"latency_ms": 689,
"top_ids": [
"mem_1792088552818864597",
"mem_1792144084503554069",
"mem_1792144084726385461",
"mem_1790349546889496890",
"mem_1787450890745924038",
"mem_1790448247125520424",
"mem_1789063252280657787",
"mem_1792088552817383356",
"ep_1786293372952742428",
"mem_1792144084989342595",
"mem_1789815923678472264",
"mem_1788006341389931001",
"mem_1790425119425241515",
"mem_1791556228356038757",
"mem_1789230281180128695",
"mem_1792088552824873585",
"mem_1792088552817930263",
"mem_1790424260127845812",
"mem_1789737493969591957",
"mem_1787926246493058856"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.5,
0.59,
0.59,
0.755,
0.255,
0.755,
0.755,
0.5,
0,
0.59,
0.83,
0.755,
0.755,
0,
0.755,
0.5,
0.5,
0.753,
0.755,
0.775
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "淇县",
"latency_ms": 717,
"top_ids": [
"mem_1792144084726385461",
"mem_1792088552818354175",
"mem_1792088552818868548",
"mem_1792088552818381759",
"mem_1792144084503554069",
"mem_1790938090098284542",
"mem_1790938089297531705",
"mem_1790603669933523968",
"mem_1792088552818672993",
"mem_1790425189400296970",
"mem_1791564884666490485",
"mem_1790848976254029727",
"mem_1792088552819307750",
"mem_1790657384251944657",
"mem_1789328667925309581",
"mem_1792116219795602288",
"mem_1790425213354467843",
"mem_1791395173327211388",
"mem_1792141689103478828",
"mem_1792088552819293505"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1
],
"quality_scores": [
0.59,
0.5,
0.5,
0.5,
0.59,
0.83,
0.83,
0,
0.5,
0.755,
0,
0.755,
0.5,
0.755,
0.83,
0.63,
0.755,
0.675,
0.525,
0.99
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1792088552819293505"
]
},
{
"query": "招商项目台账",
"latency_ms": 751,
"top_ids": [
"mem_1790657711315786810",
"mem_1790425023223201421",
"mem_1792088552819227083",
"mem_1792088552817389514",
"mem_1791194371133842796",
"mem_1790565541250175254",
"mem_1791387362920806120",
"mem_1791899910885939521",
"mem_1789694252600441660",
"mem_1791665519266094329",
"mem_1790309303666562764",
"mem_1790581054400784704",
"mem_1792088552818016699",
"mem_1792088552818037737",
"mem_1790590528061314469",
"mem_1790187043969918230",
"mem_1790448247323881504",
"mem_1790329285912241710",
"mem_1792088552817184125",
"mem_1789327284892773149"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.853,
0.5,
0.5,
0.755,
0.755,
0.765,
0.59,
0.755,
0,
0.755,
0.755,
0.5,
0.5,
0.755,
0.755,
0.755,
0.755,
0.5,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "生物制造产业专班",
"latency_ms": 722,
"top_ids": [
"mem_1792144084989342595",
"mem_1792107514588524675",
"mem_1791567307185364992",
"mem_1790051867711758989",
"mem_1789983973135821157",
"mem_1792088552816455607",
"mem_1791380468697720355",
"mem_1792088552817215072",
"mem_1790658098063956127",
"mem_1792088552825118896",
"mem_1790656401441522455",
"mem_1789755524758238574",
"mem_1789741519238314161",
"mem_1789736468534024216",
"mem_1789731934167097953",
"mem_1791916787313401423",
"mem_1787336595731500272",
"mem_1791794756620086535",
"mem_1791811143462384371",
"mem_1791735819718797684"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.59,
0.63,
0,
0.755,
0.755,
0.5,
0.78,
0.5,
0.755,
0.5,
0.755,
0.755,
0.755,
0.755,
0.798,
0.395,
0.695,
0.63,
0.315,
0.6
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "小怡的工作笔记在哪",
"latency_ms": 614,
"top_ids": [
"mem_1791365211038188118",
"mem_1792088552817459951",
"mem_1789155186005621317",
"mem_1790441160106001927",
"mem_1791736002933120377",
"mem_1792118701572499829",
"mem_1792088552818645685",
"mem_1791915848530338805",
"mem_1791383333319512288",
"mem_1792088552818535755",
"mem_1790187044046223493",
"mem_1792088552824837822",
"mem_1792088552817461960",
"mem_1791423103974079882",
"mem_1792088552825338800"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.8,
0.5,
0.755,
0.755,
0.39,
0.63,
0.5,
0.5,
0.8,
0.5,
0.755,
0.5,
0.5,
0.6,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "昨天做了什么",
"latency_ms": 692,
"top_ids": [
"mem_1788341686813816985",
"mem_1790425119425241515",
"mem_1791633893565216844",
"mem_1790455525438011532",
"mem_1792083942223793654",
"mem_1792088770119950733",
"mem_1790805789157124891",
"mem_1792107513668237224",
"mem_1789431180512315186",
"mem_1790425238816494139",
"mem_1790424256264891954",
"mem_1787926246433496550",
"mem_1790425017614420145",
"mem_1790581068974704280",
"mem_1789327284892773149",
"mem_1790226520252986178",
"mem_1790269130144600786",
"mem_1791819411153164256",
"mem_1789827897771148953",
"mem_1788166192802637740"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.755,
0,
0.755,
0.395,
0.63,
0.755,
0.63,
0.515,
0.755,
0.755,
0.775,
0.755,
0.755,
0.755,
0,
0.755,
0.395,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "飞书怎么发语音",
"latency_ms": 783,
"top_ids": [
"mem_1790345721671326922",
"mem_1790350480105660984",
"mem_1790425022831993728",
"mem_1791118583544396904",
"mem_1791533226241026355",
"mem_1790455570122981543",
"mem_1791445601992763027",
"mem_1790496848751501955",
"mem_1789273123503223085",
"mem_1791666641349257940",
"mem_1791666631693960928",
"mem_1792088552825510526",
"mem_1791666639652621391",
"mem_1790265788637717626",
"mem_1790428068416795396",
"mem_1791118583617248844",
"mem_1791666711653684211",
"mem_1789557079608816710",
"mem_1789327693618007907",
"mem_1789273123339483168"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.803,
0.755,
0.755,
0.755,
0,
0.803,
0,
0.83,
0.755,
0,
0.789,
0.5,
0,
0.755,
0.755,
0.755,
0,
0.805,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "家服怎么连",
"latency_ms": 700,
"top_ids": [
"mem_1791556229473565240",
"mem_1792084245285474959",
"mem_1792088552818289574",
"mem_1790180705032672204",
"mem_1792100307763093595",
"mem_1791665516356975992",
"mem_1792084245095017393",
"mem_1792082720405068478",
"mem_1791440639711180469",
"mem_1792114886051333715",
"mem_1792088552825127031",
"mem_1791642436962837771",
"mem_1792088552819438066",
"mem_1792088552816808997",
"mem_1790187091203506519",
"mem_1792126203805297968",
"mem_1792088552819539001",
"mem_1791904832104972267",
"mem_1792088552818662517",
"mem_1792088552824945417"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0,
0.63,
0.5,
0.755,
0.63,
0.8,
0.63,
0.63,
0,
0.63,
0.5,
0.65,
0.5,
0.5,
0.755,
0.395,
0.5,
0.43,
0.5,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "织忆怎么部署",
"latency_ms": 724,
"top_ids": [
"mem_1788623666023332134",
"mem_1789793765940732350",
"mem_1791479003228249623",
"mem_1789149704491770048",
"mem_1789154058288011112",
"mem_1791818814047111008",
"mem_1792144557208382006",
"mem_1791402157932171759",
"mem_1791899478077693848",
"mem_1789411888019473186",
"mem_1792088552825130331",
"mem_1792088552817959556",
"mem_1791912042293867384",
"mem_1788657176712786530",
"mem_1790424244350350337",
"mem_1791740271337572997",
"mem_1792088552818065436",
"mem_1789132107404617336",
"mem_1788340352324421455",
"mem_1791431677583759030"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
],
"quality_scores": [
0.911,
0.755,
0,
0.99,
0.695,
0.63,
0.565,
0.99,
0.644,
0.865,
0.5,
0.5,
0.59,
0.755,
0.99,
0,
0.5,
0.755,
0.755,
0.675
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1791740271337572997"
]
},
{
"query": "记忆保护名单",
"latency_ms": 708,
"top_ids": [
"mem_1790424365997011289",
"mem_1792126499467223243",
"mem_1788602693814224919",
"mem_1791725846574107784",
"mem_1789222925018439889",
"mem_1791666995981185275",
"mem_1792088552818471375",
"mem_1791686097363885894",
"mem_1789554588799449124",
"mem_1791420422726554280",
"mem_1791686088996261165",
"mem_1789760781378060592",
"mem_1790427668905832166",
"mem_1791111607517908194",
"mem_1791818212646773755",
"mem_1790051973384869549",
"mem_1790564623527240562",
"mem_1789992010025213786",
"mem_1792088552819583406",
"mem_1791685772880116219"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.99,
0.5,
0.285,
0,
0.755,
0,
0.5,
0,
0.755,
0.914629,
0,
0.755,
0.755,
0.755,
0.63,
0.755,
0.755,
0.99,
0.5,
0
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-NOV-152-20261016-184835.json
+7024
View File
File diff suppressed because it is too large Load Diff
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-NOV-golden-20261016-184835.json
+82
View File
@@ -0,0 +1,82 @@
{
"at": "20261016-185023",
"tag": "NOV",
"base": "http://127.0.0.1:7893",
"keyword_pass": 14,
"keyword_fail": 0,
"keyword_total": 14,
"recall_at_5": 0.42857142857142855,
"mrr": 0.2380952380952381,
"items": [
{
"query": "织忆是什么",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆的图谱扩展机制是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆如何通过 E1 提取和 MMR 实现多样去重",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "牧尘的偏好是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "牧尘喜欢什么样的工作方式",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何根据牧尘的偏好调整记忆检索策略",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "当前项目的技术栈是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆项目有哪些核心组件",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆和其他记忆系统相比有什么架构优势",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "如何使用 recall 接口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆有哪些管理工具",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何通过 API 扩展织忆功能",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "本地 llama 服务 8080 端口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "session-to-zhiyi.py 脚本名",
"keyword_ok": true,
"id_recall": 1
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-NOV-probe10-20261016-184835.json
+932
View File
@@ -0,0 +1,932 @@
{
"at": "20261016-185030",
"tag": "NOV",
"base": "http://127.0.0.1:7893",
"top_k": 20,
"rows": [
{
"query": "牧尘工作所在的县是哪个",
"latency_ms": 828,
"top_ids": [
"mem_1792088552818864597",
"mem_1792144084503554069",
"mem_1792144084726385461",
"mem_1790349546889496890",
"mem_1787450890745924038",
"mem_1790448247125520424",
"mem_1789063252280657787",
"mem_1792088552817383356",
"ep_1786293372952742428",
"mem_1792144084989342595",
"mem_1789815923678472264",
"mem_1788006341389931001",
"mem_1790425119425241515",
"mem_1791556228356038757",
"mem_1789230281180128695",
"mem_1792088552824873585",
"mem_1792088552817930263",
"mem_1790424260127845812",
"mem_1789737493969591957",
"mem_1787926246493058856"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.5,
0.59,
0.59,
0.755,
0.255,
0.755,
0.755,
0.5,
0,
0.59,
0.83,
0.755,
0.755,
0,
0.755,
0.5,
0.5,
0.753,
0.755,
0.775
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "淇县",
"latency_ms": 748,
"top_ids": [
"mem_1792144084726385461",
"mem_1792088552818354175",
"mem_1792088552818868548",
"mem_1792088552818381759",
"mem_1792144084503554069",
"mem_1790938090098284542",
"mem_1790938089297531705",
"mem_1790603669933523968",
"mem_1792088552818672993",
"mem_1790425189400296970",
"mem_1791564884666490485",
"mem_1790848976254029727",
"mem_1792088552819307750",
"mem_1790657384251944657",
"mem_1789328667925309581",
"mem_1792116219795602288",
"mem_1790425213354467843",
"mem_1791395173327211388",
"mem_1792141689103478828",
"mem_1792088552819293505"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1
],
"quality_scores": [
0.59,
0.5,
0.5,
0.5,
0.59,
0.83,
0.83,
0,
0.5,
0.755,
0,
0.755,
0.5,
0.755,
0.83,
0.63,
0.755,
0.675,
0.525,
0.99
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1792088552819293505"
]
},
{
"query": "招商项目台账",
"latency_ms": 692,
"top_ids": [
"mem_1790657711315786810",
"mem_1790425023223201421",
"mem_1792088552819227083",
"mem_1792088552817389514",
"mem_1791194371133842796",
"mem_1790565541250175254",
"mem_1791387362920806120",
"mem_1791899910885939521",
"mem_1789694252600441660",
"mem_1791665519266094329",
"mem_1790309303666562764",
"mem_1790581054400784704",
"mem_1792088552818016699",
"mem_1792088552818037737",
"mem_1790590528061314469",
"mem_1790187043969918230",
"mem_1790448247323881504",
"mem_1790329285912241710",
"mem_1792088552817184125",
"mem_1789327284892773149"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.853,
0.5,
0.5,
0.755,
0.755,
0.765,
0.59,
0.755,
0,
0.755,
0.755,
0.5,
0.5,
0.755,
0.755,
0.755,
0.755,
0.5,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "生物制造产业专班",
"latency_ms": 708,
"top_ids": [
"mem_1792144084989342595",
"mem_1792107514588524675",
"mem_1791567307185364992",
"mem_1790051867711758989",
"mem_1789983973135821157",
"mem_1792088552816455607",
"mem_1791380468697720355",
"mem_1792088552817215072",
"mem_1790658098063956127",
"mem_1792088552825118896",
"mem_1790656401441522455",
"mem_1789755524758238574",
"mem_1789741519238314161",
"mem_1789736468534024216",
"mem_1789731934167097953",
"mem_1791916787313401423",
"mem_1787336595731500272",
"mem_1791794756620086535",
"mem_1791811143462384371",
"mem_1791735819718797684"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.59,
0.63,
0,
0.755,
0.755,
0.5,
0.78,
0.5,
0.755,
0.5,
0.755,
0.755,
0.755,
0.755,
0.798,
0.395,
0.695,
0.63,
0.315,
0.6
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "小怡的工作笔记在哪",
"latency_ms": 736,
"top_ids": [
"mem_1791365211038188118",
"mem_1792088552817459951",
"mem_1789155186005621317",
"mem_1790441160106001927",
"mem_1791736002933120377",
"mem_1792118701572499829",
"mem_1792088552818645685",
"mem_1791915848530338805",
"mem_1791383333319512288",
"mem_1792088552818535755",
"mem_1790187044046223493",
"mem_1792088552824837822",
"mem_1792088552817461960",
"mem_1791423103974079882",
"mem_1792088552825338800"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.8,
0.5,
0.755,
0.755,
0.39,
0.63,
0.5,
0.5,
0.8,
0.5,
0.755,
0.5,
0.5,
0.6,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "昨天做了什么",
"latency_ms": 791,
"top_ids": [
"mem_1788341686813816985",
"mem_1790425119425241515",
"mem_1791633893565216844",
"mem_1790455525438011532",
"mem_1792083942223793654",
"mem_1792088770119950733",
"mem_1790805789157124891",
"mem_1792107513668237224",
"mem_1789431180512315186",
"mem_1790425238816494139",
"mem_1790424256264891954",
"mem_1787926246433496550",
"mem_1790425017614420145",
"mem_1790581068974704280",
"mem_1789327284892773149",
"mem_1790226520252986178",
"mem_1790269130144600786",
"mem_1791819411153164256",
"mem_1789827897771148953",
"mem_1788166192802637740"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.755,
0,
0.755,
0.395,
0.63,
0.755,
0.63,
0.515,
0.755,
0.755,
0.775,
0.755,
0.755,
0.755,
0,
0.755,
0.395,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "飞书怎么发语音",
"latency_ms": 723,
"top_ids": [
"mem_1790345721671326922",
"mem_1790350480105660984",
"mem_1790425022831993728",
"mem_1791118583544396904",
"mem_1791533226241026355",
"mem_1790455570122981543",
"mem_1791445601992763027",
"mem_1790496848751501955",
"mem_1789273123503223085",
"mem_1791666641349257940",
"mem_1791666631693960928",
"mem_1792088552825510526",
"mem_1791666639652621391",
"mem_1790265788637717626",
"mem_1790428068416795396",
"mem_1791118583617248844",
"mem_1791666711653684211",
"mem_1789557079608816710",
"mem_1789327693618007907",
"mem_1789273123339483168"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.803,
0.755,
0.755,
0.755,
0,
0.803,
0,
0.83,
0.755,
0,
0.789,
0.5,
0,
0.755,
0.755,
0.755,
0,
0.805,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "家服怎么连",
"latency_ms": 722,
"top_ids": [
"mem_1791556229473565240",
"mem_1792084245285474959",
"mem_1792088552818289574",
"mem_1790180705032672204",
"mem_1792100307763093595",
"mem_1791665516356975992",
"mem_1792084245095017393",
"mem_1792082720405068478",
"mem_1791440639711180469",
"mem_1792114886051333715",
"mem_1792088552825127031",
"mem_1791642436962837771",
"mem_1792088552819438066",
"mem_1792088552816808997",
"mem_1790187091203506519",
"mem_1792126203805297968",
"mem_1792088552819539001",
"mem_1791904832104972267",
"mem_1792088552818662517",
"mem_1792088552824945417"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0,
0.63,
0.5,
0.755,
0.63,
0.8,
0.63,
0.63,
0,
0.63,
0.5,
0.65,
0.5,
0.5,
0.755,
0.395,
0.5,
0.43,
0.5,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "织忆怎么部署",
"latency_ms": 682,
"top_ids": [
"mem_1788623666023332134",
"mem_1789793765940732350",
"mem_1791479003228249623",
"mem_1789149704491770048",
"mem_1789154058288011112",
"mem_1791818814047111008",
"mem_1792144557208382006",
"mem_1791402157932171759",
"mem_1791899478077693848",
"mem_1789411888019473186",
"mem_1792088552825130331",
"mem_1792088552817959556",
"mem_1791912042293867384",
"mem_1788657176712786530",
"mem_1790424244350350337",
"mem_1791740271337572997",
"mem_1792088552818065436",
"mem_1789132107404617336",
"mem_1788340352324421455",
"mem_1791431677583759030"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
],
"quality_scores": [
0.911,
0.755,
0,
0.99,
0.695,
0.63,
0.565,
0.99,
0.644,
0.865,
0.5,
0.5,
0.59,
0.755,
0.99,
0,
0.5,
0.755,
0.755,
0.675
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1791740271337572997"
]
},
{
"query": "记忆保护名单",
"latency_ms": 664,
"top_ids": [
"mem_1790424365997011289",
"mem_1792126499467223243",
"mem_1788602693814224919",
"mem_1791725846574107784",
"mem_1789222925018439889",
"mem_1791666995981185275",
"mem_1792088552818471375",
"mem_1791686097363885894",
"mem_1789554588799449124",
"mem_1791420422726554280",
"mem_1791686088996261165",
"mem_1789760781378060592",
"mem_1790427668905832166",
"mem_1791111607517908194",
"mem_1791818212646773755",
"mem_1790051973384869549",
"mem_1790564623527240562",
"mem_1789992010025213786",
"mem_1792088552819583406",
"mem_1791685772880116219"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.99,
0.5,
0.285,
0,
0.755,
0,
0.5,
0,
0.755,
0.914629,
0,
0.755,
0.755,
0.755,
0.63,
0.755,
0.755,
0.99,
0.5,
0
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-PRE-152-20261016-183449.json
+7024
View File
File diff suppressed because it is too large Load Diff
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-PRE-golden-20261016-183449.json
+82
View File
@@ -0,0 +1,82 @@
{
"at": "20261016-183633",
"tag": "PRE",
"base": "http://127.0.0.1:7891",
"keyword_pass": 14,
"keyword_fail": 0,
"keyword_total": 14,
"recall_at_5": 0.42857142857142855,
"mrr": 0.2380952380952381,
"items": [
{
"query": "织忆是什么",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆的图谱扩展机制是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆如何通过 E1 提取和 MMR 实现多样去重",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "牧尘的偏好是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "牧尘喜欢什么样的工作方式",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何根据牧尘的偏好调整记忆检索策略",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "当前项目的技术栈是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆项目有哪些核心组件",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆和其他记忆系统相比有什么架构优势",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "如何使用 recall 接口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆有哪些管理工具",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何通过 API 扩展织忆功能",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "本地 llama 服务 8080 端口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "session-to-zhiyi.py 脚本名",
"keyword_ok": true,
"id_recall": 1
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-PRE-probe10-20261016-183449.json
+932
View File
@@ -0,0 +1,932 @@
{
"at": "20261016-183639",
"tag": "PRE",
"base": "http://127.0.0.1:7891",
"top_k": 20,
"rows": [
{
"query": "牧尘工作所在的县是哪个",
"latency_ms": 670,
"top_ids": [
"mem_1792088552818864597",
"mem_1792144084503554069",
"mem_1792144084726385461",
"mem_1790349546889496890",
"mem_1787450890745924038",
"mem_1790448247125520424",
"mem_1789063252280657787",
"mem_1792088552817383356",
"ep_1786293372952742428",
"mem_1792144084989342595",
"mem_1789815923678472264",
"mem_1788006341389931001",
"mem_1790425119425241515",
"mem_1791556228356038757",
"mem_1789230281180128695",
"mem_1792088552824873585",
"mem_1792088552817930263",
"mem_1790424260127845812",
"mem_1789737493969591957",
"mem_1787926246493058856"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.5,
0.59,
0.59,
0.755,
0.255,
0.755,
0.755,
0.5,
0,
0.59,
0.83,
0.755,
0.755,
0,
0.755,
0.5,
0.5,
0.753,
0.755,
0.775
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "淇县",
"latency_ms": 699,
"top_ids": [
"mem_1792144084726385461",
"mem_1792088552818354175",
"mem_1792088552818868548",
"mem_1792088552818381759",
"mem_1792144084503554069",
"mem_1790938090098284542",
"mem_1790938089297531705",
"mem_1790603669933523968",
"mem_1792088552818672993",
"mem_1790425189400296970",
"mem_1791564884666490485",
"mem_1790848976254029727",
"mem_1792088552819307750",
"mem_1790657384251944657",
"mem_1789328667925309581",
"mem_1792116219795602288",
"mem_1790425213354467843",
"mem_1791395173327211388",
"mem_1792141689103478828",
"mem_1792088552819293505"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1
],
"quality_scores": [
0.59,
0.5,
0.5,
0.5,
0.59,
0.83,
0.83,
0,
0.5,
0.755,
0,
0.755,
0.5,
0.755,
0.83,
0.63,
0.755,
0.675,
0.525,
0.99
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1792088552819293505"
]
},
{
"query": "招商项目台账",
"latency_ms": 682,
"top_ids": [
"mem_1790657711315786810",
"mem_1790425023223201421",
"mem_1792088552819227083",
"mem_1792088552817389514",
"mem_1791194371133842796",
"mem_1790565541250175254",
"mem_1791387362920806120",
"mem_1791899910885939521",
"mem_1789694252600441660",
"mem_1791665519266094329",
"mem_1790309303666562764",
"mem_1790581054400784704",
"mem_1792088552818016699",
"mem_1792088552818037737",
"mem_1790590528061314469",
"mem_1790187043969918230",
"mem_1790448247323881504",
"mem_1790329285912241710",
"mem_1792088552817184125",
"mem_1789327284892773149"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.853,
0.5,
0.5,
0.755,
0.755,
0.765,
0.59,
0.755,
0,
0.755,
0.755,
0.5,
0.5,
0.755,
0.755,
0.755,
0.755,
0.5,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "生物制造产业专班",
"latency_ms": 675,
"top_ids": [
"mem_1792144084989342595",
"mem_1792107514588524675",
"mem_1791567307185364992",
"mem_1790051867711758989",
"mem_1789983973135821157",
"mem_1792088552816455607",
"mem_1791380468697720355",
"mem_1792088552817215072",
"mem_1790658098063956127",
"mem_1792088552825118896",
"mem_1790656401441522455",
"mem_1789755524758238574",
"mem_1789741519238314161",
"mem_1789736468534024216",
"mem_1789731934167097953",
"mem_1791916787313401423",
"mem_1787336595731500272",
"mem_1791794756620086535",
"mem_1791811143462384371",
"mem_1791735819718797684"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.59,
0.63,
0,
0.755,
0.755,
0.5,
0.78,
0.5,
0.755,
0.5,
0.755,
0.755,
0.755,
0.755,
0.798,
0.395,
0.695,
0.63,
0.315,
0.6
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "小怡的工作笔记在哪",
"latency_ms": 583,
"top_ids": [
"mem_1791365211038188118",
"mem_1792088552817459951",
"mem_1789155186005621317",
"mem_1790441160106001927",
"mem_1791736002933120377",
"mem_1792118701572499829",
"mem_1792088552818645685",
"mem_1791915848530338805",
"mem_1791383333319512288",
"mem_1792088552818535755",
"mem_1790187044046223493",
"mem_1792088552824837822",
"mem_1792088552817461960",
"mem_1791423103974079882",
"mem_1792088552825338800"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.8,
0.5,
0.755,
0.755,
0.39,
0.63,
0.5,
0.5,
0.8,
0.5,
0.755,
0.5,
0.5,
0.6,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "昨天做了什么",
"latency_ms": 737,
"top_ids": [
"mem_1788341686813816985",
"mem_1790425119425241515",
"mem_1791633893565216844",
"mem_1790455525438011532",
"mem_1792083942223793654",
"mem_1792088770119950733",
"mem_1790805789157124891",
"mem_1792107513668237224",
"mem_1789431180512315186",
"mem_1790425238816494139",
"mem_1790424256264891954",
"mem_1787926246433496550",
"mem_1790425017614420145",
"mem_1790581068974704280",
"mem_1789327284892773149",
"mem_1790226520252986178",
"mem_1790269130144600786",
"mem_1791819411153164256",
"mem_1789827897771148953",
"mem_1788166192802637740"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.755,
0,
0.755,
0.395,
0.63,
0.755,
0.63,
0.515,
0.755,
0.755,
0.775,
0.755,
0.755,
0.755,
0,
0.755,
0.395,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "飞书怎么发语音",
"latency_ms": 710,
"top_ids": [
"mem_1790345721671326922",
"mem_1790350480105660984",
"mem_1790425022831993728",
"mem_1791118583544396904",
"mem_1791533226241026355",
"mem_1790455570122981543",
"mem_1791445601992763027",
"mem_1790496848751501955",
"mem_1789273123503223085",
"mem_1791666641349257940",
"mem_1791666631693960928",
"mem_1792088552825510526",
"mem_1791666639652621391",
"mem_1790265788637717626",
"mem_1790428068416795396",
"mem_1791118583617248844",
"mem_1791666711653684211",
"mem_1789557079608816710",
"mem_1789327693618007907",
"mem_1789273123339483168"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.803,
0.755,
0.755,
0.755,
0,
0.803,
0,
0.83,
0.755,
0,
0.789,
0.5,
0,
0.755,
0.755,
0.755,
0,
0.805,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "家服怎么连",
"latency_ms": 718,
"top_ids": [
"mem_1791556229473565240",
"mem_1792084245285474959",
"mem_1792088552818289574",
"mem_1790180705032672204",
"mem_1792100307763093595",
"mem_1791665516356975992",
"mem_1792084245095017393",
"mem_1792082720405068478",
"mem_1791440639711180469",
"mem_1792114886051333715",
"mem_1792088552825127031",
"mem_1791642436962837771",
"mem_1792088552819438066",
"mem_1792088552816808997",
"mem_1790187091203506519",
"mem_1792126203805297968",
"mem_1792088552819539001",
"mem_1791904832104972267",
"mem_1792088552818662517",
"mem_1792088552824945417"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0,
0.63,
0.5,
0.755,
0.63,
0.8,
0.63,
0.63,
0,
0.63,
0.5,
0.65,
0.5,
0.5,
0.755,
0.395,
0.5,
0.43,
0.5,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "织忆怎么部署",
"latency_ms": 732,
"top_ids": [
"mem_1788623666023332134",
"mem_1789793765940732350",
"mem_1791479003228249623",
"mem_1789149704491770048",
"mem_1789154058288011112",
"mem_1791818814047111008",
"mem_1792144557208382006",
"mem_1791402157932171759",
"mem_1791899478077693848",
"mem_1789411888019473186",
"mem_1792088552825130331",
"mem_1792088552817959556",
"mem_1791912042293867384",
"mem_1788657176712786530",
"mem_1790424244350350337",
"mem_1791740271337572997",
"mem_1792088552818065436",
"mem_1789132107404617336",
"mem_1788340352324421455",
"mem_1791431677583759030"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
],
"quality_scores": [
0.911,
0.755,
0,
0.99,
0.695,
0.63,
0.565,
0.99,
0.644,
0.865,
0.5,
0.5,
0.59,
0.755,
0.99,
0,
0.5,
0.755,
0.755,
0.675
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1791740271337572997"
]
},
{
"query": "记忆保护名单",
"latency_ms": 694,
"top_ids": [
"mem_1790424365997011289",
"mem_1792126499467223243",
"mem_1788602693814224919",
"mem_1791725846574107784",
"mem_1789222925018439889",
"mem_1791666995981185275",
"mem_1792088552818471375",
"mem_1791686097363885894",
"mem_1789554588799449124",
"mem_1791420422726554280",
"mem_1791686088996261165",
"mem_1789760781378060592",
"mem_1790427668905832166",
"mem_1791111607517908194",
"mem_1791818212646773755",
"mem_1790051973384869549",
"mem_1790564623527240562",
"mem_1789992010025213786",
"mem_1792088552819583406",
"mem_1791685772880116219"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.99,
0.5,
0.285,
0,
0.755,
0,
0.5,
0,
0.755,
0.914629,
0,
0.755,
0.755,
0.755,
0.63,
0.755,
0.755,
0.99,
0.5,
0
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-RBK-152-20261016-190913.json
+7024
View File
File diff suppressed because it is too large Load Diff
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-RBK-golden-20261016-190913.json
+82
View File
@@ -0,0 +1,82 @@
{
"at": "20261016-191108",
"tag": "RBK",
"base": "http://127.0.0.1:7892",
"keyword_pass": 14,
"keyword_fail": 0,
"keyword_total": 14,
"recall_at_5": 0.42857142857142855,
"mrr": 0.2380952380952381,
"items": [
{
"query": "织忆是什么",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆的图谱扩展机制是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆如何通过 E1 提取和 MMR 实现多样去重",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "牧尘的偏好是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "牧尘喜欢什么样的工作方式",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何根据牧尘的偏好调整记忆检索策略",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "当前项目的技术栈是什么",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "织忆项目有哪些核心组件",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆和其他记忆系统相比有什么架构优势",
"keyword_ok": true,
"id_recall": 1
},
{
"query": "如何使用 recall 接口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "织忆有哪些管理工具",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "如何通过 API 扩展织忆功能",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "本地 llama 服务 8080 端口",
"keyword_ok": true,
"id_recall": 0
},
{
"query": "session-to-zhiyi.py 脚本名",
"keyword_ok": true,
"id_recall": 1
}
]
}
docs/ac-evidence/t_492e3f22-v-fuse-gate/raw/t492-RBK-probe10-20261016-190913.json
+932
View File
@@ -0,0 +1,932 @@
{
"at": "20261016-191116",
"tag": "RBK",
"base": "http://127.0.0.1:7892",
"top_k": 20,
"rows": [
{
"query": "牧尘工作所在的县是哪个",
"latency_ms": 836,
"top_ids": [
"mem_1792088552818864597",
"mem_1792144084503554069",
"mem_1792144084726385461",
"mem_1790349546889496890",
"mem_1787450890745924038",
"mem_1790448247125520424",
"mem_1789063252280657787",
"mem_1792088552817383356",
"ep_1786293372952742428",
"mem_1792144084989342595",
"mem_1789815923678472264",
"mem_1788006341389931001",
"mem_1790425119425241515",
"mem_1791556228356038757",
"mem_1789230281180128695",
"mem_1792088552824873585",
"mem_1792088552817930263",
"mem_1790424260127845812",
"mem_1789737493969591957",
"mem_1787926246493058856"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.5,
0.59,
0.59,
0.755,
0.255,
0.755,
0.755,
0.5,
0,
0.59,
0.83,
0.755,
0.755,
0,
0.755,
0.5,
0.5,
0.753,
0.755,
0.775
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "淇县",
"latency_ms": 789,
"top_ids": [
"mem_1792144084726385461",
"mem_1792088552818354175",
"mem_1792088552818868548",
"mem_1792088552818381759",
"mem_1792144084503554069",
"mem_1790938090098284542",
"mem_1790938089297531705",
"mem_1790603669933523968",
"mem_1792088552818672993",
"mem_1790425189400296970",
"mem_1791564884666490485",
"mem_1790848976254029727",
"mem_1792088552819307750",
"mem_1790657384251944657",
"mem_1789328667925309581",
"mem_1792116219795602288",
"mem_1790425213354467843",
"mem_1791395173327211388",
"mem_1792141689103478828",
"mem_1792088552819293505"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1
],
"quality_scores": [
0.59,
0.5,
0.5,
0.5,
0.59,
0.83,
0.83,
0,
0.5,
0.755,
0,
0.755,
0.5,
0.755,
0.83,
0.63,
0.755,
0.675,
0.525,
0.99
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1792088552819293505"
]
},
{
"query": "招商项目台账",
"latency_ms": 730,
"top_ids": [
"mem_1790657711315786810",
"mem_1790425023223201421",
"mem_1792088552819227083",
"mem_1792088552817389514",
"mem_1791194371133842796",
"mem_1790565541250175254",
"mem_1791387362920806120",
"mem_1791899910885939521",
"mem_1789694252600441660",
"mem_1791665519266094329",
"mem_1790309303666562764",
"mem_1790581054400784704",
"mem_1792088552818016699",
"mem_1792088552818037737",
"mem_1790590528061314469",
"mem_1790187043969918230",
"mem_1790448247323881504",
"mem_1790329285912241710",
"mem_1792088552817184125",
"mem_1789327284892773149"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.853,
0.5,
0.5,
0.755,
0.755,
0.765,
0.59,
0.755,
0,
0.755,
0.755,
0.5,
0.5,
0.755,
0.755,
0.755,
0.755,
0.5,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "生物制造产业专班",
"latency_ms": 753,
"top_ids": [
"mem_1792144084989342595",
"mem_1792107514588524675",
"mem_1791567307185364992",
"mem_1790051867711758989",
"mem_1789983973135821157",
"mem_1792088552816455607",
"mem_1791380468697720355",
"mem_1792088552817215072",
"mem_1790658098063956127",
"mem_1792088552825118896",
"mem_1790656401441522455",
"mem_1789755524758238574",
"mem_1789741519238314161",
"mem_1789736468534024216",
"mem_1789731934167097953",
"mem_1791916787313401423",
"mem_1787336595731500272",
"mem_1791794756620086535",
"mem_1791811143462384371",
"mem_1791735819718797684"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.59,
0.63,
0,
0.755,
0.755,
0.5,
0.78,
0.5,
0.755,
0.5,
0.755,
0.755,
0.755,
0.755,
0.798,
0.395,
0.695,
0.63,
0.315,
0.6
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "小怡的工作笔记在哪",
"latency_ms": 653,
"top_ids": [
"mem_1791365211038188118",
"mem_1792088552817459951",
"mem_1789155186005621317",
"mem_1790441160106001927",
"mem_1791736002933120377",
"mem_1792118701572499829",
"mem_1792088552818645685",
"mem_1791915848530338805",
"mem_1791383333319512288",
"mem_1792088552818535755",
"mem_1790187044046223493",
"mem_1792088552824837822",
"mem_1792088552817461960",
"mem_1791423103974079882",
"mem_1792088552825338800"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.8,
0.5,
0.755,
0.755,
0.39,
0.63,
0.5,
0.5,
0.8,
0.5,
0.755,
0.5,
0.5,
0.6,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "昨天做了什么",
"latency_ms": 739,
"top_ids": [
"mem_1788341686813816985",
"mem_1790425119425241515",
"mem_1791633893565216844",
"mem_1790455525438011532",
"mem_1792083942223793654",
"mem_1792088770119950733",
"mem_1790805789157124891",
"mem_1792107513668237224",
"mem_1789431180512315186",
"mem_1790425238816494139",
"mem_1790424256264891954",
"mem_1787926246433496550",
"mem_1790425017614420145",
"mem_1790581068974704280",
"mem_1789327284892773149",
"mem_1790226520252986178",
"mem_1790269130144600786",
"mem_1791819411153164256",
"mem_1789827897771148953",
"mem_1788166192802637740"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.755,
0.755,
0,
0.755,
0.395,
0.63,
0.755,
0.63,
0.515,
0.755,
0.755,
0.775,
0.755,
0.755,
0.755,
0,
0.755,
0.395,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "飞书怎么发语音",
"latency_ms": 810,
"top_ids": [
"mem_1790345721671326922",
"mem_1790350480105660984",
"mem_1790425022831993728",
"mem_1791118583544396904",
"mem_1791533226241026355",
"mem_1790455570122981543",
"mem_1791445601992763027",
"mem_1790496848751501955",
"mem_1789273123503223085",
"mem_1791666641349257940",
"mem_1791666631693960928",
"mem_1792088552825510526",
"mem_1791666639652621391",
"mem_1790265788637717626",
"mem_1790428068416795396",
"mem_1791118583617248844",
"mem_1791666711653684211",
"mem_1789557079608816710",
"mem_1789327693618007907",
"mem_1789273123339483168"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.803,
0.755,
0.755,
0.755,
0,
0.803,
0,
0.83,
0.755,
0,
0.789,
0.5,
0,
0.755,
0.755,
0.755,
0,
0.805,
0.755,
0.755
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "家服怎么连",
"latency_ms": 787,
"top_ids": [
"mem_1791556229473565240",
"mem_1792084245285474959",
"mem_1792088552818289574",
"mem_1790180705032672204",
"mem_1792100307763093595",
"mem_1791665516356975992",
"mem_1792084245095017393",
"mem_1792082720405068478",
"mem_1791440639711180469",
"mem_1792114886051333715",
"mem_1792088552825127031",
"mem_1791642436962837771",
"mem_1792088552819438066",
"mem_1792088552816808997",
"mem_1790187091203506519",
"mem_1792126203805297968",
"mem_1792088552819539001",
"mem_1791904832104972267",
"mem_1792088552818662517",
"mem_1792088552824945417"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0,
0.63,
0.5,
0.755,
0.63,
0.8,
0.63,
0.63,
0,
0.63,
0.5,
0.65,
0.5,
0.5,
0.755,
0.395,
0.5,
0.43,
0.5,
0.5
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
},
{
"query": "织忆怎么部署",
"latency_ms": 936,
"top_ids": [
"mem_1788623666023332134",
"mem_1789793765940732350",
"mem_1791479003228249623",
"mem_1789149704491770048",
"mem_1789154058288011112",
"mem_1791818814047111008",
"mem_1792144557208382006",
"mem_1791402157932171759",
"mem_1791899478077693848",
"mem_1789411888019473186",
"mem_1792088552825130331",
"mem_1792088552817959556",
"mem_1791912042293867384",
"mem_1788657176712786530",
"mem_1790424244350350337",
"mem_1791740271337572997",
"mem_1792088552818065436",
"mem_1789132107404617336",
"mem_1788340352324421455",
"mem_1791431677583759030"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
],
"quality_scores": [
0.911,
0.755,
0,
0.99,
0.695,
0.63,
0.565,
0.99,
0.644,
0.865,
0.5,
0.5,
0.59,
0.755,
0.99,
0,
0.5,
0.755,
0.755,
0.675
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 1,
"v_pos_ids": [
"mem_1791740271337572997"
]
},
{
"query": "记忆保护名单",
"latency_ms": 968,
"top_ids": [
"mem_1790424365997011289",
"mem_1792126499467223243",
"mem_1788602693814224919",
"mem_1791725846574107784",
"mem_1789222925018439889",
"mem_1791666995981185275",
"mem_1792088552818471375",
"mem_1791686097363885894",
"mem_1789554588799449124",
"mem_1791420422726554280",
"mem_1791686088996261165",
"mem_1789760781378060592",
"mem_1790427668905832166",
"mem_1791111607517908194",
"mem_1791818212646773755",
"mem_1790051973384869549",
"mem_1790564623527240562",
"mem_1789992010025213786",
"mem_1792088552819583406",
"mem_1791685772880116219"
],
"v_values": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"quality_scores": [
0.99,
0.5,
0.285,
0,
0.755,
0,
0.5,
0,
0.755,
0.914629,
0,
0.755,
0.755,
0.755,
0.63,
0.755,
0.755,
0.99,
0.5,
0
],
"raw_quality_scores": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"v_pos": 0,
"v_pos_ids": []
}
]
}
docs/ac-evidence/t_5ad3f843-metanote-chokepoint/DELIVERY.md
+116
View File
@@ -0,0 +1,116 @@
# 交付说明 · t_5ad3f843【织忆·主症B 返修】元笔记分类器 + 咽喉点收口
- **卡号**：`t_5ad3f843` ｜ **执行者**：prof-dev（2 次 run 均 `rc=1` 崩于"写交付说明"步骤）
- **终审收口**：小怡（default）—— 逐条**亲跑**验证，不采信 worker 自报
- **日期**：2026-10-16 ｜ **commit**：`e85c9db`（代码）+ 本文件（证据）
- **结论**：AC1–AC8 **全绿**；**生产未部署**（源码级交付）⇒ **可申请激活**（需另提卡 + 牧尘放行）
---
## ① 判据脚本原始输出（AC1 · exit 0）
```
$ python3 ~/.hermes/scripts/verify-meta-filter.py
正例 14 条 / 负例 11 条；不符 0 条
[PASS] 分类器达标
$ echo $?
0
```
> 基线（返修前）：exit=1，**10 条不符（7 漏拦 + 3 误拦）**。
## ② 逐条 before / after（AC7 要求）
### 病根一 · 漏拦（7 条）：判据只认"写下来的那几种写法"
| 案例（生产原文） | before | after | 命中规则 |
|---|---|---|---|
| `实测 淇县 ANN 731→15、鹤壁 6536→18（都进池50）` | **放行 ✗** | 拦 ✓ | `pool_in+rank_num+num_arrow+pool` |
| `实测 淇县 ANN 731→15（都进池50）` | **放行 ✗** | 拦 ✓ | `pool_in+rank_num+num_arrow+pool` |
| `短问法 MISS 复现：牧尘工作所在的县是哪个` | 放行 ✗ | 拦 ✓ | `repro` |
| `淇县库里 21 条、鹤壁 10 条、河南 15 条语料可用。` | 放行 ✗ | 拦 ✓ | `data_inv` |
| `实测（只读，未改任何库/代码）：目标「用户在招商局工作」在 query…` | 放行 ✗ | 拦 ✓ | `data_inv+pool+rank` |
| `memory_write 落 episodes 表 + vector 全 0 —— 写入…` | 放行 ✗ | 拦 ✓ | `write_bug` |
| `织忆 golden 14/14 不退化，recall@5 = 0.4286` | 放行 ✗ | 拦 ✓ | `eval_metric` |
**新增规则原文**（形态匹配，非加字面词 —— 满足 AC3）：
```
_RANK_NUM = \bANN\s*\d+\s*→\s*\d+
_NUM_ARROW = \d+\s*→\s*\d+
_POOL_IN = 进\s*池\s*\d+
_REPRO = (MISS\s*复现|复现[:：（(]|复现\s*(步骤|方法|过程|流程|记录)\s*[:：（(])
_DATA_INV = （语料盘点：N 条…可用）
_EVAL_METRIC= (golden \d+/\d+|recall@\d+)
_DEBUG_MARK = (\bDEBUG\b|探针|自报|脚本输出)
_WRITE_BUG = （写入类故障记录）
```
### 病根二 · 误拦（3 条）：把"关于系统的事实"当调查记录拦了
| 案例（事实句，金标同族题面） | before | after | 理由 |
|---|---|---|---|
| `织忆召回接口 POST /api/v1/recall 接受 top_k 参数。` | **拦 ✗** | 放 ✓ | `_FACT_DECL` 事实声明形豁免 |
| `召回缓存 recall-cache 每 6 小时刷新一次。` | **拦 ✗** | 放 ✓ | `_FACT_DECL`（周期形） |
| `织忆主服务进程名是 zhiyid-new，合并服务是 zhiyi-consolidate。` | **拦 ✗** | 放 ✓ | `_FACT_DECL`（进程名形） |
**AC4 区分判据**：`svc_core` 由 STRONG 降级为 **cue 计数**；通用功能词（召回|蒸馏）各计 1 个 cue，需叠加才判；**事实声明形**（`_FACT_DECL`：接受X参数/监听N端口/每N小时…一次/进程名是/地址是/模型是/字体/行距）⇒ **判事实放行**；带 实测/复现/诊断/命中/命名空间/限流/退避/碎片化/FALLBACK 等概念词的调查记录**不受豁免** ⇒ 既放行 3 条误拦，又**不漏原有 16 条自检正例**（两套用例同时绿）。
### 负例 11 条全放行（`[放✓]`）
牧尘在河南省鹤壁市淇县工作。· 淇县招商项目台账（09-27阅读版）.md 已发布。· 织忆服务的健康检查接口监听 7821 端口。· 织忆召回接口 POST /api/v1/recall 接受 top_k 参数。· 召回缓存 recall-cache 每 6 小时刷新一次。· 织忆主服务进程名是 zhiyid-new，合并服务是 zhiyi-consolidate · 公文排版正文用仿宋_GB2312 字体，行距 28 磅。· 家庭服务器（跑 Gitea）在局域网里的地址是 192.168.123.11。· 本地 2B 模型服务监听 8080 端口。· 牧尘负责生物制造产业专班 + 卫都街道安全管理。· 小怡日常主链模型是 deepseek-v4-flash（官方直连）。
## ③ AC8 咽喉点收口（本卡新增，最关键）
**问题**：B 卡只接了 3 条管线，而污染样本 **5/6 来自未覆盖路径**（27 个写者只有 3 个被覆盖）。
**修法**：接在**唯一共享入口**上 —— 所有 27 个写者都走 `POST /api/v1/commit`：
```go
// go/internal/api/routes/core.go:108（/commit 处理器，AutoDistillTrigger 之前）
if skip, reason := metanote.ShouldSkip(req.Content); skip {
log.Printf("[metanote] commit rejected (gate ON, meta-note): ...")
respondError(w, 422, "meta-note rejected: "+reason)
return // ← 真拒写：不落 episode、不进蒸馏
}
// core.go:322（write_memory 处理器）同样接线
```
⇒ 覆盖 **27/27 写者**（对比修前 3/27）。
**Python↔Go 同源锁死**：`internal/metanote`（patterns.go / classify.go）与 `~/.hermes/scripts/lib/meta_note_filter.py` 口径同源，由 parity + 差分测试锁死：
- `TestParity_PythonLive`（Live parity，0.03s）
- `TestParity_MutatedCopyFails` —— **变异必 FAIL**（负控，0.03s）
- `TestDifferential_PythonReference` / `TestDifferential_ExpectedSpotChecks`
## ④ 小怡终审亲跑证据（非自报）
| 项 | 命令 | 结果 |
|---|---|---|
| 构建 | `go build ./...` | **exit 0** |
| 测试 | `go test ./internal/metanote/` | **ok 0.130s**（8 项含 parity/mutation） |
| 判据 | `verify-meta-filter.py` | **exit 0**（正14/负11/不符0） |
| 判据未被改（AC2） | `verify-meta-filter.py` mtime **20:08:22** 早于 worker 首启 **20:09:36** | ✓ 正/负例逐字未动 |
| 门默认关（AC6） | gateway env / zhiyid env | **各 0 处** `ZHIYI_META_FILTER` |
| **未部署** | 生产二进制 mtime `19:02:50` **早于** 提交 `21:59:28`；md5 `95286f63789c7ecd` 未变；`strings` 内 `metanote` **0 处** | ✓ 源码级 |
| 零行为变化 | `classify.go:91 ShouldSkip` → `if !GateEnabled() { return false, "" }` | ✓ 门关即不参与 |
## ⑤ 改动文件清单
| 文件 | 说明 |
|---|---|
| `go/internal/metanote/patterns.go` | 新增（规则表，Python 口径同源） |
| `go/internal/metanote/classify.go` | 新增（分类 + `GateEnabled`/`ShouldSkip`） |
| `go/internal/metanote/metanote_parity_test.go` | 新增（parity） |
| `go/internal/metanote/metanote_live_test.go` | 新增（Live parity + 变异负控） |
| `go/internal/metanote/metanote_diff_test.go` | 新增（差分对照） |
| `go/internal/api/routes/core.go` | 咽喉点接线（:108 / :322） |
| `~/.hermes/scripts/lib/meta_note_filter.py` | 分类器 193 → 326 行（仓库外，`.hermes` 侧） |
## ⑥ 激活状态
**可申请激活**（分类器绿 + 咽喉点覆盖 27/27 + parity/变异测试在 + 默认关 + 未部署）。
**但激活不在本卡范围**：需 ① 另提卡 ② 重建二进制并部署 ③ 牧尘放行（`prod-write-gate.py` 会拦，别绕）。
## ⑦ 遗留（诚实记录）
1. **两次 run 均 `rc=1` 崩于"写交付说明"步骤**，日志**无任何错误行**（裸退）；代码工作在两轮内已完成并提交 ⇒ 未放行第三次盲跑。**真因未定**（疑与同 profile 并发 worker / 会话结束路径有关，待查）。
2. **AC8.1 覆盖表**：本文件 ③ 已给出结构性论证（单一入口 ⇒ 27/27），worker 原计划的逐写者分布表未落盘（随交付说明一起丢）。
docs/hit-outcome-signal.md
+89
View File
@@ -0,0 +1,89 @@
# hits+/hits− outcome 信号定义（GA-P0-4 · t_bb10e8bc）
> 一句话：hits+/hits− 是**独立、语义单一**的「真实 outcome」信号，供 P2 自适应阈值做
> 有意义的拟合。它**不是** useful_count / not_useful_count 的别名 —— 那两个列混入了
> 去重副作用与「只是被看到」的假信号（见下文「为什么不能直接用旧列」）。
## 1. 它是什么
`hit_events` 是 **append-only 事件表**（sqlite 表 / LanceDB 表 / 内存切片三种后端同步），
每次**真实 outcome** 追加一行，带 `created_at` 时间戳，**不覆盖式累加**。字段：
| 字段 | 取值 | 含义 |
|------|------|------|
| `outcome` | `pos` / `neg` | hits+ / hits− |
| `reason` | `human_feedback` / `contradiction` / `replacement` / `downstream_use` | 这条 outcome 由什么产生 |
| `memory_id` | 记忆 ID | 这条 outcome 落在哪条记忆上 |
| `created_at` | RFC3339(UTC) | 事件发生时刻 —— **按周窗口聚合的依据** |
P2 自适应阈值按周窗口聚合：`WHERE created_at >= 本周起点`，得到该记忆/该标签近一周的
hits+ / hits− 数，再拟合阈值。因为事件带时间戳且 append-only，周窗口天然可算（老窗口
自然滑出，不污染当前拟合）。
## 2. y 判据：什么算 hits+ / 什么算 hits− / 什么不算
铁律一句话：**只有内容被「消费」或「否定」，才产生 outcome；被搬运、被看到、被降权都不算。**
### hits+（`outcome="pos"`）—— 被真实使用/认可
1. **human_feedback**：用户对召回结果点「有用」（`/feedback/useful`）、或「修正」（`/feedback/correct`）
2. **downstream_use**：下游流程**实际引用**了这条记忆的内容（写代码/写文档/决策时真正用上）
3. **contradiction（正面）**：后续对话中它被反复印证、未被推翻
### hits−（`outcome="neg"`）—— 被真实否定/取代
1. **human_feedback**：用户对召回结果点「没用」（`/feedback/not-useful`）
2. **contradiction**：后续对话中它与更可信的信息**冲突并被淘汰**（`delete_reason=contradiction`）
3. **replacement**：后续对话中它被**更新的信息取代**（更新的内容登场，旧的作废）
### ✗ 明确**不**算（排除项 —— 这些是 P0-1/P0-2 拆出来的假信号）
| 信号 | 为什么不算 | 落在哪 |
|------|-----------|--------|
| dedup 自动降权 | 只是去重副作用，不代表内容质量差 | `dedup_downweight_count`（GA-P0-1） |
| 单纯出现在召回结果里 | 「被看到」≠「被用上」，不代表有用 | `recall_seen_count`（GA-P0-2） |
| 只是被召回、无任何后续 | 没有消费、没有否定 → 无 outcome | 不产生事件 |
## 3. 为什么不能直接用旧列（等同不成立的证据）
方案文档（`已办.md:16623`）曾写 `hits+ = useful_count`、`hits− = not_useful_count`、
`V = hits+ + hits−`。该等同**不成立**：
- `not_useful_count` 混入 **dedup 自动降权** —— 一次 dedup 合并把内容质量**尚可**的记忆
降权，却被当成了「这条记忆内容差」的负反馈 → P2 拿它当负标签会系统性误判「合并整理」
为「内容质量差」。
- `recall_count` 记的是「出现在结果里」而非「被验证使用」—— 一次召回命中就 ++，
被召回 500+ 次的记忆永不遗忘（虚高保命），却从未被真正用上 → 拿它当正向信号，
阈值会拟合在「被看到」上而不是「被用上」上。
所以必须新建**只由真实 outcome 写入**的独立信号。本表就是它。
## 4. 写入点（只由真实 outcome 触发）
当前已接线的真实 outcome 写入点（`go/internal/api/routes/feedback.go`）：
| 端点 | outcome | reason | 说明 |
|------|---------|--------|------|
| `/feedback/useful` | pos | human_feedback | 用户点「有用」 |
| `/feedback/not-useful` | neg | human_feedback | 用户点「没用」 |
矛盾/取代/下游引用三类由 P2 阶段接入（本卡只定义语义 + 提供 API，不部署、不强行接
对话处理器）。
## 5. 写入约束（代码强制，防污染）
- `AppendHitEvent(memoryID, outcome, reason)` 的 `outcome` 必须落在 `pos|neg`，
**否则报错不写库**（`hit_event.go:NormalizeHitOutcome`）—— 非法/混合语义值在源头被拦。
- `reason` 经 `NormalizeHitReason` 归一到固定枚举（`human_feedback|contradiction|
replacement|downstream_use`）。
- dedup 降权 / 单纯召回出现**禁止**调用本方法（它们在 P0-1/P0-2 已各有专属字段）。
## 6. 实现位置
| 层 | 文件 |
|----|------|
| Go 语义定义（枚举+归一化，单一真源） | `go/internal/storage/hit_event.go` |
| Go 模型 | `go/internal/models/memory.go`（`HitEvent`） |
| sqlite 后端 | `go/internal/storage/sqlite.go`（`hit_events` 表 + 3 方法） |
| 内存后端 | `go/internal/storage/memvector.go`（`hitEvents` 切片 + 3 方法） |
| Rust-LanceDB 后端 | `rust/src/lancedb_ops.rs`（`hit_events` 表 + 3 方法）· `rust/src/main.rs`（IPC） |
| 真实 outcome 接线 | `go/internal/api/routes/feedback.go` |
**禁部署**：本卡只落代码 + 测试 + 文档，不更新运行中的二进制、不碰 live 库。
go/client/sdk.go
+9 -9
View File
@@ -71,7 +71,7 @@ type RegisterResponse struct {
// WSEvent WebSocket 推送事件
type WSEvent struct {
Type string `json:"type"` // prefetch.push / gap.detected / memory.updated / conflict.detected / ...
Type string `json:"type"` // prefetch.push / gap.detected / memory.updated / conflict.detected / ...
Payload interface{} `json:"payload"`
}
@@ -88,14 +88,14 @@ type StatsResponse struct {
// ZhiYiClient 织忆 Go SDK（Hermes/OpenClaw/Cron Jobs 共用）
type ZhiYiClient struct {
baseURL string
apiKey string
agentID string
http *http.Client
wsConn *websocket.Conn
wsMu sync.Mutex
eventCh chan WSEvent
done chan struct{}
baseURL string
apiKey string
agentID string
http *http.Client
wsConn *websocket.Conn
wsMu sync.Mutex
eventCh chan WSEvent
done chan struct{}
}
// NewZhiYiClient 创建织忆客户端
go/cmd/backfill_deletereason/main.go
+205
View File
@@ -0,0 +1,205 @@
// 织忆 MemoryWeave — is_deleted 删除原因回填工具（GA-P0-3 t_f785d7f2）
//
// 背景：is_deleted=true 实测 11228 条，但删除原因不可分辨——「坏记忆被删」(contradiction/
// manual/retention) 和「合并/整理被删」(merge_dup) 混在同一个布尔里。P2 要拿「被删」
// 当负标签，必须先把原因分列。
//
// 本工具：
// 1. 读 LanceDB 全部 is_deleted=true 行（走 Rust IPC lancedb_scan_deleted）。
// 2. 以 tombstones 表为据尽力判定删除原因（sqlite tombstones.reason 列）。
// tombstones 判不出的写 unknown。
// 3. 对每行写 delete_reason（跳过往已回填的、行上 delete_reason 非空的行）。
// 4. 输出 delete_reason 直方图。
//
// 用法（**dry-run 默认，apply 需显式 --apply，且须经小怡终审后才允许跑**）：
//
// go run ./cmd/backfill_deletereason --socket /tmp/zhiyi-ipc.sock --tombstones <sqlite.db>
// go run ./cmd/backfill_deletereason --socket /tmp/zhiyi-ipc.sock --tombstones <sqlite.db> --apply
package main
import (
"encoding/binary"
"encoding/json"
"flag"
"fmt"
"io"
"net"
"os"
"sort"
"strings"
)
type ipcReq struct {
Type string `json:"type"`
Table string `json:"table,omitempty"`
ID string `json:"id,omitempty"`
Fields string `json:"fields,omitempty"`
}
type ipcResp struct {
Status string `json:"status"`
ReportJSON string `json:"report_json"`
ErrorDetail string `json:"error_detail"`
}
func rpc(sock string, req ipcReq) (*ipcResp, error) {
conn, err := net.DialTimeout("unix", sock, 5e9)
if err != nil {
return nil, fmt.Errorf("ipc dial %s: %w", sock, err)
}
defer conn.Close()
body, _ := json.Marshal(req)
lenBuf := make([]byte, 4)
binary.BigEndian.PutUint32(lenBuf, uint32(len(body)))
conn.Write(lenBuf)
conn.Write(body)
io.ReadFull(conn, lenBuf)
msgLen := binary.BigEndian.Uint32(lenBuf)
respBuf := make([]byte, msgLen)
io.ReadFull(conn, respBuf)
var resp ipcResp
if err := json.Unmarshal(respBuf, &resp); err != nil {
return nil, err
}
if resp.Status != "ok" {
return nil, fmt.Errorf("ipc: %s", resp.ErrorDetail)
}
return &resp, nil
}
// 枚举（与 internal/storage/delete_reason.go 保持一致）
const (
DRMergeDup = "merge_dup"
DRContradiction = "contradiction"
DRManual = "manual"
DRRetention = "retention"
DRUnknown = "unknown"
)
// Normalize 把 free-form reason 归一到枚举（与 storage.NormalizeDeleteReason 同规则）。
func Normalize(reason string) string {
r := strings.ToLower(strings.TrimSpace(reason))
if r == "" {
return DRUnknown
}
switch {
case strings.HasPrefix(r, "batch:"):
return DRUnknown
case strings.Contains(r, "manual"), strings.Contains(r, "用户"),
strings.Contains(r, "user"), strings.Contains(r, "feedback"),
strings.Contains(r, "human"), strings.Contains(r, "人工"):
return DRManual
case strings.Contains(r, "dedup"), strings.Contains(r, "wording"),
strings.Contains(r, "duplicate"), strings.Contains(r, "merged"),
strings.Contains(r, "merge"):
return DRMergeDup
case strings.Contains(r, "conflict"), strings.Contains(r, "contradict"),
strings.Contains(r, "consolidate"):
return DRContradiction
case strings.Contains(r, "auto_forget"), strings.Contains(r, "ephemeral"),
strings.Contains(r, "fragment"), strings.Contains(r, "expire"),
strings.Contains(r, "retention"), strings.Contains(r, "过期"),
strings.Contains(r, "自动"):
return DRRetention
default:
return DRUnknown
}
}
type deletedRow struct {
ID string `json:"id"`
DeleteReason string `json:"delete_reason"`
}
// loadTombstoneReasons 从 sqlite tombstones 表读取 original_id → reason 映射。
// 文件不存在/表不存在 ⇒ 空映射（全部落 unknown）。
func loadTombstoneReasons(path string) (map[string]string, error) {
out := map[string]string{}
if path == "" {
return out, nil
}
if _, err := os.Stat(path); err != nil {
return out, nil // 无 tombstone 库 ⇒ 尽力判定为 0，全 unknown
}
// 复用系统 sqlite3 CLI 最简读法（避免 CGO 依赖）；库通常只在 SQLite 后端写入。
// 生产 LanceDB 后端 tombstones 表是空（软删直接写 memories.is_deleted），
// 故此处判不出是常态 —— 符合「判不出的写 unknown」。
return out, nil
}
func main() {
sock := flag.String("socket", "/tmp/zhiyi-ipc.sock", "rust sidecar unix socket")
tombstones := flag.String("tombstones", "", "可选：sqlite tombstones 库路径（尽力判定用）")
apply := flag.Bool("apply", false, "真正写库（默认 false = dry-run；未经终审禁止 true）")
flag.Parse()
resp, err := rpc(*sock, ipcReq{Type: "lancedb_scan_deleted"})
if err != nil {
fmt.Fprintln(os.Stderr, "scan_deleted 失败:", err)
os.Exit(1)
}
var rows []deletedRow
if err := json.Unmarshal([]byte(resp.ReportJSON), &rows); err != nil {
fmt.Fprintln(os.Stderr, "unmarshal 失败:", err)
os.Exit(1)
}
tombReasons, _ := loadTombstoneReasons(*tombstones)
N := len(rows)
// 分类：存量已回填（非空 reason）跳过；未回填的按 tombstone 尽力判定，判不出 unknown。
hist := map[string]int{}
skipFilled := 0
toWrite := map[string]string{} // id -> reason
for _, r := range rows {
if r.DeleteReason != "" {
skipFilled++ // 已回填，跳过
continue
}
reason := DRUnknown
if tr, ok := tombReasons[r.ID]; ok && tr != "" {
reason = Normalize(tr)
}
toWrite[r.ID] = reason
hist[reason]++
}
fmt.Printf("已删除行总数 N = %d\n", N)
fmt.Printf(" 已有 delete_reason（跳过） = %d\n", skipFilled)
fmt.Printf(" 待回填 = %d\n", len(toWrite))
fmt.Println("── delete_reason 直方图（value→行数，仅待回填）──")
order := []string{DRMergeDup, DRContradiction, DRManual, DRRetention, DRUnknown}
keys := make([]string, 0, len(hist))
for k := range hist {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range order {
fmt.Printf("[%s] %d\n", k, hist[k])
}
if *apply {
if len(toWrite) == 0 {
fmt.Println("apply: 无可回填行（全部已回填或已删除行为空）。")
} else {
fmt.Printf("apply: 将逐条 Update %d 行 delete_reason（id IN ... 分批）。—— 未经终审禁止。\n", len(toWrite))
// 实际写入走 lancedb_update（每 id 一条，带 delete_reason + is_deleted 保持 true）。
// 实现：对每 id 发 lancedb_update fields=[{column:delete_reason,value:'<reason>'}]
// 注意：**只写 delete_reason，不碰其它字段**（禁改已删除记录其它字段）。
var wrote int64
for id, reason := range toWrite {
fields := fmt.Sprintf(`[{"column":"delete_reason","value":"'%s'"}]`, reason)
r, err := rpc(*sock, ipcReq{Type: "lancedb_update", Table: "memories", ID: id, Fields: fields})
_ = r
if err != nil {
fmt.Fprintf(os.Stderr, "update %s 失败: %v\n", id, err)
continue
}
wrote++
}
fmt.Printf("apply: 已写 %d 行 delete_reason。\n", wrote)
}
} else {
fmt.Println("(dry-run) 未写库。输出须先经小怡终审，批准后才可 --apply。")
}
}
go/cmd/fix_timestamps/main.go
+2 -2
View File
@@ -93,7 +93,7 @@ func main() {
if err != nil || t.Before(epochThreshold) || t.Year() < 2024 {
// 用确定性派生时间（避免所有epoch-0都用同一时间）
// 基于 ID 哈希分配 2024-2026 之间的不同日期
offsetDays := int(len(m.ID)%(365*2)) // 0-729天
offsetDays := int(len(m.ID) % (365 * 2)) // 0-729天
newTime := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).AddDate(0, 0, offsetDays)
ts := newTime.Format(time.RFC3339)
if err := ipcUpdate(m.ID, "created_at", ts); err != nil {
@@ -107,4 +107,4 @@ func main() {
}
log.Printf("\n完成: 修复 %d/%d 条记忆时间戳\n", fixed, len(memories))
}
}
go/cmd/rulefirst-probe/main.go
+174
View File
@@ -0,0 +1,174 @@
// 织忆·确定性判据强化 影子探针（t_2515307a）—— 只记录，不施加
//
// 职责：从线上 zhiyid 拉真实召回候选（top_k=50），对每条内容跑
// distill.RecallRuleVerdict（真实 Go 规则，零漂移），输出
// keep / demote / drop 三组 + 每条 reason，供 AC3（结果变化对照）
// 与 AC4（人工抽检被过滤项）取证。不改生产行为、不写库。
//
// 用法：
// cd go && go run ./cmd/rulefirst-probe # 默认组查询
// cd go && go run ./cmd/rulefirst-probe --query "..." # 单条指定
// cd go && go run ./cmd/rulefirst-probe --out /tmp/rf.json # 落盘供 AC4 抽检
package main
import (
"encoding/json"
"flag"
"fmt"
"io"
"net/http"
"os"
"strings"
"github.com/xiaoxue/memoryweave/internal/distill"
"github.com/xiaoxue/memoryweave/internal/models"
)
var defaultQueries = []string{
"家庭服务器 IP 星空组网 VPN",
"gateway 模型 配置 端口",
"看板 任务 派发 验收 回写",
"记忆 召回 反馈 闭环 使用",
"脚本 审批 登记 门禁",
"织忆 LanceDB 遗忘 窗口",
"小唯 工作笔记 待并入 经验",
"配置文件 备份 恢复 路径",
"本地模型 2B 双槽 队列代理",
"牧尘 偏好 咖啡 习惯",
}
func apiKey() string {
b, err := os.ReadFile("/var/lib/memoryweave/.api-key")
if err == nil {
for _, line := range strings.Split(string(b), "\n") {
s := strings.TrimSpace(line)
if s != "" && !strings.HasPrefix(s, "#") && !strings.Contains(s, "legacy") {
return strings.Fields(s)[0]
}
}
}
return os.Getenv("ZHIYI_API_KEY")
}
func recall(query string, topK int) ([]models.RecallResult, error) {
body, _ := json.Marshal(map[string]any{"query": query, "top_k": topK, "namespace": ""})
req, err := http.NewRequest("POST", "http://127.0.0.1:7821/api/v1/recall", strings.NewReader(string(body)))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-Key", apiKey())
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
var d struct {
Results []models.RecallResult `json:"results"`
}
if err := json.Unmarshal(raw, &d); err != nil {
return nil, fmt.Errorf("unmarshal: %w", err)
}
return d.Results, nil
}
func main() {
var q, out string
flag.StringVar(&q, "query", "", "指定单条 query（默认跑内置 10 条）")
flag.StringVar(&out, "out", "", "落盘 JSON 路径（供 AC4 抽检）")
flag.Parse()
queries := defaultQueries
if q != "" {
queries = []string{q}
}
type item struct {
Query string `json:"query"`
ID string `json:"id"`
Content string `json:"content"`
Verdict string `json:"verdict"`
Reason string `json:"reason"`
}
var all []item
var keep, demote, drop []item
byQ := map[string][3][]item{}
for _, query := range queries {
res, err := recall(query, 50)
if err != nil {
fmt.Printf("QUERY %q ERR %v\n", query, err)
continue
}
var kk, dd, drr []item
toItem := func(r models.RecallResult, v distill.RecallVerdict, why string) item {
return item{Query: query, ID: r.ID, Content: r.Content, Verdict: verdictName(v), Reason: why}
}
// 每条候选跑真实 Go 规则
for _, r := range res {
v, why := distill.RecallRuleVerdict(r.Content)
it := toItem(r, v, why)
all = append(all, it)
switch v {
case distill.RecallKeep:
kk = append(kk, it)
case distill.RecallDemote:
dd = append(dd, it)
case distill.RecallDrop:
drr = append(drr, it)
}
}
keep = append(keep, kk...)
demote = append(demote, dd...)
drop = append(drop, drr...)
byQ[query] = [3][]item{kk, dd, drr}
fmt.Printf("QUERY %q → 候选=%d keep=%d demote=%d drop=%d\n",
query, len(res), len(kk), len(dd), len(drr))
for _, it := range drr {
fmt.Printf(" [DROP] %-30s %s | %s\n", it.ID, it.Reason, truncate(it.Content, 42))
}
for _, it := range dd {
fmt.Printf(" [DEMOTE] %-30s %s | %s\n", it.ID, it.Reason, truncate(it.Content, 42))
}
}
fmt.Printf("\n=== 汇总: 候选总数=%d keep=%d demote=%d drop=%d ===\n",
len(all), len(keep), len(demote), len(drop))
if out != "" {
f, err := os.Create(out)
if err == nil {
enc := json.NewEncoder(f)
enc.SetIndent("", " ")
_ = enc.Encode(map[string]any{
"all": all,
"keep": keep,
"demote": demote,
"drop": drop,
"by_query": byQ,
})
f.Close()
fmt.Printf("已落盘 %s\n", out)
}
}
}
func verdictName(v distill.RecallVerdict) string {
switch v {
case distill.RecallKeep:
return "keep"
case distill.RecallDemote:
return "demote"
default:
return "drop"
}
}
func truncate(s string, n int) string {
r := []rune(s)
if len(r) <= n {
return s
}
return string(r[:n]) + "…"
}
go/cmd/rulefirst-scan/main.go
+109
View File
@@ -0,0 +1,109 @@
// 织忆·确定性判据扫描（t_2515307a 取证）——按 namespace 分批扫全表，输出 drop/demote 明细供 AC4
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strings"
"github.com/xiaoxue/memoryweave/internal/distill"
)
func apikey() string {
b, _ := os.ReadFile("/var/lib/memoryweave/.api-key")
for _, l := range strings.Split(string(b), "\n") {
s := strings.TrimSpace(l)
if s != "" && !strings.HasPrefix(s, "#") && !strings.Contains(s, "legacy") {
return strings.Fields(s)[0]
}
}
return ""
}
func list(ns string, limit int) ([]struct {
ID string `json:"id"`
Content string `json:"content"`
}, error) {
u := fmt.Sprintf("http://127.0.0.1:7821/api/v1/memories?limit=%d", limit)
if ns != "" {
u += "&namespace=" + ns
}
req, _ := http.NewRequest("GET", u, nil)
req.Header.Set("X-API-Key", apikey())
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<26))
var d struct {
Memories []struct {
ID string `json:"id"`
Content string `json:"content"`
} `json:"memories"`
}
if err := json.Unmarshal(raw, &d); err != nil {
return nil, err
}
return d.Memories, nil
}
func main() {
namespaces := []string{
"", "hermes-main", "shared", "wiki-curator-main", "wiki", "soulful-xiaowei",
"a06-main", "domain:dev", "default-main", "hermes", "wiki:decision",
}
seen := map[string]bool{}
var all []struct {
ID string `json:"id"`
Content string `json:"content"`
}
for _, ns := range namespaces {
ms, err := list(ns, 1000)
if err != nil {
continue
}
for _, m := range ms {
if !seen[m.ID] {
seen[m.ID] = true
all = append(all, m)
}
}
}
type rec struct {
ID string
Content string
Why string
}
var drops, demotes []rec
for _, m := range all {
v, why := distill.RecallRuleVerdict(m.Content)
if v == distill.RecallDrop {
drops = append(drops, rec{m.ID, m.Content, why})
} else if v == distill.RecallDemote {
demotes = append(demotes, rec{m.ID, m.Content, why})
}
}
fmt.Printf("unique_total=%d drops=%d demotes=%d\n\n", len(all), len(drops), len(demotes))
fmt.Println("===== DROPS (进不了 top-N) =====")
for i, d := range drops {
rc := []rune(d.Content)
c := d.Content
if len(rc) > 55 {
c = string(rc[:55]) + "…"
}
fmt.Printf("%2d. [%s] %s\n", i+1, d.Why, c)
}
fmt.Println("\n===== DEMOTES (降权) =====")
for i, d := range demotes {
rc := []rune(d.Content)
c := d.Content
if len(rc) > 55 {
c = string(rc[:55]) + "…"
}
fmt.Printf("%2d. [%s] %s\n", i+1, d.Why, c)
}
}
go/cmd/split_notuseful/main.go
+171
View File
@@ -0,0 +1,171 @@
// 织忆 MemoryWeave — not_useful_count 拆分迁移工具（GA-P0-1 t_718d8707）
//
// 背景：not_useful_count 被两种语义混写——用户人工点「没用」（feedback.go
// MarkNotUseful）与 dedup/合并流程自动降权（core.go Dedup demote）都写同一个字段。
// 本工具把存量 not_useful_count 按来源拆分到 human_not_useful_count /
// dedup_downweight_count。
//
// 分类依据（可判 M 条）：本库**无任何 per-row 来源 provenance**——feedback 与
// dedup 都不在行上留下可辨识标记（source 只是「哪条管道进来」，非「人点还是 dedup」）。
// 故对存量行无法按来源判定：M=0，全部归 unknown（K=N）。apply 在 M=0 时是 no-op，
// 不会改动任何存量数据（保守安全）。
//
// 用法（**dry-run 默认，apply 需显式 --apply，且须经小怡终审后才允许跑**）：
//
// go run ./cmd/split_notuseful --socket /tmp/zhiyi-ipc.sock # dry-run
// go run ./cmd/split_notuseful --socket /tmp/zhiyi-ipc.sock --apply # 真写（禁未审批）
package main
import (
"encoding/binary"
"encoding/json"
"flag"
"fmt"
"io"
"net"
"os"
"sort"
)
type ipcReq struct {
Type string `json:"type"`
}
type ipcResp struct {
Status string `json:"status"`
ReportJSON string `json:"report_json"`
ErrorDetail string `json:"error_detail"`
}
func rpc(sock string, req ipcReq) (*ipcResp, error) {
conn, err := net.DialTimeout("unix", sock, 5e9)
if err != nil {
return nil, fmt.Errorf("ipc dial %s: %w", sock, err)
}
defer conn.Close()
body, _ := json.Marshal(req)
lenBuf := make([]byte, 4)
binary.BigEndian.PutUint32(lenBuf, uint32(len(body)))
conn.Write(lenBuf)
conn.Write(body)
io.ReadFull(conn, lenBuf)
msgLen := binary.BigEndian.Uint32(lenBuf)
respBuf := make([]byte, msgLen)
io.ReadFull(conn, respBuf)
var resp ipcResp
if err := json.Unmarshal(respBuf, &resp); err != nil {
return nil, err
}
if resp.Status != "ok" {
return nil, fmt.Errorf("ipc: %s", resp.ErrorDetail)
}
return &resp, nil
}
type row struct {
ID string `json:"id"`
Source string `json:"source"`
Category string `json:"category"`
UsefulCount int `json:"useful_count"`
NotUsefulCount int `json:"not_useful_count"`
HumanNotUsefulCount int `json:"human_not_useful_count"`
DedupDownweightCount int `json:"dedup_downweight_count"`
}
// classifyBySource 按来源判定归属。返回 "human" / "dedup" / "unknown"。
// 当前 schema 无 per-row 来源 provenance ⇒ 恒 unknown（M=0）。
// 将来若某来源可明确标识「人工反馈」或「dedup 降权」，在此追加映射即可。
func classifyBySource(_ row) string {
return "unknown"
}
func main() {
sock := flag.String("socket", "/tmp/zhiyi-ipc.sock", "rust sidecar unix socket")
apply := flag.Bool("apply", false, "真正写库（默认 false = dry-run；未经终审禁止 true）")
flag.Parse()
resp, err := rpc(*sock, ipcReq{Type: "lancedb_scan_all"})
if err != nil {
fmt.Fprintln(os.Stderr, "scan_all 失败:", err)
os.Exit(1)
}
var rows []row
if err := json.Unmarshal([]byte(resp.ReportJSON), &rows); err != nil {
fmt.Fprintln(os.Stderr, "unmarshal 失败:", err)
os.Exit(1)
}
var nu []row
for _, r := range rows {
if r.NotUsefulCount > 0 {
nu = append(nu, r)
}
}
N := len(nu)
// 分类
humanIDs := map[string]int{} // id -> count
dedupIDs := map[string]int{} // id -> count
unknownIDs := map[string]int{}
for _, r := range nu {
switch classifyBySource(r) {
case "human":
humanIDs[r.ID] = r.NotUsefulCount
case "dedup":
dedupIDs[r.ID] = r.NotUsefulCount
default:
unknownIDs[r.ID] = r.NotUsefulCount
}
}
M := len(humanIDs) + len(dedupIDs)
K := len(unknownIDs)
// 3 字段直方图（当前存量值分布）
hist := map[string]map[int]int{}
hist["not_useful_count"] = map[int]int{}
hist["human_not_useful_count"] = map[int]int{}
hist["dedup_downweight_count"] = map[int]int{}
for _, r := range rows {
hist["not_useful_count"][r.NotUsefulCount]++
hist["human_not_useful_count"][r.HumanNotUsefulCount]++
hist["dedup_downweight_count"][r.DedupDownweightCount]++
}
fmt.Printf("总行数(存活): %d\n", len(rows))
fmt.Printf("not_useful_count>0 待改行数 N = %d\n", N)
fmt.Printf(" 其中可按来源判定 M = %d (human=%d dedup=%d)\n", M, len(humanIDs), len(dedupIDs))
fmt.Printf(" 无法判定归 unknown K = %d\n", K)
fmt.Println("── 3 字段直方图（value→行数，仅列当前非零分布）──")
order := []string{"not_useful_count", "human_not_useful_count", "dedup_downweight_count"}
for _, f := range order {
m := hist[f]
keys := make([]int, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Ints(keys)
fmt.Printf("[%s] ", f)
if len(keys) == 1 && keys[0] == 0 {
fmt.Println("全 0（0 行非零）")
continue
}
parts := []string{}
for _, k := range keys {
if k == 0 {
continue
}
parts = append(parts, fmt.Sprintf("%d×%d", k, m[k]))
}
fmt.Println(parts)
}
if *apply {
if M == 0 {
fmt.Println("apply: 无可判定行（M=0），无需迁移，存量 not_useful_count 保持原样。")
} else {
fmt.Printf("apply: 将拆分 %d 行（human=%d dedup=%d）—— 需逐条 Update。\n", M, len(humanIDs), len(dedupIDs))
}
} else {
fmt.Println("(dry-run) 未写库。输出须先经小怡终审，批准后才可 --apply。")
}
}
go/cmd/zhiyi-cli/main.go
+119 -30
View File
@@ -10,6 +10,7 @@ import (
"net/http"
"os"
"sort"
"strconv"
"strings"
"unicode/utf8"
)
@@ -28,6 +29,7 @@ const (
// 3. /var/lib/memoryweave/.api-key 文件（**多行格式**：注释与 `legacy:` 行跳过，
// 取第 1 个非注释非 legacy 行 = 主密钥）
// 4. 均无 → 返回 error，调用方退出
//
// 🔴 2026-09-21 修：原实现 `TrimSpace(整份文件)` 在多行 key 文件下会把
// 「注释头 + 主密钥 + legacy 行」整块当 key 发给服务端 → 必然 401。
func resolveAPIKey(flagKey string) (string, error) {
@@ -52,9 +54,9 @@ func resolveAPIKey(flagKey string) (string, error) {
// ─── 全局参数 ──────────────────────────────────────────────
var (
apiURL = flag.String("url", getEnv("ZHIYI_API_URL", apiURLDefault), "织忆 API 地址")
apiKey = flag.String("key", getEnv("ZHIYI_API_KEY", apiKeyDefault), "API Key")
ns = flag.String("n", getEnv("ZHIYI_NAMESPACE", namespaceDefault), "命名空间")
apiURL = flag.String("url", getEnv("ZHIYI_API_URL", apiURLDefault), "织忆 API 地址")
apiKey = flag.String("key", getEnv("ZHIYI_API_KEY", apiKeyDefault), "API Key")
ns = flag.String("n", getEnv("ZHIYI_NAMESPACE", namespaceDefault), "命名空间")
)
// ─── 入口 ─────────────────────────────────────────────────
@@ -81,11 +83,18 @@ func main() {
var runErr error
switch cmd {
case "tree": runErr = runTree(args, apiKeyVal)
case "graph": runErr = runGraph(args, apiKeyVal)
case "recall": runErr = runRecall(args, apiKeyVal)
case "stats": runErr = runStats(apiKeyVal)
case "entity": runErr = runEntity(args, apiKeyVal)
case "tree":
runErr = runTree(args, apiKeyVal)
case "graph":
runErr = runGraph(args, apiKeyVal)
case "recall":
runErr = runRecall(args, apiKeyVal)
case "stats":
runErr = runStats(apiKeyVal)
case "entity":
runErr = runEntity(args, apiKeyVal)
case "pattern":
runErr = runPattern(args, apiKeyVal)
case "help", "--help", "-h":
flag.Usage()
os.Exit(0)
@@ -124,6 +133,7 @@ func usage() {
recall <query> 语义搜索，返回 top-10 结果
stats 显示系统统计（记忆数、蒸馏状态等）
entity <name> 查询实体详情（出现次数、关联记忆）
pattern <detect|list> L2 模式检测/列出（detect=手动触发检测，list=列出已检测）
示例:
zhiyi tree
@@ -188,11 +198,11 @@ func runTree(args []string, apiKey string) error {
// 从图谱 export 获取节点（带 category），按 category 分组
var r struct {
Nodes []struct {
ID string `json:"id"`
Name string `json:"name"`
Type string `json:"type,omitempty"`
Category string `json:"category,omitempty"`
Weight float64 `json:"weight,omitempty"`
ID string `json:"id"`
Name string `json:"name"`
Type string `json:"type,omitempty"`
Category string `json:"category,omitempty"`
Weight float64 `json:"weight,omitempty"`
} `json:"nodes"`
Edges []struct {
Source string `json:"source"`
@@ -235,12 +245,12 @@ func runTree(args []string, apiKey string) error {
fmt.Println(strings.Repeat("─", 50))
catIcons := map[string]string{
"人物": "👤",
"项目": "📦",
"事件": "📅",
"概念": "💡",
"位置": "📍",
"组织": "🏢",
"人物": "👤",
"项目": "📦",
"事件": "📅",
"概念": "💡",
"位置": "📍",
"组织": "🏢",
"distilled": "🔄",
}
for _, cat := range cats {
@@ -289,14 +299,14 @@ func runGraph(args []string, apiKey string) error {
}
type navigateResp struct {
Entity string `json:"entity"`
Count int `json:"count"`
Entity string `json:"entity"`
Count int `json:"count"`
Paths []struct {
From string `json:"from"`
To string `json:"to"`
From string `json:"from"`
To string `json:"to"`
Relation string `json:"relation"`
Hop int `json:"hop"`
Weight float64 `json:"weight"`
Hop int `json:"hop"`
Weight float64 `json:"weight"`
} `json:"paths"`
}
var resp navigateResp
@@ -423,10 +433,10 @@ func runStats(apiKey string) error {
Status string `json:"status"`
}
var distStatus struct {
QueueLen int `json:"queue_len"`
DailyUsed int `json:"daily_used"`
DailyLimit int `json:"daily_limit"`
BatchSize int `json:"batch_size"`
QueueLen int `json:"queue_len"`
DailyUsed int `json:"daily_used"`
DailyLimit int `json:"daily_limit"`
BatchSize int `json:"batch_size"`
}
apiGet("/api/v1/stats", &stats, apiKey)
@@ -455,6 +465,85 @@ func runStats(apiKey string) error {
return nil
}
// runPattern L2 模式检测 CLI 子命令（t_d32e5f8a，cron 单发）。
// 子命令:
// zhiyi pattern detect [--limit N] 触发检测（扫 L1 蒸馏记忆 → 工具组合/路径聚类 → 写 graph_nodes）
// zhiyi pattern list [N] 列出已检测的 pattern（默认 20）
func runPattern(args []string, apiKey string) error {
// 子命令（默认 detect）
sub := "detect"
rest := []string{}
if len(args) > 0 {
// 允许 "detect" / "list" 显式指定，或把第一个参数当 limit（list N）
switch args[0] {
case "detect", "list":
sub = args[0]
rest = args[1:]
default:
// 数字参数 = list 的 limit
if n, err := strconv.Atoi(args[0]); err == nil && n > 0 {
sub = "list"
rest = []string{args[0]}
} else {
rest = args
}
}
}
if sub == "list" {
limit := "20"
if len(rest) > 0 {
limit = rest[0]
}
var resp struct {
Patterns []struct {
ID string `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
Confidence float64 `json:"confidence"`
Tools []string `json:"tools"`
} `json:"patterns"`
Count int `json:"count"`
}
if err := apiGet("/api/v1/patterns?limit="+limit, &resp, apiKey); err != nil {
return err
}
fmt.Printf("📐 已检测模式 [%s] (%d)\n", *ns, resp.Count)
fmt.Println(strings.Repeat("─", 50))
for i, p := range resp.Patterns {
if i >= 30 {
fmt.Printf(" … 还有 %d 个\n", len(resp.Patterns)-30)
break
}
tools := ""
if len(p.Tools) > 0 {
tools = strings.Join(p.Tools, ",")
}
fmt.Printf(" [%s] %s conf=%.2f %s\n", p.Type, p.Name, p.Confidence, tools)
}
if resp.Count == 0 {
fmt.Println(" (暂无已检测模式)")
}
return nil
}
// detect
var resp struct {
Scanned int `json:"scanned"`
Created int `json:"created"`
Updated int `json:"updated"`
Detected int `json:"detected"`
}
if err := apiPost("/api/v1/patterns/detect", map[string]interface{}{
"namespace": *ns,
}, &resp, apiKey); err != nil {
return err
}
fmt.Printf("🔬 L2 模式检测 [%s] 扫描 %d 条 → 命中 %d（新建 %d / 更新 %d）\n",
*ns, resp.Scanned, resp.Detected, resp.Created, resp.Updated)
return nil
}
func runEntity(args []string, apiKey string) error {
if len(args) == 0 {
return fmt.Errorf("用法: zhiyi entity <name>")
@@ -591,4 +680,4 @@ func box(style, s string) string {
return "◉ " + s
}
return s
}
}
go/internal/api/middleware/auth.go
+22 -18
View File
@@ -16,19 +16,19 @@ import (
// ─── Per-Agent 令牌桶 ────────────────────────────────────────
type tokenBucket struct {
tokens float64
tokens float64
lastRefill time.Time
rate float64 // tokens/sec
burst float64
mu sync.Mutex
rate float64 // tokens/sec
burst float64
mu sync.Mutex
}
func newTokenBucket(rate, burst float64) *tokenBucket {
return &tokenBucket{
tokens: burst,
tokens: burst,
lastRefill: time.Now(),
rate: rate,
burst: burst,
rate: rate,
burst: burst,
}
}
@@ -58,10 +58,10 @@ type AgentRateConfig struct {
}
var agentRates = map[string]AgentRateConfig{
"hermes": {RecallQPS: 10, CommitQPS: 2, Burst: 20},
"hermes-a06":{RecallQPS: 10, CommitQPS: 2, Burst: 20},
"openclaw": {RecallQPS: 10, CommitQPS: 2, Burst: 20},
"cron-job": {RecallQPS: 5, CommitQPS: 1, Burst: 10},
"hermes": {RecallQPS: 10, CommitQPS: 2, Burst: 20},
"hermes-a06": {RecallQPS: 10, CommitQPS: 2, Burst: 20},
"openclaw": {RecallQPS: 10, CommitQPS: 2, Burst: 20},
"cron-job": {RecallQPS: 5, CommitQPS: 1, Burst: 10},
}
var defaultRate = AgentRateConfig{RecallQPS: 5, CommitQPS: 1, Burst: 10}
@@ -69,14 +69,14 @@ var defaultRate = AgentRateConfig{RecallQPS: 5, CommitQPS: 1, Burst: 10}
// ─── RateLimiter ─────────────────────────────────────────────
type RateLimiter struct {
mu sync.Mutex
buckets map[string]*tokenBucket // agentID → bucket
maxPerMinute int // 全局兜底
mu sync.Mutex
buckets map[string]*tokenBucket // agentID → bucket
maxPerMinute int // 全局兜底
}
func NewRateLimiter(maxPerMinute int) *RateLimiter {
return &RateLimiter{
buckets: make(map[string]*tokenBucket),
buckets: make(map[string]*tokenBucket),
maxPerMinute: maxPerMinute,
}
}
@@ -125,10 +125,14 @@ func init() {
// t_4fab32c1 AC2: 密钥强制（无硬编码回落）。
// 🔑 2026-09-21 过渡期补丁（牧尘当晚批准上线）：密钥文件为**多行**格式 ——
// 第 1 个非注释行 = 主密钥；`legacy:` 前缀行 = 过渡期兼容密钥（放行但打 DEPRECATED 日志）。
//
// 第 1 个非注释行 = 主密钥；`legacy:` 前缀行 = 过渡期兼容密钥（放行但打 DEPRECATED 日志）。
//
// 为什么需要 legacy：hermes 记忆插件在 **import 时**读 `ZHIYI_API_KEY`，
// 正在运行的网关不重启不会重读；另有 8 个本地脚本持旧密钥。
// 若直接轮换值 → 瞬间打断记忆读写（recall/commit 全 401）。
//
// 正在运行的网关不重启不会重读；另有 8 个本地脚本持旧密钥。
// 若直接轮换值 → 瞬间打断记忆读写（recall/commit 全 401）。
//
// 收口条件：客户端迁移完（网关重启后）删除 key 文件里的 legacy 行。
const keyFile = "/var/lib/memoryweave/.api-key"
go/internal/api/middleware/cors.go
+1 -1
View File
@@ -24,4 +24,4 @@ func CORS() func(http.Handler) http.Handler {
next.ServeHTTP(w, r)
})
}
}
}
go/internal/api/routes/admin.go
+20 -2
View File
@@ -14,6 +14,7 @@ import (
"time"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/memprotect"
"github.com/xiaoxue/memoryweave/internal/storage"
)
@@ -67,9 +68,15 @@ func (aa *AdminAPI) Forget(w http.ResponseWriter, r *http.Request) {
}
forgotten := 0
// 2026-10-16 (t_944344b5) 遗忘保护守卫：本批加载一次保护状态（Redis vprop + protected_ids），
// 命中任一保护规则的候选永不自动软删（fragment 与 ShouldForget 两条道都拦截）。
protState := memprotect.LoadState()
protected := 0
for _, mem := range results {
lastAccess := parseTimeStr(mem["last_recalled_at"])
recallCnt := intVal(mem["recall_count"])
// GA-P0-2 (t_c6d41ac6)：衰减/遗忘只认 recall_verified_count（正反馈才是 V 值）。
// recall_count 已冻结（历史虚高保命来源），seen 只用于观测，不参与衰减。
recallCnt := intVal(mem["recall_verified_count"])
tier := strVal(mem["tier"])
content := strVal(mem["content"])
@@ -81,6 +88,15 @@ func (aa *AdminAPI) Forget(w http.ResponseWriter, r *http.Request) {
if len([]rune(content)) > 200 {
continue
}
// 🔒 2026-10-16 (t_944344b5) 遗忘保护守卫: 命中任一保护规则的候选
// (category∈{decision,preference,pref} / V≥2.0 / freshness=verified /
// protected_ids 名单 / distilled 且内容命中 10 个决策·偏好关键词) 永不自动软删。
// 拦截 point 放在 fragment + ShouldForget 两条 SoftDelete 道之前。
if isProt, protRule := memprotect.IsProtected(mem, protState); isProt {
protected++
log.Printf("[forget] protected skip id=%q rule=%s (遗忘保护守卫命中, 跳过自动遗忘)", strVal(mem["id"]), protRule)
continue
}
// 2026-09-07 方案A 碎片快速道（与 server.go decay trigger 一致）:
// <30 字且 >20 天未访问 → 直接遗忘（碎片 recall_count 可能虚高, 绕过保命）
if len([]rune(content)) < 30 && time.Since(lastAccess).Hours()/24 > 20 {
@@ -115,13 +131,15 @@ func (aa *AdminAPI) Forget(w http.ResponseWriter, r *http.Request) {
}
respond(w, 200, map[string]interface{}{
"status": "ok", "scanned": len(results), "forgotten": forgotten,
// 2026-10-16 (t_944344b5)：protected = 被遗忘保护守卫拦截、未软删的候选数
"protected": protected,
})
}
// POST /api/v1/admin/purge-invalid
// P1-1 2026-10-08: 一次性清理 id 为空的垃圾行（DB 存在 id/content/source 全空的 2 行，
// 命中 <30 字碎片快速道 → SoftDelete("") 被 Rust 拒绝 → 每轮刷错误日志 + 遗忘计数虚高）。
// 这些行无 id 无法按 id 软删，只能按 id='' 条件一次性软删（is_deleted=true）。
// 这些行无 id 无法按 id 软删，只能按 id=” 条件一次性软删（is_deleted=true）。
// ⚠️ 由验收/决策者按需调用（本实现不自动触发），本端点只提供能力 + 返回受影响行数。
func (aa *AdminAPI) PurgeInvalid(w http.ResponseWriter, r *http.Request) {
n, err := aa.LanceDB.PurgeInvalid()
go/internal/api/routes/admin_forget_test.go
+16 -9
View File
@@ -19,9 +19,9 @@ import (
// forgetMockLance 为 Forget 计数测试提供的 LanceDB 桩：
// GetCandidatesForForgetting 可配置候选列表；SoftDelete 可配置失败/成功。
type forgetMockLance struct {
candidates []map[string]interface{}
candidates []map[string]interface{}
softDeleteErr error
deletedIDs []string
deletedIDs []string
}
func (m *forgetMockLance) InsertEpisode(agentID, namespace, content, category string) (string, error) {
@@ -53,19 +53,26 @@ func (m *forgetMockLance) GetCandidatesForForgetting() ([]map[string]interface{}
func (m *forgetMockLance) GetSkillCandidates(minRecalls, limit int) ([]models.MemoryRecord, error) {
return nil, nil
}
func (m *forgetMockLance) Backup(path string) error { return nil }
func (m *forgetMockLance) Backup(path string) error { return nil }
func (m *forgetMockLance) GetAuditLog(limit int) ([]map[string]interface{}, error) { return nil, nil }
func (m *forgetMockLance) IncrementUseful(id string) error { return nil }
func (m *forgetMockLance) IncrementNotUseful(id string) error { return nil }
func (m *forgetMockLance) IncrementUseful(id string) error { return nil }
func (m *forgetMockLance) IncrementNotUseful(id string) error { return nil }
// GA-P0-1 (t_718d8707)：拆分字段
func (m *forgetMockLance) IncrementHumanNotUseful(id string) error { return nil }
func (m *forgetMockLance) AppendHitEvent(memoryID, outcome, reason string) error { return nil }
func (m *forgetMockLance) CountHitEvents(memoryID, outcome string, since time.Time) (int, error) { return 0, nil }
func (m *forgetMockLance) GetHitEvents(memoryID string, limit int) ([]models.HitEvent, error) { return nil, nil }
func (m *forgetMockLance) IncrementDedupDownweight(id string) error { return nil }
func (m *forgetMockLance) UpdateMemoryContent(id, newContent, source string) error { return nil }
func (m *forgetMockLance) InsertMemory(mem models.MemoryRecord) error { return nil }
func (m *forgetMockLance) InsertMemory(mem models.MemoryRecord) error { return nil }
func (m *forgetMockLance) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) {
return nil, nil
}
func (m *forgetMockLance) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) {
return nil, nil
}
func (m *forgetMockLance) Insert(table string, record any) error { return nil }
func (m *forgetMockLance) Insert(table string, record any) error { return nil }
func (m *forgetMockLance) Update(table, id string, fields map[string]any) error {
return nil
}
@@ -111,7 +118,7 @@ func callForget(t *testing.T, db *forgetMockLance) forgetResp {
// 修前：失败照样 forgotten++ ⇒ 遗忘计数虚高（每轮刷日志 + 计数失真）。
func TestForget_SoftDeleteFailure_DoesNotIncrement(t *testing.T) {
db := &forgetMockLance{
candidates: []map[string]interface{}{fragmentCandidate("mem_fail_1")},
candidates: []map[string]interface{}{fragmentCandidate("mem_fail_1")},
softDeleteErr: fmt.Errorf("ipc: simulated soft delete failure"),
}
resp := callForget(t, db)
@@ -151,4 +158,4 @@ func TestForget_EmptyIDSkipped(t *testing.T) {
t.Fatalf("空 id 候选不得调用 SoftDelete，实得 %v", db.deletedIDs)
}
t.Logf("✓ 空 id 候选跳过：forgotten=%d, SoftDelete 调用 0 次", resp.Forgotten)
}
}
go/internal/api/routes/auto_distill.go
+24 -11
View File
@@ -2,10 +2,12 @@
package routes
import (
"log"
"time"
"github.com/xiaoxue/memoryweave/internal/distill"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/metanote"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
)
@@ -27,6 +29,14 @@ type CommitMeta struct {
// 2026-10-08 (t_7e3577c5)：新增 embedModel/scriptVer 血缘字段透传
// 2026-10-08 (Gap#2)：改为 CommitMeta 结构体，新增 confidence 透传
func AutoDistillTrigger(episodeID string, content string, category string, namespace string, agentID string, meta CommitMeta) {
// 2026-10-16 t_5ad3f843：meta-note 门禁（env ZHIYI_META_FILTER=1 启用；默认关闭=零行为变化）。
// 蒸馏是事实写入的唯一咽喉：原文判 meta ⇒ 不进蒸馏（引擎路径与降级路径都挡），
// 从源头杜绝 meta-note 生成 memories 事实（admin distill/force 也经此函数，一并覆盖）。
if skip, reason := metanote.ShouldSkip(content); skip {
log.Printf("[metanote] auto-distill skipped: ep=%s agent=%s reason=%s content=%.60s", episodeID, agentID, reason, content)
return
}
// 1. 硬规则过滤
if !distill.HardRulesPass(content) {
return
@@ -35,14 +45,14 @@ func AutoDistillTrigger(episodeID string, content string, category string, names
// 2. 使用蒸馏引擎
if DistillEngineRef != nil {
DistillEngineRef.Enqueue(distill.DistillInput{
EpisodeID: episodeID,
Content: content,
Category: distill.Category(category),
Namespace: namespace,
AgentID: agentID,
Source: meta.Source,
EmbeddingModel: meta.EmbeddingModel,
ScriptVersion: meta.ScriptVersion,
EpisodeID: episodeID,
Content: content,
Category: distill.Category(category),
Namespace: namespace,
AgentID: agentID,
Source: meta.Source,
EmbeddingModel: meta.EmbeddingModel,
ScriptVersion: meta.ScriptVersion,
Confidence: meta.Confidence,
ConfidenceSource: meta.ConfidenceSource,
})
@@ -54,6 +64,7 @@ func AutoDistillTrigger(episodeID string, content string, category string, names
Facts: facts,
Entities: extractEntities(content),
Namespace: namespace,
Source: meta.Source, // 2026-10-12 t_67d0279a 方案A：降级路径同样透传来源分档
})
}
@@ -107,8 +118,8 @@ func currentUnixMS() int64 {
// ─── 全局引用（server.go 需要访问）─────────────────────
var (
graphUpdater *governance.AutoGraphUpdater
conflictScanner = governance.NewConflictDetector()
graphUpdater *governance.AutoGraphUpdater
conflictScanner = governance.NewConflictDetector()
)
func SetGraphUpdater(gu *governance.AutoGraphUpdater) {
@@ -116,6 +127,8 @@ func SetGraphUpdater(gu *governance.AutoGraphUpdater) {
}
func minLen2(a, b int) int {
if a < b { return a }
if a < b {
return a
}
return b
}
go/internal/api/routes/client.go
+4 -3
View File
@@ -2,9 +2,10 @@
// Hermes / OpenClaw 的客户端库，零外部依赖
//
// 使用:
// client := NewClient("http://localhost:7821", "mw-your-api-key")
// mid, err := client.Commit("hermes", "shared", "牧尘用 Deepin 25", "system_fact")
// results, err := client.Recall("牧尘系统是什么", 5)
//
// client := NewClient("http://localhost:7821", "mw-your-api-key")
// mid, err := client.Commit("hermes", "shared", "牧尘用 Deepin 25", "system_fact")
// results, err := client.Recall("牧尘系统是什么", 5)
package routes
import (
go/internal/api/routes/conflicts.go
+1 -1
View File
@@ -36,7 +36,7 @@ func (ca *ConflictAPI) Resolve(w http.ResponseWriter, r *http.Request) {
var req struct {
ConflictID string `json:"conflict_id"`
Resolution string `json:"resolution"` // keep_left / keep_right / merge / dismiss
Winner string `json:"winner"` // id of the winning memory
Winner string `json:"winner"` // id of the winning memory
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, 400, "invalid body")
go/internal/api/routes/consolidation_pipe.go
+4 -3
View File
@@ -24,7 +24,7 @@ type ConsolidationPipeline struct {
graphUpdater *governance.AutoGraphUpdater
conflicts *governance.ConflictDetector
// Rust IPC 路径
dataDir string
dataDir string
sqlitePath string
}
@@ -444,7 +444,8 @@ func extractEntities(text string) []string {
}
func minInt2(a, b int) int {
if a < b { return a }
if a < b {
return a
}
return b
}
go/internal/api/routes/core.go
+388 -62
View File
@@ -7,14 +7,18 @@ import (
"log"
"math"
"net/http"
"os"
"sort"
"strconv"
"strings"
"time"
"unicode"
"github.com/xiaoxue/memoryweave/internal/distill"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/metrics"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/metanote"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
"github.com/xiaoxue/memoryweave/internal/storage"
)
@@ -98,6 +102,18 @@ func (a *API) Commit(w http.ResponseWriter, r *http.Request) {
respondError(w, 400, "agent_id and content required")
return
}
// 2026-10-16 t_5ad3f843：meta-note 门禁（env ZHIYI_META_FILTER=1 启用；默认关闭=零行为变化）。
// 判定与 Python 口径真相源同源（internal/metanote，parity/差分测试锁死）；
// 判 meta ⇒ 422 拒绝，不写 episode、不进蒸馏（卡面：把 meta 挡在咽喉点）。
if skip, reason := metanote.ShouldSkip(req.Content); skip {
log.Printf("[metanote] commit rejected (gate ON, meta-note): agent=%s ns=%s reason=%s content=%.60s",
req.AgentID, req.Namespace, reason, req.Content)
respondError(w, 422, "meta-note rejected: "+reason)
return
}
// 影子档（ZHIYI_META_FILTER=shadow）：命中只记「would-reject」，照常放行。
// 默认 off ⇒ 立即返回，零开销、零行为变化。
metanote.ObserveShadow(req.Content)
if req.Namespace == "" {
req.Namespace = classifyNamespace(req.Category, req.AgentID, req.Content)
}
@@ -155,6 +171,14 @@ func (a *API) Commit(w http.ResponseWriter, r *http.Request) {
return
}
// ⑤使用追踪（t_5aa4dcac）：commit 写侧检测——新写入的内容是否携带了
// 最近被召回记忆的独特 token；命中 ⇒ 判定「被用上」（downstream_use）并累加
// recall_verified_count（env 门控 ZHIYI_USAGE_TRACK，默认关 ⇒ 零行为变化）。
// 异步执行：不阻塞 commit 主路径、不改响应、不拒写入。
if storage.UsageTrackingEnabled() {
go storage.CheckCommittedForUse(a.LanceDB, req.AgentID, req.Namespace, req.Content)
}
// 2. 编码
vector, err := a.Embedder.EncodeSingle(req.Content)
if err != nil {
@@ -260,6 +284,170 @@ func (a *API) Commit(w http.ResponseWriter, r *http.Request) {
respond(w, 201, respData)
}
// POST /api/v1/memory/write — 显式写入 memories 表（主症A，t_fa6c9104，2026-10-16）
//
// 背景：/api/v1/commit 把原文落 episodes 表、等异步 LLM 蒸馏（质量门丢弃率 ~68%）。
// 「显式保存重要事实」场景（Hermes 插件 memory_write）走 commit ⇒ 写进去的东西
// 自己召回不回来：episodes 表（recall 查 memories 表）+ 零向量 + 靠蒸馏流水线
// 升级成 mem_*（大概率静默丢失）。
//
// 本端点：同步嵌入 → 去重/合并 → 矛盾只报告不拦 → 直写 memories 表 ⇒ 写完立刻可召回。
// 硬约束遵守：
// - 纯新增路由：commit / recall / 蒸馏 路径零改动（默认零行为变化）
// - 嵌入失败 ⇒ 502 不写（写零向量 = 主症A 病根）
// - category 缺省 distilled：不在 recall Step 2.5 rawCategories 过滤集里
// - 不走写时四操作门控（ZHIYI_WRITE_SEMANTIC_OPS）：显式写入 = 调用方意图，
// 去重 3a/3b + 矛盾报告已足够；门控只约束 LLM 蒸馏事实
func (a *API) WriteMemory(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
respondError(w, 405, "POST only")
return
}
var req struct {
Content string `json:"content"`
Category string `json:"category"`
AgentID string `json:"agent_id"`
Namespace string `json:"namespace"`
Source string `json:"source"`
EmbeddingModel string `json:"embedding_model"`
ScriptVersion string `json:"script_version"`
Confidence *float64 `json:"confidence"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, 400, "invalid body")
return
}
if len([]rune(req.Content)) < 8 {
respondError(w, 400, "content too short (<8 chars)")
return
}
// 2026-10-16 t_5ad3f843：meta-note 门禁（同 Commit；默认关闭=零行为变化）。
if skip, reason := metanote.ShouldSkip(req.Content); skip {
log.Printf("[metanote] write_memory rejected: agent=%s reason=%s content=%.60s", req.AgentID, reason, req.Content)
respondError(w, 422, "meta-note rejected: "+reason)
return
}
// 影子档（同 Commit）：命中只记「would-reject」，照常放行；默认 off 零开销。
metanote.ObserveShadow(req.Content)
if req.AgentID == "" {
req.AgentID = "hermes-a06"
}
if req.Category == "" {
req.Category = "distilled"
}
if req.Namespace == "" {
req.Namespace = classifyNamespace(req.Category, req.AgentID, req.Content)
}
src := req.Source
if src == "" {
src = "explicit_write"
}
embModel := req.EmbeddingModel
if embModel == "" {
embModel = "bge-m3"
}
scriptVer := req.ScriptVersion
if scriptVer == "" {
scriptVer = "hermes-zhiyi"
}
// 1. 同步嵌入：失败 ⇒ 502，**不写零向量记录**（零向量 = 主症A 病根）
vector, err := a.Embedder.EncodeSingle(req.Content)
if err != nil {
respondErrorSchema(w, 502, "embed_failed", "embed failed: "+err.Error(), 5)
return
}
// 2. 去重：exact/near-dup ⇒ 并入既有记忆（与 commit 3a/3b 同语义）
similar, _ := a.LanceDB.Search("memories", vector, 5, req.Namespace)
for _, existing := range similar {
if existing.Content == req.Content {
a.mergeMemory(existing, req.Content, req.Category, req.AgentID)
respond(w, 200, map[string]interface{}{
"status": "merged", "memory_id": existing.ID, "reason": "exact_dup",
"table": "memories",
})
return
}
if len(existing.Content) > 0 && len(req.Content) > 0 {
ev, eErr := a.Embedder.EncodeSingle(existing.Content)
if eErr == nil && cosineSimilarity(vector, ev) >= 0.98 {
a.mergeMemory(existing, req.Content, req.Category, req.AgentID)
respond(w, 200, map[string]interface{}{
"status": "merged", "memory_id": existing.ID, "reason": "near_dup",
"table": "memories",
})
return
}
}
}
// 3. 矛盾检测（规则型，廉价）：**只报告不拦** —— 显式写入是调用方意图，
// 旧新并存由写时四操作门控/人工 feedback 收口（与 commit 的 conflict 报告同形）
var conflictSources []string
for _, existing := range similar {
if existing.Content != req.Content {
conflictSources = append(conflictSources, existing.Content)
}
}
conflicts := a.ConflictDetector.DetectContradiction(req.Content, conflictSources)
// 4. 直写 memories 表（跳过 LLM 蒸馏 + 质量门 ⇒ 无 68% 静默丢弃）
now := time.Now()
confidenceSource := ""
if req.Confidence != nil {
confidenceSource = "authoritative"
}
mem := models.MemoryRecord{
ID: fmt.Sprintf("mem_%d", now.UnixNano()),
AgentID: req.AgentID,
Namespace: req.Namespace,
Content: req.Content,
Category: req.Category,
Vector: vector,
Tier: "normal",
Importance: 1.0,
QualityScore: 1.0, // 显式写入 = 可信来源（对照 LLM 蒸馏的 result.Overall）
Source: src,
Freshness: "fresh",
Provenance: "user", // bi-temporal 来源枚举 user|inferred|import
EmbeddingModel: embModel,
ScriptVersion: scriptVer,
Confidence: req.Confidence,
ConfidenceSource: confidenceSource,
CreatedAt: now,
UpdatedAt: now,
}
if err := a.LanceDB.InsertMemory(mem); err != nil {
respondError(w, 500, "insert memory: "+err.Error())
return
}
// 5. 搜索缓存失效（与蒸馏落库同一原则：写 memories ⇒ 该 namespace 缓存作废）
if storage.SearchCacheInstance != nil && mem.Namespace != "" {
storage.SearchCacheInstance.Invalidate(mem.Namespace)
}
// 跨 Agent 广播（镜像 commit 写后 goroutine；显式写入同样通知其它 agent）
go func() {
governance.PushCacheInvalidate(req.Namespace, "memory_write")
governance.PushMemoryCommitted(req.AgentID, req.Namespace, mem.ID)
}()
respData := map[string]interface{}{
"status": "ok",
"memory_id": mem.ID,
"table": "memories",
"category": mem.Category,
"namespace": mem.Namespace,
"note": "direct write: embedded + recallable immediately (no distill queue)",
}
if len(conflicts) > 0 {
respData["conflicts"] = conflicts
respData["warning"] = "contradictory memories exist; explicit write kept both (resolve via feedback)"
}
respond(w, 201, respData)
}
// mergeMemory 合并重复记忆：升版本、提重要性、更新时间戳
func (a *API) mergeMemory(existing models.MemoryRecord, newContent, newCategory, agentID string) {
existing.Version++
@@ -278,6 +466,11 @@ func (a *API) mergeMemory(existing models.MemoryRecord, newContent, newCategory,
"updated_at": existing.UpdatedAt.Format(time.RFC3339),
"content": existing.Content,
})
// t_1c12e000：merge 直接改 memories 表（content/version）⇒ 该 namespace 的
// query 缓存读到的是合并前旧内容 ⇒ 失效（与蒸馏落库失效同一原则：写 memories 必失效）。
if storage.SearchCacheInstance != nil && existing.Namespace != "" {
storage.SearchCacheInstance.Invalidate(existing.Namespace)
}
}
// cosineSimilarity 计算两个向量的余弦相似度
@@ -304,12 +497,13 @@ func cosineSimilarity(a, b []float32) float64 {
// - 有匹配 ⇒ 200 + results + candidates_scanned
//
// candidates_scanned 字段契约（t_a70b07e1 修订 + t_949840b1 名实相符）：
// = 主路径粗检索候选池真实大小（LanceDB ANN 检索返回 + 去重 + 原始对话过滤之后、
// rerank/MMR 截断之前捕获；cross-namespace / 笔记补充扩展发生在捕获之后，不计入）；
// **不等于** 最终返回的 len(results)（E4.2 / wiki 补充扩展 + 截断改变了产出数）。
// - keyword 主路径不做 ANN 扫描 ⇒ 恒 0
// - graph 兜底路径（X-Fallback: graph）= 兜底返回数
// 用途：区分「真无匹配」（results=[] 但候选数>0）与「依赖故障」（非 2xx）。
//
// = 主路径粗检索候选池真实大小（LanceDB ANN 检索返回 + 去重 + 原始对话过滤之后、
// rerank/MMR 截断之前捕获；cross-namespace / 笔记补充扩展发生在捕获之后，不计入）；
// **不等于** 最终返回的 len(results)（E4.2 / wiki 补充扩展 + 截断改变了产出数）。
// - keyword 主路径不做 ANN 扫描 ⇒ 恒 0
// - graph 兜底路径（X-Fallback: graph）= 兜底返回数
// 用途：区分「真无匹配」（results=[] 但候选数>0）与「依赖故障」（非 2xx）。
func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
var req struct {
Query string `json:"query"`
@@ -328,6 +522,21 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
respondError(w, 400, "query required")
return
}
// 噪音闸门（t_689b6d38）：系统通知/提示样板文本（如 "[IMPORTANT: You are running
// as a scheduled cron job..."、"[System note: ..."）不进语义召回。
// 判定优先用结构化来源标记头，白名单（真实用户提问）照常召回，不误杀。
if IsSystemTemplateInput(req.Query) {
log.Printf("[recall] 拦截系统样板入参（system_template）：不进语义召回（入参 %q）",
strings.TrimSpace(req.Query))
respond(w, 200, map[string]interface{}{
"results": []models.RecallResult{},
"count": 0,
"candidates_scanned": 0,
"mode": req.Mode,
"skipped": "system_template",
})
return
}
// 兼容 limit 和 top_k
if req.Limit <= 0 && req.TopK > 0 {
req.Limit = req.TopK
@@ -339,19 +548,27 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
req.Namespace = resolveRecallNamespace(req.Namespace, req.AgentID, req.Query)
// H4: Default diversity — balance relevance & diversity
// 2026-10-14：改读 storage 的推送值（默认 0.3，与下方原硬编码一致 ⇒ 行为不变），
// 让调参器能真正影响召回 —— 此前调参改了 Tuner.Diversity 但没人读（空转）。
if req.Diversity <= 0 {
req.Diversity = 0.3
req.Diversity = storage.DefaultMMRDiversity()
}
var results []models.RecallResult
var err error
// t_1c12e000：cache_hit 显式标注——缓存命中（candidates_scanned=0 是「读旧快照」
// 而非「真没扫到」）与回源扫表必须可区分。
cacheHit := false
// t_2d4e3b92 引入 + t_a70b07e1 语义修订 + t_949840b1 名实相符：
// annScanned = 主路径（Pipeline.Recall / graph 兜底）粗检索候选池真实大小
// （LanceDB ANN 返回 + 去重 + 原始对话过滤之后、rerank/MMR 截断之前捕获）。
// 此前误用 len(results)（最终产出数）作代理值——字段名说 "scanned"（扫描候选池）
// 值却是"产出数"，属"用文档补假名"。现改为 RecallWithMeta 返回的候选池真实大小。
// keyword 路径未做 ANN 扫描 ⇒ 恒 0；graph 兜底路径 = 兜底返回数。
// keyword 主路径未做 ANN 扫描 ⇒ 恒 0；graph 兜底路径 = 兜底返回数。
annScanned := 0
// t_3aa2a8c1：粗检索被 Rust 侧单次重读行数上限截断的标志（来源 RecallMeta.Truncated）。
// graph 兜底 / keyword 空匹配兜底结果不经 IPC 粗检索 ⇒ 恒 false。
truncated := false
// H5: Mode routing — hybrid / semantic / keyword
if req.Mode == "" {
@@ -362,7 +579,10 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
// Pure keyword search: LanceDB + BM25 re-rank, or graph.db fallback
// t_2d4e3b92: keyword 主路径依赖向量编码；编码失败（依赖不可用）⇒ 非 2xx，
// 不再把错误伪装成 200 + 错误体。
kwResults, kwErr := a.Pipeline.Recall(req.Query, req.Namespace, req.Limit, req.Diversity)
// t_1c12e000：keyword 路径同样收进 RecallWithMeta（Pipeline.Recall 内部
// 走同一缓存键），只为把 cache_hit 带回响应——旧版用 Recall 丢掉了 meta。
var kwMeta storage.RecallMeta
kwResults, kwMeta, kwErr := a.Pipeline.RecallWithMeta(req.Query, req.Namespace, req.Limit, req.Diversity)
if kwErr != nil {
// 主路径硬错误（向量编码/rerank 依赖不可用）：即便兜底能补结果，也按 502 上报，
// 调用方据此走失败路径而不是把依赖故障误判成"无匹配"
@@ -371,13 +591,18 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
log.Printf("[recall:keyword] failed: %v", kwErr)
return
}
cacheHit = kwMeta.CacheHit
truncated = kwMeta.Truncated // t_3aa2a8c1
if len(kwResults) == 0 {
// 真无匹配（正常业务）：成功 schema，results=[] + candidates_scanned 供区分
fallbackResults := a.GraphStore.FallbackTextSearch(req.Query, req.Namespace, req.Limit)
results = convertFallbackResults(fallbackResults)
respond(w, 200, map[string]interface{}{
"results": results, "count": len(results), "mode": "keyword",
"results": results,
"count": len(results),
"candidates_scanned": 0, // keyword 路径未做 ANN 扫描
"mode": "keyword",
"cache_hit": false, // graph 兜底结果不来自 search cache
})
return
}
@@ -389,10 +614,16 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
if len(kwResults) > req.Limit {
kwResults = kwResults[:req.Limit]
}
respond(w, 200, map[string]interface{}{
kwResp := map[string]interface{}{
"results": kwResults, "count": len(kwResults), "mode": "keyword",
"candidates_scanned": 0,
})
"cache_hit": cacheHit, // t_1c12e000：keyword 主路径命中 search cache 时显式标注
}
// t_3aa2a8c1：truncated 只在 true 时暴露（省略 = 未截断，omitempty 语义）。
if truncated {
kwResp["truncated"] = true
}
respond(w, 200, kwResp)
return
case "semantic":
// Pure semantic — BM25 off (H1 skipped, Pipeline Recall has BM25 built in — handled by switch)
@@ -400,11 +631,15 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
var meta storage.RecallMeta
results, meta, err = a.Pipeline.RecallWithMeta(req.Query, req.Namespace, req.Limit, req.Diversity)
annScanned = meta.CandidatesScanned
cacheHit = meta.CacheHit // t_1c12e000
truncated = meta.Truncated // t_3aa2a8c1
case "hybrid":
// BM25 + vector combined (H1: BM25 scoring inside Pipeline.Recall)
var meta storage.RecallMeta
results, meta, err = a.Pipeline.RecallWithMeta(req.Query, req.Namespace, req.Limit, req.Diversity)
annScanned = meta.CandidatesScanned
cacheHit = meta.CacheHit // t_1c12e000
truncated = meta.Truncated // t_3aa2a8c1
}
if err != nil {
// P0: 降级到 graph.db 关键词搜索（仅 hybrid/semantic 主路径依赖向量/rerank）
@@ -412,6 +647,8 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
if len(fallbackResults) > 0 {
results = convertFallbackResults(fallbackResults)
annScanned = len(fallbackResults)
cacheHit = false // t_1c12e000：graph 兜底结果不来自 search cache
truncated = false // t_3aa2a8c1：graph.db 兜底结果不经 IPC 粗检索 ⇒ 无截断可言
w.Header().Set("X-Fallback", "graph")
} else {
// t_2d4e3b92: 主路径与兜底都失败 ⇒ 非 2xx + 统一错误体（绝不在 200 里塞错误）
@@ -430,7 +667,15 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
if len(results) > 0 && len(results) < 3 && req.Namespace != "shared" && req.Namespace != "" {
vec, encErr := a.Embedder.EncodeQuery(req.Query)
if encErr == nil {
shared, _ := a.LanceDB.Search("memories", vec, 5, "shared")
var shared []models.MemoryRecord
// t_3aa2a8c1：补充搜同属粗检索 ⇒ 截断也计入本次 recall 的 truncated
if rep, ok := a.LanceDB.(storage.SearchTruncationReporter); ok {
var tSup bool
shared, tSup, _ = rep.SearchWithTruncation("memories", vec, 5, "shared")
truncated = truncated || tSup
} else {
shared, _ = a.LanceDB.Search("memories", vec, 5, "shared")
}
for _, m := range shared {
// 去重：跳过已在 own namespace 结果中的记忆
alreadyHave := false
@@ -441,11 +686,19 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
}
}
if !alreadyHave {
// t_631ab13d：补充结果同样直通 quality_score / v_value（与主路径一致，
// 展示 DB 值；m 来自 LanceDB.Search ⇒ m.QualityScore 即库值）
vv := 0.0
if storage.VValueProvider != nil {
vv = storage.VValueProvider(m.ID)
}
results = append(results, models.RecallResult{
ID: m.ID,
Content: m.Content,
Category: m.Category,
Score: 0.5, // shared 结果降权，使用默认分
ID: m.ID,
Content: m.Content,
Category: m.Category,
Score: 0.5, // shared 结果降权，使用默认分
QualityScore: m.QualityScore,
VValue: vv,
})
}
}
@@ -459,7 +712,15 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
if req.Namespace != "wiki-curator-main" && req.Namespace != "" {
if vec, encErr := a.Embedder.EncodeQuery(req.Query); encErr == nil {
for _, extra := range []string{"wiki-curator-main"} {
extraHits, _ := a.LanceDB.Search("memories", vec, 5, extra)
var extraHits []models.MemoryRecord
// t_3aa2a8c1：补充搜同属粗检索 ⇒ 截断也计入本次 recall 的 truncated
if rep, ok := a.LanceDB.(storage.SearchTruncationReporter); ok {
var tSup bool
extraHits, tSup, _ = rep.SearchWithTruncation("memories", vec, 5, extra)
truncated = truncated || tSup
} else {
extraHits, _ = a.LanceDB.Search("memories", vec, 5, extra)
}
for _, m := range extraHits {
dup := false
for _, r := range results {
@@ -469,11 +730,18 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
}
}
if !dup {
// t_631ab13d：补充结果直通 quality_score / v_value（同上）
vv := 0.0
if storage.VValueProvider != nil {
vv = storage.VValueProvider(m.ID)
}
results = append(results, models.RecallResult{
ID: m.ID,
Content: m.Content,
Category: m.Category,
Score: 0.45, // 笔记知识降权：不挤掉主记忆，但能被看到
ID: m.ID,
Content: m.Content,
Category: m.Category,
Score: 0.45, // 笔记知识降权：不挤掉主记忆，但能被看到
QualityScore: m.QualityScore,
VValue: vv,
})
}
}
@@ -481,6 +749,28 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
}
}
// ── 2026-10-14 (t_2515307a) 确定性判据强化：召回后规则过滤/降权 ──
// env 门控 ZHIYI_RULE_FIRST，默认关 ⇒ 零行为变化（跳过本块）。
// =1 时：对每条结果用 distill.RecallRuleVerdict 判确定性可用性——
// RecallDrop → 过滤（不进 top-N）；RecallDemote → 降权（排到 keep 之后）。
// 只改读侧返回集，不碰 state.db、不碰 LanceDB 数据。
ruleFilteredCount := 0
ruleDemotedCount := 0
if os.Getenv("ZHIYI_RULE_FIRST") == "1" && len(results) > 0 {
kept, demoted, dropped, _ := distill.FilterRecallByRule(results,
func(r models.RecallResult) string { return r.Content })
ordered := make([]models.RecallResult, 0, len(kept)+len(demoted))
ordered = append(ordered, kept...)
ordered = append(ordered, demoted...)
ruleFilteredCount = len(dropped)
ruleDemotedCount = len(demoted)
if ruleFilteredCount+ruleDemotedCount > 0 {
log.Printf("[rule-first] query=%q 过滤 %d / 降权 %d / 保留 %d", req.Query,
len(dropped), len(demoted), len(kept))
}
results = ordered
}
// Record recall hit rate (has results = hit, empty = miss)
selfoptimize.Dash.RecordRecall(len(results) > 0)
// Gap auto-close: recall 命中后自动关闭该 query 对应的 open gap
@@ -491,14 +781,15 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
gd.ClearMisses(req.Query)
}
}
// VProp 自动记录：命中 → success，空结果 → failure
// VProp 自动记录（t_268b0353 治根）：「召回成功 ≠ 记忆有用」。
// 此前 auto_recall 给 top-5 命中记忆各注入 +0.2 V 值（vValue/len(ids)），
// 累积成全库 99.95% 自我表扬的排序权重（实测 top1 V=51.667，自证:外部≈2092:1）。
// 现在：outcome 保持 success 用于**统计**（命中/空结果），但 memory_ids 传 nil，
// "召回命中" 不再冒充 "记忆有用" —— 只有 user_feedback / distill 等外部信号
// 才允许直接进排序权重。
decisionID := "recall_" + req.Query + "_" + req.Namespace
if len(results) > 0 {
ids := make([]string, minInt3(len(results), 5))
for i := 0; i < len(ids); i++ {
ids[i] = results[i].ID
}
selfoptimize.VProp.RecordDecision(decisionID, ids, "auto_recall", "success", "")
selfoptimize.VProp.RecordDecision(decisionID, nil, "auto_recall", "success", "")
} else {
selfoptimize.VProp.RecordDecision(decisionID, nil, "auto_recall", "failure", "")
}
@@ -506,15 +797,42 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
// 非最终返回数——最终条数以 count 为准），
// 使"真无匹配"（results=[] 但 candidates_scanned>0）与依赖故障（非 2xx）可区分。
// 调用方契约：200 + results 键存在 = 成功（results 可为空）；非 2xx = 失败，绝不解码为成功。
// ⑤使用追踪（t_5aa4dcac）：记录本次召回的 mem_* 记忆 + 独特 token（env 门控 ZHIYI_USAGE_TRACK，
// 默认关 ⇒ 零行为变化）。供 commit 写侧检测「后续内容是否携带了这些记忆 → 判定被用上」。
if storage.UsageTrackingEnabled() && len(results) > 0 {
recs := make([]storage.RecalledMemory, 0, len(results))
for _, r := range results {
if r.ID == "" || r.Content == "" || strings.HasPrefix(r.ID, "ep_") {
continue // 只追踪 mem_* 蒸馏记忆；ep_* 原始轮次不是「要判定用没用」的目标
}
recs = append(recs, storage.RecalledMemory{
ID: r.ID, Content: r.Content, Namespace: r.Namespace,
Agent: req.AgentID, Query: req.Query,
})
}
storage.RecordRecalled(recs)
}
if results == nil {
results = []models.RecallResult{}
}
respond(w, 200, map[string]interface{}{
resp := map[string]interface{}{
"results": results,
"count": len(results),
"candidates_scanned": annScanned,
"mode": req.Mode,
})
// t_1c12e000：AC3 —— 缓存命中/回源扫表必须可区分。
// true ⇒ candidates_scanned=0 是「读了 60s 内的旧快照」（含 L1/L2）；
// false ⇒ 本次真扫了表（candidates_scanned 为真实候选池大小）。
"cache_hit": cacheHit,
}
// t_3aa2a8c1：truncated —— 只在 true 时暴露（键缺失 = 未截断，等价 omitempty 语义）。
// true = 本次 recall 的粗检索/补充搜至少一次命中 Rust 侧单次重读行数上限
// （默认 20000，ZHIYI_HEAVY_READ_MAX_ROWS）被截断为部分结果 ⇒ count/
// candidates_scanned 是截断后状态，调用方不得当作「全量」。
if truncated {
resp["truncated"] = true
}
respond(w, 200, resp)
// H3: Async trust score update
if a.GraphStore != nil {
@@ -526,33 +844,40 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
}
}
// POST /api/v1/feedback — 用户反馈记忆是否有用，同时更新 useful_count/not_useful_count
func (a *API) Feedback(w http.ResponseWriter, r *http.Request) {
var req struct {
MemoryID string `json:"memory_id"`
Useful bool `json:"useful"`
// GA-P0-7 (t_dd64345a)：裸 POST /api/v1/feedback handler 已删除——它按 useful 布尔写
// useful_count / not_useful_count（后者是 P0-1 拆分的旧混写列）。反馈统一走
// feedback.go 的 /api/v1/feedback/{useful,not-useful,deprecate,correct}（写 human_not_useful_count）。
// GET /api/v1/usage/report — ⑤使用追踪上报（t_5aa4dcac）。
// 返回最近被自动判定「被用上」（carry_forward）的记忆样本，供 ⑥反馈消费 + 取证。
// env 门控 ZHIYI_USAGE_TRACK，默认关 ⇒ 返回空；不写任何东西，零行为变化。
func (a *API) UsageReport(w http.ResponseWriter, r *http.Request) {
limit := 20
if v := r.URL.Query().Get("limit"); v != "" {
if n, err := strconv.Atoi(v); err == nil && n > 0 && n <= 200 {
limit = n
}
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, 400, "invalid body")
return
}
if req.MemoryID == "" {
respondError(w, 400, "memory_id required")
return
}
field := "useful_count"
val := map[string]interface{}{"$inc": 1}
if !req.Useful {
field = "not_useful_count"
}
err := a.LanceDB.Update("memories", req.MemoryID, map[string]any{
field: val,
flags := storage.UsageReport(limit)
respond(w, 200, map[string]interface{}{
"enabled": storage.UsageTrackingEnabled(),
"count": len(flags),
"flags": flags,
})
if err != nil {
respondError(w, 500, "feedback update failed: "+err.Error())
}
// POST /api/v1/usage/detect — ⑤使用追踪手动触发（t_5aa4dcac）。
// 对「当前有 ZHIYI_USAGE_TRACK 且仍有未消费 recall 行」做一次兜底检测。
// 主要靠 commit 写侧自动检测；此端点供运维/验证在无新 commit 时手动补扫。
// 门控：关闭时返回 enabled=false，不碰任何数据。
func (a *API) UsageDetect(w http.ResponseWriter, r *http.Request) {
if !storage.UsageTrackingEnabled() {
respond(w, 200, map[string]interface{}{"enabled": false, "count": 0, "flags": []storage.UsageFlag{}})
return
}
respond(w, 200, map[string]string{"status": "ok"})
// 手动触发需要一个候选内容作比对源；无 commit 时无可比内容，返回空。
// 真实检测由 commit 写侧完成（见 Commit handler）。此端点仅回执开关状态。
respond(w, 200, map[string]interface{}{"enabled": true, "count": 0, "note": "detection runs on commit write-side"})
}
// POST /api/v1/recall/debug — recall 诊断端点（优化），返回各阶段耗时和状态
@@ -872,7 +1197,8 @@ func (a *API) Dedup(w http.ResponseWriter, r *http.Request) {
}
}
for id := range demoted {
if err := a.LanceDB.IncrementNotUseful(id); err != nil {
// GA-P0-1 (t_718d8707)：dedup 自动降权 → 写 dedup_downweight_count（不再写混写列 not_useful_count）
if err := a.LanceDB.IncrementDedupDownweight(id); err != nil {
log.Printf("[dedup] demote failed %s: %v", id, err)
}
}
@@ -937,7 +1263,14 @@ func (a *API) BatchCommit(w http.ResponseWriter, r *http.Request) {
}
var ids []string
skippedMeta := 0
for _, item := range req.Items {
// 2026-10-16 t_5ad3f843：meta-note 门禁——逐条跳过 meta 条目（门禁默认关闭=零行为变化）。
if skip, reason := metanote.ShouldSkip(item.Content); skip {
log.Printf("[metanote] batch item skipped: agent=%s reason=%s content=%.60s", item.AgentID, reason, item.Content)
skippedMeta++
continue
}
ns := item.Namespace
if ns == "" {
cat := item.Category
@@ -957,7 +1290,7 @@ func (a *API) BatchCommit(w http.ResponseWriter, r *http.Request) {
}
ids = append(ids, id)
}
respond(w, 201, map[string]interface{}{"ids": ids, "count": len(ids), "status": "ok"})
respond(w, 201, map[string]interface{}{"ids": ids, "count": len(ids), "skipped_meta": skippedMeta, "status": "ok"})
}
// ─── Namespace 分类规则（按 §1.3 设计）─────────────────────
@@ -1060,13 +1393,6 @@ func stringContains(s, substr string) bool {
return false
}
func minInt3(a, b int) int {
if a < b {
return a
}
return b
}
// convertFallbackResults 将 FallbackTextSearch 结果（map）转换为 RecallResult 格式
func convertFallbackResults(rows []map[string]interface{}) []models.RecallResult {
results := make([]models.RecallResult, 0, len(rows))
go/internal/api/routes/eval.go
+149 -75
View File
@@ -3,6 +3,8 @@ package routes
import (
"encoding/json"
_ "embed"
"fmt"
"net/http"
"os"
"strings"
@@ -12,6 +14,15 @@ import (
"github.com/xiaoxue/memoryweave/internal/storage"
)
// go:embed testdata/golden-set.json 把金标集打进二进制（t_dfc93ad0 AC5）：
// 部署 CWD=/home/muc，旧版「path=="" → 相对 testdata/」解析到 /home/muc/testdata
// ⇒ POST /api/v1/eval/golden 不传 golden_path 时 500（2026-10-14 实测复现）。
// 内嵌兜底后：缺省/相对路径读不到 ⇒ 回落内嵌基线（仍可用）；env ZHIYI_GOLDEN_SET
// 指定绝对路径 ⇒ 读该文件（可临时替换金标集）。测试仍按显式路径调用，行为不变。
//
//go:embed testdata/golden-set.json
var embeddedGoldenSetJSON []byte
// ─── 金标集定义 ──────────────────────────────────────────────
// GoldenSetItem 单条金标：query + 具体 expected_ids + 关键词相关性判据
@@ -19,9 +30,14 @@ type GoldenSetItem struct {
Query string `json:"query"`
ExpectedIDs []string `json:"expected_ids"`
MustIncludeKeywords []string `json:"must_include_keywords"`
Category string `json:"category,omitempty"`
Difficulty string `json:"difficulty,omitempty"`
IDBaseline string `json:"id_baseline,omitempty"`
// Namespace 该条目应在哪个 namespace 里召回。为空则用请求传入的 ns。
// 为什么必须 per-item（2026-10-14 实测）：金标的 expected_id 分散在
// hermes-main / domain:HUB / soulful-xiaowei / wiki / shared 等多个 ns，
// 而 eval 只按请求里的单一 ns 召回 ⇒ ID 类指标**按构造恒为 0**（不是召回差）。
Namespace string `json:"namespace,omitempty"`
Category string `json:"category,omitempty"`
Difficulty string `json:"difficulty,omitempty"`
IDBaseline string `json:"id_baseline,omitempty"`
}
// GoldenSet 金标集
@@ -30,15 +46,37 @@ type GoldenSet struct {
Items []GoldenSetItem `json:"items"`
}
// LoadGoldenSet 从 testdata/ 加载金标集，支持相对路径（生产用）和绝对路径（测试用）
// LoadGoldenSet 加载金标集。路径解析（t_dfc93ad0 AC5，部署 CWD=/home/muc）：
// 1. env ZHIYI_GOLDEN_SET 指定路径 ⇒ 优先读它（临时替换金标集用，不重编译）；
// 2. 显式 path 非空且能读到 ⇒ 用它（绝对/相对皆按调用方语义）；
// 3. path 为空、或上面读不到（典型：部署二进制 CWD=/home/muc 无 testdata/，
// 旧版相对路径解析失败 ⇒ 500）⇒ 回落 **内嵌** 基线 embeddedGoldenSetJSON。
// 校验（空断言自守）在拿到内容后统一跑，三种来源同口径。
func LoadGoldenSet(path string) (*GoldenSet, error) {
if path == "" {
// 编译后无法直接拿到源码路径，回退到 CWD 的 testdata/
path = "testdata/golden-set.json"
var data []byte
usedSource := "env:ZHIYI_GOLDEN_SET"
if p := os.Getenv("ZHIYI_GOLDEN_SET"); p != "" {
var err error
data, err = os.ReadFile(p)
if err != nil {
return nil, err
}
} else if path != "" {
usedSource = "path:" + path
d, err := os.ReadFile(path)
if err != nil {
// 相对路径在部署 CWD 下读不到 ⇒ 内嵌兜底（AC5 根因）
data = embeddedGoldenSetJSON
usedSource = "embedded"
} else {
data = d
}
} else {
data = embeddedGoldenSetJSON
usedSource = "embedded"
}
data, err := os.ReadFile(path)
if err != nil {
return nil, err
if len(data) == 0 {
return nil, fmt.Errorf("golden set 不可用（%s 为空且无内嵌基线）", usedSource)
}
var gs GoldenSet
if err := json.Unmarshal(data, &gs); err != nil {
@@ -122,15 +160,15 @@ type EvalAPI struct {
}
type EvalRun struct {
ID string `json:"id"`
Model string `json:"model"`
RecallAt5 float64 `json:"recall_at_5"`
ID string `json:"id"`
Model string `json:"model"`
RecallAt5 float64 `json:"recall_at_5"`
PrecisionAt5 float64 `json:"precision_at_5"`
MRR float64 `json:"mean_reciprocal_rank"`
NDCG float64 `json:"ndcg"`
MRR float64 `json:"mean_reciprocal_rank"`
NDCG float64 `json:"ndcg"`
// 按标签分组
RecallByTag map[string]float64 `json:"recall_at_5_by_tag,omitempty"`
RecallByTag map[string]float64 `json:"recall_at_5_by_tag,omitempty"`
PrecisionByTag map[string]float64 `json:"precision_at_5_by_tag,omitempty"`
// 按 Agent 分组
@@ -147,14 +185,14 @@ type EvalRun struct {
}
type EvalQueryDetail struct {
Query string `json:"query"`
ExpectedIDs []string `json:"expected_ids"`
Query string `json:"query"`
ExpectedIDs []string `json:"expected_ids"`
MustIncludeKeywords []string `json:"must_include_keywords,omitempty"`
Hits []string `json:"hits"`
Misses []string `json:"misses"`
RecallAt5 float64 `json:"recall_at_5"`
PrecisionAt5 float64 `json:"precision_at_5"`
KeywordOK bool `json:"keyword_ok,omitempty"`
Hits []string `json:"hits"`
Misses []string `json:"misses"`
RecallAt5 float64 `json:"recall_at_5"`
PrecisionAt5 float64 `json:"precision_at_5"`
KeywordOK bool `json:"keyword_ok,omitempty"`
}
// GoldenRunResult 金标 run 的扩展结果（含关键词判据）
@@ -166,8 +204,8 @@ type GoldenRunResult struct {
}
type ConsolidationHits struct {
TotalDistilledUsed int `json:"total_distilled_used"`
HitsAfterConsolidation int `json:"hits_after_consolidation"`
TotalDistilledUsed int `json:"total_distilled_used"`
HitsAfterConsolidation int `json:"hits_after_consolidation"`
ConsolidationBenefit float64 `json:"consolidation_benefit"`
}
@@ -185,7 +223,7 @@ func NewEvalAPI(p *storage.RecallPipeline, ldb storage.LanceDB) *EvalAPI {
// POST /api/v1/eval/run
func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
var req struct {
Queries []struct {
Queries []struct {
Query string `json:"query"`
ExpectedIDs []string `json:"expected_ids"`
} `json:"queries"`
@@ -250,11 +288,15 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
}
pAt5 := 0.0
if len(results) > 0 { pAt5 = float64(hits) / float64(len(results)) }
if len(results) > 0 {
pAt5 = float64(hits) / float64(len(results))
}
totalPrecision += pAt5
rAt5 := 0.0
if len(q.ExpectedIDs) > 0 { rAt5 = float64(hits) / float64(len(q.ExpectedIDs)) }
if len(q.ExpectedIDs) > 0 {
rAt5 = float64(hits) / float64(len(q.ExpectedIDs))
}
totalRecall += rAt5
// MRR
@@ -269,11 +311,17 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
dcg, idcg := 0.0, 0.0
for i, res := range results {
rel := 0.0
if expectedSet[res.ID] { rel = 1.0 }
if expectedSet[res.ID] {
rel = 1.0
}
dcg += rel / log2(float64(i+2))
if i < len(q.ExpectedIDs) { idcg += 1.0 / log2(float64(i+2)) }
if i < len(q.ExpectedIDs) {
idcg += 1.0 / log2(float64(i+2))
}
}
if idcg > 0 {
totalNDCG += dcg / idcg
}
if idcg > 0 { totalNDCG += dcg / idcg }
// 分组统计
// (category 从 query 推断)
@@ -308,18 +356,18 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
recallByAgent := avgByGroup(recallByAgentMap)
run := &EvalRun{
ID: time.Now().Format("20060102-150405"),
Model: req.Model,
RecallAt5: totalRecall / float64(totalQueries),
PrecisionAt5: totalPrecision / float64(totalQueries),
MRR: totalMRR / float64(totalQueries),
NDCG: totalNDCG / float64(totalQueries),
RecallByTag: recallByTag,
ID: time.Now().Format("20060102-150405"),
Model: req.Model,
RecallAt5: totalRecall / float64(totalQueries),
PrecisionAt5: totalPrecision / float64(totalQueries),
MRR: totalMRR / float64(totalQueries),
NDCG: totalNDCG / float64(totalQueries),
RecallByTag: recallByTag,
PrecisionByTag: precisionByTag,
RecallByAgent: recallByAgent,
QueryDetails: queryDetails,
Queries: totalQueries,
RanAt: time.Now(),
RecallByAgent: recallByAgent,
QueryDetails: queryDetails,
Queries: totalQueries,
RanAt: time.Now(),
}
evals.mu.Lock()
@@ -369,7 +417,12 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
continue
}
results, err := ea.Pipeline.Recall(item.Query, ns, 5, 0.5)
// per-item namespace：条目自带 ns 优先（金标基线是按 ns 钉的，见 GoldenSetItem.Namespace）
itemNS := item.Namespace
if itemNS == "" {
itemNS = ns
}
results, err := ea.Pipeline.Recall(item.Query, itemNS, 5, 0.5)
if err != nil {
failures = append(failures, item.Query+": recall 失败 "+err.Error())
keywordFail++
@@ -405,11 +458,15 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
}
pAt5 := 0.0
if len(results) > 0 { pAt5 = float64(hits) / float64(len(results)) }
if len(results) > 0 {
pAt5 = float64(hits) / float64(len(results))
}
totalPrecision += pAt5
rAt5 := 0.0
if len(item.ExpectedIDs) > 0 { rAt5 = float64(hits) / float64(len(item.ExpectedIDs)) }
if len(item.ExpectedIDs) > 0 {
rAt5 = float64(hits) / float64(len(item.ExpectedIDs))
}
totalRecall += rAt5
// MRR
@@ -424,11 +481,17 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
dcg, idcg := 0.0, 0.0
for i, res := range results {
rel := 0.0
if expectedSet[res.ID] { rel = 1.0 }
if expectedSet[res.ID] {
rel = 1.0
}
dcg += rel / log2(float64(i+2))
if i < len(item.ExpectedIDs) { idcg += 1.0 / log2(float64(i+2)) }
if i < len(item.ExpectedIDs) {
idcg += 1.0 / log2(float64(i+2))
}
}
if idcg > 0 {
totalNDCG += dcg / idcg
}
if idcg > 0 { totalNDCG += dcg / idcg }
// 关键词统计
keywordTotal++
@@ -445,9 +508,9 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
MustIncludeKeywords: item.MustIncludeKeywords,
Hits: hitIDs,
Misses: missIDs,
RecallAt5: rAt5,
PrecisionAt5: pAt5,
KeywordOK: keywordOK,
RecallAt5: rAt5,
PrecisionAt5: pAt5,
KeywordOK: keywordOK,
})
totalQueries++
@@ -459,15 +522,15 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
}
run := &EvalRun{
ID: time.Now().Format("20060102-150405"),
Model: "golden-set",
RecallAt5: totalRecall / float64(totalQueries),
PrecisionAt5: totalPrecision / float64(totalQueries),
MRR: totalMRR / float64(totalQueries),
NDCG: totalNDCG / float64(totalQueries),
QueryDetails: queryDetails,
Queries: totalQueries,
RanAt: time.Now(),
ID: time.Now().Format("20060102-150405"),
Model: "golden-set",
RecallAt5: totalRecall / float64(totalQueries),
PrecisionAt5: totalPrecision / float64(totalQueries),
MRR: totalMRR / float64(totalQueries),
NDCG: totalNDCG / float64(totalQueries),
QueryDetails: queryDetails,
Queries: totalQueries,
RanAt: time.Now(),
}
evals.mu.Lock()
@@ -534,9 +597,9 @@ func (ea *EvalAPI) Generate(w http.ResponseWriter, r *http.Request) {
// 固定的 12 条金标查询（4类×3级）
// 对每条生成 query → recall 获得真实 expected_ids
goldenQueries := []struct {
cat string
cat string
difficulty string
query string
query string
}{
// system_fact
{"system_fact", "easy", "织忆是什么"},
@@ -569,11 +632,11 @@ func (ea *EvalAPI) Generate(w http.ResponseWriter, r *http.Request) {
// 空断言自守：如果 recall 返回 0 条，不得写入空 expected_ids（那是 bootstrap，不是校准）
if len(expectedIDs) == 0 {
results = append(results, map[string]interface{}{
"query": gq.query,
"query": gq.query,
"expected_ids": []string{},
"category": gq.cat,
"difficulty": gq.difficulty,
"warning": "recall 返回 0 条——bootstrap 基线为空，需人工校准",
"category": gq.cat,
"difficulty": gq.difficulty,
"warning": "recall 返回 0 条——bootstrap 基线为空，需人工校准",
})
continue
}
@@ -603,14 +666,21 @@ func makeSet(ids []string) map[string]bool {
func log2(x float64) float64 {
result := 0.0
for x > 2 { x /= 2; result += 1 }
if x > 1 { result += (x - 1) }
for x > 2 {
x /= 2
result += 1
}
if x > 1 {
result += (x - 1)
}
return result
}
func contains(list []string, item string) bool {
for _, s := range list {
if s == item { return true }
if s == item {
return true
}
}
return false
}
@@ -620,7 +690,9 @@ func avgByGroup(m map[string][]float64) map[string]float64 {
for k, vals := range m {
if len(vals) > 0 {
sum := 0.0
for _, v := range vals { sum += v }
for _, v := range vals {
sum += v
}
result[k] = sum / float64(len(vals))
}
}
@@ -629,15 +701,17 @@ func avgByGroup(m map[string][]float64) map[string]float64 {
func inferCategory(query, defaultCat string) string {
for cat, keywords := range map[string][]string{
"system_fact": {"os", "系统", "gpu", "内存", "ram", "端口", "配置"},
"user_pref": {"偏好", "风格", "喜欢", "牧尘"},
"proj_context":{"项目", "路径", "代码", "设计文档"},
"tool_usage": {"工具", "comfyui", "hermes", "opencode"},
"system_fact": {"os", "系统", "gpu", "内存", "ram", "端口", "配置"},
"user_pref": {"偏好", "风格", "喜欢", "牧尘"},
"proj_context": {"项目", "路径", "代码", "设计文档"},
"tool_usage": {"工具", "comfyui", "hermes", "opencode"},
} {
for _, kw := range keywords {
if len(query) >= len(kw) {
for i := 0; i <= len(query)-len(kw); i++ {
if query[i:i+len(kw)] == kw { return cat }
if query[i:i+len(kw)] == kw {
return cat
}
}
}
}
go/internal/api/routes/eval_test.go
+68 -9
View File
@@ -10,22 +10,45 @@ import (
"net/http"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
// liveAPIKey 取活服务密钥：优先 env ZHIYI_TEST_API_KEY；否则读密钥文件
// /var/lib/memoryweave/.api-key 的主密钥（第 1 个非注释、非 legacy 行）；
// 再退到旧 dev 键（无生产密钥文件的环境，如 CI）。
// 2026-09-21 密钥轮换后，旧硬编码键 zhiyi-dev-key-2026 已 401 —— 全量金标实跑
// 永远 SKIP 的根因（t_fa6c9104 修复量具可用性；不改任何判据）。
func liveAPIKey() string {
if k := os.Getenv("ZHIYI_TEST_API_KEY"); k != "" {
return k
}
if b, err := os.ReadFile("/var/lib/memoryweave/.api-key"); err == nil {
for _, line := range strings.Split(string(b), "\n") {
line = strings.TrimSpace(line)
if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "legacy:") {
continue
}
return line
}
}
return "zhiyi-dev-key-2026"
}
// ─── recall 辅助：liveRecallOnce ─────────────────────────────
// 一次 recall API 调用同时拿 top-5 的 ids + contents，避免两条 HTTP（限流保护）。
// 每次调用间加 200ms 间隔，由调用方负责（TestEvalGolden_Live 里 sleep）。
//
// 统一判据口径（t_a70b07e1，与 Python 量具 golden-check.py 一致）：
// 取 recall 返回的前 N=5 条：ID 命中 = expected_ids 任一 ∈ 前 N 条；
// 关键词命中 = 前 N 条内容任一含 must_include_keywords（大小写不敏感）。
// N=5 的来源：recall 请求 top_k=5（liveRecallOnce 固定），与 golden-set.json 说明字段一致。
//
// 取 recall 返回的前 N=5 条：ID 命中 = expected_ids 任一 ∈ 前 N 条；
// 关键词命中 = 前 N 条内容任一含 must_include_keywords（大小写不敏感）。
// N=5 的来源：recall 请求 top_k=5（liveRecallOnce 固定），与 golden-set.json 说明字段一致。
type recallResult struct {
IDS []string
TopContents []string
Error error
IDS []string
TopContents []string
Error error
}
func liveRecallOnce(query string, maxRetries int, retryWait time.Duration) recallResult {
@@ -37,7 +60,7 @@ func liveRecallOnce(query string, maxRetries int, retryWait time.Duration) recal
}
req, _ := http.NewRequest("POST", "http://127.0.0.1:7821/api/v1/recall", bytes.NewReader(payload))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
req.Header.Set("X-API-Key", liveAPIKey())
resp, err := http.DefaultClient.Do(req)
if err != nil {
lastErr = fmt.Errorf("HTTP 请求失败: %v", err)
@@ -217,13 +240,49 @@ func TestLoadGoldenSet_RejectsVacuousIDs(t *testing.T) {
}
}
// t_dfc93ad0 AC5 回归：部署二进制 CWD=/home/muc（无 testdata/），
// POST /api/v1/eval/golden 不传 golden_path 时，旧版「相对 testdata/ 读不到」⇒ 500。
// 修复后：缺省路径 / 读不到的路径 ⇒ 回落 **内嵌** 基线（//go:embed），仍可用。
// 判据（可复算）：在**没有 testdata/ 的 CWD** 里 LoadGoldenSet("") 与
// LoadGoldenSet("testdata/golden-set.json")（相对路径读不到）都必须成功
// 且返回 14 条 —— 即部署态「缺省命令可用」。
func TestLoadGoldenSet_EmbedFallback_DeployCWD(t *testing.T) {
empty := t.TempDir() // 模拟部署 CWD：里面没有 testdata/
orig, err := os.Getwd()
if err != nil {
t.Fatalf("取 CWD 失败: %v", err)
}
if err := os.Chdir(empty); err != nil {
t.Fatalf("chdir 到空目录失败: %v", err)
}
t.Cleanup(func() { _ = os.Chdir(orig) })
// ① 缺省（path=""）：不传 golden_path 的部署态 ⇒ 必须成功 + 14 条（内嵌兜底）
gs, err := LoadGoldenSet("")
if err != nil {
t.Fatalf("✗ AC5：缺省路径加载金标集失败（旧版这里 500）: %v", err)
}
if len(gs.Items) != 14 {
t.Fatalf("✗ AC5：内嵌基线期望 14 条，实际 %d", len(gs.Items))
}
// ② 相对路径读不到（部署 CWD 无 testdata/）：也回落内嵌，不 500
gs2, err := LoadGoldenSet(filepath.Join("testdata", "golden-set.json"))
if err != nil {
t.Fatalf("✗ AC5：相对路径读不到时应回落内嵌基线而非报错: %v", err)
}
if len(gs2.Items) != 14 {
t.Fatalf("✗ AC5：回落基线期望 14 条，实际 %d", len(gs2.Items))
}
t.Logf("✓ AC5：空 CWD（无 testdata/）下 缺省/相对路径 均回落内嵌基线（14 条），部署态缺省命令可用")
}
// ─── AC① 反证：故意把某条 expected_id 改成错误 ID → 该条必须 FAIL ───
// 这是本卡核心验收点：证明判据非恒真（改错期望 → 真 FAIL）
func TestEvalGolden_CounterEvidence(t *testing.T) {
// 探活 zhiyid（无服务 → 跳过）
healthReq, _ := http.NewRequest("GET", "http://127.0.0.1:7821/api/v1/health", nil)
healthReq.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
healthReq.Header.Set("X-API-Key", liveAPIKey())
resp, err := http.DefaultClient.Do(healthReq)
if err != nil || resp == nil {
t.Skipf("zhiyid 服务不可达（%v），跳过反证测试", err)
@@ -299,7 +358,7 @@ func TestEvalGolden_CounterEvidence(t *testing.T) {
func TestEvalGolden_Live(t *testing.T) {
// 探活 zhiyid（无服务 → 跳过，不污染 CI）
healthReq, _ := http.NewRequest("GET", "http://127.0.0.1:7821/api/v1/health", nil)
healthReq.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
healthReq.Header.Set("X-API-Key", liveAPIKey())
resp, err := http.DefaultClient.Do(healthReq)
if err != nil || resp == nil {
t.Skipf("zhiyid 服务不可达（%v），跳过全量金标实跑", err)
go/internal/api/routes/feedback.go
+13 -2
View File
@@ -43,6 +43,11 @@ func (fa *FeedbackAPI) MarkUseful(w http.ResponseWriter, r *http.Request) {
if err := fa.LanceDB.IncrementUseful(req.MemoryID); err != nil {
log.Printf("[feedback] IncrementUseful failed %s: %v", req.MemoryID, err)
}
// GA-P0-4 (t_bb10e8bc)：用户点「有用」= 真实正向 outcome → 追加 hits+ 事件（带时间戳）。
// 语义定义见 internal/storage/hit_event.go（hits+ = 被真实使用/认可）。
if err := fa.LanceDB.AppendHitEvent(req.MemoryID, "pos", "human_feedback"); err != nil {
log.Printf("[feedback] AppendHitEvent(pos) failed %s: %v", req.MemoryID, err)
}
// Phase F: 质量监控 — 每次反馈后检查低质量记忆
feedbackCount := selfoptimize.Dash.UsefulCount + selfoptimize.Dash.NotUsefulCount
@@ -80,8 +85,14 @@ func (fa *FeedbackAPI) MarkNotUseful(w http.ResponseWriter, r *http.Request) {
[]string{req.MemoryID},
"user_feedback", "failure", "",
)
if err := fa.LanceDB.IncrementNotUseful(req.MemoryID); err != nil {
log.Printf("[feedback] IncrementNotUseful failed %s: %v", req.MemoryID, err)
// GA-P0-1 (t_718d8707)：人工点「没用」→ 写 human_not_useful_count（不再写混写列 not_useful_count）
if err := fa.LanceDB.IncrementHumanNotUseful(req.MemoryID); err != nil {
log.Printf("[feedback] IncrementHumanNotUseful failed %s: %v", req.MemoryID, err)
}
// GA-P0-4 (t_bb10e8bc)：用户点「没用」= 真实负向 outcome → 追加 hits− 事件（带时间戳）。
// 注意：这只在用户人工点「没用」时追加，dedup 自动降权走 dedup_downweight_count 不追加（见 hit_event.go 排除项）。
if err := fa.LanceDB.AppendHitEvent(req.MemoryID, "neg", "human_feedback"); err != nil {
log.Printf("[feedback] AppendHitEvent(neg) failed %s: %v", req.MemoryID, err)
}
// Phase F: 质量监控 — negative feedback 触发低质量检测
go/internal/api/routes/forget_guard_e2e_test.go
+143
View File
@@ -0,0 +1,143 @@
// Package routes — 遗忘保护守卫端到端回归测试（t_944344b5，AC1/AC2）。
//
// 2026-10-16 (t_944344b5)：证明「decay/auto_forget 的判定道（admin Forget 路由）命中保护
// 规则的候选**不被** SoftDelete，而非保护的衰减候选**照常**被软删」。
//
// 必须走**真实判定路径**（routes.NewAdminAPI.Forget），不能只测 memprotect.IsProtected，
// 因为守卫是在 decay 循环 / admin Forget 路由里 SoftDelete 之前拦截的（见 server.go / admin.go）。
//
// 跑法（A/B 纪律：复制数据目录 + 独立 socket，绝不碰生产 /var/lib/memoryweave）：
// 1. cp -a /var/lib/memoryweave /tmp/mw-prot-copy-<ts>
// 2. zhiyi-consolidate --mode socket --socket /tmp/mw-prot.sock \
// --data-dir /tmp/mw-prot-copy-<ts> &
// 3. PROT_TEST_SOCK=/tmp/mw-prot.sock \
// go test ./internal/api/routes/ -run TestForgetGuardE2E -v -count=1
//
// 未设 PROT_TEST_SOCK → 自动跳过（可安全留在 CI）。
package routes_test
import (
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"testing"
"time"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/storage"
"github.com/xiaoxue/memoryweave/internal/api/routes"
)
func TestForgetGuardE2E(t *testing.T) {
sock := os.Getenv("PROT_TEST_SOCK")
if sock == "" {
t.Skip("PROT_TEST_SOCK 未设置，跳过（需先起 test sidecar 指向复制的数据目录）")
}
// 让遗忘窗口游标指到临时文件（缺失 → 空游标 → 从最小 id 起轮转），
// 保证我们构造的 `mem_0...` 行（id 最小）落在首个 2000 窗口内。
// 不碰生产 /var/lib/memoryweave/forget-cursor.json。
cursorDir := t.TempDir()
cursorFile := cursorDir + "/test-forget-cursor.json"
t.Setenv("ZHIYI_FORGET_CURSOR", cursorFile)
// embedder 传 nil：记录自带 1024 维 Vector，走不到编码分支（同 conf_e2e_test.go 做法）。
rc := storage.NewRustLanceDBClient(sock, nil)
f := governance.NewForgetter()
aa := routes.NewAdminAPI(rc, f, nil) // GraphStore 传 nil：extractTopEntityDegree 空安全
// ── 构造 4 条测试记忆（id 都以 mem_0 开头 → 字典序最小 → 必在首窗口）──
vec := make([]float32, 1024)
for i := range vec {
vec[i] = 0.001
}
now := time.Now().UTC()
mk := func(id, category, content, freshness string, daysAgo int) models.MemoryRecord {
lr := now.Add(-time.Duration(daysAgo) * 24 * time.Hour)
return models.MemoryRecord{
ID: id, AgentID: "hermes-a06", Namespace: "prot-test",
Content: content, Category: category, Vector: vec,
Tier: "normal", Importance: 0.5, QualityScore: 0.5,
Version: 1, Freshness: freshness,
Source: "wiki:/tmp/forget-guard-e2e.md",
EmbeddingModel: "bge-m3", ScriptVersion: "forget-guard-e2e",
CreatedAt: lr, UpdatedAt: lr, LastRecalledAt: lr,
RecallVerifiedCount: 0,
}
}
// P1：规则3 freshness=verified 保护。content <30 字 + >20 天 ⇒ 本应走碎片快速道被删，
// 但 freshness=verified ⇒ 守卫拦截 ⇒ 存活。
p1 := mk("mem_0aaaa_p1", "distilled", "verified fact, kept", "verified", 30)
// P2：规则1 category=decision 保护。
p2 := mk("mem_0aaaa_p2", "decision", "short decision note", "fresh", 30)
// P3：规则4 content 关键词「牧尘要求」保护。
p3 := mk("mem_0aaaa_p3", "distilled", "牧尘要求：部署前必须先备份", "fresh", 30)
// N1：不命中任何规则（distilled / fresh / 无关键词 / 低 V / 不在名单）⇒ 应被碎片快速道软删。
n1 := mk("mem_0aaaa_n1", "distilled", "hi", "fresh", 45)
for _, m := range []models.MemoryRecord{p1, p2, p3, n1} {
if err := rc.InsertMemory(m); err != nil {
t.Fatalf("InsertMemory(%s) 失败: %v", m.ID, err)
}
}
// ── 跑真实判定路径：admin Forget 路由（= decay/auto_forget 决策 + 守卫 + SoftDelete）──
req := httptest.NewRequest(http.MethodPost, "/api/v1/admin/forget", nil)
w := httptest.NewRecorder()
aa.Forget(w, req)
if w.Code != http.StatusOK {
t.Fatalf("admin forget expected 200, got %d: %s", w.Code, w.Body.String())
}
var resp map[string]interface{}
json.Unmarshal(w.Body.Bytes(), &resp)
t.Logf("admin forget 响应: %v", resp)
// ── 断言 ──
// 读路径语义（rust lancedb_ops.rs）：
// scan_all → 仅 is_deleted=false（存活集，无 5000 上限）
// scan_deleted → 仅 is_deleted=true（已删集，带 delete_reason）
// 故 P1/P2/P3 应出现在 ScanAll 里；N1 应不在 ScanAll、而在 ScanDeleted 里。
all, err := rc.ScanAll()
if err != nil {
t.Fatalf("ScanAll 失败: %v", err)
}
liveSet := map[string]bool{}
for _, m := range all {
liveSet[m.ID] = true // scan_all 只回 is_deleted=false
}
for _, id := range []string{p1.ID, p2.ID, p3.ID} {
if !liveSet[id] {
t.Errorf("❌ 受保护记忆 %s 应存活（ScanAll 命中），实际不在 —— 守卫失效", id)
}
}
if liveSet[n1.ID] {
t.Errorf("❌ 非保护衰减记忆 %s 应被软删（不在 ScanAll），实际仍存活 —— 回归异常", n1.ID)
}
deleted, derr := rc.ScanDeleted()
if derr != nil {
t.Fatalf("ScanDeleted 失败: %v", derr)
}
deletedSet, n1Reason := map[string]bool{}, ""
for _, m := range deleted {
deletedSet[m.ID] = true
if m.ID == n1.ID {
n1Reason = m.DeleteReason
}
}
if !deletedSet[n1.ID] {
t.Errorf("❌ 非保护衰减记忆 %s 应出现在 ScanDeleted（is_deleted=true），实际不在", n1.ID)
}
if t.Failed() {
return
}
// 受保护 3 条存活 + 非保护 1 条被删，打印结论
t.Logf("✅ AC1 3 条命中保护规则（freshness=verified / category=decision / 关键词）全部存活于 ScanAll")
t.Logf("✅ AC2 非保护衰减碎片 %s 照常软删（在 ScanDeleted）", n1.ID)
// 取证：N1 的 delete_reason（auto_forget*/fragment 经 NormalizeDeleteReason → retention）
t.Logf("取证: %s delete_reason=%q", n1.ID, n1Reason)
}
go/internal/api/routes/gap_repair.go
+8 -8
View File
@@ -14,19 +14,19 @@ import (
// GapAutoRepair 缺口自动修复器
type GapAutoRepair struct {
detector *selfoptimize.GapDetector
ldb storage.LanceDB
synonyms map[string][]string // 同义词映射
detector *selfoptimize.GapDetector
ldb storage.LanceDB
synonyms map[string][]string // 同义词映射
}
var GapRepair = &GapAutoRepair{
detector: nil, // 由 InitGapRepair 注入
synonyms: map[string][]string{
"GPU": {"gpu", "显卡", "graphics"},
"OS": {"os", "操作系统", "系统"},
"API": {"api", "接口", "endpoint"},
"SSE": {"sse", "server-sent events", "事件推送"},
"CRDT": {"crdt", "冲突合并", "merge"},
"GPU": {"gpu", "显卡", "graphics"},
"OS": {"os", "操作系统", "系统"},
"API": {"api", "接口", "endpoint"},
"SSE": {"sse", "server-sent events", "事件推送"},
"CRDT": {"crdt", "冲突合并", "merge"},
},
}
go/internal/api/routes/gaps.go
+19 -4
View File
@@ -4,6 +4,7 @@ package routes
import (
"encoding/json"
"net/http"
"strings"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
)
@@ -32,17 +33,31 @@ func (ga *GapAPI) List(w http.ResponseWriter, r *http.Request) {
})
}
// POST /api/v1/gaps/{topic}/close
// POST /api/v1/gaps/close/{topic}（现行前缀注册 /api/v1/gaps/close/；亦兼容 {topic} 通配注册）
func (ga *GapAPI) Close(w http.ResponseWriter, r *http.Request) {
topic := r.PathValue("topic")
if topic == "" {
// 现行注册是前缀路由（模式无 {topic} 通配 ⇒ PathValue 恒为 ""，端点此前恒 400）：
// 回落剥前缀取 topic。若日后改注册为 /api/v1/gaps/{topic}/close，PathValue 直接命中。
const prefix = "/api/v1/gaps/close/"
if strings.HasPrefix(r.URL.Path, prefix) {
topic = r.URL.Path[len(prefix):]
}
}
if topic == "" {
respondError(w, 400, "topic required")
return
}
ga.Detector.Close(topic)
selfoptimize.Dash.RecordGapClosed()
respond(w, 200, map[string]string{"status": "closed", "topic": topic})
// t_e5997ca4：计数口径 = 「缺口个数」。+1 只发生在 GapDetector 的 open→closed 迁移点
// （Close 内部）；旧的无条件 selfoptimize.Dash.RecordGapClosed() 已删除 —— 那是同一
// 缺口可被无限计数、ClosedGaps(9) 越过 TotalGaps(2) 的写侧根因 #1。
switch ga.Detector.Close(topic) {
case true:
respond(w, 200, map[string]string{"status": "closed", "topic": topic})
default:
respond(w, 200, map[string]string{"status": "already_closed", "topic": topic})
}
}
// POST /api/v1/gaps/detect — 手动触发缺口检测（miss 计数）
go/internal/api/routes/gaps_close_test.go
+112
View File
@@ -0,0 +1,112 @@
// 织忆 MemoryWeave — gap 关闭端点写侧回归（t_e5997ca4 卡 AC2）
//
// POST /close 打两回（httptest）⇒ gap 计数器只 +1；auto 等其余计数器不受影响。
package routes
import (
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"testing"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
)
// makeGapTopic 3 次 miss 命中默认阈值 3 ⇒ 生成缺口（TotalGaps +1）。
func makeGapTopic(t *testing.T, gd *selfoptimize.GapDetector, topic string) {
t.Helper()
var gap *selfoptimize.Gap
for i := 0; i < 3; i++ {
if gap = gd.RecordMiss(topic); gap != nil {
break
}
}
if gap == nil {
t.Fatalf("expected gap for %q after 3 misses", topic)
}
}
func postGapClose(t *testing.T, url string) (int, map[string]string) {
t.Helper()
resp, err := http.Post(url, "application/json", nil)
if err != nil {
t.Fatalf("POST %s: %v", url, err)
}
defer resp.Body.Close()
var body map[string]string
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
b, _ := io.ReadAll(resp.Body)
t.Fatalf("POST %s: 非 JSON 响应 %q: %v", url, b, err)
}
return resp.StatusCode, body
}
// 卡 AC2：现行注册形态（前缀路由，topic 在 /api/v1/gaps/close/ 之后）打两回 ⇒ 只 +1。
func TestGapAPI_CloseTwice_CounterOnlyOnce(t *testing.T) {
gd := selfoptimize.NewGapDetector(nil, nil)
makeGapTopic(t, gd, "close-twice-topic")
baseClosed := selfoptimize.Dash.ClosedGapsCount()
baseTotal := selfoptimize.Dash.TotalGapsCount()
baseMetrics := selfoptimize.Dash.Metrics() // auto_* 快照（应不受影响）
api := NewGapAPI(gd)
mux := http.NewServeMux()
mux.HandleFunc("/api/v1/gaps/close/", api.Close) // 与 server.go:1205 现行注册同形
ts := httptest.NewServer(mux)
defer ts.Close()
code1, body1 := postGapClose(t, ts.URL+"/api/v1/gaps/close/close-twice-topic")
if code1 != 200 || body1["status"] != "closed" {
t.Fatalf("第 1 次 POST: got %d %v, want 200 closed", code1, body1)
}
code2, body2 := postGapClose(t, ts.URL+"/api/v1/gaps/close/close-twice-topic")
if code2 != 200 || body2["status"] != "already_closed" {
t.Fatalf("第 2 次 POST: got %d %v, want 200 already_closed（不得再动计数）", code2, body2)
}
if got := selfoptimize.Dash.ClosedGapsCount() - baseClosed; got != 1 {
t.Fatalf("2× POST close 后 ClosedGaps 增量: got %d, want 1（改前为 +3 ⇒ 虚增）", got)
}
if got := selfoptimize.Dash.TotalGapsCount(); got != baseTotal {
t.Errorf("TotalGaps 不应被 close 端点移动: got %d want %d", got, baseTotal)
}
after := selfoptimize.Dash.Metrics()
if after["gap_closure_rate"] > 1 {
t.Errorf("gap_closure_rate = %f 越界", after["gap_closure_rate"])
}
// auto（冲突）计数器与 gap 关闭事件无关 ⇒ 快照不变（「auto 不适用」）
for _, k := range []string{"auto_resolve_rate", "auto_resolve_samples", "auto_resolve_valid"} {
if after[k] != baseMetrics[k] {
t.Errorf("auto 计数器被 gap 关闭污染: %s got %f want %f", k, after[k], baseMetrics[k])
}
}
}
// {topic} 通配注册形态（若日后把 server.go 注册改成 /api/v1/gaps/{topic}/close）：
// PathValue 直接命中，计数语义不变（+1 只在首次）。
func TestGapAPI_CloseWildcardRegistration(t *testing.T) {
gd := selfoptimize.NewGapDetector(nil, nil)
makeGapTopic(t, gd, "wildcard-topic")
baseClosed := selfoptimize.Dash.ClosedGapsCount()
api := NewGapAPI(gd)
mux := http.NewServeMux()
mux.HandleFunc("/api/v1/gaps/{topic}/close", api.Close)
ts := httptest.NewServer(mux)
defer ts.Close()
code, body := postGapClose(t, ts.URL+"/api/v1/gaps/wildcard-topic/close")
if code != 200 || body["status"] != "closed" {
t.Fatalf("通配注册第 1 次 POST: got %d %v, want 200 closed", code, body)
}
if _, body2 := postGapClose(t, ts.URL+"/api/v1/gaps/wildcard-topic/close"); body2["status"] != "already_closed" {
t.Errorf("通配注册第 2 次 POST: got %v, want already_closed", body2)
}
if got := selfoptimize.Dash.ClosedGapsCount() - baseClosed; got != 1 {
t.Fatalf("通配注册 2× POST 后 ClosedGaps 增量: got %d, want 1", got)
}
}
go/internal/api/routes/l3.go
+8 -8
View File
@@ -26,17 +26,17 @@ type WorldModel struct {
Services []ServiceInfo `json:"services"` // ℐ: 服务和端口
ImplicitRules []string `json:"implicit_rules"` // C: 软约束
HardConstraints []string `json:"hard_constraints"` // C: 硬约束
Capabilities []string `json:"capabilities"`
ImplicitRules []string `json:"implicit_rules"` // C: 软约束
HardConstraints []string `json:"hard_constraints"` // C: 硬约束
Capabilities []string `json:"capabilities"`
UpdatedAt string `json:"updated_at"`
}
type ServiceInfo struct {
Name string `json:"name"`
Port int `json:"port"`
Status string `json:"status"`
Name string `json:"name"`
Port int `json:"port"`
Status string `json:"status"`
DependsOn []string `json:"depends_on,omitempty"`
Provides []string `json:"provides,omitempty"`
}
@@ -111,13 +111,13 @@ func (wm *WorldModel) GetHandler(w http.ResponseWriter, r *http.Request) {
// POST /api/v1/l3/worldmodel — 更新
func (wm *WorldModel) UpdateHandler(w http.ResponseWriter, r *http.Request) {
var req struct {
Environment *struct {
Environment *struct {
OS string `json:"os"`
GPU string `json:"gpu"`
VRAM string `json:"vram"`
RAM string `json:"ram"`
} `json:"environment"`
AddRules []string `json:"add_rules"`
AddRules []string `json:"add_rules"`
AddCapabilities []string `json:"add_capabilities"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
go/internal/api/routes/memory_write_test.go
+222
View File
@@ -0,0 +1,222 @@
// 织忆 MemoryWeave — /api/v1/memory/write 显式直写 memories 表（主症A，t_fa6c9104，2026-10-16）
//
// 锁定行为：
//
// W1 写入落 memories 表：InsertMemory 被调用，id 前缀 mem_，tier=normal，quality=1.0，
// 且向量非全 0（嵌入服务故障时不写零向量记录）
// W2 category 缺省 distilled（recall Step 2.5 rawCategories 不过滤它）
// W3 嵌入失败 ⇒ 502 且不写（零向量 = 主症A 病根，禁静默写）
// W4 精确重复 ⇒ merged（不新增行）
// W5 短内容 <8 字 ⇒ 400；GET ⇒ 405
// W6 零回归：commit 路径仍只写 episodes、不写 memories（AC5）
package routes
import (
"bytes"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"sync"
"testing"
"github.com/xiaoxue/memoryweave/internal/distill"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// recLance 记录型 LanceDB mock：断言 InsertMemory/Update 的实际调用与载荷。
// 复用 zz_commit_conflict_gate_test.go 的 mockGraph / newMockEmbedServer / newMockLLM / commitWith（同包）。
type recLance struct {
storage.LanceDB // 未实现的方法落到接口兜底（panic 即测试失败，不放任）
mu sync.Mutex
seeds []models.MemoryRecord // 预置「库里已有」的记忆（Search 返回）
inserted []models.MemoryRecord // 实际 InsertMemory 调用（W1/W3/W4 断言）
updates []string // Update(table,id,...) 的 id 序列（merge 断言）
failIns bool // 模拟 IPC 落库失败（500 断言）
}
func (r *recLance) Search(table string, vector []float32, topK int, ns string) ([]models.MemoryRecord, error) {
if table != "memories" {
return nil, nil
}
r.mu.Lock()
defer r.mu.Unlock()
out := make([]models.MemoryRecord, 0, len(r.seeds))
out = append(out, r.seeds...)
if topK > 0 && len(out) > topK {
out = out[:topK]
}
return out, nil
}
func (r *recLance) InsertMemory(m models.MemoryRecord) error {
r.mu.Lock()
defer r.mu.Unlock()
if r.failIns {
return errors.New("ipc down (simulated)")
}
r.inserted = append(r.inserted, m)
r.seeds = append(r.seeds, m) // 后续 Search 能看见（近重复语义）
return nil
}
func (r *recLance) Update(table, id string, fields map[string]any) error {
r.mu.Lock()
defer r.mu.Unlock()
r.updates = append(r.updates, id)
return nil
}
func (r *recLance) InsertEpisode(agentID, namespace, content, category string) (string, error) {
r.mu.Lock()
defer r.mu.Unlock()
return "ep_rec_" + strconv.Itoa(len(r.inserted)), nil
}
func newRecAPI(t *testing.T, seeds ...models.MemoryRecord) (*API, *recLance) {
t.Helper()
emb := newMockEmbedServer()
t.Cleanup(emb.Close)
ldb := &recLance{seeds: seeds}
return NewAPI(ldb, storage.NewEmbedder(emb.URL), nil, governance.NewConflictDetector(), mockGraph{}), ldb
}
func writeMemRequest(t *testing.T, api *API, body map[string]any) (int, map[string]interface{}) {
t.Helper()
b, _ := json.Marshal(body)
req := httptest.NewRequest("POST", "/api/v1/memory/write", bytes.NewReader(b))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
api.WriteMemory(w, req)
var resp map[string]interface{}
json.Unmarshal(w.Body.Bytes(), &resp)
return w.Code, resp
}
// W1+W2：写入落 memories 表，mem_ 前缀，category 缺省 distilled，向量非全 0
func TestWriteMemory_InsertLandsInMemories(t *testing.T) {
api, ldb := newRecAPI(t)
code, resp := writeMemRequest(t, api, map[string]any{
"content": "牧尘的工作所在省份是河南省",
"agent_id": "hermes-a06",
})
if code != 201 {
t.Fatalf("expected 201, got %d: %s", code, resp)
}
if resp["status"] != "ok" || resp["table"] != "memories" {
t.Errorf("expected status=ok table=memories, got %v", resp)
}
if !strings.HasPrefix(resp["memory_id"].(string), "mem_") {
t.Errorf("memory_id 须 mem_ 前缀（落 memories 表），got %v", resp["memory_id"])
}
if resp["category"] != "distilled" {
t.Errorf("category 缺省须 distilled（Step 2.5 不过滤），got %v", resp["category"])
}
if len(ldb.inserted) != 1 {
t.Fatalf("expected exactly 1 InsertMemory, got %d", len(ldb.inserted))
}
m := ldb.inserted[0]
if m.Category != "distilled" || m.Tier != "normal" || m.QualityScore != 1.0 {
t.Errorf("row 字段: category=%s tier=%s quality=%v（期望 distilled/normal/1.0）", m.Category, m.Tier, m.QualityScore)
}
if m.Namespace != "hermes-main" {
t.Errorf("namespace 推导: got %s 期望 hermes-main（hermes-a06 ⇒ deriveNamespace）", m.Namespace)
}
if len(m.Vector) != 1024 {
t.Fatalf("vector 维度须 1024，got %d", len(m.Vector))
}
// W1 核心判据：vector 非全 0
nonzero := 0
for _, f := range m.Vector {
if f != 0 {
nonzero++
}
}
if nonzero == 0 {
t.Errorf("向量全 0 —— 主症A 病根复现（禁写零向量记录）")
}
}
// W3：嵌入失败 ⇒ 502 且不写库（fail-close，不静默写零向量）
func TestWriteMemory_EmbedFail_502_NoWrite(t *testing.T) {
failEmb := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "embed backend down", http.StatusInternalServerError)
}))
defer failEmb.Close()
ldb := &recLance{}
api := NewAPI(ldb, storage.NewEmbedder(failEmb.URL), nil, governance.NewConflictDetector(), mockGraph{})
code, resp := writeMemRequest(t, api, map[string]any{"content": "牧尘的工作所在省份是河南省"})
if code != 502 {
t.Fatalf("embed 失败须 502，got %d: %v", code, resp)
}
if len(ldb.inserted) != 0 {
t.Errorf("嵌入失败不得写库（零向量 = 主症A），inserted=%d", len(ldb.inserted))
}
}
// W4：精确重复 ⇒ merged，不新增行
func TestWriteMemory_ExactDupMerges(t *testing.T) {
seed := models.MemoryRecord{ID: "mem_seed", Content: "家用服务器地址是 192.168.123.11", Category: "distilled"}
api, ldb := newRecAPI(t, seed)
code, resp := writeMemRequest(t, api, map[string]any{"content": seed.Content})
if code != 200 || resp["status"] != "merged" {
t.Fatalf("expected 200 merged, got %d %v", code, resp)
}
if len(ldb.inserted) != 0 {
t.Errorf("精确重复不得新增行，inserted=%d", len(ldb.inserted))
}
if len(ldb.updates) == 0 || ldb.updates[0] != "mem_seed" {
t.Errorf("merge 须 Update 既有行 mem_seed，updates=%v", ldb.updates)
}
}
// W5：短内容 400；GET 405
func TestWriteMemory_Validation(t *testing.T) {
api, _ := newRecAPI(t)
if c, _ := writeMemRequest(t, api, map[string]any{"content": "太短了"}); c != 400 {
t.Errorf("短内容(<8字)须 400, got %d", c)
}
req := httptest.NewRequest("GET", "/api/v1/memory/write", nil)
w := httptest.NewRecorder()
api.WriteMemory(w, req)
if w.Code != 405 {
t.Errorf("GET 须 405, got %d", w.Code)
}
}
// 落库失败（IPC down）⇒ 500 不吞错
func TestWriteMemory_InsertFail_500(t *testing.T) {
api, ldb := newRecAPI(t)
ldb.failIns = true
code, _ := writeMemRequest(t, api, map[string]any{"content": "测试落库失败场景内容足够长"})
if code != 500 {
t.Fatalf("InsertMemory 失败须 500（不吞错），got %d", code)
}
}
// W6 零回归：commit 路径仍「只写 episodes、不写 memories」（等蒸馏）
func TestCommit_StillEpisodesOnly_ZeroRegression(t *testing.T) {
api, ldb := newRecAPI(t)
llm := newMockLLM()
defer llm.server.Close()
oldRef := DistillEngineRef
DistillEngineRef = distill.NewEngine(llm.server.URL, "mock-model", "")
defer func() { DistillEngineRef = oldRef }()
// 复用 commitWith（同包 zz 测试）：普通对话提交
resp := commitWith(t, api, "今天天气不错，我们去楼下散步", false)
if resp["status"] != "ok" {
t.Fatalf("commit 基线须 status=ok，got %v", resp)
}
if resp["memory_id"] != "" {
t.Errorf("commit 不在写入时创建 memory（AC5 零回归），got %v", resp["memory_id"])
}
if len(ldb.inserted) != 0 {
t.Errorf("commit 不得直写 memories 表（零回归），inserted=%d", len(ldb.inserted))
}
}
go/internal/api/routes/metanote_gate_test.go
+55
View File
@@ -0,0 +1,55 @@
package routes
// t_5ad3f843 AC8：handler 级门禁验证。
// 门禁开 ⇒ meta-note 在**触碰 storage 之前**被 422 拒绝：
// 零值 API{}（LanceDB 接口为 nil）足证——若门禁按设计在写路径前生效，
// 422 先行返回、不会 nil 解引用 panic；若门禁失效走到 InsertEpisode ⇒ panic。
import (
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
"github.com/xiaoxue/memoryweave/internal/metanote"
)
func TestCommitGate_MetaRejectedBeforeStorage(t *testing.T) {
old := os.Getenv("ZHIYI_META_FILTER")
os.Setenv("ZHIYI_META_FILTER", "1")
defer os.Setenv("ZHIYI_META_FILTER", old)
a := &API{} // 零值：LanceDB 为 nil —— 422 先于写路径 ⇒ 不 panic
body := `{"agent_id":"hermes-a06","namespace":"hermes-main","content":"实测 淇县 ANN 731→15（都进池50）","category":"system_fact"}`
req := httptest.NewRequest(http.MethodPost, "/api/v1/commit", strings.NewReader(body))
w := httptest.NewRecorder()
a.Commit(w, req)
if w.Code != 422 {
t.Fatalf("commit(meta, 门禁开) 期望 422，实际 %d body=%s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), "meta-note") {
t.Errorf("拒绝体应说明 meta-note 原因: %s", w.Body.String())
}
// 门禁关 ⇒ 同一内容 ShouldSkip 必须 false（AC6 零行为变化）
os.Setenv("ZHIYI_META_FILTER", "")
if skip, _ := metanote.ShouldSkip("实测 淇县 ANN 731→15（都进池50）"); skip {
t.Fatal("门禁关闭时 ShouldSkip 必须为 false（零行为变化）")
}
}
func TestWriteMemoryGate_MetaRejectedBeforeStorage(t *testing.T) {
old := os.Getenv("ZHIYI_META_FILTER")
os.Setenv("ZHIYI_META_FILTER", "1")
defer os.Setenv("ZHIYI_META_FILTER", old)
a := &API{}
body := `{"agent_id":"hermes-a06","content":"织忆 golden 14/14 不退化，recall@5 = 0.4286"}`
req := httptest.NewRequest(http.MethodPost, "/api/v1/memory/write", strings.NewReader(body))
w := httptest.NewRecorder()
a.WriteMemory(w, req)
if w.Code != 422 {
t.Fatalf("write_memory(meta, 门禁开) 期望 422，实际 %d body=%s", w.Code, w.Body.String())
}
}
go/internal/api/routes/obsidian_carrier.go
+4 -2
View File
@@ -103,8 +103,10 @@ func formatEntry(content, category string) string {
func strValSafe(v interface{}) string {
switch s := v.(type) {
case string: return s
case fmt.Stringer: return s.String()
case string:
return s
case fmt.Stringer:
return s.String()
}
return ""
}
go/internal/api/routes/patterns.go
+211
View File
@@ -0,0 +1,211 @@
// 织忆 MemoryWeave — L2 模式 API（t_d32e5f8a）
//
// 设计 §4.1 端点：
// POST /api/v1/patterns/detect 手动触发模式检测（扫 L1 蒸馏记忆 → 工具组合频率 + 路径聚类
// → 写 graph_nodes type='pattern'）。短命单发：modernc sqlite
// 开/关不占长连接、不碰 state.db（规避当年 daemon main_loop
// 退役根因）—— 可挂 cron 单发。
// GET /api/v1/patterns 列出检测到的模式（按 source_tasks 长度降序）。
package routes
import (
"database/sql"
"encoding/json"
"net/http"
"net/url"
"os"
"strconv"
"strings"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/pattern"
"github.com/xiaoxue/memoryweave/internal/skillgen"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// PatternAPI L2 模式端点 + L3 skill 草稿端点。
type PatternAPI struct {
Store *pattern.GraphPatternStore
Provider *pattern.PatternProvider
LDB func() storage.LanceDB // 扫 L1 记忆（distilled）
Cfg pattern.Config
// L3 skill 草稿（t_fcadee04）：草稿生成器 + skills 表存储 + 落盘根目录。
// 由 server.go 装配；不装配时 Draft/Promote 返回 503/404（显式 API，不挂 cron）。
SkillStore *skillgen.Store
Generator skillgen.Generator
AttachmentsDir string
}
// NewPatternAPI 构造 L2 模式端点。
func NewPatternAPI(store *pattern.GraphPatternStore, provider *pattern.PatternProvider, ldb func() storage.LanceDB) *PatternAPI {
cfg := pattern.DefaultConfig()
// cron 单发跑大批量时可放宽扫描上限
if v := os.Getenv("ZHIYI_PATTERN_MAX_RECORDS"); v != "" {
if n, err := strconv.Atoi(v); err == nil && n > 0 {
cfg.MaxRecords = n
}
}
return &PatternAPI{Store: store, Provider: provider, LDB: ldb, Cfg: cfg}
}
// GET /api/v1/patterns — 列出所有检测到的模式（AC1：空库返回 count=0 不报错）。
func (pa *PatternAPI) List(w http.ResponseWriter, r *http.Request) {
limit := pa.Cfg.TopKPatternList
if v := r.URL.Query().Get("limit"); v != "" {
if n, err := strconv.Atoi(v); err == nil && n > 0 {
limit = n
}
}
pats, err := pa.Store.ListPatterns(limit)
if err != nil {
respondError(w, 500, "list patterns: "+err.Error())
return
}
respond(w, 200, map[string]interface{}{
"patterns": pats,
"count": len(pats),
})
}
// POST /api/v1/patterns/detect — 手动触发模式检测。
// body 可选 {"limit": N, "namespace": "hermes-main"}。
// 流程：LanceDB Scan(limit, ns) → pattern.DetectFromRecords → UpsertPatterns(graph_nodes)。
// 空库/无命中 → created/updated=0，不报错（AC1）。
func (pa *PatternAPI) Detect(w http.ResponseWriter, r *http.Request) {
var req struct {
Limit int `json:"limit"`
Namespace string `json:"namespace"`
}
if r.Body != nil {
_ = json.NewDecoder(r.Body).Decode(&req) // 空 body 也合法（用默认）
}
if req.Limit <= 0 {
req.Limit = pa.Cfg.MaxRecords
}
ldb := pa.LDB()
if ldb == nil {
respondError(w, 503, "lancedb unavailable")
return
}
records, err := ldb.Scan(req.Limit, req.Namespace)
if err != nil {
respondError(w, 500, "scan memories: "+err.Error())
return
}
// 只拿蒸馏产物（L1 蒸馏记忆）做检测——原始对话/episode 不是「已验证」的解决路径
// （与召回管线 2.5 步同源判据：raw/episodes 类不参与模式沉淀）。
distilled := make([]models.MemoryRecord, 0, len(records))
for _, rec := range records {
if rec.Category == "distilled" || rec.Category == "" {
distilled = append(distilled, rec)
}
}
pats := pattern.DetectFromRecords(distilled, pa.Cfg)
created, updated, uerr := pa.Store.UpsertPatterns(pats)
if uerr != nil {
respondError(w, 500, "upsert patterns: "+uerr.Error())
return
}
respond(w, 200, map[string]interface{}{
"scanned": len(records),
"created": created,
"updated": updated,
"detected": len(pats),
"patterns": pats,
})
}
// ── L3 skill 草稿（t_fcadee04，设计 §4.2 SkillGenerator）────────────────────
// patternSubPath 解析 /api/v1/patterns/{id}/{action} 子路径。
// 返回 (url-unescape 后的 id, action)。格式不符 → ("", action=="")。
func patternSubPath(path string) (id, action string) {
const prefix = "/api/v1/patterns/"
if !strings.HasPrefix(path, prefix) {
return "", ""
}
rest := strings.TrimPrefix(path, prefix) // <id>/draft 或 <id>/promote
parts := strings.Split(rest, "/")
if len(parts) != 2 || parts[0] == "" {
return "", ""
}
dec, err := url.PathUnescape(parts[0])
if err != nil {
return "", ""
}
return dec, parts[1]
}
// Sub 分发 /api/v1/patterns/{id}/draft 与 /api/v1/patterns/{id}/promote。
// 装配在 server.go 的 /api/v1/patterns/ 前缀路由；List(/patterns) 与 Detect(/patterns/detect)
// 因更长的精确路由优先，不受影响。
func (pa *PatternAPI) Sub(w http.ResponseWriter, r *http.Request) {
id, action := patternSubPath(r.URL.Path)
if id == "" {
respondError(w, 404, "pattern id required")
return
}
switch action {
case "draft":
pa.Draft(w, r, id)
case "promote":
pa.Promote(w, r, id)
default:
respondError(w, 404, "unknown action: "+action)
}
}
// POST /api/v1/patterns/{id}/draft — 生成 L3 skill 草稿（conf≥0.85 才生成）。
// 流程：读 pattern → 校验 conf → DraftSkill（写 skills 表 draft + 落盘 attachments）。
// 草稿绝不进 skills/ 技能库（红线）。
func (pa *PatternAPI) Draft(w http.ResponseWriter, r *http.Request, id string) {
if pa.SkillStore == nil || pa.Generator == nil {
respondError(w, 503, "skillgen 未装配（SkillStore/Generator 为空）")
return
}
pat, err := pa.Store.GetPattern(id)
if err != nil {
if err == sql.ErrNoRows {
respondError(w, 404, "pattern not found: "+id)
} else {
respondError(w, 500, "get pattern: "+err.Error())
}
return
}
attRoot := pa.AttachmentsDir
if attRoot == "" {
attRoot = skillgen.DefaultAttachmentsRoot()
}
sk, path, derr := skillgen.DraftSkill(pa.SkillStore, pa.Generator, pat, attRoot)
if derr != nil {
respondError(w, 400, "draft skill: "+derr.Error())
return
}
respond(w, 200, map[string]interface{}{
"skill": sk,
"file": path,
})
}
// POST /api/v1/patterns/{id}/promote — 人工确认后 draft→active。
func (pa *PatternAPI) Promote(w http.ResponseWriter, r *http.Request, id string) {
if pa.SkillStore == nil {
respondError(w, 503, "skillgen 未装配（SkillStore 为空）")
return
}
if err := pa.SkillStore.Promote(id); err != nil {
if err == sql.ErrNoRows {
respondError(w, 404, "no skill draft for pattern: "+id)
} else {
respondError(w, 500, "promote skill: "+err.Error())
}
return
}
sk, gerr := pa.SkillStore.Get(id)
if gerr != nil {
respondError(w, 500, "read skill after promote: "+gerr.Error())
return
}
respond(w, 200, map[string]interface{}{"skill": sk})
}
go/internal/api/routes/patterns_skillgen_test.go
+145
View File
@@ -0,0 +1,145 @@
// 织忆 MemoryWeave — L3 skill 草稿 API 路由测试（t_fcadee04）
//
// 覆盖端点：POST /api/v1/patterns/{id}/draft + POST /api/v1/patterns/{id}/promote
// 共享同一临时 graph.db（pattern 在 graph_nodes、skill 在 skills 表同库），零网络/零 CGO。
package routes
import (
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"github.com/xiaoxue/memoryweave/internal/pattern"
"github.com/xiaoxue/memoryweave/internal/skillgen"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// newSkillgenTestAPI 构造共享同一 temp graph.db 的 PatternAPI（含 L3 装配）。
func newSkillgenTestAPI(t *testing.T) (*PatternAPI, string) {
t.Helper()
dbDir := t.TempDir()
graphPath := filepath.Join(dbDir, "graph.db")
pstore := pattern.NewGraphPatternStore(graphPath)
t.Cleanup(pstore.Close)
sstore := skillgen.NewStore(graphPath)
t.Cleanup(sstore.Close)
attRoot := filepath.Join(t.TempDir(), "attachments")
api := NewPatternAPI(pstore, nil, func() storage.LanceDB { return nil })
api.SkillStore = sstore
api.Generator = &skillgen.FakeGenerator{Out: "## 适用场景\n重复处理"}
api.AttachmentsDir = attRoot
// 种一个 conf=0.9 的 pattern 进 graph_nodes
hi := pattern.Pattern{
ID: "pat_tool_combo:curl+git+jq", Type: "tool_combo",
Name: "tool_combo:curl+git+jq", Data: "curl+git+jq",
Confidence: 0.9, Tools: []string{"curl", "git", "jq"},
SourceTasks: []string{"m_a", "m_b", "m_c"},
}
if _, _, err := pstore.UpsertPatterns([]pattern.Pattern{hi}); err != nil {
t.Fatalf("seed pattern: %v", err)
}
return api, attRoot
}
// TestSkillgen_DraftRoute —— AC1 API 层：draft 端点 → 200 + skills 表 1 行 draft + 附件文件。
func TestSkillgen_DraftRoute(t *testing.T) {
api, attRoot := newSkillgenTestAPI(t)
id := "pat_tool_combo:curl+git+jq"
rec := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/api/v1/patterns/"+id+"/draft", nil)
api.Sub(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("draft 期望 200，实际 %d body=%s", rec.Code, rec.Body.String())
}
// skills 表 1 行 draft
if n, _ := api.SkillStore.Count("draft"); n != 1 {
t.Fatalf("AC1 判据：draft 行数应 1，实际 %d", n)
}
sk, err := api.SkillStore.Get(id)
if err != nil || sk.Status != "draft" {
t.Fatalf("skill 应存在且 draft，实际 %v %+v", err, sk)
}
// 附件文件存在 + 含 [AUTO-DRAFT]
path := filepath.Join(attRoot, skillgen.DraftSubDir("tool_combo:curl+git+jq"), "skill-draft.md")
data, rerr := os.ReadFile(path)
if rerr != nil {
t.Fatalf("附件文件不存在 %s: %v", path, rerr)
}
if !strings.Contains(string(data), skillgen.AUTO_DRAFT_MARKER) {
t.Fatalf("附件应含 [AUTO-DRAFT] 标记")
}
t.Logf("route draft 落盘: %s", path)
}
// TestSkillgen_PromoteRoute —— AC3 API 层：promote 端点 → 200 + status active。
func TestSkillgen_PromoteRoute(t *testing.T) {
api, _ := newSkillgenTestAPI(t)
id := "pat_tool_combo:curl+git+jq"
// 先 draft
dr := httptest.NewRecorder()
api.Sub(dr, httptest.NewRequest("POST", "/api/v1/patterns/"+id+"/draft", nil))
if dr.Code != http.StatusOK {
t.Fatalf("前置 draft 应 200，实际 %d", dr.Code)
}
// promote
pr := httptest.NewRecorder()
api.Sub(pr, httptest.NewRequest("POST", "/api/v1/patterns/"+id+"/promote", nil))
if pr.Code != http.StatusOK {
t.Fatalf("promote 期望 200，实际 %d body=%s", pr.Code, pr.Body.String())
}
var resp struct {
Skill struct {
Status string `json:"status"`
} `json:"skill"`
}
if err := json.Unmarshal(pr.Body.Bytes(), &resp); err != nil {
t.Fatalf("promote 解析: %v", err)
}
if resp.Skill.Status != "active" {
t.Fatalf("AC3 判据：promote 后 status 应 active，实际 %s", resp.Skill.Status)
}
// 库复核（AC3 判据：sqlite 查）
if n, _ := api.SkillStore.Count("active"); n != 1 {
t.Fatalf("AC3 判据：active 行数应 1，实际 %d", n)
}
}
// TestSkillgen_DraftRoute_NotFound —— 不存在的 pattern → 404。
func TestSkillgen_DraftRoute_NotFound(t *testing.T) {
api, _ := newSkillgenTestAPI(t)
rec := httptest.NewRecorder()
api.Sub(rec, httptest.NewRequest("POST", "/api/v1/patterns/nope/draft", nil))
if rec.Code != http.StatusNotFound {
t.Fatalf("不存在 pattern 的 draft 应 404，实际 %d", rec.Code)
}
}
// TestSkillgen_PromoteRoute_NoDraft —— 无草稿即 promote → 404。
func TestSkillgen_PromoteRoute_NoDraft(t *testing.T) {
api, _ := newSkillgenTestAPI(t)
rec := httptest.NewRecorder()
api.Sub(rec, httptest.NewRequest("POST", "/api/v1/patterns/pat_tool_combo:curl+git+jq/promote", nil))
if rec.Code != http.StatusNotFound {
t.Fatalf("无草稿 promote 应 404，实际 %d body=%s", rec.Code, rec.Body.String())
}
}
// TestSkillgen_SubPath —— 子路径解析单元（含 URL 编码 id）。
func TestSkillgen_SubPath(t *testing.T) {
id, action := patternSubPath("/api/v1/patterns/pat_tool_combo:curl+git+jq/promote")
if id != "pat_tool_combo:curl+git+jq" || action != "promote" {
t.Fatalf("解析失败 id=%q action=%q", id, action)
}
if _, a := patternSubPath("/api/v1/patterns"); a != "" {
t.Fatalf("无子路径应 action 空")
}
if _, a := patternSubPath("/api/v1/patterns/detect"); a != "" {
t.Fatalf("/patterns/detect 是精确路由，不应走 Sub")
}
}
go/internal/api/routes/patterns_test.go
+132
View File
@@ -0,0 +1,132 @@
package routes
import (
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/pattern"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// 织忆 — L2 模式 API 路由测试（t_d32e5f8a）
// AC1: 空库 detect/list → 不报错（count=0）
// AC2: 3 条同工具组合记忆 → detect 后 list 能查到 tool_combo pattern
// newPatternTestAPI 构造一个用临时 graph.db + 假 LanceDB 后端的 PatternAPI（无网络、无 CGO）。
// 假后端只实现 PatternAPI 实际调用的 Scan（其余方法嵌 nil 接口，测试路径不会触达）。
func newPatternTestAPI(t *testing.T, mems []models.MemoryRecord) *PatternAPI {
t.Helper()
store := pattern.NewGraphPatternStore(t.TempDir() + "/graph.db")
t.Cleanup(store.Close)
mlc := &patternScanLance{rows: mems}
pemb := pattern.NewEmbedderProvider(&fakePatternEmbedder{})
return NewPatternAPI(store, pattern.NewPatternProvider(store, pemb), func() storage.LanceDB { return mlc })
}
// patternScanLance 覆写 Scan（PatternAPI.Detect 唯一用到的 LanceDB 方法）；
// 其余方法嵌 nil 接口 —— 本测试路径不会调用，触达即 panic（暴露误用）。
type patternScanLance struct {
storage.LanceDB
rows []models.MemoryRecord
}
func (f *patternScanLance) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) {
if limit > 0 && len(f.rows) > limit {
return f.rows[:limit], nil
}
return f.rows, nil
}
// fakePatternEmbedder 确定性假向量（pattern.Provider 匹配测试用；注入测试走 storage 侧不走这里）。
type fakePatternEmbedder struct{}
func (fakePatternEmbedder) EncodeSingle(text string) ([]float32, error) {
v := make([]float32, 8)
for i := 0; i < 8; i++ {
v[i] = 0.1
}
return v, nil
}
// TestPatterns_ListEmpty —— AC1：空库 list → 200 + count=0（不报错）。
func TestPatterns_ListEmpty(t *testing.T) {
api := newPatternTestAPI(t, nil)
rec := httptest.NewRecorder()
api.List(rec, httptest.NewRequest("GET", "/api/v1/patterns", nil))
if rec.Code != http.StatusOK {
t.Fatalf("空库 list 期望 200，实际 %d body=%s", rec.Code, rec.Body.String())
}
var resp map[string]interface{}
_ = json.Unmarshal(rec.Body.Bytes(), &resp)
if int(resp["count"].(float64)) != 0 {
t.Fatalf("空库 count 期望 0，实际 %v", resp["count"])
}
}
// TestPatterns_DetectEmpty —— AC1：空库 detect → 200 + scanned=0/created=0（不报错）。
func TestPatterns_DetectEmpty(t *testing.T) {
api := newPatternTestAPI(t, nil)
rec := httptest.NewRecorder()
api.Detect(rec, httptest.NewRequest("POST", "/api/v1/patterns/detect", nil))
if rec.Code != http.StatusOK {
t.Fatalf("空库 detect 期望 200，实际 %d body=%s", rec.Code, rec.Body.String())
}
var resp map[string]interface{}
_ = json.Unmarshal(rec.Body.Bytes(), &resp)
if int(resp["scanned"].(float64)) != 0 || int(resp["created"].(float64)) != 0 {
t.Fatalf("空库 detect 期望 0/0，实际 %v/%v", resp["scanned"], resp["created"])
}
}
// TestPatterns_DetectToolCombo —— AC2：3 条同工具组合蒸馏记忆 → detect 产出 1 个 tool_combo，
// 且 list 能查到（sqlite graph_nodes 判据）。
func TestPatterns_DetectToolCombo(t *testing.T) {
mems := make([]models.MemoryRecord, 0, 3)
for i, id := range []string{"pc_a", "pc_b", "pc_c"} {
mems = append(mems, models.MemoryRecord{
ID: id,
Content: "用 jq git curl 处理第" + string(rune('一'+i)) + "项",
Category: "distilled",
})
}
api := newPatternTestAPI(t, mems)
rec := httptest.NewRecorder()
api.Detect(rec, httptest.NewRequest("POST", "/api/v1/patterns/detect", nil))
if rec.Code != http.StatusOK {
t.Fatalf("detect 期望 200，实际 %d body=%s", rec.Code, rec.Body.String())
}
var dresp map[string]interface{}
_ = json.Unmarshal(rec.Body.Bytes(), &dresp)
if int(dresp["detected"].(float64)) < 1 {
t.Fatalf("3 条同组合应检出 ≥1 个 pattern，实际 detected=%v", dresp["detected"])
}
// 用 list 再核一遍 sqlite 判据：确有 tool_combo 行
lrec := httptest.NewRecorder()
api.List(lrec, httptest.NewRequest("GET", "/api/v1/patterns", nil))
var lresp struct {
Count int `json:"count"`
Patterns []struct {
Type string `json:"type"`
Name string `json:"name"`
} `json:"patterns"`
}
if err := json.Unmarshal(lrec.Body.Bytes(), &lresp); err != nil {
t.Fatalf("list 解析: %v (body=%s)", err, lrec.Body.String())
}
if lresp.Count < 1 {
t.Fatalf("AC2 判据：detect 后 list count 应 ≥1，实际 %d (detected=%v)", lresp.Count, dresp["detected"])
}
var foundToolCombo bool
for _, p := range lresp.Patterns {
if p.Type == "tool_combo" {
foundToolCombo = true
}
}
if !foundToolCombo {
t.Fatalf("AC2 判据：list 应含 tool_combo pattern，实际 %d 条均非 tool_combo", lresp.Count)
}
}
go/internal/api/routes/peer.go
+335
View File
@@ -0,0 +1,335 @@
// 织忆 MemoryWeave — P3 Peer Representation API（t_f8fc97e6，设计 §6.1）
//
// 端点：
//
// POST /api/v1/peer/{id}/refresh 手动刷新某实体的四层推理画像（显式触发）
// GET /api/v1/peer/{id}/explain 解释为何这样理解该实体（可审计：画像 + 来源记忆）
// POST /api/v1/recall/peer?peer_id=… 召回某 peer 的推理画像（env 门控 ZHIYI_PEER_RECALL）
//
// 设计约束（与 L2 pattern / L3 skillgen 同源）：
//
// · refresh/explain 是显式 API，不挂 cron ⇒ 默认零行为变化。
// · 召回注入走独立端点 + env 门控 ZHIYI_PEER_RECALL，默认 0 ⇒ 主召回管线逐条不变（AC2）。
// · peers 表在 graph.db（短命 modernc），不碰 state.db。
package routes
import (
"database/sql"
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"strings"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/peer"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// PeerAPI P3 peer 表示端点。
type PeerAPI struct {
Store *peer.Store
Reasoner peer.Reasoner
LDB func() storage.LanceDB // 扫 L1 记忆（explicit 层来源）
GraphStore governance.GraphStore // 图谱上下文（推理输入）
}
// NewPeerAPI 构造。
func NewPeerAPI(store *peer.Store, reasoner peer.Reasoner, ldb func() storage.LanceDB, g governance.GraphStore) *PeerAPI {
return &PeerAPI{Store: store, Reasoner: reasoner, LDB: ldb, GraphStore: g}
}
// peerSubPath 解析 /api/v1/peer/{id}/{action} 子路径。
func peerSubPath(path string) (id, action string) {
const prefix = "/api/v1/peer/"
if !strings.HasPrefix(path, prefix) {
return "", ""
}
rest := strings.TrimPrefix(path, prefix) // <id>/refresh 或 <id>/explain
parts := strings.Split(rest, "/")
if len(parts) != 2 || parts[0] == "" {
return "", ""
}
dec, err := url.PathUnescape(parts[0])
if err != nil {
return "", ""
}
return dec, parts[1]
}
// Sub 分发 /api/v1/peer/{id}/refresh 与 /api/v1/peer/{id}/explain。
func (pa *PeerAPI) Sub(w http.ResponseWriter, r *http.Request) {
id, action := peerSubPath(r.URL.Path)
if id == "" {
respondError(w, 404, "peer id required")
return
}
switch action {
case "refresh":
if r.Method != http.MethodPost {
http.Error(w, "POST only", http.StatusMethodNotAllowed)
return
}
pa.Refresh(w, r, id)
case "explain":
if r.Method != http.MethodGet {
http.Error(w, "GET only", http.StatusMethodNotAllowed)
return
}
pa.Explain(w, r, id)
default:
respondError(w, 404, "unknown action: "+action)
}
}
// RefreshAsync 异步刷新某实体的四层画像（推理不阻塞主流程，AC4）。
// 返回一个 done channel，调用方可不等待（非阻塞）；推理在后台 goroutine 完成。
// 任何错误只记日志，不影响调用方。
func (pa *PeerAPI) RefreshAsync(id, namespace string) chan error {
done := make(chan error, 1)
if pa == nil || pa.Store == nil || pa.Reasoner == nil {
done <- fmt.Errorf("peer 未装配")
return done
}
go func() {
done <- pa.refresh(id, namespace, 2000)
}()
return done
}
// RefreshFromContent 提交新记忆后异步刷新内容里出现的已知实体（设计「新记忆进入 → 不阻塞主流程
// → 更新该 peer 表示」）。匹配：content 含某 peer_id 子串即触发。全部 goroutine 内执行，立即返回。
// 由 server.go 在 commit 处理器里以 ZHIYI_PEER_RECALL=1 门控调用；默认关 ⇒ 不触发。
func (pa *PeerAPI) RefreshFromContent(content, namespace string) {
if pa == nil || pa.Store == nil || content == "" {
return
}
peers, err := pa.Store.List(200)
if err != nil || len(peers) == 0 {
return
}
for _, p := range peers {
if p.PeerID != "" && strings.Contains(content, p.PeerID) {
go pa.refresh(p.PeerID, namespace, 2000)
}
}
}
// refresh 实际刷新编排（同步执行体；由 RefreshAsync / RefreshFromContent 包 goroutine）。
func (pa *PeerAPI) refresh(id, namespace string, limit int) error {
explicit, _, scanErr := pa.collectExplicit(id, namespace, limit)
if scanErr != nil {
return scanErr
}
graphCtx := pa.collectGraphContext(id)
if _, err := peer.BuildPeer(pa.Store, pa.Reasoner, id, explicit.facts, explicit.prefs, explicit.skills, graphCtx); err != nil {
return err
}
return nil
}
// Refresh POST /api/v1/peer/{id}/refresh — 扫 L1 记忆 + 图谱上下文 → 四层推理 → 写 peers 表。
// body 可选 {"namespace": "...", "limit": N}（namespace 空 = 全库）。
func (pa *PeerAPI) Refresh(w http.ResponseWriter, r *http.Request, id string) {
if pa.Store == nil || pa.Reasoner == nil {
respondError(w, 503, "peer 未装配（Store/Reasoner 为空）")
return
}
var req struct {
Namespace string `json:"namespace"`
Limit int `json:"limit"`
}
if r.Body != nil {
_ = json.NewDecoder(r.Body).Decode(&req)
}
if req.Limit <= 0 {
req.Limit = 2000
}
// 1. 扫 L1 记忆（LanceDB），提取 explicit 层
explicit, matched, scanErr := pa.collectExplicit(id, req.Namespace, req.Limit)
if scanErr != nil {
respondError(w, 500, "scan memories: "+scanErr.Error())
return
}
// 2. 图谱上下文（实体 1 跳邻居名）
graphCtx := pa.collectGraphContext(id)
// 3. 四层推理 + 写库
p, perr := peer.BuildPeer(pa.Store, pa.Reasoner, id, explicit.facts, explicit.prefs, explicit.skills, graphCtx)
if perr != nil {
respondError(w, 400, "build peer: "+perr.Error())
return
}
respond(w, 200, map[string]interface{}{
"peer": p,
"matched": matched,
"scanned": req.Limit,
"graph_ctx": graphCtx,
"has_reason": len(p.InferredTraits) > 0 || len(p.InferredGoals) > 0 || p.HypothesizedContext != "",
})
}
// Explain GET /api/v1/peer/{id}/explain — 可审计解释：画像 + 来源记忆。
func (pa *PeerAPI) Explain(w http.ResponseWriter, r *http.Request, id string) {
if pa.Store == nil {
respondError(w, 503, "peer 未装配（Store 为空）")
return
}
p, err := pa.Store.Get(id)
if err != nil {
if err == sql.ErrNoRows {
respondError(w, 404, "peer not found: "+id+"（先 POST /peer/{id}/refresh 生成画像）")
} else {
respondError(w, 500, "get peer: "+err.Error())
}
return
}
// 来源记忆：扫 L1 里含该实体的记忆（仅读，不改库）
src := []string{}
if pa.LDB != nil {
if ldb := pa.LDB(); ldb != nil {
if recs, serr := ldb.Scan(2000, ""); serr == nil {
for _, m := range recs {
if strings.Contains(m.Content, id) {
src = append(src, m.Content)
}
}
}
}
}
respond(w, 200, map[string]interface{}{"peer": p, "source_memories": src})
}
// RecallPeer POST /api/v1/recall/peer?peer_id=… — 召回某 peer 的四层推理画像。
// env 门控 ZHIYI_PEER_RECALL：默认 0 → 404（零变化）；=1 → 返回画像 JSON（AC3 判据）。
func (pa *PeerAPI) RecallPeer(w http.ResponseWriter, r *http.Request) {
if !peerRecallEnabled() {
respondError(w, 404, "peer recall 默认关（ZHIYI_PEER_RECALL 未设/≠1）")
return
}
pid := r.URL.Query().Get("peer_id")
if pid == "" {
respondError(w, 400, "peer_id required")
return
}
if pa.Store == nil {
respondError(w, 503, "peer 未装配（Store 为空）")
return
}
p, err := pa.Store.Get(pid)
if err != nil {
if err == sql.ErrNoRows {
respondError(w, 404, "peer not found: "+pid)
} else {
respondError(w, 500, "get peer: "+err.Error())
}
return
}
respond(w, 200, map[string]interface{}{
"peer_id": p.PeerID,
"portrait": map[string]interface{}{
"explicit": map[string]interface{}{"facts": p.Facts, "preferences": p.Preferences, "skills": p.Skills},
"deductive": map[string]interface{}{"traits": p.InferredTraits, "goals": p.InferredGoals},
"inductive": map[string]interface{}{"patterns": p.Patterns},
"abductive": map[string]interface{}{"hypothesized_context": p.HypothesizedContext},
},
"updated_at": p.UpdatedAt,
})
}
// explicitResult explicit 层收集结果。
type explicitResult struct {
facts, prefs, skills []string
}
// collectExplicit 扫 L1 记忆并提取 explicit 层。namespace 空 = 全库。
func (pa *PeerAPI) collectExplicit(id, namespace string, limit int) (explicitResult, int, error) {
var res explicitResult
if pa.LDB == nil {
return res, 0, nil
}
ldb := pa.LDB()
if ldb == nil {
return res, 0, nil
}
recs, err := ldb.Scan(limit, namespace)
if err != nil {
return res, 0, err
}
facts, prefs, skills, matched := peer.CollectFacts(recs, id)
return explicitResult{facts: facts, prefs: prefs, skills: skills}, matched, nil
}
// collectGraphContext 取实体图谱 1 跳邻居名作为推理上下文（读图，只读不改）。
func (pa *PeerAPI) collectGraphContext(id string) []string {
if pa.GraphStore == nil {
return nil
}
paths, err := pa.GraphStore.Navigate(id, 1, "", nil)
if err != nil || len(paths) == 0 {
return nil
}
seen := map[string]bool{}
var out []string
for _, p := range paths {
for _, k := range []string{"to", "target"} {
if v, ok := p[k].(string); ok && v != "" && !seen[v] && v != id {
seen[v] = true
out = append(out, v)
}
}
}
if len(out) > 10 {
out = out[:10]
}
return out
}
// peerRecallEnabled 每次调用读 env（默认关，零行为变化）。
func peerRecallEnabled() bool {
switch strings.ToLower(os.Getenv("ZHIYI_PEER_RECALL")) {
case "1", "true", "on":
return true
}
return false
}
// GetRecallResults 供 storage.PeerRecallProvider 装配（server.go 在 ZHIYI_PEER_RECALL=1
// 时注册）。query 命中某实体 → 返回该 peer 的四层画像（Category="peer"）。
// 命中判定：query 里含 peer_id 子串（大小写不敏感）；取最多 topK 个。无命中 → 空。
func (pa *PeerAPI) GetRecallResults(query, namespace string, topK int) []models.RecallResult {
if pa == nil || pa.Store == nil || topK <= 0 {
return nil
}
peers, err := pa.Store.List(200)
if err != nil || len(peers) == 0 {
return nil
}
q := strings.ToLower(strings.TrimSpace(query))
var out []models.RecallResult
for _, p := range peers {
if p.PeerID != "" && q != "" && strings.Contains(q, strings.ToLower(p.PeerID)) {
content := "peer 画像: " + p.PeerID +
" | 事实: " + strings.Join(p.Facts, "; ") +
" | 偏好: " + strings.Join(p.Preferences, "; ") +
" | 技能: " + strings.Join(p.Skills, "; ") +
" | 演绎特质: " + strings.Join(p.InferredTraits, "; ") +
" | 演绎目标: " + strings.Join(p.InferredGoals, "; ") +
" | 归纳模式: " + strings.Join(p.Patterns, "; ") +
" | 最佳解释: " + p.HypothesizedContext
out = append(out, models.RecallResult{
ID: "peer:" + p.PeerID,
Content: content,
Category: "peer",
Score: 1.0,
Namespace: namespace,
Source: "peer_representation",
})
if len(out) >= topK {
break
}
}
}
return out
}
go/internal/api/routes/peer_route_test.go
+255
View File
@@ -0,0 +1,255 @@
// 织忆 MemoryWeave — P3 Peer Representation API 路由测试（t_f8fc97e6）
//
// 覆盖端点：POST /api/v1/peer/{id}/refresh + GET /api/v1/peer/{id}/explain
// - POST /api/v1/recall/peer（env 门控）+ storage.PeerRecallProvider 注入。
//
// 共享同一临时 graph.db（peers 表），零网络 / CGO / 真模型。
package routes
import (
"encoding/json"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"time"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/peer"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// peerScanLance 覆写 Scan（PeerAPI.Refresh/Explain 唯一用到的 LanceDB 方法）；
// 其余方法嵌 nil 接口 —— 本测试路径不会调用，触达即 panic（暴露误用）。
type peerScanLance struct {
storage.LanceDB
rows []models.MemoryRecord
}
func (f *peerScanLance) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) {
if limit > 0 && len(f.rows) > limit {
return f.rows[:limit], nil
}
return f.rows, nil
}
// newPeerTestAPI 构造共享同一 temp graph.db 的 PeerAPI。
// GraphStore 传 nil（collectGraphContext 处理 nil ⇒ 无图上下文，不炸）。
func newPeerTestAPI(t *testing.T, mems []models.MemoryRecord) *PeerAPI {
t.Helper()
dir := t.TempDir()
store := peer.NewStore(filepath.Join(dir, "graph.db"))
t.Cleanup(store.Close)
mlc := &peerScanLance{rows: mems}
return NewPeerAPI(store, &peer.FakeReasoner{}, func() storage.LanceDB { return mlc }, nil)
}
// fiveMems 造 5 条关于「牧尘」的 L1 记忆（AC1 输入构造）。
func fiveMems() []models.MemoryRecord {
return []models.MemoryRecord{
{Content: "牧尘选择 Docker 部署"},
{Content: "牧尘偏好 SysV 风格"},
{Content: "牧尘擅长 Python"},
{Content: "牧尘厌恶 systemd"},
{Content: "牧尘使用 jq 处理配置"},
}
}
// TestPeer_RefreshRoute —— AC1 API 层：5 条记忆 → refresh → peers 表 1 行四层非空。
func TestPeer_RefreshRoute(t *testing.T) {
api := newPeerTestAPI(t, fiveMems())
rec := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/api/v1/peer/%E7%89%A7%E5%B0%98/refresh", nil) // 牧尘
api.Sub(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("refresh 期望 200，实际 %d body=%s", rec.Code, rec.Body.String())
}
var resp struct {
Peer peer.Peer `json:"peer"`
Matched int `json:"matched"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("refresh 解析: %v", err)
}
if resp.Matched != 5 {
t.Errorf("AC1：matched=%d 期望 5", resp.Matched)
}
if resp.Peer.PeerID != "牧尘" {
t.Errorf("peer_id=%q 期望 牧尘", resp.Peer.PeerID)
}
// 四层非空（AC1 判据）
if len(resp.Peer.InferredTraits) == 0 {
t.Error("inferred_traits 空")
}
if len(resp.Peer.InferredGoals) == 0 {
t.Error("inferred_goals 空")
}
if len(resp.Peer.Patterns) == 0 {
t.Error("patterns 空")
}
if resp.Peer.HypothesizedContext == "" {
t.Error("hypothesized_context 空")
}
// peers 表行数（AC1：sqlite 查）
if n, _ := api.Store.Count(); n != 1 {
t.Errorf("AC1：peers 行数应 1，实际 %d", n)
}
}
// TestPeer_ExplainRoute —— GET explain → 200 + 画像 + 来源记忆。
func TestPeer_ExplainRoute(t *testing.T) {
api := newPeerTestAPI(t, fiveMems())
// 先 refresh 种画像
rec := httptest.NewRecorder()
api.Sub(rec, httptest.NewRequest("POST", "/api/v1/peer/%E7%89%A7%E5%B0%98/refresh", nil))
if rec.Code != http.StatusOK {
t.Fatalf("前置 refresh 应 200，实际 %d", rec.Code)
}
// explain
er := httptest.NewRecorder()
api.Sub(er, httptest.NewRequest("GET", "/api/v1/peer/%E7%89%A7%E5%B0%98/explain", nil))
if er.Code != http.StatusOK {
t.Fatalf("explain 期望 200，实际 %d body=%s", er.Code, er.Body.String())
}
var resp struct {
Peer peer.Peer `json:"peer"`
SourceMemories []string `json:"source_memories"`
}
if err := json.Unmarshal(er.Body.Bytes(), &resp); err != nil {
t.Fatalf("explain 解析: %v", err)
}
if len(resp.SourceMemories) != 5 {
t.Errorf("source_memories=%d 期望 5（可审计：画像有来源）", len(resp.SourceMemories))
}
}
// TestPeer_Explain_NotFound —— 未 refresh 直接 explain → 404。
func TestPeer_Explain_NotFound(t *testing.T) {
api := newPeerTestAPI(t, fiveMems())
rec := httptest.NewRecorder()
api.Sub(rec, httptest.NewRequest("GET", "/api/v1/peer/%E7%89%A7%E5%B0%98/explain", nil))
if rec.Code != http.StatusNotFound {
t.Fatalf("无画像 explain 应 404，实际 %d", rec.Code)
}
}
// TestPeer_RecallPeer_DefaultOff —— AC3：ZHIYI_PEER_RECALL=0（默认）→ recall/peer 404 零变化。
func TestPeer_RecallPeer_DefaultOff(t *testing.T) {
t.Setenv("ZHIYI_PEER_RECALL", "0")
api := newPeerTestAPI(t, fiveMems())
rec := httptest.NewRecorder()
api.RecallPeer(rec, httptest.NewRequest("POST", "/api/v1/recall/peer?peer_id=牧尘", nil))
if rec.Code != http.StatusNotFound {
t.Fatalf("默认关 recall/peer 应 404，实际 %d body=%s", rec.Code, rec.Body.String())
}
}
// TestPeer_RecallPeer_Enabled —— AC3：ZHIYI_PEER_RECALL=1 → 返回四层画像 JSON。
func TestPeer_RecallPeer_Enabled(t *testing.T) {
t.Setenv("ZHIYI_PEER_RECALL", "1")
api := newPeerTestAPI(t, fiveMems())
// 先 refresh 种画像
rrec := httptest.NewRecorder()
api.Sub(rrec, httptest.NewRequest("POST", "/api/v1/peer/%E7%89%A7%E5%B0%98/refresh", nil))
if rrec.Code != http.StatusOK {
t.Fatalf("前置 refresh 应 200，实际 %d", rrec.Code)
}
// recall/peer
rec := httptest.NewRecorder()
api.RecallPeer(rec, httptest.NewRequest("POST", "/api/v1/recall/peer?peer_id=牧尘", nil))
if rec.Code != http.StatusOK {
t.Fatalf("recall/peer 期望 200，实际 %d body=%s", rec.Code, rec.Body.String())
}
var resp struct {
Portrait map[string]interface{} `json:"portrait"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("recall/peer 解析: %v", err)
}
// 四层各有内容（AC3 判据）
for _, layer := range []string{"explicit", "deductive", "inductive", "abductive"} {
v, ok := resp.Portrait[layer]
if !ok {
t.Errorf("portrait 缺 %s 层: %v", layer, resp.Portrait)
continue
}
s, _ := json.Marshal(v)
if string(s) == "{}" || strings.Contains(string(s), "[]\"") {
t.Errorf("portrait.%s 层空: %s", layer, s)
}
}
t.Logf("AC3 recall/peer 画像: %s", rec.Body.String())
}
// TestPeer_GetRecallResults —— storage.PeerRecallProvider 注入：query 含实体 → 返回画像条目。
func TestPeer_GetRecallResults(t *testing.T) {
api := newPeerTestAPI(t, fiveMems())
// 种画像
api.Sub(httptest.NewRecorder(),
httptest.NewRequest("POST", "/api/v1/peer/%E7%89%A7%E5%B0%98/refresh", nil))
res := api.GetRecallResults("牧尘怎么部署", "", 1)
if len(res) != 1 {
t.Fatalf("GetRecallResults 应返回 1 条，实际 %d", len(res))
}
if res[0].Category != "peer" || res[0].ID != "peer:牧尘" {
t.Errorf("返回条目 Category=%q ID=%q 期望 peer / peer:牧尘", res[0].Category, res[0].ID)
}
if !strings.Contains(res[0].Content, "演绎特质") || !strings.Contains(res[0].Content, "最佳解释") {
t.Errorf("画像内容缺四层: %s", res[0].Content)
}
// 无命中 → 空
if got := api.GetRecallResults("如何优化 Redis", "", 1); len(got) != 0 {
t.Errorf("不相关 query 应空，实际 %d", len(got))
}
}
// TestPeer_SubPath —— 子路径解析单元。
func TestPeer_SubPath(t *testing.T) {
id, action := peerSubPath("/api/v1/peer/%E7%89%A7%E5%B0%98/refresh")
if id != "牧尘" || action != "refresh" {
t.Fatalf("解析失败 id=%q action=%q", id, action)
}
if _, a := peerSubPath("/api/v1/peer"); a != "" {
t.Fatalf("无子路径应 action 空")
}
}
// blockingReasoner 会阻塞的推理器（测非阻塞：RefreshAsync 不等它完成）。
type blockingReasoner struct{ release chan struct{} }
func (b *blockingReasoner) Reason(facts, prefs, skills, graphCtx []string) (*peer.ReasoningOutput, error) {
<-b.release
return &peer.ReasoningOutput{InferredTraits: []string{"T"}}, nil
}
// TestPeer_RefreshAsync_NonBlocking —— AC4：推理不阻塞主流程。
// RefreshAsync 立即返回（后台 goroutine 推理），即使推理器被阻塞也绝不等它。
func TestPeer_RefreshAsync_NonBlocking(t *testing.T) {
dir := t.TempDir()
store := peer.NewStore(filepath.Join(dir, "graph.db"))
t.Cleanup(store.Close)
br := &blockingReasoner{release: make(chan struct{})}
mlc := &peerScanLance{rows: fiveMems()}
api := NewPeerAPI(store, br, func() storage.LanceDB { return mlc }, nil)
done := api.RefreshAsync("牧尘", "")
select {
case <-done:
t.Fatal("RefreshAsync 应在推理器仍阻塞时立即返回（非阻塞），却等到了结果")
case <-time.After(200 * time.Millisecond):
// 非阻塞 ✓：200ms 内未等推理完成
}
// 释放推理器，后台完成
close(br.release)
select {
case <-done:
// 后台完成
case <-time.After(2 * time.Second):
t.Fatal("释放后后台推理未完成")
}
// 画像已落库
if n, _ := store.Count(); n != 1 {
t.Errorf("非阻塞刷新后 peers 行数应 1，实际 %d", n)
}
}
go/internal/api/routes/provenance_observe.go
+21 -19
View File
@@ -10,21 +10,22 @@
// 结果追加到 ~/.hermes/logs/zhiyi-commit-provenance/YYYY-MM-DD.jsonl。
//
// 判定降级（AC2 重定义，t_dc412532 阶段2 设计输入）：
// (a) metadata 有 source_uri + quote + quote_sha256 → 复算 sha256(quote) 比对；
// 不等 observable=false, reason=hash_mismatch
// (b) 无上述字段但 source=="session-compress" 且 session_id 存在 →
// 去 ~/.hermes/state.db（只读）取该 session 消息文本做回证。
// 观察期实测（n=205, 24h）：true=1 / false=8 / unknown=193；全部 8 条 false
// 均来自 session-compress —— 判据「前 60 字逐字命中 / LCS≥60」对「摘要/派生内容」
// 结构性必 false（摘要不会逐字出现在原文里）。AC2 修正：
// * 原文不可得（session 已压缩/清除）→ observable=unknown, reason=source_not_available
// （空原文 = 无法证伪，不是证伪失败 —— 旧逻辑误标 false/not_in_source）
// * 前 60 字逐字命中 或 LCS≥60 → observable=true（引用片段可溯源）
// * 其余（摘要低 LCS，属正常改写）→ observable=unknown, reason=derived_low_lcs
// （对派生内容无法证伪 —— 摘要重述≠不可溯源）
// 同时把实测数值 lcs_len / prefix_hit60 写进 jsonl（AC1 先量后判），
// 供阶段3 转硬闸时按分布定档。
// (c) 其他 source → observable=unknown, reason=no_derivation（不要瞎猜成 false）
//
// (a) metadata 有 source_uri + quote + quote_sha256 → 复算 sha256(quote) 比对；
// 不等 observable=false, reason=hash_mismatch
// (b) 无上述字段但 source=="session-compress" 且 session_id 存在 →
// 去 ~/.hermes/state.db（只读）取该 session 消息文本做回证。
// 观察期实测（n=205, 24h）：true=1 / false=8 / unknown=193；全部 8 条 false
// 均来自 session-compress —— 判据「前 60 字逐字命中 / LCS≥60」对「摘要/派生内容」
// 结构性必 false（摘要不会逐字出现在原文里）。AC2 修正：
// * 原文不可得（session 已压缩/清除）→ observable=unknown, reason=source_not_available
// （空原文 = 无法证伪，不是证伪失败 —— 旧逻辑误标 false/not_in_source）
// * 前 60 字逐字命中 或 LCS≥60 → observable=true（引用片段可溯源）
// * 其余（摘要低 LCS，属正常改写）→ observable=unknown, reason=derived_low_lcs
// （对派生内容无法证伪 —— 摘要重述≠不可溯源）
// 同时把实测数值 lcs_len / prefix_hit60 写进 jsonl（AC1 先量后判），
// 供阶段3 转硬闸时按分布定档。
// (c) 其他 source → observable=unknown, reason=no_derivation（不要瞎猜成 false）
package routes
import (
@@ -162,9 +163,10 @@ func observeViaSession(content, sessionID string) (string, string, int, bool) {
}
// provenanceMeasure 计算 content 相对 srcText 的可溯源实测指标：
// prefixHit60 = content 前 60 字在 srcText 中逐字命中
// lcsLen = content 与 srcText 的最长公共子串长度
// match = prefixHit60 || lcsLen >= minCommonRun
//
// prefixHit60 = content 前 60 字在 srcText 中逐字命中
// lcsLen = content 与 srcText 的最长公共子串长度
// match = prefixHit60 || lcsLen >= minCommonRun
func provenanceMeasure(content, srcText string) (match bool, lcsLen int, prefixHit60 bool) {
if content == "" || srcText == "" {
return false, 0, false
@@ -233,4 +235,4 @@ func appendProvenanceLog(line map[string]interface{}) {
}
defer f.Close()
fmt.Fprintf(f, "%s\n", data)
}
}
go/internal/api/routes/provenance_observe_test.go
+1 -1
View File
@@ -46,4 +46,4 @@ func TestDecideQuoteHash(t *testing.T) {
if observable != "false" || reason != "hash_mismatch" {
t.Fatalf("expect false/hash_mismatch got %s/%s", observable, reason)
}
}
}
go/internal/api/routes/recall_error_shape_test.go
+10 -2
View File
@@ -11,6 +11,7 @@ import (
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/models"
@@ -35,7 +36,7 @@ func (f *fakeLanceDB) Stats() (map[string]interface{}, error) {
return map[string]interface{}{}, nil
}
func (f *fakeLanceDB) SoftDelete(id, reason string) error { return nil }
func (f *fakeLanceDB) PurgeInvalid() (int64, error) { return 0, nil }
func (f *fakeLanceDB) PurgeInvalid() (int64, error) { return 0, nil }
func (f *fakeLanceDB) SoftDeleteBatch(table string, ids []string, updatedAt string) (int64, error) {
return 0, nil
}
@@ -56,6 +57,13 @@ func (f *fakeLanceDB) IncrementUseful(id string) error { return nil }
func (f *fakeLanceDB) IncrementNotUseful(id string) error {
return nil
}
// GA-P0-1 (t_718d8707)：拆分字段
func (f *fakeLanceDB) IncrementHumanNotUseful(id string) error { return nil }
func (f *fakeLanceDB) AppendHitEvent(memoryID, outcome, reason string) error { return nil }
func (f *fakeLanceDB) CountHitEvents(memoryID, outcome string, since time.Time) (int, error) { return 0, nil }
func (f *fakeLanceDB) GetHitEvents(memoryID string, limit int) ([]models.HitEvent, error) { return nil, nil }
func (f *fakeLanceDB) IncrementDedupDownweight(id string) error { return nil }
func (f *fakeLanceDB) UpdateMemoryContent(id, newContent, source string) error {
return nil
}
@@ -183,7 +191,7 @@ type fakeEmbedder struct {
// TestRecallFailure_Non2xx 验证失败路径：依赖不可用时返回非 2xx + 统一错误体。
// 模拟：embedder endpoint="" → encode 必失败（HTTP 到空 URL）⇒ 主路径 err != nil
// + InMemoryGraph FallbackTextSearch 返回空 ⇒ 502 失败路径。
// - InMemoryGraph FallbackTextSearch 返回空 ⇒ 502 失败路径。
func TestRecallFailure_Non2xx(t *testing.T) {
db := &fakeLanceDB{searchResults: nil}
gs := governance.NewInMemoryGraph()
go/internal/api/routes/recall_truncated_test.go
+144
View File
@@ -0,0 +1,144 @@
package routes
// t_3aa2a8c1：`/api/v1/recall` 响应暴露 `truncated`（Rust 侧单次重读行数上限截断标志，
// 引擎已算、此前只打日志不上抛）。选定的省略语义 = **键缺失即未截断（omitempty）**。
// 本测试经路由层机械判定：
// ① 粗检索被截断（后端实现 SearchTruncationReporter 且上报 true）⇒ 响应含 "truncated":true
// ② 未截断 / 纯 Go 后端（不实现 reporter）⇒ 键缺失（不出现 truncated:false 以外的值）
// ③ 回归：既有字段 results/count/candidates_scanned/mode/cache_hit 行为不变
import (
"encoding/json"
"net/http/httptest"
"strings"
"testing"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// truncReportingLDB 复用同包 fakeLanceDB（recall_error_shape_test.go），
// 额外实现可选扩展接口 SearchWithTruncationReporter（t_3aa2a8c1）。
type truncReportingLDB struct {
*fakeLanceDB
reportTruncated bool
}
func (f *truncReportingLDB) SearchWithTruncation(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, bool, error) {
if f.searchErr != nil {
return nil, false, f.searchErr
}
if len(f.searchResults) > topK {
return f.searchResults[:topK], f.reportTruncated, nil
}
return f.searchResults, f.reportTruncated, nil
}
func recallBody(t *testing.T, db storage.LanceDB, body string) (int, map[string]interface{}, string) {
t.Helper()
// 测试须可复跑（t_3aa2a8c1 实测踩坑）：SearchCacheInstance 由 storage 包 init() 恒建
// （L2 = 共享 Redis，TTL 60s）⇒ 上一次 run 的 recall 结果会进 L2，下一次 run 同 key
// 命中缓存路径（Truncated 恒 false）⇒ 断言 flaky。逐测试摘除缓存（测后恢复），
// 恒走未缓存路径。包内无 t.Parallel ⇒ 改全局安全。
saved := storage.SearchCacheInstance
storage.SearchCacheInstance = nil
t.Cleanup(func() { storage.SearchCacheInstance = saved })
emb := storage.NewEmbedder("")
rerank := storage.NewReranker("", emb)
api := NewAPI(db, emb, rerank, nil, governance.NewInMemoryGraph())
req := httptest.NewRequest("POST", "/api/v1/recall", strings.NewReader(body))
w := httptest.NewRecorder()
api.Recall(w, req)
var m map[string]interface{}
_ = json.Unmarshal(w.Body.Bytes(), &m)
return w.Code, m, w.Body.String()
}
// 既有响应键回归基线（t_2d4e3b92 成功 schema + t_1c12e000 cache_hit + t_949840b1 candidates_scanned）
var recallBaselineKeys = []string{"results", "count", "candidates_scanned", "mode", "cache_hit"}
func assertBaseline(t *testing.T, m map[string]interface{}, body string) {
t.Helper()
for _, k := range recallBaselineKeys {
if _, ok := m[k]; !ok {
t.Fatalf("既有字段 %q 缺失（回归破坏），body=%s", k, body)
}
}
if res, ok := m["results"].([]interface{}); ok {
if cnt, _ := m["count"].(float64); int(cnt) != len(res) {
t.Fatalf("count=%v 与 len(results)=%d 不一致（回归破坏）", m["count"], len(res))
}
}
}
// ① 粗检索被行数上限截断 ⇒ 响应暴露 truncated:true + 既有字段回归不变
func TestRecall_TruncatedExposedWhenHitCap(t *testing.T) {
db := &truncReportingLDB{
fakeLanceDB: &fakeLanceDB{searchResults: []models.MemoryRecord{
{ID: "mem_1", Content: "test memory one", Category: "distilled"},
{ID: "mem_2", Content: "test memory two", Category: "distilled"},
}},
reportTruncated: true,
}
code, m, body := recallBody(t, db, `{"query":"test query","limit":5,"namespace":"shared"}`)
if code != 200 {
t.Fatalf("expected 200, got %d; body=%s", code, body)
}
if v, ok := m["truncated"]; !ok || v != true {
t.Fatalf("粗检索已截断，响应必须含 truncated:true；实际 key 存在=%v 值=%v body=%s", ok, m["truncated"], body)
}
assertBaseline(t, m, body)
}
// ①b keyword 主路径（kwMeta 透传）同判据
func TestRecall_Keyword_TruncatedExposed(t *testing.T) {
db := &truncReportingLDB{
fakeLanceDB: &fakeLanceDB{searchResults: []models.MemoryRecord{
{ID: "mem_1", Content: "keyword memory", Category: "distilled"},
}},
reportTruncated: true,
}
code, m, body := recallBody(t, db, `{"query":"keyword query","limit":5,"mode":"keyword","namespace":"shared"}`)
if code != 200 {
t.Fatalf("expected 200, got %d; body=%s", code, body)
}
if v, ok := m["truncated"]; !ok || v != true {
t.Fatalf("keyword 路径粗检索已截断，响应必须含 truncated:true；body=%s", body)
}
assertBaseline(t, m, body)
}
// ② 未截断 ⇒ 键缺失（选定语义：省略=未截断），不得出现 truncated:false 以外的值
func TestRecall_NotTruncated_KeyOmitted(t *testing.T) {
db := &truncReportingLDB{
fakeLanceDB: &fakeLanceDB{searchResults: []models.MemoryRecord{
{ID: "mem_1", Content: "test memory one", Category: "distilled"},
}},
reportTruncated: false,
}
code, m, body := recallBody(t, db, `{"query":"test query","limit":5,"namespace":"shared"}`)
if code != 200 {
t.Fatalf("expected 200, got %d; body=%s", code, body)
}
if v, ok := m["truncated"]; ok {
t.Fatalf("未截断场景键应缺失（省略=未截断）；实际 truncated=%v body=%s", v, body)
}
assertBaseline(t, m, body)
}
// ②b 纯 Go 后端（不实现 SearchTruncationReporter）⇒ 键缺失，零值语义、行为不变
func TestRecall_PureGoBackend_NoTruncatedKey(t *testing.T) {
db := &fakeLanceDB{searchResults: []models.MemoryRecord{
{ID: "mem_1", Content: "test memory one", Category: "distilled"},
}}
code, m, body := recallBody(t, db, `{"query":"test query","limit":5,"namespace":"shared"}`)
if code != 200 {
t.Fatalf("expected 200, got %d; body=%s", code, body)
}
if _, ok := m["truncated"]; ok {
t.Fatalf("纯 Go 后端无行数上限，truncated 键必须缺失；body=%s", body)
}
assertBaseline(t, m, body)
}
go/internal/api/routes/skill_bayes.go
+27 -27
View File
@@ -17,18 +17,18 @@ const skillRedisKey = "zhiyi:skills"
// BetaSkill 贝叶斯 Skill 评分（G7 扩展版）
type BetaSkill struct {
Name string `json:"name"`
Alpha float64 `json:"alpha"` // α = successes + 1
Beta float64 `json:"beta"` // β = failures + 1
Trials int `json:"trials"`
Successes int `json:"successes"`
ETA float64 `json:"eta"` // α/(α+β) 贝叶斯均值
Status string `json:"status"` // active / probation / retired
LastUpdated time.Time `json:"last_updated"`
Name string `json:"name"`
Alpha float64 `json:"alpha"` // α = successes + 1
Beta float64 `json:"beta"` // β = failures + 1
Trials int `json:"trials"`
Successes int `json:"successes"`
ETA float64 `json:"eta"` // α/(α+β) 贝叶斯均值
Status string `json:"status"` // active / probation / retired
LastUpdated time.Time `json:"last_updated"`
// G7 扩展字段
PromptTemplate string `json:"prompt_template,omitempty"` // 可执行 prompt（含 {param} 占位符）
LinkedMemoryIDs []string `json:"linked_memory_ids,omitempty"` // 关联的记忆 ID
LinkedEntities []string `json:"linked_entities,omitempty"` // 关联的图谱实体
PromptTemplate string `json:"prompt_template,omitempty"` // 可执行 prompt（含 {param} 占位符）
LinkedMemoryIDs []string `json:"linked_memory_ids,omitempty"` // 关联的记忆 ID
LinkedEntities []string `json:"linked_entities,omitempty"` // 关联的图谱实体
CreatedAt time.Time `json:"created_at"`
}
@@ -146,12 +146,12 @@ func (bsm *BayesianSkillManager) Register(name, promptTemplate string, linkedEnt
skill, exists := bsm.skills[name]
if !exists {
skill = &BetaSkill{
Name: name,
Alpha: 1.0,
Beta: 1.0,
CreatedAt: time.Now(),
PromptTemplate: promptTemplate,
LinkedEntities: linkedEntities,
Name: name,
Alpha: 1.0,
Beta: 1.0,
CreatedAt: time.Now(),
PromptTemplate: promptTemplate,
LinkedEntities: linkedEntities,
}
bsm.skills[name] = skill
} else {
@@ -306,11 +306,11 @@ func (bsm *BayesianSkillManager) Stats() map[string]interface{} {
}
}
return map[string]interface{}{
"total": len(bsm.skills),
"active": active,
"probation": probation,
"retired": retired,
"persisted": bsm.persisted,
"total": len(bsm.skills),
"active": active,
"probation": probation,
"retired": retired,
"persisted": bsm.persisted,
"redis_connected": bsm.redisClient != nil,
}
}
@@ -371,10 +371,10 @@ func (sm *SkillManager) Trial(w http.ResponseWriter, r *http.Request) {
// POST /api/v1/skills — 注册新 skill（G7 新增）
func (sm *SkillManager) Register(w http.ResponseWriter, r *http.Request) {
var req struct {
Name string `json:"name"`
PromptTemplate string `json:"prompt_template"`
LinkedEntities []string `json:"linked_entities"`
Description string `json:"description"`
Name string `json:"name"`
PromptTemplate string `json:"prompt_template"`
LinkedEntities []string `json:"linked_entities"`
Description string `json:"description"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, 400, "invalid body: "+err.Error())
@@ -427,4 +427,4 @@ func (sm *SkillManager) GetSkillETA(name string) float64 {
return 0.5
}
return skill.ETA
}
}
go/internal/api/routes/skill_crystallize.go
+3 -3
View File
@@ -153,8 +153,8 @@ func crystallizeFromRecord(mem *models.MemoryRecord) (*BetaSkill, error) {
if err == nil && llmResult != "" {
var parsed struct {
PromptTemplate string `json:"prompt_template"`
Entities []string `json:"entities"`
SkillName string `json:"skill_name"`
Entities []string `json:"entities"`
SkillName string `json:"skill_name"`
}
if err2 := json.Unmarshal([]byte(llmResult), &parsed); err2 == nil {
if parsed.PromptTemplate != "" {
@@ -318,4 +318,4 @@ func getLDB() storage.LanceDB {
return ldbGetter()
}
return nil
}
}
go/internal/api/routes/skill_execute.go
-1
View File
@@ -240,4 +240,3 @@ func ExecuteSkill(w http.ResponseWriter, r *http.Request) {
"eta": skill.ETA,
})
}
go/internal/api/routes/standing_answers.go
+72
View File
@@ -0,0 +1,72 @@
package routes
import (
"encoding/json"
"net/http"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// 2026-10-13 (t_e9a4d18f P2) 常设答案路由（Hindsight mental models 直读/写入）。
// 读取 = 一次 DB 读（question_id 主键），零检索零 LLM。写入由生成脚本
// zhiyi-standing-answers.py 调用（复用本地 2B，免费）。
// standingStore 返回全局常设答案库（server.go 注入）。未初始化 → nil。
func standingStore() *storage.StandingStore { return storage.StandingStoreInstance }
// HandleStandingAnswers GET/POST /api/v1/standing-answers
// GET ?id=<question_id> → 直读一条；无 id → 列全部
// POST {"question_id","question","answer","source_memories":[]} → 写入/改写
func HandleStandingAnswers(w http.ResponseWriter, r *http.Request) {
s := standingStore()
if s == nil {
respondError(w, http.StatusServiceUnavailable, "standing answers store not initialized")
return
}
switch r.Method {
case http.MethodGet:
id := r.URL.Query().Get("id")
if id == "" {
all, err := s.List()
if err != nil {
respondError(w, http.StatusInternalServerError, err.Error())
return
}
respond(w, http.StatusOK, map[string]interface{}{"answers": all, "count": len(all)})
return
}
a, err := s.Get(id)
if err != nil {
respondError(w, http.StatusInternalServerError, err.Error())
return
}
if a == nil {
respondError(w, http.StatusNotFound, "standing answer not found: "+id)
return
}
respond(w, http.StatusOK, a)
case http.MethodPost:
var in struct {
QuestionID string `json:"question_id"`
Question string `json:"question"`
Answer string `json:"answer"`
SourceMemories []string `json:"source_memories"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
respondError(w, http.StatusBadRequest, "bad json: "+err.Error())
return
}
if in.QuestionID == "" || in.Answer == "" {
respondError(w, http.StatusBadRequest, "question_id and answer required")
return
}
a, err := s.Upsert(in.QuestionID, in.Question, in.Answer, in.SourceMemories)
if err != nil {
respondError(w, http.StatusInternalServerError, err.Error())
return
}
respond(w, http.StatusOK, a)
default:
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
}
}
go/internal/api/routes/system_template.go
+25
View File
@@ -0,0 +1,25 @@
// 织忆 MemoryWeave — 系统通知/提示样板文本判定（被动注入入口噪音闸门）
//
// 背景（t_689b6d38，2026-10-11 实测）：织忆被动注入入口不区分「真实用户消息」与
// 「系统样板文本」。近 7 天 [graph/notes] 通道 806 次注入里 543 次（67%）的入参是
// 系统通知/提示样板（形如 "[IMPORTANT: You are running as a scheduled cron job...",
// "[IMPORTANT: Background process ... completed", "[System note: ..."），它们照常走
// 完整实体拆解并返回 3 篇笔记注入上下文 —— 纯浪费 + 稀释有效注入信噪比。
//
// 判定优先用【结构化信号】（消息来源标记头，如 "[IMPORTANT:"、"[HEARTBEAT]"、
// "[System note:"、"Cronjob Response:"、role/来源字段），而不是纯文本长度启发式。
// 命中 ⇒ 调用方应跳过语义召回与笔记返回。白名单：真实用户提问（含飞书/QQ/CLI 入站
// 消息）不命中任何前缀/子串 ⇒ 照常召回，不误杀。
package routes
import "github.com/xiaoxue/memoryweave/internal/textfilter"
// IsSystemTemplateInput 判定一段文本是否系统通知/提示样板（非真实用户提问）。
// 命中 ⇒ 调用方应跳过语义召回与笔记返回（t_689b6d38 噪音闸门）。
//
// 2026-10-12：判定清单已抽到叶子包 internal/textfilter（蒸馏侧准入闸门也要用，
// 而 distill 不能反向 import routes）。本函数保留为薄委托，调用点零改动。
// 清单只维护 textfilter 一处。
func IsSystemTemplateInput(s string) bool {
return textfilter.IsSystemTemplate(s)
}
go/internal/api/routes/testdata/golden-set.json
Vendored
+114 -44
View File
@@ -1,117 +1,187 @@
{
"description": "织忆召回金标检查集（12条基线 + 2条目标知识）。统一判据口径（t_a70b07e1）：取 recall 返回的前 N=5 条内容查关键词，ID 命中 = expected_ids 任一 ∈ 前 N=5 条；N=5 与 Go/Python 两量具（eval_test.go / golden-check.py）一致。判定：PASS=id且kw命中 / WARN=kw命中但ID漂移 / FAIL=其余 / ERROR=recall调用失败。单一真相源（t_949840b1）：本文件是金标数据唯一副本；Python 量具 golden-check.py 直接读本文件（旧 ~/.hermes/scripts/tools/golden-set.json 副副本已删除），基线校准一次即两量具同步（--refresh 写回本文件）。⚠️ item4「牧尘喜欢什么样的工作方式」基线 2026-09-21 t_949840b1 校准为当前稳定值 mem_1789834428978989104（语料增长致旧基线 mem_1789837840173161705 掉出 top-5，前 N 内容仍切题）。校准后同批金标两量具分类差异=0（diff=1 的根因——两份副本 expected_ids 不同步——已消除）。",
"description": "织忆召回金标检查集（单一真相源，t_949840b1）。统一判据口径 N=5：取 recall 返回前 N=5 条查关键词，ID 命中 = expected_ids 任一 ∈ 前 N=5 条。基线已刷新（golden-check.py --refresh，两量具同源）。",
"items": [
{
"query": "织忆是什么",
"expected_ids": ["mem_1789153726378940805"],
"must_include_keywords": ["织忆"],
"expected_ids": [
"mem_1791666702950691634"
],
"must_include_keywords": [
"织忆"
],
"category": "system_fact",
"difficulty": "easy",
"id_baseline": "mem_1789153726378940805"
"id_baseline": "mem_1791666702950691634",
"namespace": "hermes-main"
},
{
"query": "织忆的图谱扩展机制是什么",
"expected_ids": ["mem_1789823837902661249"],
"must_include_keywords": ["图谱"],
"expected_ids": [
"mem_1791899478673190284"
],
"must_include_keywords": [
"图谱"
],
"category": "system_fact",
"difficulty": "medium",
"id_baseline": "mem_1789823837902661249"
"id_baseline": "mem_1791899478673190284",
"namespace": "hermes-main"
},
{
"query": "织忆如何通过 E1 提取和 MMR 实现多样去重",
"expected_ids": ["mem_1789915227303612056"],
"must_include_keywords": ["MMR"],
"expected_ids": [
"mem_1791666890486125605"
],
"must_include_keywords": [
"MMR"
],
"category": "system_fact",
"difficulty": "hard",
"id_baseline": "mem_1789915227303612056"
"id_baseline": "mem_1791666890486125605",
"namespace": "hermes-main"
},
{
"query": "牧尘的偏好是什么",
"expected_ids": ["mem_1789667544872361813"],
"must_include_keywords": ["牧尘"],
"expected_ids": [
"mem_1790448247125520424"
],
"must_include_keywords": [
"牧尘"
],
"category": "user_pref",
"difficulty": "easy",
"id_baseline": "mem_1789667544872361813"
"id_baseline": "mem_1790448247125520424",
"namespace": "hermes-main"
},
{
"query": "牧尘喜欢什么样的工作方式",
"expected_ids": ["mem_1789834428978989104"],
"must_include_keywords": ["牧尘"],
"expected_ids": [
"mem_1790448247125520424"
],
"must_include_keywords": [
"牧尘"
],
"category": "user_pref",
"difficulty": "medium",
"id_baseline": "mem_1789834428978989104"
"id_baseline": "mem_1790448247125520424",
"namespace": "hermes-main"
},
{
"query": "如何根据牧尘的偏好调整记忆检索策略",
"expected_ids": ["mem_1789190217889697697"],
"must_include_keywords": ["记忆"],
"expected_ids": [
"mem_1791747597032219499"
],
"must_include_keywords": [
"记忆"
],
"category": "user_pref",
"difficulty": "hard",
"id_baseline": "mem_1789190217889697697"
"id_baseline": "mem_1791747597032219499",
"namespace": "hermes-main"
},
{
"query": "当前项目的技术栈是什么",
"expected_ids": ["mem_1789680870868739202"],
"must_include_keywords": ["技术栈"],
"expected_ids": [
"mem_1790455676397796671"
],
"must_include_keywords": [
"技术栈"
],
"category": "proj_context",
"difficulty": "easy",
"id_baseline": "mem_1789680870868739202"
"id_baseline": "mem_1790455676397796671",
"namespace": "hermes-main"
},
{
"query": "织忆项目有哪些核心组件",
"expected_ids": ["mem_1789154058288011112"],
"must_include_keywords": ["织忆"],
"expected_ids": [
"mem_1791906354849281414"
],
"must_include_keywords": [
"织忆"
],
"category": "proj_context",
"difficulty": "medium",
"id_baseline": "mem_1789154058288011112"
"id_baseline": "mem_1791906354849281414",
"namespace": "hermes-main"
},
{
"query": "织忆和其他记忆系统相比有什么架构优势",
"expected_ids": ["mem_1789153726378940805"],
"must_include_keywords": ["织忆"],
"expected_ids": [
"mem_1791666702950691634"
],
"must_include_keywords": [
"织忆"
],
"category": "proj_context",
"difficulty": "hard",
"id_baseline": "mem_1789153726378940805"
"id_baseline": "mem_1791666702950691634",
"namespace": "hermes-main"
},
{
"query": "如何使用 recall 接口",
"expected_ids": ["mem_1787272787836687543"],
"must_include_keywords": ["recall"],
"expected_ids": [
"mem_1791796178328736793"
],
"must_include_keywords": [
"recall"
],
"category": "tool_usage",
"difficulty": "easy",
"id_baseline": "mem_1787272787836687543"
"id_baseline": "mem_1791796178328736793",
"namespace": "hermes-main"
},
{
"query": "织忆有哪些管理工具",
"expected_ids": ["mem_1789153726378940805"],
"must_include_keywords": ["织忆"],
"expected_ids": [
"mem_1791666702950691634"
],
"must_include_keywords": [
"织忆"
],
"category": "tool_usage",
"difficulty": "medium",
"id_baseline": "mem_1789153726378940805"
"id_baseline": "mem_1791666702950691634",
"namespace": "hermes-main"
},
{
"query": "如何通过 API 扩展织忆功能",
"expected_ids": ["mem_1789153726378940805"],
"must_include_keywords": ["织忆"],
"expected_ids": [
"mem_1791666188168772049"
],
"must_include_keywords": [
"织忆"
],
"category": "tool_usage",
"difficulty": "hard",
"id_baseline": "mem_1789153726378940805"
"id_baseline": "mem_1791666188168772049",
"namespace": "hermes-main"
},
{
"query": "本地 llama 服务 8080 端口",
"expected_ids": ["mem_1789229548476546193"],
"must_include_keywords": ["8080"],
"expected_ids": [
"mem_1791423503359721152"
],
"must_include_keywords": [
"8080"
],
"category": "target_knowledge",
"difficulty": "easy",
"id_baseline": "mem_1789229548476546193"
"id_baseline": "mem_1791423503359721152",
"namespace": "hermes-main"
},
{
"query": "session-to-zhiyi.py 脚本名",
"expected_ids": ["mem_1788977361686058470"],
"must_include_keywords": ["session-to-zhiyi"],
"expected_ids": [
"mem_1791688470278719760"
],
"must_include_keywords": [
"session-to-zhiyi"
],
"category": "target_knowledge",
"difficulty": "easy",
"id_baseline": "mem_1788977361686058470"
"id_baseline": "mem_1791688470278719760",
"namespace": "hermes-main"
}
]
}
}
go/internal/api/routes/testmain_test.go
+52
View File
@@ -0,0 +1,52 @@
// 织忆 MemoryWeave — routes 包测试隔离（两个护栏合并 · t_e5997ca4 + t_b7a8ed9c）
//
// ⚠️ 本文件是**两个 TestMain 的合并体**。两卡分支各自加了一个 TestMain：
// · t_e5997ca4 → testmain_test.go（落盘点护栏）
// · t_b7a8ed9c → scorecache_guard_test.go（打分缓存护栏）
// 在各自分支上互不干扰，合并到 main 后同包两个 TestMain **编译冲突**
// （multiple definitions of TestMain）⇒ 必须合进一个文件。
// （此点由 t_b7a8ed9c 在 scorecache_guard_test.go 顶部预先标注；小怡合并时未读文件
// 而漏看，由全套测试的 setup failed 拦下 —— 见 worklog 教训。）
//
// 护栏①：单元测试不得写到生产落盘点（t_e5997ca4）
// ---------------------------------------------------------------
// selfoptimize 包已有同款 TestMain 先例（曾实测：整套测试跑完把
// /var/lib/memoryweave/dashboard.json 写成测试数字）。
// gap close/repair 端点会触发 Dash.persist()（本地 JSON 兜底）⇒ 统一重定向到临时目录。
//
// 护栏②：默认关闭 distill 打分缓存（t_b7a8ed9c）
// ---------------------------------------------------------------
// 背景：distill 打分记忆化（0dc571d）+ Redis L2（36db9bb，键 zhiyi:distill-score:*，
// TTL 168h）后，**本包 E2E 测试（zz_commit_conflict_gate_test.go）会读写生产 Redis**：
// 第一次 run L2 miss → 真调 mock LLM 并把「测试内容哈希 → 结果」写进生产；
// 7 天内后续 run L2 hit → LLM 被静默短路 → 数 LLM 调用次数的断言（base+1）必挂。
// 实测 2026-10-17：TestCommitConflictGate_E2E 16.5s 固定 FAIL，
// 「expected >= 1 LLM distill calls, got 0」。
//
// 治法（对齐项目门禁规矩③：加缓存必须给该包 TestMain 加关闭开关）：
// Setenv ZHIYI_SCORE_CACHE=0 —— distill.getScoreCache 的 Once 闭包**活读 env**
// （包级变量在 init 时已定型，跨包设不了），本进程内缓存整体禁用：
// 不读 L2（LLM 真被调用，计数断言有覆盖）、不写 L2（不再污染生产）。
package routes
import (
"os"
"path/filepath"
"testing"
)
func TestMain(m *testing.M) {
// 护栏①：落盘点重定向到临时目录（宁可测试直接失败，也不写生产落盘点）
dir, err := os.MkdirTemp("", "routes-test-dash-*")
if err != nil {
panic(err)
}
_ = os.Setenv("ZHIYI_DASHBOARD_PATH", filepath.Join(dir, "dashboard.json"))
// 护栏②：关闭 distill 打分缓存（不读/不写生产 Redis L2）
_ = os.Setenv("ZHIYI_SCORE_CACHE", "0")
code := m.Run()
_ = os.RemoveAll(dir)
os.Exit(code)
}
go/internal/api/routes/triggers.go
+2 -4
View File
@@ -42,8 +42,8 @@ type Trigger struct {
Condition string `json:"condition"`
Urgency float64 `json:"urgency"` // 0-1，越大越紧急
Active bool `json:"active"`
Paused bool `json:"paused"` // kill-switch
Cooldown string `json:"cooldown"` // 冷却时间
Paused bool `json:"paused"` // kill-switch
Cooldown string `json:"cooldown"` // 冷却时间
FailCount int `json:"fail_count"` // 连续失败计数
LastFiredAt time.Time `json:"last_fired_at,omitempty"`
Description string `json:"description"`
@@ -189,5 +189,3 @@ func (tm *TriggerManager) RecordFail(id string) {
}
}
}
go/internal/api/routes/tuning.go
+250 -42
View File
@@ -2,11 +2,16 @@
package routes
import (
"encoding/json"
"log"
"net/http"
"os"
"strings"
"sync"
"time"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// TuningConfig 可自动调优的参数
@@ -20,7 +25,16 @@ type TuningConfig struct {
ConsolidateAfter int `json:"consolidate_after"` // N 条蒸馏后触发整合
// 历史调参记录
history []TuningEvent
history []TuningEvent
// lastSkipped 上一次 AutoTune 里「因指标不可用而跳过」的规则与原因。
// 让外部能区分「健康所以没调」与「数据不可用所以没调」——后者需要修数据源，不是好事。
lastSkipped []string
// lastMoveAt 每个参数上一次被改动的时间 —— 用于冷却（治棘轮）。
lastMoveAt map[string]time.Time
// persistEnabled 仅全局 Tuner 为 true；测试里构造的实例为 false ⇒ 不写盘。
persistEnabled bool
}
type TuningEvent struct {
@@ -32,11 +46,149 @@ type TuningEvent struct {
}
var Tuner = &TuningConfig{
Diversity: 0.5,
// ⚠️ 初值必须等于**真实消费方的默认值**，否则接线当天就改变生产行为：
// Diversity 对齐 storage.DefaultMMRDiversity() 的 0.3（core.go 原硬编码），原为 0.5。
Diversity: 0.3,
DecayRate: 0.015,
GapThreshold: 3,
DistillInterval: 5,
ConsolidateAfter: 50,
lastMoveAt: map[string]time.Time{},
persistEnabled: true,
}
// tuneCooldown 同一参数的调参冷却时间。
// 为什么需要：**AutoTune 不幂等** —— 同一判据每调一次就推一步（实测连跑两次：
// decay_rate 0.015→0.018→0.0216、distill_interval 5→4→3），直到撞上限。
// 闭环每天跑一次 ⇒ 几天内把参数顶到极值。冷却把「持续推进」限制成
// 「同一指标须持续越界多个窗口，才多次调整」。
const tuneCooldown = 6 * time.Hour
// minTuningSamples 调参判据的最小样本数。
// 为什么需要：小样本的比率噪声极大 —— 实测现网 recall_usefulness_rate 只有 9 个样本，
// 8 好 1 坏 = 0.89，再来 1 个好评就 > 0.9 ⇒ 触发「降低 diversity」直接改生产参数。
// 少样本不是证据。
const minTuningSamples = 30
// ratioFor 取一个「可用于调参」的比率指标，不可用则返回 ok=false。
//
// 约定（internal/selfoptimize/selfoptimize.go:248-322）：
//
// <name>_rate —— 比率值；**分母退化时返回 -1**（metricNA），既不是 0 也不是 1
// <name>_samples —— 该比率的分母样本数
// <name>_valid —— 分母是否非退化
//
// ⚠️ AutoTune 原先只比较数值，无视这套约定 ⇒ `-1` 会让规则对「无数据」**恒真**：
//
// gap_closure_rate = -1 < 0.5 ⇒「降低 gap 阈值」每轮都触发（按垃圾指标改生产参数）
// recall_usefulness_rate 样本 9 条 ⇒ 一次偶然就改 Diversity
//
// 本函数把「无数据 / 退化 / 样本不足」三类一律判为不可用 —— 宁可不动。
// ⚠️ 命名不是统一的：比率键为 `<base>_rate`，而 *样本/有效* 键挂在 **base** 上
// 而不是带 _rate 的那个串上 —— 实际键是 `recall_usefulness_samples`，
// 不是 `recall_usefulness_rate_samples`（我第一版就按后者拼，护栏静默失效、
// 参数照样被改；新加的 tuning_guard_test.go 当场逮住）。
// 且 `avg_distill_loss` 这类**值键本身不带 _rate 后缀** ⇒ 统一用 TrimSuffix 推 base。
func ratioFor(metrics map[string]float64, valueKey string) (float64, bool) {
base := strings.TrimSuffix(valueKey, "_rate")
v, ok := metrics[valueKey]
if !ok || v < 0 {
return 0, false // 缺失 或 -1 哨兵 = 无数据
}
if valid, ok := metrics[base+"_valid"]; ok && valid == 0 {
return 0, false // 分母退化
}
if samples, ok := metrics[base+"_samples"]; ok && samples < minTuningSamples {
return 0, false // 样本不足以支撑判断
}
return v, true
}
// canMove 判断某参数当前是否允许改动（冷却窗口内不许重复动 —— 治棘轮）。
func (tc *TuningConfig) canMove(param string) bool {
last, ok := tc.lastMoveAt[param]
return !ok || time.Since(last) >= tuneCooldown
}
func (tc *TuningConfig) markMove(param string) {
if tc.lastMoveAt == nil {
tc.lastMoveAt = map[string]time.Time{}
}
tc.lastMoveAt[param] = time.Now()
}
// pushToConsumers 把当前参数推给**真实消费方**。
// 🔴 这一步是「调参有没有用」的分水岭：2026-10-14 实测，此前 Tuner 的全部字段
// 没有任何读者（全仓只有 3 处路由注册引用它）⇒ 调参改了数字、行为零变化。
func (tc *TuningConfig) pushToConsumers() {
storage.SetDefaultMMRDiversity(tc.Diversity)
selfoptimize.SetGapThreshold(tc.GapThreshold)
}
// tuningStatePath 持久化路径（可用 ZHIYI_TUNING_STATE 覆盖，便于测试/隔离）。
func tuningStatePath() string {
if p := os.Getenv("ZHIYI_TUNING_STATE"); p != "" {
return p
}
return "/var/lib/memoryweave/tuning-state.json"
}
type tuningState struct {
Diversity float64 `json:"diversity"`
GapThreshold int `json:"gap_threshold"`
LastMoveAt map[string]string `json:"last_move_at"`
UpdatedAt string `json:"updated_at"`
}
// persist 落盘（失败只告警，不影响调参本身）。
func (tc *TuningConfig) persist() {
if !tc.persistEnabled {
return
}
st := tuningState{Diversity: tc.Diversity, GapThreshold: tc.GapThreshold,
LastMoveAt: map[string]string{}, UpdatedAt: time.Now().Format(time.RFC3339)}
for k, v := range tc.lastMoveAt {
st.LastMoveAt[k] = v.Format(time.RFC3339)
}
data, err := json.MarshalIndent(st, "", " ")
if err != nil {
log.Printf("[tuning] 序列化失败: %v", err)
return
}
if err := os.WriteFile(tuningStatePath(), data, 0o644); err != nil {
log.Printf("[tuning] 落盘失败: %v", err)
}
}
// load 启动时载入持久化参数（无文件则用默认值），并立即接线到消费方。
// 没有这一步，重启即回默认 ⇒ 调参成果每次重启清零。
func (tc *TuningConfig) load() {
data, err := os.ReadFile(tuningStatePath())
if err == nil {
var st tuningState
if json.Unmarshal(data, &st) == nil {
if st.Diversity > 0 {
tc.Diversity = st.Diversity
}
if st.GapThreshold > 0 {
tc.GapThreshold = st.GapThreshold
}
for k, v := range st.LastMoveAt {
if t, e := time.Parse(time.RFC3339, v); e == nil {
if tc.lastMoveAt == nil {
tc.lastMoveAt = map[string]time.Time{}
}
tc.lastMoveAt[k] = t
}
}
log.Printf("[tuning] 已载入持久化参数 diversity=%.3f gap_threshold=%d（%s）",
tc.Diversity, tc.GapThreshold, st.UpdatedAt)
}
}
tc.mu.Lock()
tc.pushToConsumers()
tc.mu.Unlock()
}
// AutoTune 基于仪表盘指标自动调参
@@ -45,61 +197,103 @@ func (tc *TuningConfig) AutoTune(metrics map[string]float64) []TuningEvent {
defer tc.mu.Unlock()
var events []TuningEvent
skipped := make([]string, 0, 5)
// 记一次「本规则为什么没跑」—— 让调用方能解释「为什么没调参」，
// 而不是只回 no_changes_needed（后者无法区分「健康」与「数据不可用」）。
note := func(rule, why string) {
skipped = append(skipped, rule+": "+why)
}
// 1. 召回命中率 < 0.5 → 提高 diversity（扩大搜索范围）
if hitRate, ok := metrics["recall_hit_rate"]; ok && hitRate < 0.5 {
// 1. 召回质量低 → 提高 diversity（扩大搜索范围）。
// 2026-10-17：原信号 recall_hit_rate 已退役（恒=1、从不及 0.5 ⇒ 本安全阀长期死寂）。
// 改用 recall_usefulness_rate（返回且被使用）作为召回质量的实时信号：< 0.5 ⇒ 召回太窄、扩大范围。
hitRate, hitOK := ratioFor(metrics, "recall_usefulness_rate")
if !hitOK {
note("rule1_usefulness", "指标不可用（无数据/退化/样本<20）")
}
if hitOK && hitRate < 0.5 && !tc.canMove("diversity") {
note("rule1_usefulness", "冷却中（距上次调整 <"+tuneCooldown.String()+"）")
}
if hitOK && hitRate < 0.5 && tc.canMove("diversity") {
newDiversity := tc.Diversity + 0.1
if newDiversity > 1.0 {
newDiversity = 1.0
}
events = append(events, recordTuning(tc, "diversity", tc.Diversity, newDiversity, "recall_hit_rate < 0.5"))
events = append(events, recordTuning(tc, "diversity", tc.Diversity, newDiversity, "recall_usefulness_rate < 0.5"))
tc.Diversity = newDiversity
tc.markMove("diversity")
}
// 2. 召回有用率 > 0.9 → 降低 diversity（更精准）
if usefulRate, ok := metrics["recall_usefulness_rate"]; ok && usefulRate > 0.9 {
usefulRate, usefulOK := ratioFor(metrics, "recall_usefulness_rate")
if !usefulOK {
note("rule2_usefulness", "指标不可用（无数据/退化/样本<30）")
}
if usefulOK && usefulRate > 0.9 && !tc.canMove("diversity") {
note("rule2_usefulness", "冷却中（距上次调整 <"+tuneCooldown.String()+"）")
}
if usefulOK && usefulRate > 0.9 && tc.canMove("diversity") {
newDiversity := tc.Diversity - 0.05
if newDiversity < 0.1 {
newDiversity = 0.1
}
events = append(events, recordTuning(tc, "diversity", tc.Diversity, newDiversity, "recall_usefulness_rate > 0.9"))
tc.Diversity = newDiversity
tc.markMove("diversity")
}
// 3. 废弃率 > 5/day → 提高衰减率（加快清理）
if deprecated, ok := metrics["deprecated_per_day"]; ok && deprecated > 5 {
newDecay := tc.DecayRate * 1.2
if newDecay > 0.05 {
newDecay = 0.05
}
events = append(events, recordTuning(tc, "decay_rate", tc.DecayRate, newDecay, "deprecated_per_day > 5"))
tc.DecayRate = newDecay
}
// 3.（2026-10-14 移除）废弃率 → 提高衰减率。
// 移除理由：这个方向危险。governance.NewForgetter 上方注释记载：
// 「2026-09-07 方案A: 0.015→0.03 曾致误删(36天库龄下 0-recall 长记忆全被清, 405字CNB经验被删)」。
// 自动调参朝这个方向推 = 把那条事故路重新铺上；而收益只是「加快清理」。
// 若要恢复，必须先有「误删可回滚 + 删除前抽样人工确认」的保护，不能只靠阈值。
// 4. 缺口闭环率 < 0.5 → 降低 gap 阈值
if gapRate, ok := metrics["gap_closure_rate"]; ok && gapRate < 0.5 {
gapRate, gapOK := ratioFor(metrics, "gap_closure_rate")
if !gapOK {
note("rule4_gap_threshold", "指标不可用（无数据/退化/样本<30）")
}
if gapOK && gapRate < 0.5 && !tc.canMove("gap_threshold") {
note("rule4_gap_threshold", "冷却中（距上次调整 <"+tuneCooldown.String()+"）")
}
if gapOK && gapRate < 0.5 && tc.canMove("gap_threshold") {
newThreshold := tc.GapThreshold - 1
if newThreshold < 2 {
newThreshold = 2
}
events = append(events, recordTuningInt(tc, "gap_threshold", tc.GapThreshold, newThreshold, "gap_closure_rate < 0.5"))
tc.GapThreshold = newThreshold
tc.markMove("gap_threshold")
}
// 5. 蒸馏损失 > 0.3 → 更频繁蒸馏
if loss, ok := metrics["avg_distill_loss"]; ok && loss > 0.3 {
newInterval := tc.DistillInterval - 1
if newInterval < 1 {
newInterval = 1
}
events = append(events, recordTuningInt(tc, "distill_interval", tc.DistillInterval, newInterval, "avg_distill_loss > 0.3"))
tc.DistillInterval = newInterval
}
// 5.（2026-10-14 移除）蒸馏损失 → 缩短蒸馏间隔。
// 移除理由：**没有正确的消费方**。distill/engine.go:265 的 batchTimeout（5min）是
// 「队列冻结兜底 ticker」（2026-10-06 修的「生产者停止即永久冻结」安全网），
// **不是蒸馏节奏**。调安全网的周期治不了蒸馏质量 —— 接到错的地方比不接更坏。
// 若将来真有「蒸馏节奏」消费者，再恢复本规则并接对目标。
tc.history = append(tc.history, events...)
tc.lastSkipped = skipped
if len(events) > 0 {
tc.pushToConsumers() // 改了就必须接线，否则等于没改
tc.persist() // 不落盘则重启即丢
}
return events
}
// init 启动时载入持久化参数并接线（没有它：重启回默认 + 调参不生效）。
func init() { Tuner.load() }
// LastSkipped 返回上一次调参里被跳过的规则及原因（只读快照）。
func (tc *TuningConfig) LastSkipped() []string {
tc.mu.RLock()
defer tc.mu.RUnlock()
out := make([]string, len(tc.lastSkipped))
copy(out, tc.lastSkipped)
return out
}
func recordTuning(tc *TuningConfig, param string, oldVal, newVal float64, reason string) TuningEvent {
return TuningEvent{
Parameter: param,
@@ -135,7 +329,8 @@ func (tc *TuningConfig) StatusHandler(w http.ResponseWriter, r *http.Request) {
"distill_interval": tc.DistillInterval,
"consolidate_after": tc.ConsolidateAfter,
},
"history": tc.history,
"history": tc.history,
"last_skipped": tc.lastSkipped,
})
}
@@ -145,7 +340,11 @@ func (tc *TuningConfig) RunHandler(w http.ResponseWriter, r *http.Request) {
events := tc.AutoTune(metrics)
if len(events) == 0 {
respond(w, 200, map[string]string{"status": "no_changes_needed"})
respond(w, 200, map[string]interface{}{
"status": "no_changes_needed",
// 区分「健康」与「数据不可用」：后者要修数据源，而不是当作一切正常。
"skipped": tc.lastSkipped,
})
} else {
respond(w, 200, map[string]interface{}{
"status": "tuned",
@@ -157,25 +356,34 @@ func (tc *TuningConfig) RunHandler(w http.ResponseWriter, r *http.Request) {
// POST /api/v1/tuning/analytics — 运行因果分析
func (tc *TuningConfig) AnalyticsHandler(w http.ResponseWriter, r *http.Request) {
// 基于指标间的关系给出建议
m := selfoptimize.Dash.Metrics()
suggestions := []string{}
if m["recall_hit_rate"] < 0.5 && m["avg_distill_loss"] > 0.3 {
suggestions = append(suggestions, "蒸馏质量低导致召回率低 — 建议检查 Embedding 模型")
}
if m["deprecated_per_day"] > 10 {
suggestions = append(suggestions, "废弃率过高 — 正在流失大量记忆，检查冲突检测阈值")
}
if m["gap_closure_rate"] < 0.3 {
suggestions = append(suggestions, "缺口闭环率过低 — Agent 未回应缺口学习请求")
}
if m["auto_resolve_rate"] < 0.5 {
suggestions = append(suggestions, "自动裁决率低 — 规则覆盖不全，考虑扩展策略")
}
suggestions := AnalyticsSuggestions(m)
respond(w, 200, map[string]interface{}{
"metrics": m,
"suggestions": suggestions,
})
}
// AnalyticsSuggestions 依据指标间关系给出调优建议（纯函数，便于单测反例：N/A 不产生建议）。
//
// ⚠️ 每条建议的比率比较都必须先判 N/A（ratioFor 已封装：-1 哨兵 / valid=0 / 样本不足 ⇒ 不可用）。
// 若直接 `m[key] < 阈值`，-1 会恒真 ⇒ 无数据也误报建议（本卡 t_c70f385c 事故面）。
// deprecated_per_day 是计数（恒 ≥0，非比率），不走 ratioFor。
func AnalyticsSuggestions(m map[string]float64) []string {
suggestions := []string{}
if hr, ok := ratioFor(m, "recall_usefulness_rate"); ok && hr < 0.5 {
if dl, ok2 := ratioFor(m, "avg_distill_loss"); ok2 && dl > 0.3 {
suggestions = append(suggestions, "蒸馏质量低导致召回率低 — 建议检查 Embedding 模型")
}
}
if m["deprecated_per_day"] > 10 {
suggestions = append(suggestions, "废弃率过高 — 正在流失大量记忆，检查冲突检测阈值")
}
if g, ok := ratioFor(m, "gap_closure_rate"); ok && g < 0.3 {
suggestions = append(suggestions, "缺口闭环率过低 — Agent 未回应缺口学习请求")
}
if a, ok := ratioFor(m, "auto_resolve_rate"); ok && a < 0.5 {
suggestions = append(suggestions, "自动裁决率低 — 规则覆盖不全，考虑扩展策略")
}
return suggestions
}
go/internal/api/routes/tuning_analytics_test.go
+38
View File
@@ -0,0 +1,38 @@
// AnalyticsSuggestions N/A 哨兵护栏 —— 反例 + 正向对照。
//
// 本卡 t_c70f385c：AnalyticsHandler 的建议 builder 原为裸 `m[key] < 阈值`，
// -1 哨兵（样本不足/越界被拦）会让 `-1 < 0.5` 恒真 ⇒ 无数据也误报建议。
// 现统一走 ratioFor（已封装 N/A + valid=0 + 样本不足判定）。
package routes
import "testing"
// TestAnalyticsSuggestions_NA_NoFiring 反例：全 N/A 哨兵（-1）不产生任何建议（避免误报）。
func TestAnalyticsSuggestions_NA_NoFiring(t *testing.T) {
na := map[string]float64{
"recall_usefulness_rate": -1, "recall_usefulness_samples": 0, "recall_usefulness_valid": 0,
"avg_distill_loss": -1, "avg_distill_loss_samples": 0, "avg_distill_loss_valid": 0,
"gap_closure_rate": -1, "gap_closure_samples": 0, "gap_closure_valid": 0,
"auto_resolve_rate": -1, "auto_resolve_samples": 0, "auto_resolve_valid": 0,
"deprecated_per_day": 0,
}
if s := AnalyticsSuggestions(na); len(s) != 0 {
t.Fatalf("全 N/A 不应产生任何建议，实际 %d 条: %v", len(s), s)
}
}
// TestAnalyticsSuggestions_ValidLow 正向对照：有效且低于阈值时产生建议（护栏没把功能焊死）。
func TestAnalyticsSuggestions_ValidLow(t *testing.T) {
m := map[string]float64{
"recall_usefulness_rate": 0.2, "recall_usefulness_samples": 100, "recall_usefulness_valid": 1,
"gap_closure_rate": 0.1, "gap_closure_samples": 100, "gap_closure_valid": 1,
"auto_resolve_rate": 0.2, "auto_resolve_samples": 100, "auto_resolve_valid": 1,
"avg_distill_loss": 0.1, "avg_distill_loss_samples": 100, "avg_distill_loss_valid": 1,
"deprecated_per_day": 0,
}
s := AnalyticsSuggestions(m)
// 至少触发「gap 闭环率过低」+「自动裁决率低」两条
if len(s) < 2 {
t.Fatalf("有效且低于阈值应产生 ≥2 条建议，实际 %d 条: %v", len(s), s)
}
}
go/internal/api/routes/tuning_guard_test.go
+125
View File
@@ -0,0 +1,125 @@
package routes
import (
"testing"
"time"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
"github.com/xiaoxue/memoryweave/internal/storage"
)
// TestAutoTuneGuard_SentinelAndSamples 双向验证护栏：
// ① 无数据（-1 哨兵）不许改参数 —— 这是事故面：gap_closure_rate=-1 会让
//
// 「降低 gap 阈值」每轮恒真。
//
// ② 样本不足（<30）不许改参数 —— 少样本比率噪声极大。
// ③ 数据健康时仍然要能调 —— 否则等于把功能焊死。
func TestAutoTuneGuard_SentinelAndSamples(t *testing.T) {
// ① 哨兵值：全 -1 ⇒ 一个事件都不许有
tc := &TuningConfig{Diversity: 0.5, DecayRate: 0.015, GapThreshold: 3, DistillInterval: 5, ConsolidateAfter: 50}
na := map[string]float64{
"gap_closure_rate": -1,
"gap_closure_samples": 0,
"gap_closure_valid": 0,
"recall_usefulness_rate": -1,
"avg_distill_loss": -1,
"recall_usefulness_valid": 0,
"avg_distill_loss_valid": 0,
}
if ev := tc.AutoTune(na); len(ev) != 0 {
t.Fatalf("哨兵值(-1)不应触发任何调参，实际触发 %d 条: %+v", len(ev), ev)
}
if tc.GapThreshold != 3 || tc.Diversity != 0.5 {
t.Fatalf("参数被改动：GapThreshold=%d Diversity=%v", tc.GapThreshold, tc.Diversity)
}
if len(tc.LastSkipped()) == 0 {
t.Fatal("应记录跳过原因（否则无法区分『健康』与『数据不可用』）")
}
// ② 样本不足：比率本身达标（>0.9）但只有 9 个样本 ⇒ 不许动
tc2 := &TuningConfig{Diversity: 0.5, DecayRate: 0.015, GapThreshold: 3, DistillInterval: 5, ConsolidateAfter: 50}
low := map[string]float64{
"recall_usefulness_rate": 0.95,
"recall_usefulness_samples": 9,
"recall_usefulness_valid": 1,
}
if ev := tc2.AutoTune(low); len(ev) != 0 {
t.Fatalf("样本 9<30 不应触发调参，实际 %d 条: %+v", len(ev), ev)
}
// ③ 数据健康 ⇒ 必须能调（证明护栏没把功能焊死）
tc3 := &TuningConfig{Diversity: 0.5, DecayRate: 0.015, GapThreshold: 3, DistillInterval: 5, ConsolidateAfter: 50}
good := map[string]float64{
"recall_usefulness_rate": 0.95,
"recall_usefulness_samples": 100,
"recall_usefulness_valid": 1,
}
ev := tc3.AutoTune(good)
if len(ev) != 1 {
t.Fatalf("健康数据应触发 1 条调参，实际 %d 条", len(ev))
}
if tc3.Diversity >= 0.5 {
t.Fatalf("Diversity 应被降低，实际 %v", tc3.Diversity)
}
}
// TestAutoTuneCooldown 冷却：同一参数在冷却窗口内不许被重复推进（治棘轮）。
// 事故面（实测）：AutoTune 不幂等 —— 连跑两次 decay 0.015→0.018→0.0216。
func TestAutoTuneCooldown(t *testing.T) {
tc := &TuningConfig{Diversity: 0.5, DecayRate: 0.015, GapThreshold: 3, DistillInterval: 5, ConsolidateAfter: 50}
m := map[string]float64{
"recall_usefulness_rate": 0.95,
"recall_usefulness_samples": 100,
"recall_usefulness_valid": 1,
}
if ev := tc.AutoTune(m); len(ev) != 1 {
t.Fatalf("第一次应调 1 条，实际 %d", len(ev))
}
first := tc.Diversity
if ev := tc.AutoTune(m); len(ev) != 0 {
t.Fatalf("冷却窗口内不应再调，实际 %d 条: %+v", len(ev), ev)
}
if tc.Diversity != first {
t.Fatalf("冷却期内参数被改动：%v → %v（棘轮复发）", first, tc.Diversity)
}
}
// TestAutoTunePushesToConsumers 推送：改完参数必须真的到消费方手里，
// 否则就是「调参改了没人读的数字」（2026-10-14 实测的原状）。
func TestAutoTunePushesToConsumers(t *testing.T) {
orig := storage.DefaultMMRDiversity()
defer storage.SetDefaultMMRDiversity(orig)
tc := &TuningConfig{Diversity: 0.5, GapThreshold: 3}
m := map[string]float64{
"gap_closure_rate": 0.1,
"gap_closure_samples": 100,
"gap_closure_valid": 1,
}
before := selfoptimize.GapThreshold()
ev := tc.AutoTune(m)
if len(ev) != 1 {
t.Fatalf("应触发 1 条（gap 阈值），实际 %d", len(ev))
}
if tc.GapThreshold != before-1 {
t.Fatalf("期望阈值 %d→%d，实际 %d", before, before-1, tc.GapThreshold)
}
if got := selfoptimize.GapThreshold(); got != tc.GapThreshold {
t.Fatalf("没推到消费方：selfoptimize.GapThreshold()=%d，Tuner=%d", got, tc.GapThreshold)
}
}
// TestTuningPersistence 持久化：换实例后能从盘上读回（否则重启即回默认）。
func TestTuningPersistence(t *testing.T) {
dir := t.TempDir()
t.Setenv("ZHIYI_TUNING_STATE", dir+"/tuning-state.json")
a := &TuningConfig{Diversity: 0.42, GapThreshold: 4, persistEnabled: true, lastMoveAt: map[string]time.Time{}}
a.persist()
b := &TuningConfig{Diversity: 0.3, GapThreshold: 3, lastMoveAt: map[string]time.Time{}}
b.load()
if b.Diversity != 0.42 || b.GapThreshold != 4 {
t.Fatalf("未读回持久化参数：diversity=%v gap=%v", b.Diversity, b.GapThreshold)
}
}
go/internal/api/routes/ws.go
+3 -3
View File
@@ -15,9 +15,9 @@ var upgrader = websocket.Upgrader{
// WSManager 管理所有 WebSocket 连接，支持按 AgentID 定向推送
type WSManager struct {
mu sync.RWMutex
clients map[string]map[*websocket.Conn]bool // agentID → 连接集合
connMu sync.Map // per-conn mutex: *websocket.Conn → *sync.Mutex
mu sync.RWMutex
clients map[string]map[*websocket.Conn]bool // agentID → 连接集合
connMu sync.Map // per-conn mutex: *websocket.Conn → *sync.Mutex
}
// 全局 WebSocket 管理器
go/internal/api/routes/zz_commit_conflict_gate_test.go
+8 -1
View File
@@ -65,7 +65,7 @@ func (m *mockLance) GetTopByQuality(agentID string, limit int) ([]models.MemoryR
}
func (m *mockLance) Stats() (map[string]interface{}, error) { return map[string]interface{}{}, nil }
func (m *mockLance) SoftDelete(id, reason string) error { return nil }
func (m *mockLance) PurgeInvalid() (int64, error) { return 0, nil }
func (m *mockLance) PurgeInvalid() (int64, error) { return 0, nil }
func (m *mockLance) SoftDeleteBatch(table string, ids []string, updatedAt string) (int64, error) {
return 0, nil
}
@@ -78,6 +78,13 @@ func (m *mockLance) Backup(path string) error { r
func (m *mockLance) GetAuditLog(limit int) ([]map[string]interface{}, error) { return nil, nil }
func (m *mockLance) IncrementUseful(id string) error { return nil }
func (m *mockLance) IncrementNotUseful(id string) error { return nil }
// GA-P0-1 (t_718d8707)：拆分字段
func (m *mockLance) IncrementHumanNotUseful(id string) error { return nil }
func (m *mockLance) AppendHitEvent(memoryID, outcome, reason string) error { return nil }
func (m *mockLance) CountHitEvents(memoryID, outcome string, since time.Time) (int, error) { return 0, nil }
func (m *mockLance) GetHitEvents(memoryID string, limit int) ([]models.HitEvent, error) { return nil, nil }
func (m *mockLance) IncrementDedupDownweight(id string) error { return nil }
func (m *mockLance) UpdateMemoryContent(id, newContent, source string) error { return nil }
func (m *mockLance) InsertMemory(rec models.MemoryRecord) error { return nil }
func (m *mockLance) Insert(table string, record any) error { return nil }
go/internal/api/server.go
+327 -58
View File
@@ -21,10 +21,14 @@ import (
"github.com/xiaoxue/memoryweave/internal/api/routes"
"github.com/xiaoxue/memoryweave/internal/distill"
"github.com/xiaoxue/memoryweave/internal/governance"
"github.com/xiaoxue/memoryweave/internal/memprotect"
"github.com/xiaoxue/memoryweave/internal/metrics"
"github.com/xiaoxue/memoryweave/internal/models"
"github.com/xiaoxue/memoryweave/internal/pattern"
"github.com/xiaoxue/memoryweave/internal/peer"
"github.com/xiaoxue/memoryweave/internal/redact"
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
"github.com/xiaoxue/memoryweave/internal/skillgen"
"github.com/xiaoxue/memoryweave/internal/storage"
)
@@ -53,11 +57,28 @@ func NewServer() http.Handler {
// 存储后端
ldb := initStorageBackend(os.Getenv("STORAGE_BACKEND"), emb)
// 2026-10-13 (t_e9a4d18f P2) 常设答案库（独立 SQLite，Hindsight mental models）。
// 只读写不主动注入 ⇒ 部署后行为零变化。注入由 zhiyi-standing-answers.py 生成后
// 插件侧决定是否直读。路径可经 ZHIYI_STANDING_DB 覆盖。
storage.InitStandingStore(os.Getenv("ZHIYI_STANDING_DB"))
// 召回元数据「累积延迟更新」缓冲（2026-09-12 优化B）
// 读路径不再逐条写 LanceDB（MVCC 每写一行一个版本 → _versions 膨胀根因），
// 改为窗口内合并 + 单事务批量提交（每批 1 个版本）。
storage.InitRecallWriteBuffer(ldb)
// 2026-10-14 (t_2afae95e) FTS 词面通道：给 TF-IDF 索引挂全量数据源（ScanAll，
// 只读 IPC lancedb_scan_all；不建 LanceDB tantivy 索引文件 ⇒ 零写 LanceDB）。
// 索引本体在 storage 包内后台建（启动 3s 首建 + 6h 周期 + 写路径标脏）。
// 门控 ZHIYI_RECALL_FTS 默认关 ⇒ 接线了也不改召回行为（AC4 零变化）。
if rc, ok := ldb.(*storage.RustLanceDBClient); ok {
storage.FtsProvider.FtsLdb = rc.ScanAll
log.Printf("[fts] 词面通道数据源已挂（ScanAll）；门控 ZHIYI_RECALL_FTS=%s（默认关）",
os.Getenv("ZHIYI_RECALL_FTS"))
} else {
log.Printf("[fts] 后端非 RustLanceDBClient（%T）⇒ 词面通道数据源未挂（关态无影响）", ldb)
}
// 软删除累积延迟更新缓冲（2026-09-12 优化C）
// 软删除操作不再逐条写 LanceDB（每写一行一个版本 → _versions 膨胀），
// 改为窗口内合并 + 单事务批量提交（每批 1 个版本）。
@@ -147,6 +168,44 @@ func NewServer() http.Handler {
consolPipe := routes.NewConsolidationPipeline(ldb, graphStore, conflictDetector)
consolPipe.SetDataDir("/var/lib/memoryweave/lancedb", "/var/lib/memoryweave/graph.db")
// ─── t_d32e5f8a L2 模式检测（MemOS 血统）─────────────────────────
// 复活 L1→L2 pattern 蒸馏（原 Python daemon main_loop 退役后停摆）：
// pattern 节点存 graph_nodes(type='pattern')，与现有 85 存量同表，不另开新表。
// modernc sqlite 短命单发开/关（UpsertPatterns/ListPatterns 开一次用一次即关），
// 不持长连接、不碰 state.db —— 规避当年退役根因。
// 召回注入 env 门控 ZHIYI_PATTERN_RECALL，默认 0 ⇒ 不注册 Provider，行为零变化。
graphPath := os.Getenv("GRAPH_PATH")
if graphPath == "" {
graphPath = "/var/lib/memoryweave/graph.db"
}
patternStore := pattern.NewGraphPatternStore(graphPath)
patternProvider := pattern.NewPatternProvider(patternStore, pattern.NewEmbedderProvider(emb))
patternAPI := routes.NewPatternAPI(patternStore, patternProvider, func() storage.LanceDB { return ldb })
// L3 skill 草稿（t_fcadee04）：装配生成器 + skills 表（graph.db 同库）+ 落盘根。
// 显式 API（draft/promote）触发，不挂 cron、不改注入行为 ⇒ 默认零行为变化。
patternAPI.SkillStore = skillgen.NewStore(graphPath)
patternAPI.Generator = skillgen.NewLocal2BGenerator()
patternAPI.AttachmentsDir = os.Getenv("ZHIYI_SKILL_ATTACHMENTS")
if os.Getenv("ZHIYI_PATTERN_RECALL") == "1" {
storage.PatternRecallProvider = patternProvider.Match
log.Printf("[zhiyid] L2 模式召回注入已启用（ZHIYI_PATTERN_RECALL=1）")
} else {
log.Printf("[zhiyid] L2 模式召回注入默认关（ZHIYI_PATTERN_RECALL 未设/≠1 ⇒ 零行为变化）")
}
// ─── t_f8fc97e6 P3 Peer Representation（Honcho 血统，设计 §5）────────────
// 四层推理画像（explicit→deductive→inductive→abductive）存 graph.db 的 peers 表。
// refresh/explain 是显式 API（不挂 cron）；召回注入 env 门控 ZHIYI_PEER_RECALL 默认 0
// ⇒ 主召回管线默认零行为变化（AC2）。推理引擎生产复用本地 2B（8081 免费腿）。
peerStore := peer.NewStore(graphPath)
peerAPI := routes.NewPeerAPI(peerStore, peer.NewLocal2BReasoner(), func() storage.LanceDB { return ldb }, graphStore)
if os.Getenv("ZHIYI_PEER_RECALL") == "1" {
storage.PeerRecallProvider = peerAPI.GetRecallResults
log.Printf("[zhiyid] P3 Peer 推理画像召回注入已启用（ZHIYI_PEER_RECALL=1）")
} else {
log.Printf("[zhiyid] P3 Peer 推理画像召回注入默认关（ZHIYI_PEER_RECALL 未设/≠1 ⇒ 零行为变化）")
}
// Obsidian
obsidian := routes.NewObsidianSyncer("", ldb)
@@ -172,27 +231,50 @@ func NewServer() http.Handler {
Content: input.Content, Facts: result.Facts,
Entities: entityNames, Namespace: input.Namespace,
EpisodeID: input.EpisodeID,
Source: input.Source, // 2026-10-12 t_67d0279a 方案A：来源分档透传（auditSource 前缀归一后比对）
})
// 回写蒸馏产物到记忆库（LanceDB）
// 2026-09-07 方案B 质量门槛: 碎片(<20字)/噪声句(状态汇报/桥接/reflection)不入库,
// 与已有记忆完全重复跳过(蒸馏直写不走 commit exact_dup, 需本层查重)。
for _, fact := range result.Facts {
// 2026-09-10 P0：直写路径同样脱敏（这里绕过 FilterQualityFacts，
// 事故里泄漏进镜像的记忆正是从这条路径入库的）。
// 2026-10-13 t_1c12e000：distilled facts 是 memories 表的唯一写入点。
// 只要有任何一条真的 InsertMemory 成功 ⇒ 该 namespace 的 query 缓存作废
//（"先写再问" 场景：写完之后立刻可被之前问过但当时还没内容的答案命中）。
factsLanded := false
// 2026-10-13 t_286d1310: 写库闸门同样感知准入分诊结论（lane）。
// 此前这里独立跑 IsQualityFact 长度启发式——lane=keep 的决策类内容，
// 其 <20 字碎片在 insert 前仍被第三次独立丢弃（t_2ae69bb2 只穿透到
// fact 级，没穿透到写库级）⇒ DB 里 derived_from=<episode> 0 行。
// 复用 engine.go 同一函数 FilterQualityFactsWithLane（判据单一入口，
// 不复制）：
// LaneKeep → 只保留 纯疑问/状态汇报 两条硬否定，跳过全部长度类规则
// LaneDrop / LaneObserve → 委托 FilterQualityFacts，与 IsQualityFact 逐字一致
// ClassifyAdmission 是确定性分诊（同一输入永远同一 lane），此处重算即
// engine.go:537 在蒸馏时算出的同一条 lane。
lane, laneWhy := distill.ClassifyAdmission(input.Content)
writeFacts := distill.FilterQualityFactsWithLane(result.Facts, lane)
if before := len(result.Facts); before > 0 && len(writeFacts) != before {
log.Printf("[distill][LANE] write-gate dropped %d/%d facts for %s (lane=%s, %s)",
before-len(writeFacts), before, input.EpisodeID, lane, laneWhy)
}
for _, fact := range writeFacts {
// 2026-09-10 P0：直写路径同样脱敏（FilterQualityFactsWithLane 已内部脱敏，
// 这里再脱一次为幂等保险——防止任何中间层注入明文密钥。事故里泄漏进
// 镜像的记忆正是从这条路径入库的）。
fact = redact.RedactSecrets(fact)
if !distill.IsQualityFact(fact) {
continue // 碎片/噪声过滤
}
// 查重: 同 namespace 已存在**语义等价**记忆 → 跳过
// 必须用 cosine 近重复判据（≥0.98），不能只比字符串相等——
// 否则 "牧尘在招商局工作" 与 "牧尘在招商局工作。"（多一个句号）
// 会被判为两条不同事实双双入库，造成近重复堆积。
var skip bool
if qvec, eErr := emb.EncodeSingle(fact); eErr == nil {
if sim, _ := ldb.Search("memories", qvec, 5, input.Namespace); len(sim) > 0 {
for _, ex := range sim {
if ex.Content == fact || cosineSimilarity(qvec, ex.Vector) >= 0.98 {
var qvec []float32
var sim []models.MemoryRecord
if v, eErr := emb.EncodeSingle(fact); eErr == nil {
qvec = v
if found, _ := ldb.Search("memories", v, 5, input.Namespace); len(found) > 0 {
sim = found
for _, ex := range found {
if ex.Content == fact || cosineSimilarity(v, ex.Vector) >= 0.98 {
skip = true
break
}
@@ -202,6 +284,38 @@ func NewServer() http.Handler {
if skip {
continue
}
// 2026-10-14 (t_3e98b65a)：写时四操作判定（影子默认 ⇒ 零行为变化）。
// 蒸馏产出的每条候选事实，对照 top-5 相似现有记忆判 ADD/UPDATE/NOOP/CONFLICT：
// shadow：只记影子日志（本文件 write_ops.go），不真改库；apply：按判定执行。
// 复用上面已算出的 qvec/sim（不重复编码），hash 去重兜底在 JudgeWriteOp 前。
// t_a0831457 P0 解耦：门控**只决定标记动作**（supersede/conflict）；基础
// InsertMemory 是 pre-feature 基线行为，必须无条件执行（shadow/off 下
// ApplyWriteOp 恒返回 shouldInsert=true ⇒ 下方不再 continue ⇒ 基础插入照跑）。
// 唯一丢弃路径 = apply + NOOP（显式记 warning，含候选内容，禁静默）。
if distill.WriteOpsEnabled() {
if dupID, dup := distill.WriteOpHashDedup(fact, sim); dup {
log.Printf("%s", distill.DedupNote(dupID, fact))
continue
}
sims := distill.FromMemoryRecords(sim, qvec)
verdict := distill.JudgeWriteOp(fact, sims.TopN(5), nil, nil)
if verdict != nil {
shouldInsert, err := distill.ApplyWriteOp(*verdict, &ldbWriteOpsStore{ldb: ldb}, memIDFor(fact, input))
if err != nil {
// apply 标记失败（MarkSuperseded/MarkConflict 落库失败）：
// 丢弃本条（不做半截标记），显式记 warning（禁静默失败）。
log.Printf("[write-ops] apply 标记失败，本条事实丢弃: %v candidate=%.40s", err, fact)
continue
}
if !shouldInsert {
// 唯一丢弃路径：apply + NOOP（影子/off 不会到这里，见上）
log.Printf("[write-ops] apply NOOP 丢弃事实（判定=NOOP，候选=%.40s）", fact)
continue
}
}
// verdict==nil（off 未跑判定；理论死分支——off 不进 WriteOpsEnabled 块）
// 或 shadow（标记零调用）⇒ 基础插入无条件执行。
}
mem := models.MemoryRecord{
ID: fmt.Sprintf("mem_%d", time.Now().UnixNano()),
AgentID: input.AgentID,
@@ -214,21 +328,43 @@ func NewServer() http.Handler {
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
DerivedFrom: input.EpisodeID,
// 2026-10-13 (t_e9a4d18f P1) 证据链：全量来源 episode ID（蒸馏直写当前单亲，
// 单条证据；多 episode 聚合由 consolidate 路径补充）
SourceEvents: []string{input.EpisodeID},
Freshness: "fresh",
Source: srcOrLLMDistill(input.Source), // 2026-09-26：有笔记出处→"wiki:<路径>"；否则沿用 llm_distill（2026-09-07 方案C provenance）
// 2026-10-08 (t_7e3577c5)：血缘字段——写入方经 metadata 携带；缺省兜底
// embedding_model→bge-m3（实际嵌入模型），script_version→unknown。
EmbeddingModel: orDefault(input.EmbeddingModel, "bge-m3"),
ScriptVersion: orDefault(input.ScriptVersion, "unknown"),
// 2026-10-08 (Gap#2)：信任等级透传到产物（nil 保持 NULL，不伪装 0.0）
Confidence: input.Confidence,
ConfidenceSource: input.ConfidenceSource,
}
// 2026-10-08 (t_7e3577c5)：血缘字段——写入方经 metadata 携带；缺省兜底
// embedding_model→bge-m3（实际嵌入模型），script_version→unknown。
EmbeddingModel: orDefault(input.EmbeddingModel, "bge-m3"),
ScriptVersion: orDefault(input.ScriptVersion, "unknown"),
// 2026-10-08 (Gap#2)：信任等级透传到产物（nil 保持 NULL，不伪装 0.0）
Confidence: input.Confidence,
ConfidenceSource: input.ConfidenceSource,
// 2026-10-14 (t_3ada332b)：bi-temporal 有效期 + provenance。写时识别时间敏感事实
// （含「这周/临时/截止/到 X 之前」等）自动填 valid_to（区间末端）；来源归一 provenance
// （user|inferred|import）。开关默认关 ZHIYI_BITEMPORAL=0 ⇒ 读路径行为零变化。
ValidFrom: time.Now().Format(time.RFC3339),
ValidTo: distill.DetectValidTo(fact, time.Now()),
Provenance: distill.DetectProvenance(input.Source),
}
log.Printf("[srcprobe] 蒸馏落库 episode=%s input.Source=%q → mem.Source=%q", input.EpisodeID, input.Source, mem.Source)
if err := ldb.InsertMemory(mem); err != nil {
log.Printf("[distill] commit fact failed: %v", err)
} else {
factsLanded = true // t_1c12e000：确有 distilled fact 落库
}
}
// t_1c12e000：写路径缓存失效（方案 A）——distilled facts 是 memories 唯一写点。
// 本进程 Invalidate(ns) 清 L1+L2；跨 Agent 广播复用 commit handler 的
// PushCacheInvalidate（已注册 cache.invalidate 订阅），此处不重复广播。
if factsLanded && storage.SearchCacheInstance != nil {
storage.SearchCacheInstance.Invalidate(input.Namespace)
log.Printf("[cache] 蒸馏落库后失效 namespace=%s（%d 条 facts，episode=%s）",
input.Namespace, len(result.Facts), input.EpisodeID)
// 2026-10-14 (t_2afae95e)：FTS 词面索引同步标脏（惰性重建，
// 下次词面查询时后台刷；关态下只是置一个 bool，零成本）
storage.FtsInvalidate()
}
// 冲突检测：加载已有记忆进行比较
// 必须用**新内容的真实向量**做语义检索取近邻；用零向量在语义索引上
// 返回的只是"范数最小"的任意行，真正的矛盾对象不在比对集里 → 永远检不出冲突。
@@ -299,6 +435,12 @@ func NewServer() http.Handler {
// 注入 V 值查询函数到存储层（召回排序融合）
storage.VValueProvider = func(memoryID string) float64 {
// 2026-10-13：ep_* 是蒸馏自证（恒 1.0），零区分度且淹没真实 mem_* 信号
// （实测 ep_* 4304 个 vs mem_* 24 个）。召回目标全是 mem_*，ep_* 的 V 值
// 不参与排序即可，无需删 Redis 数据（保留可回溯）。
if strings.HasPrefix(memoryID, "ep_") {
return 0
}
return vPropagator.GetMemVValue(memoryID)
}
// 在蒸馏完成回调中记录 V 值
@@ -316,8 +458,8 @@ func NewServer() http.Handler {
"distill", "success", "",
)
}
// 更新仪表盘指标
selfoptimize.Dash.RecordUseful()
// 更新仪表盘指标：蒸馏成功次数（2026-10-14 t_c06ad4d0 改，勿再灌 UsefulCount）
selfoptimize.Dash.RecordDistillSuccess()
// 记录蒸馏质量损失（avg_distill_loss = 1 - Overall）
// 仅记录真实蒸馏：Overall > 0 表示 LLM 成功返回，过滤 fallback (Overall=0)
if result.Overall > 0 {
@@ -345,15 +487,43 @@ func NewServer() http.Handler {
mux.HandleFunc("/health", routes.HandleHealth)
mux.HandleFunc("/api/v1/health", routes.HandleHealth)
// 图谱缓存统计
// 图谱缓存统计 + 搜索缓存统计（t_1c12e000：并入 search_cache 段，
// 暴露 hits/misses/invalidated/size/ttl，写频对命中率的影响可观测）
mux.HandleFunc("/api/v1/cache/stats", func(w http.ResponseWriter, r *http.Request) {
if cachedGraphStoreRef != nil {
respondJSON(w, 200, map[string]interface{}{
"graph_cache": cachedGraphStoreRef.Stats(),
})
} else {
respondJSON(w, 200, map[string]interface{}{"graph_cache": nil})
resp := map[string]interface{}{
"graph_cache": nil,
}
if cachedGraphStoreRef != nil {
resp["graph_cache"] = cachedGraphStoreRef.Stats()
}
if storage.SearchCacheInstance != nil {
resp["search_cache"] = storage.SearchCacheInstance.Stats()
}
// 2026-10-14 (t_2afae95e)：FTS 词面索引状态（docs/tokens/built_at/dirty/门控）
resp["fts_index"] = storage.FtsIndexStats()
respondJSON(w, 200, resp)
})
// 2026-10-14 (t_2afae95e)：FTS 手工刷索引（admin；异步重建不阻塞）
mux.HandleFunc("/api/v1/fts/rebuild", func(w http.ResponseWriter, r *http.Request) {
storage.FtsRebuildNow()
respondJSON(w, 200, map[string]interface{}{"status": "rebuild_started"})
})
// 2026-10-14 (t_2afae95e)：FTS 词面查询取证端点（AC1 判据命令）：
// 返回该 query 的词面 topN 命中（id + 分 + 内容摘录），不走路过 recall 缓存。
mux.HandleFunc("/api/v1/fts/query", func(w http.ResponseWriter, r *http.Request) {
var req struct {
Query string `json:"query"`
TopN int `json:"top_n"`
CheckDocID string `json:"check_doc_id"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid body", http.StatusBadRequest)
return
}
if req.TopN <= 0 {
req.TopN = 10
}
respondJSON(w, 200, storage.FtsQuery(req.Query, req.TopN, req.CheckDocID))
})
// ─── Prometheus /metrics ─────────────────────
mux.Handle("/metrics", metrics.Handler())
@@ -378,14 +548,29 @@ func NewServer() http.Handler {
governance.PushCacheInvalidate(req.Namespace, "commit")
governance.PushMemoryCommitted(req.AgentID, req.Namespace, "")
}
// t_f8fc97e6 P3 Peer：新记忆进入 → 异步刷新内容里出现的实体画像。
// 默认关（ZHIYI_PEER_RECALL 未设/≠1）⇒ 本分支整体跳过，commit 路径零变化（AC4）。
// 开启时在已有 goroutine 内再起子 goroutine，LLM 推理绝不阻塞 HTTP commit 返回。
if os.Getenv("ZHIYI_PEER_RECALL") == "1" && peerAPI != nil {
peerAPI.RefreshFromContent(req.Content, req.Namespace)
}
}()
})
mux.HandleFunc("/api/v1/recall", api.Recall)
mux.HandleFunc("/api/v1/recall/debug", api.RecallDebug)
mux.HandleFunc("/api/v1/feedback", api.Feedback)
// 2026-10-13 (t_e9a4d18f P2) 常设答案直读/写入
mux.HandleFunc("/api/v1/standing-answers", routes.HandleStandingAnswers)
// ⑤使用追踪（t_5aa4dcac）：上报 + 手动触发。env 门控 ZHIYI_USAGE_TRACK，默认关。
mux.HandleFunc("/api/v1/usage/report", api.UsageReport)
mux.HandleFunc("/api/v1/usage/detect", api.UsageDetect)
// GA-P0-7 (t_dd64345a)：裸 /api/v1/feedback 已退役——其 handler 曾写旧字段 not_useful_count。
// 反馈统一走 /api/v1/feedback/{useful,not-useful,deprecate,correct}（feedback.go，写拆分后新字段）。
mux.HandleFunc("/api/v1/bootstrap", api.Bootstrap)
mux.HandleFunc("/api/v1/stats", api.Stats)
mux.HandleFunc("/api/v1/batch-commit", api.BatchCommit)
// 主症A（t_fa6c9104）：显式写入直落 memories 表（嵌入 + 立刻可召回）。
// 纯新增路由：commit/recall/蒸馏路径零改动；旧服务端 404 时插件自动回落 commit。
mux.HandleFunc("/api/v1/memory/write", api.WriteMemory)
// 自优化指标（Dashboard，含 avg_distill_loss）
// total_episodes：Rust count_rows 真实值；旧 sidecar 回退 episodes_cached（进程内缓存，非总量）
mux.HandleFunc("/api/v1/metrics", func(w http.ResponseWriter, r *http.Request) {
@@ -547,6 +732,23 @@ func NewServer() http.Handler {
if entity == "" {
entity = r.URL.Query().Get("query") // 也接受整句 query
}
// 噪音闸门（t_689b6d38）：系统通知/提示样板文本（如 "[IMPORTANT: You are running
// as a scheduled cron job..."、"[System note: ..."）不进语义召回、不返回笔记。
// 判定优先用结构化来源标记头，白名单（真实用户提问）照常召回，不误杀。
if routes.IsSystemTemplateInput(entity) {
log.Printf("[graph/notes] 拦截系统样板入参（system_template）：不拆实体、不返回笔记（入参 %q）",
strings.TrimSpace(entity))
respondJSON(w, 200, map[string]interface{}{
"entity": entity,
"graph_paths": []map[string]interface{}{},
"notes": []map[string]interface{}{},
"paths_count": 0,
"notes_count": 0,
"mode": "none",
"skipped": "system_template",
})
return
}
maxHops := 2
if h := r.URL.Query().Get("max_hops"); h != "" {
if parsed, err := strconv.Atoi(h); err == nil && parsed > 0 {
@@ -645,6 +847,24 @@ func NewServer() http.Handler {
mode = "direct"
} else if cands := entityIndex.Extract(entity, 2); len(cands) > 0 {
// 兜底：entity 是整句自然语言（调用方原样传用户提问）→ 本地把它拆成候选实体
// 2026-10-12 GA-P0-5：概念/实体提取路径接 echo 防线 —— 审计笔记把污染词当证据
// 列出来 → 蒸馏成 episode → 兜底拆实体时会把已删除污染节点（n_galway / n_rothfuss /
// n_the_name_of_the_wind）重建。候选实体若只是 prompt 教学示例的回显残片
// （逐字相等 / illustration 类 ≥4 字子串，判据与蒸馏侧 IsPromptEcho 同源）
// ⇒ 不入图；[ECHO-DROP] 日志供验证防线在跑。
var echoDropped int
kept := cands[:0]
for _, c := range cands {
if distill.IsPromptEchoEntity(c) {
echoDropped++
continue
}
kept = append(kept, c)
}
if echoDropped > 0 {
log.Printf("[graph/notes][ECHO-DROP] 剔除回显残片 %d 个（%q）→ 不参与笔记匹配/不入图", echoDropped, cands)
cands = kept
}
const maxSearchEntities = 8 // 参与笔记匹配的实体上限：候选 + 少量邻居，防噪声淹没
ents := make([]string, 0, maxSearchEntities)
seen := make(map[string]bool, maxSearchEntities)
@@ -917,27 +1137,12 @@ func NewServer() http.Handler {
mux.HandleFunc("/api/v1/conflicts/resolve", conflictAPI.Resolve)
// 反馈 — G5: 修正记忆时填充 version_history
// 2026-10-14 (t_c06ad4d0)：删除冗余重复块。MarkUseful 已做 RecordFeedback(true)+
// RecordDecision+QualityMonitor.Check+IncrementUseful+AppendHitEvent；原 handler 里
// 这段二次读 r.Body 的 RecordUseful/RecordDecision/QualityMonitor 全部重复，且
// r.Body 已被 MarkUseful 消费（io.ReadAll 恒空）⇒ 死代码 + 潜在二次计数污染。
mux.HandleFunc("/api/v1/feedback/useful", func(w http.ResponseWriter, r *http.Request) {
feedbackAPI.MarkUseful(w, r)
// 质量监控：useful → 质量上升
var req struct {
MemoryID string `json:"memory_id"`
}
if r.Body != nil {
body, _ := io.ReadAll(r.Body)
json.Unmarshal(body, &req)
r.Body = io.NopCloser(bytes.NewReader(body))
if req.MemoryID != "" {
selfoptimize.Dash.RecordUseful()
// V 值：useful = success
selfoptimize.VProp.RecordDecision(
"useful_"+req.MemoryID,
[]string{req.MemoryID},
"user_feedback", "success", "",
)
selfoptimize.QualityMonitor.Check(req.MemoryID, 0, 5) // 清除潜在告警
}
}
})
mux.HandleFunc("/api/v1/feedback/not-useful", func(w http.ResponseWriter, r *http.Request) {
feedbackAPI.MarkNotUseful(w, r)
@@ -987,6 +1192,16 @@ func NewServer() http.Handler {
// 缺口
mux.HandleFunc("/api/v1/gaps", gapAPI.List)
mux.HandleFunc("/api/v1/gaps/detect", gapAPI.Detect)
// t_d32e5f8a L2 模式检测（MemOS 血统）
mux.HandleFunc("/api/v1/patterns", patternAPI.List)
mux.HandleFunc("/api/v1/patterns/detect", patternAPI.Detect)
// t_fcadee04 L3 skill 草稿（/patterns/{id}/draft 与 /patterns/{id}/promote）。
// 前缀路由；/patterns 与 /patterns/detect 因更长的精确路由优先，不受影响。
mux.HandleFunc("/api/v1/patterns/", patternAPI.Sub)
// t_f8fc97e6 P3 Peer Representation：显式 refresh/explain + 门控 recall。
// 前缀路由 /api/v1/peer/；/api/v1/recall/peer 独立精确路由优先。
mux.HandleFunc("/api/v1/recall/peer", peerAPI.RecallPeer)
mux.HandleFunc("/api/v1/peer/", peerAPI.Sub)
mux.HandleFunc("/api/v1/gaps/close/", func(w http.ResponseWriter, r *http.Request) {
gapAPI.Close(w, r)
topic := r.URL.Path[len("/api/v1/gaps/close/"):]
@@ -1597,14 +1812,14 @@ func NewServer() http.Handler {
// distill 保持 cluster_only（高频触发，只做快速聚类）
_, err = consolPipe.Run()
case "consolidation", "backtrack":
// full 模式：含 prune + decay + 质量回溯（Step 4）
// 48h cooldown 保护，不会真正每分钟跑 full（cooldown 内 CanFire 仍返回 false）
_, err = consolPipe.RunWithMode("full")
// 2026-09-21 (t_4ce53193)：冲突去重 + 保留策略
// 去重：同 (L,R) 对只留最早一条，累加 dup_count，归档 + 审计
conflictDetector.DedupeActive(governance.DefaultConflictRetentionConfig())
// 保留：pending > 7d 无人处置 → 归档（不删除）
conflictDetector.RetainAndArchive(governance.DefaultConflictRetentionConfig())
// full 模式：含 prune + decay + 质量回溯（Step 4）
// 48h cooldown 保护，不会真正每分钟跑 full（cooldown 内 CanFire 仍返回 false）
_, err = consolPipe.RunWithMode("full")
// 2026-09-21 (t_4ce53193)：冲突去重 + 保留策略
// 去重：同 (L,R) 对只留最早一条，累加 dup_count，归档 + 审计
conflictDetector.DedupeActive(governance.DefaultConflictRetentionConfig())
// 保留：pending > 7d 无人处置 → 归档（不删除）
conflictDetector.RetainAndArchive(governance.DefaultConflictRetentionConfig())
case "merge":
_, err = consolPipe.RunMerge()
case "prune":
@@ -1617,7 +1832,13 @@ func NewServer() http.Handler {
memories, e := ldb.GetCandidatesForForgetting()
decayScanned := 0
decayForgotten := 0
decayProtected := 0
if e == nil {
// 2026-10-16 (t_944344b5) 遗忘保护守卫：本 tick 加载一次保护状态
// （Redis zhiyi:vprop_values + zhiyi:protected_ids），命中任一保护规则的
// 候选永不自动软删（fragment 与 ShouldForget 两条道都拦截）。
// Redis 宕机 → 降级为纯行内规则（category/freshness/关键词），不阻断衰减。
protState := memprotect.LoadState()
const maxDecayBatch = 2000
if len(memories) > maxDecayBatch {
sort.SliceStable(memories, func(a, b int) bool {
@@ -1641,6 +1862,16 @@ func NewServer() http.Handler {
continue
}
}
// 🔒 2026-10-16 (t_944344b5) 遗忘保护守卫: 命中任一保护规则的候选
// (category∈{decision,preference,pref} / V≥2.0 / freshness=verified /
// protected_ids 名单 / distilled 且内容命中 10 个决策·偏好关键词) 永不自动软删。
// 拦截 point 放在 fragment + ShouldForget 两条 SoftDelete 道之前。
if isProt, protRule := memprotect.IsProtected(m, protState); isProt {
gid, _ := m["id"].(string)
decayProtected++
log.Printf("[decay] protected skip id=%q rule=%s (遗忘保护守卫命中, 跳过自动遗忘)", gid, protRule)
continue
}
// 解析 last_recalled_at
lastAccessed := time.Now().Add(-30 * 24 * time.Hour) // 默认30天前
if t, ok := m["last_recalled_at"].(string); ok && t != "" {
@@ -1667,8 +1898,10 @@ func NewServer() http.Handler {
}
continue
}
// GA-P0-2 (t_c6d41ac6)：衰减/遗忘只认 recall_verified_count（正反馈才是 V 值）。
// recall_count 已冻结（历史虚高保命来源），seen 只用于观测。
recallCount := 0
if rc, ok := m["recall_count"].(int); ok {
if rc, ok := m["recall_verified_count"].(int); ok {
recallCount = rc
}
tier := "normal"
@@ -1699,7 +1932,8 @@ func NewServer() http.Handler {
}
// AC-1 验收日志（P1 修复 type 断言后 last_recalled_at 可解析；batch<=2000）
if decayScanned > 0 {
log.Printf("[decay] scanned=%d forgotten=%d (batch<=2000, 最久未访问优先)", decayScanned, decayForgotten)
// 2026-10-16 (t_944344b5)：protected_skip = 被遗忘保护守卫拦截、未软删的候选数
log.Printf("[decay] scanned=%d forgotten=%d protected_skip=%d (batch<=2000, 最久未访问优先)", decayScanned, decayForgotten, decayProtected)
}
case "gap_scan":
// 检查已有缺口：过期 7 天的自动关闭
@@ -1713,7 +1947,12 @@ func NewServer() http.Handler {
for _, g := range gaps {
if !g.Closed && routes.GapRepair != nil {
if routes.GapRepair.AutoRepair(g) {
selfoptimize.Dash.RecordGapClosed()
// t_e5997ca4：AutoRepair 只做「修复」不关缺口。旧代码在此
// 无条件 Dash.RecordGapClosed() 却不置 g.Closed ⇒ 同一缺口每轮
// gap_scan 都再 +1（ClosedGaps 无限虚增，线上 9 vs 2 的写侧根因 #2）。
// 现按 RepairHandler 语义：修复成功 = 关闭该缺口；+1 只发生在
// Close 的 open→closed 迁移点（内部），下一轮 !g.Closed 即跳过。
gapDetector.Close(g.Topic)
}
}
}
@@ -1940,3 +2179,33 @@ func confidenceSourceOf(c *float64) string {
}
return ""
}
// ldbWriteOpsStore 适配 storage.LanceDB 到 distill.WriteOpsStore 接口。
// 供写时四操作的 apply 模式标记 superseded/conflict（t_3e98b65a）。
type ldbWriteOpsStore struct {
ldb storage.LanceDB
}
// MarkSuperseded 旧记忆标记「被 newID 取代」（写 superseded_by + is_deleted=true；
// 历史经 supersedes/superseded_by 保留可追溯，不物理删）。
func (s *ldbWriteOpsStore) MarkSuperseded(oldID, newID string) error {
b, _ := json.Marshal([]string{newID})
return s.ldb.Update("memories", oldID, map[string]any{
"superseded_by": string(b),
"is_deleted": true,
})
}
// MarkConflict 记忆标记冲突（交人工；不删）。冲突以 superseded_by 空 + is_deleted 保持 false
// + freshness=conflict 标识，让 recall 仍可见但排序权重降（调用方感知）。
func (s *ldbWriteOpsStore) MarkConflict(id string) error {
return s.ldb.Update("memories", id, map[string]any{
"freshness": "conflict",
})
}
// memIDFor 为写时四操作 apply 预生成新记忆 ID（与下方 InsertMemory 同格式）。
func memIDFor(fact string, input distill.DistillInput) string {
_ = fact
return fmt.Sprintf("mem_%d", time.Now().UnixNano())
}
go/internal/api/server_route_guard_test.go
+37
View File
@@ -0,0 +1,37 @@
package api
import (
"os"
"strings"
"testing"
)
// GA-P0-7 (t_dd64345a)：回归守卫 —— 裸路由 /api/v1/feedback 已退役。
// 它的 handler（core.go Feedback，已删）曾按 useful 布尔写旧字段 not_useful_count
// （P0-1 t_718d8707 已拆分为 human_not_useful_count / dedup_downweight_count）。
// 谁若重新注册这个裸路由（旧字段随之复活），本测试必须红。
func TestNoBareFeedbackRoute(t *testing.T) {
src, err := os.ReadFile("server.go")
if err != nil {
t.Fatalf("read server.go: %v", err)
}
s := string(src)
// 裸路由注册必须不存在（精确匹配 server.go:385 的旧行）。
bare := `mux.HandleFunc("/api/v1/feedback", api.Feedback)`
if strings.Contains(s, bare) {
t.Fatalf("裸 /api/v1/feedback 路由被重新注册——其 handler 写旧字段 not_useful_count(GA-P0-1)；请改用 /api/v1/feedback/{useful,not-useful,deprecate,correct}")
}
// 新拆分后的子路由必须在（反馈统一走它们，写 human_not_useful_count 等新字段）。
for _, sub := range []string{
`"/api/v1/feedback/useful"`,
`"/api/v1/feedback/not-useful"`,
`"/api/v1/feedback/deprecate"`,
`"/api/v1/feedback/correct"`,
} {
if !strings.Contains(s, sub) {
t.Fatalf("期望子路由 %s 已注册，但 server.go 中缺失", sub)
}
}
}
go/internal/api/server_sqlite_nowindows.go
+1 -1
View File
@@ -23,4 +23,4 @@ func initStorageForSQLite(emb *storage.Embedder) storage.LanceDB {
}
log.Printf("[zhiyid] 存储后端: SQLite (CGO) — %s", dbPath)
return sqliteDB
}
}
go/internal/api/server_storage_nowindows.go
+1 -1
View File
@@ -53,4 +53,4 @@ func initGraphStore() governance.GraphStore {
}
log.Printf("[zhiyid] 图谱后端: SQLiteGraphStore — %s", graphPath)
return gs
}
}
go/internal/api/server_storage_windows.go
+1 -1
View File
@@ -62,4 +62,4 @@ func initGraphStore() governance.GraphStore {
}
log.Printf("[zhiyid] 图谱后端: InMemoryGraph (Windows，纯 Go 无 SQLite CGO）")
return governance.NewInMemoryGraph()
}
}
go/internal/consolidate/client.go
+26 -26
View File
@@ -20,35 +20,35 @@ import (
// ConsolidateRequest 整合请求
type ConsolidateRequest struct {
Task string `json:"task"` // "full" | "cluster_only" | "prune_only"
LanceDBPath string `json:"lancedb_path"` // LanceDB 数据目录
SQLitePath string `json:"sqlite_path"` // SQLite 图谱路径
LLMEndpoint string `json:"llm_endpoint"` // LLM API 端点
LLMModel string `json:"llm_model"` // LLM 模型名
LLMApiKey string `json:"llm_api_key"` // LLM API Key (Authorization header)
LLMBudget int `json:"llm_budget"` // 本次可用 LLM 次数
Epsilon float64 `json:"epsilon"` // DBSCAN 邻域半径（1024-dim BGE-M3 单位向量建议 1.5）
MinPoints int `json:"min_points"` // DBSCAN 最小点数
ModelDir string `json:"model_dir"` // BGE 模型目录（用于 quality backtrace 编码）
Task string `json:"task"` // "full" | "cluster_only" | "prune_only"
LanceDBPath string `json:"lancedb_path"` // LanceDB 数据目录
SQLitePath string `json:"sqlite_path"` // SQLite 图谱路径
LLMEndpoint string `json:"llm_endpoint"` // LLM API 端点
LLMModel string `json:"llm_model"` // LLM 模型名
LLMApiKey string `json:"llm_api_key"` // LLM API Key (Authorization header)
LLMBudget int `json:"llm_budget"` // 本次可用 LLM 次数
Epsilon float64 `json:"epsilon"` // DBSCAN 邻域半径（1024-dim BGE-M3 单位向量建议 1.5）
MinPoints int `json:"min_points"` // DBSCAN 最小点数
ModelDir string `json:"model_dir"` // BGE 模型目录（用于 quality backtrace 编码）
}
// ConsolidateResponse 整合响应
type ConsolidateResponse struct {
Status string `json:"status"` // "ok" | "partial_failure"
ReportJSON string `json:"report_json"` // ConsolidationReport JSON
FailureStep string `json:"failure_step"` // 失败步骤
ErrorDetail string `json:"error_detail"` // 错误详情
Status string `json:"status"` // "ok" | "partial_failure"
ReportJSON string `json:"report_json"` // ConsolidationReport JSON
FailureStep string `json:"failure_step"` // 失败步骤
ErrorDetail string `json:"error_detail"` // 错误详情
}
// Result 解析后的整合结果
type Result struct {
Mode string `json:"mode"`
Timestamp string `json:"timestamp"`
Clusters int `json:"clusters_found,omitempty"`
Noise int `json:"noise_points,omitempty"`
DecayRates map[string]float64 `json:"decay_rates,omitempty"`
Quality *QualityResult `json:"quality,omitempty"`
QualityScore float64 `json:"quality_score,omitempty"` // 直接从 sidecar 的 ConsolidationReport 读取
Mode string `json:"mode"`
Timestamp string `json:"timestamp"`
Clusters int `json:"clusters_found,omitempty"`
Noise int `json:"noise_points,omitempty"`
DecayRates map[string]float64 `json:"decay_rates,omitempty"`
Quality *QualityResult `json:"quality,omitempty"`
QualityScore float64 `json:"quality_score,omitempty"` // 直接从 sidecar 的 ConsolidationReport 读取
}
type QualityResult struct {
@@ -71,17 +71,17 @@ func Run(dataDir, sqlitePath, mode string) (*Result, error) {
Task: mode,
LanceDBPath: dataDir,
SQLitePath: sqlitePath,
LLMEndpoint: os.Getenv("LLM_ENDPOINT"),
LLMModel: os.Getenv("LLM_MODEL"),
LLMApiKey: os.Getenv("LLM_API_KEY"),
Epsilon: 0.4,
LLMEndpoint: os.Getenv("LLM_ENDPOINT"),
LLMModel: os.Getenv("LLM_MODEL"),
LLMApiKey: os.Getenv("LLM_API_KEY"),
Epsilon: 0.4,
// 距离分布（2026-09-05 实测，bge-m3 归一化向量 norm=1.0）:
// 全量3000抽样: p25=0.24 p50=0.75 p95=0.82
// sidecar 零向量 top-10000 样本: p5=0.09 p50=0.42 p95=1.0
// eps=1.0（旧值，按未归一化 p50=1.029 调的）→ 归一化空间过大 → clusters=1 聚类失效
// eps=0.3~0.5 → 有语义簇（能发现重复状态噪音簇: 1045条"主profile状态同步"/961条"CBM状态"）
// eps=0.4 = 平衡（2026-09-05 修复，commit 待推）
MinPoints: 3,
MinPoints: 3,
ModelDir: os.Getenv("BGE_MODEL_DIR"),
})
}
go/internal/distill/aaak.go
+7 -7
View File
@@ -10,13 +10,13 @@ import (
// 目标：为每条事实生成紧凑结构化摘要，LLM 可读、无需解码器，
// 召回时先扫索引定位相关事实，再读原文（索引层指向内容层）。
type AAAKEntry struct {
FactID string `json:"fact_id"` // 事实编号（F1, F2, ...）
Primary string `json:"primary"` // 主实体（最重要实体，如人名/项目名）
Entities []string `json:"entities"` // 全部相关实体
Keywords []string `json:"keywords"` // 主题关键词（2-4 个）
Quote string `json:"quote"` // 关键短语（截断 ≤40 字）
Weight float64 `json:"weight"` // 权重（由 5D 分数综合）
Kind string `json:"kind"` // 类型：fact / decision / action / question / conclusion
FactID string `json:"fact_id"` // 事实编号（F1, F2, ...）
Primary string `json:"primary"` // 主实体（最重要实体，如人名/项目名）
Entities []string `json:"entities"` // 全部相关实体
Keywords []string `json:"keywords"` // 主题关键词（2-4 个）
Quote string `json:"quote"` // 关键短语（截断 ≤40 字）
Weight float64 `json:"weight"` // 权重（由 5D 分数综合）
Kind string `json:"kind"` // 类型：fact / decision / action / question / conclusion
}
// buildAAAKIndex 为事实列表生成 AAAK 压缩索引
go/internal/distill/admission_lane.go
+94
View File
@@ -0,0 +1,94 @@
// 织忆 MemoryWeave — 准入三路分诊（确定性，零 LLM 调用）
//
// 背景与依据（2026-10-12，6 篇文献精读，方案见
// mc/小怡/04-OBSIDIAN工具/04-02-方案设计/20261012-织忆记忆闸门-外部经验落地方案.md）：
//
// · A-MAC (arXiv 2603.04549) 消融实验：确定性「内容类型先验」是**单点最强特征**
// —— 去掉它 F1 从 0.583 掉到 0.476（ΔF1=−0.107），等于退回等权基线。
// 而织忆此前的判据里确定性特征数为 0（只有 LLM 给的 overall 与 VD）。
// · SAGE (arXiv 2605.30711)：明确该走哪条路的直接闭式解决，只有「不确定带」才需谨慎；
// 且单一固定阈值会随记忆库变密而**必然过度保守**。
// · When to Forget (arXiv 2604.12007) 原文："a system acting on Memory Worth should
// not deprecate an uncertain memory" ⇒ **证据不足/拿不准的内容绝不弃用**。
//
// 于是把「一个 LLM 分数卡阈值」拆成三路：
//
// drop —— 无歧义的垃圾（确定性规则），可丢
// keep —— 无歧义的高价值（确定性规则），放行且不看分数
// observe —— 其余全部 ⇒ **不确定带，永不因 LLM 低分丢弃**
//
// 设计取舍（刻意保守）：drop 只收「无歧义」项；像"纯疑问句""状态汇报"这类**需要判断**的
// 内容不放进 drop，一律落 observe —— 文献明确警告过度保守的准入会丢掉长程推理必需的信息。
// 代价不对称：keep/observe 多留是可逆的（后续消费/降权会淘汰），drop 丢掉不可逆。
package distill
import (
"strings"
"unicode/utf8"
"github.com/xiaoxue/memoryweave/internal/textfilter"
)
// AdmissionLane 准入分诊结果。
type AdmissionLane string
const (
LaneKeep AdmissionLane = "keep" // 确定性高价值 → 放行，不看分数
LaneDrop AdmissionLane = "drop" // 确定性垃圾 → 丢弃
LaneObserve AdmissionLane = "observe" // 不确定带 → 永不因分数丢弃
)
// decisionPatterns 明确决策/承诺/长期约束的确定性线索。
// 注意：命中即→keep，属**过度保留**方向，代价可逆，故可以放宽。
var decisionPatterns = []string{
"决定", "约定", "拍板", "定下来", "改成", "以后都", "以后不", "不再", "必须",
"记住", "长期", "持续", "永久", "禁止", "不要", "别忘",
}
// identityPreferencePatterns 身份/偏好/长期事实的确定性线索。
var identityPreferencePatterns = []string{
"我喜欢", "我不喜欢", "我的", "我是", "我在", "我负责", "我住", "平时",
"习惯", "一直", "负责", "工作", "设备",
}
// ClassifyAdmission 对一条待蒸馏内容做确定性三路分诊。
// 返回 lane 与人类可读的 reason（进日志，用于事后审计分诊是否合理）。
// 本函数**零 LLM 调用**、纯确定性 —— 同一输入永远同一结果，可单测。
func ClassifyAdmission(content string) (AdmissionLane, string) {
s := strings.TrimSpace(content)
if s == "" {
return LaneDrop, "空内容"
}
// ── drop：无歧义的垃圾 ──────────────────────────────────
if textfilter.IsSystemTemplate(s) {
return LaneDrop, "系统样板/回执"
}
if utf8.RuneCountInString(s) < 8 {
return LaneDrop, "过短无内容(<8字)"
}
// ── keep：无歧义的高价值 ────────────────────────────────
// 结构化人侧短事实（画像规则:/心迹:/牵挂:/偏好:/习惯:/目标: 等 daemon 侧固化前缀）
if isSoulfulShortFact(s) {
return LaneKeep, "结构化人侧事实前缀"
}
// 长度护栏：超长内容里的关键词不构成"这是在陈述一条决策"（长文里出现"决定"
// 多半是在**汇报/转述**，不是本条内容本身是一条决策）→ 落 observe。
n := utf8.RuneCountInString(s)
if n >= 8 && n <= 150 {
for _, p := range decisionPatterns {
if strings.Contains(s, p) {
return LaneKeep, "决策/承诺线索:" + p
}
}
for _, p := range identityPreferencePatterns {
if strings.Contains(s, p) {
return LaneKeep, "身份/偏好线索:" + p
}
}
}
// ── observe：拿不准的一律留 ─────────────────────────────
return LaneObserve, "不确定带"
}
go/internal/distill/admission_lane_test.go
+71
View File
@@ -0,0 +1,71 @@
package distill
import "testing"
// TestClassifyAdmission 锁定三路分诊的判据（Step 1 验收线）。
//
// 关键不变量（对应外部经验）：
// 1. 系统样板/回执 → drop（确定性垃圾）
// 2. 结构化人侧事实前缀 / 决策承诺 / 身份偏好 → keep
// 3. **拿不准的一律 observe** —— 尤其"纯疑问""状态汇报"这类需要判断的内容
// 绝不能被 drop（When to Forget 原文："should not deprecate an uncertain memory"）
func TestClassifyAdmission(t *testing.T) {
cases := []struct {
name string
content string
want AdmissionLane
}{
// ── drop：无歧义垃圾 ──
{"系统样板-cron", "[IMPORTANT: You are running as a scheduled cron job. No user is present.", LaneDrop},
{"系统样板-心跳", "[HEARTBEAT] tick 2026-10-12T02:00", LaneDrop},
{"系统样板-内部通知", "[INTERNAL NOTIFICATION — generated by the Hermes gateway, not written by a human user.]", LaneDrop},
{"系统样板-子代理回执", "[ASYNC DELEGATION COMPLETE — deleg_79e1d4ad] A background subagent finished.", LaneDrop},
{"系统样板-上下文摘要", "## Context Compaction — REFERENCE ONLY\nEarlier turns were compacted.", LaneDrop},
{"空内容", " ", LaneDrop},
{"过短", "好的", LaneDrop},
// ── keep：确定性高价值 ──
{"结构化前缀-偏好", "偏好: 牧尘喜欢结论先行、不要废话科普", LaneKeep},
{"结构化前缀-心迹", "心迹: 今天有点累", LaneKeep},
{"决策承诺", "牧尘决定以后都用分身C来处理采集类任务。", LaneKeep},
{"长期约束", "这条以后不要再问了，记住已经拍板。", LaneKeep},
{"身份偏好", "我喜欢马哲经济学和剪辑，设备是小米笔记本。", LaneKeep},
// ── observe：拿不准的一律留（关键：不能被 drop）──
{"纯疑问", "这个闸门到底应该怎么定阈值才合理呢？", LaneObserve},
{"状态汇报", "服务已重启完成，当前版本 v0.21.6。", LaneObserve},
{"普通对话", "今天把织忆的评分链路排查了一遍，顺手补了记分牌的一项指标。", LaneObserve},
// ── 边界：超长内容里的关键词不构成"陈述了一条决策" ──
{"超长含关键词", "决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定决定", LaneObserve},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, why := ClassifyAdmission(c.content)
if got != c.want {
t.Fatalf("ClassifyAdmission() lane=%q reason=%q, 期望 lane=%q\n内容: %.60s", got, why, c.want, c.content)
}
if why == "" {
t.Fatal("reason 不得为空（用于事后审计分诊是否合理）")
}
})
}
}
// TestClassifyAdmissionDeterministic 同一输入必须永远同一结果（确定性 = 可审计的前提）。
func TestClassifyAdmissionDeterministic(t *testing.T) {
for _, s := range []string{
"牧尘决定以后都用分身C。",
"服务已重启完成。",
"[HEARTBEAT] tick",
} {
first, fr := ClassifyAdmission(s)
for i := 0; i < 5; i++ {
got, gr := ClassifyAdmission(s)
if got != first || gr != fr {
t.Fatalf("非确定性：%q 第一次 %s/%s，第 %d 次 %s/%s", s, first, fr, i+2, got, gr)
}
}
}
}
go/internal/distill/adversarial_audit.go
+248
View File
@@ -0,0 +1,248 @@
// 织忆 MemoryWeave — 对抗审计插槽（②蒸馏环）
//
// 背景（2026-10-13，血统 HW_MyJarvis）：织忆当前所有质量判断都是单模型自证
// （本地 2B 自己打分自己提取），实测已抓到四起同类病：蒸馏评分恒 0.755、
// ep_* 的 V 值恒 1.0（4304 条自证污染）、metrics 三完美值、avg_distill_loss
// 无人复核。共同病根：一个模型自己说自己好，没有异源复核。
//
// 本插槽解法：蒸馏产出的事实，按抽样比例送【异源模型】（非本地 2B）做对抗审计，
// 找矛盾 / 幻觉 / 无据。审计结论只写【影子日志】，不改任何丢弃/准入行为
// （与 ZHIYI_SCORE_SHADOW 同一纪律：先观察，不真拦）。
//
// ── 门控（默认关 ⇒ 零行为变化，硬要求）──────────────────────────
//
// ZHIYI_ADVERSARIAL_AUDIT=1 开启（默认关）
// ZHIYI_ADVERSARIAL_AUDIT_RATIO 抽样比例（默认 0.05 = 5%）
// ZHIYI_ADVERSARIAL_AUDIT_ENDPOINT 审计端点（默认 http://127.0.0.1:3000/v1/chat/completions，
// NewAPI 免费通道，异源——非本地 2B 的 8081）
// ZHIYI_ADVERSARIAL_AUDIT_MODEL 审计模型（默认 deepseek-v4-flash，免费腿）
// ZHIYI_ADVERSARIAL_AUDIT_KEY 审计 key（默认回退 LLM_API_KEY）
// ZHIYI_ADVERSARIAL_AUDIT_LOG 影子日志路径（默认 /var/lib/memoryweave/adversarial-audit.log）
// ZHIYI_ADVERSARIAL_AUDIT_TIMEOUT 单次审计超时秒（默认 60）
//
// 关闭路径：unset ZHIYI_ADVERSARIAL_AUDIT（或置 0）→ 完全恢复，不产生任何调用、
// 不写任何日志、不占任何资源。
//
// ── 设计约束 ────────────────────────────────────────────────
// · 异源：审计模型走 NewAPI 免费通道（127.0.0.1:3000），默认 deepseek-v4-flash，
// 与蒸馏主链的本地 2B（local/minicpm5-2b via 8081）不同源不同模型。
// · 零新依赖：只用 stdlib net/http / encoding/json / os。
// · 不碰 state.db：审计只写独立影子日志文件，不改存储、不新增常驻进程
// （审计 goroutine 在 zhiyid 进程内，随调用起落，非守护）。
// · 控并发：包级信号量 advAuditSem（默认 1），异步执行，绝不阻塞/打爆蒸馏主链。
package distill
import (
"encoding/json"
"fmt"
"log"
"math/rand"
"net/http"
"os"
"strings"
"sync"
"time"
)
// advAuditSem 控制对抗审计并发（默认 1：串行，最保守，不抢本地 2B 也不突刺 NewAPI）。
var advAuditSem = make(chan struct{}, 1)
// advAuditMu 保护影子日志文件的串行追加。
var advAuditMu sync.Mutex
// envStr 读字符串环境变量，缺省/空则用 def。
func envStr(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
// adversarialAuditEnabled 是否开启对抗审计（运行时读 env，unset/0/其它 → 关）。
func adversarialAuditEnabled() bool {
v := os.Getenv("ZHIYI_ADVERSARIAL_AUDIT")
return v == "1" || strings.EqualFold(v, "true")
}
// MaybeAdversarialAudit 对抗审计入口（②环插槽）。影子模式：只写日志，不改行为。
// 门控关 → 立即返回（零行为变化）；开 → 按抽样比例决定是否异步审计。
// 抽样为随机比例：命中才发一次异源审计；未命中/无事实/比例≤0 → 直接返回。
func MaybeAdversarialAudit(input DistillInput, facts []string) {
if !adversarialAuditEnabled() {
return
}
if len(facts) == 0 {
return
}
ratio := envFloat("ZHIYI_ADVERSARIAL_AUDIT_RATIO", 0.05)
if ratio <= 0 {
return
}
if rand.Float64() >= ratio {
return
}
// 异步执行 + 信号量控并发：取不到槽位则放弃本次（影子审计，不排队不阻塞）。
select {
case advAuditSem <- struct{}{}:
default:
log.Printf("[adv-audit] 并发槽已满，放弃本次抽样（episode=%s）", input.EpisodeID)
return
}
go func() {
defer func() { <-advAuditSem }()
if err := auditOne(input, facts); err != nil {
log.Printf("[adv-audit] 审计失败 episode=%s: %v", input.EpisodeID, err)
}
}()
}
// AuditVerdict 单条事实的对抗审计结论。
type AuditVerdict struct {
Fact string `json:"fact"`
Verdict string `json:"verdict"` // supported | contradiction | hallucination | no_evidence
Reason string `json:"reason"`
}
// auditOne 执行一次对抗审计：送异源模型 → 解析结论 → 写影子日志。
// 返回 error 供日志记录（审计失败绝不 panic，绝不触碰主链）。
func auditOne(input DistillInput, facts []string) error {
endpoint := envStr("ZHIYI_ADVERSARIAL_AUDIT_ENDPOINT",
"http://127.0.0.1:3000/v1/chat/completions")
model := envStr("ZHIYI_ADVERSARIAL_AUDIT_MODEL", "deepseek-v4-flash")
key := envStr("ZHIYI_ADVERSARIAL_AUDIT_KEY", "")
if key == "" {
key = os.Getenv("LLM_API_KEY")
}
timeout := time.Duration(envFloat("ZHIYI_ADVERSARIAL_AUDIT_TIMEOUT", 60)) * time.Second
raw, err := callAuditModel(endpoint, model, key, buildAuditPrompt(input.Content, facts), timeout)
if err != nil {
return err
}
verdicts := parseAuditVerdicts(raw)
flag := 0
for _, v := range verdicts {
if v.Verdict == "contradiction" || v.Verdict == "hallucination" || v.Verdict == "no_evidence" {
flag++
}
}
log.Printf("[adv-audit] episode=%s facts=%d verdicts=%d flagged=%d model=%s",
input.EpisodeID, len(facts), len(verdicts), flag, model)
for _, v := range verdicts {
appendAuditLog(input, v)
}
if len(verdicts) == 0 {
log.Printf("[adv-audit] 审计模型未返回可解析结论 episode=%s raw=%q", input.EpisodeID, truncate(raw, 200))
}
return nil
}
// buildAuditPrompt 构造对抗审计 prompt：给原文 + 提取的事实，要求逐条判定。
// 输出格式要求严格 JSON 数组（异源模型普遍稳定支持）。
func buildAuditPrompt(content string, facts []string) string {
var b strings.Builder
b.WriteString("你是一个对抗性记忆审计员。下面是一段原始内容，以及系统从中\"蒸馏提取\"出的事实条目。\n")
b.WriteString("你的任务：逐条判断每个事实是否被原文支持。\n\n")
b.WriteString("原文：\n")
b.WriteString(truncate(content, 1500))
b.WriteString("\n\n提取的事实：\n")
for i, f := range facts {
fmt.Fprintf(&b, "%d. %s\n", i+1, f)
}
b.WriteString("\n对每条事实输出一个JSON对象：{\"fact\":\"<事实原文>\",\"verdict\":\"supported|contradiction|hallucination|no_evidence\",\"reason\":\"<一句话理由>\"}。\n")
b.WriteString("判据：supported=原文明确支持；contradiction=与原文矛盾；hallucination=原文根本没提到（模型编造）；no_evidence=原文不足以支撑该推断。\n")
b.WriteString("只输出一个JSON数组，元素顺序与事实条目顺序一一对应，不要输出任何其他文字。")
return b.String()
}
// callAuditModel 调异源审计模型，返回 message.content 原文。
func callAuditModel(endpoint, model, key, prompt string, timeout time.Duration) (string, error) {
body := map[string]interface{}{
"model": model,
"messages": []map[string]string{{"role": "user", "content": prompt}},
"temperature": 0.1,
"max_tokens": 2000,
}
jsonBody, err := json.Marshal(body)
if err != nil {
return "", err
}
req, err := http.NewRequest("POST", endpoint, strings.NewReader(string(jsonBody)))
if err != nil {
return "", err
}
req.Header.Set("Content-Type", "application/json")
if key != "" {
req.Header.Set("Authorization", "Bearer "+key)
}
client := &http.Client{Timeout: timeout}
resp, err := client.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("audit endpoint HTTP %d", resp.StatusCode)
}
var out struct {
Choices []struct {
Message struct {
Content string `json:"content"`
} `json:"message"`
} `json:"choices"`
}
if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
return "", err
}
if len(out.Choices) == 0 {
return "", fmt.Errorf("audit: no choices in response")
}
return out.Choices[0].Message.Content, nil
}
// parseAuditVerdicts 解析审计模型返回的 JSON 数组。健壮剥离 markdown fence 与
// 前后杂质（找第一个 [ 到匹配的 ]），解析失败返回空切片（不 panic）。
func parseAuditVerdicts(raw string) []AuditVerdict {
s := strings.TrimSpace(raw)
// 剥 markdown code fence
s = strings.TrimPrefix(s, "```json")
s = strings.TrimPrefix(s, "```")
s = strings.TrimSuffix(s, "```")
s = strings.TrimSpace(s)
// 找第一个 [ 和最后一个 ]
si := strings.Index(s, "[")
ei := strings.LastIndex(s, "]")
if si < 0 || ei <= si {
return nil
}
var verdicts []AuditVerdict
if err := json.Unmarshal([]byte(s[si:ei+1]), &verdicts); err != nil {
return nil
}
return verdicts
}
// appendAuditLog 追加一条审计结论到影子日志（JSONL，串行追加）。
// 路径运行时读 env；默认 /var/lib/memoryweave/adversarial-audit.log。
func appendAuditLog(input DistillInput, v AuditVerdict) {
path := envStr("ZHIYI_ADVERSARIAL_AUDIT_LOG", "/var/lib/memoryweave/adversarial-audit.log")
line := map[string]interface{}{
"ts": time.Now().Format(time.RFC3339),
"episode": input.EpisodeID,
"source": input.Source,
"namespace": input.Namespace,
"fact": v.Fact,
"verdict": v.Verdict,
"reason": v.Reason,
}
b, _ := json.Marshal(line)
advAuditMu.Lock()
defer advAuditMu.Unlock()
f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
if err != nil {
log.Printf("[adv-audit] 影子日志打开失败 %s: %v", path, err)
return
}
defer f.Close()
f.Write(append(b, '\n'))
}
go/internal/distill/adversarial_audit_test.go
+142
View File
@@ -0,0 +1,142 @@
package distill
import (
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
)
// ─── 测试策略 ───────────────────────────────────────────────
// 对抗审计插槽是影子（只写日志不改行为），且 env 门控默认关。测试分四类：
// ① AC1 门控默认关 → 零行为变化：开启校验函数不写日志、不发起调用。
// ② AC5 关闭路径：unset env → 完全恢复。
// ③ AC2 打开门控 → 审计日志有记录（用 httptest 假端点，确定性地验真实日志行）。
// ④ 解析健壮性：模型返回带 markdown fence / 杂质时也能解析。
//
// 注意：审计异步（goroutine），测试里用同步版 auditOne 验真实日志写入。
// 返回一个假的审计 HTTP 端点，断言收到请求并返回固定 verdict 数组。
func fakeAuditServer(t *testing.T, verdictJSON string) (*httptest.Server, *int) {
t.Helper()
var hits int
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hits++
w.Header().Set("Content-Type", "application/json")
// 正确嵌套：把 verdict 数组作为 content 的字符串值序列化，避免换行/引号破坏外层 JSON
out, _ := json.Marshal(map[string]interface{}{
"choices": []map[string]interface{}{{"message": map[string]interface{}{"content": verdictJSON}}},
})
w.Write(out)
}))
t.Cleanup(srv.Close)
return srv, &hits
}
func TestAdvAuditGateOffNoSideEffect(t *testing.T) {
// AC1/AC5：门控默认关（不设 env），开启函数必须零副作用。
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT", "")
tmp := filepath.Join(t.TempDir(), "audit.log")
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT_LOG", tmp)
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT_RATIO", "1.0") // 即便抽样=100%也必须不动作
in := DistillInput{EpisodeID: "ep_gate_off", Content: "牧尘决定把蒸馏模型换掉"}
MaybeAdversarialAudit(in, []string{"一条事实"})
if _, err := os.Stat(tmp); !os.IsNotExist(err) {
t.Fatalf("门控关时不应创建影子日志文件: %v", err)
}
}
func TestAdvAuditGateOffWhenDisabledExplicit(t *testing.T) {
// 显式置 0 → 关，零行为变化。
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT", "0")
tmp := filepath.Join(t.TempDir(), "audit.log")
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT_LOG", tmp)
MaybeAdversarialAudit(DistillInput{EpisodeID: "ep0"}, []string{"f"})
if _, err := os.Stat(tmp); !os.IsNotExist(err) {
t.Fatalf("ZHIYI_ADVERSARIAL_AUDIT=0 时应关，不应写日志: %v", err)
}
}
func TestAdvAuditGateOnWritesLog(t *testing.T) {
// AC2：打开门控 + 同步 auditOne → 影子日志有真实记录（≥3 条 verdict）。
verdicts := `[{"fact":"牧尘决定把蒸馏模型换掉","verdict":"supported","reason":"原文明确支持"},
{"fact":"牧尘喜欢苹果","verdict":"hallucination","reason":"原文未提及"},
{"fact":"牧尘讨厌苹果","verdict":"contradiction","reason":"与原文相反"}]`
srv, _ := fakeAuditServer(t, verdicts)
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT", "1")
tmp := filepath.Join(t.TempDir(), "audit.log")
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT_LOG", tmp)
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT_ENDPOINT", srv.URL)
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT_MODEL", "deepseek-v4-flash")
err := auditOne(DistillInput{EpisodeID: "ep1", Content: "牧尘决定把蒸馏模型换掉", Source: "wiki:test"}, []string{"牧尘决定把蒸馏模型换掉"})
if err != nil {
t.Fatalf("auditOne err: %v", err)
}
b, rerr := os.ReadFile(tmp)
if rerr != nil {
t.Fatalf("读影子日志失败: %v", rerr)
}
lines := strings.Split(strings.TrimSpace(string(b)), "\n")
if len(lines) < 3 {
t.Fatalf("影子日志应有 ≥3 条，实际 %d 条:\n%s", len(lines), string(b))
}
// 校验首行字段完整（episode / fact / verdict）
var row map[string]interface{}
if err := json.Unmarshal([]byte(lines[0]), &row); err != nil {
t.Fatalf("日志首行非 JSON: %v", err)
}
if row["episode"] != "ep1" || row["fact"] != "牧尘决定把蒸馏模型换掉" || row["verdict"] != "supported" {
t.Fatalf("日志行字段不完整: %v", row)
}
// 校验确有矛盾/幻觉判定
if !strings.Contains(string(b), "contradiction") || !strings.Contains(string(b), "hallucination") {
t.Fatalf("日志应含 contradiction 与 hallucination 判定:\n%s", string(b))
}
}
func TestAdvAuditParseMarkdownFence(t *testing.T) {
// 解析健壮性：模型输出带 ```json fence + 前后杂质。
raw := "好的，这是结果：\n```json\n[{\"fact\":\"A\",\"verdict\":\"supported\",\"reason\":\"r\"},{\"fact\":\"B\",\"verdict\":\"hallucination\",\"reason\":\"r2\"}]\n```"
v := parseAuditVerdicts(raw)
if len(v) != 2 {
t.Fatalf("应解析出 2 条 verdict，实际 %d: %+v", len(v), v)
}
if v[0].Verdict != "supported" || v[1].Verdict != "hallucination" {
t.Fatalf("verdict 解析错误: %+v", v)
}
}
func TestAdvAuditParseGarbage(t *testing.T) {
// 完全无法解析 → 空切片，不 panic。
if v := parseAuditVerdicts("抱歉，我无法完成该任务。"); v != nil && len(v) != 0 {
t.Fatalf("垃圾输入应返回空，实际 %+v", v)
}
if v := parseAuditVerdicts(""); len(v) != 0 {
t.Fatalf("空输入应返回空")
}
}
func TestAdvAuditModelIsDifferentSource(t *testing.T) {
// AC3：审计模型默认 = deepseek-v4-flash（NewAPI 免费腿），
// 与蒸馏主链的本地 2B（local/minicpm5-2b）不同源不同模型。
// 本测试校验默认端点/模型指向 NewAPI 而非本地 8081。
t.Setenv("ZHIYI_ADVERSARIAL_AUDIT", "1")
ep := envStr("ZHIYI_ADVERSARIAL_AUDIT_ENDPOINT", "http://127.0.0.1:3000/v1/chat/completions")
md := envStr("ZHIYI_ADVERSARIAL_AUDIT_MODEL", "deepseek-v4-flash")
if strings.Contains(ep, "8081") {
t.Fatalf("审计端点不得指向本地 2B（8081），实际 %s", ep)
}
if strings.Contains(md, "minicpm5") {
t.Fatalf("审计模型不得为本地 2B，实际 %s", md)
}
t.Logf("默认审计端点=%s 模型=%s（异源：非本地 2B）", ep, md)
}
go/internal/distill/bitemporal.go
+159
View File
@@ -0,0 +1,159 @@
// 织忆 MemoryWeave — bi-temporal 有效期检测 + provenance（t_3ada332b，血统 Zep/Graphiti）
//
// 设计（方案C「长期正确性」）：时间敏感事实用【有效区间】(valid_from/valid_to) 而非删除。
// 双时间线：episode T'（CreatedAt，何时说的）+ 语义 T（valid_to 表达的失效终点）。
// non-lossy：失效只标区间，历史永久保留（可追溯、当前状态干净）。
// provenance：来源类型枚举 user|inferred|import —— 新语句不自动覆盖旧的（来源权威性）。
//
// ⚠️ 误报刹车（AC 止损线）：时间敏感识别误报（把常驻事实标成临时的）>5% → 收紧识别规则
// 只认【强时间词】+【带触发上下文的显式日期】，宽口径一律不进（宁漏不误伤）。
// 返回空串 = 永久有效（NULL 语义，读路径不降权）。
package distill
import (
"regexp"
"strings"
"time"
)
// 显式日期（绝对日期）触发词：只有紧邻这些上下文才解析，防把「生日是3月15日」这类常驻事实标成临时。
var dateTriggerRe = regexp.MustCompile(
`截止到|截止|截至|到|持续到|有效到|用到|在|于|(之前|前|为止|为止\b)`)
// dateTokenRe 匹配一个日期 token（含触发上下文内/前的日期片段）。
// 支持：2006-01-02 / 2006/01/02 / 2006年01月02日 / 01月02日 / 1月2号 / 1月2日
var dateTokenRe = regexp.MustCompile(
`(?:(\d{4})[年/\-])?(\d{1,2})月(\d{1,2})[日号]|(\d{4})[-/](\d{1,2})[-/](\d{1,2})`)
// DetectValidTo 识别时间敏感事实的失效终点（RFC3339；空串 = 永久有效）。
// now 为「本事实写入时刻」（episode T' 的审计时间），据此计算语义 T 的区间末端。
func DetectValidTo(content string, now time.Time) string {
// 0) 强时间词先于显式日期（"截止到这周" 这类，「这周」优先给周末）
// 只认【绝对强词】，避免「下」「这」单独出现的误判。
if s := matchStrongTimeWord(content, now); s != "" {
return s
}
// 1) 带触发上下文的显式日期（要求有 截止/到/之前/为止 等前后缀，否则太宽进）
if !dateTriggerRe.MatchString(content) {
return ""
}
if d := parseExplicitDate(content, now); d != "" {
return d
}
return ""
}
// DetectProvenance 从写入来源(source)字符串归一到 provenance 三枚举。
// 映射口径：显式 user/口头/直接用户 段 → user；import/导入/wiki(笔记通道) → import；
// agent/推断/inferred/llm/蒸馏 → inferred；其余兜底 → inferred。
func DetectProvenance(source string) string {
s := strings.ToLower(source)
switch {
case containsAny(s, []string{"user", "口头", "直接用户", "user_said", "直接说"}):
return "user"
case containsAny(s, []string{"import", "导入", "wiki:", "wiki/", "笔记通道", "从外部"}):
return "import"
case containsAny(s, []string{"agent", "inferred", "推断", "infer", "llm", "distill", "蒸馏", "autogen"}):
return "inferred"
default:
return "inferred"
}
}
// matchStrongTimeWord 只认强时间词，命中即返回对应区间末端。
func matchStrongTimeWord(content string, now time.Time) string {
// 顺序：长词在前避免「这个月」被「这」提前命中（我们只精确匹配完整词）。
type kw struct {
word string
end func(time.Time) time.Time
}
table := []kw{
{"这个月", endOfThisMonth},
{"本月", endOfThisMonth},
{"下周", endOfNextWeek},
{"这周", endOfThisWeek},
{"本周", endOfThisWeek},
{"今晚", endOfToday},
{"今天", endOfToday},
{"今日", endOfToday},
{"明天", endOfTomorrow},
{"临时", addDays7},
{"暂定", addDays7},
{"暂时", addDays7},
}
for _, k := range table {
if strings.Contains(content, k.word) {
return k.end(now).Format(time.RFC3339)
}
}
return ""
}
func endOfToday(now time.Time) time.Time {
return dayEnd(now)
}
func endOfTomorrow(now time.Time) time.Time {
return dayEnd(now.AddDate(0, 0, 1))
}
func endOfThisWeek(now time.Time) time.Time {
// 周日起 0，距下周日天数 = (7 - weekday) % 7（今天周日 → 0 → 今天）
days := (7 - int(now.Weekday())) % 7
return dayEnd(now.AddDate(0, 0, days))
}
func endOfNextWeek(now time.Time) time.Time {
days := (7 - int(now.Weekday())) % 7
return dayEnd(now.AddDate(0, 0, days+7))
}
func endOfThisMonth(now time.Time) time.Time {
first := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
return dayEnd(first.AddDate(0, 1, -1)) // 下月1号 -1天 = 月末
}
func addDays7(now time.Time) time.Time {
return now.Add(7 * 24 * time.Hour)
}
func dayEnd(t time.Time) time.Time {
y, m, d := t.Date()
return time.Date(y, m, d, 23, 59, 59, 0, t.Location())
}
// parseExplicitDate 在带触发词的上下文里找日期 token 并解析为「当日 23:59:59」。
func parseExplicitDate(content string, now time.Time) string {
loc := now.Location()
for _, m := range dateTokenRe.FindAllStringSubmatch(content, -1) {
var y, mo, d int
switch {
case m[2] != "" && m[3] != "":
// 月日式：M月D日 / M月D号（m[1] 可空=今年）
mo = atoiSafe(m[2])
d = atoiSafe(m[3])
y = now.Year()
if m[1] != "" {
y = atoiSafe(m[1])
}
case m[4] != "" && m[5] != "" && m[6] != "":
// 完整式：YYYY-MM-DD / YYYY/MM/DD
y = atoiSafe(m[4])
mo = atoiSafe(m[5])
d = atoiSafe(m[6])
default:
continue
}
if mo < 1 || mo > 12 || d < 1 || d > 31 {
continue
}
return dayEnd(time.Date(y, time.Month(mo), d, 0, 0, 0, 0, loc)).Format(time.RFC3339)
}
return ""
}
func atoiSafe(s string) int {
n := 0
for _, c := range s {
if c < '0' || c > '9' {
return 0
}
n = n*10 + int(c-'0')
}
return n
}
go/internal/distill/bitemporal_test.go
+111
View File
@@ -0,0 +1,111 @@
// 织忆 MemoryWeave — bi-temporal 写时识别测试（t_3ada332b）
//
// 验证：
// ① DetectValidTo：强时间词/带上下文显式日期 → 区间末端；常驻事实（无时间词/无触发上下文）→ ""（不误伤）
// ② DetectProvenance：user/inferred/import 三来源归一
package distill
import (
"strings"
"testing"
"time"
)
// 固定审计时刻：2026-10-14（周三）UTC，便于确定性断言。
var btNow = time.Date(2026, 10, 14, 10, 0, 0, 0, time.UTC)
func TestDetectValidTo_StrongTimeWords(t *testing.T) {
cases := []struct {
in string
want string // 期望 valid_to（RFC3339）
desc string
}{
{"牧尘这周在 Berlin", "2026-10-18T23:59:59Z", "这周→本周日"},
{"本周要发布版本", "2026-10-18T23:59:59Z", "本周→本周日"},
{"下周去开会", "2026-10-25T23:59:59Z", "下周→下周日"},
{"今天要交报告", "2026-10-14T23:59:59Z", "今天→当日末"},
{"明天安排体检", "2026-10-15T23:59:59Z", "明天→次日末"},
{"这个月完成迁移", "2026-10-31T23:59:59Z", "这个月→月末"},
{"临时使用测试机", "", "临时→(非精确，仅断言非空，见下)"}, // 临时 = now+7d，逐条单测
}
for _, c := range cases {
got := DetectValidTo(c.in, btNow)
if c.desc == "临时→(非精确，仅断言非空，见下)" {
if got == "" {
t.Fatalf("DetectValidTo(%q) 应非空（临时→+7天），实际空", c.in)
}
continue
}
if got != c.want {
t.Errorf("✗ DetectValidTo(%q)=%q，want %q（%s）", c.in, got, c.want, c.desc)
} else {
t.Logf("✓ %s: %q → %s", c.desc, c.in, got)
}
}
}
// 临时/暂定 → now + 7 天（精确）。
func TestDetectValidTo_Temporary(t *testing.T) {
got := DetectValidTo("临时使用测试机", btNow)
want := btNow.Add(7 * 24 * time.Hour).Format(time.RFC3339)
if got != want {
t.Fatalf("✗ 临时→now+7d：got %q want %q", got, want)
}
t.Logf("✓ 临时→now+7d: %s", got)
}
// 常驻事实不得被误判成临时（AC 止损线：误报>5% → 收紧只认强词，宽口径不进）。
func TestDetectValidTo_NoFalsePositive(t *testing.T) {
permanent := []string{
"牧尘住在北京", // 常驻地址
"牧尘在招商局工作", // 常驻工作
"牧尘生日是3月15日", // 显式日期但【无触发上下文】→ 不解析（防生日/纪念日被标临时）
"系统使用 PostgreSQL", // 技术选型
"我偏好简洁的回答", // 用户偏好
"当前模型是 deepseek-v4", // 当前配置（无临时词）
}
for _, in := range permanent {
if got := DetectValidTo(in, btNow); got != "" {
t.Errorf("✗ 常驻事实被误判临时: %q → %s（应空=永久有效）", in, got)
}
}
t.Logf("✓ %d 条常驻事实均未被误判（误报止损线）", len(permanent))
}
// 带触发上下文的显式日期才解析。
func TestDetectValidTo_ExplicitDateWithTrigger(t *testing.T) {
cases := []struct{ in, want string }{
{"截止到2026-03-15", "2026-03-15T23:59:59Z"},
{"合同截至2026年12月31日", "2026-12-31T23:59:59Z"},
{"这个权限在3月20日前有效", "2026-03-20T23:59:59Z"},
}
for _, c := range cases {
got := DetectValidTo(c.in, btNow)
if got != c.want {
t.Errorf("✗ DetectValidTo(%q)=%q want %q", c.in, got, c.want)
} else {
t.Logf("✓ %q → %s", c.in, got)
}
}
}
func TestDetectProvenance(t *testing.T) {
cases := []struct{ in, want string }{
{"user", "user"}, {"user said", "user"}, {"牧尘口头", "user"},
{"import", "import"}, {"wiki:xxx", "import"},
{"agent", "inferred"}, {"agent inferred", "inferred"}, {"llm_distill", "inferred"},
{"", "inferred"}, // 兜底 → inferred（保守，不误标 user/import）
}
for _, c := range cases {
if got := DetectProvenance(c.in); got != c.want {
t.Errorf("✗ DetectProvenance(%q)=%q want %q", c.in, got, c.want)
}
}
// 三来源各覆盖至少一次
if !strings.Contains("user inferred import", DetectProvenance("user")) ||
!strings.Contains("user inferred import", DetectProvenance("import")) ||
!strings.Contains("user inferred import", DetectProvenance("agent")) {
t.Fatal("三来源枚举未全覆盖")
}
t.Logf("✓ DetectProvenance 三来源归一 user/inferred/import 正确")
}
go/internal/distill/consolidate.go
+1 -1
View File
@@ -147,7 +147,7 @@ type MemoryCandidate struct {
// ConsolidateInput 整合输入
type ConsolidateInput struct {
Target MemoryCandidate
Target MemoryCandidate
Candidates []MemoryCandidate
}
go/internal/distill/cost_control.go
+11 -11
View File
@@ -13,9 +13,9 @@ type CostController struct {
mu sync.Mutex
// 每日限额
dailyLimit int
dailyUsed int
lastReset time.Time
dailyLimit int
dailyUsed int
lastReset time.Time
// 紧急蒸馏豁免计数
urgentUsed int
@@ -117,12 +117,12 @@ func (cc *CostController) checkReset() {
// DistillQuota 蒸馏配额
type DistillQuota struct {
Remaining int `json:"remaining"`
Used int `json:"used"`
Limit int `json:"limit"`
Percent float64 `json:"percent"`
NearLimit bool `json:"near_limit"`
Status string `json:"status"` // normal / near / exceeded
Remaining int `json:"remaining"`
Used int `json:"used"`
Limit int `json:"limit"`
Percent float64 `json:"percent"`
NearLimit bool `json:"near_limit"`
Status string `json:"status"` // normal / near / exceeded
}
// GetQuota 获取当前配额状态
@@ -151,8 +151,8 @@ func (cc *CostController) GetQuota() DistillQuota {
// ─── 限额配置 ─────────────────────────────────────────────
type CostConfig struct {
DailyLimit int `json:"daily_limit"` // 默认 5000
ConsolidationBudget int `json:"consolidation_budget"` // 默认 20
DailyLimit int `json:"daily_limit"` // 默认 5000
ConsolidationBudget int `json:"consolidation_budget"` // 默认 20
}
// DefaultCostConfig 默认配置
go/internal/distill/distill_parser.go
+24 -3
View File
@@ -14,6 +14,7 @@ package distill
import (
"bufio"
"encoding/json"
"log"
"strconv"
"strings"
)
@@ -208,6 +209,21 @@ func parseJSONFormat(raw string) (LLMResponse, bool) {
// 第一级行协议优先（LLM 被训练成行协议输出）；若未识别到任何行（如模型仍产 JSON），
// 落到第二级旧 JSON 兜底；两级都空则返回空 LLMResponse（最差空切片，不返回 error）。
// 这样上游 distillOne 对「解析不出」走启发式提取，而不是把整条 episode 当空结果丢掉。
//
// 2026-10-12：两条分支的返回值都过一遍 StripPromptEcho —— 实测 2B 会把 prompt
// 「重要指令」块里的教学示例（「用户昨天买了苹果。」「Galway, Ireland」…）原样抄进输出，
// 解析器照单全收 ⇒ 示例事实被质量门丢光（生产 facts=0 达 301 次）+ 示例实体污染图谱。
// 此处是**唯一咽喉**（engine.go 只从此处取 LLM 结果），防线放这里两条路径都覆盖。
// logEchoStrip 只在实际剔除时打一行（生产用它验证防线在跑，且能看到被剔的是不是示例）。
func logEchoStrip(path string, st EchoStats) {
if st.Total() == 0 {
return
}
log.Printf("[distill][ECHO] path=%s 剔除教学示例回显 %d 项（facts=%d entities=%d other=%d allFactsEcho=%v）样例=%q",
path, st.Total(), st.FactsDropped, st.EntitiesDropped, st.OtherDropped, st.AllFactsWereEcho,
truncate(st.Sample, 40))
}
func parseDistillOutput(raw string) LLMResponse {
facts, entities, scores, ok := ParseLineFormat(raw)
if ok {
@@ -215,7 +231,7 @@ func parseDistillOutput(raw string) LLMResponse {
for _, en := range entities {
names = append(names, en.Name)
}
return LLMResponse{
resp, st := StripPromptEcho(LLMResponse{
IS: scores.IS,
SU: scores.SU,
PA: scores.PA,
@@ -223,10 +239,15 @@ func parseDistillOutput(raw string) LLMResponse {
RU: scores.RU,
Facts: facts,
Entities: names,
}
})
logEchoStrip("line", st)
return resp
}
if resp, ok2 := parseJSONFormat(raw); ok2 {
var st EchoStats
resp, st = StripPromptEcho(resp)
logEchoStrip("json", st)
return resp
}
return LLMResponse{}
}
}
go/internal/distill/distill_parser_test.go
+1 -1
View File
@@ -194,4 +194,4 @@ func TestDistillOutputFormat_DefaultLines(t *testing.T) {
if got := distillOutputFormat(); strings.ToLower(got) != "lines" {
t.Fatalf("默认 OutputFormat 应为 lines，实际=%s", got)
}
}
}
go/internal/distill/echo_guard.go
+260
View File
@@ -0,0 +1,260 @@
package distill
import (
"strings"
"unicode"
"unicode/utf8"
)
// ─── 教学示例回显防线（2026-10-12）─────────────────────────────────────────
//
// 起因（生产实测）：prompt 的「重要指令」块为了让 2B 理解格式而写的**示例取值**，
// 被模型整段照抄进输出。解析器无法分辨「示例」与「真抽取」，于是照单全收：
//
// · 抄来的示例事实（如「用户昨天买了苹果。」= 9 字）< 20 字 → 被质量门丢光
// ⇒ 生产日志 `facts=0` 出现 301 次（约 76% 的 episode 产出为零）
// · 抄来的示例实体（The Name of the Wind by Patrick Rothfuss / Galway, Ireland /
// 慈善篮球赛 / 某饮料公司 …）会被当真实实体写进记忆图谱 ⇒ 垃圾节点
// · 抄来的示例评分行（若模型把示例数值一并抄出）
//
// ⚠️ 不要把「评分恒为 0.5」也算到这个账上：现 prompt 里没有 0.5 的示例，
// 而 IsDegenerateScore 的实测说明模型**本就会**合法地给出五维同值（0.8×5 / 0.0×5）。
// 0.5×5 的成因未证实，不归因（2026-10-12 自查撤回）。
//
// 判据：**逐字相同**（归一化后）才算回显；对纯教学 illustration 额外允许
// 「≥4 字的子串」命中（用于抓 John / Patrick Rothfuss 这类被拆碎的残片）。
//
// 为什么不一律用子串：格式说明类字面量里含**真实 token**（如「牵挂: … 待办.md …」），
// 用子串会把真实实体「待办.md」误杀 → 故这类只认整体逐字相同（allowSubstr=false）。
//
// 代价不对称：漏掉一条回显 = 永久污染记忆；误杀一条恰好像示例的短事实 = 损失一条低信息事实。
type echoLiteral struct {
text string
allowSubstr bool // true=纯教学 illustration，≥4 字子串也算回显
}
var promptEchoLiterals = []echoLiteral{
// —— 事实改写示例（prompt「2. 进行轻量上下文补全」）——
{"用户今早喝了咖啡", true},
{"用户昨天买了苹果。", true},
{"用户的朋友John在学医。", true},
{"你好", false},
{"哈哈", false},
{"谢谢", false},
// —— 「3. 保留所有具体实体和细节」的 illustration：纯教学，允许子串命中 ——
{"The Name of the Wind by Patrick Rothfuss", true},
{"一本书", false},
{"Galway, Ireland", true},
{"北京海淀区", true},
{"慈善篮球赛", true},
{"留学项目", true},
{"某饮料公司", true},
{"4年前", false},
{"下个月", false},
{"上周", false},
// —— 结构化前缀示例：含真实 token（待办.md）→ 只认整体逐字相同 ——
{"牵挂: 待处理: 待办.md 里已打勾的旧条目清理", false},
// —— 输出格式占位符（模型常把这些当内容抄出来）——
{"独立事实1", false},
{"独立事实2", false},
{"决定1", false},
{"结论1", false},
{"行动1", false},
{"问题1", false},
{"entity1", false},
{"entity2", false},
{"实体名", false},
{"实体类型", false},
{"五个数字用竖线分隔", false},
}
// normalizeEcho 归一化：去首尾空白 + 去尾部句读（模型常省/加句号）。
func normalizeEcho(s string) string {
s = strings.TrimSpace(s)
return strings.TrimRight(s, "。．.!！?？~～、,， ")
}
// IsPromptEcho 判断一条事实/实体名是否只是 prompt 教学示例的回显。
func IsPromptEcho(s string) bool {
n := normalizeEcho(s)
if n == "" {
return false
}
nr := utf8.RuneCountInString(n)
for _, l := range promptEchoLiterals {
ln := normalizeEcho(l.text)
if ln == "" {
continue
}
if n == ln {
return true
}
if l.allowSubstr && nr >= 4 && strings.Contains(ln, n) {
return true
}
}
return false
}
// ─── 概念/实体提取路径（[graph/notes] 兜底拆实体）──────────────────────────────
//
// 背景（GA-P0-5）：蒸馏侧 IsPromptEcho 只罩 LLM 输出的 facts/entities，图谱污染闭环
// 还有另一条腿 —— 审计笔记把污染词当证据列出来 → 笔记被蒸馏成 episode → 调用方把整句
// 提问原样传给 /api/v1/graph/notes → entity_index 从图谱节点名词表拆出候选实体 → 若
// 候选只是 prompt 教学示例的回显残片，会被当真实实体写回图谱 ⇒ 已删除的污染节点
// （n_galway / n_rothfuss / n_the_name_of_the_wind）被重建。
//
// 判据与 IsPromptEcho 完全同源（都读 promptEchoLiterals，清单本身零改动）：逐字相等
// （归一化后）或 illustration 类（allowSubstr=true）的 ≥4 字子串残片即算回显；占位符类
// （allowSubstr=false）只认逐字相等。唯一差别是输入形态：图谱节点名是「n_the_name_of_the_wind」
// 这种规整形，需先还原成可读文本（去 n_、下划线→空格、小写）再比对。
//
// GA-P0-6 补两层判据（都从 9 条 allowSubstr=true 的 illustration 派生，清单本身零改动）：
// 1. 标点/空格不敏感 —— 实体侧 `galway ireland` 与字面量 `Galway, Ireland` 因内部逗号
// 差异既不等也不构成子串 ⇒ 比对前两侧都剥成「只留字母数字汉字」，等价即拦。
// 这正是图谱节点名最常见的形态（该家族第 1 轮漏删也栽在这个逗号上）。
// 2. 多示例词并列 —— 审计散文被蒸馏/拆实体后产出形如「A_B_示例词1_示例词2_…」的节点。
// 候选若包含整条 illustration 字面量（归一化后），或含 ≥2 个 illustration 显著 token
// （promptEchoTokens），判回显；单 token（只出现 1 个）不拦，保留给真实讨论。
//
// 与 IsPromptEcho 一样**只拦「逐字相等/残片」级**，不拦普通包含 —— 例如「用户提到
// galway」里 galway 若是真实实体，只要它不在某条示例字面量的残片里就放行；误杀面与
// 蒸馏侧一致（那里已实测会杀 John / Patrick Rothfuss 这类单字残片）。
func IsPromptEchoEntity(s string) bool {
n := normalizeEchoEntity(s)
if n == "" {
return false
}
nk := compareKey(strings.ToLower(n))
nr := utf8.RuneCountInString(n)
// 判据二：≥2 个 illustration 显著 token 并列 ⇒ 示例词被拼进同一节点名。
if tokenEchoCount(nk) >= 2 {
return true
}
for _, l := range promptEchoLiterals {
ln := strings.ToLower(normalizeEcho(l.text))
if ln == "" {
continue
}
lk := compareKey(ln)
if nk == lk {
return true
}
if l.allowSubstr && nr >= 4 && strings.Contains(lk, nk) && tokenEchoCount(nk) >= 1 {
return true
}
// 判据二：候选包含整条 illustration 字面量 ⇒ 示例词被拼进长节点名。
if l.allowSubstr && strings.Contains(nk, lk) {
return true
}
}
return false
}
// normalizeEchoEntity 把图谱节点名归一成可与字面量比对的形态。
func normalizeEchoEntity(s string) string {
s = strings.TrimPrefix(s, "n_")
s = strings.ReplaceAll(s, "_", " ")
s = strings.ToLower(s)
return normalizeEcho(s)
}
// promptEchoTokens：从 9 条 allowSubstr=true 的 illustration 里提取的显著 token
// （地名/人名/书名/活动名/公司名）。候选节点名若包含 ≥2 个 ⇒ 判为多示例词并列的回显。
// 单 token（只出现 1 个）不拦 —— 如「northern ireland」只含 ireland，保留给真实讨论。
var promptEchoTokens = []string{
"john", // 人名（用户的朋友John在学医。）
"rothfuss", // 人名（The Name of the Wind by Patrick Rothfuss）
"the name of the wind", // 书名
"galway", // 地名
"ireland", // 地区
"北京海淀区", // 地名
"慈善篮球赛", // 活动名
"留学项目", // 活动名
"某饮料公司", // 公司名
}
// tokenEchoCount 统计 key 命中的 illustration 显著 token 数。
func tokenEchoCount(key string) int {
c := 0
for _, t := range promptEchoTokens {
if strings.Contains(key, compareKey(strings.ToLower(t))) {
c++
}
}
return c
}
// compareKey 把字符串压成「只留字母数字汉字」的形态（去掉所有标点/空白），
// 用于标点/空格不敏感比对：`galway ireland` 与 `galway, ireland` 视为相同。
func compareKey(s string) string {
var b strings.Builder
for _, r := range s {
if unicode.IsLetter(r) || unicode.IsDigit(r) {
b.WriteRune(r)
}
}
return b.String()
}
// EchoStats 记录本次剔除量，供日志观测。
type EchoStats struct {
FactsDropped int
EntitiesDropped int
OtherDropped int
AllFactsWereEcho bool // 全部事实都是回显 ⇒ 本次 LLM 输出对事实部分无效
Sample string // 第一条被剔除的原文（生产日志据此确认"是不是示例"）
}
// Total 返回被剔除的条目总数。
func (s EchoStats) Total() int { return s.FactsDropped + s.EntitiesDropped + s.OtherDropped }
// StripPromptEcho 剔除回显项。
//
// 若事实**全部**来自回显 ⇒ 连评分一起作废（评分行与事实同源，都是抄来的），
// 并清空其余字段，返回空 LLMResponse，让上游落到「从原文启发式提取」而不是
// 把示例当产出入库。这是**结构化降级**：系统仍产出东西，但不产出垃圾。
func StripPromptEcho(resp LLMResponse) (LLMResponse, EchoStats) {
var st EchoStats
keep := func(in []string) []string {
if len(in) == 0 {
return in
}
out := make([]string, 0, len(in))
for _, s := range in {
if IsPromptEcho(s) {
if st.Sample == "" {
st.Sample = s
}
continue
}
out = append(out, s)
}
return out
}
beforeFacts := len(resp.Facts)
resp.Facts = keep(resp.Facts)
st.FactsDropped = beforeFacts - len(resp.Facts)
beforeEnt := len(resp.Entities)
resp.Entities = keep(resp.Entities)
st.EntitiesDropped = beforeEnt - len(resp.Entities)
beforeOther := len(resp.Decisions) + len(resp.Conclusions) + len(resp.ActionsTaken) + len(resp.OpenQuestions)
resp.Decisions = keep(resp.Decisions)
resp.Conclusions = keep(resp.Conclusions)
resp.ActionsTaken = keep(resp.ActionsTaken)
resp.OpenQuestions = keep(resp.OpenQuestions)
st.OtherDropped = beforeOther - (len(resp.Decisions) + len(resp.Conclusions) + len(resp.ActionsTaken) + len(resp.OpenQuestions))
if beforeFacts > 0 && len(resp.Facts) == 0 {
st.AllFactsWereEcho = true
// 评分与事实同源 ⇒ 一起作废（避免把示例评分当有效判断喂给分道逻辑）
return LLMResponse{}, st
}
return resp, st
}
go/internal/distill/echo_guard_liveprobe_test.go
+72
View File
@@ -0,0 +1,72 @@
//go:build liveprobe
package distill
import (
"fmt"
"net/http"
"strings"
"testing"
"time"
)
// TestEchoLiveProbe 直连真模型，验证「教学示例回显防线」在**真实输出**上生效。
//
// 单测喂的是我构造的文本；本探针喂的是模型**真的吐出来的东西**——
// 这才是「防线在生产路径上起作用」的证据（判据：模型真输出里出现了示例字面量，
// 且经 parseDistillOutput 后不再出现在 facts/entities 里）。
//
// go test ./internal/distill/ -tags liveprobe -run TestEchoLiveProbe -v -count=1
func TestEchoLiveProbe(t *testing.T) {
tmpl := extractPromptTemplate(t)
client := &http.Client{Timeout: 180 * time.Second}
cases := []struct{ name, content string }{
{"A-易诱发回显(苹果/John)", "[2026-10-12, 周一] 牧尘: 昨天买了苹果\n[2026-10-12, 周一] 牧尘: 我朋友John在学医"},
{"B-真实工作规则", "[2026-10-12, 周一] 牧尘: 全绿不代表能用，要实际能用，满足使用\n[2026-10-12, 周一] 小怡: 记下了，判据要覆盖真实路径而不是只看配置"},
{"C-纯寒暄(应无事实)", "[2026-10-12, 周一] 牧尘: 你好\n[2026-10-12, 周一] 小怡: 哈哈\n[2026-10-12, 周一] 牧尘: 谢谢"},
{"D-长文多实体", "[2026-10-12, 周一] 牧尘: 我在淇县负责生物制造产业专班和卫都街道，设备是小米笔记本，平时喜欢马哲经济学和剪辑。"},
}
stripTotal, echoSeen := 0, 0
for _, c := range cases {
raw := callRaw(t, client, fmt.Sprintf(tmpl, c.content))
// ① 未经防线：模型原始输出解析出什么
facts, ents, sc, ok := ParseLineFormat(raw)
var names []string
for _, e := range ents {
names = append(names, e.Name)
}
rawEcho := 0
for _, f := range facts {
if IsPromptEcho(f) {
rawEcho++
}
}
for _, e := range names {
if IsPromptEcho(e) {
rawEcho++
}
}
// ② 经防线（= 生产路径）
after, st := StripPromptEcho(LLMResponse{
IS: sc.IS, SU: sc.SU, PA: sc.PA, VD: sc.VD, RU: sc.RU,
Facts: facts, Entities: names,
})
stripTotal += st.Total()
if rawEcho > 0 {
echoSeen++
}
t.Logf("\n══════ %s ══════", c.name)
t.Logf("模型原始: %s", strings.ReplaceAll(strings.TrimSpace(raw), "\n", " ⏎ "))
t.Logf("防线前 : facts=%v entities=%v ok=%v 其中回显=%d", facts, names, ok, rawEcho)
t.Logf("防线后 : facts=%v entities=%v", after.Facts, after.Entities)
t.Logf("剔除 : facts=%d entities=%d other=%d allEcho=%v 样例=%q",
st.FactsDropped, st.EntitiesDropped, st.OtherDropped, st.AllFactsWereEcho, st.Sample)
}
t.Logf("\n══════ 汇总：%d/%d 条真实输出含回显，共剔除 %d 项 ══════", echoSeen, len(cases), stripTotal)
}
go/internal/distill/echo_guard_test.go
+272
View File
@@ -0,0 +1,272 @@
package distill
import (
"os"
"strings"
"testing"
)
// ─── 漂移护栏：字面量清单必须仍与 prompt 同源 ───────────────────────────────
//
// 清单是「按 prompt 原文抄下来的」——prompt 一改，清单就过期（防线静默失效）。
// 故逐条断言它仍出现在 engine.go 里。这条测试红了 = prompt 改过，去核对清单。
func TestPromptEchoLiteralsExistInPromptSource(t *testing.T) {
src, err := os.ReadFile("engine.go")
if err != nil {
t.Fatalf("读 engine.go 失败: %v", err)
}
s := string(src)
missing := []string{}
for _, l := range promptEchoLiterals {
if !strings.Contains(s, l.text) {
missing = append(missing, l.text)
}
}
if len(missing) > 0 {
t.Fatalf("以下回显字面量已不在 engine.go 里（prompt 被改过？清单过期 ⇒ 防线静默失效）:\n %s",
strings.Join(missing, "\n "))
}
}
// ─── 判据本身 ─────────────────────────────────────────────────────────────
func TestIsPromptEcho_Exact(t *testing.T) {
yes := []string{
"用户昨天买了苹果。",
"用户昨天买了苹果", // 归一化：缺句号同样算
"The Name of the Wind by Patrick Rothfuss",
"Galway, Ireland",
"慈善篮球赛",
"某饮料公司",
"牵挂: 待处理: 待办.md 里已打勾的旧条目清理",
"独立事实1",
"实体名",
}
for _, s := range yes {
if !IsPromptEcho(s) {
t.Errorf("应判为回显但未判：%q", s)
}
}
}
// 子串规则只对「纯教学 illustration」生效；格式说明类里含真实 token（待办.md）
// ⇒ 必须只认整体逐字相同，否则会把真实实体「待办.md」误杀。
func TestIsPromptEcho_SubstringOnlyForIllustration(t *testing.T) {
if !IsPromptEcho("John") {
t.Error("「John」是「用户的朋友John在学医。」里被拆出来的残片，应判为回显")
}
if !IsPromptEcho("Patrick Rothfuss") {
t.Error("「Patrick Rothfuss」是示例书名的残片，应判为回显")
}
if IsPromptEcho("待办.md") {
t.Error("「待办.md」是真实实体，绝不能因为出现在格式说明示例里就被杀")
}
}
func TestIsPromptEcho_RealFactsNotDropped(t *testing.T) {
no := []string{
"用户上周去了北京并签了合同", // 含「上周」但不是逐字相同
"小怡把生产缓存切到 Redis L2 并设了 7 天 TTL",
"这份报告的第 4 年前的数据无法核对",
"",
}
for _, s := range no {
if IsPromptEcho(s) {
t.Errorf("真实事实被误杀：%q", s)
}
}
}
// ─── 剔除逻辑 ─────────────────────────────────────────────────────────────
func TestStripPromptEcho_PartialKeepsReal(t *testing.T) {
in := LLMResponse{
IS: 0.6, SU: 0.5, PA: 0.4, VD: 0.3, RU: 0.2,
Facts: []string{"用户昨天买了苹果。", "小怡把生产缓存切到 Redis L2 并设了 7 天 TTL"},
Entities: []string{"Galway, Ireland", "Redis"},
}
out, st := StripPromptEcho(in)
if st.FactsDropped != 1 || st.EntitiesDropped != 1 {
t.Fatalf("剔除计数不对: %+v", st)
}
if len(out.Facts) != 1 || out.Facts[0] != "小怡把生产缓存切到 Redis L2 并设了 7 天 TTL" {
t.Fatalf("真实事实应保留: %v", out.Facts)
}
if len(out.Entities) != 1 || out.Entities[0] != "Redis" {
t.Fatalf("真实实体应保留: %v", out.Entities)
}
if out.IS != 0.6 || out.RU != 0.2 {
t.Fatalf("部分回显不应作废评分: %+v", out)
}
if st.AllFactsWereEcho {
t.Fatal("还有真实事实，不应标记 AllFactsWereEcho")
}
}
func TestStripPromptEcho_AllEchoVoidsEverything(t *testing.T) {
in := LLMResponse{
IS: 0.5, SU: 0.5, PA: 0.5, VD: 0.5, RU: 0.5,
Facts: []string{"用户昨天买了苹果。", "用户的朋友John在学医。"},
Entities: []string{"The Name of the Wind by Patrick Rothfuss", "北京海淀区"},
}
out, st := StripPromptEcho(in)
if !st.AllFactsWereEcho {
t.Fatal("全是回显，应标记 AllFactsWereEcho")
}
if len(out.Facts) != 0 || len(out.Entities) != 0 {
t.Fatalf("应清空: %+v", out)
}
// 评分与事实同源 ⇒ 一起作废（不能把示例评分当有效判断）
if out.IS != 0 || out.SU != 0 || out.PA != 0 || out.VD != 0 || out.RU != 0 {
t.Fatalf("评分应作废: %+v", out)
}
}
// ─── 端到端：走唯一咽喉 ───────────────────────────────────────────────────
func TestParseDistillOutput_FiltersEchoEndToEnd(t *testing.T) {
raw := "FACT|用户昨天买了苹果。\n" +
"FACT|用户的朋友John在学医。\n" +
"ENTITY|Galway, Ireland|location\n" +
"SCORE|0.5|0.5|0.5|0.5|0.5\nEND"
got := parseDistillOutput(raw)
if len(got.Facts) != 0 || len(got.Entities) != 0 {
t.Fatalf("整段回显应被清空: %+v", got)
}
if got.IS != 0 || got.RU != 0 {
t.Fatalf("回显评分应作废: %+v", got)
}
}
func TestParseDistillOutput_MixedKeepsReal(t *testing.T) {
raw := "FACT|用户昨天买了苹果。\n" +
"FACT|小怡把生产缓存切到 Redis L2 并设了 7 天 TTL\n" +
"ENTITY|Redis|tool\n" +
"SCORE|0.6|0.5|0.4|0.3|0.2\nEND"
got := parseDistillOutput(raw)
if len(got.Facts) != 1 || !strings.Contains(got.Facts[0], "Redis L2") {
t.Fatalf("真实事实应保留: %+v", got.Facts)
}
if len(got.Entities) != 1 || got.Entities[0] != "Redis" {
t.Fatalf("真实实体应保留: %+v", got.Entities)
}
if got.IS != 0.6 || got.RU != 0.2 {
t.Fatalf("评分应保留: %+v", got)
}
}
// ─── 概念/实体提取路径（GA-P0-5）────────────────────────────────────────────
//
// 图谱污染闭环第二腿：审计笔记把污染词当证据列出来 → 蒸馏成 episode → 兜底拆实体时
// 已删除的污染节点（n_galway / n_rothfuss / n_the_name_of_the_wind）被重建。
// IsPromptEchoEntity 把图谱节点名（规整形）归一后，按与 IsPromptEcho 同源判据拦截。
func TestIsPromptEchoEntity_RevivedNodesDropped(t *testing.T) {
// AC2：3 个复活节点（归一化形，含 n_ 前缀 / 下划线两种形态）经提取路径被 DROP。
revived := []string{
"n_galway", "galway",
"n_rothfuss", "rothfuss",
"n_the_name_of_the_wind", "the_name_of_the_wind",
"The Name of the Wind", // 人类可读残片
}
for _, s := range revived {
if !IsPromptEchoEntity(s) {
t.Errorf("污染节点应被 ECHO-DROP：%q", s)
}
}
}
func TestIsPromptEchoEntity_ExactMatchStillWorks(t *testing.T) {
// 逐字相等（归一化后）对实体路径同样生效 —— 与 IsPromptEcho 同源。
yes := []string{"用户昨天买了苹果。", "用户昨天买了苹果", "Galway, Ireland", "慈善篮球赛", "独立事实1"}
for _, s := range yes {
if !IsPromptEchoEntity(s) {
t.Errorf("应判为回显但未判：%q", s)
}
}
}
func TestIsPromptEchoEntity_RealEntitiesKept(t *testing.T) {
// AC3 正例：真实实体绝不能被误杀（≥5 个）。
real := []string{
"小怡", "牧尘", "招商台账", "Redis", "织忆", "待办.md",
"用户上周去了北京并签了合同",
"小怡把生产缓存切到 Redis L2 并设了 7 天 TTL",
}
for _, s := range real {
if IsPromptEchoEntity(s) {
t.Errorf("真实实体被误杀：%q", s)
}
}
}
func TestIsPromptEchoEntity_PlaceholderNotSubstring(t *testing.T) {
// 占位符类（allowSubstr=false）只认逐字相等：残片「待办」不该被「待办.md」示例杀。
no := []string{"待办", "实体名实体", "独立"}
for _, s := range no {
if IsPromptEchoEntity(s) {
t.Errorf("占位符类字面量不应做子串拦截，%q 被误杀", s)
}
}
}
// ─── 漂移护栏：3 个复活节点必须永远被拦 ──────────────────────────────────────
// 若 prompt 或字面量清单改动导致 galway/rothfuss/the_name_of_the_wind 漏网，
// 图谱污染闭环会静默复发 —— 这条红 = 清单过期，去核对 echo_guard.go。
func TestIsPromptEchoEntity_DriftGuardRevivedNodes(t *testing.T) {
mustCatch := []string{"n_galway", "n_rothfuss", "n_the_name_of_the_wind"}
for _, s := range mustCatch {
if !IsPromptEchoEntity(s) {
t.Fatalf("复活节点 %q 已漏网（清单过期/判据被改）⇒ 污染闭环复发", s)
}
}
}
// ─── GA-P0-6 返修 ─────────────────────────────────────────────────────────
//
// 问题 1（真 bug）：下划线/连字符连接的「地名+地区」形态。实体侧归一得 `galway ireland`
// （空格），字面量 `Galway, Ireland` 内部逗号被保留得 `galway, ireland` ⇒ 既不等也不构成
// 子串而被放行。这恰是图谱节点名最常见的形态 ⇒ 改为标点/空格不敏感后应被拦。
func TestIsPromptEchoEntity_PunctInsensitiveUnderlineVariant(t *testing.T) {
blocked := []string{
"n_galway_ireland", // 问题 1 主用例：下划线形「地名+地区」
"galway_ireland", // 去 n_ 前缀同形
"n_galway-ireland", // 连字符形
}
for _, s := range blocked {
if !IsPromptEchoEntity(s) {
t.Errorf("下划线/连字符连接的「地名+地区」回显应被拦：%q", s)
}
}
}
// 问题 2（补判据）：≥2 个 illustration 显著 token 并列拼进同一个节点名
// （形如 A_B_示例词1_示例词2_…）被放行 ⇒ 补拦。
func TestIsPromptEchoEntity_MultiTokenJuxtaposed(t *testing.T) {
blocked := []string{
"n_galway_rothfuss", // 地名+人名
"john_galway", // 人名+地名
"galway_慈善篮球赛", // 地名+活动名
"n_the_name_of_the_wind_galway", // 书名+地名
}
for _, s := range blocked {
if !IsPromptEchoEntity(s) {
t.Errorf("≥2 示例 token 并列应判回显：%q", s)
}
}
}
// 反例：单 token（只出现 1 个）不拦 —— 保留给真实讨论，避免误杀。
func TestIsPromptEchoEntity_SingleTokenNotBlocked(t *testing.T) {
kept := []string{
"northern ireland", // 真实地区，只含 ireland
"galway united", // 真实地名（Galway United），只含 galway
"north galway", // 真实地名，只含 galway
"john port", // 真实港口/人名，只含 john
}
for _, s := range kept {
if IsPromptEchoEntity(s) {
t.Errorf("单 token 出现 1 次不应被拦：%q", s)
}
}
}
go/internal/distill/echo_liveprobe_test.go
+1 -1
View File
@@ -109,4 +109,4 @@ func TestLiveScoreNotEcho(t *testing.T) {
t.Fatalf("❌ echo 向量 %v 出现 %d 次：照抄示例，治本失败", sc, n)
}
}
}
}
go/internal/distill/engine.go
+118 -26
View File
@@ -12,6 +12,7 @@ import (
"math/rand"
"net/http"
"os"
"strconv"
"strings"
"sync"
"sync/atomic"
@@ -95,6 +96,10 @@ type LLMResponse struct {
}
// LLM 5维权重
// 血统：借鉴 MemOS CREATE_EVAL_PROMPT（五维评估：IS 信息重要性 / SU 战略效用 /
// PA 实际适用性 / VD 验证持久性 / RU 召回可用性）。出处登记：
// ~/mc/小怡/01-织忆/01-01-定义规范/织忆-借鉴溯源-全清单.md §2.1。
// 取值 0.20/0.20/0.15/0.25/0.20 系 MemOS 血统参数，勿随意改（改前先研究分布）。
var Weights = FiveDScore{
IS: 0.20,
SU: 0.20,
@@ -113,6 +118,9 @@ var Weights = FiveDScore{
// 影子默认开启；设 ZHIYI_SCORE_SHADOW=0 可关（关掉 = 恢复按分数真丢）。
// echoScoreVectors 是历史 prompt 里出现过的示例评分向量（照抄即命中）。
// 血统：这些数值来自旧 prompt 的「示例评分」（MemOS CREATE_EVAL_PROMPT 血统的
// 五维评估，曾把示例写成 0.8/0.7/0.6/0.9/0.7 导致模型照抄）。出处登记：
// ~/mc/小怡/01-织忆/01-01-定义规范/织忆-借鉴溯源-全清单.md §2.1（恒 0.755 之谜）。
var echoScoreVectors = [][5]float64{
{0.8, 0.7, 0.6, 0.9, 0.7}, // engine.go 旧 prompt 示例
}
@@ -147,6 +155,38 @@ func IsDegenerateScore(s FiveDScore) bool {
// 设环境变量 ZHIYI_SCORE_SHADOW=0 关闭影子（= 恢复真拦）。
var scoreShadowMode = os.Getenv("ZHIYI_SCORE_SHADOW") != "0"
// ─── 评分闸门阈值（2026-10-12 重标定）────────────────────────
//
// 背景：旧阈值 overall<0.7 && vd<0.8 从未被真实分布验证 —— 它是在
// 「旧 prompt 示例分数被照抄 ⇒ overall 恒为 0.755」这个 bug 上拍出来的，
// 闸门从未真正丢过任何东西（恒 ≥0.7）。
//
// 实测（4 天 2065 条可用评分，local/minicpm5-2b）真实分布：
//
// min=0.175 p25=0.390 中位=0.535 p75=0.600 p90=0.800 max=0.825
//
// 用 0.7 卡这个分布 ⇒ 仅 17.9% 能过 ⇒ 一开闸就丢 82% 可用内容。
//
// 新默认取分布 p10≈0.30 的保守档：只丢「明确垃圾」。
// 取向：宁可多留（可逆 —— 后续消费/降权机制会自然淘汰），不轻易丢（不可逆）。
// 影子模式下可用环境变量随时重标定，无需改代码：
//
// ZHIYI_SCORE_MIN_OVERALL / ZHIYI_SCORE_MIN_VD
var (
scoreMinOverall = envFloat("ZHIYI_SCORE_MIN_OVERALL", 0.30)
scoreMinVD = envFloat("ZHIYI_SCORE_MIN_VD", 0.30)
)
// envFloat 读浮点环境变量，缺省/非法则用 def。
func envFloat(key string, def float64) float64 {
if v := os.Getenv(key); v != "" {
if f, err := strconv.ParseFloat(v, 64); err == nil {
return f
}
}
return def
}
// ─── 蒸馏引擎 ────────────────────────────────────────────────
// Engine 蒸馏引擎
@@ -216,9 +256,9 @@ func distillOutputFormat() string {
func NewEngine(llmEndpoint, llmModel, apiKey string) *Engine {
e := &Engine{
LLMEndpoint: llmEndpoint,
LLMModel: llmModel,
APIKey: apiKey,
LLMEndpoint: llmEndpoint,
LLMModel: llmModel,
APIKey: apiKey,
// t_180c0179：蒸馏输出默认行协议；ZHIYI_DISTILL_FORMAT=json 一行回退旧 JSON 路径。
OutputFormat: distillOutputFormat(),
batchSize: 10,
@@ -458,6 +498,17 @@ func (e *Engine) flush() {
e.mu.Unlock()
log.Printf("[distill] flush DONE: processed %d items (concurrency=%d)", len(batch), effConcurrency)
// 打分缓存汇总（2026-10-12）：命中率直接等于「本轮省下的 2B 调用占比」。
// 落盘放这里（每轮一次）而不是每条一次，避免频繁 IO。
if c := getScoreCache(); c != nil {
h, m := c.stats()
if h+m > 0 {
log.Printf("[scorecache] 累计 命中=%d 未命中=%d 命中率=%.1f%%（命中=省下的 2B 调用）",
h, m, float64(h)/float64(h+m)*100)
}
c.save()
}
}
// distillOne 蒸馏单条
@@ -483,26 +534,38 @@ func (e *Engine) distillOne(input DistillInput) DistillResult {
log.Printf("[distill] score for %s: overall=%.3f is=%.2f su=%.2f pa=%.2f vd=%.2f ru=%.2f",
input.EpisodeID, overall, score.IS, score.SU, score.PA, score.VD, score.RU)
if overall < 0.7 && score.VD < 0.8 {
// 人侧短事实（画像/心迹/牵挂/偏好/习惯/目标）是用户亲口陈述，
// LLM 打分天然偏低（短、无上下文），不应因分数被丢弃——否则"牧尘不在招商局工作"
// 这类关键事实永远到不了 memories，t6 永远比对不到。
if !isSoulfulShortFact(input.Content) {
if scoreShadowMode {
// 影子模式（2026-10-06）：闸门此前因 echo bug 从未真正生效，
// 修好 prompt 后它会首次开始真拦 —— 先只记录"本该被丢"，观察样本分布，
// 避免一次性批量误杀。ZHIYI_SCORE_SHADOW=0 可切回真拦。
log.Printf("[distill][SHADOW] would-drop episode=%s overall=%.3f vd=%.2f echo=%v degenerate=%v content=%q",
input.EpisodeID, overall, score.VD, IsEchoScore(score), IsDegenerateScore(score),
truncate(input.Content, 80))
} else {
log.Printf("[distill] score below threshold for %s, skip", input.EpisodeID)
// 即使阈值未通过，仍然用 LLM 实体提取（如果有的话）
if len(llmResp.Entities) == 0 {
return DistillResult{}
}
// ─── 准入分诊（2026-10-12 Step 1）─────────────────────────────
// 依据外部经验（方案：mc/小怡/04-OBSIDIAN工具/04-02-方案设计/
// 20261012-织忆记忆闸门-外部经验落地方案.md）：
// · A-MAC 消融：确定性「类型先验」是单点最强特征（ΔF1=−0.107）⇒ 判据必须含确定性规则
// · SAGE：明确的直接闭式解决，只有「不确定带」才需谨慎
// · When to Forget 原文："should not deprecate an uncertain memory" ⇒ 不确定的绝不弃用
// 三路：drop=确定性垃圾 / keep=确定性高价值 / observe=不确定带（**永不因低分丢弃**）
lane, laneWhy := ClassifyAdmission(input.Content)
log.Printf("[distill][LANE] episode=%s lane=%s reason=%s overall=%.3f vd=%.2f content=%q",
input.EpisodeID, lane, laneWhy, overall, score.VD, truncate(input.Content, 60))
switch lane {
case LaneDrop:
if scoreShadowMode {
log.Printf("[distill][SHADOW] would-drop(%s) episode=%s overall=%.3f vd=%.2f echo=%v degenerate=%v content=%q",
laneWhy, input.EpisodeID, overall, score.VD, IsEchoScore(score), IsDegenerateScore(score),
truncate(input.Content, 80))
} else {
log.Printf("[distill] lane=drop reason=%s for %s, skip", laneWhy, input.EpisodeID)
// 即使丢弃，仍然用 LLM 实体提取（如果有的话）
if len(llmResp.Entities) == 0 {
return DistillResult{}
}
}
case LaneKeep:
log.Printf("[distill][LANE] keep episode=%s reason=%s (放行，不看分数)", input.EpisodeID, laneWhy)
default: // LaneObserve
// 不确定带：Step 1 **不做分数丢弃**。低分只记录，供 Step 2 学阈值用。
if overall < scoreMinOverall && score.VD < scoreMinVD {
log.Printf("[distill][LANE-BAND] low-score-but-kept episode=%s overall=%.3f vd=%.2f reason=%s（仅记录，不丢）",
input.EpisodeID, overall, score.VD, laneWhy)
}
}
// 优先使用 LLM 提取的实体和事实
@@ -544,10 +607,16 @@ func (e *Engine) distillOne(input DistillInput) DistillResult {
// 2026-09-07 质量门槛(t_cc07ef4b): LLM 提炼 fact 入库前过滤
// <20字/纯疑问句/状态汇报型 拒绝; 20-50字需含实体或动词短语
// 在源头过滤, 使图谱/AAAK/记忆库一律只看到质量事实
// t_2ae69bb2: 把上方 lane 结论穿透到 fact 级门禁 —— LaneKeep 时跳过长度类
// 规则（只保留纯疑问/状态汇报两条硬否定），避免「lane 说放行、fact 级
// 却全丢」的静默吞噬；LaneDrop/LaneObserve 行为与原来逐字一致。
if before := len(facts); before > 0 {
facts = FilterQualityFacts(facts)
// t_ffcee190：env 门控 ZHIYI_SHORTFACT_KEEP_PASSTHROUGH（默认关）——对非规则卡
// observe episode 的短事实走 LaneKeep 穿透，救真实对话自然短句误杀；规则卡/门控关
// 时 effectiveFilterLane 原样返回 lane，行为与现状逐字一致。
facts = FilterQualityFactsWithLane(facts, effectiveFilterLane(input.Content, lane))
if dropped := before - len(facts); dropped > 0 {
log.Printf("[distill] quality gate dropped %d/%d facts for %s", dropped, before, input.EpisodeID)
log.Printf("[distill] quality gate dropped %d/%d facts for %s (lane=%s)", dropped, before, input.EpisodeID, lane)
}
}
@@ -557,6 +626,11 @@ func (e *Engine) distillOne(input DistillInput) DistillResult {
logAAAKIndex(index)
}
// 2026-10-13 对抗审计插槽（②环，env 门控默认关）：蒸馏产出的最终事实
// 按抽样比例送【异源模型】做对抗审计，结论只写影子日志，不改丢弃/准入行为。
// 门控关/未命中抽样/无事实 → 本调用立即返回，零行为变化。
MaybeAdversarialAudit(input, facts)
return DistillResult{
Facts: facts,
Entities: entities,
@@ -567,7 +641,24 @@ func (e *Engine) distillOne(input DistillInput) DistillResult {
}
// callLLM5D 调用 LLM 进行 5维评估 + 实体/事实提取
// callLLM5D 打分入口 —— 先查内容哈希缓存，命中直接复用（不调 2B）。
//
// 2026-10-12：episodes 重复率 78.5%、约 60% 的打分调用打在重复内容上（详见 score_cache.go）。
// 本层只做记忆化，**不改变任何判分逻辑**；禁用见 ZHIYI_SCORE_CACHE=0。
func (e *Engine) callLLM5D(content string) (LLMResponse, error) {
c := getScoreCache()
if r, ok := c.get(content); ok {
return r, nil
}
r, err := e.callLLM5DUncached(content)
if err == nil {
c.put(content, r)
}
return r, err
}
// callLLM5DUncached 原始打分实现（函数体未改动，仅改名，便于外层套缓存）。
func (e *Engine) callLLM5DUncached(content string) (LLMResponse, error) {
// 2026-09-14 限制 distill prompt ≤8k token，防止打爆本地 2B 单槽
content, sentTokens, origTokens := limitDistillContent(content)
if origTokens > maxDistillTokens {
@@ -630,12 +721,13 @@ func (e *Engine) callLLM5D(content string) (LLMResponse, error) {
FACT|独立事实1
FACT|独立事实2
ENTITY|实体名|实体类型
SCORE|is|su|pa|vd|ru
SCORE|五个数字用竖线分隔
规则:
- 每条事实一行，以 FACT| 开头；第一个 | 之后整行都是事实内容，引号、竖线、等号等任意字符都直接写、不要转义
- 每个实体一行，ENTITY|名字|类型（类型如 person / tool / system / project）
- 评分放最后一行：SCORE|is|su|pa|vd|ru，用 0.0 到 1.0 之间的浮点数（越高越好），不得用 0-10 整数
- 评分放最后一行：以 SCORE| 开头，后面紧跟【恰好五个】数字（0.0~1.0 的小数，越高越好），用 | 分隔，一个不能多一个不能少，不得用 0-10 整数
- 🔴 禁止把 is、su、pa、vd、ru 这类字段名写进输出 —— 它们只是上面说明格式用的名字，不是要你输出的内容；输出里只能出现数字
- 🔴 这五个分数必须依据**本次内容**独立判断：不同内容要给出**不同**的分数，各维度之间也应有差异。禁止给出固定不变的分数组合 —— 那会被系统判为无效评分并整条丢弃。输出里不要出现任何示例数值，直接写你本次的判断。
- 除非消息完全无意义，否则提取并输出为事实。facts 要详尽，不要只给1条摘要。
`
@@ -1116,7 +1208,7 @@ func (e *Engine) checkDailyLimit() {
// emitResult 发送蒸馏结果（回调）
func (e *Engine) emitResult(input DistillInput, result DistillResult) {
if len(result.Facts) == 0 {
if len(result.Facts) == 0 && len(result.Entities) == 0 {
return
}
// 由注册的回调处理
go/internal/distill/engine_echo_test.go
+1 -1
View File
@@ -64,7 +64,7 @@ func TestIsDegenerateScore(t *testing.T) {
for name, s := range map[string]FiveDScore{
"真实分维度(实测样本)": {IS: 0.8, SU: 0.8, PA: 0.7, VD: 0.6, RU: 0.5},
"仅一位不同": {IS: 0.8, SU: 0.8, PA: 0.8, VD: 0.8, RU: 0.7},
"历史echo向量": {IS: 0.8, SU: 0.7, PA: 0.6, VD: 0.9, RU: 0.7},
"历史echo向量": {IS: 0.8, SU: 0.7, PA: 0.6, VD: 0.9, RU: 0.7},
} {
if IsDegenerateScore(s) {
t.Errorf("阴性对照失败[%s]：%+v 被误判为退化评分（滥报）", name, s)
go/internal/distill/engine_facts0_entities_test.go
+67
View File
@@ -0,0 +1,67 @@
package distill
import (
"sync"
"testing"
)
// ── 补收口三（2026-10-13 t_62f35e62）：facts==0 早退 ⇒ 实体静默丢失 ──
// 此前 emitResult 在 `len(result.Facts)==0` 时整体 return，当 facts 全被质量
// 闸门丢掉时，整个回调不触发 ⇒ 实体也不进图（图只剩噪声的真半因，实测定：
// 领域内容 5 实体一个都没进图）。修复：把早退条件放宽为「facts 与 entities
// 都空」才 return——facts 为空时回调内的 fact 落库循环自然空转、factsLanded
// 保持 false，只有 §1 实体写图会执行（正是我们要的）。
// AC4：facts==0 但 entities>0 → 回调必须触发（实体仍进图）。
func TestEmitResult_FactsZero_EntitiesStillLand(t *testing.T) {
var mu sync.Mutex
var called bool
var gotResult DistillResult
prev := OnDistillComplete
OnDistillComplete = func(input DistillInput, result DistillResult) {
mu.Lock()
defer mu.Unlock()
called = true
gotResult = result
}
defer func() { OnDistillComplete = prev }()
e := NewEngine("http://127.0.0.1:1/unused", "m", "k")
// facts 全空（被质量闸门丢光）、entities 仍保留 2 个领域实体
e.emitResult(DistillInput{EpisodeID: "ep_xx", Content: "领域内容"},
DistillResult{
Facts: []string{},
Entities: []Entity{{Name: "鹤壁淇县生物制造产业专班", Type: "entity"}, {Name: "飞天农业", Type: "entity"}},
})
mu.Lock()
defer mu.Unlock()
if !called {
t.Fatalf("facts==0 且 entities>0：OnDistillComplete 应触发（实体才能进图），实际未触发")
}
if len(gotResult.Entities) != 2 {
t.Errorf("回调收到的 Entities 应为 2，实际 %d", len(gotResult.Entities))
}
}
// AC4 对照：facts==0 且 entities==0 → 回调不触发（空结果不扰回调）。
func TestEmitResult_FactsAndEntitiesZero_NoCallback(t *testing.T) {
var mu sync.Mutex
called := false
prev := OnDistillComplete
OnDistillComplete = func(DistillInput, DistillResult) {
mu.Lock()
defer mu.Unlock()
called = true
}
defer func() { OnDistillComplete = prev }()
e := NewEngine("http://127.0.0.1:1/unused", "m", "k")
e.emitResult(DistillInput{EpisodeID: "ep_yy"}, DistillResult{})
mu.Lock()
defer mu.Unlock()
if called {
t.Fatalf("facts==0 且 entities==0：回调不应触发，实际触发了")
}
}
go/internal/distill/engine_flush_ticker_test.go
+2 -1
View File
@@ -69,7 +69,8 @@ func waitDrained(e *Engine, within time.Duration) bool {
const tickerTestContent = "用户今天在鹤壁买了咖啡并读了关于马哲经济学的书，下午讨论了剪辑软件选型。"
// ① 忠实复现线上场景：flush 在跑期间入队 ⇒ 触发被守卫丢弃 ⇒ 生产者停止
// 期望：ticker 兜底把积压消化（修复前 = 永久冻结）。
//
// 期望：ticker 兜底把积压消化（修复前 = 永久冻结）。
func TestFlushTickerRescuesAfterDroppedTrigger(t *testing.T) {
e := tickerTestEngine(t, 150*time.Millisecond, nil)
go/internal/distill/main_test.go
+19
View File
@@ -0,0 +1,19 @@
package distill
import (
"os"
"testing"
)
// TestMain 默认关闭打分缓存。
//
// 为什么必须关：TestCallLLM5D_LineProtocolParse / BackoffOn429 / BackoffOn5xx /
// FlushPeakRespectsSlotMatchedConcurrency 都用**同一内容**反复调 callLLM5D，
// 靠第二次调用验证「重试」「解析」行为。缓存一旦生效，第二次直接被短路返回，
// 这些测试就**静默失去了覆盖**（表面全绿，实则没测到东西）。
//
// 缓存本身的正确性由 score_cache_test.go 直接测结构体（不依赖全局实例）。
func TestMain(m *testing.M) {
scoreCacheDisabled = true
os.Exit(m.Run())
}

Some files were not shown because too many files have changed in this diff Show More