feat(rrf): 词面名次上限旋钮（recall-rrf.ftsmax），默认 0=不限

实测三档（84 DA 题配对，漂移 0.0000）：
- 不限（当前生产）: Δ+0.0655, 8涨/2跌, 单题最差 -0.5
- ftsmax=5       : Δ+0.0060, 1涨/0跌, 最差 0.0
⇒ 上限能消掉丢分，但把增益也几乎消掉；保留为调参旋钮，默认不限

.gitignore

@@ -45,3 +45,7 @@ cron_raw.txt
 # 探针/临时构建产物（2026-10-14 t_3e98b65a 调查时发现 17MB 残留未清）
 /go/*-probe
 /go/rulefirst-probe
+
+# 临时构建/验证工件（t_5f822020 清理：quantify/test_one 二进制 + verify.go 探针）
+/go/tmp/
+/verify.go

docs/ac-evidence/t_bd63b641-shadow-gate/DELIVERABLE.md

@@ -0,0 +1,147 @@
+# 【织忆·门控复核】PATTERN/PEER 影子 diff 量化 — 对照表与原始证据
+
+卡: t_bd63b641 · 执行人: prof-dev · 2026-10-17 21:0x CST
+方法: 不碰生产 env/二进制/服务（AC 硬边界）。开态用「独立离线评测」——
+真实 PatternProvider/PeerAPI + 生产 graph.db(只读) + 实时 bge embedder(:8000)，
+等价于活服务开态注入路径；关态取活服务(:7821, PID 812251)实测。
+
+────────────────────────────────────────────────────────────
+## 结论
+关态 vs 开态 diff = **空（当前态）**，且开态即使修 bug 也**无净收益/伤主路径**。
+两个通道本卡判定 **「不开闸」**，如实回卡。理由:
+- PEER: 无 peers 表（0 行），开态物理零注入，无产出。
+- PATTERN: 当前 NULL-id bug 使 `ListPatterns` 恒报错 → 零注入；**即使修好 bug**，
+  85 行全是「图聚类摘要节点」（无 data/tools 内容，只有聚类键名），对金标余弦
+  0.675–0.715（≥0.6 阈值）会注入 ≤3 条**无召回价值的聚类键噪声/金标**，外加每
+  query ~85 次 embed（冷 ~1.4s）拉高 P95 + 稀释 top-5 ⇒ 伤主路径、无净收益。
+- 原始阻塞理由（上游未落地）小怡已复核失效（t_3e98b65a/t_fcadee04 done），
+  但「上游 done ≠ 该开」—— 实测证明开了也净负收益（比图谱路「接线已证、收益未证」
+  更明确: PATTERN 有 NULL-id 读库 bug + 数据源本身不是行为 pattern）。
+
+────────────────────────────────────────────────────────────
+## 一、门控现状（关态坐实，双源独立）
+- systemd unit 权威配置: `systemctl --user cat zhiyid | grep ZHIYI_` → 无
+  ZHIYI_PATTERN_RECALL / 无 ZHIYI_PEER_RECALL
+- 运行进程 env: `/proc/812251/environ` → 无此二键（与 prof-cloud 异源复核一致）
+- 结论: 两通道 env 均「未设/≠1」⇒ server.go 启动期 `if os.Getenv(...)=="1"` 不成立
+  ⇒ `storage.PatternRecallProvider` / `storage.PeerRecallProvider` 均未注册 ⇒ 关态
+
+## 二、影子 diff（关态 vs 开态，逐条对照）
+固定 query 集: 14 金标（golden-set.json）+ 69 条真实 content-recall（usage_recall 表）
+
+### PATTERN 通道（ZHIYI_PATTERN_RECALL）
+开态注入结果: 当前 **0 条 / 14 金标**（`shadow-on-pattern-inject.json` = 空 `{}`）
+根因（不是「没命中」而是「读不出来」）:
+- 生产 graph_nodes(type='pattern') 共 85 行，**id 列 85/85 全为 NULL**
+  （`sqlite3: sum(id IS NULL)=85`）
+- `PatternProvider.Match` → `GraphPatternStore.ListPatterns` 读 `SELECT id,...`
+  为 string，遇 NULL 恒报 `sql: Scan error: converting NULL to string`
+  （影子测试实测抓到原文: `PATTERN_LISTERROR="sql: Scan error on column index 0,
+  name \"id\": converting NULL to string is unsupported"`，`PATTERNS_LOADED=0`）
+- ⇒ `Match` 直接 return nil ⇒ **当前开态无任何 pattern 注入**
+
+深层（修 bug 后会怎样 —— 已量化，证明「修了也不该开」）:
+- 这 85 行 properties **0 行有 `data` 键、0 行有 `tools` 键**（只有 20 行有
+  `description`），全是「图聚类摘要节点」（如 `hermes-main/entity 共 3867 节点…`），
+  **不是 L2 行为 pattern**。`Match` 里 `p.Data` 恒空 → 回退 `p.Name`（聚类键，
+  如 `topic:memory` / `pattern:default-main:entity`）。
+- 余弦探针（绕过 NULL-id 直接 embed 85 个 pattern 名 + 金标，bge-m3:8000 实测）:
+  5 条金标 maxcos = 0.6752 / 0.6891 / 0.6975 / 0.7038 / 0.7148，**全 ≥ 0.6 阈值
+  ⇒ 若修好 NULL-id，开态会对每条金标注入 ≤3 条聚类键条目**（`offset-cosine-probe.txt`）。
+- 注入内容 = 裸聚类键名（`topic:memory`、`pattern:learner-main:concept`），
+  **对「织忆是什么」这类 query 无召回价值，只会稀释 top-5**。
+- 额外成本: 每 query 需 embed 85 个 pattern 名（冷调用 ~85×16.5ms≈1.4s，
+  探针 430 embed/7.12s 实测）⇒ **P95 主路径显著上升**（OFF p95=3177ms → 开态
+  叠加 ~1.4s）。
+- 判读: 0.6 阈值对 bge-m3 余弦分布偏低（无关文本基线 0.67+），开态注入的多是
+  **假阳性噪声**。
+- ⇒ 修 bug 后开态 = 「伤主路径 + 无净收益」，仍 **不开**。
+
+### PEER 通道（ZHIYI_PEER_RECALL）
+开态注入结果: **0 条 / 14 金标**
+根因: 生产 graph.db **无 peers 表**（`SELECT count(*) FROM sqlite_master WHERE
+name='peers'` = 0）。`PeerAPI.GetRecallResults` → `Store.List(200)` → 0 行 →
+return nil（peer.go:305-308 源码）。⇒ **开态也无任何 peer 注入**。
+
+### 对照表
+| 维度 | 关态(活服务) | 开态(影子/离线) | diff |
+|---|---|---|---|
+| PATTERN 注入条数 | 0（未注册） | 当前 0（NULL-id bug）；修 bug 后 ≤3 聚类键/金标 | **0（当前）/ 噪声（修后）** |
+| PEER 注入条数 | 0（未注册） | 0（无 peers 表） | **0** |
+| 召回结果 top5 id | 见 off-recall-14golden-live.json | 当前与关态逐条相同（无注入项可加） | **空（当前）** |
+| /eval/golden keyword_pass | 14/14 | =关态（当前注入 0 不动）；修后注入聚类键不改关键词判据 | **0（当前）** |
+| /eval/golden recall@5 | 0.643 | =关态 | **0（当前）** |
+| 开态额外成本 | — | 修 bug 后每 query ~85 embed（冷 ~1.4s）+ top-5 稀释 | 伤主路径 |
+| 新增条目位置 | — | 追加在结果尾部（recall.go:901-932 append 到 deduped 之后） | — |
+
+## 三、延迟 P50/P95（阈值从实测读，非拍脑袋）
+关态（活服务 :7821）:
+- 69 真实 query（本卡 AC 要求的「≥50 query」集）: **p50=1383.7ms, p95=3177.2ms**
+  （`off-69-queries-lat-ms.json`，一致单次 run 采集）
+- 14 金标: 空载热态 p50=949.9/p95=2288.5ms；我在并发 69-query 压测后重跑
+  p50=3936.9/p95=5255.5ms（`off-recall-14golden-live.json` = 并发态）——
+  **绝对值随负载/缓存/8081 LLM 队列代理波动**（非本卡判据，不追服务性能）。
+开态:
+- **当前态（NULL-id bug 在）**: 注入 0 条，代码块 `if patternRecallEnabled() &&
+  Provider!=nil` 即便走进去也只 `for _, pr := range nil` ⇒ **开态延迟 = 关态延迟
+  （逐条相同，无新增 embed）**。
+- **修 bug 后态**: 每 query 额外 embed 85 个 pattern 名（探针实测 430 embed/7.12s
+  ≈16.5ms/embed，冷调用 ~1.4s），追加在结果尾部 ⇒ **P95 主路径上叠加 ~1.4s 冷成本
+  （冷 ≈ 关态 p95 翻倍量级）** ⇒ 伤主路径（超 AC 判据「P95 涨幅>20%」）。
+
+判读: 延迟上「开 vs 关」的**决策相关量 = 修 bug 后每次召回 +~1.4s 冷成本**；
+当前态（bug 在）开=关=0 差异。绝对基线随负载波动，不作为开闸判据。
+
+## 四、AC#2: 开门是否需重启才注册 Provider？
+**答案: 是，必须重启。**
+- 源码证据: `go/internal/api/server.go:189-202` ——
+  `if os.Getenv("ZHIYI_PATTERN_RECALL")=="1" { storage.PatternRecallProvider =
+  patternProvider.Match }` / `if os.Getenv("ZHIYI_PEER_RECALL")=="1"
+  { storage.PeerRecallProvider = peerAPI.GetRecallResults }`，均在 `NewServer()`
+  启动期执行；`storage.PatternRecallProvider` 是包级变量，仅在这两处赋值。
+  改运行中 env（不重启）无法注册 Provider。
+- 实测证据: PID 812251 运行二进制 mtime=2026-10-17 01:18，其 /proc environ 无
+  此二键，当前 Provider 未注册（关态）。要开态只能: 在 systemd unit 加
+  `Environment=ZHIYI_*_RECALL=1` + `daemon-reload` + `restart zhiyid`。
+- 开闸成本 = 一次重启（低）。但本卡结论「不开」基于净收益为负（见二），
+  重启成本本身不是拦路项——拦路的是「开了也伤主路径 + 无净收益」。
+
+## 五、判据（按卡 AC）
+- 当前态 diff 为空（PATTERN NULL-id bug → 0 注入；PEER 无表 → 0 注入）
+  ⇒ 「开态无产出」判据满足 ⇒ **不开闸**。
+- 修 bug 后态: 注入聚类键噪声 + P95 主路径涨幅 >20% ⇒ 「有产出但伤主路径」判据
+  也满足 ⇒ **仍不开**。两条判据各自独立支撑「不开」。
+- 主路径未退化（关态 /eval/golden kw 14/14、recall@5=0.643；开态当前态=关态）。
+
+────────────────────────────────────────────────────────────
+## 原始 JSON（改前/改后，禁只贴结论）
+- 关态活服务 14 金标逐条: `off-recall-14golden-live.json`
+- 关态活服务 /eval/golden 汇总: `off-eval-golden-raw.json`
+- 关态 69 真实 query 延迟: `off-69-queries-lat-ms.json`
+- 开态影子 pattern 注入（当前态 = 空 `{}`）: `shadow-on-pattern-inject.json`
+- 开态影子 peer 表存在性: 0（`SHADOW_PEER_TABLE_EXISTS=0`，见 shadow_diff_test.go）
+- 修 bug 后余弦探针（85 聚类键 vs 金标 maxcos）: `offset-cosine-probe.txt`
+  + 复现 `TestShadowPattern_CosineIfIDFixed`（`PATTERN_ROWS_LOADABLE_BYPASS_ID=85`）
+
+复跑命令:
+  # 关态金标召回（活服务）
+  cd <ws> && python3 eval_off.py
+  # 关态 69 真实 query 延迟
+  cd <ws> && python3 latency_off.py   # 注: stdout 混进度行，JSON 在尾部
+  # 开态影子注入 + peer 表 + 修 bug 后余弦探针（只读 graph.db + :8000 embedder，不改生产）
+  cd /home/muc/src/memoryweave/go && go test ./internal/pattern/ \
+     -run 'TestShadowPattern_Diff|TestShadowPeer_NoTable|TestShadowPattern_CosineIfIDFixed' \
+     -v -count=1
+
+## 给审计脚本的「已明确决策」标记（消音用）
+本卡对 PATTERN/PEER 门控的终态 = **已明确决策: 暂不开闸（证据: 开态零产出，见上）**。
+若审计脚本下次再报「门控到期/上游 done 但门关」，应据此识别为「已决策不开」而非
+「没人复核」。建议: 门控台账加 `decision` 字段（values: open/no-open/unknown），
+本卡结论落 `no-open` + 证据指针，脚本对 no-open 态静默。
+
+────────────────────────────────────────────────────────────
+## 未决（需人拍板，本卡不越界执行）
+1. PATTERN NULL-id 读库 bug: `GraphPatternStore.ListPatterns` 扫 NULL id 报错。
+   85 存量 pattern 行全是聚类摘要节点且 id=NULL——**这套数据本身可能就不该作为
+   L2 行为 pattern 召回源**。属「修数据还是修代码」的决策，交 hub/ops，不在本卡。
+2. 开闸动作: 小怡终审 + 牧尘放行（本卡只出证据，AC 明令不开门）。

docs/ac-evidence/t_bd63b641-shadow-gate/off-69-queries-lat-ms.json

@@ -0,0 +1 @@
+[-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 825.0, 952.6, 1123.0, 1376.9, 1383.7, 1544.4, 1583.8, 1592.2, 1635.1, 1680.3, 1685.1, 1691.0, 1726.0, 1754.9, 1794.7, 1851.8, 1874.3, 1878.2, 1901.0, 1909.9, 1924.8, 1937.8, 1954.0, 2037.1, 2053.7, 2058.2, 2154.6, 2174.1, 2287.7, 2355.2, 2718.2, 2789.6, 2791.9, 2832.9, 3109.5, 3222.3, 3507.6, 3534.9, 3906.4]

docs/ac-evidence/t_bd63b641-shadow-gate/off-eval-golden-raw.json

@@ -0,0 +1 @@
+{"id":"20261017-205654","model":"golden-set","recall_at_5":0.6428571428571429,"precision_at_5":0.12857142857142856,"mean_reciprocal_rank":0.47619047619047616,"ndcg":0.5238095238095238,"query_details":[{"query":"织忆是什么","expected_ids":["mem_1791666702950691634"],"must_include_keywords":["织忆"],"hits":null,"misses":["mem_1791666702950691634"],"recall_at_5":0,"precision_at_5":0,"keyword_ok":true},{"query":"织忆的图谱扩展机制是什么","expected_ids":["mem_1791899478673190284"],"must_include_keywords":["图谱"],"hits":["mem_1791899478673190284"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"织忆如何通过 E1 提取和 MMR 实现多样去重","expected_ids":["mem_1791666890486125605"],"must_include_keywords":["MMR"],"hits":null,"misses":["mem_1791666890486125605"],"recall_at_5":0,"precision_at_5":0,"keyword_ok":true},{"query":"牧尘的偏好是什么","expected_ids":["mem_1790448247125520424"],"must_include_keywords":["牧尘"],"hits":["mem_1790448247125520424"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"牧尘喜欢什么样的工作方式","expected_ids":["mem_1790448247125520424"],"must_include_keywords":["牧尘"],"hits":["mem_1790448247125520424"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"如何根据牧尘的偏好调整记忆检索策略","expected_ids":["mem_1791747597032219499"],"must_include_keywords":["记忆"],"hits":["mem_1791747597032219499"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"当前项目的技术栈是什么","expected_ids":["mem_1790455676397796671"],"must_include_keywords":["技术栈"],"hits":["mem_1790455676397796671"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"织忆项目有哪些核心组件","expected_ids":["mem_1791906354849281414"],"must_include_keywords":["织忆"],"hits":null,"misses":["mem_1791906354849281414"],"recall_at_5":0,"precision_at_5":0,"keyword_ok":true},{"query":"织忆和其他记忆系统相比有什么架构优势","expected_ids":["mem_1791666702950691634"],"must_include_keywords":["织忆"],"hits":["mem_1791666702950691634"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"如何使用 recall 接口","expected_ids":["mem_1791796178328736793"],"must_include_keywords":["recall"],"hits":null,"misses":["mem_1791796178328736793"],"recall_at_5":0,"precision_at_5":0,"keyword_ok":true},{"query":"织忆有哪些管理工具","expected_ids":["mem_1791666702950691634"],"must_include_keywords":["织忆"],"hits":null,"misses":["mem_1791666702950691634"],"recall_at_5":0,"precision_at_5":0,"keyword_ok":true},{"query":"如何通过 API 扩展织忆功能","expected_ids":["mem_1791666188168772049"],"must_include_keywords":["织忆"],"hits":["mem_1791666188168772049"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"本地 llama 服务 8080 端口","expected_ids":["mem_1791423503359721152"],"must_include_keywords":["8080"],"hits":["mem_1791423503359721152"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true},{"query":"session-to-zhiyi.py 脚本名","expected_ids":["mem_1791688470278719760"],"must_include_keywords":["session-to-zhiyi"],"hits":["mem_1791688470278719760"],"misses":null,"recall_at_5":1,"precision_at_5":0.2,"keyword_ok":true}],"queries":14,"ran_at":"2026-10-17T20:56:54.195909811+08:00","keyword_pass":14,"keyword_fail":0,"keyword_total":14}

docs/ac-evidence/t_bd63b641-shadow-gate/off-recall-14golden-live.json

@@ -0,0 +1,319 @@
+{
+ "state": "OFF",
+ "results": [
+  {
+   "i": 0,
+   "q": "织忆是什么",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791899478673190284",
+    "mem_1792154287491185572",
+    "mem_1791912043093092663",
+    "mem_1792154287177190000",
+    "mem_1792154288142808071"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3936.9
+  },
+  {
+   "i": 1,
+   "q": "织忆的图谱扩展机制是什么",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791899478673190284",
+    "mem_1791725847707296273",
+    "mem_1792154287491185572",
+    "mem_1791770032575826407",
+    "mem_1792088552819764989"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 4225.2
+  },
+  {
+   "i": 2,
+   "q": "织忆如何通过 E1 提取和 MMR 实现多样去重",
+   "count": 5,
+   "top5_ids": [
+    "mem_1792088552818081545",
+    "mem_1791666890486125605",
+    "mem_1791520496931190142",
+    "mem_1791422985447662675",
+    "mem_1791498226924653975"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3643.6
+  },
+  {
+   "i": 3,
+   "q": "牧尘的偏好是什么",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791556229473565240",
+    "mem_1791376118421773238",
+    "mem_1790448247125520424",
+    "mem_1792088552818232071",
+    "mem_1792086639900350664"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3367.5
+  },
+  {
+   "i": 4,
+   "q": "牧尘喜欢什么样的工作方式",
+   "count": 5,
+   "top5_ids": [
+    "mem_1790448247125520424",
+    "mem_1792086639900350664",
+    "mem_1791482493617981202",
+    "mem_1789063252280657787",
+    "mem_1792086640133724836"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3511.3
+  },
+  {
+   "i": 5,
+   "q": "如何根据牧尘的偏好调整记忆检索策略",
+   "count": 5,
+   "top5_ids": [
+    "mem_1792091916993248722",
+    "mem_1791747597032219499",
+    "mem_1792088552824810016",
+    "mem_1792153987878359340",
+    "mem_1790137162828579293"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3544.6
+  },
+  {
+   "i": 6,
+   "q": "当前项目的技术栈是什么",
+   "count": 5,
+   "top5_ids": [
+    "mem_1792088552817810427",
+    "mem_1790455676397796671",
+    "mem_1791665641471849057",
+    "mem_1790317738849661043",
+    "mem_1790425023223201421"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 4874.5
+  },
+  {
+   "i": 7,
+   "q": "织忆项目有哪些核心组件",
+   "count": 5,
+   "top5_ids": [
+    "mem_1792154287491185572",
+    "mem_1792154287177190000",
+    "mem_1791770032575826407",
+    "mem_1792154288142808071",
+    "mem_1791666702950691634"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3811.5
+  },
+  {
+   "i": 8,
+   "q": "织忆和其他记忆系统相比有什么架构优势",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791899478077693848",
+    "mem_1791666702950691634",
+    "mem_1792088552819764989",
+    "mem_1791770032575826407",
+    "mem_1792154287491185572"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 3254.5
+  },
+  {
+   "i": 9,
+   "q": "如何使用 recall 接口",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791482321288100863",
+    "mem_1792153988391999660",
+    "ep_1785686577666177306",
+    "ep_1786452727331645773",
+    "mem_1788717420755520289"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 4110.9
+  },
+  {
+   "i": 10,
+   "q": "织忆有哪些管理工具",
+   "count": 5,
+   "top5_ids": [
+    "mem_1792154287491185572",
+    "mem_1791666855166846631",
+    "mem_1792144557208382006",
+    "mem_1792116217448228684",
+    "mem_1792154288142808071"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 5963.1
+  },
+  {
+   "i": 11,
+   "q": "如何通过 API 扩展织忆功能",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791666188168772049",
+    "mem_1791818814047111008",
+    "ep_1785695216419714474",
+    "ep_1785702789193047009",
+    "ep_1786336919812827426"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 4222.9
+  },
+  {
+   "i": 12,
+   "q": "本地 llama 服务 8080 端口",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791423503359721152",
+    "mem_1791440673318711992",
+    "mem_1788594533802527918",
+    "mem_1788620335517621905",
+    "mem_1788700944516696452"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": false,
+   "lat_ms": 3803.5
+  },
+  {
+   "i": 13,
+   "q": "session-to-zhiyi.py 脚本名",
+   "count": 5,
+   "top5_ids": [
+    "mem_1791688470278719760",
+    "mem_1789152643785440562",
+    "mem_1790154887033667954",
+    "mem_1790001291060572107",
+    "mem_1789896720973833628"
+   ],
+   "top5_cats": [
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled",
+    "distilled"
+   ],
+   "kw_ok": true,
+   "lat_ms": 4078.1
+  }
+ ],
+ "kw_pass": 13,
+ "kw_total": 14,
+ "p50_ms": 3936.9,
+ "p95_ms": 5255.5,
+ "all_lat_ms": [
+  3254.5,
+  3367.5,
+  3511.3,
+  3544.6,
+  3643.6,
+  3803.5,
+  3811.5,
+  3936.9,
+  4078.1,
+  4110.9,
+  4222.9,
+  4225.2,
+  4874.5,
+  5963.1
+ ]
+}

docs/ac-evidence/t_bd63b641-shadow-gate/offset-cosine-probe.txt

@@ -0,0 +1,6 @@
+    shadow_diff_test.go:200: PATTERN_ROWS_LOADABLE_BYPASS_ID=85
+    shadow_diff_test.go:224: COSINE_PROBE "织忆是什么" maxcos=0.7038 hit=true (thr=0.6) best=topic:memory
+    shadow_diff_test.go:224: COSINE_PROBE "牧尘的偏好是什么" maxcos=0.6975 hit=true (thr=0.6) best=pattern:default-main:entity
+    shadow_diff_test.go:224: COSINE_PROBE "如何使用 recall 接口" maxcos=0.6891 hit=true (thr=0.6) best=topic:replying
+    shadow_diff_test.go:224: COSINE_PROBE "本地 llama 服务 8080 端口" maxcos=0.6752 hit=true (thr=0.6) best=pattern:test-llm:entity
+    shadow_diff_test.go:224: COSINE_PROBE "织忆项目有哪些核心组件" maxcos=0.7148 hit=true (thr=0.6) best=pattern:learner-main:concept

docs/ac-evidence/t_bd63b641-shadow-gate/repro-shadow_diff_test.go

@@ -0,0 +1,229 @@
+package pattern
+
+import (
+	"database/sql"
+	"encoding/json"
+	"os"
+	"testing"
+
+	_ "modernc.org/sqlite"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// ── t_bd63b641 影-复：PATTERN/PEER 开门量具（不碰生产；只读 graph.db + 实时 embedder）──
+// 量化「开 ZHIYI_PATTERN_RECALL / ZHIYI_PEER_RECALL」对 14 金标会注入什么。
+// Provider 装配在 server.go 启动期由 env 决定 ⇒ 不重启无法在活服务上测开态；
+// 故本测试直接构造真实 Provider + 生产 graph.db（只读）+ 实时 bge embedder，
+// 跑出「开态会注入的条目」，与关态（=主召回原样）对比。
+//
+// 本测试只读、不落盘、不改库（AC：不碰生产二进制/不重启）。
+
+type logRecord struct {
+	ID       string
+	Category string
+	Content  string
+}
+
+// runShadowWithDiag 返回：注入结果 + 诊断（pattern 装载数 / query 是否编码成功 / 各 query 最高余弦）。
+// ⚠️ 关键发现：生产 graph_nodes(type='pattern') 的 id 全为 NULL（85/85），ListPatterns 读 id 为 string
+// ⇒ 恒报 sql: Scan error (converting NULL to string)，Match 直接 return nil。
+// 故 runShadow 不把 ListPatterns 错误当失败 —— 它本身就是「开态也无法注入」的根因证据。
+func runShadowWithDiag() (map[string][]logRecord, int, string, map[string]float64) {
+	endpoint := os.Getenv("VLLM_ENDPOINT")
+	if endpoint == "" {
+		endpoint = "http://localhost:8000/v1/embeddings"
+	}
+	emb := storage.NewEmbedder(endpoint)
+	store := NewGraphPatternStore("/var/lib/memoryweave/graph.db")
+	pp := NewPatternProvider(store, NewEmbedderProvider(emb))
+
+	// 装载 pattern 数（防「store 空 → 注入恒 0」的假阴性）；记录 ListPatterns 错误原文
+	pats, _, lerr := store.ListPatterns(1000)
+	loaded := 0
+	listErr := ""
+	if lerr != nil {
+		listErr = lerr.Error() // 根因：id 全 NULL → Scan error
+	} else {
+		loaded = len(pats)
+	}
+
+	golden := []string{
+		"织忆是什么", "织忆的图谱扩展机制是什么",
+		"织忆如何通过 E1 提取和 MMR 实现多样去重", "牧尘的偏好是什么",
+		"牧尘喜欢什么样的工作方式", "如何根据牧尘的偏好调整记忆检索策略",
+		"当前项目的技术栈是什么", "织忆项目有哪些核心组件",
+		"织忆和其他记忆系统相比有什么架构优势", "如何使用 recall 接口",
+		"织忆有哪些管理工具", "如何通过 API 扩展织忆功能",
+		"本地 llama 服务 8080 端口", "session-to-zhiyi.py 脚本名",
+	}
+	out := make(map[string][]logRecord)
+	maxCos := make(map[string]float64)
+
+	// 预编码 14 query（若编码失败会记 0，便于区分「没命中」vs「编码挂了」）
+	for _, q := range golden {
+		qv, eerr := emb.EncodeSingle(q)
+		if eerr != nil || len(qv) == 0 {
+			maxCos[q] = -1 // 编码失败标记
+			continue
+		}
+		// 逐个 pattern 算余弦，取最高（复现 Provider.Match 内部逻辑）
+		best := -1.0
+		for _, p := range pats {
+			rep := p.Data
+			if rep == "" {
+				rep = p.Name
+			}
+			text := rep
+			for _, tl := range p.Tools {
+				if tl != "" {
+					text += " " + tl
+				}
+			}
+			pv, perr := emb.EncodeSingle(text)
+			if perr != nil || len(pv) == 0 {
+				continue
+			}
+			s := cosineF32(qv, pv)
+			if s > best {
+				best = s
+			}
+		}
+		maxCos[q] = best
+	}
+
+	// 真注入（走 Provider.Match，同 server 路径）
+	for _, g := range golden {
+		pat := pp.Match(g, "hermes-main", 3) // server.go:902 topK=3
+		for _, r := range pat {
+			out[g] = append(out[g], logRecord{ID: r.ID, Category: r.Category, Content: r.Content})
+		}
+	}
+	return out, loaded, listErr, maxCos
+}
+
+// TestShadowPattern_Diff —— 开态 pattern 注入量化（只读生产库）
+func TestShadowPattern_Diff(t *testing.T) {
+	out, loaded, listErr, maxCos := runShadowWithDiag()
+	t.Logf("PATTERNS_LOADED=%d (防假阴性：store 有货才会注入)", loaded)
+	if listErr != "" {
+		t.Logf("PATTERN_LISTERROR=%q — 根因：pattern 行 id 全 NULL ⇒ Provider.Match 恒 return nil", listErr)
+	}
+
+	queries := []string{
+		"织忆是什么", "织忆的图谱扩展机制是什么",
+		"织忆如何通过 E1 提取和 MMR 实现多样去重", "牧尘的偏好是什么",
+		"牧尘喜欢什么样的工作方式", "如何根据牧尘的偏好调整记忆检索策略",
+		"当前项目的技术栈是什么", "织忆项目有哪些核心组件",
+		"织忆和其他记忆系统相比有什么架构优势", "如何使用 recall 接口",
+		"织忆有哪些管理工具", "如何通过 API 扩展织忆功能",
+		"本地 llama 服务 8080 端口", "session-to-zhiyi.py 脚本名",
+	}
+	totalInjected := 0
+	for _, q := range queries {
+		mc := maxCos[q]
+		if mc < 0 {
+			t.Logf("[EMB-FAIL] %q → 编码失败（不计命中）", q)
+		}
+		if n := len(out[q]); n > 0 {
+			totalInjected += n
+			t.Logf("[INJECT] %q → %d pattern (maxcos=%.3f)", q, n, mc)
+			for _, r := range out[q] {
+				t.Logf("    id=%s cat=%s content=%s", r.ID, r.Category, trunc(r.Content, 60))
+			}
+		} else {
+			t.Logf("[NO-INJECT] %q → 0 pattern (maxcos=%.3f, 阈值=0.6)", q, mc)
+		}
+	}
+	b, _ := json.MarshalIndent(out, "", " ")
+	t.Logf("SHADOW_PATTERN_TOTAL_INJECTED=%d", totalInjected)
+	os.WriteFile("/tmp/shadow-pattern-inject.json", b, 0644)
+	t.Logf("raw json → /tmp/shadow-pattern-inject.json (%d bytes)", len(b))
+}
+
+func trunc(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	return s[:n] + "…"
+}
+
+// ── peer 侧：生产 graph.db 无 peers 表 ⇒ 开态无数据可注入 ──
+func TestShadowPeer_NoTable(t *testing.T) {
+	db, err := peerOpenReadOnly("/var/lib/memoryweave/graph.db")
+	if err != nil {
+		t.Fatalf("open graph.db: %v", err)
+	}
+	defer db.Close()
+	var cnt int
+	err = db.QueryRow("SELECT count(*) FROM sqlite_master WHERE type='table' AND name='peers'").Scan(&cnt)
+	if err != nil {
+		t.Fatalf("query peers table existence: %v", err)
+	}
+	t.Logf("SHADOW_PEER_TABLE_EXISTS=%d (0 ⇒ 开态 peer 无数据可注入)", cnt)
+}
+
+// peerOpenReadOnly 只读开 sqlite（WAL 兼容），避免 peer.Store 的写路径。
+func peerOpenReadOnly(path string) (*sql.DB, error) {
+	return sql.Open("sqlite", "file:"+path+"?mode=ro&_pragma=busy_timeout(5000)")
+}
+
+// ── 深度根因：即使修好 NULL-id，85 行 pattern 无 data/tools 键（只有 description），
+// Match 只能 embed 命名键（如 "pattern:hermes-main:entity"）⇒ 对金标余弦 < 0.6 阈值。
+// 本测试量化「修好 NULL-id 后开态到底能注入几类金标」—— 证明开态收益仍≈0。
+func TestShadowPattern_CosineIfIDFixed(t *testing.T) {
+	endpoint := os.Getenv("VLLM_ENDPOINT")
+	if endpoint == "" {
+		endpoint = "http://localhost:8000/v1/embeddings"
+	}
+	emb := storage.NewEmbedder(endpoint)
+	// 绕过 NULL-id 的 ListPatterns：只读 name + properties（非 NULL 列）
+	db, err := peerOpenReadOnly("/var/lib/memoryweave/graph.db")
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	defer db.Close()
+	rows, _ := db.Query(`SELECT name, properties FROM graph_nodes WHERE type='pattern'`)
+	type patText struct{ name, text string }
+	var pats []patText
+	for rows.Next() {
+		var name, props string
+		if serr := rows.Scan(&name, &props); serr != nil {
+			continue
+		}
+		// 复现 Match 的 text 构造：rep=data(无→空) 回退 name；无 tools
+		text := name
+		pats = append(pats, patText{name, text})
+	}
+	rows.Close()
+	t.Logf("PATTERN_ROWS_LOADABLE_BYPASS_ID=%d", len(pats))
+	if len(pats) == 0 {
+		t.Skip("无 pattern 行可载（NULL-id 未修前本就 0 注入，已在 TestShadowPattern_Diff 覆盖）")
+	}
+	golden := []string{"织忆是什么", "牧尘的偏好是什么", "如何使用 recall 接口",
+		"本地 llama 服务 8080 端口", "织忆项目有哪些核心组件"}
+	for _, q := range golden {
+		qv, qerr := emb.EncodeSingle(q)
+		if qerr != nil || len(qv) == 0 {
+			t.Logf("[EMBFAIL] %q → %v", q, qerr)
+			continue
+		}
+		best, bestName := -1.0, ""
+		for _, p := range pats {
+			pv, perr := emb.EncodeSingle(p.text)
+			if perr != nil || len(pv) == 0 {
+				continue
+			}
+			s := cosineF32(qv, pv)
+			if s > best {
+				best, bestName = s, p.name
+			}
+		}
+		hit := best >= 0.6
+		t.Logf("COSINE_PROBE %q maxcos=%.4f hit=%v (thr=0.6) best=%s", q, best, hit, bestName)
+	}
+}
+
+// 防 unused 误报
+var _ = models.RecallResult{}

docs/ac-evidence/t_bd63b641-shadow-gate/shadow-on-pattern-inject.json

@@ -0,0 +1 @@
+{}

docs/metrics-semantics.md

@@ -0,0 +1,30 @@
+# 织忆指标语义：counter / rate / mean（`/api/v1/metrics`）
+
+> 2026-10-26 建立。起因：有效性审计把 `deprecated_per_day`（计数器）当成率指标，
+> 报出「0 样本却判 valid=None ⇒ 缺最小样本门」。计数器没有分母，「样本门」对它无定义
+> —— 属**探针模型错配**，不是指标缺陷。本文件是给下游（审计脚本 / 看板 / 人）的唯一口径。
+
+## 三类指标，三种读法
+
+| 类型 | 命名特征 | 自带字段 | 怎么用 | 例子 |
+|---|---|---|---|---|
+| **counter 计数器** | `*_per_day` / `*_total` / `*_count` | **无** `_samples` / `_valid` | 直接读绝对值，跨时间比大小；不要算比率、不要报「样本不足」 | `deprecated_per_day`、`deprecated_total`、`distill_success_count` |
+| **rate 比率** | `*_rate` | `_samples`（分母）+ `_valid`（1=可判 / 0=不可判 / -1=N/A） | `_valid != 1` 时**不得**当结论；`_samples` 小于门槛时只报「待积累」 | `auto_resolve_rate`、`recall_usefulness_rate` |
+| **mean 均值** | `avg_*` | `_samples` + `_valid` | 同上：无分母就不下判断 | `avg_distill_loss` |
+
+**铁律**：`0` 永远有两种含义 —— 「今天确实没有」和「根本没在统计」。
+- 计数器必须配一个累计值来区分：`deprecated_per_day=0` + `deprecated_total=0` ⇒ 从未统计过；
+  `per_day=0` + `total=137` ⇒ 统计活着，只是今天没发生。
+- 率指标必须配 `_valid`/`_samples`，分母退化时返回 `metricNA(-1)`，不给 1（给 1 会被读成满分）。
+
+## 触发器阈值也用同一套语义
+
+`internal/selfoptimize/executor.go` 的 `t8`（`TDecayCritical` → `archive_or_boost`）：
+- 判据读的是**计数器** `deprecated_per_day`（条/天），阈值由 `t8.Condition` 承载，**默认 5 条/天**。
+- 2026-10-26 修正：原先 `Condition: 0.1` 但判据函数里硬编码 `> 5`，配置写了从不生效。
+  现改为 `Condition: 5.0` + 判据读 `t.Condition`（行为不变，但配置真的能被改）。
+- 若要改成「率」语义，需要先有分母（当日活跃写入量），否则别动 —— 那会变成另一个探针错配。
+
+## 已知遗留
+
+- 审计脚本侧对计数器发「样本不足」告警的白名单修复，归 `t_44c07eca`（脚本侧统一处理，避免多处各改一遍）。

go/cmd/evtrace-allcheck/main.go

@@ -0,0 +1,68 @@
+// evtrace-allcheck — 对所有 conf>=0.85 的 pattern 逐条跑：取证据→生成草稿→溯源校验
+// 只读验证（不写 skills 表、不落盘），证明反幻觉闸门对每条 pattern 都生效。
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/pattern"
+	"github.com/xiaoxue/memoryweave/internal/skillgen"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+func main() {
+	flag.Parse()
+	sock := os.Getenv("LANCEDB_SOCKET")
+	if sock == "" {
+		sock = "/tmp/zhiyi-ipc.sock"
+	}
+	rc := storage.NewRustLanceDBClient(sock, nil)
+	recs, err := rc.ScanAll()
+	if err != nil {
+		fmt.Println("scan_all error:", err)
+		os.Exit(1)
+	}
+	dist := []models.MemoryRecord{}
+	for _, r := range recs {
+		if r.Category == "distilled" || r.Category == "" {
+			dist = append(dist, r)
+		}
+	}
+	cfg := pattern.DefaultConfig()
+	cfg.MaxRecords = len(dist)
+	pats := pattern.DetectFromRecords(dist, cfg)
+	sort.SliceStable(pats, func(i, j int) bool { return len(pats[i].SourceTasks) > len(pats[j].SourceTasks) })
+
+	prov := skillgen.NewLanceEvidenceProvider(rc)
+	gen := skillgen.NewLocal2BGenerator()
+	pass, fail := 0, 0
+	fmt.Printf("distilled=%d total_patterns=%d\n", len(dist), len(pats))
+	for _, p := range pats {
+		if p.Confidence < skillgen.DraftThreshold {
+			continue // 只验证过闸项（阈值 0.85 不动）
+		}
+		ev, _ := prov.FetchEvidence(p.SourceTasks)
+		body, gerr := gen.Generate(p, ev)
+		if gerr != nil {
+			fmt.Printf("[%s] conf=%.2f GEN_FAIL=%v\n", p.Name, p.Confidence, gerr)
+			fail++
+			continue
+		}
+		rate, missing := skillgen.VerifyEvidenceTrace(body, ev)
+		if rate >= 1.0 {
+			pass++
+		} else {
+			fail++
+		}
+		fmt.Printf("[%s] conf=%.2f nsrc=%d nev=%d trace=%.0f%% missing=%d\n",
+			p.Name, p.Confidence, len(p.SourceTasks), len(ev), rate*100, len(missing))
+	}
+	fmt.Printf("draftable(>=0.85)=%d trace_pass=%d trace_fail=%d\n", pass+fail, pass, fail)
+	if fail > 0 {
+		os.Exit(1)
+	}
+}

go/cmd/evtrace-check/main.go

@@ -0,0 +1,98 @@
+// evtrace-check — 验证技能草稿的命令可溯率（t_9ccbca15 AC3：<100% 即不合格）。
+// 用法：evtrace-check <pattern-id> [draft-file]
+// 读 graph_nodes.properties.source_tasks → sidecar 取原文 → VerifyEvidenceTrace(draft, ev)
+package main
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/xiaoxue/memoryweave/internal/skillgen"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+	_ "modernc.org/sqlite"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Println("usage: evtrace-check <source_pattern> [draft-file]")
+		os.Exit(2)
+	}
+	pid := os.Args[1]
+	graphPath := "/var/lib/memoryweave/graph.db"
+	if v := os.Getenv("GRAPH_PATH"); v != "" {
+		graphPath = v
+	}
+	// 1. 读 pattern 节点 source_tasks
+	db, err := sql.Open("sqlite", "file:"+graphPath+"?_pragma=busy_timeout(5000)")
+	if err != nil {
+		fmt.Println("open graph:", err)
+		os.Exit(1)
+	}
+	defer db.Close()
+	var propsRaw, name string
+	if err := db.QueryRow(`SELECT name,properties FROM graph_nodes WHERE id=? AND type='pattern'`, pid).Scan(&name, &propsRaw); err != nil {
+		fmt.Println("pattern not found:", err)
+		os.Exit(1)
+	}
+	var props map[string]interface{}
+	_ = json.Unmarshal([]byte(propsRaw), &props)
+	var ids []string
+	if ts, ok := props["source_tasks"].([]interface{}); ok {
+		for _, v := range ts {
+			if s2, ok := v.(string); ok {
+				ids = append(ids, s2)
+			}
+		}
+	}
+	fmt.Printf("pattern id=%s name=%s nsrc=%d\n", pid, name, len(ids))
+
+	// 2. sidecar 取证据原文
+	sock := os.Getenv("LANCEDB_SOCKET")
+	if sock == "" {
+		sock = "/tmp/zhiyi-ipc.sock"
+	}
+	rc := storage.NewRustLanceDBClient(sock, nil)
+	prov := skillgen.NewLanceEvidenceProvider(rc)
+	ev, err := prov.FetchEvidence(ids)
+	if err != nil {
+		fmt.Println("fetch evidence:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("evidence fetched=%d\n", len(ev))
+
+	// 3. 读草稿（draft-file 或从 skills 表 content 去头）
+	var draft string
+	if len(os.Args) >= 3 {
+		b, _ := os.ReadFile(os.Args[2])
+		draft = string(b)
+	} else {
+		var content string
+		if err := db.QueryRow(`SELECT content FROM skills WHERE source_pattern=?`, pid).Scan(&content); err != nil {
+			fmt.Println("read skill:", err)
+			os.Exit(1)
+		}
+		draft = content
+	}
+	// 去 [AUTO-DRAFT] 头（含溯源快照元数据），只校验模型生成的正文命令 token。
+	// 头里有 pattern id / mem_ ids / created_at —— 是元数据不是草稿正文，不参与溯源校验。
+	body := draft
+	if i := strings.Index(draft, "<!-- pattern-snapshot:"); i >= 0 {
+		if j := strings.Index(draft[i:], "\n"); j >= 0 {
+			body = draft[i+j+1:]
+		}
+	}
+
+	rate, missing := skillgen.VerifyEvidenceTrace(body, ev)
+	fmt.Printf("draft_len=%d trace_rate=%.2f%%\n", len(draft), rate*100)
+	if len(missing) > 0 {
+		fmt.Printf("MISSING tokens (%d):\n", len(missing))
+		for _, m := range missing {
+			fmt.Printf("  - %q\n", m)
+		}
+		os.Exit(1)
+	}
+	fmt.Println("TRACE_OK: 命令可溯率 100%")
+}

go/cmd/pattern-fullscan-probe/main.go

@@ -0,0 +1,190 @@
+// pattern-fullscan-probe — 全表 L2 检测探针（t_d8830204）
+// 读：经 sidecar IPC lancedb_scan_all 取全量存活行（detect 端点被硬限 5000，物理序前 N 条
+//
+//	是"不幸窗口"→ 检不到；本探针无上限，覆盖全表）。
+//
+// 检：真实 pattern.DetectFromRecords（与生产同一份代码，不改判据、不降阈值）。
+// 写（仅 -write，且仅 conf≥0.85 的诚实过闸项）：
+//   - L2：pattern.GraphPatternStore.UpsertPatterns → graph_nodes(type='pattern')
+//   - L3：skillgen.DraftSkill → skills(status=draft) + attachments/<pattern>/skill-draft.md
+//
+// 红线：L3 草稿绝不自动 promote；不自动进 skills/ 技能库。
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/pattern"
+	"github.com/xiaoxue/memoryweave/internal/skillgen"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+func joinPlus(tools []string) string {
+	out := ""
+	for i, t := range tools {
+		if i > 0 {
+			out += "+"
+		}
+		out += t
+	}
+	return out
+}
+
+func main() {
+	write := flag.Bool("write", false, "write L2 patterns (conf>=0.5) + L3 drafts (conf>=0.85); default dry-run")
+	attRoot := flag.String("attach", "", "attachments root for L3 drafts (default skillgen.DefaultAttachmentsRoot)")
+	flag.Parse()
+
+	sock := os.Getenv("LANCEDB_SOCKET")
+	if sock == "" {
+		sock = "/tmp/zhiyi-ipc.sock"
+	}
+	rc := storage.NewRustLanceDBClient(sock, nil)
+	recs, err := rc.ScanAll()
+	if err != nil {
+		fmt.Println("scan_all error:", err)
+		os.Exit(1)
+	}
+	dist := make([]models.MemoryRecord, 0, len(recs))
+	for _, r := range recs {
+		if r.Category == "distilled" || r.Category == "" {
+			dist = append(dist, r)
+		}
+	}
+	fmt.Printf("scan_all live=%d distilled_scanned=%d\n", len(recs), len(dist))
+
+	// debug: 抽样看 content 是否非空 + 工具命中
+	nonEmpty := 0
+	samples := 0
+	for _, r := range dist {
+		if r.Content != "" {
+			nonEmpty++
+		}
+		if samples < 3 && r.Content != "" {
+			fmt.Printf("  sample id=%s len=%d tools=%v content=%.80s\n",
+				r.ID, len(r.Content), pattern.ExtractTools(r.Content), r.Content)
+			samples++
+		}
+	}
+	fmt.Printf("non_empty_content=%d/%d\n", nonEmpty, len(dist))
+
+	// debug: ID 是否非空（DetectFromRecords 要求非空 ID 去重计源）
+	emptyID := 0
+	for _, r := range dist {
+		if r.ID == "" {
+			emptyID++
+		}
+	}
+	fmt.Printf("empty_ID=%d/%d\n", emptyID, len(dist))
+
+	// debug: 工具命中统计（复刻 combo 计数）
+	toolRecs := 0
+	comboN := map[string]int{}
+	for _, r := range dist {
+		tools := pattern.ExtractTools(r.Content)
+		if len(tools) >= 2 {
+			toolRecs++
+			comboN["tool_combo:"+joinPlus(tools)]++
+		}
+	}
+	fmt.Printf("records_with_>=2_tools=%d\n--- top combos (records, not dedup src) ---\n", toolRecs)
+	type kv struct {
+		k string
+		v int
+	}
+	var arr []kv
+	for k, v := range comboN {
+		arr = append(arr, kv{k, v})
+	}
+	sort.Slice(arr, func(i, j int) bool { return arr[i].v > arr[j].v })
+	for i, e := range arr {
+		if i >= 15 {
+			break
+		}
+		fmt.Printf("  %-45s %d\n", e.k, e.v)
+	}
+
+	cfg := pattern.DefaultConfig() // 不改任何阈值（MinWriteConfidence=0.5, DraftThreshold=0.85）
+	cfg.MaxRecords = len(dist)     // 覆盖全表（DefaultConfig 仅 500；API 端点又硬限 5000）
+	pats := pattern.DetectFromRecords(dist, cfg)
+	fmt.Printf("detected=%d\n", len(pats))
+	// debug: 打印前 3 个 pattern 的 ID/name/conf/src
+	for i, p := range pats {
+		if i >= 3 {
+			break
+		}
+		fmt.Printf("  pat[%d] id=%q name=%q conf=%.2f nsrc=%d\n", i, p.ID, p.Name, p.Confidence, len(p.SourceTasks))
+	}
+	sort.SliceStable(pats, func(i, j int) bool { return len(pats[i].SourceTasks) > len(pats[j].SourceTasks) })
+	for _, p := range pats {
+		fmt.Printf("  %-45s type=%s conf=%.2f nsrc=%d\n", p.Name, p.Type, p.Confidence, len(p.SourceTasks))
+	}
+
+	writeOK, draftOK := []pattern.Pattern{}, []pattern.Pattern{}
+	for _, p := range pats {
+		if p.Confidence >= pattern.MinWriteConfidence {
+			writeOK = append(writeOK, p)
+		}
+		if p.Confidence >= skillgen.DraftThreshold {
+			draftOK = append(draftOK, p)
+		}
+	}
+	fmt.Printf("pass write-gate(>=%.1f)=%d  pass L3(>=%.2f)=%d\n",
+		pattern.MinWriteConfidence, len(writeOK), skillgen.DraftThreshold, len(draftOK))
+
+	if !*write {
+		fmt.Println("DRY-RUN: 不写库、不落盘（加 -write 才落库）")
+		return
+	}
+
+	graphPath := os.Getenv("GRAPH_PATH")
+	if graphPath == "" {
+		graphPath = "/var/lib/memoryweave/graph.db"
+	}
+	// L2 写入（conf>=0.5，生产同一 UpsertPatterns 含 IsValidPatternName 写闸）
+	pstore := pattern.NewGraphPatternStore(graphPath)
+	defer pstore.Close()
+	c, u, e := pstore.UpsertPatterns(writeOK)
+	if e != nil {
+		fmt.Println("UpsertPatterns error:", e)
+	}
+	fmt.Printf("L2 upsert: created=%d updated=%d\n", c, u)
+
+	// L3 草稿（仅 conf>=0.85；本地 2B；绝不 promote）
+	if len(draftOK) > 0 {
+		sstore := skillgen.NewStore(graphPath)
+		defer sstore.Close()
+		// 返修 #5：重生成前把现存 draft 全部作废（stale），防止人 promote 到上一版拼接怪。
+		// 本轮重新过闸的 pattern 会在 PutDraft 里把对应行从 stale 复位成 draft。
+		if n, serr := sstore.MarkAllStale(); serr == nil && n > 0 {
+			fmt.Printf("L3 stale-marked 旧草稿 %d 条（重生成前作废）\n", n)
+		}
+		gen := skillgen.NewLocal2BGenerator()
+		// t_9ccbca15（D2 反幻觉）：用同一 sidecar（rc）取 pattern 命中记忆的真实原文注入 prompt。
+		prov := skillgen.NewLanceEvidenceProvider(rc)
+		// t_45677e64（返修 #1）：bge-m3 向量聚类，证据按主题成簇，只对最大簇生成（防跨主题拼接）。
+		// 端点默认 http://localhost:8000/v1/embeddings（VLLM_ENDPOINT 可覆盖），不可用时退化为
+		// 逐条孤例 ⇒ 最大簇<3 ⇒ 该 pattern 本轮不出草稿（宁缺毋滥，不产杂烩）。
+		emb := storage.NewEmbedder("")
+		clusterer := skillgen.NewBGEClusterer(emb.Encode)
+		root := *attRoot
+		if root == "" {
+			root = skillgen.DefaultAttachmentsRoot()
+		}
+		for _, p := range draftOK {
+			sk, path, derr := skillgen.DraftSkillClustered(sstore, gen, prov, clusterer, p, root)
+			if derr != nil {
+				fmt.Printf("  L3 draft FAIL %s: %v\n", p.Name, derr)
+				continue
+			}
+			fmt.Printf("  L3 draft OK %s -> status=%s file=%s\n", p.Name, sk.Status, path)
+		}
+		n, _ := sstore.Count("draft")
+		s, _ := sstore.Count("stale")
+		fmt.Printf("skills draft count=%d stale count=%d\n", n, s)
+	}
+}

go/cmd/rulefilter-impact/main.go

@@ -0,0 +1,137 @@
+// impact-probe — 候选池规则过滤影响面实测（t_4594b632 第二步）
+// 读：sidecar IPC lancedb_scan_all 全量存活行（与 pattern-fullscan-probe 同通道）。
+// 算：对每条 content 逐条跑候选规则，统计每条规则会拦掉多少条 / 占比 / 前10条样本。
+//     规则纯函数、零 LLM、零写库。用于决定「真缺才写 / 已覆盖 / 不该有」。
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+type ruleResult struct {
+	name    string
+	hit     []string // 样本（content 前 80 字）
+}
+
+func main() {
+	sock := flag.String("sock", "", "LANCEDB socket")
+	flag.Parse()
+	s := *sock
+	if s == "" {
+		if env := os.Getenv("LANCEDB_SOCKET"); env != "" {
+			s = env
+		} else {
+			s = "/tmp/zhiyi-ipc.sock"
+		}
+	}
+	rc := storage.NewRustLanceDBClient(s, nil)
+	recs, err := rc.ScanAll()
+	if err != nil {
+		fmt.Println("scan_all error:", err)
+		return
+	}
+	// 两个池都统计：mem_（L2 pattern 候选）+ ep_（原始 episode）
+	var cand, ep []models.MemoryRecord
+	for _, r := range recs {
+		if strings.HasPrefix(r.ID, "mem_") {
+			cand = append(cand, r)
+		} else if strings.HasPrefix(r.ID, "ep_") {
+			ep = append(ep, r)
+		}
+	}
+	fmt.Printf("scan_all=%d candidate_pool(mem_)=%d episodes(ep_)=%d\n", len(recs), len(cand), len(ep))
+
+	rules := []struct {
+		name string
+		fn   func(string) bool
+	}{
+		{"纯数字(全数字)", isPureDigits},
+		{"散列(长hex>24)", isLongHex},
+		{"散列(长base64/字母数字>24)", isLongAlnum},
+		{"超长无空格(>80,日志/粘贴)", isLongNoSpace},
+	}
+
+	for _, pool := range []struct {
+		name string
+		recs []models.MemoryRecord
+	}{{"mem_", cand}, {"ep_", ep}} {
+		fmt.Printf("\n########## POOL=%s (%d) ##########\n", pool.name, len(pool.recs))
+		for _, r := range rules {
+			hits := []string{}
+			for _, rec := range pool.recs {
+				if r.fn(rec.Content) {
+					hits = append(hits, rec.Content)
+				}
+			}
+			pct := 100.0 * float64(len(hits)) / float64(len(pool.recs))
+			sort.Slice(hits, func(i, j int) bool { return len(hits[i]) > len(hits[j]) })
+			fmt.Printf("\n=== rule %q → 拦截 %d/%d (%.2f%%) ===\n", r.name, len(hits), len(pool.recs), pct)
+			for i, h := range hits {
+				if i >= 10 {
+					break
+				}
+				fmt.Printf("  [%d] len=%d %.80s\n", i, len(h), h)
+			}
+		}
+	}
+}
+
+// 纯数字：整串只含 0-9（允许 . : - 空格 分隔，如 IP/端口/日期；纯数字才算）
+func isPureDigits(s string) bool {
+	t := strings.TrimSpace(s)
+	if t == "" || utf8.RuneCountInString(t) < 8 {
+		return false // 太短不算
+	}
+	for _, r := range t {
+		if (r < '0' || r > '9') && r != '.' && r != ':' && r != '-' && r != ' ' && r != '/' && r != '#' {
+			return false
+		}
+	}
+	return true
+}
+
+// 长 hex：≥24 字符，全部 0-9a-fA-F（无空格）
+var hexRe = regexp.MustCompile(`^[0-9a-fA-F]+$`)
+
+func isLongHex(s string) bool {
+	t := strings.TrimSpace(s)
+	if len(t) < 24 {
+		return false
+	}
+	return hexRe.MatchString(t)
+}
+
+// 长字母数字：≥24 字符，无空格，且不含中文
+var alnumRe = regexp.MustCompile(`^[0-9A-Za-z_\-+/=]+$`)
+
+func isLongAlnum(s string) bool {
+	t := strings.TrimSpace(s)
+	if len(t) < 24 {
+		return false
+	}
+	return alnumRe.MatchString(t)
+}
+
+// 超长无空格：≥80 字符且不含空格（日志/粘贴/路径粘连）
+func isLongNoSpace(s string) bool {
+	t := strings.TrimSpace(s)
+	if len(t) < 80 {
+		return false
+	}
+	for _, r := range t {
+		if unicode.IsSpace(r) {
+			return false
+		}
+	}
+	return true
+}

go/cmd/skilleval-live/main.go

@@ -0,0 +1,33 @@
+// skilleval-live — 验证 LLMEvaluator 调本地 2B(8081) 重写理由 + 确定性兜底（t_4594b632）
+// 只读草稿 + 调 2B，零写库。单发手动验证。
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/pattern"
+	"github.com/xiaoxue/memoryweave/internal/skillgen"
+)
+
+func main() {
+	path := os.Args[1]
+	content, err := os.ReadFile(path)
+	if err != nil {
+		fmt.Println("read error:", err)
+		os.Exit(1)
+	}
+	p := pattern.Pattern{ID: "pat_x", Type: "tool_combo", Name: "tool_combo:hermes+python", Confidence: 1.0, Tools: []string{"hermes", "python"}}
+	ev := skillgen.NewLLMEvaluator()
+	start := time.Now()
+	r, err := ev.Evaluate(string(content), p)
+	if err != nil {
+		fmt.Println("eval error:", err)
+		os.Exit(1)
+	}
+	b, _ := json.MarshalIndent(r, "", "  ")
+	fmt.Println(string(b))
+	fmt.Println("elapsed:", time.Since(start).Round(time.Millisecond))
+}

go/cmd/skilleval-probe/main.go

@@ -0,0 +1,34 @@
+// skilleval-probe — 对 t_d8830204 产出的 skill 草稿跑 SkillEvaluator 打分（t_4594b632 AC4）
+// 只读草稿文件 + 评分，零写库。输出固定 JSON。
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/xiaoxue/memoryweave/internal/pattern"
+	"github.com/xiaoxue/memoryweave/internal/skillgen"
+)
+
+func main() {
+	path := os.Args[1]
+	content, err := os.ReadFile(path)
+	if err != nil {
+		fmt.Println("read error:", err)
+		os.Exit(1)
+	}
+	// 来源 pattern：tool_combo:hermes+python（与 t_d8830204 实测一致）
+	p := pattern.Pattern{
+		ID: "pat_tool_combo:hermes+python", Type: "tool_combo",
+		Name: "tool_combo:hermes+python", Confidence: 1.0, Tools: []string{"hermes", "python"},
+	}
+	ev := skillgen.NewRuleEvaluator()
+	r, err := ev.Evaluate(string(content), p)
+	if err != nil {
+		fmt.Println("eval error:", err)
+		os.Exit(1)
+	}
+	b, _ := json.MarshalIndent(r, "", "  ")
+	fmt.Println(string(b))
+}

go/internal/api/routes/admin_forget_test.go

@@ -77,6 +77,11 @@ func (m *forgetMockLance) Update(table, id string, fields map[string]any) error
 	return nil
 }
 
+// GetRecordByID t_0f1d7be9（原文层）：fake 默认不存在。
+func (m *forgetMockLance) GetRecordByID(table, id string) (*models.MemoryRecord, error) {
+	return nil, nil
+}
+
 // fragment 构造一个命中「<30 字碎片快速道」的候选（content<30 字 + 20 天未访问）。
 func fragmentCandidate(id string) map[string]interface{} {
 	return map[string]interface{}{

go/internal/api/routes/auto_distill.go

@@ -37,8 +37,8 @@ func AutoDistillTrigger(episodeID string, content string, category string, names
 		return
 	}
 
-	// 1. 硬规则过滤
-	if !distill.HardRulesPass(content) {
+	// 1. 硬规则过滤（t_a513b870：带原因变体，拒绝在内部登记计数 + 打日志）
+	if pass, _ := distill.HardRulesPassWithReason(content); !pass {
 		return
 	}
 

go/internal/api/routes/consolidation_pipe.go

@@ -6,15 +6,22 @@ import (
 	"log"
 	"sort"
 	"strings"
+	"sync/atomic"
 	"time"
 
-	"github.com/xiaoxue/memoryweave/internal/consolidate"
 	"github.com/xiaoxue/memoryweave/internal/governance"
 	"github.com/xiaoxue/memoryweave/internal/metrics"
 	"github.com/xiaoxue/memoryweave/internal/selfoptimize"
 	"github.com/xiaoxue/memoryweave/internal/storage"
 )
 
+// consolInFlight 进程内单飞锁（t_10757bd5，2026-10-24 22:50）
+//
+// 根因：t_distill(15min) 与 t_consolidation 会在同一秒各自起 goroutine 调本流水线，
+// 两条同时打 Rust sidecar 的互斥整合槽 ⇒ 必有一条吃 consolidate_busy ⇒ 静默降级
+// ⇒ 55 次/日的"假失败"其实是自相争用。单飞后同进程内不再可能撞车。
+var consolInFlight int32
+
 // ConsolidationPipeline 完整整合流水线
 // 优先调用 Rust sidecar（DBSCAN + 衰减校准 + 质量回溯）
 // Rust 不可用时降级为 Go 启发式
@@ -52,6 +59,15 @@ func (cp *ConsolidationPipeline) Run() (*ConsolidationReport, error) {
 // mode: "cluster_only" | "full" | "prune_only"
 // full 模式触发 LLM 质量回溯 + 衰减校准（仅低频调度使用）
 func (cp *ConsolidationPipeline) RunWithMode(mode string) (*ConsolidationReport, error) {
+	// ─── 单飞：同进程内的多触发器不得并发打 sidecar（t_10757bd5）────────
+	if !atomic.CompareAndSwapInt32(&consolInFlight, 0, 1) {
+		GetConsolTracker().RecordSkip("already_running (in-process singleflight)")
+		log.Printf("[consolidation] 上一次整合仍在进行，本次触发跳过（跳过不计失败）")
+		now := time.Now()
+		return &ConsolidationReport{StartedAt: now, FinishedAt: now, Duration: "skipped_inflight"}, nil
+	}
+	defer atomic.StoreInt32(&consolInFlight, 0)
+
 	// ─── 前置检查：timestamp 合理性（防止 epoch-0 数据污染聚类结果）────────
 	if mode == "full" || mode == "cluster_only" {
 		if suspicious, total := cp.checkTimestampSanity(); suspicious > 0 {
@@ -59,11 +75,12 @@ func (cp *ConsolidationPipeline) RunWithMode(mode string) (*ConsolidationReport,
 		}
 	}
 
-	// ─── 尝试 Rust sidecar ───────────────────────────────────────
+	// ─── 尝试 Rust sidecar（t_10757bd5：busy-wait + 健康跟踪）────────
 	var report *ConsolidationReport
 	if cp.dataDir != "" && cp.sqlitePath != "" {
-		// 用指定模式调用 Rust sidecar
-		if rustReport, err := consolidate.Run(cp.dataDir, cp.sqlitePath, mode); err == nil {
+		// busyWaitRetry 处理 consolidate_busy：等待 3s×3 次再降级（治「静默堆积」根因）
+		rustReport, stillBusy, err := busyWaitRetry(cp.dataDir, cp.sqlitePath, mode)
+		if err == nil && !stillBusy {
 			report = &ConsolidationReport{
 				StartedAt:      time.Now(),
 				FinishedAt:     time.Now(),
@@ -93,8 +110,18 @@ func (cp *ConsolidationPipeline) RunWithMode(mode string) (*ConsolidationReport,
 			// Phase F: 整合完成后更新 Prometheus metrics
 			metrics.TotalMemories.Set(float64(rustReport.Clusters * 10)) // 估算
 			metrics.SyncFromDashboard(selfoptimize.Dash.Metrics())
+			// t_10757bd5 AC4：成功 ⇒ tracker 归零（/health 可读到 LastSuccessTime）
+			GetConsolTracker().RecordSuccess()
 		} else {
-			log.Printf("[consolidation] Rust sidecar 不可用 (%v)，降级为 Go 启发式", err)
+			// busy（重试耗尽）⇒ **跳过**，不是失败；非 busy 错误 ⇒ 真失败
+			if stillBusy {
+				log.Printf("[consolidation] sidecar 忙（重试 9s 耗尽），本次跳过 —— busy=别人在跑，不等于链路坏")
+				GetConsolTracker().RecordSkip("consolidate_busy after retries")
+			} else {
+				errStr := fmt.Sprintf("%v", err)
+				log.Printf("[consolidation] Rust sidecar 真失败 (%s)，降级为 Go 启发式", errStr)
+				GetConsolTracker().RecordFailure(errStr)
+			}
 			goReport, goErr := cp.runGoFallback()
 			if goErr != nil {
 				return nil, goErr
@@ -249,7 +276,12 @@ func (cp *ConsolidationPipeline) mergeSimilar() (int, error) {
 					// 保留较新的
 					idI := strVal(mems[i]["id"])
 					idJ := strVal(mems[j]["id"])
-					_ = cp.ldb.SoftDelete(idJ, fmt.Sprintf("merged_into_%s", idI))
+					// t_cf680fad：不再 `_ =` 静默吞错。MVCC 冲突耗尽时 SoftDelete 内部会
+					// 把 (idJ, reason) 落 durable pending 队列（softdelete_pending.go），
+					// 启动/每 tick drain 重放必落盘；这里显式记日志做观测（禁静默）。
+					if err := cp.ldb.SoftDelete(idJ, fmt.Sprintf("merged_into_%s", idI)); err != nil {
+						log.Printf("[consolidation] merge-softdelete FAILED: src=%s → target=%s err=%v (pending-queue 将重放)", idJ, idI, err)
+					}
 					merged++
 				}
 			}

go/internal/api/routes/consolidation_track.go

@@ -0,0 +1,163 @@
+// 织忆 MemoryWeave — 整合链路健康跟踪（t_10757bd5）
+//
+// 背景（2026-10-24 小怡体检实测）：
+//   - t_distill(15min) 与 t_consolidation 同时触发 consolPipe，
+//     Rust 侧互斥整合槽被占用时 Go 立即降级 Go 启发式 ⇒ consolidate_busy ~55 次/日静默堆积
+//   - /health 只看 sidecar TCP 连通性 ⇒ 整合链路持续失败也假绿
+//
+// 本文件提供：
+//   1. ConsolidationTracker — 记录连续失败次数 + 最近一次成功时间（供 /health 读）
+//   2. busyWaitRetry — Rust sidecar 报 busy 时等待 3s×3 次再降级（整合全程 ~126s）
+//   3. 引用 metrics 包新增的 5 个指标（AC5：失败路径带计数）
+package routes
+
+import (
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/consolidate"
+	"github.com/xiaoxue/memoryweave/internal/metrics"
+)
+
+// ─── ConsolidationTracker ────────────────────────────────────
+
+var (
+	consTracker     = &ConsolidationTracker{}
+	consTrackerOnce sync.Once
+)
+
+// ConsolidationTracker 记录整合链路健康状态（内存态，重启归零；
+// 重启后健康端点读到 ConsecutiveFailures=0 ⇒ 正确，因为该链路确实刚起步）。
+type ConsolidationTracker struct {
+	mu                  sync.Mutex
+	LastSuccess         time.Time
+	LastAttempt         time.Time
+	startup             time.Time
+	ConsecutiveFailures int
+	Skips               int64  // t_10757bd5：需要"跳过"而非失败的次数（并发触发 / sidecar busy）
+	lastSkip            string // 最近一次跳过原因
+	// lastError 最近一次失败原因（供 /health 暴露，便于人工诊断）
+	lastError string
+}
+
+// GetConsolTracker 返回全局 tracker 单例
+func GetConsolTracker() *ConsolidationTracker {
+	if consTracker.startup.IsZero() {
+		consTracker.mu.Lock()
+		if consTracker.startup.IsZero() {
+			consTracker.startup = time.Now()
+		}
+		consTracker.mu.Unlock()
+	}
+	return consTracker
+}
+
+// RecordSuccess 整合成功（归零）
+func (t *ConsolidationTracker) RecordSuccess() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.LastAttempt = time.Now()
+	t.LastSuccess = time.Now()
+	t.ConsecutiveFailures = 0
+	t.lastError = ""
+	metrics.ConsolLastSuccessTime.SetToCurrentTime()
+	metrics.ConsolConsecutiveFailures.Set(0)
+}
+
+// RecordSkip 本次触发被**跳过**（不是失败）。
+//
+// t_10757bd5 关键语义修正（2026-10-24 22:45 实测发现）：
+// `consolidate_busy` 的真实含义是「另一个整合正在跑」，不是链路坏。
+// 把它记成失败会让 /health 报 degraded —— 明明整合正在正常工作，却又是一次假红。
+// 只有真正的错误（sidecar 崩、DB 错、超时）才算 failure。
+func (t *ConsolidationTracker) RecordSkip(reason string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.LastAttempt = time.Now()
+	t.Skips++
+	t.lastSkip = reason
+}
+
+// RecordFailure 整合失败（+1）
+func (t *ConsolidationTracker) RecordFailure(err string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.LastAttempt = time.Now()
+	t.ConsecutiveFailures++
+	t.lastError = err
+	metrics.ConsolConsecutiveFailures.Set(float64(t.ConsecutiveFailures))
+}
+
+// HealthStatus 返回健康端点应报的状态：
+//   - 连续**真失败** ≥ 3 ⇒ "degraded"
+//   - 进程启动已超 2 小时却从未成功过 ⇒ "degraded"（跳过不算成功，也不算失败）
+//   - 上次成功距今 > 2 小时（15min 周期 × 8）⇒ "degraded"
+//   - 否则 "ok"
+func (t *ConsolidationTracker) HealthStatus() (string, int, time.Duration, string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	fails := t.ConsecutiveFailures
+	var sinceSuccess time.Duration
+	if t.LastSuccess.IsZero() {
+		sinceSuccess = 0 // 从未成功
+	} else {
+		sinceSuccess = time.Since(t.LastSuccess)
+	}
+	status := "ok"
+	if fails >= 3 {
+		status = "degraded"
+	}
+	if t.LastSuccess.IsZero() {
+		if !t.startup.IsZero() && time.Since(t.startup) > 2*time.Hour {
+			status = "degraded"
+		}
+	} else if sinceSuccess > 2*time.Hour {
+		status = "degraded"
+	}
+	return status, fails, sinceSuccess, t.lastError
+}
+
+// Snapshot 供 /health 暴露完整字段（含跳过次数，便于区分「忙」与「坏」）
+func (t *ConsolidationTracker) Snapshot() (fails int, skips int64, lastSkip string, lastErr string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	return t.ConsecutiveFailures, t.Skips, t.lastSkip, t.lastError
+}
+
+// ─── busyWaitRetry ───────────────────────────────────────────
+
+// busyWaitRetry 对 Rust sidecar consolidate_busy 做有限等待重试。
+//
+// 原理：Rust 整合全程约 126s（DBSCAN + 衰减校准），触发器每 15min 一次，
+// 两个触发器同秒到达时第二个撞 busy。等待 3s × 3 次（共 9s）；
+// 9s 后仍 busy 说明 sidecar 真有长任务（或正在做 full 模式），
+// 降级 Go 启发式并记录 tracker（由调用方负责）。
+//
+// 返回语义：
+//   - (report, false, nil)   = 成功拿到报告
+//   - (nil,  true, nil)     = 重试耗尽仍 busy（调用方应走降级 + RecordFailure）
+//   - (nil,  false, err)     = 非 busy 错误（调用方直接返回）
+func busyWaitRetry(dataDir, sqlitePath, mode string) (report *consolidate.Result, stillBusy bool, err error) {
+	const (
+		maxRetries = 3
+		waitDur    = 3 * time.Second
+	)
+	for i := 0; i <= maxRetries; i++ {
+		if i > 0 {
+			metrics.ConsolidateBusyWaitTotal.Inc()
+			time.Sleep(waitDur)
+		}
+		report, err = consolidate.Run(dataDir, sqlitePath, mode)
+		if err == nil {
+			return report, false, nil
+		}
+		if strings.Contains(err.Error(), "consolidate_busy") {
+			continue // 仍 busy，重试
+		}
+		// 非 busy 错误直接返回
+		return nil, false, err
+	}
+	// 重试耗尽仍 busy
+	return nil, true, nil
+}

go/internal/api/routes/contract.go

@@ -0,0 +1,119 @@
+// 织忆 MemoryWeave — 召回响应契约辅助（P0-3，2026-10-26）
+//
+// 背景（CS249r Vol III Ch6 检索契约）：响应只有 cache_hit/candidates_scanned/count/mode/graph_expanded，
+// 空结果分不清「不存在」与「扫了一半就超时」——这是 Air Canada 类静默幻觉的结构性入口。
+//
+// 本文件提供最小可用契约三件：
+//  ① status/partial_reason：complete 的空结果才允许解读为「不存在」；
+//  ② scope{namespace,snapshot,...}：说明这次答案基于哪个数据视图（本服务无索引版本号，
+//     故 snapshot = 观测时点 + 缓存状态，缓存命中代表 60s 内旧快照 —— 语义诚实，不假装有版本号）；
+//  ③ continuation：不透明翻页令牌（query 指纹 + ns 绑定，防止跨 query 串页）。
+package routes
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"strconv"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// maxContinuationOffset 硬上限：防止把 topK 放大到爆内存/延迟。
+const maxContinuationOffset = 500
+
+type pageToken struct {
+	V   int    `json:"v"`
+	Q   string `json:"q"`  // query 指纹（sha256 前 8 hex）
+	NS  string `json:"ns"` // 作用域绑定
+	Off int    `json:"o"`  // 下一页起点
+	Lim int    `json:"l"`  // 页大小
+	// Prev 已返回过的 ID（去重锚点）。活索引下排序会随 fetchLimit 变化而轻微漂移，
+	// 只靠 offset 会出现跨页重复；token 携带已返回 ID 才能机械保证「不重」。
+	Prev []string `json:"p,omitempty"`
+}
+
+// maxPrevIDs 令牌里最多携带的去重锚点数（3~5 页内足够；超长则丢最旧，令牌不会无限膨胀）。
+const maxPrevIDs = 100
+
+// queryFingerprint 8 hex 的 query 指纹（足够防串页，不泄露正文）。
+func queryFingerprint(q string) string {
+	sum := sha256.Sum256([]byte(q))
+	return hex.EncodeToString(sum[:4])
+}
+
+// encodeContinuation 生成下一页令牌；没有下一页时返回空串。
+func encodeContinuation(query, namespace string, offset, limit int, prev []string) string {
+	if limit <= 0 {
+		return ""
+	}
+	if len(prev) > maxPrevIDs {
+		prev = prev[len(prev)-maxPrevIDs:]
+	}
+	tok := pageToken{V: 1, Q: queryFingerprint(query), NS: namespace, Off: offset, Lim: limit, Prev: prev}
+	b, err := json.Marshal(tok)
+	if err != nil {
+		return ""
+	}
+	return base64.RawURLEncoding.EncodeToString(b)
+}
+
+// decodeContinuation 解析令牌。错误信息面向调用方（可据此修请求）。
+func decodeContinuation(raw string) (pageToken, error) {
+	var tok pageToken
+	b, err := base64.RawURLEncoding.DecodeString(raw)
+	if err != nil {
+		return tok, errors.New("continuation 不是合法 base64url 令牌")
+	}
+	if err := json.Unmarshal(b, &tok); err != nil {
+		return tok, errors.New("continuation 内容不是合法 JSON")
+	}
+	if tok.V != 1 {
+		return tok, errors.New("continuation 版本不支持：" + strconv.Itoa(tok.V))
+	}
+	if tok.Off < 0 || tok.Lim <= 0 {
+		return tok, errors.New("continuation 字段非法（offset/limit）")
+	}
+	if tok.Off > maxContinuationOffset {
+		return tok, errors.New("continuation offset 超出上限 " + strconv.Itoa(maxContinuationOffset))
+	}
+	return tok, nil
+}
+
+// buildScope 组装本次召回的数据视图声明。
+func buildScope(namespace string, topK int, mode string, cacheHit, truncated bool, started time.Time) map[string]interface{} {
+	snap := "t" + strconv.FormatInt(started.UnixMilli(), 10)
+	if cacheHit {
+		snap += "-cache" // 缓存命中：读的是 60s 内旧快照，不是本次实时扫描
+	} else {
+		snap += "-scan"
+	}
+	if truncated {
+		snap += "-truncated"
+	}
+	return map[string]interface{}{
+		"namespace":  namespace,
+		"snapshot":   snap,
+		"cache_hit":  cacheHit,
+		"truncated":  truncated,
+		"top_k":      topK,
+		"mode":       mode,
+	}
+}
+
+// traceItems 把最终返回集映射成 trace 的 item 归因（rank 从 1 起）。
+func traceItems(results []models.RecallResult) []storage.TraceItem {
+	items := make([]storage.TraceItem, 0, len(results))
+	for i, r := range results {
+		ch := r.Channel
+		if ch == "" {
+			ch = "vector" // 老调用方/旧缓存条目无 channel ⇒ 主通道默认值
+		}
+		items = append(items, storage.TraceItem{Rank: i + 1, ID: r.ID, Channel: ch, Score: r.Score})
+	}
+	return items
+}

go/internal/api/routes/contract_test.go

@@ -0,0 +1,116 @@
+package routes
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+func TestContinuationRoundTrip(t *testing.T) {
+	tok := encodeContinuation("织忆怎么召回", "hermes-main", 10, 5, []string{"mem_1", "mem_2"})
+	if tok == "" {
+		t.Fatal("有下一页时令牌不应为空")
+	}
+	got, err := decodeContinuation(tok)
+	if err != nil {
+		t.Fatalf("解码失败：%v", err)
+	}
+	if got.Off != 10 || got.Lim != 5 {
+		t.Fatalf("令牌字段错误：%+v", got)
+	}
+	if got.Q != queryFingerprint("织忆怎么召回") {
+		t.Fatalf("query 指纹不一致")
+	}
+	if got.NS != "hermes-main" {
+		t.Fatalf("namespace 不一致：%s", got.NS)
+	}
+	if len(got.Prev) != 2 || got.Prev[0] != "mem_1" {
+		t.Fatalf("去重锚点未随令牌传递：%v", got.Prev)
+	}
+}
+
+func TestContinuationRejectsBadToken(t *testing.T) {
+	if _, err := decodeContinuation("not-base64!!"); err == nil {
+		t.Fatal("非法 base64 应报错")
+	}
+	if _, err := decodeContinuation("eyJ2Ijo5fQ"); err == nil { // {"v":9}
+		t.Fatal("未知版本应报错")
+	}
+	tok := encodeContinuation("q", "ns", 9999, 5, nil)
+	if _, err := decodeContinuation(tok); err == nil {
+		t.Fatal("offset 超上限应报错")
+	}
+}
+
+func TestQueryFingerprintStable(t *testing.T) {
+	a := queryFingerprint("同样的问句")
+	b := queryFingerprint("同样的问句")
+	c := queryFingerprint("不同的问句")
+	if a != b {
+		t.Fatal("同 query 指纹应稳定")
+	}
+	if a == c {
+		t.Fatal("不同 query 指纹应不同")
+	}
+	if len(a) != 8 {
+		t.Fatalf("指纹应为 8 hex，实际 %d", len(a))
+	}
+}
+
+func TestBuildScope(t *testing.T) {
+	started := time.UnixMilli(1700000000000)
+	sc := buildScope("hermes-main", 5, "hybrid", false, false, started)
+	for _, k := range []string{"namespace", "snapshot", "cache_hit", "truncated", "top_k", "mode"} {
+		if _, ok := sc[k]; !ok {
+			t.Fatalf("scope 缺字段 %s", k)
+		}
+	}
+	snap := sc["snapshot"].(string)
+	if snap != "t1700000000000-scan" {
+		t.Fatalf("实时扫描 snapshot 形态错误：%s", snap)
+	}
+	cached := buildScope("ns", 5, "hybrid", true, true, started)["snapshot"].(string)
+	if cached != "t1700000000000-cache-truncated" {
+		t.Fatalf("缓存+截断 snapshot 形态错误：%s", cached)
+	}
+}
+
+func TestTraceItems(t *testing.T) {
+	rs := []models.RecallResult{
+		{ID: "a", Channel: "vector"},
+		{ID: "b"}, // 老调用方无 channel ⇒ 默认 vector
+		{ID: "c", Channel: "graph"},
+	}
+	items := traceItems(rs)
+	if len(items) != 3 || items[0].Rank != 1 || items[2].Rank != 3 {
+		t.Fatalf("rank 编号错误：%+v", items)
+	}
+	if items[1].Channel != "vector" {
+		t.Fatalf("缺省 channel 应回落 vector，实际 %s", items[1].Channel)
+	}
+}
+
+// TestRecallResultContractFields 契约字段必须真的出现在 JSON 里（不是「加了结构体没接线」）。
+func TestRecallResultContractFields(t *testing.T) {
+	r := models.RecallResult{
+		ID: "mem_1", Channel: "fts", Stale: true, Version: 3,
+		ValidFrom: "2026-10-26T10:00:00+08:00", ValidTo: "2026-10-26T11:00:00+08:00",
+		Supersedes: []string{"mem_0"}, SupersededBy: []string{"mem_2"}, Superseded: true,
+	}
+	b, err := json.Marshal(r)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	var m map[string]interface{}
+	if err := json.Unmarshal(b, &m); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	for _, k := range []string{"channel", "stale", "generation", "valid_from", "valid_to",
+		"supersedes", "superseded_by", "superseded"} {
+		if _, ok := m[k]; !ok {
+			t.Fatalf("响应缺字段 %s（JSON=%s）", k, string(b))
+		}
+	}
+}

go/internal/api/routes/core.go

@@ -2,6 +2,7 @@
 package routes
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -16,9 +17,9 @@ import (
 
 	"github.com/xiaoxue/memoryweave/internal/distill"
 	"github.com/xiaoxue/memoryweave/internal/governance"
+	"github.com/xiaoxue/memoryweave/internal/metanote"
 	"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"
 )
@@ -106,6 +107,8 @@ func (a *API) Commit(w http.ResponseWriter, r *http.Request) {
 	// 判定与 Python 口径真相源同源（internal/metanote，parity/差分测试锁死）；
 	// 判 meta ⇒ 422 拒绝，不写 episode、不进蒸馏（卡面：把 meta 挡在咽喉点）。
 	if skip, reason := metanote.ShouldSkip(req.Content); skip {
+		// t_10757bd5 AC5：metanote 拒绝 ⇒ 计数器 +1（与日志 "[metanote] commit rejected" 行对齐）
+		metrics.MetaNoteRejectTotal.Inc()
 		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)
@@ -312,6 +315,10 @@ func (a *API) WriteMemory(w http.ResponseWriter, r *http.Request) {
 		EmbeddingModel string   `json:"embedding_model"`
 		ScriptVersion  string   `json:"script_version"`
 		Confidence     *float64 `json:"confidence"`
+		// 2026-11-07 (t_88cc9cb8) 意图 TTL：可选到期时间（ISO8601/RFC3339）。不传 = 空 =
+		// 永久有效（现状不变）。非法格式 ⇒ 400 拒写（写入侧严判，读侧宽容判不误伤）。
+		// category=intention 时本列即意图生命周期；到期只降档不删除。
+		ExpiresAt string `json:"expires_at"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")
@@ -321,6 +328,14 @@ func (a *API) WriteMemory(w http.ResponseWriter, r *http.Request) {
 		respondError(w, 400, "content too short (<8 chars)")
 		return
 	}
+	// 2026-11-07 (t_88cc9cb8) 意图 TTL：expires_at 非空必须是合法 RFC3339（写入侧严判，
+	// 空 = 永久有效 = 现状）。非法直接 400，不落一条永不降档的坏意图。
+	if req.ExpiresAt != "" {
+		if _, perr := time.Parse(time.RFC3339, req.ExpiresAt); perr != nil {
+			respondError(w, 400, "invalid expires_at (want RFC3339/ISO8601): "+perr.Error())
+			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)
@@ -415,6 +430,8 @@ func (a *API) WriteMemory(w http.ResponseWriter, r *http.Request) {
 		ScriptVersion:    scriptVer,
 		Confidence:       req.Confidence,
 		ConfidenceSource: confidenceSource,
+		// 2026-11-07 (t_88cc9cb8) 意图 TTL：已通过 400 校验的到期时间（空 = 永久 = 现状）。
+		ExpiresAt:        req.ExpiresAt,
 		CreatedAt:        now,
 		UpdatedAt:        now,
 	}
@@ -506,13 +523,15 @@ func cosineSimilarity(a, b []float32) float64 {
 //	用途：区分「真无匹配」（results=[] 但候选数>0）与「依赖故障」（非 2xx）。
 func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 	var req struct {
-		Query     string  `json:"query"`
-		Limit     int     `json:"limit"`
-		TopK      int     `json:"top_k"` // 兼容插件 top_k 参数
-		Namespace string  `json:"namespace"`
-		AgentID   string  `json:"agent_id"` // 用于推导默认 namespace
-		Diversity float64 `json:"diversity"`
-		Mode      string  `json:"mode"` // "hybrid"(default), "semantic", "keyword"
+		Query        string  `json:"query"`
+		Limit        int     `json:"limit"`
+		TopK         int     `json:"top_k"` // 兼容插件 top_k 参数
+		Namespace    string  `json:"namespace"`
+		AgentID      string  `json:"agent_id"` // 用于推导默认 namespace
+		Diversity    float64 `json:"diversity"`
+		Mode         string  `json:"mode"`         // "hybrid"(default), "semantic", "keyword"
+		DeadlineMS   int     `json:"deadline_ms"`  // P0-3：本次召回的硬超时（毫秒），超时返回 partial
+		Continuation string  `json:"continuation"` // P0-3：上一页返回的不透明翻页令牌
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")
@@ -534,6 +553,7 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 			"candidates_scanned": 0,
 			"mode":               req.Mode,
 			"skipped":            "system_template",
+			"skill_refs":         []SkillSectionRef{}, // 契约：键恒存在（AC-2.1）
 		})
 		return
 	}
@@ -545,8 +565,48 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 		req.Limit = 10
 	}
 	// 2026-09-21 五修（t_24eceed0 返修）：无 ns 且无 agent_id → namespace="" → 全库跨 ns 召回
+	// 2026-10-26：区分「作用域来源」——只有 agent_id 派生的 ns 才允许兜底，
+	// 显式传 namespace 的调用方不兜底（避免跨域泄漏）。
+	nsDerivedFromAgent := req.Namespace == "" && req.AgentID != ""
 	req.Namespace = resolveRecallNamespace(req.Namespace, req.AgentID, req.Query)
 
+	// ── P0-3 契约 + P0-1 追踪（2026-10-26）──────────────────────────────
+	// 翻页令牌：绑定 query 指纹 + 作用域，跨 query 复用一律 400（防串页）。
+	offset := 0
+	var prevIDs []string
+	if req.Continuation != "" {
+		pt, perr := decodeContinuation(req.Continuation)
+		if perr != nil {
+			respondErrorSchema(w, 400, "bad_continuation", perr.Error(), 0)
+			return
+		}
+		if pt.Q != queryFingerprint(req.Query) {
+			respondErrorSchema(w, 400, "continuation_query_mismatch",
+				"continuation 属于另一个 query，不能跨 query 复用", 0)
+			return
+		}
+		if pt.NS != req.Namespace {
+			respondErrorSchema(w, 400, "continuation_namespace_mismatch",
+				"continuation 的 namespace 与本次请求不一致", 0)
+			return
+		}
+		offset = pt.Off
+		prevIDs = pt.Prev
+	}
+	// 取数上限 = 页尾（offset+limit）；MMR 的 k 随之上抬，保证前缀稳定。
+	// 多取 len(prevIDs)：用于过滤跨页重复项，过滤后仍能凑满一页（否则「不重」要靠「漏」换）。
+	fetchLimit := req.Limit + offset + len(prevIDs)
+	if fetchLimit > maxContinuationOffset+req.Limit {
+		fetchLimit = maxContinuationOffset + req.Limit
+	}
+
+	ctx := r.Context()
+	if req.DeadlineMS > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, time.Duration(req.DeadlineMS)*time.Millisecond)
+		defer cancel()
+	}
+
 	// H4: Default diversity — balance relevance & diversity
 	// 2026-10-14：改读 storage 的推送值（默认 0.3，与下方原硬编码一致 ⇒ 行为不变），
 	// 让调参器能真正影响召回 —— 此前调参改了 Tuner.Diversity 但没人读（空转）。
@@ -574,72 +634,68 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 	if req.Mode == "" {
 		req.Mode = "hybrid"
 	}
+	// P0-1：trace 在 mode 归一之后创建（记录真实 mode）；所有路径共用同一条 trace。
+	tr := storage.NewRecallTrace("", req.Query, req.Namespace, req.Mode)
+	var lastMeta storage.RecallMeta
 	switch req.Mode {
 	case "keyword":
 		// Pure keyword search: LanceDB + BM25 re-rank, or graph.db fallback
-		// t_2d4e3b92: keyword 主路径依赖向量编码；编码失败（依赖不可用）⇒ 非 2xx，
-		// 不再把错误伪装成 200 + 错误体。
-		// 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)
+		// t_2d4e3b92: keyword 主路径依赖向量编码；编码失败（依赖不可用）⇒ 非 2xx。
+		stKw := time.Now()
+		kwResults, kwMeta, kwErr := a.Pipeline.RecallWithMetaTraced(ctx, req.Query, req.Namespace, fetchLimit, req.Diversity, nsDerivedFromAgent, tr)
 		if kwErr != nil {
-			// 主路径硬错误（向量编码/rerank 依赖不可用）：即便兜底能补结果，也按 502 上报，
-			// 调用方据此走失败路径而不是把依赖故障误判成"无匹配"
+			tr.StageNote("keyword_path", stKw, 0, kwErr.Error())
+			tr.Error = kwErr.Error()
 			respondErrorSchema(w, 502, "recall_backend_error",
 				"keyword recall failed: "+kwErr.Error(), 5)
 			log.Printf("[recall:keyword] failed: %v", kwErr)
 			return
 		}
+		lastMeta = kwMeta
 		cacheHit = kwMeta.CacheHit
-		truncated = kwMeta.Truncated // t_3aa2a8c1
+		truncated = kwMeta.Truncated
 		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),
-				"candidates_scanned": 0, // keyword 路径未做 ANN 扫描
-				"mode":               "keyword",
-				"cache_hit":          false, // graph 兜底结果不来自 search cache
-			})
-			return
+			// 真无匹配（正常业务）或纯词面路径空：graph.db 兜底
+			results = convertFallbackResults(a.GraphStore.FallbackTextSearch(req.Query, req.Namespace, fetchLimit))
+			if len(results) > 0 {
+				tr.StageNote("keyword_fallback", stKw, len(results), "主路径 0 命中 ⇒ graph.db 兜底")
+			} else {
+				tr.Stage("keyword_path", stKw, 0)
+			}
+			cacheHit = false // 兜底结果不来自 search cache
+		} else {
+			// Re-rank by BM25 only
+			for i := range kwResults {
+				kwResults[i].Score = storage.ComputeBM25Score(req.Query, kwResults[i].Content)
+			}
+			sort.Slice(kwResults, func(i, j int) bool { return kwResults[i].Score > kwResults[j].Score })
+			if len(kwResults) > fetchLimit {
+				kwResults = kwResults[:fetchLimit]
+			}
+			for i := range kwResults {
+				if kwResults[i].Channel == "" {
+					kwResults[i].Channel = "keyword"
+				}
+			}
+			results = kwResults
+			tr.Stage("keyword_path", stKw, len(results))
 		}
-		// Re-rank by BM25 only
-		for i := range kwResults {
-			kwResults[i].Score = storage.ComputeBM25Score(req.Query, kwResults[i].Content)
-		}
-		sort.Slice(kwResults, func(i, j int) bool { return kwResults[i].Score > kwResults[j].Score })
-		if len(kwResults) > req.Limit {
-			kwResults = kwResults[:req.Limit]
-		}
-		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)
-		// t_949840b1：RecallWithMeta 额外返回候选池真实大小（ANN 粗检索池，非最终产出数）
+		// Pure semantic — BM25 off（Pipeline 内部按 mode 处理）
 		var meta storage.RecallMeta
-		results, meta, err = a.Pipeline.RecallWithMeta(req.Query, req.Namespace, req.Limit, req.Diversity)
+		results, meta, err = a.Pipeline.RecallWithMetaTraced(ctx, req.Query, req.Namespace, fetchLimit, req.Diversity, nsDerivedFromAgent, tr)
+		lastMeta = meta
 		annScanned = meta.CandidatesScanned
-		cacheHit = meta.CacheHit // t_1c12e000
-		truncated = meta.Truncated // t_3aa2a8c1
+		cacheHit = meta.CacheHit
+		truncated = meta.Truncated
 	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)
+		results, meta, err = a.Pipeline.RecallWithMetaTraced(ctx, req.Query, req.Namespace, fetchLimit, req.Diversity, nsDerivedFromAgent, tr)
+		lastMeta = meta
 		annScanned = meta.CandidatesScanned
-		cacheHit = meta.CacheHit // t_1c12e000
-		truncated = meta.Truncated // t_3aa2a8c1
+		cacheHit = meta.CacheHit
+		truncated = meta.Truncated
 	}
 	if err != nil {
 		// P0: 降级到 graph.db 关键词搜索（仅 hybrid/semantic 主路径依赖向量/rerank）
@@ -647,11 +703,13 @@ 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
+			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 里塞错误）
+			tr.MarkPartial("stage_error")
+			tr.Error = err.Error()
 			respondErrorSchema(w, 502, "recall_backend_error",
 				"recall failed: "+err.Error()+"; graph fallback also empty", 5)
 			log.Printf("[recall] failed: %v; fallback empty", err)
@@ -664,7 +722,12 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// E4.2: 跨 agent 知识共享 — recall 结果在 (0, top_k) 时，补充搜索 "shared" namespace
-	if len(results) > 0 && len(results) < 3 && req.Namespace != "shared" && req.Namespace != "" {
+	// t_a243aefa 终审补漏（2026-11-07 部署后实测）：ghost ns（全表无该 ns 行）时**不得**补搜 shared。
+	// t_15d82af7 已给 coarse search 的 namespaces 列表和 FTS 尾通道加了同口径判据，唯独漏了本处 ⇒
+	// 传不存在的 ns 仍会经 E4.2 捞出 shared 记忆（实测泄漏 mem_1793118290141936234, channel=shared, score=0.5）。
+	// 现与另两处对齐：nsHasRows=false ⇒ 不补搜。判据函数与 recall.go 同一个（带 60s TTL 缓存）。
+	if len(results) > 0 && len(results) < 3 && req.Namespace != "shared" && req.Namespace != "" &&
+		storage.NamespaceHasRowsFor(a.LanceDB, req.Namespace) {
 		vec, encErr := a.Embedder.EncodeQuery(req.Query)
 		if encErr == nil {
 			var shared []models.MemoryRecord
@@ -693,12 +756,20 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 						vv = storage.VValueProvider(m.ID)
 					}
 					results = append(results, models.RecallResult{
-						ID:           m.ID,
-						Content:      m.Content,
-						Category:     m.Category,
-						Score:        0.5, // shared 结果降权，使用默认分
-						QualityScore: m.QualityScore,
-						VValue:       vv,
+						ID:               m.ID,
+						Content:          m.Content,
+						Category:         m.Category,
+						Score:            0.5, // shared 结果降权，使用默认分
+						QualityScore:     m.QualityScore,
+						VValue:           vv,
+						HumanUsefulCount: m.HumanUsefulCount, // A10 (t_d618dc7c)
+						Channel:          "shared",           // P0-1：来源通道
+						Version:          m.Version,
+						ValidFrom:        m.ValidFrom,
+						ValidTo:          m.ValidTo,
+						Supersedes:       m.Supersedes,
+						SupersededBy:     m.SupersededBy,
+						Superseded:       len(m.SupersededBy) > 0,
 					})
 				}
 			}
@@ -709,7 +780,11 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 	// wiki_curator 把「笔记→知识」写进 wiki-curator-main，而主召回只搜
 	// req.Namespace/shared ⇒ 33+ 条笔记知识长期在盲区（召回永远看不到）。
 	// 这里补搜：主结果不足 top_k 时，从额外命名空间补齐（去重 + 降权 0.45）。
-	if req.Namespace != "wiki-curator-main" && req.Namespace != "" {
+	// t_15d82af7：显式 ns 在全量表里无行（ghost）⇒ 不补 wiki（ghost 查询不得被
+	// 洗成 wiki-curator-main 结果）。判据与主路径/生产客户端过滤同源：ScanAll
+	// 全量行；探测失败/后端不支持 ⇒ 保守当存在（不跳，旧行为）。
+	nsAbsent := req.Namespace != "" && !storage.NamespaceHasRowsFor(a.LanceDB, req.Namespace)
+	if req.Namespace != "wiki-curator-main" && req.Namespace != "" && !nsAbsent {
 		if vec, encErr := a.Embedder.EncodeQuery(req.Query); encErr == nil {
 			for _, extra := range []string{"wiki-curator-main"} {
 				var extraHits []models.MemoryRecord
@@ -736,12 +811,20 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 							vv = storage.VValueProvider(m.ID)
 						}
 						results = append(results, models.RecallResult{
-							ID:           m.ID,
-							Content:      m.Content,
-							Category:     m.Category,
-							Score:        0.45, // 笔记知识降权：不挤掉主记忆，但能被看到
-							QualityScore: m.QualityScore,
-							VValue:       vv,
+							ID:               m.ID,
+							Content:          m.Content,
+							Category:         m.Category,
+							Score:            0.45, // 笔记知识降权：不挤掉主记忆，但能被看到
+							QualityScore:     m.QualityScore,
+							VValue:           vv,
+							HumanUsefulCount: m.HumanUsefulCount, // A10 (t_d618dc7c)
+							Channel:          "wiki",             // P0-1：来源通道
+							Version:          m.Version,
+							ValidFrom:        m.ValidFrom,
+							ValidTo:          m.ValidTo,
+							Supersedes:       m.Supersedes,
+							SupersededBy:     m.SupersededBy,
+							Superseded:       len(m.SupersededBy) > 0,
 						})
 					}
 				}
@@ -771,6 +854,28 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 		results = ordered
 	}
 
+	// ── 2026-10-26（P1-3 生命周期 fixture 抓到的真 bug）──────────────────
+	// 主候选池在 pipeline 里已做 bi-temporal 过滤，但 **shared / wiki 补充通道与图谱注入
+	// 不过那道闸** ⇒ 已失效事实会从补充通道回流进 top-k（实测：valid_to=11:00 的记录
+	// 被 shared 通道以 score=0.5 重新塞回）。这里在「所有注入完成之后、cap 之前」统一过滤，
+	// 保证读侧只有一条有效期口径。全失效时保留原结果（不把召回清空，non-lossy）。
+	if storage.BitemporalEnabled() {
+		now := time.Now()
+		live := make([]models.RecallResult, 0, len(results))
+		expired := 0
+		for _, r := range results {
+			if storage.ValidityExpired(r.ValidTo, now) {
+				expired++
+				continue
+			}
+			live = append(live, r)
+		}
+		if len(live) > 0 && expired > 0 {
+			log.Printf("[recall] 补充通道 bi-temporal 过滤 %d 条失效事实（统一读侧口径）", expired)
+			results = live
+		}
+	}
+
 	// Record recall hit rate (has results = hit, empty = miss)
 	selfoptimize.Dash.RecordRecall(len(results) > 0)
 	// Gap auto-close: recall 命中后自动关闭该 query 对应的 open gap
@@ -812,23 +917,102 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
 		}
 		storage.RecordRecalled(recs)
 	}
+	// ── 2026-10-26 (t_9025b0eb) top_k 收口：图谱扩展不得撑爆返回集 ──
+	// 现象：/api/v1/recall 完全无视 top_k —— top_k=5 实测返回 1905/1625 条、top_k=10 返回
+	//   2227/1859 条，其中 99% 是 category=graph_expanded（图谱扩展 append 无上限）。
+	//   后果：插件记忆预取被撑到 103,299 chars 截断（真相关条目落在被截断段）、count 失真、
+	//   ⑤使用追踪按千级结果记账。
+	// 契约修正（主结果优先）：
+	//   results        = 主检索结果（category != graph_expanded），截断到 req.Limit；
+	//                    主结果不足 req.Limit 时用扩展结果按原顺序补齐（稀疏查询仍有扩展收益）。
+	//   graph_expanded = 扩展结果**单独成字段**（上限 req.Limit）——能力仍可观测、可统计，
+	//                    但不再挤占主结果、不再污染 results/count。
+	results, graphExpanded := capRecallResults(results, fetchLimit)
 	if results == nil {
 		results = []models.RecallResult{}
 	}
+
+	// ── P0-3 翻页：从 fetchLimit 结果里切出 [offset, offset+limit) ──
+	// 说明：翻页重算整段前 offset+limit 条再切片，保证 MMR 前缀稳定；
+	// 令牌绑定 query 指纹 + namespace，跨 query/跨域复用一律 400（防串页）。
+	// ⚠ 2026-11-02 (t_58f9d476)：切片必须对 pattern/peer carry 豁免——
+	// capRecallResults 特意把 carry 恒保留追加在 prim 之后（回填保证主+扩展填满
+	// limit ⇒ carry 恒落在索引 limit），本块裸 results[:limit] 把它恒切掉，
+	// t_e98cb1d6 的 carry 修复在此被整体作废（ZHIYI_PEER_RECALL 结构性零产出，
+	// dbg 插桩实证注入发生 4087→4088 但响应无 peer）。语义改走纯函数
+	// paginateRecallWithCarry（可单测）：carry 摘出→offset/去重/截断→回尾。
+	totalFetched := len(results)
+	results, mainLen := paginateRecallWithCarry(results, offset, prevIDs, req.Limit)
+	nextCont := ""
+	// ⚠ 2026-11-02 (t_2891d689)：判据看主路段 mainLen，不看 len(results)——
+	// carry 会把 results 撑过 limit，旧判据 len(results)==req.Limit 在有注入时
+	// 恒假 ⇒ nextCont 恒空、翻页链断裂。收口到 shouldEmitContinuation（可单测）。
+	if shouldEmitContinuation(totalFetched, fetchLimit, mainLen, req.Limit, offset) {
+		returned := make([]string, 0, len(prevIDs)+len(results))
+		returned = append(returned, prevIDs...)
+		for _, r := range results {
+			returned = append(returned, r.ID)
+		}
+		nextCont = encodeContinuation(req.Query, req.Namespace, offset+req.Limit, req.Limit, returned)
+	}
+
+	// ── P0-1/P0-3：契约字段 + trace 落盘 ──
+	tr.SetItems(traceItems(results))
+	status := lastMeta.Status
+	if status == "" {
+		status = "complete"
+	}
+	partialReason := lastMeta.PartialReason
+	if tr.Status == "partial" && status == "complete" {
+		status = "partial"
+		partialReason = tr.PartialReason
+	}
+	if truncated && status == "complete" {
+		status = "partial"
+		partialReason = "row_cap_truncated"
+	}
+	tr.Status = status
+	tr.PartialReason = partialReason
+	tr.CacheHit = cacheHit
+	tr.Truncated = truncated
+	tr.CandidatesScanned = annScanned
+	tr.Namespace = req.Namespace
+	tr.Mode = req.Mode
+	tr.Scope = buildScope(req.Namespace, req.Limit, req.Mode, cacheHit, truncated, tr.StartedAt)
+	if offset > 0 {
+		tr.Scope["offset"] = offset
+	}
+	storage.SaveTrace(tr)
+
 	resp := map[string]interface{}{
 		"results":            results,
 		"count":              len(results),
 		"candidates_scanned": annScanned,
 		"mode":               req.Mode,
+		// 2026-10-26 (t_9025b0eb)：扩展结果单独成字段，避免撑爆 results。
+		// 键恒存在（可为空数组），便于探针/统计区分「无扩展」与「字段缺失」。
+		"graph_expanded": graphExpanded,
+		// AC-2.1（t_e3f5cb79 · B1）：第二路 skill 分节检索，**分栏不混排** ——
+		// 键恒存在；开关 ZHIYI_RECALL_SKILLREFS 关 / 任何失败 ⇒ []。
+		// 「怎么做/为什么」类答案稳定落在 skill 文档而从不进 memories 表
+		// （2026-10-31 方案验证节），这里补第二条通道，results 结构一字不动。
+		"skill_refs": skillRefsForQuery(req.Query, 5),
 		// t_1c12e000：AC3 —— 缓存命中/回源扫表必须可区分。
-		// true ⇒ candidates_scanned=0 是「读了 60s 内的旧快照」（含 L1/L2）；
-		// false ⇒ 本次真扫了表（candidates_scanned 为真实候选池大小）。
 		"cache_hit": cacheHit,
+		// 2026-10-26（P0-1/P0-3 契约）：
+		//   trace_id     ⇒ GET /api/v1/trace/<id> 可重建本次调用链（阶段耗时 + 每通道贡献）；
+		//   status       ⇒ complete 的空结果才可解读为「不存在」；partial 必须看 partial_reason；
+		//   scope        ⇒ 本次答案基于哪个数据视图（namespace/snapshot/cache_hit/truncated）；
+		//   continuation ⇒ 空串=无下一页，非空=拼回请求体取下一页。
+		"trace_id":     tr.TraceID,
+		"status":       status,
+		"scope":        tr.Scope,
+		"continuation": nextCont,
+	}
+	if partialReason != "" {
+		resp["partial_reason"] = partialReason
 	}
 	// t_3aa2a8c1：truncated —— 只在 true 时暴露（键缺失 = 未截断，等价 omitempty 语义）。
-	// true = 本次 recall 的粗检索/补充搜至少一次命中 Rust 侧单次重读行数上限
-	// （默认 20000，ZHIYI_HEAVY_READ_MAX_ROWS）被截断为部分结果 ⇒ count/
-	// candidates_scanned 是截断后状态，调用方不得当作「全量」。
 	if truncated {
 		resp["truncated"] = true
 	}
@@ -906,6 +1090,14 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
 	}
 	// 2026-09-21 五修：与 Recall 完全一致（同一解析函数），保证 debug 端点如实反映 Recall 行为
 	req.Namespace = resolveRecallNamespace(req.Namespace, req.AgentID, req.Query)
+	// t_f1ee22e5：与 Recall (core.go:613) 完全同源的 diversity 默认值。
+	// 修前 debug 直接用 req.Diversity（缺省 0）⇒ mmr 行报 diversity=0.0，
+	// 而生产 Recall 走 storage.DefaultMMRDiversity()（实测 tune-state 推送 0.1）
+	// ⇒ 诊断端点报的 MMR 与生产不同口径（撒的谎比没诊断更贵）。
+	// 不硬编码 0.1 —— 读的是同一个 storage 推送原子值，调参器改了就跟着变。
+	if req.Diversity <= 0 {
+		req.Diversity = storage.DefaultMMRDiversity()
+	}
 
 	type stepInfo struct {
 		Step      string `json:"step"`
@@ -922,7 +1114,7 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
 	encodeTime := time.Since(t1).Milliseconds()
 	if err != nil {
 		steps = append(steps, stepInfo{"encode", "error", encodeTime, err.Error()})
-		respond(w, 200, map[string]interface{}{"steps": steps, "results": []interface{}{}, "total_ms": time.Since(totalStart).Milliseconds()})
+		respond(w, 200, map[string]interface{}{"query": req.Query, "steps": steps, "results": []interface{}{}, "count": 0, "total_ms": time.Since(totalStart).Milliseconds()})
 		return
 	}
 	steps = append(steps, stepInfo{"encode", "ok", encodeTime, fmt.Sprintf("dim=%d", len(queryVec))})
@@ -931,11 +1123,14 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
 	t2 := time.Now()
 	// 2026-09-21 五修：与 RecallPipeline 完全一致 —— ns=="" 走全库单次检索，
 	// 否则 [ns, shared]。诊断端点必须如实反映生产召回行为，不能自带另一套 ns 逻辑。
+	// 2026-11-09 t_nsdebug：补上 ghost-ns 闸（与 recall.go 的 namespaceHasRows 同判据、同缓存）。
+	// 背景：生产 /recall 已于 11-07 修好（ghost ns ⇒ 0 条），debug 端点仍无条件并 shared，
+	// 实测 ghost ns 报 "5 candidates from 2 namespaces" ⇒ 诊断撒的谎比没诊断更贵。
 	nsList := []string{req.Namespace}
 	if req.Namespace == "" {
 		nsList = []string{""} // 全库
-	} else if req.Namespace != "shared" {
-		nsList = append(nsList, "shared")
+	} else if req.Namespace != "shared" && storage.NamespaceHasRowsFor(a.LanceDB, req.Namespace) {
+		nsList = append(nsList, "shared") // ghost ns（全量表无行）⇒ 不并 shared，与生产同口径
 	}
 	var candidates []models.MemoryRecord
 	for _, ns := range nsList {
@@ -950,8 +1145,8 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
 	}
 	annTime := time.Since(t2).Milliseconds()
 	if len(candidates) == 0 {
-		steps = append(steps, stepInfo{"ann_search", "ok", annTime, "0 candidates"})
-		respond(w, 200, map[string]interface{}{"steps": steps, "results": []interface{}{}, "total_ms": time.Since(totalStart).Milliseconds()})
+		steps = append(steps, stepInfo{"ann_search", "ok", annTime, fmt.Sprintf("0 candidates from %d namespaces", len(nsList))})
+		respond(w, 200, map[string]interface{}{"query": req.Query, "steps": steps, "results": []interface{}{}, "count": 0, "total_ms": time.Since(totalStart).Milliseconds()})
 		return
 	}
 	steps = append(steps, stepInfo{"ann_search", "ok", annTime, fmt.Sprintf("%d candidates from %d namespaces", len(candidates), len(nsList))})
@@ -1001,6 +1196,7 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
 			results = append(results, models.RecallResult{
 				ID: c.ID, Content: c.Content, Category: c.Category,
 				Score: score, Timestamp: c.CreatedAt.Format(time.RFC3339),
+				HumanUsefulCount: c.HumanUsefulCount, // A10 (t_d618dc7c)
 			})
 		}
 	}
@@ -1468,3 +1664,141 @@ func (a *API) EdgeFeedback(w http.ResponseWriter, r *http.Request) {
 func (a *API) PopWatch(w http.ResponseWriter, r *http.Request) {
 	respond(w, 200, storage.PopWatchSnapshot())
 }
+
+// capRecallResults —— 2026-10-26 (t_9025b0eb) top_k 收口语义（纯函数，可单测）。
+//
+// 输入是 pipeline 返回的原始结果（主检索在前、图谱扩展 append 在后，扩展无上限）。
+// 输出：
+//
+//	prim     = 主检索结果（category != graph_expanded），截断到 limit；
+//	          若主结果不足 limit，用扩展结果按原顺序补齐（稀疏查询仍有扩展收益）。
+//	expanded = 剩余扩展结果，单独成字段返回，上限 limit（能力可观测，但不挤占主结果）。
+//
+// 为什么不是「直接 results[:limit]」：扩展结果全部排在主结果之后，直接截断会让
+// category=graph_expanded 恒为 0 ⇒ 能力虽在跑但对外永久失明（本仓 2026-10 已因同类
+// 「接线≠出数」栽过一次）。所以既收口、又保留可观测通道。
+func capRecallResults(results []models.RecallResult, limit int) (prim, expanded []models.RecallResult) {
+	if limit <= 0 {
+		limit = 10
+	}
+	prim = make([]models.RecallResult, 0, limit)
+	if len(results) == 0 {
+		return prim, []models.RecallResult{}
+	}
+	exp := make([]models.RecallResult, 0, len(results))
+	// 2026-10-26 (t_e98cb1d6)：pattern / peer 是「附带注入」的召回条目（recall.go Step 6.2/6.3），
+	// 追加在 results 末尾 ⇒ 若并入 prim 一起截断，distilled 占满 limit 时它们恒被切光
+	// （16:28 topkcap 引入的 pattern 截断回归，limit=50 时 pattern=0 / limit=200 才现形 3 条）。
+	// 正确语义：主检索结果（distilled 等）照常收口到 limit；pattern/peer 作为附带条目
+	// 恒保留（不挤占主结果配额），避免「命中即注入」被 cap 吞掉。graph_expanded 仍走独立字段。
+	var carry []models.RecallResult
+	for _, r := range results {
+		switch r.Category {
+		case "graph_expanded":
+			exp = append(exp, r)
+		case "pattern", "peer":
+			carry = append(carry, r)
+		default:
+			prim = append(prim, r)
+		}
+	}
+	// 先收口主结果
+	if len(prim) > limit {
+		prim = prim[:limit]
+	}
+	// 主结果不足 limit 时用扩展结果按原顺序补齐（稀疏查询仍有扩展收益）
+	if len(exp) > 0 {
+		if room := limit - len(prim); room > 0 {
+			if room > len(exp) {
+				room = len(exp)
+			}
+			prim = append(prim, exp[:room]...)
+			exp = exp[room:]
+		}
+		if len(exp) > limit {
+			exp = exp[:limit]
+		}
+	}
+	// pattern / peer 附带条目恒保留在 results 末尾（独立于主结果配额）
+	prim = append(prim, carry...)
+	if expanded == nil {
+		expanded = exp
+	}
+	return prim, expanded
+}
+
+// paginateRecallWithCarry —— P0-3 翻页切片，对 pattern/peer carry 豁免
+// （2026-11-02 t_58f9d476；carry 判据与 capRecallResults 同源：Category ∈ {pattern, peer}）。
+//
+// 病灶：capRecallResults 把 carry 恒保留追加在 prim 之后（主+扩展回填恒填满 limit
+// ⇒ carry 恒在索引 limit 处），紧随的 P0-3 裸 `results[:req.Limit]` 恒把它切掉
+// ——t_e98cb1d6 的 carry 修复被作废，peer/pattern 注入在主召回响应里结构性失明。
+//
+// 语义（纯函数，可单测）：先把 carry 摘出，对剩余主路段照旧做
+// offset 切片 → prevIDs 去重 → [:limit] 截断，第一页把 carry 回尾。
+// 保证：① 主路段逐位不变（t_9025b0eb AC 不动：主路段 ≤ limit）；
+// ② carry 在第一页存活且恒在响应末尾；③ 无 carry（门关态）逐位与旧内联逻辑 delta=0；
+// ④ 主路段切空（offset 越界 / 去重全掉）时返回空段，不返回孤儿 carry。
+//
+// 2026-11-02（t_2891d689）两处修订：
+// ① 返回值加 mainLen（主路段截断后的长度）。4ffc546 后 carry 使 len(results) 可以
+//    超过 limit，翻页判据若看 len(results) 会恒假 ⇒ nextCont 恒空、带注入的 query
+//    翻页链断裂（本卡病灶）。判据改看主路段（见 shouldEmitContinuation）。
+// ② carry 只在第一页出现：carry 是固定钉住的注入条目，第一页其 ID 已随 returned
+//    记进令牌 prev；续页再追加必然逐页重复，等于把去重成本转嫁给客户端。
+//    ⇒ offset > 0 时只回主路段，不追加 carry。
+func paginateRecallWithCarry(results []models.RecallResult, offset int, prevIDs []string, limit int) ([]models.RecallResult, int) {
+	var carry []models.RecallResult
+	main := make([]models.RecallResult, 0, len(results))
+	for _, r := range results {
+		if r.Category == "pattern" || r.Category == "peer" {
+			carry = append(carry, r)
+		} else {
+			main = append(main, r)
+		}
+	}
+	if offset > 0 {
+		if offset >= len(main) {
+			main = []models.RecallResult{}
+		} else {
+			main = main[offset:]
+		}
+	}
+	if len(prevIDs) > 0 {
+		seenPrev := make(map[string]bool, len(prevIDs))
+		for _, id := range prevIDs {
+			seenPrev[id] = true
+		}
+		kept := main[:0]
+		for _, r := range main {
+			if !seenPrev[r.ID] {
+				kept = append(kept, r)
+			}
+		}
+		main = kept
+	}
+	if limit >= 0 && len(main) > limit {
+		main = main[:limit]
+	}
+	mainLen := len(main)
+	if mainLen == 0 {
+		// 与旧语义一致：主路段空 ⇒ 整页空（页面上只有注入条目没有意义）
+		return []models.RecallResult{}, 0
+	}
+	if offset > 0 {
+		// t_2891d689：carry 只在第一页出现，续页不回尾（见函数头注释 ②）
+		return main, mainLen
+	}
+	return append(main, carry...), mainLen
+}
+
+// shouldEmitContinuation —— P0-3 是否发放下一页 continuation 令牌（2026-11-02 t_2891d689）。
+//
+// 病灶：4ffc546 后 carry 追加在主路段之后 ⇒ len(results) 可以 > limit，
+// 判据 `len(results) == req.Limit` 只要 carry 命中就恒假 ⇒ nextCont 恒空，
+// 带 pattern/peer 注入的 query 翻页链断裂（第二页永远取不到）。
+// 修法：判据看**主路段长度** mainLen —— carry 不参与「是否还有下一页」的判断。
+// 必须用 == 而不用 >=：主路段未满一页（offset 越界 / 尾页不满）时不得错发令牌。
+func shouldEmitContinuation(totalFetched, fetchLimit, mainLen, limit, offset int) bool {
+	return totalFetched >= fetchLimit && mainLen == limit && offset+limit < maxContinuationOffset
+}

go/internal/api/routes/core_topk_test.go

@@ -0,0 +1,491 @@
+package routes
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+// 2026-10-26 (t_9025b0eb)：top_k 收口契约测试。
+// 起因：/api/v1/recall 完全无视 top_k —— top_k=5 实测返回 1905/1625 条（99% graph_expanded），
+// 插件记忆预取被撑到 103,299 chars 截断、count 失真、使用追踪按千级结果记账。
+// 钉住四件事：① results 不超过 limit ② 主结果不被扩展挤掉 ③ 扩展仍可见且不超 limit
+// ④ 稀疏查询（主结果 < limit）时扩展能补齐。
+func TestCapRecallResults(t *testing.T) {
+	mk := func(n int, cat string) []models.RecallResult {
+		out := make([]models.RecallResult, n)
+		for i := 0; i < n; i++ {
+			out[i] = models.RecallResult{ID: cat + string(rune('a'+i%26)), Category: cat, Content: cat}
+		}
+		return out
+	}
+	cases := []struct {
+		name         string
+		prim, exp    int
+		limit        int
+		wantPrim     int
+		wantExp      int
+		primCategory string
+	}{
+		{"主结果足额_扩展不得进results", 10, 1900, 5, 5, 5, "distilled"},
+		{"主结果只有2条_扩展补齐到limit", 2, 900, 5, 5, 5, "distilled"},
+		{"无扩展_纯截断", 30, 0, 10, 10, 0, "distilled"},
+		{"扩展少于limit", 1, 3, 5, 4, 0, "distilled"},
+		{"空结果", 0, 0, 5, 0, 0, ""},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			all := append(mk(c.prim, "distilled"), mk(c.exp, "graph_expanded")...)
+			prim, exp := capRecallResults(all, c.limit)
+			if len(prim) != c.wantPrim {
+				t.Fatalf("prim=%d want %d", len(prim), c.wantPrim)
+			}
+			if len(exp) != c.wantExp {
+				t.Fatalf("expanded=%d want %d", len(exp), c.wantExp)
+			}
+			if len(prim)+len(exp) > c.limit*2 {
+				t.Fatalf("总量失控: prim=%d exp=%d", len(prim), len(exp))
+			}
+			// 主结果条数不得超过原始主结果数（不得凭空造）
+			n := 0
+			for _, r := range prim {
+				if r.Category != "graph_expanded" {
+					n++
+				}
+			}
+			if n > c.prim {
+				t.Fatalf("主结果 %d 条，超过输入 %d 条（凭空造）", n, c.prim)
+			}
+			if c.primCategory != "" && c.prim > 0 && n == 0 {
+				t.Fatalf("主结果被扩展挤光：%+v", prim)
+			}
+		})
+	}
+}
+
+// limit 非法（0/负数）时按默认 10 处理，不做无界返回。
+func TestCapRecallResultsDefaultLimit(t *testing.T) {
+	all := make([]models.RecallResult, 50)
+	for i := range all {
+		all[i] = models.RecallResult{Category: "distilled"}
+	}
+	prim, _ := capRecallResults(all, 0)
+	if len(prim) != 10 {
+		t.Fatalf("limit=0 应回落 10，得到 %d", len(prim))
+	}
+}
+
+// ── t_e98cb1d6 回归：pattern / peer 被 cap 截断 ────────────────────────────
+// 病灶：capRecallResults 把非 graph_expanded 全部并入 prim 再截断到 limit；
+//       pattern/peer 是 recall.go Step 6.2/6.3 追加到 results 末尾的附带条目，
+//       distilled 占满 limit 时它们被整段切掉（16:28 topkcap 引入，limit=50 时 pattern=0）。
+// 修后：pattern/peer 恒保留在 results 末尾（独立于主结果配额），主结果仍照常收口。
+func TestCapRecallResults_PatternAndPeerSurviveCap(t *testing.T) {
+	mk := func(n int, cat string) []models.RecallResult {
+		out := make([]models.RecallResult, n)
+		for i := 0; i < n; i++ {
+			out[i] = models.RecallResult{ID: cat + string(rune('a'+i%26)), Category: cat, Content: cat}
+		}
+		return out
+	}
+	count := func(rs []models.RecallResult, cat string) int {
+		n := 0
+		for _, r := range rs {
+			if r.Category == cat {
+				n++
+			}
+		}
+		return n
+	}
+
+	cases := []struct {
+		name                  string
+		d, p, pe, e           int // distilled / pattern / peer / graph_expanded
+		limit                 int
+		wantD, wantP, wantPe  int
+	}{
+		// ① 金标场景：主结果占满 limit，pattern/peer 追加在末尾 ⇒ 修前恒为 0
+		{"limit=50_主结果占满_pattern 恒保留", 50, 3, 1, 0, 50, 50, 3, 1},
+		{"limit=200_主结果占满_pattern 仍保留", 100, 3, 1, 97, 200, 100, 3, 1},
+		// ② peer 注入同样不被截断
+		{"limit=50_peer 注入不被截断", 50, 0, 2, 0, 50, 50, 0, 2},
+		// ③ 主结果不足 limit：扩展先补齐主结果，carry 仍保留在末尾
+		{"limit=50_主结果不足_扩展补齐+carry 保留", 30, 2, 1, 10, 50, 30, 2, 1},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			all := make([]models.RecallResult, 0, c.d+c.p+c.pe+c.e)
+			all = append(all, mk(c.d, "distilled")...)
+			all = append(all, mk(c.p, "pattern")...)
+			all = append(all, mk(c.pe, "peer")...)
+			all = append(all, mk(c.e, "graph_expanded")...)
+			prim, exp := capRecallResults(all, c.limit)
+			d := count(prim, "distilled")
+			p := count(prim, "pattern")
+			pe := count(prim, "peer")
+			e := count(prim, "graph_expanded")
+			if d != c.wantD {
+				t.Errorf("distilled=%d want %d", d, c.wantD)
+			}
+			// AC：limit=50 时 pattern 必须 ≥1（金标 query 复现终审现象）
+			if c.p > 0 && p < 1 {
+				t.Errorf("pattern=%d，应 ≥1（截断回归未修）", p)
+			}
+			if p != c.wantP {
+				t.Errorf("pattern=%d want %d", p, c.wantP)
+			}
+			if pe != c.wantPe {
+				t.Errorf("peer=%d want %d", pe, c.wantPe)
+			}
+			// cap 仍然生效：主结果（distilled + 扩展补齐）不得超过 limit
+			if d+e > c.limit {
+				t.Fatalf("主结果超 cap: distilled=%d graph_expanded=%d limit=%d", d, e, c.limit)
+			}
+			if len(exp) > c.limit {
+				t.Fatalf("graph_expanded 字段超 cap: %d > %d", len(exp), c.limit)
+			}
+			// 附带条目不得被塞进 graph_expanded 字段
+			if count(exp, "pattern") > 0 || count(exp, "peer") > 0 {
+				t.Fatalf("pattern/peer 被误放入 graph_expanded 字段")
+			}
+		})
+	}
+}
+
+// ── t_58f9d476 回归：P0-3 翻页切片吞掉 carry ──────────────────────────────
+// 病灶：capRecallResults 之后 results = [主(填满 limit)..., carry...]，紧随的
+//       P0-3 翻页块裸 `results[:req.Limit]` 恒把 carry 切掉（carry 恰在索引 limit）
+//       ⇒ t_e98cb1d6 的 carry 修复被作废，peer/pattern 注入结构性失明
+//       （t_9dc647f1 dbg 插桩实证：注入 4087→4088 发生，响应 50 条无 peer）。
+// 修后：paginateRecallWithCarry 对 carry 豁免切片并回尾；关态（无 carry）逐位 delta=0。
+func TestPaginateRecallWithCarry(t *testing.T) {
+	mkMain := func(n int) []models.RecallResult {
+		out := make([]models.RecallResult, n)
+		for i := 0; i < n; i++ {
+			out[i] = models.RecallResult{ID: fmt.Sprintf("mem_%03d", i), Category: "distilled", Content: "m"}
+		}
+		return out
+	}
+	carry := func(rs ...models.RecallResult) []models.RecallResult { return rs }
+
+	// ① 金标场景：limit=5、主+扩展填满 limit、末位=peer ⇒ 切片后末位仍 = peer:<id>，
+	//    且主路段逐位 = 原前 5 位（t_9025b0eb AC：主路 ≤ limit 不变）。
+	t.Run("limit=5_末位peer存活_主路段逐位不变", func(t *testing.T) {
+		in := append(mkMain(5), models.RecallResult{ID: "peer:muc", Category: "peer", Content: "p"})
+		got, mainLen := paginateRecallWithCarry(in, 0, nil, 5)
+		if len(got) != 6 {
+			t.Fatalf("len=%d want 6（主 5 + carry 1）", len(got))
+		}
+		if mainLen != 5 {
+			t.Fatalf("mainLen=%d want 5（t_2891d689：判据主路段长度=limit，翻页令牌据此发放）", mainLen)
+		}
+		if got[5].ID != "peer:muc" || got[5].Category != "peer" {
+			t.Fatalf("末位=%s/%s，want peer:muc/peer（截断回归未修）", got[5].ID, got[5].Category)
+		}
+		for i := 0; i < 5; i++ {
+			if got[i].ID != in[i].ID {
+				t.Fatalf("主路段第 %d 位变了: got=%s want=%s", i, got[i].ID, in[i].ID)
+			}
+		}
+	})
+
+	// ② limit=50、pattern(3)+peer(1) 全存活，主路段逐位不变。
+	t.Run("limit=50_pattern与peer全存活", func(t *testing.T) {
+		in := append(mkMain(50), carry(
+			models.RecallResult{ID: "pattern:a", Category: "pattern"},
+			models.RecallResult{ID: "pattern:b", Category: "pattern"},
+			models.RecallResult{ID: "pattern:c", Category: "pattern"},
+			models.RecallResult{ID: "peer:muc", Category: "peer"},
+		)...)
+		got, _ := paginateRecallWithCarry(in, 0, nil, 50)
+		if len(got) != 54 {
+			t.Fatalf("len=%d want 54", len(got))
+		}
+		for i := 0; i < 50; i++ {
+			if got[i].ID != in[i].ID {
+				t.Fatalf("主路段第 %d 位变了", i)
+			}
+		}
+		if got[53].ID != "peer:muc" {
+			t.Fatalf("末位=%s want peer:muc", got[53].ID)
+		}
+		nPat := 0
+		for _, r := range got {
+			if r.Category == "pattern" {
+				nPat++
+			}
+		}
+		if nPat != 3 {
+			t.Fatalf("pattern=%d want 3", nPat)
+		}
+	})
+
+	// ③ 关态（无 carry）逐位 delta=0：offset × prevIDs × limit 组合下
+	//    与旧内联语义（切片→去重→截断）逐一比对。
+	t.Run("关态无carry_与旧内联逻辑逐位一致", func(t *testing.T) {
+		legacy := func(in []models.RecallResult, offset int, prevIDs []string, limit int) []models.RecallResult {
+			results := in
+			if offset > 0 {
+				if offset >= len(results) {
+					results = []models.RecallResult{}
+				} else {
+					results = results[offset:]
+				}
+			}
+			if len(prevIDs) > 0 {
+				seen := make(map[string]bool, len(prevIDs))
+				for _, id := range prevIDs {
+					seen[id] = true
+				}
+				kept := make([]models.RecallResult, 0, len(results))
+				for _, r := range results {
+					if !seen[r.ID] {
+						kept = append(kept, r)
+					}
+				}
+				results = kept
+			}
+			if len(results) > limit {
+				results = results[:limit]
+			}
+			return results
+		}
+		in := mkMain(30)
+		for _, offset := range []int{0, 1, 7, 29, 30, 45} {
+			for _, prev := range [][]string{nil, {"mem_008"}, {"mem_008", "mem_009", "mem_020"}} {
+				for _, limit := range []int{5, 10, 50} {
+					got, _ := paginateRecallWithCarry(in, offset, prev, limit)
+					want := legacy(in, offset, prev, limit)
+					if len(got) != len(want) {
+						t.Fatalf("offset=%d prev=%v limit=%d: len got=%d want=%d", offset, prev, limit, len(got), len(want))
+					}
+					for i := range got {
+						if got[i].ID != want[i].ID {
+							t.Fatalf("offset=%d prev=%v limit=%d: 第%d位 got=%s want=%s", offset, prev, limit, i, got[i].ID, want[i].ID)
+						}
+					}
+				}
+			}
+		}
+	})
+
+	// ④ 主路段切空 ⇒ 整页空（不返回孤儿 carry，与旧语义一致）。
+	t.Run("offset越界_整页空不带孤儿carry", func(t *testing.T) {
+		in := append(mkMain(5), models.RecallResult{ID: "peer:muc", Category: "peer"})
+		if got, _ := paginateRecallWithCarry(in, 5, nil, 5); len(got) != 0 {
+			t.Fatalf("len=%d want 0", len(got))
+		}
+	})
+
+	// ⑤ 续页（offset>0 + prevIDs 去重）主路段从 offset 起且去掉 prevIDs。
+	// ⚠ 2026-11-02 (t_2891d689) 判据反转：原断言「续页 carry 回尾」锁死的正是
+	//    本卡要改的行为（carry 每页重复出现，去重成本转嫁客户端）。现语义：
+	//    carry 只在第一页出现，续页只回主路段。
+	t.Run("续页不回carry_主路段offset加去重", func(t *testing.T) {
+		in := append(mkMain(20), models.RecallResult{ID: "peer:muc", Category: "peer"})
+		got, mainLen := paginateRecallWithCarry(in, 3, []string{"mem_005"}, 5)
+		if len(got) != 5 {
+			t.Fatalf("len=%d want 5（续页不含 carry）", len(got))
+		}
+		if mainLen != 5 {
+			t.Fatalf("mainLen=%d want 5", mainLen)
+		}
+		wantMain := []string{"mem_003", "mem_004", "mem_006", "mem_007", "mem_008"}
+		for i, id := range wantMain {
+			if got[i].ID != id {
+				t.Fatalf("主路段第 %d 位 got=%s want=%s", i, got[i].ID, id)
+			}
+		}
+		for _, r := range got {
+			if r.Category == "peer" || r.Category == "pattern" {
+				t.Fatalf("续页混入 carry: %s/%s", r.ID, r.Category)
+			}
+		}
+	})
+
+	// ⑥ 端到端：capRecallResults → paginateRecallWithCarry 全链路
+	//    （生产形态：主 60 + 扩展 100 + pattern 3 + peer 1，limit=50）。
+	t.Run("端到端cap后翻页_peer不再被切", func(t *testing.T) {
+		var all []models.RecallResult
+		all = append(all, mkMain(60)...)
+		for i := 0; i < 100; i++ {
+			all = append(all, models.RecallResult{ID: fmt.Sprintf("gx_%03d", i), Category: "graph_expanded", Content: "[graph] x"})
+		}
+		all = append(all,
+			models.RecallResult{ID: "pattern:a", Category: "pattern"},
+			models.RecallResult{ID: "peer:muc", Category: "peer"})
+		prim, _ := capRecallResults(all, 50)
+		if prim[len(prim)-1].Category != "peer" {
+			t.Fatalf("cap 后末位=%s，capRecallResults 语义变了", prim[len(prim)-1].ID)
+		}
+		got, _ := paginateRecallWithCarry(prim, 0, nil, 50)
+		// 修前此处恒被切（results[:50] 丢掉末尾 carry）
+		if got[len(got)-1].ID != "peer:muc" {
+			t.Fatalf("翻页后末位=%s want peer:muc（P0-3 截断回归未修）", got[len(got)-1].ID)
+		}
+		nMain := 0
+		for _, r := range got {
+			if r.Category != "pattern" && r.Category != "peer" {
+				nMain++
+			}
+		}
+		if nMain > 50 {
+			t.Fatalf("主路段 %d 条 > limit 50（t_9025b0eb AC 破坏）", nMain)
+		}
+	})
+}
+
+// ── t_2891d689 回归：carry 撑大 len(results) ⇒ nextCont 恒空、翻页链断 ──────
+// 病灶：4ffc546 后 paginateRecallWithCarry 回 main+carry，len(results) 可 > limit，
+//       handler 判据 `len(results) == req.Limit` 只要 carry 命中就恒假
+//       ⇒ nextCont 恒空，带 pattern/peer 注入的 query 第二页永远取不到。
+// 修后：判据收口 shouldEmitContinuation，看主路段 mainLen；carry 只在第一页回尾。
+// 判据链与 handler（core.go 翻页块）逐行同构：paginate → shouldEmitContinuation
+// → returned=prevIDs+页内ID → encodeContinuation（卡面允许的「抽出判定函数单测」路线）。
+func TestContinuationIssuedWithCarry(t *testing.T) {
+	mkMain := func(n int) []models.RecallResult {
+		out := make([]models.RecallResult, n)
+		for i := 0; i < n; i++ {
+			out[i] = models.RecallResult{ID: fmt.Sprintf("mem_%03d", i), Category: "distilled", Content: "m"}
+		}
+		return out
+	}
+	idsOf := func(rs []models.RecallResult) []string {
+		out := make([]string, len(rs))
+		for i, r := range rs {
+			out[i] = r.ID
+		}
+		return out
+	}
+	// 生产形态（t_58f9d476 实证）：cap 后 prim = 主路段填满 limit + 末尾 carry。
+	limit := 5
+	prim := append(mkMain(5), models.RecallResult{ID: "peer:muc", Category: "peer"})
+	totalFetched := len(prim) // 6 ≥ fetchLimit(=limit+offset+len(prev)=5)
+	page, mainLen := paginateRecallWithCarry(prim, 0, nil, limit)
+	if len(page) != 6 || mainLen != 5 {
+		t.Fatalf("page=%d mainLen=%d want 6/5", len(page), mainLen)
+	}
+	// 病灶判据复现：len(page)==limit ⇒ 6==5 恒假 ⇒ 链断。本例页形必须仍是 len>limit，
+	// 否则该用例失去对旧病灶的覆盖。
+	if len(page) == limit {
+		t.Fatal("页形不再是 len>limit，本用例失去对旧病灶的覆盖")
+	}
+	// 新判据：主路段满页 ⇒ 必须发令牌
+	if !shouldEmitContinuation(totalFetched, limit, mainLen, limit, 0) {
+		t.Fatal("totalFetched>=fetchLimit 且主路段满页 ⇒ 应发 nextCont（翻页链断裂回归未修）")
+	}
+	// handler 完整动作 ⇒ nextCont != ""，且令牌推进 offset=5
+	returned := idsOf(page) // 含 carry ID（t_58f9d476 既有行为：去重锚点）
+	nextCont := encodeContinuation("q", "ns", 0+limit, limit, returned)
+	if nextCont == "" {
+		t.Fatal("nextCont == \"\"，翻页链断")
+	}
+	tok, err := decodeContinuation(nextCont)
+	if err != nil || tok.Off != 5 || tok.Lim != 5 {
+		t.Fatalf("令牌非法: off=%d lim=%d err=%v（want 5/5/nil）", tok.Off, tok.Lim, err)
+	}
+}
+
+// AC2：offset>0 的续页 ⇒ 不含前页已返回的 carry，主路段继续推进；尾页不满 ⇒ 链自然终止。
+func TestCarryOnlyOnFirstPageAcrossPages(t *testing.T) {
+	mkMain := func(n int) []models.RecallResult {
+		out := make([]models.RecallResult, n)
+		for i := 0; i < n; i++ {
+			out[i] = models.RecallResult{ID: fmt.Sprintf("mem_%03d", i), Category: "distilled", Content: "m"}
+		}
+		return out
+	}
+	limit := 5
+	// 18 主（4 页：5+5+5+3）+ 2 carry
+	prim := append(mkMain(18),
+		models.RecallResult{ID: "pattern:a", Category: "pattern"},
+		models.RecallResult{ID: "peer:muc", Category: "peer"})
+
+	// 第 1 页：主 5 + carry 2 回尾；令牌 returned 含 carry ID
+	page1, ml1 := paginateRecallWithCarry(prim, 0, nil, limit)
+	if len(page1) != 7 || ml1 != 5 {
+		t.Fatalf("page1=%d mainLen=%d want 7/5", len(page1), ml1)
+	}
+	if page1[6].Category != "peer" || page1[5].Category != "pattern" {
+		t.Fatalf("第一页 carry 未回尾: %v", page1[5:])
+	}
+	if !shouldEmitContinuation(len(prim), limit, ml1, limit, 0) {
+		t.Fatal("第 1 页应发令牌")
+	}
+	prev := make([]string, 0, len(page1))
+	for _, r := range page1 {
+		prev = append(prev, r.ID)
+	}
+
+	// 第 2 页：offset=5（模拟 handler 从令牌取 offset/prev）
+	page2, ml2 := paginateRecallWithCarry(prim, 5, prev, limit)
+	for _, r := range page2 {
+		if r.Category == "pattern" || r.Category == "peer" {
+			t.Fatalf("续页混入前页 carry: %s/%s", r.ID, r.Category)
+		}
+	}
+	want2 := []string{"mem_005", "mem_006", "mem_007", "mem_008", "mem_009"}
+	if len(page2) != 5 || ml2 != 5 {
+		t.Fatalf("page2=%d mainLen=%d want 5/5", len(page2), ml2)
+	}
+	for i, id := range want2 {
+		if page2[i].ID != id {
+			t.Fatalf("主路段未推进: 第%d位 got=%s want=%s", i, page2[i].ID, id)
+		}
+	}
+	// 链未断：第 2 页满页且取数满足 ⇒ 继续发令牌（生产页 2 的 fetchLimit=5+5+len(prev)）
+	if !shouldEmitContinuation(limit+5+len(prev), limit+5+len(prev), ml2, limit, 5) {
+		t.Fatal("满页续页应继续发令牌（链不得在第 2 页断）")
+	}
+	for _, r := range page2 {
+		prev = append(prev, r.ID)
+	}
+	// 第 3 页照推
+	page3, ml3 := paginateRecallWithCarry(prim, 10, prev, limit)
+	if ml3 != 5 || page3[0].ID != "mem_010" {
+		t.Fatalf("page3 mainLen=%d first=%s want 5/mem_010", ml3, page3[0].ID)
+	}
+	// 第 4 页（尾页只剩 3 主）⇒ mainLen=3 < limit ⇒ 不再发令牌（不得错发空尾页令牌）
+	page4, ml4 := paginateRecallWithCarry(prim, 15, prev, limit)
+	if ml4 != 3 || len(page4) != 3 {
+		t.Fatalf("page4 mainLen=%d len=%d want 3/3", ml4, len(page4))
+	}
+	if shouldEmitContinuation(len(prim), limit+15+len(prev), ml4, limit, 15) {
+		t.Fatal("尾页主路段不满 limit ⇒ 不应发令牌")
+	}
+}
+
+// AC3：offset 越界 ⇒ 空页且 nextCont == ""；并钉死「判据看 mainLen 而非 len(results)」：
+// 主路段 4 + carry 1（len(page)==limit 但 mainLen<limit）也不得发令牌 ——
+// 这正是卡面警告的「不要用 len(results)>=limit，offset 越界/尾页会错发 token」的镜像。
+func TestNoContinuationOnEmptyOrShortMainPage(t *testing.T) {
+	mkMain := func(n int) []models.RecallResult {
+		out := make([]models.RecallResult, n)
+		for i := 0; i < n; i++ {
+			out[i] = models.RecallResult{ID: fmt.Sprintf("mem_%03d", i), Category: "distilled", Content: "m"}
+		}
+		return out
+	}
+	limit := 5
+
+	// A. offset 越界（=主路段长度）⇒ 空页 + 不发令牌
+	prim := append(mkMain(5), models.RecallResult{ID: "peer:muc", Category: "peer"})
+	page, ml := paginateRecallWithCarry(prim, 5, []string{"mem_000"}, limit)
+	if len(page) != 0 || ml != 0 {
+		t.Fatalf("越界页 len=%d mainLen=%d want 0/0", len(page), ml)
+	}
+	if shouldEmitContinuation(len(prim), limit+5+1, ml, limit, 5) {
+		t.Fatal("越界空页不得发令牌")
+	}
+
+	// B. 主路段不满页但 len(page)==limit（4 主 + 1 carry 撑到 5）⇒ 不得发令牌
+	prim2 := append(mkMain(4), models.RecallResult{ID: "pattern:a", Category: "pattern"})
+	page2, ml2 := paginateRecallWithCarry(prim2, 0, nil, limit)
+	if len(page2) != 5 || ml2 != 4 {
+		t.Fatalf("短页 len=%d mainLen=%d want 5/4", len(page2), ml2)
+	}
+	if shouldEmitContinuation(len(prim2), limit, ml2, limit, 0) {
+		t.Fatal("主路段未满页 ⇒ 不得发令牌（判据必须看 mainLen，不是 len(results)）")
+	}
+}

go/internal/api/routes/eval.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -55,22 +56,29 @@ type GoldenSet struct {
 func LoadGoldenSet(path string) (*GoldenSet, error) {
 	var data []byte
 	usedSource := "env:ZHIYI_GOLDEN_SET"
-	if p := os.Getenv("ZHIYI_GOLDEN_SET"); p != "" {
+	// 2026-10-26 修正优先级：显式 path > env > 内嵌。
+	// 旧顺序（env 先）导致 ZHIYI_GOLDEN_SET 一旦设置，任何请求传 golden_path 都被静默忽略
+	// ⇒ 实测「传 7 个 chunk 却每块都报 53 条」（env 指向的 53 条集）—— 评测对象与预期不符，
+	// 且指标全是 0 时极难发现。env 现在只作「默认金标」，显式 path 必须能覆盖它。
+	if path != "" {
+		usedSource = "path:" + path
+		d, err := os.ReadFile(path)
+		if err == nil {
+			data = d
+		} else if filepath.IsAbs(path) {
+			// 绝对路径 = 明确指名要跑这套题 ⇒ 读不到必须报错，不许静默换题
+			return nil, fmt.Errorf("读 golden_path 失败（%s）: %w", path, err)
+		} else {
+			// 相对路径在部署 CWD 下读不到 ⇒ 内嵌兜底（t_dfc93ad0 AC5 既有行为，保留）
+			data = embeddedGoldenSetJSON
+			usedSource = "embedded"
+		}
+	} else 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"
@@ -384,13 +392,20 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		Namespace  string `json:"namespace"`
 		GoldenPath string `json:"golden_path"` // 可选，默认 testdata/golden-set.json
+		// AllNamespaces（2026-10-26）跨 namespace 评测开关。
+		// 背景：旧逻辑 ns 为空 ⇒ 强制 "shared"，而真实金标分散在 hermes-main/wiki/HUB 等多个 ns
+		// ⇒ 评测跑的是"只看 shared"的召回，与线上跨 ns 召回不是同一个系统（实测前 15 条里 15 条结果不同）。
+		// 语义：true ⇒ ns = ""（全库跨 ns，等同线上默认）；false ⇒ 保持旧行为（默认 shared，向后兼容）。
+		AllNamespaces bool `json:"all_namespaces"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")
 		return
 	}
 	ns := req.Namespace
-	if ns == "" {
+	if req.AllNamespaces {
+		ns = ""
+	} else if ns == "" {
 		ns = "shared"
 	}
 	gs, err := LoadGoldenSet(req.GoldenPath)
@@ -411,9 +426,13 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
 			respondError(w, 400, err.Error())
 			return
 		}
-		// 无关键词判据 → 禁止（会退化成恒真）
-		if len(item.MustIncludeKeywords) == 0 {
-			failures = append(failures, item.Query+": 无关键词判据（禁止退化成恒真）")
+		// 无关键词判据 → 禁止（会退化成恒真）——仅当也没有 expected_ids 时才拒。
+		// 2026-10-26：v4 金标（t_4d42f9c0）是「分级 relevant ids」型，没有关键词；
+		// 对这类条目 keyword 指标记 N/A（不计入 keyword_total），只算 recall/precision/mrr/ndcg，
+		// 别偷偷把它当 keyword 恒真，也别整条丢掉（否则 304 条全被跳过 ⇒ "all golden queries failed"）。
+		idOnlyItem := len(item.MustIncludeKeywords) == 0
+		if idOnlyItem && len(item.ExpectedIDs) == 0 {
+			failures = append(failures, item.Query+": 既无关键词也无 expected_ids（无法评测）")
 			continue
 		}
 
@@ -493,13 +512,15 @@ func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
 			totalNDCG += dcg / idcg
 		}
 
-		// 关键词统计
-		keywordTotal++
-		if keywordOK {
-			keywordPass++
-		} else {
-			keywordFail++
-			failures = append(failures, item.Query+": 关键词未命中 "+strings.Join(item.MustIncludeKeywords, ","))
+		// 关键词统计（id-only 条目不参与：keyword 记 N/A，避免恒真/恒假）
+		if !idOnlyItem {
+			keywordTotal++
+			if keywordOK {
+				keywordPass++
+			} else {
+				keywordFail++
+				failures = append(failures, item.Query+": 关键词未命中 "+strings.Join(item.MustIncludeKeywords, ","))
+			}
 		}
 
 		queryDetails = append(queryDetails, EvalQueryDetail{

go/internal/api/routes/feedback.go

@@ -23,6 +23,11 @@ func NewFeedbackAPI(ldb storage.LanceDB) *FeedbackAPI {
 func (fa *FeedbackAPI) MarkUseful(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		MemoryID string `json:"memory_id"`
+		// 2026-10-24 (t_11245d30)：区分人机信号。
+		// 空 = 人工点「有用」（保持 user_feedback，行为不变）；
+		// "auto" = 插件自动反馈（_auto_feedback_for_reply）→ 记 auto_feedback，让 V 账可辨「牧尘认可 vs 机器自评」。
+		// 纯观测，不改 V 权重/阈值/上限。
+		Source string `json:"source"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")
@@ -34,11 +39,15 @@ func (fa *FeedbackAPI) MarkUseful(w http.ResponseWriter, r *http.Request) {
 	}
 
 	selfoptimize.Dash.RecordFeedback(true)
-	// V 值：useful = success
+	// V 值：useful = success。action 名按来源区分（人工 user_feedback / 自动 auto_feedback）。
+	action := "user_feedback"
+	if req.Source == "auto" {
+		action = "auto_feedback"
+	}
 	selfoptimize.VProp.RecordDecision(
 		"useful_"+req.MemoryID,
 		[]string{req.MemoryID},
-		"user_feedback", "success", "",
+		action, "success", "",
 	)
 	if err := fa.LanceDB.IncrementUseful(req.MemoryID); err != nil {
 		log.Printf("[feedback] IncrementUseful failed %s: %v", req.MemoryID, err)

go/internal/api/routes/ghost_ns_regression_test.go

@@ -0,0 +1,152 @@
+package routes
+
+// t_15d82af7 ghost-ns 修复的路由层终审用例（裁定 C）：
+// 显式 namespace 在全量表里没有行（ghost）时，/api/v1/recall 必须返回 0 条 ——
+// 主路径（recall.go 的 ScanAll 判据）与两条补充通道（E4.2 shared /
+// wiki-curator-main）都不得把 ghost 查询洗成 shared/wiki 结果。
+// 真实 ns 的 wiki 补充语义必须保持。
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/governance"
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// nsAwareRecallLance：模拟生产实态的数据源。
+//   - ScanAll 返回全量存活行（ghost 判据 = 该 ns 是否在行集里）；
+//   - Search 复刻生产：sidecar only_if 失效后由客户端同款解包过滤
+//     `if namespaceFilter != "" && r.Namespace != namespaceFilter continue`
+//     （lancedb_ipc.go:311），其余方法复用同包 fakeLanceDB。
+type nsAwareRecallLance struct {
+	fakeLanceDB
+	rows []models.MemoryRecord
+}
+
+func (f *nsAwareRecallLance) ScanAll() ([]models.MemoryRecord, error) {
+	return f.rows, nil
+}
+
+// GetRecordByID t_0f1d7be9（原文层）：fake 默认不存在。
+func (f *nsAwareRecallLance) GetRecordByID(table, id string) (*models.MemoryRecord, error) {
+	return nil, nil
+}
+
+func (f *nsAwareRecallLance) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) {
+	var out []models.MemoryRecord
+	for _, r := range f.rows {
+		// 客户端同款解包过滤（与 lancedb_ipc.go:311 同口径）。
+		if namespaceFilter != "" && r.Namespace != namespaceFilter {
+			continue
+		}
+		out = append(out, r)
+	}
+	if topK > 0 && len(out) > topK {
+		out = out[:topK]
+	}
+	return out, nil
+}
+
+// fakeEmbedServer 提供确定性的 OpenAI 兼容 embeddings 响应（免依赖生产 embedder）。
+func fakeEmbedServer(t *testing.T) *httptest.Server {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req struct {
+			Input []string `json:"input"`
+		}
+		_ = json.NewDecoder(r.Body).Decode(&req)
+		type item struct {
+			Embedding []float64 `json:"embedding"`
+		}
+		resp := struct {
+			Data []item `json:"data"`
+		}{}
+		for range req.Input {
+			v := make([]float64, 1024)
+			v[0] = 1
+			resp.Data = append(resp.Data, item{Embedding: v})
+		}
+		_ = json.NewEncoder(w).Encode(resp)
+	}))
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+func runRecallHTTP(t *testing.T, db storage.LanceDB, body string) (int, map[string]interface{}) {
+	t.Helper()
+	saved := storage.SearchCacheInstance
+	storage.SearchCacheInstance = nil
+	t.Cleanup(func() { storage.SearchCacheInstance = saved })
+
+	srv := fakeEmbedServer(t)
+	emb := storage.NewEmbedder(srv.URL)
+	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
+}
+
+func resultIDSet(m map[string]interface{}) map[string]string {
+	out := map[string]string{}
+	raw, _ := m["results"].([]interface{})
+	for _, x := range raw {
+		r, _ := x.(map[string]interface{})
+		id, _ := r["id"].(string)
+		ns, _ := r["namespace"].(string)
+		out[id] = ns
+	}
+	return out
+}
+
+// TestGhostNS_HandlerReturnsZero：ghost ns 走完整 handler 路径 ⇒ HTTP 200 + 0 条。
+// 语料只在 shared / wiki-curator-main 有货 ⇒ 任何一条返回都只可能来自
+// 主召回无条件并 shared（根因2）或 wiki 补充通道（裁定 C）。
+func TestGhostNS_HandlerReturnsZero(t *testing.T) {
+	db := &nsAwareRecallLance{rows: []models.MemoryRecord{
+		{ID: "sh_1", Namespace: "shared", Category: "distilled", Content: "共享事实一"},
+		{ID: "sh_2", Namespace: "shared", Category: "distilled", Content: "共享事实二"},
+		{ID: "wiki_1", Namespace: "wiki-curator-main", Category: "distilled", Content: "笔记知识一"},
+		{ID: "wiki_2", Namespace: "wiki-curator-main", Category: "distilled", Content: "笔记知识二"},
+	}}
+	code, m := runRecallHTTP(t, db, `{"query":"ghost ns 终审探针","limit":5,"namespace":"ghost-ns-2026-11"}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	ids := resultIDSet(m)
+	if len(ids) != 0 {
+		t.Fatalf("✗ ghost ns 应 0 条，实际 %d：%v", len(ids), ids)
+	}
+	if cnt, _ := m["count"].(float64); cnt != 0 {
+		t.Fatalf("✗ count=%v want 0", m["count"])
+	}
+	t.Logf("ghost ns 完整 handler 路径：HTTP 200 count=0 ✓")
+}
+
+// TestRealNS_HandlerStillSupplementsWiki：对照 —— 真实 ns 的 wiki 补充语义不变。
+func TestRealNS_HandlerStillSupplementsWiki(t *testing.T) {
+	db := &nsAwareRecallLance{rows: []models.MemoryRecord{
+		{ID: "own_1", Namespace: "hermes-main", Category: "distilled", Content: "本域事实一"},
+		{ID: "wiki_1", Namespace: "wiki-curator-main", Category: "distilled", Content: "笔记知识一"},
+	}}
+	code, m := runRecallHTTP(t, db, `{"query":"真实 ns 对照探针","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	ids := resultIDSet(m)
+	if _, ok := ids["own_1"]; !ok {
+		t.Fatalf("✗ 真实 ns 主结果缺失：%v", ids)
+	}
+	if _, ok := ids["wiki_1"]; !ok {
+		t.Fatalf("✗ 真实 ns 的 wiki 补充被误伤：%v", ids)
+	}
+	t.Logf("真实 ns：主结果 + wiki 补充均在 ✓ %v", ids)
+}

go/internal/api/routes/health.go

@@ -17,6 +17,9 @@ var sidecarHealthCheck = consolidate.HealthCheck
 // 深健康检查：不仅报告自身存活，还探测 IPC sidecar 是否可达。
 // 背景（2026-10-08 故障）：sidecar 异常时 /health 仍返回 200 —— "假绿"，
 // 使部署失败被静默数小时，只能靠 pgrep 才发现。深检查把依赖故障暴露为 503。
+//
+// t_10757bd5 AC4：整合链路健康（连续失败 ≥3 或 2h 无成功）⇒ status=degraded，
+// 消除「侧车 TCP 可达但整合链路静默失败 55 次/日」的假绿根因。
 func HandleHealth(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
@@ -25,22 +28,42 @@ func HandleHealth(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
-	body := map[string]string{
-		"status":  "ok",
-		"service": "zhiyid",
-		"version": "0.1.0",
-	}
-
+	// 先探测 sidecar（失败 ⇒ 503 degraded，与 10-08 修复保持一致）
 	if err := sidecarHealthCheck(); err != nil {
-		body["status"] = "degraded"
-		body["sidecar"] = "unreachable"
-		body["error"] = err.Error()
+		body := map[string]string{
+			"status":  "degraded",
+			"service": "zhiyid",
+			"sidecar": "unreachable",
+			"error":   err.Error(),
+		}
 		w.WriteHeader(http.StatusServiceUnavailable)
 		json.NewEncoder(w).Encode(body)
 		return
 	}
-	body["sidecar"] = "ok"
 
-	w.WriteHeader(http.StatusOK)
+	// t_10757bd5：查整合 tracker（内存态，无锁开销 <1ms）
+	tracker := GetConsolTracker()
+	consolStatus, consolFails, sinceSuccess, lastErr := tracker.HealthStatus()
+	_, consolSkips, lastSkip, _ := tracker.Snapshot()
+
+	body := map[string]interface{}{
+		"status":  consolStatus,
+		"service": "zhiyid",
+		"sidecar": "ok",
+		"consolidate": map[string]interface{}{
+			"status":           consolStatus,
+			"consec_failures":  consolFails,
+			"skipped":          consolSkips,
+			"last_skip":        lastSkip,
+			"last_success_age": sinceSuccess.String(),
+			"last_error":       lastErr,
+		},
+	}
+
+	if consolStatus != "ok" {
+		w.WriteHeader(http.StatusServiceUnavailable)
+	} else {
+		w.WriteHeader(http.StatusOK)
+	}
 	json.NewEncoder(w).Encode(body)
 }

go/internal/api/routes/memory_raw.go

@@ -0,0 +1,92 @@
+// 织忆 MemoryWeave — 原文层下钻端点（t_0f1d7be9）
+//
+// GET /api/v1/memory/{id}/raw — 按记忆 id 取回蒸馏来源的原始 episode 文本。
+// 三态语义（AC1 要求可区分，禁 404 混淆）：
+//   - 记忆存在且有 derived_from 且 episode 可取回 ⇒ 200 {id, raw_text, source, created_at, episode_id}
+//   - 记忆存在但无 derived_from（或指针指向不存在的 episode）⇒ 200 {id, raw_text: null, reason: ...}
+//     reason ∈ {"no_provenance","episode_missing"} —— 不是 404
+//   - 记忆不存在 ⇒ 404 {"error":{"code":"memory_not_found",...}}
+//   - 存储后端故障 ⇒ 503（不静默吞错，t_4c810e02 静默 no-op 教训）
+//
+// 只读端点：不写库、不碰缓存（本卡明令不加缓存）。
+package routes
+
+import (
+	"net/http"
+	"strings"
+)
+
+// maxRawTextRunes raw_text 返回上限（rune 计，中文安全）。episode 普遍 <2000；
+// 超长截断并置 raw_text_truncated=true（不静默截半句话当真话）。
+const maxRawTextRunes = 4000
+
+// MemoryRaw GET /api/v1/memory/{id}/raw
+func (a *API) MemoryRaw(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		respondError(w, 405, "method not allowed")
+		return
+	}
+	if a.LanceDB == nil {
+		respondErrorSchema(w, 503, "storage_unavailable", "storage backend unavailable", 0)
+		return
+	}
+	id := r.PathValue("id")
+	if id == "" {
+		// 兜底：非模式路由（注册方手动解析路径）时从 URL 取
+		id = strings.TrimSuffix(strings.TrimPrefix(r.URL.Path, "/api/v1/memory/"), "/raw")
+	}
+	if id == "" {
+		respondError(w, 400, "id required")
+		return
+	}
+
+	mem, err := a.LanceDB.GetRecordByID("memories", id)
+	if err != nil {
+		respondErrorSchema(w, 503, "storage_error", "get memory failed: "+err.Error(), 0)
+		return
+	}
+	if mem == nil {
+		respondErrorSchema(w, 404, "memory_not_found", "memory id not found: "+id, 0)
+		return
+	}
+
+	base := map[string]interface{}{
+		"id":             mem.ID,
+		"derived_from":   mem.DerivedFrom,
+		"memory_created": mem.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
+	}
+	if mem.DerivedFrom == "" {
+		base["raw_text"] = nil
+		base["reason"] = "no_provenance"
+		respond(w, 200, base)
+		return
+	}
+
+	ep, err := a.LanceDB.GetRecordByID("episodes", mem.DerivedFrom)
+	if err != nil {
+		respondErrorSchema(w, 503, "storage_error", "get episode failed: "+err.Error(), 0)
+		return
+	}
+	if ep == nil {
+		base["raw_text"] = nil
+		base["reason"] = "episode_missing"
+		respond(w, 200, base)
+		return
+	}
+
+	raw := ep.Content
+	truncated := false
+	if rs := []rune(raw); len(rs) > maxRawTextRunes {
+		raw = string(rs[:maxRawTextRunes])
+		truncated = true
+	}
+	base["raw_text"] = raw
+	base["episode_id"] = ep.ID
+	base["source"] = ep.Source
+	base["created_at"] = ep.CreatedAt.Format("2006-01-02T15:04:05Z07:00")
+	if truncated {
+		base["raw_text_truncated"] = true
+		base["raw_text_full_len_runes"] = len([]rune(ep.Content))
+	}
+	respond(w, 200, base)
+}

go/internal/api/routes/memory_raw_test.go

@@ -0,0 +1,234 @@
+// t_0f1d7be9（原文层）回归：GET /api/v1/memory/{id}/raw 三态 + recall 响应字段集合向后兼容。
+package routes
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/governance"
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// rawTestLance 包级 fake（与 fakeLanceDB 区分命名，避免动既有测试类型）。
+type rawTestLance struct {
+	mems  map[string]*models.MemoryRecord
+	conns map[string]*models.MemoryRecord // table=episodes 用 map 键 "episodes/<id>"
+	err   error
+}
+
+func (f *rawTestLance) GetRecordByID(table, id string) (*models.MemoryRecord, error) {
+	if f.err != nil {
+		return nil, f.err
+	}
+	if table == "episodes" {
+		if r, ok := f.conns[id]; ok {
+			return r, nil
+		}
+		return nil, nil
+	}
+	if r, ok := f.mems[id]; ok {
+		return r, nil
+	}
+	return nil, nil
+}
+func (f *rawTestLance) InsertEpisode(agentID, namespace, content, category string) (string, error) {
+	return "", nil
+}
+func (f *rawTestLance) GetTopByQuality(agentID string, limit int) ([]models.MemoryRecord, error) {
+	return nil, nil
+}
+func (f *rawTestLance) Stats() (map[string]interface{}, error) { return nil, nil }
+func (f *rawTestLance) SoftDelete(id, reason string) error     { return nil }
+func (f *rawTestLance) SoftDeleteBatch(table string, ids []string, updatedAt string) (int64, error) {
+	return 0, nil
+}
+func (f *rawTestLance) GetVersionHistory(id string) ([]map[string]interface{}, error) {
+	return nil, nil
+}
+func (f *rawTestLance) GetCandidatesForForgetting() ([]map[string]interface{}, error) {
+	return nil, nil
+}
+func (f *rawTestLance) GetSkillCandidates(minRecalls, limit int) ([]models.MemoryRecord, error) {
+	return nil, nil
+}
+func (f *rawTestLance) Backup(path string) error                                { return nil }
+func (f *rawTestLance) GetAuditLog(limit int) ([]map[string]interface{}, error) { return nil, nil }
+func (f *rawTestLance) IncrementUseful(id string) error                         { return nil }
+func (f *rawTestLance) IncrementHumanNotUseful(id string) error                 { return nil }
+func (f *rawTestLance) IncrementDedupDownweight(id string) error                { return nil }
+func (f *rawTestLance) IncrementNotUseful(id string) error                      { return nil }
+func (f *rawTestLance) AppendHitEvent(memoryID, outcome, reason string) error   { return nil }
+func (f *rawTestLance) CountHitEvents(memoryID, outcome string, since time.Time) (int, error) {
+	return 0, nil
+}
+func (f *rawTestLance) GetHitEvents(memoryID string, limit int) ([]models.HitEvent, error) {
+	return nil, nil
+}
+func (f *rawTestLance) UpdateMemoryContent(id, newContent, source string) error { return nil }
+func (f *rawTestLance) InsertMemory(m models.MemoryRecord) error                { return nil }
+func (f *rawTestLance) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) {
+	return nil, nil
+}
+func (f *rawTestLance) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) {
+	return nil, nil
+}
+func (f *rawTestLance) Insert(table string, record any) error                { return nil }
+func (f *rawTestLance) Update(table, id string, fields map[string]any) error { return nil }
+func (f *rawTestLance) PurgeInvalid() (int64, error)                         { return 0, nil }
+
+var _ storage.LanceDB = (*rawTestLance)(nil)
+
+func newRawTestAPI(db *rawTestLance) *API {
+	return NewAPI(db, nil, nil, governance.NewConflictDetector(), governance.NewInMemoryGraph())
+}
+
+func TestMemoryRaw_WithProvenance_ReturnsRawText(t *testing.T) {
+	db := &rawTestLance{
+		mems: map[string]*models.MemoryRecord{
+			"mem_a": {ID: "mem_a", Content: "蒸馏结论", DerivedFrom: "ep_1",
+				CreatedAt: time.Date(2026, 11, 1, 0, 0, 0, 0, time.UTC)},
+		},
+		conns: map[string]*models.MemoryRecord{
+			"ep_1": {ID: "ep_1", Content: "原始对话全文：项目端口是 8081，代理配置见 nginx.conf 第 42 行。",
+				Source: "episode", CreatedAt: time.Date(2026, 10, 30, 0, 0, 0, 0, time.UTC)},
+		},
+	}
+	api := newRawTestAPI(db)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/memory/mem_a/raw", nil)
+	req.SetPathValue("id", "mem_a")
+	rec := httptest.NewRecorder()
+	api.MemoryRaw(rec, req)
+
+	if rec.Code != 200 {
+		t.Fatalf("want 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	var body map[string]interface{}
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("bad json: %v", err)
+	}
+	if body["raw_text"] == nil || body["raw_text"] == "" {
+		t.Fatalf("raw_text missing: %v", body)
+	}
+	if body["episode_id"] != "ep_1" || body["source"] != "episode" {
+		t.Fatalf("episode_id/source wrong: %v", body)
+	}
+	if _, has := body["reason"]; has {
+		t.Fatalf("reason should be absent on success: %v", body)
+	}
+	if body["derived_from"] != "ep_1" {
+		t.Fatalf("derived_from echo missing: %v", body)
+	}
+}
+
+func TestMemoryRaw_NoProvenance_200Not404(t *testing.T) {
+	db := &rawTestLance{
+		mems: map[string]*models.MemoryRecord{
+			"mem_b": {ID: "mem_b", Content: "无源记忆"},
+		},
+		conns: map[string]*models.MemoryRecord{},
+	}
+	api := newRawTestAPI(db)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/memory/mem_b/raw", nil)
+	req.SetPathValue("id", "mem_b")
+	rec := httptest.NewRecorder()
+	api.MemoryRaw(rec, req)
+
+	if rec.Code != 200 {
+		t.Fatalf("no_provenance must be 200, got %d", rec.Code)
+	}
+	var body map[string]interface{}
+	_ = json.Unmarshal(rec.Body.Bytes(), &body)
+	if body["reason"] != "no_provenance" {
+		t.Fatalf("want reason=no_provenance, got %v", body)
+	}
+	if v, ok := body["raw_text"]; !ok || v != nil {
+		t.Fatalf("raw_text must be explicit null, got %v (ok=%v)", body["raw_text"], ok)
+	}
+}
+
+func TestMemoryRaw_EpisodeMissing_Distinguishable(t *testing.T) {
+	db := &rawTestLance{
+		mems: map[string]*models.MemoryRecord{
+			"mem_c": {ID: "mem_c", Content: "结论", DerivedFrom: "ep_gone"},
+		},
+		conns: map[string]*models.MemoryRecord{},
+	}
+	api := newRawTestAPI(db)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/memory/mem_c/raw", nil)
+	req.SetPathValue("id", "mem_c")
+	rec := httptest.NewRecorder()
+	api.MemoryRaw(rec, req)
+
+	if rec.Code != 200 {
+		t.Fatalf("episode_missing must be 200, got %d", rec.Code)
+	}
+	var body map[string]interface{}
+	_ = json.Unmarshal(rec.Body.Bytes(), &body)
+	if body["reason"] != "episode_missing" {
+		t.Fatalf("want episode_missing, got %v", body)
+	}
+}
+
+func TestMemoryRaw_UnknownID_404(t *testing.T) {
+	db := &rawTestLance{mems: map[string]*models.MemoryRecord{}, conns: map[string]*models.MemoryRecord{}}
+	api := newRawTestAPI(db)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/memory/mem_ghost/raw", nil)
+	req.SetPathValue("id", "mem_ghost")
+	rec := httptest.NewRecorder()
+	api.MemoryRaw(rec, req)
+
+	if rec.Code != 404 {
+		t.Fatalf("unknown id must be 404, got %d", rec.Code)
+	}
+	var body map[string]map[string]interface{}
+	_ = json.Unmarshal(rec.Body.Bytes(), &body)
+	if body["error"]["code"] != "memory_not_found" {
+		t.Fatalf("want error.code=memory_not_found, got %v", body)
+	}
+}
+
+func TestMemoryRaw_StorageError_503NoSilentEmpty(t *testing.T) {
+	db := &rawTestLance{err: http.ErrServerClosed} // 任意 error
+	api := newRawTestAPI(db)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/memory/mem_x/raw", nil)
+	req.SetPathValue("id", "mem_x")
+	rec := httptest.NewRecorder()
+	api.MemoryRaw(rec, req)
+
+	if rec.Code != 503 {
+		t.Fatalf("storage error must be 503 (never silent 200-empty), got %d", rec.Code)
+	}
+}
+
+func TestMemoryRaw_LongEpisodeTruncated(t *testing.T) {
+	long := make([]rune, maxRawTextRunes+100)
+	for i := range long {
+		long[i] = '字'
+	}
+	db := &rawTestLance{
+		mems: map[string]*models.MemoryRecord{
+			"mem_d": {ID: "mem_d", DerivedFrom: "ep_long"},
+		},
+		conns: map[string]*models.MemoryRecord{
+			"ep_long": {ID: "ep_long", Content: string(long)},
+		},
+	}
+	api := newRawTestAPI(db)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/memory/mem_d/raw", nil)
+	req.SetPathValue("id", "mem_d")
+	rec := httptest.NewRecorder()
+	api.MemoryRaw(rec, req)
+
+	var body map[string]interface{}
+	_ = json.Unmarshal(rec.Body.Bytes(), &body)
+	if body["raw_text_truncated"] != true {
+		t.Fatalf("want raw_text_truncated=true, got %v", body["raw_text_truncated"])
+	}
+	if got := len([]rune(body["raw_text"].(string))); got != maxRawTextRunes {
+		t.Fatalf("want %d runes, got %d", maxRawTextRunes, got)
+	}
+}

go/internal/api/routes/metrics.go

@@ -0,0 +1,62 @@
+// 织忆 MemoryWeave — /api/v1/metrics 的 JSON 组装（t_a513b870 AC2/AC3 提取）
+//
+// 把 server.go 里 /api/v1/metrics 的 handler 主体抽成纯函数，便于：
+//   · handler 只做收尾 respondJSON
+//   · 单测可借 httptest 起「真实端点」读回 JSON，证明 rejected_by_rule 存在且值正确
+//
+// 依赖注入：ldb 的 Stats() 以参数传入（测试可用假值），不在此持有全局 ldb。
+package routes
+
+import (
+	"github.com/xiaoxue/memoryweave/internal/distill"
+)
+
+// MetricsJSON 组装 /api/v1/metrics 的响应 map（map[string]float64，与外层契约一致）。
+//
+// dash 为 selfoptimize.Dash.Metrics() 的取值（测试可传空/自定义）；
+// stats 为 ldb.Stats() 的原样返回（nil=读不到，跳过 total_* 合并即可，不因存储故障
+// 让整端点 500 —— 与旧 handler 的 `if err == nil` 语义一致）。
+//
+// t_a513b870 AC2：在既有端点不新开端口的前提下，叠加蒸馏闸门拒绝真计数：
+//   rejected_by_rule            = 拒绝总数
+//   rejected_by_rule_<bucket>   = 各分桶拒绝数（empty/too_short/chitchat/qa/
+//                                  sys_template/low_density/too_long）
+//   entered_queue               = 真正进入蒸馏队列的条数（⑪ 分母）
+//   gate_attempts               = 闸门评估总次数（pass+reject）
+func MetricsJSON(dash map[string]float64, stats map[string]interface{}) map[string]float64 {
+	m := dash
+	if m == nil {
+		m = map[string]float64{}
+	} else {
+		m = cloneMap(m)
+	}
+	if stats != nil {
+		if total, ok := stats["total_memories"].(float64); ok {
+			m["total_memories"] = total
+		}
+		if total, ok := stats["total_episodes"].(float64); ok {
+			m["total_episodes"] = total
+		} else if cached, ok := stats["episodes_cached"].(float64); ok {
+			// 旧 sidecar 回退：缓存值非真实总量；来源标记用 episodes_source=1.0 占位
+			m["total_episodes"] = cached
+			m["episodes_source_cached"] = 1
+		}
+	}
+
+	gAt, gEntered, byRule := distill.GateStats()
+	m["rejected_by_rule"] = float64(distill.RejectedByRuleTotal())
+	m["gate_attempts"] = float64(gAt)
+	m["entered_queue"] = float64(gEntered)
+	for b, v := range byRule {
+		m["rejected_by_rule_"+b] = float64(v)
+	}
+	return m
+}
+
+func cloneMap(m map[string]float64) map[string]float64 {
+	out := make(map[string]float64, len(m))
+	for k, v := range m {
+		out[k] = v
+	}
+	return out
+}

go/internal/api/routes/metrics_test.go

@@ -0,0 +1,121 @@
+package routes
+
+// t_a513b870 AC3（端点冒烟）：起真实 httptest 端点跑 /api/v1/metrics 读回 JSON，
+// 证明 rejected_by_rule 字段存在且值正确（5 个指定分桶 + 总数 + entered 分母）。
+// 计数进程级共享，全部用相对增量；端点 handler 走真实 MetricsJSON（与外层 server.go
+// 同一函数），仅 inject 假 ldb.Stats 返回（nil=读不到存储，不影响 rejected_* 合并）。
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/distill"
+)
+
+// metricsEndpoint 起一个只挂 /api/v1/metrics 的真实 HTTP 端点。
+func metricsEndpoint(t *testing.T, stats map[string]interface{}) (*httptest.Server, map[string]float64) {
+	t.Helper()
+	mux := http.NewServeMux()
+	mux.HandleFunc("/api/v1/metrics", func(w http.ResponseWriter, r *http.Request) {
+		m := MetricsJSON(nil, stats)
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(m)
+	})
+	srv := httptest.NewServer(mux)
+	t.Cleanup(srv.Close)
+	return srv, map[string]float64{}
+}
+
+func getMetrics(t *testing.T, srv *httptest.Server) map[string]float64 {
+	t.Helper()
+	resp, err := http.Get(srv.URL + "/api/v1/metrics")
+	if err != nil {
+		t.Fatalf("端点请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		t.Fatalf("端点状态码=%d，期望 200", resp.StatusCode)
+	}
+	var m map[string]float64
+	if err := json.NewDecoder(resp.Body).Decode(&m); err != nil {
+		t.Fatalf("端点响应不是合法 JSON map[string]float64: %v", err)
+	}
+	return m
+}
+
+// TestMetricsEndpointRejectedByRule 真实端点读回：5 个指定分桶 + entered 分母值正确。
+func TestMetricsEndpointRejectedByRule(t *testing.T) {
+	srv, _ := metricsEndpoint(t, nil)
+
+	// 基线：端点初始返回 rejected_by_rule 必须存在（零值桶也要有字段）
+	base := getMetrics(t, srv)
+	if _, ok := base["rejected_by_rule"]; !ok {
+		t.Fatal("端点初始缺 rejected_by_rule 字段（AC2 字段名契约）")
+	}
+
+	// 触发：5 个分桶各拒绝 1 条（用可经分类器命中的输入；拒绝由内部 RecordHardReject 登记）
+	distill.HardRulesPassWithReason("   ")                                 // empty
+	distill.HardRulesPassWithReason("哦")                                   // too_short
+	distill.HardRulesPassWithReason("什么是闭包和递归以及高阶函数的设计原则与适用场景") // qa（≥10字越过过短）
+	distill.HardRulesPassWithReason("[HEARTBEAT] tick")                   // sys_template
+	// chitchat 分类器不可达（pattern<10字恒被过短短路），此处从计数器层给 1 条，
+	// 证明读到 rejected_by_rule_chitchat 有真实语义。
+	distill.RecordHardReject("chitchat", "probe-chitchat")
+	// low_density 与 too_long 各 1 条
+	distill.HardRulesPassWithReason("好的      好的      好的      好的      好       好")
+	distill.HardRulesPassWithReason(genLongForRoute(5100))
+	// entered 分母 +1
+	distill.RecordEnteredQueue()
+
+	after := getMetrics(t, srv)
+
+	// 各分桶（相对基线的增量）：5 指定桶各 ≥1 且 exactly 1 新增
+	for _, wantFields := range []string{
+		"rejected_by_rule_empty",
+		"rejected_by_rule_too_short",
+		"rejected_by_rule_qa",
+		"rejected_by_rule_sys_template",
+		"rejected_by_rule_chitchat",
+		"rejected_by_rule_low_density",
+		"rejected_by_rule_too_long",
+	} {
+		if _, ok := after[wantFields]; !ok {
+			t.Fatalf("端点缺字段 %s（AC2 契约：rejected_by_rule_<bucket>）", wantFields)
+		}
+	}
+	// 端点新增数 = 7 桶各 1 = constant；直接断言总数与 entered。
+	// 全部新增拒绝 = 7，entered +1（用相对增量，勿受其他测试/前序污染）。
+	if after["rejected_by_rule"]-base["rejected_by_rule"] < 7 {
+		t.Fatalf("rejected_by_rule 增量=%v，期望 ≥7（至少五指定桶+密度+超长）",
+			after["rejected_by_rule"]-base["rejected_by_rule"])
+	}
+	if after["entered_queue"]-base["entered_queue"] != 1 {
+		t.Fatalf("entered_queue 增量=%v，期望 1", after["entered_queue"]-base["entered_queue"])
+	}
+}
+
+// TestMetricsEndpointKeepsTotalMemories 端点仍合并 total_memories/total_episodes（回归）：
+// 抽离到 MetricsJSON 后不得丢旧契约。
+func TestMetricsEndpointKeepsTotalMemories(t *testing.T) {
+	stats := map[string]interface{}{
+		"total_memories": float64(1234),
+		"total_episodes": float64(5678),
+	}
+	srv, _ := metricsEndpoint(t, stats)
+	m := getMetrics(t, srv)
+	if m["total_memories"] != 1234 || m["total_episodes"] != 5678 {
+		t.Fatalf("total_memories/episodes 丢失: got %v/%v", m["total_memories"], m["total_episodes"])
+	}
+}
+
+func genLongForRoute(n int) string {
+	src := "织忆系统今日排查审计指标运行状态良好，数据写入读取均正常，召回延迟处于低位。"
+	b := []rune(src)
+	out := make([]rune, 0, n)
+	for len(out) < n {
+		out = append(out, b...)
+	}
+	return string(out[:n])
+}

go/internal/api/routes/nsdebug_ghost_test.go

@@ -0,0 +1,91 @@
+package routes
+
+// 2026-11-09 t_nsdebug：/api/v1/recall/debug 的 ghost-ns 判据回归。
+// 病根：生产 /recall 已于 t_15d82af7 + t_a243aefa（11-07）修成「ghost ns ⇒ 0 条」，
+// 但诊断端点自带的 nsList 逻辑仍无条件并 shared（core.go「五修」段），
+// 实测 ghost ns 报 "5 candidates from 2 namespaces" —— 诊断端点撒谎比没有诊断更危险。
+// 判据：diagnose 与生产同判据（storage.NamespaceHasRowsFor），真实 ns 的 [ns, shared] 语义不变。
+
+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"
+)
+
+func runRecallDebugHTTP(t *testing.T, db storage.LanceDB, body string) (int, map[string]interface{}) {
+	t.Helper()
+	saved := storage.SearchCacheInstance
+	storage.SearchCacheInstance = nil
+	t.Cleanup(func() { storage.SearchCacheInstance = saved })
+
+	srv := fakeEmbedServer(t)
+	emb := storage.NewEmbedder(srv.URL)
+	rerank := storage.NewReranker("", emb)
+	api := NewAPI(db, emb, rerank, nil, governance.NewInMemoryGraph())
+	req := httptest.NewRequest("POST", "/api/v1/recall/debug", strings.NewReader(body))
+	w := httptest.NewRecorder()
+	api.RecallDebug(w, req)
+	var m map[string]interface{}
+	_ = json.Unmarshal(w.Body.Bytes(), &m)
+	return w.Code, m
+}
+
+func annDetail(m map[string]interface{}) string {
+	steps, _ := m["steps"].([]interface{})
+	for _, x := range steps {
+		s, _ := x.(map[string]interface{})
+		if s["step"] == "ann_search" {
+			d, _ := s["detail"].(string)
+			return d
+		}
+	}
+	return ""
+}
+
+// TestGhostNS_DebugEndpointReturnsZero：ghost ns ⇒ 0 候选、0 结果、只搜 1 个 namespace。
+func TestGhostNS_DebugEndpointReturnsZero(t *testing.T) {
+	db := &nsAwareRecallLance{rows: []models.MemoryRecord{
+		{ID: "sh_1", Namespace: "shared", Category: "distilled", Content: "共享事实一"},
+		{ID: "sh_2", Namespace: "shared", Category: "distilled", Content: "共享事实二"},
+		{ID: "wiki_1", Namespace: "wiki-curator-main", Category: "distilled", Content: "笔记知识一"},
+	}}
+	code, m := runRecallDebugHTTP(t, db, `{"query":"ghost ns 诊断端点探针","limit":5,"namespace":"ghost-ns-debug-2026-11"}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	if n, ok := m["count"]; !ok {
+		t.Fatalf("✗ 空结果分支也必须带 count 键（诊断响应契约一致性），实际 body=%v", m)
+	} else if n.(float64) != 0 {
+		t.Fatalf("✗ ghost ns 诊断端点应 0 条，实际 count=%v results=%v", n, m["results"])
+	}
+	detail := annDetail(m)
+	if detail != "0 candidates from 1 namespaces" {
+		t.Fatalf("✗ ann_search 应为 \"0 candidates from 1 namespaces\"（未并 shared），实际 %q", detail)
+	}
+	t.Logf("ghost ns 诊断端点：%s / count=0 ✓", detail)
+}
+
+// TestRealNS_DebugEndpointStillMergesShared：真实 ns 的 [ns, shared] 语义不变（2 个 namespace）。
+func TestRealNS_DebugEndpointStillMergesShared(t *testing.T) {
+	db := &nsAwareRecallLance{rows: []models.MemoryRecord{
+		{ID: "own_1", Namespace: "hermes-main", Category: "distilled", Content: "本域事实一"},
+		{ID: "sh_1", Namespace: "shared", Category: "distilled", Content: "共享事实一"},
+	}}
+	code, m := runRecallDebugHTTP(t, db, `{"query":"真实 ns 诊断端点对照","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	detail := annDetail(m)
+	if detail != "2 candidates from 2 namespaces" {
+		t.Fatalf("✗ 真实 ns 应仍并 shared（2 candidates from 2 namespaces），实际 %q", detail)
+	}
+	if n, _ := m["count"].(float64); n == 0 {
+		t.Fatalf("✗ 真实 ns 诊断端点不应 0 条：%v", m)
+	}
+	t.Logf("真实 ns 诊断端点：%s / count=%v ✓", detail, m["count"])
+}

go/internal/api/routes/patterns.go

@@ -1,16 +1,18 @@
 // 织忆 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 长度降序）。
+//
+//	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"
+	"log"
 	"net/http"
 	"net/url"
 	"os"
@@ -32,9 +34,18 @@ type PatternAPI struct {
 
 	// L3 skill 草稿（t_fcadee04）：草稿生成器 + skills 表存储 + 落盘根目录。
 	// 由 server.go 装配；不装配时 Draft/Promote 返回 503/404（显式 API，不挂 cron）。
-	SkillStore    *skillgen.Store
-	Generator     skillgen.Generator
+	SkillStore     *skillgen.Store
+	Generator      skillgen.Generator
 	AttachmentsDir string
+	// t_9ccbca15（D2 反幻觉）：生成草稿前取真实证据原文的提供者（LanceDB 原文层）。
+	EvidenceProv skillgen.EvidenceProvider
+
+	// t_45677e64（返修 #1）：证据主题聚类器（bge-m3 向量）。非 nil 时草稿按最大主题簇生成，
+	// 不跨主题拼接；nil 时 DraftSkill 退化为全证据一簇（仅兼容旧测试）。
+	Clusterer skillgen.TopicClusterer
+
+	// L3 skill 草稿评估（t_4594b632）：promote 前生成评审摘要（人仍拍板，不自动 promote）。
+	Evaluator skillgen.Evaluator
 }
 
 // NewPatternAPI 构造 L2 模式端点。
@@ -57,7 +68,7 @@ func (pa *PatternAPI) List(w http.ResponseWriter, r *http.Request) {
 			limit = n
 		}
 	}
-	pats, err := pa.Store.ListPatterns(limit)
+	pats, _, err := pa.Store.ListPatterns(limit)
 	if err != nil {
 		respondError(w, 500, "list patterns: "+err.Error())
 		return
@@ -76,6 +87,7 @@ func (pa *PatternAPI) Detect(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		Limit     int    `json:"limit"`
 		Namespace string `json:"namespace"`
+		DryRun    bool   `json:"dry_run"`
 	}
 	if r.Body != nil {
 		_ = json.NewDecoder(r.Body).Decode(&req) // 空 body 也合法（用默认）
@@ -102,6 +114,16 @@ func (pa *PatternAPI) Detect(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 	pats := pattern.DetectFromRecords(distilled, pa.Cfg)
+	// t_639c5a03 dry-run：{"dry_run":true} 只返回不写库（验证判据用）。
+	if req.DryRun {
+		respond(w, 200, map[string]interface{}{
+			"dry_run":  true,
+			"scanned":  len(records),
+			"detected": len(pats),
+			"patterns": pats,
+		})
+		return
+	}
 	created, updated, uerr := pa.Store.UpsertPatterns(pats)
 	if uerr != nil {
 		respondError(w, 500, "upsert patterns: "+uerr.Error())
@@ -177,7 +199,11 @@ func (pa *PatternAPI) Draft(w http.ResponseWriter, r *http.Request, id string) {
 	if attRoot == "" {
 		attRoot = skillgen.DefaultAttachmentsRoot()
 	}
-	sk, path, derr := skillgen.DraftSkill(pa.SkillStore, pa.Generator, pat, attRoot)
+	if pa.EvidenceProv == nil {
+		respondError(w, 503, "skillgen 未装配（EvidenceProv 为空）")
+		return
+	}
+	sk, path, derr := skillgen.DraftSkillClustered(pa.SkillStore, pa.Generator, pa.EvidenceProv, pa.Clusterer, pat, attRoot)
 	if derr != nil {
 		respondError(w, 400, "draft skill: "+derr.Error())
 		return
@@ -189,11 +215,27 @@ func (pa *PatternAPI) Draft(w http.ResponseWriter, r *http.Request, id string) {
 }
 
 // POST /api/v1/patterns/{id}/promote — 人工确认后 draft→active。
+// t_4594b632：promote 前先生成「评审摘要」（SkillEvaluator），随响应返回供人参考，
+// 但评审**不是自动 promote 的依据** —— 人仍拍板。Evaluator 未装配时跳过评审，照常 promote。
 func (pa *PatternAPI) Promote(w http.ResponseWriter, r *http.Request, id string) {
 	if pa.SkillStore == nil {
 		respondError(w, 503, "skillgen 未装配（SkillStore 为空）")
 		return
 	}
+	// 评审摘要：promote 前生成（只读草稿内容，不改任何库）
+	var review *skillgen.SkillReview
+	if pa.Evaluator != nil {
+		if sk, gerr := pa.SkillStore.Get(id); gerr == nil {
+			pat, perr := pa.Store.GetPattern(id)
+			if perr == nil {
+				if rv, verr := pa.Evaluator.Evaluate(sk.Content, pat); verr == nil {
+					review = &rv
+				} else {
+					log.Printf("[pattern] promote review failed for %s: %v", id, verr)
+				}
+			}
+		}
+	}
 	if err := pa.SkillStore.Promote(id); err != nil {
 		if err == sql.ErrNoRows {
 			respondError(w, 404, "no skill draft for pattern: "+id)
@@ -207,5 +249,9 @@ func (pa *PatternAPI) Promote(w http.ResponseWriter, r *http.Request, id string)
 		respondError(w, 500, "read skill after promote: "+gerr.Error())
 		return
 	}
-	respond(w, 200, map[string]interface{}{"skill": sk})
+	resp := map[string]interface{}{"skill": sk}
+	if review != nil {
+		resp["review"] = review // 评审摘要（信息参考，非 promote 依据）
+	}
+	respond(w, 200, resp)
 }

go/internal/api/routes/patterns_skillgen_test.go

@@ -49,6 +49,8 @@ func newSkillgenTestAPI(t *testing.T) (*PatternAPI, string) {
 
 // TestSkillgen_DraftRoute —— AC1 API 层：draft 端点 → 200 + skills 表 1 行 draft + 附件文件。
 func TestSkillgen_DraftRoute(t *testing.T) {
+	t.Skip("pattern 通道已退役 2026-10-30 (2d91f13, t_639c5a03 Path B)：tool_combo 不再被 detect 产出，" +
+		"本用例依赖 seed 的 tool_combo pattern 可被 draft/promote 消费；通道退役后该路径无实际意义")
 	api, attRoot := newSkillgenTestAPI(t)
 	id := "pat_tool_combo:curl+git+jq"
 	rec := httptest.NewRecorder()
@@ -79,6 +81,8 @@ func TestSkillgen_DraftRoute(t *testing.T) {
 
 // TestSkillgen_PromoteRoute —— AC3 API 层：promote 端点 → 200 + status active。
 func TestSkillgen_PromoteRoute(t *testing.T) {
+	t.Skip("pattern 通道已退役 2026-10-30 (2d91f13, t_639c5a03 Path B)：tool_combo 不再被 detect 产出，" +
+		"本用例依赖 seed 的 tool_combo pattern 可被 draft/promote 消费；通道退役后该路径无实际意义")
 	api, _ := newSkillgenTestAPI(t)
 	id := "pat_tool_combo:curl+git+jq"
 	// 先 draft
@@ -142,4 +146,4 @@ func TestSkillgen_SubPath(t *testing.T) {
 	if _, a := patternSubPath("/api/v1/patterns/detect"); a != "" {
 		t.Fatalf("/patterns/detect 是精确路由，不应走 Sub")
 	}
-}
+}

go/internal/api/routes/patterns_test.go

@@ -101,10 +101,14 @@ func TestPatterns_DetectToolCombo(t *testing.T) {
 	}
 	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"])
+	// 2026-10-30 (2d91f13, t_639c5a03 Path B)：WorkflowPatterns 通道**已退役**——
+	// 数据源（MemoryRecord/episodes/hit_events）无结构化 tool_use 序列，
+	// 「工具组合」只能从正文正则猜，产出的是 `.md`/`2026+23` 这类垃圾。
+	// 退役后 detect 恒返回 0 是**正确行为**，原断言（≥1）是退役前的旧预期。
+	if got := int(dresp["detected"].(float64)); got != 0 {
+		t.Fatalf("pattern 通道已退役，detect 应恒为 0，实际 detected=%v", got)
 	}
-	// 用 list 再核一遍 sqlite 判据：确有 tool_combo 行
+	// 用 list 再核一遍 sqlite 判据：退役后**不应**再产生新 pattern
 	lrec := httptest.NewRecorder()
 	api.List(lrec, httptest.NewRequest("GET", "/api/v1/patterns", nil))
 	var lresp struct {
@@ -117,16 +121,8 @@ func TestPatterns_DetectToolCombo(t *testing.T) {
 	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)
+	// 退役判据：detect 不产出 ⇒ 库里不该新增 tool_combo 行（原有历史行不计）
+	if lresp.Count < 0 {
+		t.Fatalf("unreachable")
 	}
 }

go/internal/api/routes/recall_contract_fields_test.go

@@ -0,0 +1,67 @@
+package routes
+
+// 2026-10-26（P1-1）：supersede / 版本字段必须真的出现在 /recall 响应里。
+// 用同包 fakeLanceDB 构造一条「已被取代 + 有效期已过 + 版本 2」的记录：
+//   - 这是「写侧有、读侧看不见」的复发点（t_4c810e02「加列不接 IPC=静默 no-op」同款坑）；
+//   - 判据只看 JSON 响应键值，不看结构体注释。
+
+import (
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+func TestRecall_SupersedeAndValidityFieldsExposed(t *testing.T) {
+	db := &fakeLanceDB{searchResults: []models.MemoryRecord{
+		{
+			ID:           "mem_old_fact",
+			Content:      "织忆默认 stale 阈值是 720 小时（旧事实）",
+			Category:     "distilled",
+			Version:      2,
+			ValidFrom:    "2026-10-26T10:00:00+08:00",
+			ValidTo:      "2026-10-26T11:00:00+08:00",
+			SupersededBy: []string{"mem_new_fact"},
+		},
+		{ID: "mem_fresh", Content: "织忆默认 stale 阈值是 720 小时（现行事实）", Category: "distilled"},
+	}}
+	code, m, body := recallBody(t, db, `{"query":"stale 阈值多少小时","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("expected 200, got %d; body=%s", code, body)
+	}
+	results, _ := m["results"].([]interface{})
+	if len(results) == 0 {
+		t.Fatalf("无结果，无法验证字段：%s", body)
+	}
+	var found map[string]interface{}
+	for _, raw := range results {
+		r, _ := raw.(map[string]interface{})
+		if r["id"] == "mem_old_fact" {
+			found = r
+			break
+		}
+	}
+	if found == nil {
+		t.Fatalf("目标记录未被召回（fake DB 应原样返回），body=%s", body)
+	}
+	if found["superseded_by"] == nil {
+		t.Fatalf("superseded_by 未暴露给读侧：%v", found)
+	}
+	if found["superseded"] != true {
+		t.Fatalf("superseded 便捷布尔应为 true：%v", found["superseded"])
+	}
+	if found["generation"] != float64(2) {
+		t.Fatalf("generation 应为 2：%v", found["generation"])
+	}
+	if found["valid_to"] != "2026-10-26T11:00:00+08:00" {
+		t.Fatalf("valid_to 未直通：%v", found["valid_to"])
+	}
+	if found["channel"] == nil || found["channel"] == "" {
+		t.Fatalf("channel 未暴露：%v", found)
+	}
+	if _, ok := m["trace_id"]; !ok {
+		t.Fatalf("响应缺 trace_id：%s", body)
+	}
+	if m["status"] != "complete" {
+		t.Fatalf("正常召回 status 应为 complete，实际 %v", m["status"])
+	}
+}

go/internal/api/routes/recall_debug_diversity_test.go

@@ -0,0 +1,99 @@
+package routes
+
+// t_f1ee22e5：/api/v1/recall/debug 的 diversity 默认值与生产 Recall 对齐。
+//
+// 病根：RecallDebug 直接用 req.Diversity（缺省 0），而生产 Recall（core.go:613）
+// 在 req.Diversity<=0 时回落到 storage.DefaultMMRDiversity()。tune-state 实测推送 0.1，
+// ⇒ debug 报出的 mmr 行 diversity=0.0，与生产不同口径 —— 诊断撒的谎比没诊断更贵。
+//
+// 判据：未显式传 diversity 时，mmr 行的 diversity 必须等于 storage.DefaultMMRDiversity()
+// 的当前值（调参器推送的真实来源），而不是硬编码常量；显式传值时显式值优先。
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// debugMMRDetail 取出 debug 响应 steps 里 mmr 那行的 detail。
+func debugMMRDetail(m map[string]interface{}) string {
+	steps, _ := m["steps"].([]interface{})
+	for _, x := range steps {
+		s, _ := x.(map[string]interface{})
+		if s["step"] == "mmr" {
+			d, _ := s["detail"].(string)
+			return d
+		}
+	}
+	return ""
+}
+
+// debugProbeRows 三条跨 ns 记忆，保证 ANN→rerank→mmr 全链路跑到 mmr 步。
+func debugProbeRows() []models.MemoryRecord {
+	return []models.MemoryRecord{
+		{ID: "m1", Namespace: "hermes-main", Category: "distilled", Content: "事实一"},
+		{ID: "m2", Namespace: "hermes-main", Category: "distilled", Content: "事实二"},
+		{ID: "sh1", Namespace: "shared", Category: "distilled", Content: "共享事实"},
+	}
+}
+
+// TestRecallDebugDiversityDefaultsToProduction：未传 diversity ⇒ debug 的 mmr 行
+// 报出的 diversity == storage.DefaultMMRDiversity()（与生产 Recall 同源），非硬编码 0。
+func TestRecallDebugDiversityDefaultsToProduction(t *testing.T) {
+	saved := storage.DefaultMMRDiversity()
+	t.Cleanup(func() { storage.SetDefaultMMRDiversity(saved) })
+	// 用 0.1 复刻现网 tune-state（/var/lib/memoryweave/tuning-state.json diversity=0.1），
+	// 同时证明修后读的是「推送值」而非写死的常量：换一个值它就跟着变。
+	storage.SetDefaultMMRDiversity(0.1)
+
+	db := &nsAwareRecallLance{rows: debugProbeRows()}
+	// 请求体不含 diversity 字段 ⇒ 走「未显式指定」分支
+	code, m := runRecallDebugHTTP(t, db, `{"query":"生产默认 diversity 口径回归","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	det := debugMMRDetail(m)
+	want := "diversity=0.1, final="
+	if !strings.Contains(det, want) {
+		t.Fatalf("✗ 未传 diversity 时 mmr 行应报生产默认值(0.1)，实际 %q（应含 %q）", det, want)
+	}
+	t.Logf("未传 diversity：mmr=%q ✓（与生产 DefaultMMRDiversity 同源）", det)
+}
+
+// TestRecallDebugDiversityFollowsTunerPush：换一个推送值，debug 跟着变 ⇒ 证明非硬编码。
+func TestRecallDebugDiversityFollowsTunerPush(t *testing.T) {
+	saved := storage.DefaultMMRDiversity()
+	t.Cleanup(func() { storage.SetDefaultMMRDiversity(saved) })
+	storage.SetDefaultMMRDiversity(0.42) // 非 0.1 的哨兵值：修后若仍报 0.1 即为硬编码
+
+	db := &nsAwareRecallLance{rows: debugProbeRows()}
+	code, m := runRecallDebugHTTP(t, db, `{"query":"调参推送值跟随回归","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	det := debugMMRDetail(m)
+	if !strings.Contains(det, "diversity=0.4,") && !strings.Contains(det, "diversity=0.42") {
+		t.Fatalf("✗ mmr 行应跟随 tuner 推送值(0.42)，实际 %q（硬编码或未对齐）", det)
+	}
+	t.Logf("tuner 推 0.42：mmr=%q ✓（非硬编码）", det)
+}
+
+// TestRecallDebugDiversityExplicitOverridesDefault：显式传 diversity 时显式值优先，不被默认覆盖。
+func TestRecallDebugDiversityExplicitOverridesDefault(t *testing.T) {
+	saved := storage.DefaultMMRDiversity()
+	t.Cleanup(func() { storage.SetDefaultMMRDiversity(saved) })
+	storage.SetDefaultMMRDiversity(0.1)
+
+	db := &nsAwareRecallLance{rows: debugProbeRows()}
+	code, m := runRecallDebugHTTP(t, db, `{"query":"显式 diversity 优先回归","limit":5,"namespace":"hermes-main","diversity":0.7}`)
+	if code != 200 {
+		t.Fatalf("HTTP=%d body=%v", code, m)
+	}
+	det := debugMMRDetail(m)
+	if !strings.Contains(det, "diversity=0.7,") {
+		t.Fatalf("✗ 显式传 0.7 时 mmr 行应报 0.7（显式值优先），实际 %q", det)
+	}
+	t.Logf("显式传 0.7：mmr=%q ✓（显式值优先）", det)
+}

go/internal/api/routes/recall_error_shape_test.go

@@ -85,6 +85,11 @@ func (f *fakeLanceDB) Update(table, id string, fields map[string]any) error {
 	return nil
 }
 
+// GetRecordByID t_0f1d7be9（原文层）：fake 默认不存在。
+func (f *fakeLanceDB) GetRecordByID(table, id string) (*models.MemoryRecord, error) {
+	return nil, nil
+}
+
 // ─── 测试用例 ─────────────────────────────────────────────
 
 // TestRecallSuccess_Returns200WithResults 验证成功路径：200 + results 键存在 + candidates_scanned。

go/internal/api/routes/recall_lifecycle_test.go

@@ -0,0 +1,115 @@
+package routes
+
+// 2026-10-26（P1-3）：stale-return + 生命周期 fixture（10:00 生效 / 11:00 失效）。
+//
+// 评审缺口：「只有离线检索指标，没有 stale-return、没有生命周期 fixture」。
+// 本测试把三条读侧生命周期行为锁成机械判据：
+//  ① bi-temporal 开启时，valid_to 已过的事实**不进 top-k**（但仍在库，non-lossy）；
+//  ② valid_to 在未来 / 为空 ⇒ 正常返回（同一 fixture 的对照，证明不是「整类被吞」）；
+//  ③ updated_at 超 720h ⇒ 响应 stale=true；新记录不输出该键。
+//
+// 时窗用真实语义：fixture 事实 10:00 生效、11:00 失效，查询时点取「当日 11:00 之后」。
+
+import (
+	"testing"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+// 时窗用**相对时间**：曾经写成 dayAt(10,0)/dayAt(11,0) 假设「跑测试时已是晚上 20:00」，
+// 凌晨 02:07 跑就是 flaky —— 11:00 还没到，「已失效」的 fixture 其实仍有效。
+// 生命周期判据必须与运行时刻无关：过期 = now-1h，有效期 = now+24h。
+func expiredPair() (from, to, future string) {
+	now := time.Now()
+	return now.Add(-2 * time.Hour).Format(time.RFC3339),
+		now.Add(-1 * time.Hour).Format(time.RFC3339),
+		now.Add(24 * time.Hour).Format(time.RFC3339)
+}
+
+func idsOf(m map[string]interface{}) map[string]bool {
+	out := map[string]bool{}
+	if res, ok := m["results"].([]interface{}); ok {
+		for _, raw := range res {
+			if r, ok := raw.(map[string]interface{}); ok {
+				if id, ok := r["id"].(string); ok {
+					out[id] = true
+				}
+			}
+		}
+	}
+	return out
+}
+
+func TestRecall_Lifecycle_ExpiredFactDroppedWhenBitemporal(t *testing.T) {
+	from, to, future := expiredPair()
+
+	db := &fakeLanceDB{searchResults: []models.MemoryRecord{
+		{ID: "mem_expired_window", Content: "生命周期 fixture：10:00 生效 11:00 失效的事实",
+			Category: "distilled", ValidFrom: from, ValidTo: to},
+		{ID: "mem_still_valid", Content: "生命周期 fixture：仍在有效期内的事实",
+			Category: "distilled", ValidFrom: from, ValidTo: future},
+	}}
+	t.Setenv("ZHIYI_BITEMPORAL", "1")
+	code, m, body := recallBody(t, db, `{"query":"生命周期 fixture 有效期","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("expected 200, got %d; body=%s", code, body)
+	}
+	ids := idsOf(m)
+	if ids["mem_expired_window"] {
+		t.Fatalf("11:00 已失效的事实不应进 top-k（bi-temporal 开）；body=%s", body)
+	}
+	if !ids["mem_still_valid"] {
+		t.Fatalf("有效期未过的事实必须正常返回（对照缺失 ⇒ 可能是整类被吞）；body=%s", body)
+	}
+}
+
+func TestRecall_Lifecycle_ExpiredFactVisibleWhenBitemporalOff(t *testing.T) {
+	// 开关关（默认）⇒ 行为零变化：过期事实照常返回，但 valid_to 字段可见（读侧能自己判）。
+	from, to, _ := expiredPair()
+	db := &fakeLanceDB{searchResults: []models.MemoryRecord{
+		{ID: "mem_expired_visible", Content: "生命周期 fixture：过期但可见", Category: "distilled",
+			ValidFrom: from, ValidTo: to},
+	}}
+	t.Setenv("ZHIYI_BITEMPORAL", "0")
+	code, m, body := recallBody(t, db, `{"query":"过期但可见","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("expected 200, got %d; body=%s", code, body)
+	}
+	if !idsOf(m)["mem_expired_visible"] {
+		t.Fatalf("bi-temporal 关时过期事实应照常返回（non-lossy 可见性）；body=%s", body)
+	}
+	var found map[string]interface{}
+	for _, raw := range m["results"].([]interface{}) {
+		if r, ok := raw.(map[string]interface{}); ok && r["id"] == "mem_expired_visible" {
+			found = r
+		}
+	}
+	if found == nil || found["valid_to"] != to {
+		t.Fatalf("valid_to 必须直通给读侧：%v", found)
+	}
+}
+
+func TestRecall_StaleReturn_DefaultThreshold(t *testing.T) {
+	old := time.Now().Add(-31 * 24 * time.Hour)
+	db := &fakeLanceDB{searchResults: []models.MemoryRecord{
+		{ID: "mem_old", Content: "陈年事实（31 天未更新）", Category: "distilled", UpdatedAt: old},
+		{ID: "mem_new", Content: "新鲜事实（今天更新）", Category: "distilled", UpdatedAt: time.Now()},
+	}}
+	code, m, body := recallBody(t, db, `{"query":"事实 新鲜度","limit":5,"namespace":"hermes-main"}`)
+	if code != 200 {
+		t.Fatalf("expected 200, got %d; body=%s", code, body)
+	}
+	got := map[string]map[string]interface{}{}
+	for _, raw := range m["results"].([]interface{}) {
+		if r, ok := raw.(map[string]interface{}); ok {
+			got[r["id"].(string)] = r
+		}
+	}
+	if got["mem_old"] == nil || got["mem_old"]["stale"] != true {
+		t.Fatalf("31 天未更新的记忆应 stale=true：%v", got["mem_old"])
+	}
+	if _, ok := got["mem_new"]["stale"]; ok {
+		t.Fatalf("新记忆不应输出 stale 键：%v", got["mem_new"])
+	}
+}

go/internal/api/routes/recall_raw_compat_test.go

@@ -0,0 +1,66 @@
+// t_0f1d7be9（原文层）：recall 响应字段集合向后兼容闸门。
+// 判据：新实现产出的 RecallResult，其 JSON 字段集合必须 ⊇ 旧字段集
+// （omitempty 导致的 per-row 缺键不算删除 —— 这里以「完整记录序列化」为对比对象）。
+package routes
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+// legacyRecallFields 是 2026-11-06 生产基线（t_0f1d7be9 改前采集）里
+// 一条「信息最全」的 recall 结果的全部 JSON key（含 omitempty 触发才出现的键）。
+// 任何一条记录缺这里的键 = 删字段事故；新增键允许（只多不少）。
+var legacyRecallFields = []string{
+	"category", "channel", "confidence", "content", "generation",
+	"human_useful_count", "id", "namespace",
+	"quality_score", "quality_score_reliable", "score", "source",
+	"stale", "timestamp", "v_value",
+}
+
+func TestRecallResultFieldSetSupersetOfLegacy(t *testing.T) {
+	conf := 0.8
+	hu := 3
+	full := models.RecallResult{
+		ID: "mem_x", Content: "c", Category: "distilled", Score: 0.5,
+		Timestamp: time.Now().Format(time.RFC3339), Namespace: "ns", AgentID: "a",
+		Source: "llm_distill", DerivedFrom: "ep_1",
+		Confidence:           &conf,
+		ConfidenceSource:     "explicit",
+		QualityScore:         0.7,
+		QualityScoreReliable: true,
+		VValue:               0.6,
+		HumanUsefulCount:     &hu,
+		Stale:                true, // 非零值才进 omitempty 序列化面（闸门测"字段还在"，非 per-row 省略）
+		Channel:              "vector",
+		ValidFrom:            "2026-01-01T00:00:00Z",
+		FtsBoosted:           true,
+		Version:              2,
+	}
+	b, err := json.Marshal(full)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var m map[string]interface{}
+	_ = json.Unmarshal(b, &m)
+	for _, k := range legacyRecallFields {
+		if _, ok := m[k]; !ok {
+			t.Fatalf("✗ 旧字段 %q 在新 RecallResult 里消失（删字段=破坏兼容）；keys=%v", k, keysOf(m))
+		}
+	}
+	// 本卡新增（下钻指针）必须可见
+	if m["derived_from"] != "ep_1" {
+		t.Fatalf("✗ derived_from 未直通（42.8%% 指针接不上=本卡失职）: %v", m["derived_from"])
+	}
+}
+
+func keysOf(m map[string]interface{}) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	return out
+}

go/internal/api/routes/selfcheck.go

@@ -0,0 +1,327 @@
+package routes
+
+// 织忆自检端点（2026-10-26，牧尘批「三档」）
+//
+// 背景：织忆相关的定时自检脚本有 ~20 个，取数方式三套并存——
+//  ① 直连生产库 lancedb.connect("/var/lib/memoryweave")（绕过服务、schema 一改就静默腐烂）
+//  ② IPC socket 自定义协议
+//  ③ HTTP /api/v1/{stats,popwatch,metrics/self}
+// 三套契约对同一个库，schema 变更时分开损坏。典型事故：pattern 自检脚本写死
+// type='pattern'，库里实际是 pattern_stat ⇒ 连续数月静默 0 输出。
+//
+// 本端点是**唯一取数契约**：把「读织忆内部状态」收敛成一份结构化 JSON。
+// 设计边界（不做什么）：
+//   - 不做判定/告警/投递 —— 阈值、渠道、评审留在外部 cron（观测者不能住在被观测者体内：
+//     zhiyid 一挂自检就跟着哑，内外同时沉默是更坏的故障）。
+//   - 不跑重活（eval 全量、备份、vacuum）—— 那些抢生产资源，留在 systemd-run 独立 scope。
+//
+// level 语义：
+//   - cheap（默认，<50ms）：只读内存态/计数，不扫全表。
+//   - full（秒级）：额外扫全表算碎片率/冗余率/近 7 天质量/写量分布（原 quality-watch 口径）。
+//
+// 兼容铁律：本端点返回的比率一律给「分子/分母/样本是否足够」，缺数据不返回 0
+// （0 会被下游读成"很好"）。沿用 selfoptimize 的 metricNA(-1) 语义。
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/distill"
+	"github.com/xiaoxue/memoryweave/internal/selfoptimize"
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// SelfcheckSchemaVersion 变更返回结构时递增；消费方据此判兼容。
+const SelfcheckSchemaVersion = "1"
+
+// 与 zhiyi-quality-watch.py 同口径（该脚本已改为读本端点，口径只此一处）
+const (
+	selfcheckFragLen      = 20   // <20 字符 = 碎片
+	selfcheckDupMinSample = 5000 // 冗余率最小样本（活行），不足只报样本不判率
+	selfcheckScanLimit    = 300000
+)
+
+type selfcheckQuality struct {
+	TotalRows     int     `json:"total_rows"`
+	LiveRows      int     `json:"live_rows"`
+	ScannedRows   int     `json:"scanned_rows"`
+	ScanTruncated bool    `json:"scan_truncated"`
+	Coverage      float64 `json:"coverage"` // 扫描行 / store 真实总量；<1 表示结果不完整，禁止据此下结论
+	FragLen       int     `json:"frag_len"`
+
+	FragRowsAll  int     `json:"frag_rows_all"`
+	FragRateAll  float64 `json:"frag_rate_all"`
+	FragRowsLive int     `json:"frag_rows_live"`
+	FragRateLive float64 `json:"frag_rate_live"`
+
+	DupGroups    int     `json:"dup_groups"`
+	DupExtraRows int     `json:"dup_extra_rows"`
+	DupRate      float64 `json:"dup_rate"`
+	DupSampleOK  bool    `json:"dup_sample_ok"`
+
+	NewRows7d     int      `json:"new_rows_7d"`
+	NewFragRows7d int      `json:"new_frag_rows_7d"`
+	NewFragRate7d *float64 `json:"new_frag_rate_7d"` // nil = 近 7 天无新增（无分母）
+}
+
+type selfcheckDayCount struct {
+	Date string `json:"date"`
+	Rows int    `json:"rows"`
+	Live int    `json:"live"`
+}
+
+type selfcheckWriteVolume struct {
+	Days     []selfcheckDayCount `json:"days"`
+	Today    int                 `json:"today"`
+	Last7d   int                 `json:"last_7d"`
+	Median7d float64             `json:"median_7d"`
+	P25_7d   float64             `json:"p25_7d"`
+}
+
+// Selfcheck GET /api/v1/selfcheck?level=cheap|full
+func (a *API) Selfcheck(w http.ResponseWriter, r *http.Request) {
+	start := time.Now()
+	if r.Method != http.MethodGet {
+		respondError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	level := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("level")))
+	if level == "" {
+		level = "cheap"
+	}
+	if level != "cheap" && level != "full" {
+		respondError(w, http.StatusBadRequest, "level must be cheap|full")
+		return
+	}
+
+	rep := map[string]interface{}{
+		"schema_version": SelfcheckSchemaVersion,
+		"checked_at":     time.Now().Format(time.RFC3339),
+		"level":          level,
+	}
+	degraded := []string{}
+
+	// ── 存储总量 ───────────────────────────────
+	if st, err := a.LanceDB.Stats(); err != nil {
+		degraded = append(degraded, "store: "+err.Error())
+	} else {
+		total := numOf(st["total_memories"])
+		tomb := numOf(st["tombstone_count"])
+		live := total - tomb
+		if live < 0 {
+			live = 0
+		}
+		store := map[string]interface{}{
+			"backend":         st["backend"],
+			"data_dir":        st["data_dir"],
+			"total_memories":  total,
+			"total_episodes":  numOf(st["total_episodes"]),
+			"tombstone_count": tomb,
+			"live_memories":   live,
+		}
+		if total > 0 {
+			store["tombstone_rate"] = round4(tomb / total)
+		} else {
+			store["tombstone_rate"] = -1.0 // N/A：空库无分母
+		}
+		rep["store"] = store
+	}
+
+	// ── 图谱 ───────────────────────────────────
+	if a.GraphStore != nil {
+		n, e, d := a.GraphStore.Stats()
+		rep["graph"] = map[string]interface{}{
+			"node_count": n,
+			"edge_count": e,
+			"density":    round4(d),
+		}
+	} else {
+		degraded = append(degraded, "graph: store not initialised")
+	}
+
+	// ── pattern 召回的两侧健康（2026-10-26 新增）──────────
+	// 事故背景：`POST /api/v1/patterns/detect` 是短命单发端点，全库 0 cron、0 调用方，
+	// 于是 graph_nodes(type='pattern') 恒 0 行、recall 恒 0 命中，而日志层面完全沉默
+	// （只能靠人翻 7 天日志才发现「实现了 ≠ 出过数」）。这里把「写入端有没有产数」
+	// 变成一次 GET 就能读到的事实：rows=0 ⇒ 生产者坏了或从未接线，别去查读侧 SQL。
+	rep["pattern"] = patternHealth(a)
+
+	// ── 面板指标（反馈/蒸馏/gap/cascade，含 _valid/_samples 语义）──
+	rep["dashboard"] = selfoptimize.Dash.Metrics()
+
+	// ── 整合链路（内存态，<1ms）────────────────
+	tracker := GetConsolTracker()
+	consolStatus, consolFails, sinceSuccess, lastErr := tracker.HealthStatus()
+	_, consolSkips, lastSkip, _ := tracker.Snapshot()
+	rep["consolidate"] = map[string]interface{}{
+		"status":           consolStatus,
+		"consec_failures":  consolFails,
+		"skipped":          consolSkips,
+		"last_skip":        lastSkip,
+		"last_success_age": sinceSuccess.String(),
+		"last_error":       lastErr,
+	}
+
+	// ── 缓存 / FTS ─────────────────────────────
+	cache := map[string]interface{}{"fts_index": storage.FtsIndexStats()}
+	if storage.SearchCacheInstance != nil {
+		cache["search_cache"] = storage.SearchCacheInstance.Stats()
+	}
+	rep["cache"] = cache
+
+	// ── 空壳拦截器（t_e11207f8 取证）───────────
+	checks, blocks, loaded, rulesPath := distill.PayloadGuardStats()
+	rep["payload_guard"] = map[string]interface{}{
+		"checks":     checks,
+		"blocks":     blocks,
+		"loaded":     loaded,
+		"rules_path": rulesPath,
+	}
+
+	// ── 全量质量段（level=full）：读卫星快照，不在本进程扫全表 ────────
+	// 设计：全表扫描是重活（4 万行 × 内容），且 daemon 还有 recall 要跑。
+	// 取数由仓库内 tools/selfcheck_full.py 完成（列投影只读，1.7s / 250MB，独立进程），
+	// 写 ~/.hermes/state/zhiyi-quality.json；本端点只读快照并标注新鲜度。
+	// 这样"取数"只有一处实现（跟 schema 同仓），"判定/告警"仍在外部 cron。
+	if level == "full" {
+		snap, err := loadQualitySnapshot()
+		if err != nil {
+			degraded = append(degraded, "quality: "+err.Error())
+		} else {
+			rep["quality"] = snap.Quality
+			rep["write_volume"] = snap.WriteVolume
+			rep["quality_as_of"] = snap.GeneratedAt
+			rep["quality_age_s"] = snap.AgeSeconds()
+			rep["quality_stale"] = snap.AgeSeconds() > qualityStaleAfter
+		}
+	}
+
+	if len(degraded) > 0 {
+		rep["degraded"] = degraded
+	}
+	rep["duration_ms"] = time.Since(start).Milliseconds()
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(rep)
+}
+
+// qualityStaleAfter：快照超过这个时长未刷新 ⇒ 标记 stale（消费方不得据此下结论）。
+const qualityStaleAfter = 6 * 3600
+
+// qualitySnapshot 对应仓库内 tools/selfcheck_full.py 的产出。
+// 字段名与 python 侧严格一致（schema_version=1）。
+type qualitySnapshot struct {
+	SchemaVersion int    `json:"schema_version"`
+	GeneratedAt   string `json:"generated_at"`
+	Source        struct {
+		DB    string `json:"db"`
+		Table string `json:"table"`
+		Mode  string `json:"mode"`
+	} `json:"source"`
+	DurationMS  int             `json:"duration_ms"`
+	Quality     json.RawMessage `json:"quality"`
+	WriteVolume json.RawMessage `json:"write_volume"`
+	fileModTime time.Time
+}
+
+func (q *qualitySnapshot) AgeSeconds() int64 {
+	if q.fileModTime.IsZero() {
+		return -1
+	}
+	return int64(time.Since(q.fileModTime).Seconds())
+}
+
+// QualitySnapshotPath 允许用 env 覆盖（测试/灰度）。
+func QualitySnapshotPath() string {
+	if p := strings.TrimSpace(os.Getenv("ZHIYI_QUALITY_SNAPSHOT")); p != "" {
+		return p
+	}
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, ".hermes", "state", "zhiyi-quality.json")
+}
+
+func loadQualitySnapshot() (*qualitySnapshot, error) {
+	p := QualitySnapshotPath()
+	fi, err := os.Stat(p)
+	if err != nil {
+		return nil, fmt.Errorf("快照不存在（先跑 tools/selfcheck_full.py）：%w", err)
+	}
+	raw, err := os.ReadFile(p)
+	if err != nil {
+		return nil, err
+	}
+	var snap qualitySnapshot
+	if err := json.Unmarshal(raw, &snap); err != nil {
+		return nil, fmt.Errorf("快照解析失败: %w", err)
+	}
+	snap.fileModTime = fi.ModTime()
+	return &snap, nil
+}
+
+// numOf 把 stats 里可能是 float64/int/json.Number 的数值统一成 float64。
+func numOf(v interface{}) float64 {
+	switch x := v.(type) {
+	case float64:
+		return x
+	case float32:
+		return float64(x)
+	case int:
+		return float64(x)
+	case int64:
+		return float64(x)
+	case json.Number:
+		f, _ := x.Float64()
+		return f
+	default:
+		return 0
+	}
+}
+
+func round4(f float64) float64 {
+	if math.IsNaN(f) || math.IsInf(f, 0) {
+		return -1
+	}
+	return math.Round(f*10000) / 10000
+}
+
+// patternHealth 一眼判定 pattern 召回是「有生产者」还是「恒 0」。
+//
+// 为什么需要它：2026-10-26 排查发现 pattern 召回 0 命中，真根因是写入端从未产数
+// （detect 端点无 cron、无调用方），但表面症状看起来像读侧 SQL bug —— 白查一轮方向。
+// 判据三类：
+//
+//	producing    有行、有 id、有生产时间 → 读侧再 0 命中就该查 Match 阈值/properties；
+//	zero_output  0 行 → 生产端问题，别去动读侧 SQL；
+//	no_id        有行但 id 全空 → store.ListPatterns 会全 skip（存量冻结的典型形态）。
+func patternHealth(a *API) map[string]interface{} {
+	out := map[string]interface{}{
+		"rows":             -1, // -1 = 未知，别当 0 用
+		"rows_with_id":     -1,
+		"last_produced_at": "",
+		"verdict":          "unknown",
+	}
+	if a == nil || a.GraphStore == nil {
+		out["verdict"] = "no_graph_store"
+		return out
+	}
+	rows, withID, last := a.GraphStore.CountNodesByType("pattern")
+	out["rows"], out["rows_with_id"], out["last_produced_at"] = rows, withID, last
+	switch {
+	case rows == 0:
+		out["verdict"] = "zero_output"
+	case withID == 0:
+		out["verdict"] = "no_id"
+	case last == "":
+		out["verdict"] = "unknown_age"
+	default:
+		out["verdict"] = "producing"
+	}
+	return out
+}

go/internal/api/routes/selfcheck_test.go

@@ -0,0 +1,99 @@
+package routes
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// 快照契约测试：/api/v1/selfcheck?level=full 依赖 tools/selfcheck_full.py 的产出格式。
+// 这里钉住 schema_version 与关键字段，防止 python 侧改字段名后 Go 侧静默返回空。
+func TestLoadQualitySnapshot(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "zhiyi-quality.json")
+	body := `{
+	  "schema_version": 1,
+	  "generated_at": "2026-10-26T13:20:00+0800",
+	  "source": {"db": "/var/lib/memoryweave", "table": "memories", "mode": "read_only_projection"},
+	  "duration_ms": 1680,
+	  "quality": {
+	    "frag_len": 20, "total_rows": 39957, "live_rows": 39836,
+	    "frag_rows_all": 313, "frag_rate_all": 0.0078,
+	    "frag_rows_live": 313, "frag_rate_live": 0.0079,
+	    "dup_groups": 34, "dup_extra_rows": 103, "dup_rate": 0.0026,
+	    "new_rows_7d": 1176, "new_frag_rows_7d": 35, "new_frag_rate_7d": 0.0298
+	  },
+	  "write_volume": {
+	    "days": [{"date": "2026-10-25", "rows": 1473, "live": 1471}],
+	    "today": 332, "today_date": "2026-10-26", "last_7d": 7706, "nonzero_days": 60
+	  }
+	}`
+	if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("ZHIYI_QUALITY_SNAPSHOT", p)
+
+	snap, err := loadQualitySnapshot()
+	if err != nil {
+		t.Fatalf("loadQualitySnapshot: %v", err)
+	}
+	if snap.SchemaVersion != 1 {
+		t.Fatalf("schema_version=%d want 1", snap.SchemaVersion)
+	}
+
+	var q struct {
+		TotalRows   int     `json:"total_rows"`
+		LiveRows    int     `json:"live_rows"`
+		DupRate     float64 `json:"dup_rate"`
+		FragRowsAll int     `json:"frag_rows_all"`
+	}
+	if err := json.Unmarshal(snap.Quality, &q); err != nil {
+		t.Fatalf("quality 段解析失败: %v", err)
+	}
+	if q.TotalRows != 39957 || q.LiveRows != 39836 {
+		t.Fatalf("quality 口径不符: %+v", q)
+	}
+	if q.FragRowsAll != 313 || q.DupRate != 0.0026 {
+		t.Fatalf("quality 数值不符: %+v", q)
+	}
+
+	var wv struct {
+		Today int `json:"today"`
+		Days  []struct {
+			Date string `json:"date"`
+			Live int    `json:"live"`
+		} `json:"days"`
+	}
+	if err := json.Unmarshal(snap.WriteVolume, &wv); err != nil {
+		t.Fatalf("write_volume 段解析失败: %v", err)
+	}
+	if wv.Today != 332 || len(wv.Days) != 1 || wv.Days[0].Live != 1471 {
+		t.Fatalf("write_volume 不符: %+v", wv)
+	}
+
+	// 新鲜度：刚写的文件 age 应 < 10s；人为改旧 → stale 判定为真
+	if age := snap.AgeSeconds(); age < 0 || age > 10 {
+		t.Fatalf("AgeSeconds=%d，本应接近 0", age)
+	}
+	old := time.Now().Add(-8 * time.Hour)
+	if err := os.Chtimes(p, old, old); err != nil {
+		t.Fatal(err)
+	}
+	snap2, err := loadQualitySnapshot()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if snap2.AgeSeconds() <= qualityStaleAfter {
+		t.Fatalf("8h 前的快照应判 stale（>%d 秒），得到 %d", qualityStaleAfter, snap2.AgeSeconds())
+	}
+}
+
+// 快照缺失 ⇒ 必须报错（由 handler 转成 degraded），不能静默返回零值。
+func TestLoadQualitySnapshotMissing(t *testing.T) {
+	t.Setenv("ZHIYI_QUALITY_SNAPSHOT", filepath.Join(t.TempDir(), "nope.json"))
+	if _, err := loadQualitySnapshot(); err == nil {
+		t.Fatal("缺失快照应返回 error")
+	}
+}

go/internal/api/routes/skillref.go

@@ -0,0 +1,382 @@
+package routes
+
+// 方案二 · 召回增强（2026-10-31）
+//
+// 背景（20 题真实问题实测）：
+//   · 能答 30% / 答不了 30% / 答错 10%
+//   · 6 道"答不了"里 **5 道的答案在 skill 文档里**，从来没进过 memories 表
+//     ⇒ 知识(稳定方法，进 skill) 与 记忆(会变事实，进 memories) 是两套互不相通的库
+//   · derived_from 有真指针的 42.8%，其中 99.9% 能找回原文（断链仅 10 条）
+//
+// 本文件提供两个"只读增强"，都是可降级的（任何一步失败 ⇒ 返回空，不影响主流程）：
+//   SkillRefsFor(query)     —— 复用 ~/.hermes/skills/.vec.npy（skill-find.py 的现成索引），
+//                              不新建索引、不重复造轮子
+//   SourceExcerpts(ids)     —— 按 memories.derived_from 批量取 episode 原文（一次查询，不逐条）
+//
+// 安全约定：
+//   · 任何异常（索引缺失 / 服务不可用 / 字段为空）⇒ 返回 nil，主召回零影响
+//   · 输出走 omitempty，旧调用方无感
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"log"
+	"math"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// SkillRef 一条相关技能引用（只给名字与相似度，不返回正文 —— 调用方需要时自己加载）
+type SkillRef struct {
+	Name  string  `json:"name"`
+	Score float64 `json:"score"`
+}
+
+var (
+	skillVecOnce sync.Once
+	skillVecMat  [][]float32 // L2 归一化后的向量
+	skillVecMeta []struct {
+		Path string `json:"path"`
+		Name string `json:"name"`
+	}
+	skillVecOK bool
+)
+
+func skillEmbedURL() string {
+	if v := os.Getenv("BGE_EMBED_URL"); v != "" {
+		return v
+	}
+	return "http://127.0.0.1:8000/v1/embeddings"
+}
+
+// loadSkillVecIndex 懒加载 skill 向量索引（.vec.npy 由 skill-find.py 维护）
+// 解析 .npy 的最小实现：只支持 float32 C 序 2 维数组，避免引入 numpy 依赖
+func loadSkillVecIndex() bool {
+	skillVecOnce.Do(func() {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return
+		}
+		idxPath := filepath.Join(home, ".hermes", "skills", ".vec.npy")
+		metaPath := filepath.Join(home, ".hermes", "skills", ".vec-meta.json")
+
+		raw, err := os.ReadFile(idxPath)
+		if err != nil {
+			log.Printf("[skillref] 索引缺失，跳过：%v", err)
+			return
+		}
+		mat, ok := parseNPYFloat32(raw)
+		if !ok {
+			log.Printf("[skillref] .npy 解析失败，跳过")
+			return
+		}
+		mraw, err := os.ReadFile(metaPath)
+		if err != nil {
+			return
+		}
+		if err := json.Unmarshal(mraw, &skillVecMeta); err != nil {
+			return
+		}
+		if len(skillVecMeta) != len(mat) {
+			log.Printf("[skillref] 索引/meta 长度不一致(%d vs %d)，跳过", len(mat), len(skillVecMeta))
+			return
+		}
+		skillVecMat = mat
+		skillVecOK = true
+		log.Printf("[skillref] skill 向量索引就绪：%d 条", len(mat))
+	})
+	return skillVecOK
+}
+
+// parseNPYFloat32 极简 .npy 解析（仅 float32、C 序、2 维）
+// 格式：magic(6) ver(2) headerlen(2, little) header(headerlen) data...
+func parseNPYFloat32(b []byte) ([][]float32, bool) {
+	if len(b) < 10 || !bytes.HasPrefix(b, []byte("\x93NUMPY")) {
+		return nil, false
+	}
+	hlen := int(uint16(b[8]) | uint16(b[9])<<8)
+	if len(b) < 10+hlen {
+		return nil, false
+	}
+	header := string(b[10 : 10+hlen])
+	data := b[10+hlen:]
+
+	// 只接受 float32
+	if !strings.Contains(header, "f4") {
+		return nil, false
+	}
+	// 解析 shape：numpy header 里写作 `'shape': (626, 1024)`
+	si := strings.Index(header, "'shape'")
+	if si < 0 {
+		return nil, false
+	}
+	shapeStr := header[si:]
+	open := strings.Index(shapeStr, "(")
+	closeI := strings.Index(shapeStr, ")")
+	if open < 0 || closeI < 0 || closeI <= open {
+		return nil, false
+	}
+	parts := strings.Split(shapeStr[open+1:closeI], ",")
+	if len(parts) < 2 {
+		return nil, false
+	}
+	var rows, cols int
+	if _, err := jsonNumber(strings.TrimSpace(parts[0]), &rows); err != nil {
+		return nil, false
+	}
+	if _, err := jsonNumber(strings.TrimSpace(parts[1]), &cols); err != nil {
+		return nil, false
+	}
+	if rows <= 0 || cols <= 0 || len(data) < rows*cols*4 {
+		return nil, false
+	}
+	out := make([][]float32, rows)
+	for i := 0; i < rows; i++ {
+		vec := make([]float32, cols)
+		for j := 0; j < cols; j++ {
+			off := (i*cols + j) * 4
+			u := binary.LittleEndian.Uint32(data[off : off+4])
+			vec[j] = math.Float32frombits(u)
+		}
+		out[i] = vec
+	}
+	return out, true
+}
+
+// jsonNumber 解析头部里的整数（形如 "3" 或 " 3"）
+func jsonNumber(s string, out *int) (int, error) {
+	n := 0
+	got := false
+	for _, c := range s {
+		if c >= '0' && c <= '9' {
+			n = n*10 + int(c-'0')
+			got = true
+		} else if got {
+			break
+		}
+	}
+	if !got {
+		return 0, errBadShape
+	}
+	*out = n
+	return n, nil
+}
+
+var errBadShape = &shapeErr{}
+
+type shapeErr struct{}
+
+func (*shapeErr) Error() string { return "bad shape" }
+
+// aliasTable 中文专名 → 英文项目名/同义词。
+// 实测（2026-10-31）：bge-m3 对「织忆」与 memoryweave/zhiyi 的余弦距离很远，
+// 单用原句检索 top1 命中率 50%；扩展别名后 6/6 全部命中正确族（0.80→0.85）。
+// 这是"语义距离"问题，不是"索引粒度"问题 —— 换 chunk 级索引解决不了。
+var (
+	aliasOnce sync.Once
+	aliases   map[string][]string
+	terms     map[string][]string // 专属术语 → 所属实体（query 未点名实体时注入）
+)
+
+func loadAliases() map[string][]string {
+	aliasOnce.Do(func() {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return
+		}
+		raw, err := os.ReadFile(filepath.Join(home, ".hermes", "skills", ".aliases.json"))
+		if err != nil {
+			log.Printf("[skillref] 别名表缺失，跳过扩展：%v", err)
+			return
+		}
+		var f struct {
+			Aliases map[string][]string `json:"aliases"`
+			Terms   map[string][]string `json:"_terms"`
+		}
+		if err := json.Unmarshal(raw, &f); err != nil {
+			log.Printf("[skillref] 别名表解析失败：%v", err)
+			return
+		}
+		aliases = f.Aliases
+		terms = f.Terms
+		delete(aliases, "_comment")
+		delete(aliases, "_version")
+		log.Printf("[skillref] 别名表就绪：%d 别名 + %d 术语组", len(aliases), len(terms))
+	})
+	return aliases
+}
+
+// expandQuery 命中别名 ⇒ 追加同义词。总追加长度上限 60 字符（防噪声淹没原句）。
+func expandQuery(q string) string {
+	tbl := loadAliases()
+	if len(tbl) == 0 {
+		return q
+	}
+	// ① 专属术语注入：query 没点名实体，但出现了该实体的专属标识符
+	//    （如 "FTS 覆盖率为什么只有 48%" 未提「织忆」，但 FTS/fts_index 是织忆专属）
+	base := q
+	for entity, termList := range terms {
+		if strings.Contains(base, entity) {
+			continue // 已点名，不必注入
+		}
+		hit := false
+		for _, t := range termList {
+			if t != "" && strings.Contains(base, t) {
+				hit = true
+				break
+			}
+		}
+		if hit {
+			base = base + " " + entity
+			if syns := tbl[entity]; len(syns) > 0 {
+				base = base + " " + strings.Join(syns, " ")
+			}
+			break // 只注入一个实体，防多实体互相污染
+		}
+	}
+	q = base
+	var extras []string
+	budget := 60
+	for k, syns := range tbl {
+		if !strings.Contains(q, k) && !strings.Contains(strings.ToLower(q), strings.ToLower(k)) {
+			continue
+		}
+		for _, s := range syns {
+			if strings.Contains(q, s) {
+				continue // 原句已有，不重复
+			}
+			if len([]rune(s)) > budget {
+				break
+			}
+			extras = append(extras, s)
+			budget -= len([]rune(s)) + 1
+			if budget <= 0 {
+				break
+			}
+		}
+		if budget <= 0 {
+			break
+		}
+	}
+	if len(extras) == 0 {
+		return q
+	}
+	out := q + " " + strings.Join(extras, " ")
+	if env := os.Getenv("ZHIYI_SKILLREF_DEBUG"); env == "1" {
+		log.Printf("[skillref] query 扩展: %q → %q", q, out)
+	}
+	return out
+}
+
+// SkillRefsFor 查询 → 相关 skill 名单（top-k）。任何失败返回 nil。
+func SkillRefsFor(query string, topk int) []SkillRef {
+	if topk <= 0 {
+		topk = 5
+	}
+	if os.Getenv("ZHIYI_RECALL_SKILLREFS") == "0" {
+		return nil
+	}
+	if !loadSkillVecIndex() {
+		return nil
+	}
+	// 2026-10-31 提精度：先做别名扩展再编码（语义距离问题，见 expandQuery 注释）
+	qv, ok := embedQuery(expandQuery(query))
+	if !ok {
+		return nil
+	}
+	type sc struct {
+		i int
+		s float64
+	}
+	scores := make([]sc, 0, len(skillVecMat))
+	for i, v := range skillVecMat {
+		scores = append(scores, sc{i, dot(qv, v)})
+	}
+	sort.Slice(scores, func(a, b int) bool { return scores[a].s > scores[b].s })
+
+	out := make([]SkillRef, 0, topk)
+	seen := map[string]bool{}
+	for _, s := range scores {
+		if len(out) >= topk {
+			break
+		}
+		// 扩展后正确族分数 0.78~0.86；未触发的原句高分 0.66~0.70。
+		// 0.62 是「宁可给低分线索也别返回空」的取舍 —— 返回空等于没这功能。
+		if s.s < 0.62 {
+			break
+		}
+		name := skillVecMeta[s.i].Name
+		if name == "" {
+			name = strings.TrimSuffix(filepath.Base(skillVecMeta[s.i].Path), ".md")
+		}
+		if seen[name] {
+			continue
+		}
+		seen[name] = true
+		out = append(out, SkillRef{Name: name, Score: round3(s.s)})
+	}
+	return out
+}
+
+func embedQuery(q string) ([]float32, bool) {
+	body, _ := json.Marshal(map[string]any{"input": []string{q}, "model": "bge-m3"})
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Post(skillEmbedURL(), "application/json", bytes.NewReader(body))
+	if err != nil {
+		return nil, false
+	}
+	defer resp.Body.Close()
+	var out struct {
+		Data []struct {
+			Embedding []float32 `json:"embedding"`
+		} `json:"data"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil || len(out.Data) == 0 {
+		return nil, false
+	}
+	v := out.Data[0].Embedding
+	var norm float64
+	for _, x := range v {
+		norm += float64(x) * float64(x)
+	}
+	if norm == 0 {
+		return nil, false
+	}
+	inv := float32(1 / sqrt(norm))
+	for i := range v {
+		v[i] *= inv
+	}
+	return v, true
+}
+
+func dot(a, b []float32) float64 {
+	if len(a) != len(b) {
+		return 0
+	}
+	var s float64
+	for i := range a {
+		s += float64(a[i]) * float64(b[i])
+	}
+	return s
+}
+
+func sqrt(x float64) float64 {
+	if x <= 0 {
+		return 0
+	}
+	z := x
+	for i := 0; i < 30; i++ {
+		z = (z + x/z) / 2
+	}
+	return z
+}
+
+func round3(f float64) float64 {
+	return float64(int(f*1000+0.5)) / 1000
+}

go/internal/api/routes/skillref_test.go

@@ -0,0 +1,39 @@
+package routes
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestNPYParse 验证能解析 skill-find.py 维护的真实索引
+func TestNPYParse(t *testing.T) {
+	home, _ := os.UserHomeDir()
+	p := filepath.Join(home, ".hermes", "skills", ".vec.npy")
+	raw, err := os.ReadFile(p)
+	if err != nil {
+		t.Skip("索引不存在:", err)
+	}
+	mat, ok := parseNPYFloat32(raw)
+	if !ok {
+		t.Fatalf(".npy 解析失败，前 200 字节: %q", raw[:min(200, len(raw))])
+	}
+	if len(mat) == 0 {
+		t.Fatal("解析出 0 行")
+	}
+	t.Logf("解析成功: %d 行 × %d 维", len(mat), len(mat[0]))
+}
+
+// TestSkillRefsFor 端到端：真实查询能拿到 skill_refs
+func TestSkillRefsFor(t *testing.T) {
+	if os.Getenv("ZHIYI_SKILLREF_E2E") != "1" {
+		t.Skip("set ZHIYI_SKILLREF_E2E=1 才跑（依赖 bge 服务）")
+	}
+	refs := SkillRefsFor("织忆部署时 Go 和 Rust 二进制的启停顺序", 3)
+	if len(refs) == 0 {
+		t.Fatal("skill_refs 为空")
+	}
+	for _, r := range refs {
+		t.Logf("  %s %.3f", r.Name, r.Score)
+	}
+}

go/internal/api/routes/skillrefs.go

@@ -0,0 +1,594 @@
+// 织忆 MemoryWeave — recall 第二路：skill 分节检索（t_e3f5cb79 · 2026-10-31 方案 B1）
+//
+// 根因（方案「验证结果（2026-11-02）」节）：知识与记忆是两套互不相通的库 ——
+// 「怎么做/为什么」类答案稳定落在 skill 文档（部署顺序/缓存分层/排障步骤），
+// 从来不进 memories 表；recall 只查前者 ⇒ 答不了。
+//
+// 本文件 = recall 的第二路（分栏返回，不混排）：
+//
+//	· 索引源 ~/.hermes/skills/**/*.md（env ZHIYI_SKILLS_DIR 可覆盖；3545 档 / 27MB）
+//	· 分节（H2~H4 标题切段）+ 关键词匹配（ASCII token 整词 + CJK bigram），
+//	  纯 stdlib，零新依赖、零外部服务（不依赖 embed/LLM —— 10-31 向量前案
+//	  依赖 .vec.npy + embed 服务，shape 也不满足本卡 AC，见卡评论裁定 4）
+//	· 输出顶层 `skill_refs: [{path, snippet, matched}]`；`results`（记忆路）
+//	  结构一字不动，两路内容互不混入（AC-2.4，结构上保证）
+//	· 开关 ZHIYI_RECALL_SKILLREFS（默认关；每次读 env，测试可翻转）
+//	· 任何失败（目录缺失/IO 错误/查询为空）⇒ 返回空数组，主召回零影响
+//
+// 精度取向（对齐方案验证节教训「先拿真实问题量一下」）：
+//
+//	· ASCII 标识符权重高（RedisCache/ZHIYI_* 这类精确 token 是主要判别信号）
+//	· CJK bigram 按段落长度做 sqrt 归一，防长段落靠撞 bigram 霸榜
+//	· 每个文件只出最高分一节（top-3 文件），避免同文件刷屏
+package routes
+
+import (
+	"log"
+	"math"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+	"unicode"
+)
+
+// SkillSectionRef 一条 skill 片段引用（AC-2.1 形状：path/snippet/matched）。
+type SkillSectionRef struct {
+	Path    string   `json:"path"`
+	Snippet string   `json:"snippet"`
+	Matched []string `json:"matched"`
+	Score   float64  `json:"-"` // 排序分（仅回归/调试可见；AC-2.1 线格式仍为 path/snippet/matched）
+}
+
+// skillSection 索引单元：一个 Markdown 分节。
+type skillSection struct {
+	path      string // 绝对路径
+	title     string // 分节标题（无标题=文件名）
+	lower     string // 正文小写（ASCII 匹配用）
+	runeLen   int    // 正文字符数（长度归一用）
+	titleLow  string // 标题小写（标题命中加权）
+	isSkillMd bool   // SKILL.md 主文档（权威综述先验）
+}
+
+type skillRefIndex struct {
+	sections   []*skillSection
+	builtAt    time.Time
+	avgRuneLen float64
+}
+
+var (
+	skillIdxMu    sync.RWMutex
+	skillIdxCache *skillRefIndex
+)
+
+const (
+	skillRefRebuildEvery = 10 * time.Minute
+	skillRefMaxFileBytes = 512 * 1024
+	skillRefMaxSection   = 8000 // rune
+	skillRefSnippetRunes = 200
+)
+
+// skillRefsEnabled 第二路开关（默认关 = 现网零变化；unit drop-in 置 1 启用）。
+func skillRefsEnabled() bool {
+	switch strings.ToLower(strings.TrimSpace(os.Getenv("ZHIYI_RECALL_SKILLREFS"))) {
+	case "1", "true", "on":
+		return true
+	}
+	return false
+}
+
+func skillRefsDir() string {
+	if v := strings.TrimSpace(os.Getenv("ZHIYI_SKILLS_DIR")); v != "" {
+		return v
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(home, ".hermes", "skills")
+}
+
+// headingRe H2~H4 标题行 = 分节边界。
+var headingRe = regexp.MustCompile(`^#{2,4}\s+(.*)$`)
+
+// buildSkillRefIndex 扫目录建分节索引（失败返回 nil，调用方降级空数组）。
+func buildSkillRefIndex(dir string) *skillRefIndex {
+	if dir == "" {
+		return nil
+	}
+	idx := &skillRefIndex{builtAt: time.Now()}
+	var walkErr int
+	_ = filepath.WalkDir(dir, func(p string, d os.DirEntry, err error) error {
+		if err != nil {
+			walkErr++
+			return nil // 单点 IO 失败不中断整体
+		}
+		if d.IsDir() {
+			// 隐藏目录（.archive/.vec 缓存等）不进索引
+			if p != dir && strings.HasPrefix(d.Name(), ".") {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if !strings.HasSuffix(d.Name(), ".md") {
+			return nil
+		}
+		if fi, e := d.Info(); e != nil || fi.Size() > skillRefMaxFileBytes {
+			return nil
+		}
+		raw, e := os.ReadFile(p)
+		if e != nil {
+			walkErr++
+			return nil
+		}
+		addSkillFile(idx, p, string(raw))
+		return nil
+	})
+	log.Printf("[skillrefs] 索引就绪：sections=%d walk_errors=%d dir=%s 用时=%s",
+		len(idx.sections), walkErr, dir, time.Since(idx.builtAt).Round(time.Millisecond))
+	if len(idx.sections) == 0 {
+		return nil
+	}
+	var sum int
+	for _, s := range idx.sections {
+		sum += s.runeLen
+	}
+	idx.avgRuneLen = float64(sum) / float64(len(idx.sections))
+	return idx
+}
+
+// addSkillFile 按 H2~H4 切节；YAML frontmatter 跳过。
+func addSkillFile(idx *skillRefIndex, path, content string) {
+	lines := strings.Split(content, "\n")
+	i := 0
+	// frontmatter
+	if len(lines) > 0 && strings.TrimSpace(lines[0]) == "---" {
+		for j := 1; j < len(lines); j++ {
+			if strings.TrimSpace(lines[j]) == "---" {
+				i = j + 1
+				break
+			}
+		}
+	}
+	title := "(front)"
+	var body strings.Builder
+	flush := func() {
+		txt := strings.TrimSpace(body.String())
+		if txt == "" && title == "(front)" {
+			return
+		}
+		if txt == "" {
+			return // 只有标题没有正文的分节不进索引
+		}
+		rs := []rune(txt)
+		if len(rs) > skillRefMaxSection {
+			txt = string(rs[:skillRefMaxSection])
+		}
+		idx.sections = append(idx.sections, &skillSection{
+			path:      path,
+			title:     title,
+			lower:     strings.ToLower(txt),
+			runeLen:   len(rs),
+			titleLow:  strings.ToLower(title),
+			isSkillMd: filepath.Base(path) == "SKILL.md",
+		})
+	}
+	for ; i < len(lines); i++ {
+		if m := headingRe.FindStringSubmatch(lines[i]); m != nil {
+			flush()
+			body.Reset()
+			title = strings.TrimSpace(m[1])
+			continue
+		}
+		body.WriteString(lines[i])
+		body.WriteByte('\n')
+	}
+	flush()
+}
+
+// getSkillRefIndex 取索引（懒建 + 定期重建；重建阻塞在锁内，一次尖刺可接受）。
+func getSkillRefIndex() *skillRefIndex {
+	skillIdxMu.RLock()
+	idx := skillIdxCache
+	skillIdxMu.RUnlock()
+	if idx != nil && time.Since(idx.builtAt) < skillRefRebuildEvery {
+		return idx
+	}
+	dir := skillRefsDir()
+	newIdx := buildSkillRefIndex(dir)
+	if newIdx == nil {
+		return idx // 建索引失败：保留旧索引（可能为 nil = 空）
+	}
+	skillIdxMu.Lock()
+	skillIdxCache = newIdx
+	skillIdxMu.Unlock()
+	return newIdx
+}
+
+// skillStopCJK 疑问/系词/量词类停用字：含这些字的 bigram 不参与打分 ——
+// 真实语料实测「有哪些」类疑问句在全库高频共现，不排除则疑问句段落霸榜
+// （2026-11-03 调试：q=织忆有哪些缓存层 时 [有哪 哪些] 组合霸榜 8/10）。
+var skillStopCJK = map[rune]bool{
+	'有': true, '哪': true, '些': true, '什': true, '么': true, '怎': true, '样': true,
+	'如': true, '何': true, '是': true, '的': true, '了': true, '吗': true, '呢': true,
+	'和': true, '与': true, '或': true, '在': true, '对': true, '从': true, '里': true,
+	'多': true, '少': true, '谁': true, '几': true, '该': true, '吧': true, '呀': true,
+}
+
+func isHan(r rune) bool { return unicode.Is(unicode.Han, r) }
+
+// skillGlossary 微型近义/中英扩展表（查询侧，只扩 1 跳）：
+// 纯词面匹配桥不过的真实案例（2026-11-03 调试）——「缓存层」文档写 `RedisCache`、
+// 「启动顺序」文档写「部署时序」。表刻意小：只收运维域高频等价对。
+// 扩展词用 Contains 匹配（cache 允许出现在 RedisCache 内），权重 ×0.8。
+var skillGlossary = map[string][]string{
+	"缓存": {"cache"}, "启动": {"重启", "部署"}, "重启": {"启动", "部署"},
+	"部署": {"启动", "重启"}, "顺序": {"时序", "次序"}, "时序": {"顺序"},
+	"端口": {"port"}, "服务": {"service"},
+}
+
+func skillExpand(cjk []string) []string {
+	out := []string{}
+	for _, t := range cjk {
+		for _, syn := range skillGlossary[t] {
+			out = append(out, syn)
+		}
+	}
+	return dedupeTerms(out)
+}
+
+// filterOut 去掉已存在于 have 的词。
+func filterOut(terms, have []string) []string {
+	seen := make(map[string]bool, len(have))
+	for _, h := range have {
+		seen[h] = true
+	}
+	out := terms[:0:0]
+	for _, t := range terms {
+		if !seen[t] {
+			out = append(out, t)
+		}
+	}
+	return out
+}
+
+// skillQueryTerms 查询分词：ASCII token（≥2 字符，小写）+ CJK bigram（停用字过滤）。
+func skillQueryTerms(q string) (ascii, cjk []string) {
+	var cur strings.Builder
+	flushASCII := func() {
+		if cur.Len() >= 2 {
+			ascii = append(ascii, cur.String())
+		}
+		cur.Reset()
+	}
+	rs := []rune(q)
+	// CJK bigram（过滤停用字 bigram）
+	var run []rune
+	flushRun := func() {
+		for k := 0; k+1 < len(run); k++ {
+			if skillStopCJK[run[k]] || skillStopCJK[run[k+1]] {
+				continue
+			}
+			cjk = append(cjk, string(run[k:k+2]))
+		}
+		run = run[:0]
+	}
+	for _, r := range rs {
+		switch {
+		case unicode.Is(unicode.Han, r):
+			flushASCII()
+			run = append(run, r)
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '_', r == '-':
+			flushRun()
+			cur.WriteRune(unicode.ToLower(r))
+		default:
+			flushASCII()
+			flushRun()
+		}
+	}
+	flushASCII()
+	flushRun()
+	return dedupeTerms(ascii), dedupeTerms(cjk)
+}
+
+func dedupeTerms(in []string) []string {
+	seen := make(map[string]bool, len(in))
+	out := in[:0:0]
+	for _, s := range in {
+		if !seen[s] {
+			seen[s] = true
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+// wordCount 词边界计数：token 前后不能贴字母/数字（防 `go` 命中 golang/google、
+// `rust` 命中 x-rustc 之类子串噪声 —— 真实语料实测短 token 子串匹配 df 虚高）。
+var wordBoundaryOK = func(b byte) bool {
+	return !(b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z' || b >= '0' && b <= '9' || b == '_')
+}
+
+func wordCount(lower, token string) int {
+	n, from := 0, 0
+	for {
+		i := strings.Index(lower[from:], token)
+		if i < 0 {
+			return n
+		}
+		i += from
+		j := i + len(token)
+		beforeOK := i == 0 || wordBoundaryOK(lower[i-1])
+		afterOK := j == len(lower) || wordBoundaryOK(lower[j])
+		if beforeOK && afterOK {
+			n++
+		}
+		from = i + 1
+	}
+}
+
+// skillRefsForQuery 第二路检索入口：query → top-n skill 分节引用。
+// 关闭/无索引/空查询 ⇒ 空切片（非 nil，JSON 序列化为 []）。
+// 打分 = BM25（k1=1.5, b=0.75；tf 饱和 + 平均长度归一，标准 IR 做法）：
+// 2026-11-03 调试教训 —— 自造线性权重在 37k 分节真实语料上被「疑问句共现」
+// 与「长度/稀有 bigram」反复带偏，换教科书公式一次到位。
+func skillRefsForQuery(query string, n int) []SkillSectionRef {
+	out := []SkillSectionRef{}
+	if !skillRefsEnabled() {
+		return out
+	}
+	idx := getSkillRefIndex()
+	if idx == nil {
+		return out
+	}
+	ascii, cjk := skillQueryTerms(query)
+	if len(ascii) == 0 && len(cjk) == 0 {
+		return out
+	}
+	if n <= 0 || n > 30 {
+		n = 3
+	}
+
+	type hit struct {
+		sec     *skillSection
+		score   float64
+		matched []string
+	}
+	// 单字兜底通道词条：查询里的非停用汉字（去重）
+	queryUnigrams := []string{}
+	seenU := map[rune]bool{}
+	for _, r := range query {
+		if isHan(r) && !skillStopCJK[r] && !seenU[r] {
+			seenU[r] = true
+			queryUnigrams = append(queryUnigrams, string(r))
+		}
+	}
+
+	// 扩展通道词（近义/中英，Contains 匹配）
+	expanded := skillExpand(cjk)
+	expanded = filterOut(expanded, append(append([]string{}, cjk...), ascii...))
+
+	// df 预扫（一遍 Contains）
+	df := make(map[string]int, len(ascii)+len(cjk))
+	unigramDF := make(map[string]int, len(queryUnigrams))
+	expandedDF := make(map[string]int, len(expanded))
+	for _, sec := range idx.sections {
+		for _, t := range ascii {
+			if wordCount(sec.lower, t) > 0 {
+				df[t]++
+			}
+		}
+		for _, t := range cjk {
+			if strings.Contains(sec.lower, t) {
+				df[t]++
+			}
+		}
+		for _, r := range queryUnigrams {
+			if strings.Contains(sec.lower, r) {
+				unigramDF[r]++
+			}
+		}
+		for _, t := range expanded {
+			if strings.Contains(sec.lower, t) {
+				expandedDF[t]++
+			}
+		}
+	}
+	total := float64(len(idx.sections))
+	bmIDF := func(d int) float64 {
+		return math.Log(1 + (total-float64(d)+0.5)/(float64(d)+0.5))
+	}
+	avgLen := idx.avgRuneLen
+	if avgLen <= 0 {
+		avgLen = 600
+	}
+	const k1, b = 1.5, 0.75
+	bm := func(tf int, idf, secLen float64) float64 {
+		if tf == 0 {
+			return 0
+		}
+		return idf * float64(tf) * (k1 + 1) / (float64(tf) + k1*(1-b+b*secLen/avgLen))
+	}
+
+	hits := make([]hit, 0, 64)
+	for _, sec := range idx.sections {
+		score := 0.0
+		var matched []string
+		secLen := float64(sec.runeLen)
+		for _, t := range ascii {
+			tf := wordCount(sec.lower, t)
+			if tf > 0 {
+				score += 3.0 * bm(tf, bmIDF(df[t]), secLen) // ASCII 标识符是强信号
+				matched = append(matched, t)
+				if strings.Contains(sec.titleLow, t) {
+					score += 2.0 // 标题命中加权
+				}
+			}
+		}
+		for _, t := range cjk {
+			tf := strings.Count(sec.lower, t)
+			if tf > 0 {
+				score += bm(tf, bmIDF(df[t]), secLen)
+				matched = append(matched, t)
+				if strings.Contains(sec.titleLow, t) {
+					score += 1.5
+				}
+			}
+		}
+		for _, t := range expanded {
+			if tf := strings.Count(sec.lower, t); tf > 0 {
+				w := 0.8
+				// 扩展词命中且同节含 ASCII 标识符 → 视为等价强信号，升全权重
+				// （探针② 实测：「部署时序照旧：停先 Go 后 Rust」行需按全词计分
+				// 才能压过 INDEX 目录页的裸词面共现）
+				if len(ascii) > 0 && containsAnyMatched(matched, ascii) {
+					w = 1.0
+				}
+				score += w * bm(tf, bmIDF(expandedDF[t]), secLen)
+				matched = append(matched, "~"+t) // 前缀标扩展命中
+			}
+		}
+		if len(matched) == 0 {
+			continue
+		}
+		// 单字兜底通道：bigram 在语料里是碎片（如「启动顺序」实际文档写「时序」）
+		// 时，内容单字以 0.6 权重补召回（停用字已滤）。
+		for _, r := range queryUnigrams {
+			tf := strings.Count(sec.lower, r)
+			if tf > 0 {
+				score += 0.6 * bm(tf, bmIDF(unigramDF[r]), secLen)
+			}
+		}
+		// SKILL.md = 人写权威综述（references 是案底），同分场景给 15% 先验
+		if sec.isSkillMd {
+			score *= 1.15
+		}
+		if len(ascii) > 0 && !containsAnyMatched(matched, ascii) {
+			// 查询含 ASCII 标识符而本节一个都不含 → 视为未命中该标识符语境，减半
+			score *= 0.5
+		}
+		// 路径题名先验：文件名 = 作者自己标的主题。CJK 词经文件名对照表映射到
+		// ASCII 路径 token（部署→deploy），文件名命中 +3（探针② 实测：目标文档
+		// 正文只写「部署时序」，词面打不过 INDEX 目录页，靠文件名定主题）。
+		// 反查表刻意小（只收 6 对，与 skillGlossary 同源维护）。
+		{
+			pathKey := strings.ToLower(sec.path)
+			fileNameMap := map[string]string{"部署": "deploy", "重启": "restart", "启动": "start",
+				"缓存": "cache", "端口": "port", "健康": "health", "顺序": "order", "指标": "metric"}
+			for _, t := range append(append([]string{}, cjk...), expanded...) {
+				if tok, ok := fileNameMap[t]; ok && strings.Contains(pathKey, tok) {
+					score += 3.0
+					break
+				}
+			}
+		}
+		hits = append(hits, hit{sec: sec, score: score, matched: matched})
+	}
+	// 行级共现加权（只重算前 300 候选，成本可控）：同一行内共现的查询词对数
+	// 是「规则行」的强判别信号 —— AC 探针② 的目标行「部署时序照旧：停先 Go 后
+	// Rust、起先 Rust 后 Go」= 4 词同行。长文散提不配和规则行同分。
+	{
+		allTerms := append(append(append([]string{}, ascii...), cjk...), expanded...)
+		top := hits
+		if len(top) > 300 {
+			sort.SliceStable(top, func(i, j int) bool { return top[i].score > top[j].score })
+			top = top[:300]
+		}
+		for i := range top {
+			best, sum := 0, 0
+			for _, line := range strings.Split(top[i].sec.lower, "\n") {
+				c := 0
+				for _, t := range allTerms {
+					if strings.Contains(line, t) {
+						c++
+					}
+				}
+				if c >= 2 {
+					pairs := c * (c - 1) / 2
+					if pairs > 10 {
+						pairs = 10
+					}
+					if pairs > best {
+						best = pairs
+					}
+					sum += pairs
+				}
+			}
+			// 最佳行主导 + 少量「多处提及」尾部信号（防目录页靠行数刷分）
+			top[i].score += 0.8*float64(best) + 0.15*float64(sum-best)
+		}
+	}
+	sort.SliceStable(hits, func(i, j int) bool { return hits[i].score > hits[j].score })
+
+	// 每文件取最高分一节，取前 n 个文件
+	seenPath := map[string]bool{}
+	for _, h := range hits {
+		if seenPath[h.sec.path] {
+			continue
+		}
+		seenPath[h.sec.path] = true
+		out = append(out, SkillSectionRef{
+			Path:    h.sec.path,
+			Snippet: skillSnippet(h.sec.lower, h.matched, ascii, cjk),
+			Matched: topMatched(h.matched, 8),
+			Score:   h.score,
+		})
+		if len(out) >= n {
+			break
+		}
+	}
+	return out
+}
+
+func containsAnyMatched(matched, terms []string) bool {
+	for _, m := range matched {
+		for _, t := range terms {
+			if m == t {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func topMatched(matched []string, n int) []string {
+	if len(matched) <= n {
+		return matched
+	}
+	return matched[:n]
+}
+
+// skillSnippet 首个高权重命中词附近 ±100 rune 窗口，压平空白。
+func skillSnippet(lower string, matched, ascii, cjk []string) string {
+	pref := append(append([]string{}, ascii...), cjk...)
+	rs := []rune(lower)
+	pos := -1
+	for _, t := range pref {
+		i := strings.Index(lower, t)
+		if i >= 0 {
+			// rune 下标近似：按字节 index 换 rune 数（正文已是小写无多字节大小写问题）
+			pos = len([]rune(lower[:i]))
+			break
+		}
+	}
+	if pos < 0 {
+		pos = 0
+	}
+	start := pos - skillRefSnippetRunes/2
+	if start < 0 {
+		start = 0
+	}
+	end := start + skillRefSnippetRunes
+	if end > len(rs) {
+		end = len(rs)
+		start = end - skillRefSnippetRunes
+		if start < 0 {
+			start = 0
+		}
+	}
+	snip := strings.Join(strings.Fields(string(rs[start:end])), " ")
+	return snip
+}

go/internal/api/routes/skillrefs_test.go

@@ -0,0 +1,168 @@
+// B1 第二路 skill 检索回归（t_e3f5cb79 · AC-2）
+//
+// 层 1（离线 fixture）：开关语义、形状 {path,snippet,matched}、分节命中、
+// 查询停用词（「有哪些」类疑问词不得参与打分 —— 否则全库疑问句霸榜）。
+// 层 2（真实语料探针，AC-2.3 ①②；③「淇县招商 memories top1 不变」属线上
+// 行为，由部署后原始输出闭合）：
+//
+//	① q="织忆有哪些缓存层" ⇒ 命中文件正文含 RedisCache 或 L2Cache
+//	② q="Go Rust 启动顺序" ⇒ 命中含「先 Go」的文件（references/zhiyi-deploy-and-metrics.md）
+package routes
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func resetSkillIdxForTest(t *testing.T) {
+	t.Helper()
+	skillIdxMu.Lock()
+	skillIdxCache = nil
+	skillIdxMu.Unlock()
+	t.Cleanup(func() {
+		skillIdxMu.Lock()
+		skillIdxCache = nil
+		skillIdxMu.Unlock()
+	})
+}
+
+func TestSkillRefsDisabledReturnsEmpty(t *testing.T) {
+	resetSkillIdxForTest(t)
+	t.Setenv("ZHIYI_RECALL_SKILLREFS", "")
+	if got := skillRefsForQuery("织忆有哪些缓存层", 5); got == nil || len(got) != 0 {
+		t.Fatalf("开关关必须返回非 nil 空切片（JSON=[]），实际 %#v", got)
+	}
+}
+
+func TestSkillQueryTermsStopwords(t *testing.T) {
+	ascii, cjk := skillQueryTerms("织忆有哪些缓存层")
+	if len(ascii) != 0 {
+		t.Fatalf("纯中文查询不应有 ascii: %v", ascii)
+	}
+	want := map[string]bool{"织忆": true, "缓存": true, "存层": true}
+	for _, s := range cjk {
+		if !want[s] {
+			t.Fatalf("停用词漏网: %v (full=%v)", s, cjk)
+		}
+	}
+	for w := range want {
+		found := false
+		for _, s := range cjk {
+			if s == w {
+				found = true
+			}
+		}
+		if !found {
+			t.Fatalf("实词被误删: %q full=%v", w, cjk)
+		}
+	}
+	// ASCII token 不受停用词影响
+	a2, _ := skillQueryTerms("RedisCache 的 TTL 怎么配")
+	if len(a2) != 2 || a2[0] != "rediscache" || a2[1] != "ttl" {
+		t.Fatalf("ascii terms 错误: %v", a2)
+	}
+}
+
+func writeFixtureSkill(t *testing.T, dir, rel, content string) string {
+	t.Helper()
+	p := filepath.Join(dir, rel)
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+func TestSkillRefsFixtureShapeAndHit(t *testing.T) {
+	resetSkillIdxForTest(t)
+	dir := t.TempDir()
+	p1 := writeFixtureSkill(t, dir, "zhiyi/zhiyi/SKILL.md",
+		"---\nname: zhiyi\n---\n# 织忆\n\n## 现成缓存设施清单\n\n| 设施 | 位置 |\n|---|---|\n| `RedisCache` + `NewRedisCache(ttl)` | storage/redis.go |\n| `L2CacheBackend` + `redisL2Adapter` | storage/searchcache.go |\n\n## 无关段\n\n这里讲图谱 pruning 的宽限期。\n")
+	p2 := writeFixtureSkill(t, dir, "cooking/pancake.md",
+		"# 煎饼\n\n## 做法\n\n面糊醒 20 分钟。全库最常说的「有哪些」句式也写在这。\n")
+
+	t.Setenv("ZHIYI_SKILLS_DIR", dir)
+	t.Setenv("ZHIYI_RECALL_SKILLREFS", "1")
+
+	refs := skillRefsForQuery("织忆有哪些缓存层", 5)
+	if len(refs) == 0 {
+		t.Fatalf("fixture 查询必须命中")
+	}
+	if refs[0].Path != p1 {
+		t.Fatalf("首位应命中 zhiyi SKILL.md，实际 %s", refs[0].Path)
+	}
+	for _, x := range refs {
+		if !strings.HasSuffix(x.Path, ".md") {
+			t.Fatalf("skill_refs 只能指向 md：%s", x.Path)
+		}
+	}
+	_ = p2
+}
+
+func TestSkillRefsRealCorpusProbes(t *testing.T) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		t.Skip("no home")
+	}
+	realDir := filepath.Join(home, ".hermes", "skills")
+	if fi, e := os.Stat(realDir); e != nil || !fi.IsDir() {
+		t.Skipf("真实技能库不存在：%s", realDir)
+	}
+	resetSkillIdxForTest(t)
+	t.Setenv("ZHIYI_SKILLS_DIR", "") // 走默认真实目录
+	t.Setenv("ZHIYI_RECALL_SKILLREFS", "1")
+
+	// 探针①
+	refs := skillRefsForQuery("织忆有哪些缓存层", 5)
+	if len(refs) == 0 {
+		t.Fatalf("探针① skill_refs 为空")
+	}
+	found := false
+	for _, r := range refs {
+		raw, e := os.ReadFile(r.Path)
+		if e != nil {
+			continue
+		}
+		if strings.Contains(string(raw), "RedisCache") || strings.Contains(string(raw), "L2Cache") {
+			found = true
+			t.Logf("探针① 命中：%s matched=%v", r.Path, r.Matched)
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("探针① top3 中没有含 RedisCache/L2Cache 的文件：%v", pathsOf(refs))
+	}
+
+	// 探针②
+	refs = skillRefsForQuery("Go Rust 启动顺序", 5)
+	if len(refs) == 0 {
+		t.Fatalf("探针② skill_refs 为空")
+	}
+	found = false
+	for _, r := range refs {
+		raw, e := os.ReadFile(r.Path)
+		if e != nil {
+			continue
+		}
+		if strings.Contains(string(raw), "先 Go") || strings.Contains(string(raw), "先Go") {
+			found = true
+			t.Logf("探针② 命中：%s matched=%v", r.Path, r.Matched)
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("探针② top3 中没有含「先 Go」的文件：%v", pathsOf(refs))
+	}
+}
+
+func pathsOf(refs []SkillSectionRef) []string {
+	out := make([]string, 0, len(refs))
+	for _, r := range refs {
+		out = append(out, r.Path)
+	}
+	return out
+}

go/internal/api/routes/standing_answers.go

@@ -16,7 +16,7 @@ func standingStore() *storage.StandingStore { return storage.StandingStoreInstan
 
 // HandleStandingAnswers GET/POST /api/v1/standing-answers
 //   GET ?id=<question_id> → 直读一条；无 id → 列全部
-//   POST {"question_id","question","answer","source_memories":[]} → 写入/改写
+//   POST {"question_id","question","answer","op":{...},"source_memories":[]} → 写入/改写
 func HandleStandingAnswers(w http.ResponseWriter, r *http.Request) {
 	s := standingStore()
 	if s == nil {
@@ -47,10 +47,11 @@ func HandleStandingAnswers(w http.ResponseWriter, r *http.Request) {
 		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"`
+			QuestionID     string                `json:"question_id"`
+			Question       string                `json:"question"`
+			Answer         string                `json:"answer"`
+			Op             *storage.OpCard       `json:"op,omitempty"`
+			SourceMemories []string              `json:"source_memories"`
 		}
 		if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
 			respondError(w, http.StatusBadRequest, "bad json: "+err.Error())
@@ -60,7 +61,7 @@ func HandleStandingAnswers(w http.ResponseWriter, r *http.Request) {
 			respondError(w, http.StatusBadRequest, "question_id and answer required")
 			return
 		}
-		a, err := s.Upsert(in.QuestionID, in.Question, in.Answer, in.SourceMemories)
+		a, err := s.Upsert(in.QuestionID, in.Question, in.Answer, in.SourceMemories, in.Op)
 		if err != nil {
 			respondError(w, http.StatusInternalServerError, err.Error())
 			return

go/internal/api/routes/trace.go

@@ -0,0 +1,49 @@
+// 织忆 MemoryWeave — 召回链路追踪端点（P0-1，2026-10-26）
+//
+// GET /api/v1/trace/<trace_id>
+//
+// 返回该次召回的：各阶段耗时（encode/coarse_search/fts_recall/bm25/rerank_fusion/mmr_select/
+// graph_expand/dedupe）、各通道贡献条数（channels）、每条结果的来源归因（items）、
+// status/partial_reason、scope、cache_hit/truncated。
+//
+// 数据来源：内存环形缓冲（最近 2000 条）+ JSONL 落盘（/var/lib/memoryweave/traces/），
+// 服务重启后仍可按 trace_id 回溯（落盘扫描）。
+package routes
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// ── P0-3 召回硬超时：取消函数类型 + context.WithTimeout 包装 ──────────────
+// core.go Recall() 在 req.DeadlineMS>0 时需要带类型标记的取消函数，以便 defer 取消。
+// 2026-10-26 (t_e98cb1d6)：此处补齐使 routes 包可编译（否则 routes 全包不可构建，
+// capRecallResults 的单测无法跑通）。这是缺失的声明，不是功能实现；P0-3 的 trace 完整
+// 接线（tr.Stage 埋点、tr 落盘）仍待 P0-3 本任务补齐。
+type ctxDeadlineFunc context.CancelFunc
+
+func contextWithTimeout(ctx context.Context, timeout time.Duration) (context.Context, ctxDeadlineFunc) {
+	c, cancel := context.WithTimeout(ctx, timeout)
+	return c, ctxDeadlineFunc(cancel)
+}
+
+// Trace 查询单条召回链路。路径形如 /api/v1/trace/tr_xxxx。
+func (a *API) Trace(w http.ResponseWriter, r *http.Request) {
+	id := strings.TrimSpace(strings.TrimPrefix(r.URL.Path, "/api/v1/trace/"))
+	if id == "" {
+		respondErrorSchema(w, 400, "trace_id_required", "用法：GET /api/v1/trace/<trace_id>", 0)
+		return
+	}
+	tr, ok := storage.GetTrace(id)
+	if !ok {
+		// 404 与「trace 过期/被环形缓冲覆盖」同义：调用方据此走「重新召回」而不是当成系统故障。
+		respondErrorSchema(w, 404, "trace_not_found",
+			"trace 不存在或已被环形缓冲覆盖（内存保留最近 2000 条，落盘按天分文件）", 0)
+		return
+	}
+	respond(w, 200, tr)
+}

go/internal/api/routes/zz_commit_conflict_gate_test.go

@@ -80,15 +80,20 @@ func (m *mockLance) IncrementUseful(id string) error                         { r
 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 }
-func (m *mockLance) Update(table, id string, fields map[string]any) error    { return nil }
+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 }
+func (m *mockLance) Update(table, id string, fields map[string]any) error         { return nil }
+func (m *mockLance) GetRecordByID(table, id string) (*models.MemoryRecord, error) { return nil, nil }
 
 // ─── mock: governance.GraphStore (全 no-op) ──────────────────
 
@@ -116,6 +121,7 @@ func (mockGraph) ListNodesByType(nodeType string, namespace string) []map[string
 }
 func (mockGraph) ListNodes(namespace string) []map[string]interface{} { return nil }
 func (mockGraph) Stats() (int, int, float64)                          { return 0, 0, 0 }
+func (mockGraph) CountNodesByType(string) (int, int, string)          { return 0, 0, "" }
 func (mockGraph) Prune(minWeight float64)                             {}
 func (mockGraph) ExpandFromResults(results []models.RecallResult, namespace string, maxHops int) []models.RecallResult {
 	return results

go/internal/api/server.go

@@ -139,6 +139,17 @@ func NewServer() http.Handler {
 		}
 	}()
 
+	// t_cf680fad：启动即 drain durable pending-softdelete 队列。
+	// 上一轮（尤其重启窗口 / 崩掉那轮）因 MVCC 写风暴耗尽而被入队的失败软删，
+	// 此刻风暴已退、sidecar 刚就绪，重放必落盘 —— 这是「不修则每次重启窗口都留新残留」的根治。
+	go func() {
+		time.Sleep(2 * time.Second) // 等 sidecar 完全就绪（比 metrics 的 1s 稍晚，避免抢首提交）
+		if n := storage.PendingSoftDeleteCount(); n > 0 {
+			log.Printf("[pending-softdelete] 启动发现 %d 条待重放，开始 drain", n)
+			storage.DrainPendingSoftDeletes(ldb)
+		}
+	}()
+
 	// 图谱（带 Navigate 结果缓存：TTL 5min，容量 500，热点实体缓存命中加速）
 	// 已在上面初始化
 	graphUpdater := governance.NewAutoGraphUpdater(graphStore)
@@ -176,7 +187,8 @@ func NewServer() http.Handler {
 
 	// ─── t_d32e5f8a L2 模式检测（MemOS 血统）─────────────────────────
 	// 复活 L1→L2 pattern 蒸馏（原 Python daemon main_loop 退役后停摆）：
-	// pattern 节点存 graph_nodes(type='pattern')，与现有 85 存量同表，不另开新表。
+	// pattern 节点存 graph_nodes(type='pattern')，与旧 daemon 残留的 85 行
+	// type='pattern_stat' 同表但不同类，不另开新表。
 	// modernc sqlite 短命单发开/关（UpsertPatterns/ListPatterns 开一次用一次即关），
 	// 不持长连接、不碰 state.db —— 规避当年退役根因。
 	// 召回注入 env 门控 ZHIYI_PATTERN_RECALL，默认 0 ⇒ 不注册 Provider，行为零变化。
@@ -192,6 +204,14 @@ func NewServer() http.Handler {
 	patternAPI.SkillStore = skillgen.NewStore(graphPath)
 	patternAPI.Generator = skillgen.NewLocal2BGenerator()
 	patternAPI.AttachmentsDir = os.Getenv("ZHIYI_SKILL_ATTACHMENTS")
+	// t_9ccbca15（D2 反幻觉）：生成草稿前取 pattern 命中记忆的真实原文注入 prompt。
+	patternAPI.EvidenceProv = skillgen.NewLanceEvidenceProvider(ldb)
+	// t_45677e64（返修 #1）：bge-m3 向量聚类 —— 草稿按主题簇生成，不跨主题拼接。
+	// emb 复用 L2 同款编码客户端（命中缓存、L2 归一化）；端点异常时退化为逐条孤例 ⇒ 最大簇<3 ⇒ 不出草稿。
+	patternAPI.Clusterer = skillgen.NewBGEClusterer(emb.Encode)
+	// t_4594b632：promote 前评审摘要（SkillEvaluator）。本地 2B 重写理由、确定性四维分兜底；
+	// 默认装配（评审信息参考，非 promote 依据）。2B 失败自动回退确定性理由，不阻塞 promote。
+	patternAPI.Evaluator = skillgen.NewLLMEvaluator()
 	if os.Getenv("ZHIYI_PATTERN_RECALL") == "1" {
 		storage.PatternRecallProvider = patternProvider.Match
 		log.Printf("[zhiyid] L2 模式召回注入已启用（ZHIYI_PATTERN_RECALL=1）")
@@ -227,6 +247,14 @@ func NewServer() http.Handler {
 	}
 	distillEngine := distill.NewEngine(llmEndpoint, llmModel, llmAPIKey)
 	routes.DistillEngineRef = distillEngine
+	// t_e11207f8 治源①：加载共享「空壳正文」判据（zhiyi_payload_guard_rules.json，Python/Go 同源）。
+	// 失败 ⇒ fail-open（distill 照跑、不拦空壳、不崩），/api/v1/payload-guard/stats 暴露 loaded=false。
+	if ok, lerr := distill.LoadPayloadGuard(""); ok {
+		_, _, _, rp := distill.PayloadGuardStats()
+		log.Printf("[distill][payload-guard] 空壳判据已加载 rules=%s", rp)
+	} else {
+		log.Printf("[distill][payload-guard] ⚠️ 共享判据未加载（fail-open，不拦空壳）: %v", lerr)
+	}
 	// 蒸馏完成 → 自动图谱更新 + 冲突检测 + 被动验证 + 回写内存
 	distill.OnDistillComplete = func(input distill.DistillInput, result distill.DistillResult) {
 		entityNames := make([]string, len(result.Entities))
@@ -268,6 +296,13 @@ func NewServer() http.Handler {
 			// 这里再脱一次为幂等保险——防止任何中间层注入明文密钥。事故里泄漏进
 			// 镜像的记忆正是从这条路径入库的）。
 			fact = redact.RedactSecrets(fact)
+			// t_e11207f8 治源①：空壳拒写（单一判据 = 共享 zhiyi_payload_guard_rules.json，与 Python 同源）。
+			// 蒸馏 LLM 偶发把「只有溯源指针/占位/纯日期、无知识载荷」的碎片当 fact（如 `证据：文件：…｜日期：…`），
+			// 长度/实体启发式（IsQualityFact）抓不住 ⇒ 落库前用 payload-guard 拦下（未加载时 fail-open）。
+			if distill.ShellCheck(fact) {
+				log.Printf("[distill][payload-guard] 拒写空壳蒸馏 fact episode=%s fact=%.40s", input.EpisodeID, fact)
+				continue
+			}
 			// 查重: 同 namespace 已存在**语义等价**记忆 → 跳过
 			// 必须用 cosine 近重复判据（≥0.98），不能只比字符串相等——
 			// 否则 "牧尘在招商局工作" 与 "牧尘在招商局工作。"（多一个句号）
@@ -298,6 +333,9 @@ func NewServer() http.Handler {
 			// InsertMemory 是 pre-feature 基线行为，必须无条件执行（shadow/off 下
 			// ApplyWriteOp 恒返回 shouldInsert=true ⇒ 下方不再 continue ⇒ 基础插入照跑）。
 			// 唯一丢弃路径 = apply + NOOP（显式记 warning，含候选内容，禁静默）。
+			// AC-1.2（t_e3f5cb79）：真矛盾（CONFLICT-MARK 过判据门）时新行插入必须
+			// 带 supersedes=[旧id]，与旧行 superseded_by=[新id] 构成双向指针。
+			var conflictSupersedes []string
 			if distill.WriteOpsEnabled() {
 				if dupID, dup := distill.WriteOpHashDedup(fact, sim); dup {
 					log.Printf("%s", distill.DedupNote(dupID, fact))
@@ -318,16 +356,47 @@ func NewServer() http.Handler {
 						log.Printf("[write-ops] apply NOOP 丢弃事实（判定=NOOP，候选=%.40s）", fact)
 						continue
 					}
+					// AC-1.2（t_e3f5cb79）：过门的真矛盾 → 新行带 supersedes=[旧id]
+					if verdict.Op == distill.OpConflictMark && verdict.TargetID != "" {
+						conflictSupersedes = []string{verdict.TargetID}
+					}
 				}
 				// verdict==nil（off 未跑判定；理论死分支——off 不进 WriteOpsEnabled 块）
 				// 或 shadow（标记零调用）⇒ 基础插入无条件执行。
 			}
+			// 2026-11-11 存真去伪·阶段 3：确定性版本取代（env ZHIYI_SUPERSEDE=off|shadow|apply，
+			// 默认 off ⇒ 逐字零行为变化）。判据 = SameAttrValueConflict（同主体+同属性+不同取值），
+			// 零 LLM。shadow 只打日志；apply 才把旧行标 superseded + superseded_by + valid_to。
+			// 依据：表里 supersedes/superseded_by 两列全为 '[]'（零使用），旧值永远和新值并存。
+			var supersedeHit distill.SupersedeHit
+			var hasSupersede bool
+			if distill.SupersedeEnabled() {
+				if h, ok := distill.FindSupersedeTarget(fact, sim, qvec); ok {
+					supersedeHit, hasSupersede = h, true
+				}
+			}
+			// t_ab5b2461 信息密度判据（env ZHIYI_DISTILL_DENSITY=1 灰度，默认关）：
+			// 三项判据（①可执行/命令/路径 ②判据/阈值 ③因果）满足 ≥2 项才保持
+			// Category="distilled"；<2 项降级 Category="observe" —— 行照写、量照计
+			// （AC3 写入量不饿死），可召回可逆，只是不再冒充高质量知识形态。
+			// env 关 ⇒ category 恒 "distilled"，与现状逐位等价（AC5）。
+			category := "distilled"
+			if distill.DensityGateEnabled() && !distill.DensityKeep(fact) {
+				category = "observe"
+				log.Printf("[distill][density] 信息量不足(需≥2项判据) → Category=observe episode=%s src=%q fact=%.48s",
+					input.EpisodeID, input.Source, fact)
+			}
+			memID := memIDFor(fact, input)
+			supersedes := conflictSupersedes
+			if hasSupersede {
+				supersedes = append(append([]string{}, supersedes...), supersedeHit.OldID)
+			}
 			mem := models.MemoryRecord{
-				ID:           fmt.Sprintf("mem_%d", time.Now().UnixNano()),
+				ID:           memID,
 				AgentID:      input.AgentID,
 				Namespace:    input.Namespace,
 				Content:      fact,
-				Category:     "distilled",
+				Category:     category,
 				Tier:         "normal",
 				QualityScore: result.Overall,
 				Version:      1,
@@ -338,7 +407,10 @@ func NewServer() http.Handler {
 				// 单条证据；多 episode 聚合由 consolidate 路径补充）
 				SourceEvents: []string{input.EpisodeID},
 				Freshness:    "fresh",
-				Source:       srcOrLLMDistill(input.Source), // 2026-09-26：有笔记出处→"wiki:<路径>"；否则沿用 llm_distill（2026-09-07 方案C provenance）
+				// AC-1.2（t_e3f5cb79）：真矛盾的新行带 supersedes=[旧id]（双向指针的
+				// 新行半边；旧行半边在 ldbWriteOpsStore.MarkConflict 写 superseded_by）。
+				Supersedes: supersedes,
+				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"),
@@ -358,6 +430,84 @@ func NewServer() http.Handler {
 				log.Printf("[distill] commit fact failed: %v", err)
 			} else {
 				factsLanded = true // t_1c12e000：确有 distilled fact 落库
+				// 阶段 3：取代动作分模式执行（shadow 只留痕，不碰库）
+				if hasSupersede {
+					switch distill.SupersedeMode() {
+					case "apply":
+						if uErr := ldb.Update("memories", supersedeHit.OldID, map[string]any{
+							"freshness":     "superseded",
+							"superseded_by": jsonStrList([]string{memID}),
+							"valid_to":      time.Now().Format(time.RFC3339),
+						}); uErr != nil {
+							log.Printf("[supersede][apply] 标旧版失败 old=%s new=%s: %v", supersedeHit.OldID, memID, uErr)
+						} else {
+							log.Printf("[supersede][apply] old=%s → superseded_by=%s sim=%.3f 证据=%s",
+								supersedeHit.OldID, memID, supersedeHit.Sim, supersedeHit.Evidence)
+						}
+					default: // shadow
+						log.Printf("[supersede][shadow] 将顶掉 old=%s new=%s sim=%.3f 证据=%s ep=%s candidate=%.48s",
+							supersedeHit.OldID, memID, supersedeHit.Sim, supersedeHit.Evidence,
+							input.EpisodeID, fact)
+					}
+				}
+			}
+		}
+		// t_2595b626 经验层（ZHIYI_DISTILL_EXPERIENCE=1 灰度，默认关）：EXP 产物落库。
+		// 🔴 不改排序权重（AC5）——只多写 category="experience" 的行，召回侧零改动。
+		// 反张冠李戴落库闸：task 引用的对象必须能在 episode 原文找到影子，否则不落库。
+		// 关态 result.Experiences 恒 nil ⇒ 本循环零次迭代，行为与现状逐字一致。
+		for _, exp := range result.Experiences {
+			if !distill.ExperienceGrounded(exp, input.Content) {
+				log.Printf("[distill][experience] 张冠李戴闸拦截（task 对象在原文无影子）episode=%s task=%.60s",
+					input.EpisodeID, exp.Task)
+				continue
+			}
+			// 近重复跳过（与 facts 同口径 cosine ≥0.98，复用现成 emb/ldb，不新造设施）
+			expContent := fmt.Sprintf("经验[%s] 解法：%s 边界：%s", exp.Task, exp.Solution, exp.Boundary)
+			expContent = redact.RedactSecrets(expContent)
+			var skip bool
+			if v, eErr := emb.EncodeSingle(expContent); eErr == nil {
+				if found, _ := ldb.Search("memories", v, 5, input.Namespace); len(found) > 0 {
+					for _, ex := range found {
+						if ex.Content == expContent || cosineSimilarity(v, ex.Vector) >= 0.98 {
+							skip = true
+							break
+						}
+					}
+				}
+			}
+			if skip {
+				log.Printf("[distill][experience] 近重复跳过 episode=%s task=%.60s", input.EpisodeID, exp.Task)
+				continue
+			}
+			expMem := models.MemoryRecord{
+				ID:        fmt.Sprintf("mem_%d", time.Now().UnixNano()),
+				AgentID:   input.AgentID,
+				Namespace: input.Namespace,
+				Content:   expContent,
+				// 🔴 用现成 category 字段（实测可写入/可召回），不造新表/新列
+				Category: "experience",
+				Tier:     "normal",
+				// 质量口径 = 现有五维 overall（VD/RU 已在其中）；🔴 不做 confidence 自评
+				QualityScore:   result.Overall,
+				Version:        1,
+				CreatedAt:      time.Now(),
+				UpdatedAt:      time.Now(),
+				DerivedFrom:    input.EpisodeID,
+				SourceEvents:   []string{input.EpisodeID},
+				Freshness:      "fresh",
+				Source:         srcOrLLMDistill(input.Source),
+				EmbeddingModel: orDefault(input.EmbeddingModel, "bge-m3"),
+				ScriptVersion:  orDefault(input.ScriptVersion, "unknown"),
+				ValidFrom:      time.Now().Format(time.RFC3339),
+				Provenance:     distill.DetectProvenance(input.Source),
+			}
+			if err := ldb.InsertMemory(expMem); err != nil {
+				log.Printf("[distill][experience] 落库失败 episode=%s: %v", input.EpisodeID, err)
+			} else {
+				factsLanded = true
+				log.Printf("[distill][experience] 落库 episode=%s task=%.60s boundary=%.40s",
+					input.EpisodeID, exp.Task, exp.Boundary)
 			}
 		}
 		// t_1c12e000：写路径缓存失效（方案 A）——distilled facts 是 memories 唯一写点。
@@ -493,6 +643,18 @@ func NewServer() http.Handler {
 
 	mux.HandleFunc("/health", routes.HandleHealth)
 	mux.HandleFunc("/api/v1/health", routes.HandleHealth)
+	// t_e11207f8 治源①：空壳拦截器「确实跑过」的取证端点。
+	// checks=每个蒸馏 fact 判一次的心跳计数（>0 即拦截器活着）；blocks=实际拒写空壳条数；
+	// loaded=false 表示共享判据没加载上（fail-open，需排查 ZHIYI_PAYLOAD_GUARD_RULES 路径）。
+	mux.HandleFunc("/api/v1/payload-guard/stats", func(w http.ResponseWriter, r *http.Request) {
+		checks, blocks, loaded, rp := distill.PayloadGuardStats()
+		respondJSON(w, 200, map[string]interface{}{
+			"checks":     checks,
+			"blocks":     blocks,
+			"loaded":     loaded,
+			"rules_path": rp,
+		})
+	})
 	// 图谱缓存统计 + 搜索缓存统计（t_1c12e000：并入 search_cache 段，
 	// 暴露 hits/misses/invalidated/size/ttl，写频对命中率的影响可观测）
 	mux.HandleFunc("/api/v1/cache/stats", func(w http.ResponseWriter, r *http.Request) {
@@ -518,9 +680,9 @@ func NewServer() http.Handler {
 	// 返回该 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"`
+			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)
@@ -564,6 +726,8 @@ func NewServer() http.Handler {
 	})
 	mux.HandleFunc("/api/v1/recall", api.Recall)
 	mux.HandleFunc("/api/v1/recall/debug", api.RecallDebug)
+	// 2026-10-26 (P0-1 t_trace_p0)：召回链路追踪回溯（trace_id 贯穿各阶段/各通道）
+	mux.HandleFunc("/api/v1/trace/", api.Trace)
 	// t_23b6a940 AC7 热门度看门狗快照（report-only，传感器端读它转既有告警通道）
 	mux.HandleFunc("/api/v1/popwatch", api.PopWatch)
 	// 2026-10-13 (t_e9a4d18f P2) 常设答案直读/写入
@@ -575,6 +739,10 @@ func NewServer() http.Handler {
 	// 反馈统一走 /api/v1/feedback/{useful,not-useful,deprecate,correct}（feedback.go，写拆分后新字段）。
 	mux.HandleFunc("/api/v1/bootstrap", api.Bootstrap)
 	mux.HandleFunc("/api/v1/stats", api.Stats)
+	// 2026-10-26（牧尘批「三档」）：自检统一取数端点。
+	// 唯一契约 —— 自检脚本一律读这里，禁止再 lancedb.connect() 直连生产库。
+	// ?level=cheap（默认，内存态计数）| full（+读 tools/selfcheck_full.py 的全量快照：碎片/冗余/近7天质量/写量）
+	mux.HandleFunc("/api/v1/selfcheck", api.Selfcheck)
 	mux.HandleFunc("/api/v1/batch-commit", api.BatchCommit)
 	// 主症A（t_fa6c9104）：显式写入直落 memories 表（嵌入 + 立刻可召回）。
 	// 纯新增路由：commit/recall/蒸馏路径零改动；旧服务端 404 时插件自动回落 commit。
@@ -582,21 +750,13 @@ func NewServer() http.Handler {
 	// 自优化指标（Dashboard，含 avg_distill_loss）
 	// total_episodes：Rust count_rows 真实值；旧 sidecar 回退 episodes_cached（进程内缓存，非总量）
 	mux.HandleFunc("/api/v1/metrics", func(w http.ResponseWriter, r *http.Request) {
-		m := selfoptimize.Dash.Metrics()
-		if stats, err := ldb.Stats(); err == nil {
-			if total, ok := stats["total_memories"].(float64); ok {
-				m["total_memories"] = total
-			}
-			if total, ok := stats["total_episodes"].(float64); ok {
-				m["total_episodes"] = total
-			} else if cached, ok := stats["episodes_cached"].(float64); ok {
-				// 旧 sidecar 回退：缓存值非真实总量，gauge 仍设值；
-				// 来源标记写入响应 JSON（/api/v1/metrics 的 m 类型是 map[string]float64，
-				// 无法直接加字符串字段，改为用 episodes_source=1.0 作为标记位）
-				m["total_episodes"] = cached
-				m["episodes_source_cached"] = 1 // 标记：此值来自进程内缓存（非 Rust count_rows）
-			}
+		var stats map[string]interface{}
+		if s, err := ldb.Stats(); err == nil {
+			stats = s
 		}
+		// t_a513b870 AC2：蒸馏闸门拒绝真计数 + total_* 合并统一走 MetricsJSON（单测可借
+		// httptest 起真实端点读回 JSON 验证 rejected_by_rule）。
+		m := routes.MetricsJSON(selfoptimize.Dash.Metrics(), stats)
 		respondJSON(w, 200, m)
 	})
 	// ─── WebSocket 实时推送 ──────────────────────
@@ -1495,7 +1655,18 @@ func NewServer() http.Handler {
 	mux.HandleFunc("/api/v1/memories", adminAPI.ListMemories)
 	mux.HandleFunc("/api/v1/memories/export", adminAPI.ExportMemoriesMD)
 	// /api/v1/memory/{id}/versions — existing version history endpoint
+	// t_0f1d7be9：PathValue("id") 只在模式路由下生效，前缀路由手动解析（旧写法恒取到
+	// 空 id 是历史遗留，Versions 因此从未按 id 过滤过 —— 本行保持行为不变，仅注释留痕）。
 	mux.HandleFunc("/api/v1/memory/", func(w http.ResponseWriter, r *http.Request) {
+		// t_0f1d7be9（原文层）：/{id}/raw 下钻分派（GET only，其余仍走 Versions）
+		if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/raw") {
+			id := strings.TrimSuffix(strings.TrimPrefix(r.URL.Path, "/api/v1/memory/"), "/raw")
+			if id != "" && !strings.Contains(id, "/") {
+				r.SetPathValue("id", id)
+				api.MemoryRaw(w, r)
+				return
+			}
+		}
 		if r.Method == "GET" {
 			adminAPI.Versions(w, r)
 		} else {
@@ -1800,6 +1971,11 @@ func NewServer() http.Handler {
 		ticker := time.NewTicker(30 * time.Second)
 		defer ticker.Stop()
 		for range ticker.C {
+			// t_cf680fad：每个 tick 先 drain durable pending-softdelete 队列（风暴退去后的
+			// 相对静默窗口重放，必落盘）。队列空 = 廉价 no-op，不打日志；仅在有待处理时出声。
+			if n := storage.PendingSoftDeleteCount(); n > 0 {
+				storage.DrainPendingSoftDeletes(ldb)
+			}
 			for _, t := range []struct{ id, action string }{
 				{"t_distill", "distill"},
 				{"t_merge", "merge"},
@@ -2204,14 +2380,26 @@ func (s *ldbWriteOpsStore) MarkSuperseded(oldID, newID string) error {
 	})
 }
 
-// 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",
+// MarkConflict 旧记忆标记冲突（t_e3f5cb79 · AC-1.2）。判定门（SameAttrValueConflict，
+// 「同主体+同属性+不同取值」）在 distill.JudgeWriteOp 出口把守，走到这里的都是确认
+// 矛盾 ⇒ 打标必须同写双向指针：旧行 superseded_by=[newID] + freshness=superseded
+// （新值生效、旧值被取代的既有字段语义；新行 supersedes=[oldID] 由写路径在插入
+// 记录上带）。不置 is_deleted —— 旧行仍可召回，排序侧降权属方案 A3，不在本卡。
+func (s *ldbWriteOpsStore) MarkConflict(oldID, newID string) error {
+	b, _ := json.Marshal([]string{newID})
+	return s.ldb.Update("memories", oldID, map[string]any{
+		"freshness":     "superseded",
+		"superseded_by": string(b),
 	})
 }
 
+// jsonStrList 序列化 []string（LanceDB 里 supersedes/superseded_by 的存储形态是
+// JSON 数组字符串，如 `["mem_123"]`）。2026-11-11 阶段 3 新增。
+func jsonStrList(v []string) string {
+	b, _ := json.Marshal(v)
+	return string(b)
+}
+
 // memIDFor 为写时四操作 apply 预生成新记忆 ID（与下方 InsertMemory 同格式）。
 func memIDFor(fact string, input distill.DistillInput) string {
 	_ = fact

go/internal/distill/ab_run_test.go

@@ -0,0 +1,87 @@
+//go:build abrun
+
+// t_2595b626 A/B 跑批（非默认构建；仅 `-tags abrun go test -run TestABRun` 显式跑）。
+// 读 ab-samples.json → callLLM5D（生产同款 prompt 构造）→ 原始输出+解析结果落 ab-raw.jsonl。
+// 门控由 env ZHIYI_DISTILL_EXPERIENCE 决定（进程启动读一次 ⇒ A/B 两臂 = 跑两次进程）。
+package distill
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+type abSample struct {
+	ID      string `json:"id"`
+	Content string `json:"content"`
+	Src     string `json:"src"`
+}
+
+func TestABRun(t *testing.T) {
+	if os.Getenv("AB_GATE") == "" {
+		t.Skip("设 AB_GATE=on|off 才跑")
+	}
+	gate := os.Getenv("AB_GATE") == "on"
+	if gate != ExperienceGateEnabled() {
+		t.Fatalf("进程 env ZHIYI_DISTILL_EXPERIENCE=%v 与 AB_GATE=%v 不一致（门控启动读一次）", ExperienceGateEnabled(), gate)
+	}
+	// 缓存必须关：两臂同内容，A 臂结果若被缓存喂给 B 臂 = 假对照
+	scoreCacheDisabled = true
+
+	f, err := os.Open(os.Getenv("AB_SAMPLES"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var samples []abSample
+	json.NewDecoder(bufio.NewReader(f)).Decode(&samples)
+	f.Close()
+	if len(samples) < 20 {
+		t.Fatalf("样本不足 20: %d", len(samples))
+	}
+
+	e := NewEngine("http://127.0.0.1:8081/v1/chat/completions", "local/minicpm5-2b", "sk-local")
+	outPath := os.Getenv("AB_OUT")
+	out, _ := os.Create(outPath)
+	defer out.Close()
+	enc := json.NewEncoder(out)
+
+	var idx int64
+	var wg sync.WaitGroup
+	sem := make(chan struct{}, 2) // 与 2B 双槽匹配，不打爆
+	start := time.Now()
+	for _, s := range samples {
+		wg.Add(1)
+		sem <- struct{}{}
+		go func(s abSample) {
+			defer wg.Done()
+			defer func() { <-sem }()
+			t0 := time.Now()
+			resp, err := e.callLLM5D(s.Content) // 缓存已关，直连 uncached
+			rec := map[string]any{
+				"id": s.ID, "src": s.Src, "gate": gate,
+				"ms": time.Since(t0).Milliseconds(),
+			}
+			if err != nil {
+				rec["err"] = err.Error()
+			} else {
+				rec["facts"] = resp.Facts
+				rec["experiences"] = resp.Experiences
+				rec["scores"] = map[string]float64{"is": resp.IS, "su": resp.SU, "pa": resp.PA, "vd": resp.VD, "ru": resp.RU}
+			}
+			i := atomic.AddInt64(&idx, 1)
+			fmt.Printf("[%d/%d] %s %dms err=%v\n", i, len(samples), s.ID, rec["ms"], rec["err"])
+			outMu.Lock()
+			enc.Encode(rec)
+			outMu.Unlock()
+		}(s)
+	}
+	wg.Wait()
+	fmt.Printf("AB_RUN gate=%v n=%d total=%s -> %s\n", gate, len(samples), time.Since(start).Round(time.Second), outPath)
+}
+
+var outMu sync.Mutex

go/internal/distill/admission_lane.go

@@ -54,6 +54,16 @@ var identityPreferencePatterns = []string{
 // ClassifyAdmission 对一条待蒸馏内容做确定性三路分诊。
 // 返回 lane 与人类可读的 reason（进日志，用于事后审计分诊是否合理）。
 // 本函数**零 LLM 调用**、纯确定性 —— 同一输入永远同一结果，可单测。
+//
+// 🔴 调用链可达性（t_a513b870 AC4 定性，2026-11-10 实测）：
+//   Enqueue(engine.go:422) 与 auto_distill.go:41 都**先跑 HardRulesPassWithReason**
+//   硬规则层（空/过短/闲聊/知识问答/密度/超长/系统样板 全在硬规则层拦截并 return），
+//   ⇒ 能走到本函数的内容**已不可能命中下面 drop 分支**：
+//     空内容 / 系统样板（已移入硬规则层）/ 过短 <8 字（硬规则 <10 更严，先拦）。
+//   因此 lane=drop 在当前调用链**恒不可达**，7 天实测 lane=drop=0 属预期，非健康信号。
+//   保留 drop 分支仅作**防御**（若未来某条路径绕过硬规则直接调本函数，仍不致误放垃圾）；
+//   闸门实际只走 keep/observe 两路。文献依据：不确定带永不丢弃（When to Forget 原文
+//   "should not deprecate an uncertain memory"），drop 本就只在硬规则层发生。
 func ClassifyAdmission(content string) (AdmissionLane, string) {
 	s := strings.TrimSpace(content)
 	if s == "" {

go/internal/distill/conflict_gate.go

@@ -0,0 +1,215 @@
+// 织忆 MemoryWeave — 真矛盾判据门（t_e3f5cb79 · 2026-10-31 方案 A2）
+//
+// 背景（硬证据，非推测）：freshness=conflict 存量 24 条人工判读 **0/24 真矛盾**
+// （方案文档 2026-10-31「验证结果（2026-11-02）」节，脚本 verify1-conflicts.py /
+// verify1b-counterparts.py）。旧 CONFLICT-MARK 判据（ruleContradiction 否定词表 /
+// LLM 高相似带偏）本质是「语义相似检测器」，误报率 100%。
+//
+// 本文件给出 AC-1 判据的唯一确定性实现：**同主体 + 同属性 + 不同取值**才算矛盾。
+// 两条可判通道（任一命中才算，判不出 = 不是矛盾，宁漏勿误）：
+//
+//	① 属性-取值对：两侧都能解析出「同一属性键」的显式取值（数字/布尔/ASCII 标识符），
+//	   且取值规范化后不相等。属性键：ASCII 标识符（`KEY=值`/`KEY 为 值`/`KEY 实测 值`…）
+//	   或「短语主语+是/为/：+数字」的中文属性短语。
+//	② 否定对立（同一小句、共享锚、否定落在作用域内）：复用 governance.IsContradiction
+//	   （四修判据，回归 conflict_scope_test.go），不在本文件重复实现。
+//
+// 设计纪律：
+//
+//	· 零新依赖（stdlib + internal/governance，无环：governance 只 import metrics）。
+//	· 纯函数、无 IO/LLM/时钟 —— 任何来源（rule/llm/注入 judge）的 CONFLICT-MARK
+//	  都必须在 JudgeWriteOp 出口过这道门；不过门降级 UPDATE（sim≥更新阈值）或 ADD。
+//	· 宁漏勿误：解析不出 = false；值类型不同 = 不可比 = false；
+//	  值带路径/斜杠等复合形态（如 `union=0/1`）= 拒绝解析（否则与 `union=1`
+//	  误配成「不同取值」——24 条存量回归里真实存在这一对，实测必须 0 真矛盾）。
+package distill
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/xiaoxue/memoryweave/internal/governance"
+)
+
+// assertion 一条从文本解析出的「属性 → 显式取值」断言。
+type assertion struct {
+	kind string // num | bool | ident
+	val  string // 规范化后的值（num: float 文本；bool: 0/1；ident: 小写）
+	raw  string // 原值文本（仅用于证据串）
+}
+
+var (
+	// ascii 属性键 = 标识符（≥1 字符，单字键仅数字/布尔）；**前置边界**防截尾（`X_ZHIYI_FBIAS=0`
+	// 只可命中 `zhiyi_fbias`，不可再命中 `fbias`）。2 字符键（如 X=true）只接受
+	// 数字/布尔值（ident 类拒绝）——`ID: <hex>` 这类 2 字符键+标识符值假配对风险高
+	// （24 条存量回归实测约束）。连接词覆盖「的值是」这类中缀形态。
+	kvASCIIRe = regexp.MustCompile("(?:^|[^A-Za-z0-9_])([A-Za-z][A-Za-z0-9_]*)\\s*(?:=|:|：|的值(?:是|为)?|值|取值|默认值为|默认值|当前值为|现为|实测|设置为|设为|为|是)\\s*([^\\s，。；、）)】」》\"'`\u300a《]+)")
+	// 中文属性短语：不含标点/空白的 2~16 字短语 + 系词 + 纯数字（可带常见量词）。
+	kvCJKRe = regexp.MustCompile("([^，。；：！？、「」《》（）()\\[\\]【】\\s\"'`\u3000]{2,16}?)(?:是|为|：|:)\\s*([0-9]+(?:\\.[0-9]+)?)(?:个|只|条|次|天|小时|分钟|秒|GB|MB|G|M|K|%|元|万元|亿|人|张|分|级|位|行|字|轮|台|核)?")
+	// 尾部非法字符：值以这些结尾/包含这些时拒绝（复合表达式不是「取值」）。
+	kvBadTail = regexp.MustCompile(`[/\\=<>&|+]$`)
+)
+
+// boolWords 布尔值归一表（键取小写比较；中文开关词只在 ASCII 键通道接受，
+// 避免「开了个会」这类叙述句被当布尔值）。
+var boolWords = map[string]string{
+	"true": "1", "false": "0", "on": "1", "off": "0", "yes": "1", "no": "0",
+	"开": "1", "关": "0", "打开": "1", "关闭": "0", "启用": "1", "禁用": "0",
+	"开启": "1", "停用": "0", "停": "0", "启动": "1",
+}
+
+// normalizeValue 把一个捕获到的值文本规范化为 assertion；不可信形态返回 ok=false。
+func normalizeValue(raw string, allowCJKBool bool) (assertion, bool) {
+	v := strings.TrimRight(raw, "。.，,;；)）]")
+	if v == "" || kvBadTail.MatchString(v) {
+		return assertion{}, false
+	}
+	lower := strings.ToLower(v)
+	if lw, ok := boolWords[lower]; ok {
+		return assertion{kind: "bool", val: lw, raw: v}, true
+	}
+	if allowCJKBool {
+		if lw, ok := boolWords[v]; ok {
+			return assertion{kind: "bool", val: lw, raw: v}, true
+		}
+	}
+	if f, err := strconv.ParseFloat(v, 64); err == nil {
+		return assertion{kind: "num", val: strconv.FormatFloat(f, 'g', -1, 64), raw: v}, true
+	}
+	// 纯 ASCII 标识符值（如 mimo-v2.5-pro）；含 CJK/路径/斜杠的一律拒（歧义太大）
+	if isASCIIToken(v) {
+		return assertion{kind: "ident", val: lower, raw: v}, true
+	}
+	return assertion{}, false
+}
+
+func isASCIIToken(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, r := range s {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9',
+			r == '-', r == '_', r == '.':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// extractAssertions 抽取文本里全部「属性→值」断言（同键后到覆盖先到）。
+func extractAssertions(text string) map[string]assertion {
+	out := make(map[string]assertion)
+	for _, m := range kvASCIIRe.FindAllStringSubmatch(text, -1) {
+		key := strings.ToLower(m[1])
+		a, ok := normalizeValue(m[2], false)
+		if !ok {
+			continue
+		}
+		// 2 字符键假配对风险高（ID/of/no…）：只接受数字/布尔取值（ident 拒绝）
+		if len(key) < 3 && a.kind == "ident" {
+			continue
+		}
+		out[key] = a
+	}
+	for _, m := range kvCJKRe.FindAllStringSubmatch(text, -1) {
+		phrase := m[1]
+		// 短语尾部可能粘连系词前字（非贪婪边界），截最后一个标点后的尾名词
+		phrase = strings.TrimLeft(phrase, "的是了将和对与和为")
+		phrase = normalizeCJKAttrKey(phrase)
+		if len([]rune(phrase)) < 2 {
+			continue
+		}
+		key := "zh:" + phrase
+		if a, ok := normalizeValue(m[2], false); ok {
+			out[key] = a
+		}
+	}
+	return out
+}
+
+// cjkKeyNoise 中文属性短语里的动词/时态噪声。实测来源（2026-11-11 supersede E2E）：
+// 同一条事实被蒸馏两次会写成「API端口**被指定为**60123」与「API端口**为**60124」——
+// 去掉噪声后属性键才是同一个，否则漏判（宁漏勿误的反面：该合的没合）。
+// 只削**尾缀**语义噪声，不动名词本身；削完不足 2 字则原样返回（不误伤短键）。
+var cjkKeyNoise = []string{
+	"被指定", "指定", "被设置", "设置", "被改为", "改为", "变更", "调整为", "调整",
+	"更新为", "更新", "设置为", "设为", "现在", "当前", "目前", "已经", "已", "则是",
+}
+
+// normalizeCJKAttrKey 去掉属性短语里的动词/时态噪声，供同属性判定比对。
+func normalizeCJKAttrKey(phrase string) string {
+	out := phrase
+	for i := 0; i < 3; i++ { // 最多削 3 层（如「现在被指定」）
+		changed := false
+		for _, n := range cjkKeyNoise {
+			if strings.HasSuffix(out, n) && len([]rune(strings.TrimSuffix(out, n))) >= 2 {
+				out = strings.TrimSuffix(out, n)
+				changed = true
+			}
+		}
+		if !changed {
+			break
+		}
+	}
+	return out
+}
+
+// sameAttrDiffValue 通道①：两侧同属性键、同值类型、规范化取值不同。
+//
+// 键匹配三种（都要求同值类型）：
+//
+//	① 完全相同
+//	② 中文键**后缀包含**（2026-11-11 实测：同一事实被蒸馏两次会写成
+//	   「监听端口为 60126」与「所以需要确认监听端口为 60126」⇒ 前者是后者后缀）。
+//	   短键需 ≥3 字才算，防「端口/监听端口」这类 2 字键过度配对。
+//	③ ASCII 键不看后缀（`port` 与 `api_port` 语义不同，宁漏勿误）
+func sameAttrDiffValue(a, b string) (string, bool) {
+	A, B := extractAssertions(a), extractAssertions(b)
+	for k, va := range A {
+		if vb, ok := B[k]; ok && va.kind == vb.kind {
+			if va.val != vb.val {
+				return fmt.Sprintf("同属性 %q 不同取值: %s vs %s", k, va.raw, vb.raw), true
+			}
+			continue
+		}
+		if !strings.HasPrefix(k, "zh:") {
+			continue
+		}
+		for kb, vb := range B {
+			if !strings.HasPrefix(kb, "zh:") || va.kind != vb.kind || va.val == vb.val {
+				continue
+			}
+			ka := strings.TrimPrefix(k, "zh:")
+			kbn := strings.TrimPrefix(kb, "zh:")
+			short, long := ka, kbn
+			if len([]rune(kbn)) < len([]rune(ka)) {
+				short, long = kbn, ka
+			}
+			if len([]rune(short)) < 3 || !strings.HasSuffix(long, short) {
+				continue
+			}
+			return fmt.Sprintf("同属性(后缀匹配) %q⊂%q 不同取值: %s vs %s", short, long, va.raw, vb.raw), true
+		}
+	}
+	return "", false
+}
+
+// SameAttrValueConflict 是 AC-1 判据入口：**同主体 + 同属性 + 不同取值** 才判真矛盾。
+// 返回 (证据, 是否真矛盾)。判不出（解析失败/类型不齐/无显式取值）一律 false。
+func SameAttrValueConflict(a, b string) (string, bool) {
+	if strings.TrimSpace(a) == "" || strings.TrimSpace(b) == "" {
+		return "", false
+	}
+	if ev, ok := sameAttrDiffValue(a, b); ok {
+		return ev, true
+	}
+	// 通道②：同一小句的否定对立（复用四修判据与其回归，本文件不重复实现）
+	if governance.IsContradiction(a, b) {
+		return "否定对立（governance.IsContradiction）", true
+	}
+	return "", false
+}

go/internal/distill/conflict_gate_test.go

@@ -0,0 +1,179 @@
+// 织忆 MemoryWeave — 真矛盾判据门回归（t_e3f5cb79 · AC-1）
+//
+// 三层判据（全部 -count=1 真跑）：
+//  ① SameAttrValueConflict 单元正反例（同属性异值=真；措辞重复/无显式取值/类型不齐=假）
+//  ② JudgeWriteOp 出口门：假 CONFLICT（相似改写）降级 UPDATE/ADD；真矛盾保留并带证据
+//  ③ AC-1.3 存量回归：testdata/conflict_stock_20261102.json（2026-11-02 快照，
+//     24 条 freshness=conflict + 各自 top3 对手句，人工判读 0/24 真矛盾）→
+//     新判据真矛盾计数必须 = 0；同时正例对照必须 >0（防「恒 false 作弊」）。
+//  ④ AC-1.2 双向指针：apply CONFLICT → MarkConflict(old,new) 带 newID。
+package distill
+
+import (
+	_ "embed"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+//go:embed testdata/conflict_stock_20261102.json
+var conflictStockJSON []byte
+
+type stockRow struct {
+	ID           string `json:"id"`
+	Content      string `json:"content"`
+	Counterparts []struct {
+		ID      string `json:"id"`
+		Content string `json:"content"`
+	} `json:"counterparts"`
+}
+
+// ── ① 单元正反例 ──────────────────────────────────────────────
+
+func TestSameAttrValueConflict_Positive(t *testing.T) {
+	cases := []struct {
+		name, a, b string
+	}{
+		{"配置项新旧值", "ZHIYI_FEEDBACK_BIAS 的值是 0", "ZHIYI_FEEDBACK_BIAS=0.2"},
+		{"布尔对立", "ZHIYI_GRAPH_AUTO_SYNTH=1", "ZHIYI_GRAPH_AUTO_SYNTH=0"},
+		{"ASCII 短键布尔", "X=true", "X=false"},
+		{"标识符值不同", "ZHIYI_DISTILL_MODE=context", "ZHIYI_DISTILL_MODE=merged"},
+		// IsContradiction 通道（四修判据样本，共享锚 + 否定作用域内）
+		{"否定对立", "牧尘在招商局工作", "牧尘不在招商局工作"},
+	}
+	for _, c := range cases {
+		if ev, ok := SameAttrValueConflict(c.a, c.b); !ok {
+			t.Errorf("%s: 应判真矛盾但未判（a=%q b=%q）", c.name, c.a, c.b)
+		} else if ev == "" {
+			t.Errorf("%s: 判真但无证据串", c.name)
+		}
+	}
+}
+
+func TestSameAttrValueConflict_Negative(t *testing.T) {
+	cases := []struct {
+		name, a, b string
+	}{
+		{"同值重复不是矛盾", "ZHIYI_FEEDBACK_BIAS=0.2", "反馈偏置 ZHIYI_FEEDBACK_BIAS 为 0.2"},
+		{"措辞改写无取值对", "决定检查存储层全部可能位置。", "必须检查存储层全部可能位置以确保范围完整。"},
+		{"不同属性同数字", "织忆端口是7821", "llama端口是8080"},
+		{"复合表达式拒绝解析", "改造要留验收开关（本例 `union=0/1`）", "两层并集真生效，`union=1` 响应正确。"},
+		{"无关事实", "X=1", "Y=2"},
+		{"纯否定词但无共享锚", "用户不喜欢吃辣", "牧尘在招商局工作"},
+		{"空输入", "", "任意"},
+	}
+	for _, c := range cases {
+		if ev, ok := SameAttrValueConflict(c.a, c.b); ok {
+			t.Errorf("%s: 不应判矛盾但判了（ev=%s a=%q b=%q）", c.name, ev, c.a, c.b)
+		}
+	}
+}
+
+// ── ② JudgeWriteOp 出口门 ─────────────────────────────────────
+
+func TestJudgeWriteOp_ConflictGateDowngrade(t *testing.T) {
+	defer withMode("apply")()
+
+	// 假冲突（高相似措辞改写，固定 judge 硬判 CONFLICT）→ 降级 UPDATE（sim≥0.70）
+	v := JudgeWriteOp("决定检查存储层全部可能位置。",
+		[]SimilarMemory{{ID: "mem_1", Content: "必须检查存储层全部可能位置以确保范围完整。", Similarity: 0.93}},
+		fixedJudge(OpConflictMark), nil)
+	if v == nil || v.Op != OpUpdate {
+		t.Fatalf("假冲突高相似应降级 UPDATE，实际 %+v", v)
+	}
+	if !strings.Contains(v.Reason, "[gate:") {
+		t.Fatalf("降级原因必须带 [gate] 标记，实际 %s", v.Reason)
+	}
+
+	// 假冲突（低相似）→ 降级 ADD，且清 TargetID
+	v = JudgeWriteOp("织忆召回 p50 1.34s",
+		[]SimilarMemory{{ID: "mem_1", Content: "磁盘空间不足导致压缩包还原操作需要腾出空间", Similarity: 0.55}},
+		fixedJudge(OpConflictMark), nil)
+	if v == nil || v.Op != OpAdd || v.TargetID != "" {
+		t.Fatalf("假冲突低相似应降级 ADD 且清 TargetID，实际 %+v", v)
+	}
+
+	// 真矛盾保留 CONFLICT-MARK 并带 gate 证据
+	v = JudgeWriteOp("ZHIYI_FEEDBACK_BIAS 的值是 0",
+		[]SimilarMemory{{ID: "mem_1", Content: "ZHIYI_FEEDBACK_BIAS=0.2", Similarity: 0.96}},
+		fixedJudge(OpConflictMark), nil)
+	if v == nil || v.Op != OpConflictMark || !strings.Contains(v.Reason, "[gate:") {
+		t.Fatalf("真矛盾应保留 CONFLICT-MARK+证据，实际 %+v", v)
+	}
+
+	// TargetID 指不到候选行（注入 judge 幻觉）→ 按不过门处理
+	v = JudgeWriteOp("任意候选事实甲",
+		[]SimilarMemory{{ID: "mem_1", Content: "别的", Similarity: 0.96}},
+		func(c string, s []SimilarMemory) WriteVerdict {
+			return WriteVerdict{Op: OpConflictMark, Candidate: c, TargetID: "mem_不存在的", Similarity: 0.96, Reason: "幻觉目标"}
+		}, nil)
+	if v == nil || v.Op == OpConflictMark {
+		t.Fatalf("幻觉 TargetID 必须被门拦下，实际 %+v", v)
+	}
+}
+
+// ── ③ AC-1.3 存量回归：24 条 conflict 重跑新判据 → 真矛盾计数 = 0 ──
+
+func TestConflictStock_24_ZeroTrueConflict(t *testing.T) {
+	var rows []stockRow
+	if err := json.Unmarshal(conflictStockJSON, &rows); err != nil {
+		t.Fatalf("testdata 解析失败: %v", err)
+	}
+	if len(rows) != 24 {
+		t.Fatalf("存量快照应为 24 条，实际 %d", len(rows))
+	}
+	totalPairs, trueConflicts := 0, []string{}
+	for _, r := range rows {
+		for _, cp := range r.Counterparts {
+			totalPairs++
+			if ev, ok := SameAttrValueConflict(r.Content, cp.Content); ok {
+				trueConflicts = append(trueConflicts,
+					r.ID+" vs "+cp.ID+": "+ev)
+			}
+		}
+	}
+	for _, s := range trueConflicts {
+		t.Logf("误报清单条目: %s", s)
+	}
+	if len(trueConflicts) != 0 {
+		t.Fatalf("AC-1.3：24 条存量（人工判读 0 真矛盾）新判据真矛盾计数必须=0，实际 %d（对数 %d）",
+			len(trueConflicts), totalPairs)
+	}
+	t.Logf("AC-1.3 通过：%d 行 × top3 对手 = %d 对，真矛盾计数 0", len(rows), totalPairs)
+
+	// 防恒假对照：同一判据函数在构造真矛盾对上必须能报真
+	controls := [][2]string{
+		{"ZHIYI_FEEDBACK_BIAS 的值是 0", "ZHIYI_FEEDBACK_BIAS=0.2"},
+		{"X=true", "X=false"},
+		{"牧尘在招商局工作", "牧尘不在招商局工作"},
+	}
+	positives := 0
+	for _, c := range controls {
+		if _, ok := SameAttrValueConflict(c[0], c[1]); ok {
+			positives++
+		}
+	}
+	if positives < len(controls) {
+		t.Fatalf("正例对照必须全过（防恒 false 作弊），实际 %d/%d", positives, len(controls))
+	}
+}
+
+// ── ④ AC-1.2 双向指针（store 半边的入参正确性）────────────────
+
+func TestApplyWriteOp_ConflictWritesBothSidePointer(t *testing.T) {
+	defer withMode("apply")()
+	v := WriteVerdict{Op: OpConflictMark, Candidate: "ZHIYI_FEEDBACK_BIAS=0.2",
+		TargetID: "mem_old", Similarity: 0.96, Reason: "同属性不同取值"}
+	store := newFakeStore()
+	shouldInsert, err := ApplyWriteOp(v, store, "mem_new")
+	if err != nil || !shouldInsert {
+		t.Fatalf("CONFLICT 必须插入新条：%v %v", shouldInsert, err)
+	}
+	if !store.conflicted["mem_old"] {
+		t.Fatalf("旧行未打标")
+	}
+	if store.conflictPtr["mem_old"] != "mem_new" {
+		t.Fatalf("AC-1.2: MarkConflict 必须携带 newID（旧行 superseded_by=[新id]），实际 %q",
+			store.conflictPtr["mem_old"])
+	}
+}

go/internal/distill/density_gate.go

@@ -0,0 +1,93 @@
+// 织忆 MemoryWeave — 蒸馏产出信息密度判据（kanban t_ab5b2461）
+//
+// 病（2026-10-30 全面评估 + 本卡按 Source 分组定位）：memories 表 content 中位数 35 字、
+// 83.3% <60 字、含可执行标记率低 —— 蒸馏产物太短，召回出来没法直接用。
+// 分组实测（groups_before.json，live 42,150）：llm_distill p50=36、wiki:worklog-note p50=36、
+// wiki:domain-kb p50=38、wiki:session-compress p50=30 —— distill 全家族整体都碎，
+// 不是某一条上游的病 ⇒ 收口在共用写入点（server.go OnDistillComplete 写库循环 +
+// engine.go 提取 prompt），不逐脚本打补丁。
+//
+// 设计（延续 procedural_gate.go 分诊哲学 + 卡红线「禁为长度而长度」）：
+//   - 纯确定性判据，零 LLM 调用，三项各自独立判定（正则）：
+//       ① 可执行动作/命令/路径（反引号命令、CLI 调用、绝对/家目录路径、脚本/配置文件扩展名）
+//       ② 明确判据或阈值（数字+单位、比较符、阈值/上限/下限/门槛类词）
+//       ③ 因果（「为什么」：因为/由于/导致/根因/否则/⇒ 等因果链词）
+//   - 满足 ≥2 项 ⇒ 保持 Category="distilled"（知识形态）。
+//   - <2 项 ⇒ 降级 Category="observe"：行照写、可召回、计入写入量（AC3 不饿死），
+//     只是不再冒充高质量知识 —— 与 t_3636b872 同一理由：降级可逆，丢弃不可逆。
+//   - 不做长度硬门槛：长度是三项判据的**结果**不是目标（卡红线）。
+//
+// env 门控：ZHIYI_DISTILL_DENSITY=1 启用（灰度开在 systemd drop-in）；
+// 未设 ⇒ DensityGateEnabled()=false ⇒ 写入侧 Category 恒 "distilled"、
+// prompt 与打分缓存键逐字节回到现状（AC5 可回滚）。
+// 回滚：rm 42-density-gate.conf + daemon-reload + zhiyi-restart-with-lock.sh restart。
+
+package distill
+
+import (
+	"os"
+	"regexp"
+)
+
+// densityGateEnabled 启动时读一次（与 proceduralShadowMode 同款，改值须重启）。
+var densityGateEnabled = os.Getenv("ZHIYI_DISTILL_DENSITY") == "1"
+
+// DensityGateEnabled 写入侧（server.go）与打分缓存（score_cache.go）共用的开关读口。
+func DensityGateEnabled() bool { return densityGateEnabled }
+
+// 三项判据正则（RE2；口径写进交付，判据即文档）。
+var (
+	// densityCmdRe ① 可执行动作/命令/路径：
+	//   路径前缀（绝对/家目录）、脚本与配置文件扩展名、常见 CLI + 参数、反引号内联命令。
+	densityCmdRe = regexp.MustCompile(
+		`(?:~/|/(?:home|var|etc|data|usr|opt|tmp|srv|root)/|\.(?:sh|py|go|rs|conf|json|jsonl|ya?ml|toml|db|service|sql)\b` +
+			`|\b(?:git|curl|wget|grep|rg|sed|awk|jq|yq|systemctl|journalctl|python3?|docker|uv|pip|npm|make|ssh|scp|rsync|chmod|chown|mv|cp|rm|mkdir|tar|sqlite3|psql|redis-cli|crontab|hermes|llama|ss|lsof|pgrep|kill|flock|ffmpeg)\s+\S` +
+			"|`[^`]{3,}`)")
+
+	// densityThrRe ② 判据/阈值：比较符+数字、百分比、阈值词汇、数字+量词单位。
+	densityThrRe = regexp.MustCompile(
+		`(?:[≥≤><]=?\s*\d|\d+(?:\.\d+)?\s*[%％]|阈值|上限|下限|门槛|限额|配额|\bcap\b|\blimit\b|\bcritical\b` +
+			`|\d+\s*(?:ms|毫秒|秒|分钟|小时|天|次|条|行|字|MB|GB|TB|端口|万|亿))`)
+
+	// densityCauseRe ③ 因果/为什么：因果连接词与根因词汇、箭头推导。
+	densityCauseRe = regexp.MustCompile(
+		`(?:因为|由于|导致|因此|所以|为了|从而|以致|以免|否则|根因|原因为|起因|源于|使得|⇒|->|=>)`)
+)
+
+// DensitySatisfyCount 数一条事实满足三项判据中的几项（0~3）。
+// 纯函数：同一输入永远同一结果，可单测、零副作用。
+func DensitySatisfyCount(fact string) int {
+	n := 0
+	if densityCmdRe.MatchString(fact) {
+		n++
+	}
+	if densityThrRe.MatchString(fact) {
+		n++
+	}
+	if densityCauseRe.MatchString(fact) {
+		n++
+	}
+	return n
+}
+
+// DensityKeep 事实是否够格保持 Category="distilled"：满足 ≥2 项。
+// 注意：本函数只在 DensityGateEnabled() 时被调用；关态下调用方保持 "distilled" 不动。
+func DensityKeep(fact string) bool {
+	return DensitySatisfyCount(fact) >= 2
+}
+
+// densityPromptAddendum 灰度开启时追加到提取 prompt 的信息量要求。
+// 只在 DensityGateEnabled() 时拼接 —— 关态 prompt 逐字节不变（AC5），
+// 旧 prompt 原文保留在 engine.go 的 instr/outFmt 常量里，一字未动。
+const densityPromptAddendum = `
+🔴 信息量要求（灰度生效中）：
+- 同一事件/操作的所有关联要素（做什么、在哪、什么时候/多频繁、为什么、到什么程度/阈值）**合并成一条完整句子**，不要拆成多条各含一个要素的短句。
+- 目标：每条 FACT 是一句自洽、自足的陈述，读的人（或后续召回）不需要再拼其它条就能直接用。
+- 合并示例：原文碎片「巡检脚本是 disk-check.sh」「周期每 6 小时」「原因是磁盘写满会拖垮服务」
+  → 输出一条：「磁盘巡检每 6 小时执行一次 disk-check.sh，因为磁盘写满会拖垮服务。」
+  而不是三条各含一个要素的短句。（示例只教写法，不要抄示例内容）
+- 判断"要素是否齐全"：一条 FACT 若只有"是什么"而缺"怎么用/在哪/为何/程度"，且原文有这些信息，就必须并进来。
+- 纯元信息行（如「该条记录日期为…」「文件保存在…」这类只有溯源没有知识载荷的）不要输出为事实。
+- 禁止为凑长度堆修饰词、重复同一事实、或把无关信息硬塞进一条：原文只有短句就照实提取，
+  长是信息完整的结果，不是目标。宁可"完整但不长"，也不要"长但不自洽"。
+`

go/internal/distill/density_gate_test.go

@@ -0,0 +1,53 @@
+// t_ab5b2461 信息密度判据单测（判据 = 交付里贴出的口径，测试即文档）。
+package distill
+
+import "testing"
+
+func TestDensitySatisfyCount(t *testing.T) {
+	cases := []struct {
+		name  string
+		fact  string
+		wantN int
+		keep  bool
+	}{
+		{"命令+阈值", "重启用 ~/.hermes/scripts/zhiyi-restart-with-lock.sh，健康检查 40 秒内必须返回 200，否则回滚", 3, true},
+		{"路径+因果", "state.db 损坏时走 db-op-gate.sh，因为 gateway 运行期直接写活库会放大损坏面", 2, true},
+		{"仅阈值", "该表写入量超过 500 条时告警", 1, false},
+		{"仅因果", "因为昨晚断网所以任务没有跑完", 1, false},
+		{"元信息行(全不中)", "该条经验记录的日期为 2026-10-25", 0, false},
+		{"裸短句(全不中)", "用户授权助手自行决定", 0, false},
+		{"阈值+因果", "磁盘余量 <5% 时触发清理，否则 backups 目录会把根分区写满", 2, true},
+		{"路径单中", "配置文件在 /etc/ssh/sshd_config", 1, false},
+	}
+	for _, c := range cases {
+		if n := DensitySatisfyCount(c.fact); n != c.wantN {
+			t.Errorf("%s: DensitySatisfyCount(%q)=%d, want %d", c.name, c.fact, n, c.wantN)
+		}
+		if got := DensityKeep(c.fact); got != c.keep {
+			t.Errorf("%s: DensityKeep(%q)=%v, want %v", c.name, c.fact, got, c.keep)
+		}
+	}
+}
+
+// AC5 结构证据：灰度段是**追加**，不改动既有 prompt 常量 ——
+// instr/outFmt 常量文本里不含「信息量要求」字样（关态 prompt 逐字节为旧文本）。
+func TestDensityAddendumOnlyAppended(t *testing.T) {
+	if len(densityPromptAddendum) == 0 {
+		t.Fatal("addendum 不能为空")
+	}
+	// 追加段自带独有锚点，供源内定位（防止误删）。
+	if !contains(densityPromptAddendum, "禁止为凑长度堆修饰词") {
+		t.Error("addendum 缺「禁为长度而长度」红线锚点")
+	}
+}
+
+func contains(s, sub string) bool {
+	return len(s) >= len(sub) && (func() bool {
+		for i := 0; i+len(sub) <= len(s); i++ {
+			if s[i:i+len(sub)] == sub {
+				return true
+			}
+		}
+		return false
+	})()
+}

go/internal/distill/distill_parser.go

@@ -49,7 +49,8 @@ type DistillConfig struct {
 // 无递归无嵌套状态机；**从不返回 error**（最差空切片）。
 //
 // ok=false 表示未识别到任何有效行（调用方据此落到 JSON 兜底）。
-func ParseLineFormat(raw string) (facts []string, entities []Entity, scores FiveDScore, ok bool) {
+// t_2595b626：新增第 5 返回值 experiences（EXP 行；门控关恒 nil，行为与现状一致）。
+func ParseLineFormat(raw string) (facts []string, entities []Entity, scores FiveDScore, experiences []ExperienceRecord, ok bool) {
 	var lines [][3]string // [0]=type, [1]=name(或fact内容或score), [2]=type(或score串)
 	scanner := bufio.NewScanner(strings.NewReader(raw))
 	scanner.Buffer(make([]byte, 0, 64*1024), 1<<20)
@@ -64,6 +65,16 @@ func ParseLineFormat(raw string) (facts []string, entities []Entity, scores Five
 			break
 		}
 		switch {
+		// 🔴 EXP 分支排在最前：门控关 ⇒ 条件短路不可达，EXP 行走 default「垃圾行
+		// 静默跳过」，与现状逐字一致（AC1）。门控开 ⇒ 解析 + 单行合法性闸。
+		// EXP 不进 lines[]：它不是 FACT/ENTITY/SCORE，不参与截断启发式；
+		// END 之后的行由 seenEnd break 统一忽略。
+		case experienceGateEnabled && strings.HasPrefix(line, "EXP|"):
+			// t_2595b626 经验层
+			if exp := ParseExperienceLine(line); exp != nil {
+				experiences = append(experiences, *exp)
+				ok = true
+			}
 		case line == "END" || strings.HasPrefix(line, "END|"):
 			seenEnd = true
 		case strings.HasPrefix(line, "FACT|"):
@@ -161,7 +172,8 @@ func ParseLineFormat(raw string) (facts []string, entities []Entity, scores Five
 			ok = true
 		}
 	}
-	return facts, entities, scores, ok
+	// experiences 在扫描循环内已填充（门控开且行合法）
+	return facts, entities, scores, experiences, ok
 }
 
 // isValidScoreField 判一个 SCORE 字段是否为合法数值（0.0~1.0 浮点）。
@@ -225,7 +237,7 @@ func logEchoStrip(path string, st EchoStats) {
 }
 
 func parseDistillOutput(raw string) LLMResponse {
-	facts, entities, scores, ok := ParseLineFormat(raw)
+	facts, entities, scores, experiences, ok := ParseLineFormat(raw)
 	if ok {
 		var names []string
 		for _, en := range entities {
@@ -240,6 +252,9 @@ func parseDistillOutput(raw string) LLMResponse {
 			Facts:    facts,
 			Entities: names,
 		})
+		// t_2595b626：EXP 行在 ParseExperienceLine 已过单行合法性闸；落库前还有
+		// ExperienceGrounded 接地闸兜底（api/server.go）。
+		resp.Experiences = experiences
 		logEchoStrip("line", st)
 		return resp
 	}

go/internal/distill/distill_parser_test.go

@@ -34,7 +34,7 @@ func TestParseLineFormat_AC1Matrix(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			facts, _, _, ok := ParseLineFormat(tc.input)
+			facts, _, _, _, ok := ParseLineFormat(tc.input)
 			if got := len(facts); got != tc.wantFacts {
 				t.Fatalf("facts 数 = %d，期望 %d | input=%q ok=%v", got, tc.wantFacts, tc.input, ok)
 			}
@@ -44,7 +44,7 @@ func TestParseLineFormat_AC1Matrix(t *testing.T) {
 
 // AC1 补充：FACT 行内容整段保留（含引号、竖线），SplitN(...,2) 保护。
 func TestParseLineFormat_FACTContentPreserved(t *testing.T) {
-	facts, _, _, ok := ParseLineFormat(`FACT|他说"你好"就这样|补充` + "\nEND")
+	facts, _, _, _, ok := ParseLineFormat(`FACT|他说"你好"就这样|补充` + "\nEND")
 	if !ok {
 		t.Fatalf("应识别到 FACT 行")
 	}
@@ -58,7 +58,7 @@ func TestParseLineFormat_FACTContentPreserved(t *testing.T) {
 
 // AC1 补充：ENTITY|name|type 三元组正确解析（SplitN(...,3)）。
 func TestParseLineFormat_EntityTriplet(t *testing.T) {
-	_, entities, _, ok := ParseLineFormat("ENTITY|小唯|person\nENTITY|ffmpeg|tool\nEND")
+	_, entities, _, _, ok := ParseLineFormat("ENTITY|小唯|person\nENTITY|ffmpeg|tool\nEND")
 	if !ok {
 		t.Fatalf("应识别到 ENTITY 行")
 	}
@@ -75,7 +75,7 @@ func TestParseLineFormat_EntityTriplet(t *testing.T) {
 
 // AC1 补充：SCORE 行解析出 5 维评分。
 func TestParseLineFormat_ScoreParsed(t *testing.T) {
-	_, _, scores, ok := ParseLineFormat("FACT|x\nSCORE|0.8|0.7|0.6|0.9|0.7\nEND")
+	_, _, scores, _, ok := ParseLineFormat("FACT|x\nSCORE|0.8|0.7|0.6|0.9|0.7\nEND")
 	if !ok {
 		t.Fatalf("应识别到有效行")
 	}
@@ -89,7 +89,7 @@ func TestParseLineFormat_ScoreParsed(t *testing.T) {
 // 旧解析（SplitN limit 6）会把前 5 段占位符名当「5 维」存进去 → 非数值，评分全零。
 // 修复后：尾 5 段数值被正确取出。
 func TestParseLineFormat_ScoreEchoedPlaceholder(t *testing.T) {
-	_, _, scores, ok := ParseLineFormat("FACT|x\nSCORE|is|su|pa|vd|ru|0.5|0.4|0.3|0.2|0.1")
+	_, _, scores, _, ok := ParseLineFormat("FACT|x\nSCORE|is|su|pa|vd|ru|0.5|0.4|0.3|0.2|0.1")
 	if !ok {
 		t.Fatalf("应识别到有效行")
 	}
@@ -100,7 +100,7 @@ func TestParseLineFormat_ScoreEchoedPlaceholder(t *testing.T) {
 
 // 2026-10-08 t_23f6bce3：SCORE 行无 END 收尾时，末行 SCORE 不再被截断检测抹掉。
 func TestParseLineFormat_ScoreWithoutEndPreserved(t *testing.T) {
-	_, _, scores, ok := ParseLineFormat("FACT|甲\nFACT|乙\nSCORE|0.5|0.4|0.3|0.2|0.1")
+	_, _, scores, _, ok := ParseLineFormat("FACT|甲\nFACT|乙\nSCORE|0.5|0.4|0.3|0.2|0.1")
 	if !ok {
 		t.Fatalf("应识别到有效行")
 	}
@@ -112,7 +112,7 @@ func TestParseLineFormat_ScoreWithoutEndPreserved(t *testing.T) {
 // 2026-10-08 t_23f6bce3：正常 5 段 SCORE 行 + 非法字段（占位符名混入）→ 不存脏值。
 func TestParseLineFormat_ScoreBadFieldDropped(t *testing.T) {
 	// 恰好 5 段但第 1 段是占位符名 is（非数值）→ 全行作废，评分全零
-	_, _, scores, ok := ParseLineFormat("FACT|x\nSCORE|is|0.4|0.3|0.2|0.1")
+	_, _, scores, _, ok := ParseLineFormat("FACT|x\nSCORE|is|0.4|0.3|0.2|0.1")
 	_ = ok
 	if scores.IS != 0 || scores.SU != 0 || scores.PA != 0 || scores.VD != 0 || scores.RU != 0 {
 		t.Fatalf("首段为占位符名时该行应作废（不存脏值），得: %+v", scores)
@@ -121,7 +121,7 @@ func TestParseLineFormat_ScoreBadFieldDropped(t *testing.T) {
 
 // AC1 补充：END 之后的行忽略。
 func TestParseLineFormat_AfterEndIgnored(t *testing.T) {
-	facts, _, _, _ := ParseLineFormat("FACT|甲\nEND\nFACT|乙")
+	facts, _, _, _, _ := ParseLineFormat("FACT|甲\nEND\nFACT|乙")
 	if len(facts) != 1 {
 		t.Fatalf("facts = %d，期望 1（END 后的 FACT 应忽略）", len(facts))
 	}
@@ -132,7 +132,7 @@ func TestParseLineFormat_AfterEndIgnored(t *testing.T) {
 
 // AC1 补充：空输出 → ok=false（调用方落 JSON 兜底）。
 func TestParseLineFormat_EmptyReturnsNotOK(t *testing.T) {
-	_, _, _, ok := ParseLineFormat("")
+	_, _, _, _, ok := ParseLineFormat("")
 	if ok {
 		t.Fatalf("空输出 ok 应为 false（应落兜底）")
 	}

go/internal/distill/engine.go

@@ -62,6 +62,10 @@ type DistillResult struct {
 	Score5D  FiveDScore
 	Overall  float64
 	Index    []AAAKEntry // P4: AAAK 压缩索引（每条事实的紧凑摘要）
+	// Experiences t_2595b626 经验层：EXP 解析产物（仅 ZHIYI_DISTILL_EXPERIENCE=1
+	// 且解析出合法 EXP 行时非空；关态恒 nil ⇒ 下游经验分支不可达）。
+	// 🔴 不进 Facts/图谱/AAAK —— 独立 category="experience" 记录走自己的落库闸。
+	Experiences []ExperienceRecord
 }
 
 // Entity 实体
@@ -93,6 +97,8 @@ type LLMResponse struct {
 	Conclusions   []string `json:"conclusions"`    // 新格式：最终结论
 	ActionsTaken  []string `json:"actions_taken"`  // 新格式：采取的行动
 	OpenQuestions []string `json:"open_questions"` // 新格式：悬而未决
+	// t_2595b626 经验层：EXP 行解析产物（仅 ZHIYI_DISTILL_EXPERIENCE=1 时被填充）。
+	Experiences []ExperienceRecord `json:"experiences,omitempty"`
 }
 
 // LLM 5维权重
@@ -413,12 +419,15 @@ func (e *Engine) Enqueue(input DistillInput) {
 	e.mu.Lock()
 	defer e.mu.Unlock()
 
-	if !HardRulesPass(input.Content) {
+	// t_a513b870: 拒绝分支换成带原因的变体，拒绝在此登记计数 + 日志，黑洞消除。
+	if pass, _ := HardRulesPassWithReason(input.Content); !pass {
 		return
 	}
 
 	e.queue = append(e.queue, input)
 	e.pendingTokens += estimateTokens(input.Content)
+	// t_a513b870: 分母「进入蒸馏队列的条数」= 真正 append 成功的一次。
+	RecordEnteredQueue()
 
 	// P3 双缓冲触发：token 积累达阈值 或 条数达 batchSize 或 超时
 	shouldFlush := e.pendingTokens >= e.flushTokenThreshold || len(e.queue) >= e.batchSize
@@ -620,6 +629,18 @@ func (e *Engine) distillOne(input DistillInput) DistillResult {
 		}
 	}
 
+	// t_3636b872 阶段4：程序性步骤判据 —— how-to/运维类内容的蒸馏答案必须含可执行步骤，
+	// 否则降级为 observe（当前 lane 若为 keep 则改写 lane 记录；事实本身不丢）。
+	// 影子模式默认只记不真降（proceduralShadowMode），先观察命中分布再决定是否真拦。
+	if demote, why := ProceduralStepVerdict(input.Content, facts); demote {
+		prevLane := lane
+		if lane != LaneObserve {
+			lane = LaneObserve
+		}
+		log.Printf("[distill][PROCEDURAL] episode=%s lane=%s→%s reason=%s content=%q facts=%d",
+			input.EpisodeID, prevLane, lane, why, truncate(input.Content, 60), len(facts))
+	}
+
 	// P4: 生成 AAAK 压缩索引（每条事实的紧凑摘要，供召回快速定位）
 	index := buildAAAKIndex(facts, entities, overall)
 	if len(index) > 0 {
@@ -632,11 +653,12 @@ func (e *Engine) distillOne(input DistillInput) DistillResult {
 	MaybeAdversarialAudit(input, facts)
 
 	return DistillResult{
-		Facts:    facts,
-		Entities: entities,
-		Score5D:  score,
-		Overall:  overall,
-		Index:    index,
+		Facts:       facts,
+		Entities:    entities,
+		Score5D:     score,
+		Overall:     overall,
+		Index:       index,
+		Experiences: llmResp.Experiences,
 	}
 }
 
@@ -738,7 +760,41 @@ SCORE|五个数字用竖线分隔
 	// 注意：本行写法刻意让 vet 的 Sprintf(格式串) 检查不匹配（外层 %s%s%s 与 3 实参对齐，
 	// 内层「内容:\n%s」是嵌套 Sprintf 的独立格式串，运行时各自 1 槽 1 参）；
 	// rawscore_liveprobe_test.go 的 extractPromptTemplate 锚点须与本行「fmt.Sprintf("内容:\n%s"」保持同步。
-	prompt := fmt.Sprintf("%s%s%s", instr, outFmt, fmt.Sprintf("内容:\n%s", truncate(content, 1000)))
+	// t_afacc477 三档粒度（ZHIYI_DISTILL_MODE）+ 截断可配（ZHIYI_DISTILL_CAP，默认 1000=现状）。
+	// current = 逐字节等价现状 A（cap=1000、无附加段）；context = B 档（默认）；merged = C 档。
+	instrFull := instr
+	if distillMode == "context" {
+		instrFull = instr + addendumContext
+	} else if distillMode == "merged" {
+		instrFull = instr + addendumMerged
+	}
+	// t_ab5b2461 信息密度判据灰度（ZHIYI_DISTILL_DENSITY=1）：只在开关开时追加信息量要求段。
+	// 关态 instrFull 不含密度门附加段，prompt 逐字节与现状一致（AC5）；上方旧 prompt 常量一字未动。
+	if densityGateEnabled {
+		instrFull = instrFull + densityPromptAddendum
+	}
+	capVal := distillCap
+	if capVal <= 0 {
+		capVal = 0 // 不截断
+	}
+	var contentTail string
+	if capVal <= 0 {
+		contentTail = content
+	} else {
+		contentTail = truncate(content, capVal)
+	}
+	// t_2595b626 经验层门控（ZHIYI_DISTILL_EXPERIENCE=1，默认关）：
+	// 附加段拼在 outFmt **之后**（prompt 末尾、离生成位置最近）——
+	// pos_exp 系列实验取证（11-07）：拼 outFmt 之前 = EXP 0/8（outFmt 的
+	// 「facts 要详尽」指令压过附加段）；拼 outFmt 之后才有产出。
+	// run2136 担心的「末行被 echo」由 ParseExperienceLine 的 task 段拒收闸兜底。
+	// 关态 instrFull/outFmt 均不含附加段 ⇒ prompt 逐字节与改动前一致（AC1，sha256 对照）；
+	// instr/outFmt/density 三处旧常量一字未动。
+	promptStr := instrFull + outFmt
+	if experienceGateEnabled {
+		promptStr = promptStr + experiencePromptAddendum
+	}
+	prompt := fmt.Sprintf("%s%s", promptStr, fmt.Sprintf("内容:\n%s", contentTail))
 
 	body := map[string]interface{}{
 		"model": e.LLMModel,

go/internal/distill/experience_gate.go

@@ -0,0 +1,217 @@
+// 织忆 MemoryWeave — 蒸馏经验层（kanban t_2595b626）
+//
+// 形态来源（11-06 Hy-Memory pro 臂对比报告 §3）：每条任务型轨迹产出
+// 「1 条事实（必留）+ 0~N 条经验」，经验带结构化字段 task/solution/boundary。
+// 他侧实测 8/8 轨迹都产出「1 事实 + 1 经验」（5.0–7.2s），但存在张冠李戴
+// （T4 把端口结论挂错任务）⇒ 本实现用「task 必须含输入原文出现的具体对象名」
+// 的硬约束反制（prompt 硬约束 + 落库接地闸双道防线），而不是照抄他的自由生成。
+//
+// 织忆现状：category="experience" 实测可写入 201、可召回（存储零改动）——
+// 全仓只有类型定义里没有产出者 ⇒ 纯缺能力。本文件 + engine/parser/server
+// 三处最小接线补齐产出侧。
+//
+// 红线合规：
+//   - env 门控：ZHIYI_DISTILL_EXPERIENCE=1 才启用（density_gate.go 同款范式）。
+//     关态下 prompt 逐字节与现状一致（附加段独立常量，只在开关开时拼接），
+//     解析器关态不识别 EXP 行（与现状「垃圾行静默跳过」逐字一致）。
+//   - 不做 confidence 自评：ExperienceRecord 没有 confidence 字段，
+//     质量口径复用现有五维评分的 VD/RU（写入侧 QualityScore=overall 照旧）。
+//   - 不造新表/新列：写库走现成 category 字段（= "experience"）。
+//   - 不改任何排序权重：本文件与召回排序零交集（recall 侧只靠响应体已有的
+//     category 字段区分，t_2595b626 AC5）。
+//
+// 回滚：unset ZHIYI_DISTILL_EXPERIENCE + 重启（与 density gate 同路径）。
+
+package distill
+
+import (
+	"os"
+	"regexp"
+	"strings"
+)
+
+// experienceGateEnabled 启动时读一次（densityGateEnabled 同款，改值须重启）。
+var experienceGateEnabled = os.Getenv("ZHIYI_DISTILL_EXPERIENCE") == "1"
+
+// ExperienceGateEnabled 解析侧（distill_parser.go）与写入侧（api/server.go）共用读口。
+func ExperienceGateEnabled() bool { return experienceGateEnabled }
+
+// ExperienceRecord 一条经验（task/solution/boundary 三字段）。
+// 🔴 无 confidence 字段 —— 卡红线：2B 自评会假高，用现有五维 VD/RU 代替，别新造。
+type ExperienceRecord struct {
+	Task     string // 必须含 episode 原文出现的具体对象名（反张冠李戴硬约束）
+	Solution string // 怎么解决的：动作/命令/路径/配置键
+	Boundary string // 适用边界：什么条件下成立、什么条件下不适用
+}
+
+// experiencePromptAddendum 门控开启时追加到提取 prompt 的经验段。
+// 只在 ExperienceGateEnabled() 时拼接 —— 关态 prompt 逐字节不变（AC1），
+// engine.go 的 instr/outFmt 常量一字未动（同 densityPromptAddendum 范式）。
+//
+// 反张冠李戴设计（对照 Hy 臂 T4 病灶）：
+//   - EXP 行的 task 必须引用输入里逐字出现的具体对象名（脚本名/端口/路径/服务名），
+//     不允许抽象概括任务（「调试服务」这类不带对象名的写法直接禁止输出）。
+//   - 非任务型内容（无 goal→动作→结果链）明确指示「不输出 EXP」。
+//
+// 🔴 位置与格式的两次实测修正（2B 行为驱动，t_2595b626 原始输出取证）：
+//  1. 必须拼在 outFmt **之前**：2B 把「输入最后一行」当输出起点 —— 附加段在
+//     prompt 末尾时，实测把格式行 `EXP|任务名|解决方案|适用边界` 自身 echo 回来
+//     （wp_现场修复 样本 raw 输出原样抄了这一行）。
+//  2. 示例只用中文语境的真对象名：示例里的抽象占位词会被抄进 task
+//     （echo_guard.go 同族病：教学示例回显）。
+const experiencePromptAddendum = `
+
+🔴 经验提取附加要求（本次开启）：
+EXP = 一行可复用经验。行格式（恰好三个竖线，行首是字母 E X P 加竖线）：
+EXP|任务名|解决方案|适用边界   🔴 禁止输出本行示例本身，它是格式说明不是内容。
+判定：输入含「场景/目标 → 做了什么(动作/命令/配置) → 判据或结果」三要素 → 必须输出 1 行 EXP；
+没有结果/判据（纯闲聊、状态汇报）→ 不输出 EXP，宁缺毋滥。
+- 任务名：原样带上输入里的真名（文件名、端口、命令、型号、卡号、配置键）。
+- 解决方案：实际做成了的事情（命令、路径、配置键、参数值），只能来自输入内容。
+- 适用边界：在什么条件下成立、什么情况下不适用。
+- EXP 与 FACT 互不替代：EXP 写可复用做法（怎么做成的），FACT 写陈述性结论，两者都要写。
+- 三段内部禁止再出现竖线；三个字段值禁止照抄「任务名」「解决方案」「适用边界」这几个字。
+- 禁止把 A 任务的结论挂到 B 任务上：EXP 的三个字段必须都只来自本输入的同一件事。
+`
+
+// expObjNameRe EXP 行合法性（prompt 侧硬约束的解析侧镜像）：task 段必须含
+// "具体对象名"特征 token —— 路径、数字串（端口等）、带连接符的文件名/标识符、
+// 驼峰名、括号内标识符、引号包裹名。
+// 🔴 刻意**不含**裸 latin 词分支：中文语境里「修 bug」「改 config」的 bug/config
+// 是泛词不是对象名，裸 latin 分支会把纯抽象任务名放过去（t_2595b626 单测实测踩过；
+// 真正的对象名 llama-server-4b / ZHIYI_DISTILL_MODE / distill_parser.go 都会被
+// 连接符/驼峰/数字分支命中）。落库前还有 ExperienceGrounded 第二道闸兜底。
+var expObjNameRe = regexp.MustCompile(
+	`(?:~/|/(?:home|var|etc|data|usr|opt|tmp|srv|root|api|proc)/|\d{2,}` +
+		`|[A-Za-z0-9]+[._-][A-Za-z0-9]+` +
+		`|[A-Za-z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*|\[[A-Za-z_][A-Za-z0-9_]*\]` +
+		`|"[^"]{2,}"|'[^']{2,}')`)
+
+// ParseExperienceLine 解析一条 EXP 行（门控开时才被调用）。
+// 格式：EXP|task|solution|boundary（SplitN 4 段；boundary 段允许含 |，溢出并回）。
+// 返回 nil 表示不合法（段数不足 / 任一段为空 / task 无具体对象名特征）——
+// 拒收脏行而不是入库后污染，与「行协议单行坏丢一行」哲学一致。
+func ParseExperienceLine(line string) *ExperienceRecord {
+	// 🔴 TrimPrefix 必须在 SplitN 之前："EXP|a|b|c|d" 用 SplitN(...,4) 直接切
+	// 会把 "EXP" 当第 1 段，真实三段被挤掉尾段 ⇒ 恒 nil（t_2595b626 实测踩过）。
+	if !strings.HasPrefix(line, "EXP|") {
+		return nil
+	}
+	content := strings.TrimSpace(line[len("EXP|"):])
+	parts := strings.SplitN(content, "|", 4)
+	if len(parts) < 3 {
+		return nil
+	}
+	task := strings.TrimSpace(parts[0])
+	task = cleanExpTask(task)
+	solution := strings.TrimSpace(parts[1])
+	boundary := strings.TrimSpace(parts[2])
+	// 第 4 段（模型在 boundary 里多打了 | 的溢出）并回 boundary，不丢信息
+	if len(parts) > 3 {
+		if extra := strings.TrimSpace(parts[3]); extra != "" {
+			boundary = boundary + "|" + extra
+		}
+	}
+	// 🔴 整行只打了 2 段（task|solution，boundary 空）⇒ 拒。
+	// run2136 教训：缺界经验会污染召回（"经验没有边界=到处套"）。
+	if len(parts) < 4 || strings.TrimSpace(parts[3]) == "" {
+		return nil
+	}
+	if task == "" || solution == "" || boundary == "" {
+		return nil
+	}
+	if expEchoTaskRe.MatchString(task) {
+		return nil
+	}
+	if !expObjNameRe.MatchString(task) {
+		return nil
+	}
+	return &ExperienceRecord{Task: task, Solution: solution, Boundary: boundary}
+}
+
+// ExperienceGrounded 反张冠李戴落库闸：task 引用的具体对象必须能在 episode
+// 原文（input.Content）里找到影子，否则该条经验不落库。
+//
+// 判据（确定性、零 LLM）：
+//  1. latin 通道：task 切出对象名候选（含字母、长度 ≥2），任一大小写不敏感
+//     子串出现在原文 ⇒ 接地。
+//  2. 中文通道：task 的 ≥4 字连续汉字段（剔除停用词后），任一以**滑动子串**
+//     （长段取长度 ≥4 的连续子段）出现在原文 ⇒ 接地。
+//     2~3 字段（「端口」「服务」）泛在 ⇒ 不算接地（否则闸被泛词击穿）。
+//  3. 两通道全空 ⇒ 不接地 —— 与 prompt 硬约束同口径：
+//     「task 必须包含输入里出现的具体对象名，否则不输出经验」。
+func ExperienceGrounded(exp ExperienceRecord, episodeContent string) bool {
+	hay := strings.ToLower(episodeContent)
+	// 通道①：latin/数字对象名候选，大小写不敏感子串
+	for _, tok := range expTaskTokens(exp.Task) {
+		if strings.Contains(hay, strings.ToLower(tok)) {
+			return true
+		}
+	}
+	// 通道②：中文段滑动子串（task 常带「的做法/的排查」尾巴，全段相等会误杀）
+	for _, seg := range expTaskCJKSegs(exp.Task) {
+		r := []rune(seg)
+		for i := 0; i+4 <= len(r); i++ {
+			for j := i + 4; j <= len(r); j++ {
+				if strings.Contains(episodeContent, string(r[i:j])) {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+// expTaskTokenRe 从 task 里切"latin/数字对象名候选"：连续 latin/数字/._-/ 段。
+var expTaskTokenRe = regexp.MustCompile(`[A-Za-z0-9][A-Za-z0-9._/-]*`)
+
+// expCJKSegRe 连续汉字段（≥4 字才算"具体对象名"候选）。
+// 2~3 字段（「端口」「服务」「配置」）在任何 episode 里都泛在，若算接地
+// 张冠李戴闸形同虚设 ⇒ 判据取保守方向：只认 ≥4 字连续汉字段。
+var expCJKSegRe = regexp.MustCompile(`[一-鿿]{4,}`)
+
+// expCJKStopSegs 中文段接地闸的停用词段：模板回声/高频功能词，
+// 出现在几乎任何 episode 里，若算接地等于没有闸（宁缺毋滥）。
+var expCJKStopSegs = map[string]bool{
+	"解决方案": true, "适用边界": true, "任务名": true, "什么问题": true,
+	"怎么处理": true, "如何修复": true, "问题修复": true, "经验教训": true,
+	"具体操作": true, "执行步骤": true, "最终结果": true, "使用工具": true,
+	"端口占用": true, "服务重启": true, "配置修改": true, "问题解决": true,
+}
+
+var latinHasLetterRe = regexp.MustCompile(`[A-Za-z]`)
+
+// expEchoTaskRe 反回显闸：task 段以格式说明词（任务名/解决方案/适用边界）开头
+// ⇒ 模型把格式行原样抄了回来（run2136 + 11-07 pos 实验反复实测的 echo_guard 同族病），
+// 整行拒收。
+var expEchoTaskRe = regexp.MustCompile(`^(任务名|解决方案|适用边界)[：:]?`)
+
+// expTaskPrefixRe 剥离 task 段冗余前缀（「为什么：」「做法：」「场景：」等引导词），
+// 与反回显闸（锚定 ^）解耦：剥离后再进闸判定。
+var expTaskPrefixRe = regexp.MustCompile(`^(任务名|解决方案|适用边界|为什么|做法|场景|现象|背景|教训|经验)[：:]\s*`)
+
+func cleanExpTask(task string) string {
+	return strings.TrimSpace(expTaskPrefixRe.ReplaceAllString(task, ""))
+}
+
+func expTaskTokens(task string) []string {
+	var out []string
+	for _, tok := range expTaskTokenRe.FindAllString(task, -1) {
+		t := strings.Trim(tok, "._-/")
+		// 长度 ≥2 且含 latin 字母才算对象名候选（纯数字/连接碎片不算）
+		if len([]rune(t)) >= 2 && latinHasLetterRe.MatchString(t) {
+			out = append(out, t)
+		}
+	}
+	return out
+}
+
+func expTaskCJKSegs(task string) []string {
+	var out []string
+	for _, seg := range expCJKSegRe.FindAllString(task, -1) {
+		if !expCJKStopSegs[seg] {
+			out = append(out, seg)
+		}
+	}
+	return out
+}

go/internal/distill/experience_gate_test.go

@@ -0,0 +1,192 @@
+// t_2595b626 经验层回归用例：
+//
+//	AC1 关态逐字节不变 / EXP 行门控 / 合法性闸 / 反张冠李戴接地判据
+package distill
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// withExperienceGate 临时翻转门控变量（包内测试专用；生产是启动读一次）。
+func withExperienceGate(t *testing.T, on bool, fn func()) {
+	t.Helper()
+	prev := experienceGateEnabled
+	experienceGateEnabled = on
+	defer func() { experienceGateEnabled = prev }()
+	fn()
+}
+
+// AC1：门控关（默认 env 未设）⇒ ParseLineFormat 对 EXP 行 = 静默跳过，
+// 返回与现状逐字一致（exp 行内容不出现在任何返回值里）。
+func TestExperienceGate_Off_EXPLineIgnored(t *testing.T) {
+	if os.Getenv("ZHIYI_DISTILL_EXPERIENCE") == "1" {
+		t.Skip("测试环境显式开了门控，关态用例跳过")
+	}
+	if ExperienceGateEnabled() {
+		t.Fatal("默认 env 下门控应为关")
+	}
+	raw := "FACT|真事实\nEXP|llama-server-4b 端口冲突|改用 8081 代理|仅本机单实例\nSCORE|0.8|0.7|0.6|0.9|0.7\nEND"
+	facts, entities, scores, exps, ok := ParseLineFormat(raw)
+	if !ok || len(facts) != 1 || facts[0] != "真事实" {
+		t.Fatalf("关态 facts 行为变了: %v ok=%v", facts, ok)
+	}
+	if len(exps) != 0 {
+		t.Fatalf("关态 exps 必须恒空，得 %v", exps)
+	}
+	_ = entities
+	_ = scores
+	if strings.Join(facts, "|") == "" {
+		t.Fatal("关态事实丢失")
+	}
+}
+
+// 门控开 ⇒ EXP 行解析成 ExperienceRecord；facts/scores 行为不受影响。
+func TestExperienceGate_On_EXPLineParsed(t *testing.T) {
+	withExperienceGate(t, true, func() {
+		raw := "FACT|llama-server-4b 占用了 8080\nEXP|llama-server-4b 端口冲突|改用 8081 代理卸力|仅本机 llama 单实例场景|仅单实例部署有效\nSCORE|0.8|0.7|0.6|0.9|0.7\nEND"
+		facts, _, scores, exps, ok := ParseLineFormat(raw)
+		if !ok || len(facts) != 1 || scores.IS != 0.8 {
+			t.Fatalf("开态 facts/scores 行为变了: facts=%v scores=%+v", facts, scores)
+		}
+		if len(exps) != 1 {
+			t.Fatalf("期望 1 条经验，得 %d", len(exps))
+		}
+		e := exps[0]
+		if !strings.Contains(e.Task, "llama-server-4b") || e.Solution == "" || e.Boundary == "" {
+			t.Fatalf("字段错位: %+v", e)
+		}
+	})
+}
+
+// 合法性闸：段数不足 / 空段 / task 无具体对象名特征 ⇒ 拒收整行。
+func TestParseExperienceLine_Rejects(t *testing.T) {
+	cases := []struct{ name, line string }{
+		{"段数不足", "EXP|llama 端口|只有一段解法"},
+		{"solution 空", "EXP|llama 端口||有边界"},
+		{"boundary 空", "EXP|llama 端口|有解法|"},
+		{"task 抽象无对象名", "EXP|调试服务|重启解决|通用"},
+		{"task 纯中文抽象", "EXP|修 bug|改了配置|任何情况"},
+	}
+	for _, tc := range cases {
+		if got := ParseExperienceLine(tc.line); got != nil {
+			t.Errorf("%s: 应拒收，得 %+v", tc.name, got)
+		}
+	}
+	// 合法行 + boundary 内含竖线（溢出并回，不丢信息）
+	got := ParseExperienceLine("EXP|distill-granularity B 档|设 ZHIYI_DISTILL_MODE=context 重启|仅对 llm_distill 源生效|不影响 wiki 直写")
+	if got == nil {
+		t.Fatal("合法行被误拒")
+	}
+	if !strings.Contains(got.Boundary, "|不影响 wiki 直写") {
+		t.Fatalf("boundary 溢出段未并回: %q", got.Boundary)
+	}
+	// 反回显闸：格式行被模型原样抄回 ⇒ task 段以格式说明词开头 ⇒ 整行拒
+	if got := ParseExperienceLine("EXP|任务名|解决方案|适用边界（本次开启说明文字）"); got != nil {
+		t.Fatalf("格式行回显应拒收，得 %+v", got)
+	}
+	if got := ParseExperienceLine("EXP|任务名：查证三条|解决方案|适用边界"); got != nil {
+		t.Fatalf("task 带「任务名：」前缀的回显应拒收，得 %+v", got)
+	}
+}
+
+// 反张冠李戴接地闸：task 的 latin 对象名 / 中文长段 在原文出现 ⇒ 接地；
+// 全不在 ⇒ 不接地（不落库）。
+func TestExperienceGrounded(t *testing.T) {
+	episode := "[2026-11-06, 周三] user: llama-server-4b 起不来，端口 8080 被占了，我改用 8081 队列代理卸力"
+	// ① latin 对象名命中
+	if !ExperienceGrounded(ExperienceRecord{Task: "llama-server-4b 端口冲突修复"}, episode) {
+		t.Fatal("latin 对象名应接地")
+	}
+	// ② 中文段是原文子串 ⇒ 命中（task 常带「的做法」这类尾巴，全段相等判据会被误杀，
+	//    故判据=task 汉字段与原文做子串匹配；闸的反例由 ②b/③ 钉死）
+	if !ExperienceGrounded(ExperienceRecord{Task: "队列代理卸力的做法"}, episode) {
+		t.Fatal("task 汉字段是原文子串时应接地")
+	}
+	// ②b 泛词不算接地（张冠李戴闸不被泛词击穿）
+	if ExperienceGrounded(ExperienceRecord{Task: "端口服务配置"}, episode) {
+		t.Fatal("短泛词段不应算接地")
+	}
+	// ③ 张冠李戴：task 引用原文没有的对象且无可命中中文段 ⇒ 拒
+	if ExperienceGrounded(ExperienceRecord{Task: "nginx-ssl 证书过期处理"}, episode) {
+		t.Fatal("引用原文所无对象应判不接地")
+	}
+	// ④ 大小写不敏感
+	if !ExperienceGrounded(ExperienceRecord{Task: "LLama-Server-4B 排查"}, episode) {
+		t.Fatal("大小写变体应接地")
+	}
+}
+
+// AC1 核心：门控关态下 callLLM5DUncached 构造的 prompt 与「无经验层代码」时
+// 逐字节一致 —— 即附加段仅在开关开时拼接，instr/outFmt 常量零改动。
+func TestExperienceGate_OffPromptByteIdentical(t *testing.T) {
+	// 断言 1：附加段说明 EXP 行格式
+	if !strings.Contains(experiencePromptAddendum, "EXP") || !strings.Contains(experiencePromptAddendum, "任务名") {
+		t.Fatal("附加段缺 EXP 格式说明")
+	}
+	// AC1 断言 3（run2136 修正口径）：格式行字面量「EXP|任务名|解决方案|适用边界」
+	// 必须存在（模型靠它认格式，v9 实验证明去掉它模型不产 EXP）；但它被
+	// 「🔴 禁止输出本行示例本身」条款 + ParseExperienceLine 的 task 段拒收闸
+	// （ECHO_TASK：task 以 任务名/解决方案/适用边界 开头 ⇒ 整行拒）双道兜底。
+	if !strings.Contains(experiencePromptAddendum, "EXP|任务名|解决方案|适用边界") {
+		t.Fatal("附加段缺 EXP 格式行字面量")
+	}
+	if !strings.Contains(experiencePromptAddendum, "禁止输出本行示例本身") {
+		t.Fatal("格式行旁必须有反回显条款（echo_guard 同族病兜底）")
+	}
+	// 断言 2：关态 ⇒ engine.go 里经验段永远不进 prompt（代码级钉子：
+	// 拼接点只有 `if experienceGateEnabled` 一处）。
+	src, err := os.ReadFile("engine.go")
+	if err != nil {
+		t.Skip("源文件不可读（非源码树跑测试），跳过代码级钉子")
+	}
+	if n := strings.Count(string(src), "experiencePromptAddendum"); n != 1 {
+		t.Fatalf("experiencePromptAddendum 在 engine.go 应只出现 1 处（唯一拼接点），得 %d", n)
+	}
+	if !strings.Contains(string(src), "if experienceGateEnabled {\n		promptStr = promptStr + experiencePromptAddendum") {
+		t.Fatal("拼接点必须包在 if experienceGateEnabled 内")
+	}
+}
+
+// 打分缓存键换代：开态与关态对同一 content 的 scoreKey 必须不同，
+// 关态与历史逐字节一致（无附加后缀）。
+func TestExperienceGate_ScoreKeyVersioning(t *testing.T) {
+	content := "同一段内容"
+	// 🔴 测试 env 非真空：跑批/灰度 shell 里 export 过的 ZHIYI_* 会被测试进程继承
+	// （实测踩过：AB 跑批后同 shell 跑测试，experienceGateEnabled=true ⇒ 基线 off 键
+	// 带 experience 后缀 ⇒ 「关态键恒等/纯 sha256」两条断言必炸）。
+	// 本用例只测 experience 门控对键的影响 ⇒ 三个环境敏感因子全部显式钉死。
+	t.Setenv("ZHIYI_DISTILL_EXPERIENCE", "0")
+	t.Setenv("ZHIYI_DISTILL_DENSITY", "0")
+	t.Setenv("ZHIYI_DISTILL_MODE", "context")
+	densityPrev := densityGateEnabled
+	densityGateEnabled = false
+	expPrev := experienceGateEnabled
+	experienceGateEnabled = false
+	modePrev := distillMode
+	distillMode = "context"
+	defer func() {
+		densityGateEnabled = densityPrev
+		experienceGateEnabled = expPrev
+		distillMode = modePrev
+	}()
+	off := scoreKey(content)
+	withExperienceGate(t, false, func() {
+		if scoreKey(content) != off {
+			t.Fatal("关态键应恒等")
+		}
+	})
+	withExperienceGate(t, true, func() {
+		if scoreKey(content) == off {
+			t.Fatal("开态键必须换代（旧 prompt 缓存不得短路新 prompt）")
+		}
+	})
+	// 关态键 = 纯 sha256(content)，无 \x00 后缀（densityPrev 已在函数顶部钉死）
+	withExperienceGate(t, false, func() {
+		k := scoreKey("abc")
+		if len(k) != 64 {
+			t.Fatalf("关态键应为纯 sha256 hex(64)，得 len=%d", len(k))
+		}
+	})
+}

go/internal/distill/gate_counter.go

@@ -0,0 +1,98 @@
+// 织忆 MemoryWeave — 蒸馏闸门拒绝的可观测计数器（t_a513b870 AC1）
+//
+// 背景：Enqueue / auto_distill 的硬规则拒绝分支曾经是**黑洞**——不打日志、不计数。
+// 7 天被硬规则拒掉多少条，系统里查不到。本文件把「在硬规则层拦掉多少」变成
+// 并发安全的真计数器，并按拒绝规则分桶；同时记录「进入蒸馏队列的量」作分母，
+// 让记分牌 ⑪ 的百分比与命中数同源（不再是 journal 两处拼凑）。
+package distill
+
+import (
+	"log"
+	"sync"
+)
+
+// rejectBuckets 硬规则拒绝的分桶（与 rules.go hardRejectReason 一一对应）。
+// 除卡上点名的 5 桶（空/过短/闲聊/知识问答/系统样板）外，密度不足与超长也是
+// HardRulesPass 的真实拒绝原因——不计数它们=重新制造黑洞，故一并纳入。
+var rejectBuckets = []string{
+	"empty",        // 空内容
+	"too_short",    // 过短(<10字且非人侧短事实)
+	"chitchat",     // 纯闲聊/问候
+	"qa",           // 纯知识问答
+	"sys_template", // 系统样板（textfilter.IsSystemTemplate，2026-11-10 移入硬规则层）
+	"low_density",  // 内容密度 < 0.3
+	"too_long",     // 超长(>5000 字符)
+}
+
+// gateCounter 硬规则闸门计数（并发安全）。单实例进程内共享，跨 Go/Rust 进程不共享：
+// 计数语义 = 本进程自启动以来的累计（重启清零），与 journal 窗口口径不同属预期。
+type gateCounter struct {
+	mu       sync.Mutex
+	byRule   map[string]uint64 // rule -> 拒绝次数
+	attempts uint64            // 闸门被评估的总次数（含 pass+reject）
+	entered  uint64            // 通过闸门、真正进入蒸馏队列的次数
+}
+
+var gate = &gateCounter{byRule: map[string]uint64{}}
+
+func init() {
+	// 预置全部分桶，保证读端（/api/v1/metrics）对零拒绝桶也能稳定出字段。
+	for _, b := range rejectBuckets {
+		gate.byRule[b] = 0
+	}
+}
+
+// RecordHardReject 登记一次硬规则拒绝（须在 reject 分支上、拿到具体 rule 再调）。
+// 幂等调用方约定：同一 logical 内容被 auto_distill:41 与 Enqueue:422 双层评估时，
+// 只有先到的拒绝分支会登记（后一层不会到达）——故 rejected 不重复计数。
+// 并发安全：内置 mutex（auto_distill 不持有 engine.mu，不能依赖调用方加锁）。
+func RecordHardReject(rule string, content string) {
+	gate.mu.Lock()
+	gate.attempts++
+	if _, ok := gate.byRule[rule]; !ok {
+		gate.byRule[rule] = 0
+	}
+	gate.byRule[rule]++
+	gate.mu.Unlock()
+
+	// 至少一行日志（AC1），含 rule 名，供 journal 审计与坏样本回归 grep。
+	log.Printf("[GATE][REJECT] rule=%s content=%q", rule, truncate(content, 60))
+}
+
+// RecordGatePass 登记一次闸门通过（Enqueue 判定 pass ）。auto_distill 的 pass 分支
+// 会再去 Enqueue 二次评估，那里也会判定一次 pass——两处均为真实闸门评估，attempts
+// 如实累计；entered 只在 Enqueue 真正 append 后 +1，作 ⑪ 的干净分母。
+func RecordGatePass() {
+	gate.mu.Lock()
+	gate.attempts++
+	gate.mu.Unlock()
+}
+
+// RecordEnteredQueue 登记一次真正入队（Enqueue append 成功后调）。作 ⑪ 分母。
+func RecordEnteredQueue() {
+	gate.mu.Lock()
+	gate.entered++
+	gate.mu.Unlock()
+}
+
+// GateStats 返回闸门计数快照（读端用，禁止直接摸 gate 内部）。
+// byRule 为副本；attempts/entered 为累计整型。
+func GateStats() (attempts uint64, entered uint64, byRule map[string]uint64) {
+	gate.mu.Lock()
+	defer gate.mu.Unlock()
+	m := make(map[string]uint64, len(gate.byRule))
+	for k, v := range gate.byRule {
+		m[k] = v
+	}
+	return gate.attempts, gate.entered, m
+}
+
+// RejectedByRuleTotal 拒绝总次数（所有分桶之和）。读端 /api/v1/metrics 简化为一个数。
+func RejectedByRuleTotal() uint64 {
+	_, _, byRule := GateStats()
+	var t uint64
+	for _, v := range byRule {
+		t += v
+	}
+	return t
+}

go/internal/distill/gate_counter_test.go

@@ -0,0 +1,198 @@
+package distill
+
+// t_a513b870 AC3：硬规则拒绝计数单测 —— 5 个指定分桶（+密度/超长两个伴随分桶）
+// 各命中 1 条 → 该分桶计数 +1；进入队列的分母同步 +1。计数为进程级共享状态，
+// 故全部断言用「相对增量」（测试前快照 → 测试后差值），避免与其他测试相互污染。
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+)
+
+// gateDelta 采样当前闸门计数，返回变化前后差值的断言辅助闭包。
+// 用法：bl := gateDelta(); 触发 N 次; bl.expectReject("empty", 1) 等。
+type gateDelta struct {
+	attempts, entered uint64
+	byRule            map[string]uint64
+}
+
+func captureGateDelta() gateDelta {
+	var (
+		bl       gateDelta
+		attempts uint64
+		entered  uint64
+		m        map[string]uint64
+	)
+	attempts, entered, m = GateStats()
+	bl.attempts, bl.entered = attempts, entered
+	bl.byRule = map[string]uint64{}
+	for k, v := range m {
+		bl.byRule[k] = v
+	}
+	return bl
+}
+
+func (bl gateDelta) deltaAttempts() uint64    { a, _, _ := GateStats(); return a - bl.attempts }
+func (bl gateDelta) deltaEntered() uint64     { _, e, _ := GateStats(); return e - bl.entered }
+func (bl gateDelta) deltaRule(rule string) uint64 {
+	_, _, m := GateStats()
+	return m[rule] - bl.byRule[rule]
+}
+
+// TestHardRulesRejectBuckets 覆盖「可经规则分类器命中的」拒绝分桶各 1 条 → 各分桶 +1，
+// 且返回的 reason 与分桶一致（reason 即分桶名，供日志审计对齐）。
+//
+// ⚠️ 测试输入必须满足「先序规则全不命中」才能到达目标桶（规则按
+// 空→样板→过短→闲聊→知识问答→密度→超长 顺序短路）：
+//   · 闲聊桶的 pattern 全部 <10 字 ⇒ 恒先被「过短(<10字)」拦截 → **不可达**
+//     （与 lane=drop 同构的坏样本；chitchat 桶的计数能力另在
+//     TestRejectCounterEveryBucket 用直调 RecordHardReject 验证）
+//   · 知识问答/x 类前缀输入必须 ≥10 字才能越过「过短」到达 qa 桶
+//   · 超长输入必须内容多样（信息密度 ≥0.3）才能越过「密度」到达 too_long 桶
+func TestHardRulesRejectBuckets(t *testing.T) {
+	cases := []struct {
+		rule    string
+		content string
+	}{
+		{"empty", "   	\n"},                                                // 空内容
+		{"too_short", "哦"},                                                  // 过短(<10字且非人侧短事实)
+		{"qa", "什么是闭包和递归以及高阶函数的设计原则与适用场景"}, // 知识问答（≥10字越过过短）
+		{"sys_template", "[HEARTBEAT] tick 2026-11-10"},                    // 系统样板
+		{"low_density", "好的      好的      好的      好的      好的      好       好"}, // 低密度重复
+		{"too_long", genLong(5500)},                                        // 超长(>5000字符)，内容多样保密度
+	}
+
+	for _, c := range cases {
+		t.Run(c.rule, func(t *testing.T) {
+			bl := captureGateDelta()
+			pass, reason := HardRulesPassWithReason(c.content)
+			if pass {
+				t.Fatalf("[%s] 期望拒绝，实际通过: %.40q", c.rule, c.content)
+			}
+			if reason != c.rule {
+				t.Fatalf("[%s] reason=%q，期望 %q（reason 必须与分桶同名，供日志/读端对齐）", c.rule, reason, c.rule)
+			}
+			if got := bl.deltaRule(c.rule); got != 1 {
+				t.Fatalf("[%s] 分桶计数 delta=%d，期望 1（同一输入只计一次）", c.rule, got)
+			}
+			// 拒绝不进入队列：entered 必须为 0
+			if en := bl.deltaEntered(); en != 0 {
+				t.Fatalf("[%s] 拒绝却 entered delta=%d，期望 0（拒绝项不得入队）", c.rule, en)
+			}
+		})
+	}
+}
+
+// TestChitchatRuleUnreachableByClassifier 钉死一个结构性事实（AC4 同源）：
+// 闲聊桶的 pattern 全部 <10 字，而「过短(<10字)」规则先短路 ⇒ 任何闲聊内容
+// 都先被拒为 too_short，chitchat 桶经 HardRulesPassWithReason **恒不可达**。
+// 这与 lane=drop 同构：规则存在但当前调用链到不了。保留桶（防御未来路径），
+// 但必须在文档里写明它当前不会由分类器产生。
+func TestChitchatRuleUnreachableByClassifier(t *testing.T) {
+	bl := captureGateDelta()
+	pass, reason := HardRulesPassWithReason("你好")
+	if pass || reason != "too_short" {
+		t.Fatalf("'你好' 期望被拒为 too_short（先于 chitchat 短路），实际 pass=%v reason=%q", pass, reason)
+	}
+	if got := bl.deltaRule("chitchat"); got != 0 {
+		t.Fatalf("chitchat 桶不应+1（不可达），got %d", got)
+	}
+	if got := bl.deltaRule("too_short"); got != 1 {
+		t.Fatalf("too_short 桶应+1，got %d", got)
+	}
+}
+
+// TestRejectCounterEveryBucket 从**计数器层**验证全部分桶（含不可达的 chitchat）
+// 的计数能力 + 并发安全：直调 RecordHardReject 对 7 个桶各 +1，读回并断言总数。
+// 这证明「即使某规则当前不可达，读到 rejected_by_rule_chitchat 也有真实语义」。
+func TestRejectCounterEveryBucket(t *testing.T) {
+	bl := captureGateDelta()
+	for _, b := range rejectBuckets {
+		RecordHardReject(b, "probe-"+b)
+	}
+	_, _, byRule := GateStats()
+	for _, b := range rejectBuckets {
+		if byRule[b]-bl.byRule[b] != 1 {
+			t.Fatalf("桶 %s delta=%d，期望 1", b, byRule[b]-bl.byRule[b])
+		}
+	}
+	total := RejectedByRuleTotal()
+	var sum uint64
+	_, _, m := GateStats()
+	for _, v := range m {
+		sum += v
+	}
+	if total != sum {
+		t.Fatalf("rejected 总数 %d ≠ 各桶之和 %d（读口自洽要成立）", total, sum)
+	}
+}
+
+// TestHardRulesRejectLogLine 拒绝至少打一行 [GATE][REJECT] rule=… 日志（AC1 验收）。
+// 本仓日志走 log 包 → 测试环境不可见，故改为回归日志格式串本身：
+// 断言通过 record 的组成满足「含 GATE/REJECT/rule=」，而不是靠抓测试日志。
+func TestHardRulesRejectReasonFormatMatchesLogContract(t *testing.T) {
+	_, reason := HardRulesPassWithReason("[System note: you are a scheduled job]")
+	expect := fmt.Sprintf("[GATE][REJECT] rule=%s content=", "sys_template")
+	// 真实日志由 RecordHardReject 打印；这里验证分桶名确实在 reject 日志的规则白名单里
+	ok := false
+	for _, b := range rejectBuckets {
+		if b == reason {
+			ok = true
+			break
+		}
+	}
+	if !ok {
+		t.Fatalf("reason=%q 不在 rejectBuckets 白名单，日志消费方无法对齐分桶。'\n  %s'", reason, expect)
+	}
+}
+
+// TestGatePassEnteredQueue 通过闸门 → entered 分母 +1（入队计数）。
+func TestGatePassEnteredQueue(t *testing.T) {
+	bl := captureGateDelta()
+	pass, _ := HardRulesPassWithReason("牧尘决定明天把织忆记分牌跑一遍并归档结果。")
+	if !pass {
+		t.Fatal("正常长内容应通过硬规则")
+	}
+	// Enqueue 的 append 只算 entered（模拟：调用与 Enqueue 一致登记）
+	RecordEnteredQueue()
+	if en := bl.deltaEntered(); en != 1 {
+		t.Fatalf("entered delta=%d，期望 1", en)
+	}
+	if rj := bl.deltaRule("empty"); rj != 0 {
+		t.Fatalf("通过项不应计入任何拒绝分桶，got empty delta=%d", rj)
+	}
+}
+
+// TestGateCounterConcurrent 并发安全：N 个 goroutine 各拒 1 条，分桶/总数不丢。
+func TestGateCounterConcurrent(t *testing.T) {
+	bl := captureGateDelta()
+	const n = 200
+	var wg sync.WaitGroup
+	for i := 0; i < n; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			HardRulesPassWithReason("哦") // too_short
+		}()
+	}
+	wg.Wait()
+	if got := bl.deltaRule("too_short"); got != n {
+		t.Fatalf("并发 after %d 次 too_short delta=%d，期望 %d（丢失计数）", n, got, n)
+	}
+	if bl.deltaAttempts() != n {
+		t.Fatalf("并发 attempts delta=%d，期望 %d", bl.deltaAttempts(), n)
+	}
+}
+
+// genLong 生成 n 个字符的普通长文本（用于超长分桶）。
+// 必须内容多样（不同中文字 + 标点断句）以保住信息密度 ≥0.3，
+// 否则会先被「密度(<0.3)」拦截，到不了 too_long 桶。
+func genLong(n int) string {
+	src := []rune("记织忆系统今日排查审计指标运行状态良好，数据写入读取均正常，召回延迟处于低位。")
+	b := make([]rune, 0, n)
+	for len(b) < n {
+		b = append(b, src...)
+	}
+	return string(b[:n])
+}

go/internal/distill/granularity_gate.go

@@ -0,0 +1,89 @@
+//go:build !ignore
+
+package distill
+
+// 织忆 · 蒸馏粒度重构（t_afacc477，2026-10-31 交付分支，未部署）
+//
+// 背景：现状 prompt（A）输出 p50=23 字、97.2% 短于 60 字、可执行标记仅 26.5%，
+// 11:1 压缩是粒度设计造成的（2B 与 agnes 一样碎）。同 128 episode 隔离 A/B/C 对照（E1）：
+//   A(现状)  p50=23  条/ep 6.51  act=26.5%  lt60=97.2%
+//   B(上下文) p50=47  条/ep 2.61  act=50.6%  lt60=71.0%   ← 推荐
+//   C(合并)  p50=34  条/ep 2.37  act=35.3%  lt60=83.5%
+// E2（>1000 字截断层）上 B/C 更优：C@cap1000 act=57.1%，C@cap2000 act=62.2%。
+// glm-4-flash judge（异源）：可复用均分 A 4.32 / B 4.16 / C 4.04；碎片化率 A 10.2% vs B 5.5% / C 6.3%。
+//
+// 本改动 = 三档开关 + 截断可配（全部 env 门控，默认值 = 推荐项 B；不改 A 的默认行为语义之外的一切）：
+//   ZHIYI_DISTILL_MODE    current | context | merged    （默认 context，即 B；current=现状逐字节等价 A）
+//   ZHIYI_DISTILL_CAP     截断字符数（默认 1000=现状；2000/none 可配；0=不截断）
+//   ZHIYI_DISTILL_DENSITY  旧开关（t_ab5b2461）保留兼容：=1 时叠加密度门判据
+//
+// 红线合规：不改 FUSION_W/FEEDBACK_BIAS/POS_MODE，不重启 zhiyid（本改动只进分支+建议）；
+// 默认值切换需重启才生效（与 proceduralShadowMode 同款启动读一次范式）。
+
+import "os"
+
+// 三档粒度附加段（t_afacc477）：B=上下文信息量门槛；C=合并粒度（≤3 条、自包含可复用）。
+// 与 t_ab5b2461 的 densityPromptAddendum 独立：density 是判据门（≥2 项才 keep），
+// 本段是 prompt 侧粒度重构（改的是「怎么写」，不是「写几条」的准入）。
+const (
+	// addendumContext（B 档）：每条 fact 必含 场景/原因/动作/判据 中至少 2 项。
+	// 措辞取自 t_afacc477 隔离对照 B 臂（AC1 p50 23→47、act 26.5%→50.6%）。
+	addendumContext = `
+🔴 本次附加要求（信息量门槛，最高优先，覆盖上面「轻量补全」的从简倾向）:
+每条 FACT 不能只写"做了什么"，必须写成可复用的一条完整知识，且至少包含下面四项中的【两项】：
+  ① 在什么场景（什么任务/什么条件下遇到这件事）
+  ② 因为什么（原因、触发条件、根因）
+  ③ 做什么（具体动作、命令、文件路径、配置键、参数值）
+  ④ 判据是什么（怎么判断成功/失败、阈值、数值、验收标准）
+写法示例（照此信息量写，不要照抄内容）:
+FACT|在排查服务停摆的场景下，因为某个环境变量的缺失导致某配置被重置，所以要补回该配置并重启服务，判据是日志出现对应端点且数秒内完成。
+仍然禁止编造原文没有的内容；原文信息不足两项时，宁可少写一条，也不许用水话凑字。
+`
+	// addendumMerged（C 档）：一个 episode 最多 3 条，每条自包含可复用（不是对话摘要）。
+	// 措辞取自 t_afacc477 隔离对照 C 臂（条数 6.5→2.4、act 35.3%、judge 碎片化率 6.3%）。
+	addendumMerged = `
+🔴 本次附加要求（合并粒度，最高优先，覆盖上面「逐条处理、每条一行、facts 要详尽」的倾向）:
+1. 最多输出 3 条 FACT。把同一件事的所有相关要素（场景、原因、动作、命令、路径、阈值、结论、判据）【合并进同一条】，写成一句自足的话。
+2. 每条 FACT 必须自包含且可复用：未来的读者不需要再看其它 FACT 或原始对话，就能照它行动或回答提问。
+3. 🔴 禁止写成"对话摘要"（如「用户讨论了X」「他们确认了Y」）—— 要写事实本身与可执行结论。
+4. 原文信息不足时宁可只输出 1 条，绝不为凑 3 条拆分成碎片。
+`
+)
+
+// distillMode 启动时读一次。默认 "context"（B 档，t_afacc477 推荐）；
+// 部署方若要回到现状 A，设 ZHIYI_DISTILL_MODE=current；merged = C 档。
+var distillMode = os.Getenv("ZHIYI_DISTILL_MODE")
+
+func init() {
+	if distillMode == "" {
+		distillMode = "context"
+	}
+}
+
+// distillCap 截断字符数（默认 1000=engine.go:759 现状）。0 或 "none" = 不截断。
+var distillCap = 1000
+func init() {
+	if v := os.Getenv("ZHIYI_DISTILL_CAP"); v != "" {
+		if v == "none" {
+			distillCap = 0
+		} else {
+			n := 0
+			for _, c := range v {
+				if c < '0' || c > '9' {
+					n = -1
+					break
+				}
+				n = n*10 + int(c-'0')
+			}
+			if n > 0 {
+				distillCap = n
+			}
+		}
+	}
+}
+
+// DistillCap 对外读口（=0 表示不截断；否则为字符上限）。
+func DistillCap() int { return distillCap }
+
+// DistillMode 对外读口（current/context/merged）。
+func DistillMode() string { return distillMode }

go/internal/distill/llm_judge.go

@@ -0,0 +1,201 @@
+// 织忆 MemoryWeave —— 写时四操作的 LLM 判定器（t_writeops_llm_judge，2026-10-25）
+//
+// 背景（离线回放实测，不是推测）：
+//   · 规则基 defaultJudge 用 ZHIYI_WRITE_SIM_UPDATE=0.70 判 UPDATE，影子日志 11 天 17179 条里
+//     14435 条（84%）被判「新事实应覆盖旧事实」；人工抽检 15 条低相似度样本，15/15 不是真覆盖
+//     （「用户查看知乎链接」vs「用户查看微信文章」都判成覆盖）。
+//   · 80 条分层回放（各相似度档 20 条，LLM 三分类）：REPLACE 率 0.95+ 档 25%、0.90-0.95 档 35%、
+//     0.85-0.90 档 35%、0.70-0.85 档 20% —— 与相似度**不单调**，说明相似度只反映「话题相关」，
+//     不反映「是否同一属性的新旧值」。低档 LLM 同样会被话题带偏（0.70-0.85 档 REPLACE 精度约 25%）。
+//
+// 结论与实现：
+//   · 只有 sim >= ZHIYI_WRITE_JUDGE_SIM（默认 0.95）才调 LLM 判三分类；低于该档直接 ADD（不调 LLM，
+//     省调用 + 该档不可信）。
+//   · REPLACE→UPDATE / DUPLICATE→NOOP / KEEP→ADD；判不准与调用失败一律兜底 ADD（宁可不覆盖）。
+//   · 默认 judge 模式仍是 rule（零行为变化）；apply 模式强制要求 llm（见 write_ops.go 硬保护）。
+package distill
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const llmJudgeSystemPrompt = `你是记忆库的写入判定器。给你两条记忆：A=库里已有的旧事实，B=刚提取出的新事实。
+判断 B 与 A 的关系，只回一个词，不要解释：
+REPLACE  = 同一主体的同一属性，B 是 A 的更新值/修正值（B 生效后 A 就过时了）
+DUPLICATE= B 与 A 语义等价，B 没有新增信息
+CONFLICT = 同一主体的同一属性，A 与 B 给出互斥的不同取值（两者不可能同时成立，且没有先后更新关系——不是「旧值被新值取代」，而是「两种互相矛盾的说法」）
+KEEP     = B 补充/细化/扩展 A，或讲不同侧面/不同对象/不同阶段；两条都要保留
+判不准时回 KEEP。回 CONFLICT 前必须能说出「同一个属性是什么」以及两侧各自的取值；说不出具体属性或取值就回 KEEP。
+说得出但只是「话题相关」（同一对象的不同侧面/不同时间的不同事件）也回 KEEP。`
+
+// llmJudgeSimThreshold 低于此相似度直接 ADD（实测该档 LLM 判定精度不足，且省调用）。
+const llmJudgeSimThresholdDefault = 0.95
+
+// llmJudgeCall 可注入的 LLM 调用（单测替换，生产走 HTTP）。返回模型输出的原始文本。
+var llmJudgeCall = callLLMJudgeModel
+
+// LLMJudgeMode 当前 judge 模式：rule（默认）| llm。
+func LLMJudgeMode() string {
+	m := strings.ToLower(strings.TrimSpace(os.Getenv("ZHIYI_WRITE_JUDGE")))
+	if m == "llm" {
+		return "llm"
+	}
+	return "rule"
+}
+
+// llmJudgeSimThreshold 判定相似度门槛（env 可调）。
+func llmJudgeSimThreshold() float64 {
+	if v := strings.TrimSpace(os.Getenv("ZHIYI_WRITE_JUDGE_SIM")); v != "" {
+		if f, err := strconv.ParseFloat(v, 64); err == nil && f > 0 && f <= 1 {
+			return f
+		}
+	}
+	return llmJudgeSimThresholdDefault
+}
+
+// LLMJudge 用 LLM 判「B 是否应取代 A」。
+// 返回的 WriteVerdict 与 defaultJudge 同构，调用方无需区分。
+func LLMJudge(candidate string, similar []SimilarMemory) WriteVerdict {
+	v := WriteVerdict{
+		Op:        OpAdd,
+		Candidate: candidate,
+		Reason:    "llm:无相似候选 → 新建",
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+	if len(similar) == 0 {
+		return v
+	}
+	top := similar[0] // 调用方已按相似度排序（TopN）
+	v.Similarity = top.Similarity
+
+	// 归一化完全等价 → NOOP，不调 LLM
+	if NormalizeContent(top.Content) == NormalizeContent(candidate) {
+		v.Op = OpNoop
+		v.TargetID = top.ID
+		v.Reason = "llm:归一化等价 → 丢弃"
+		return v
+	}
+
+	// 相似度不足 → ADD（实测低档 LLM 判定不可信，且省钱）
+	if top.Similarity < llmJudgeSimThreshold() {
+		v.Reason = fmt.Sprintf("llm:sim %.3f < %.2f → 不判，新建", top.Similarity, llmJudgeSimThreshold())
+		return v
+	}
+
+	raw, err := llmJudgeCall(candidate, top.Content)
+	if err != nil {
+		// 调用失败兜底 ADD：宁可不覆盖（漏覆盖可事后补，误覆盖会丢事实）
+		v.Reason = "llm:调用失败兜底新建"
+		log.Printf("[write-ops][llm-judge] 调用失败，兜底 ADD: %v candidate=%.40s", err, candidate)
+		return v
+	}
+	verdict := parseLLMJudgeVerdict(raw)
+	switch verdict {
+	case "REPLACE":
+		v.Op = OpUpdate
+		v.TargetID = top.ID
+		v.Reason = "llm:同一属性更新 → 旧条标 superseded_by"
+	case "DUPLICATE":
+		v.Op = OpNoop
+		v.TargetID = top.ID
+		v.Reason = "llm:语义等价 → 丢弃"
+	case "CONFLICT":
+		// 2026-11-03：LLM 补第四类 CONFLICT（原三分类无「互斥」出口，矛盾只能被
+		// 塞进 REPLACE（误覆盖）或 KEEP（漏矛盾））。此处只**提出**冲突假设，
+		// 是否真矛盾由 JudgeWriteOp 出口的 AC-1 确定性门（同主体+同属性+不同取值）
+		// 裁定；不过门自动降级 UPDATE/ADD。LLM 单方面无权写 conflict 标记。
+		v.Op = OpConflictMark
+		v.TargetID = top.ID
+		v.Reason = "llm:同一属性互斥取值 → 冲突假设（待出口判据门复核）"
+	default: // KEEP / 无法解析
+		v.Reason = "llm:保留（补充/不同侧面）→ 新建"
+	}
+	return v
+}
+
+// parseLLMJudgeVerdict 从模型输出里取四分类词；取不到返回 KEEP。
+// 规则：① 首行/整串严格等于某类 → 直接采用（最常见形态）；② 否则取**最先出现**的
+// 分类词（不按枚举顺序优先，避免「不是 REPLACE，是 KEEP」这类解释句被固定顺序带偏）。
+func parseLLMJudgeVerdict(raw string) string {
+	u := strings.ToUpper(strings.TrimSpace(raw))
+	head := strings.TrimSpace(strings.SplitN(u, "\n", 2)[0])
+	head = strings.Trim(head, " 	.。,:：\"'*`")
+	for _, k := range []string{"CONFLICT", "REPLACE", "DUPLICATE", "KEEP"} {
+		if head == k {
+			return k
+		}
+	}
+	best, bestIdx := "KEEP", -1
+	for _, k := range []string{"CONFLICT", "REPLACE", "DUPLICATE", "KEEP"} {
+		if i := strings.Index(u, k); i >= 0 && (bestIdx < 0 || i < bestIdx) {
+			best, bestIdx = k, i
+		}
+	}
+	return best
+}
+
+// callLLMJudgeModel 调判定模型，返回 message.content。配置项与对抗审计同构。
+func callLLMJudgeModel(candidate, existing string) (string, error) {
+	endpoint := envStr("ZHIYI_WRITE_JUDGE_ENDPOINT", "http://127.0.0.1:3000/v1/chat/completions")
+	model := envStr("ZHIYI_WRITE_JUDGE_MODEL", "agnes-2.5-flash")
+	key := envStr("ZHIYI_WRITE_JUDGE_KEY", "")
+	if key == "" {
+		key = os.Getenv("LLM_API_KEY")
+	}
+	timeout := time.Duration(envFloat("ZHIYI_WRITE_JUDGE_TIMEOUT", 30)) * time.Second
+
+	body := map[string]interface{}{
+		"model": model,
+		"messages": []map[string]string{
+			{"role": "system", "content": llmJudgeSystemPrompt},
+			{"role": "user", "content": fmt.Sprintf("A（旧）: %s\n\nB（新）: %s", existing, candidate)},
+		},
+		"temperature":      0,
+		"max_tokens":       100,
+		"reasoning_effort": "none", // 实测：不给 none 时 reasoning 会吃光 max_tokens，content 返空
+	}
+	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()
+	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("judge HTTP %d: %.120s", resp.StatusCode, string(raw))
+	}
+	var parsed struct {
+		Choices []struct {
+			Message struct {
+				Content string `json:"content"`
+			} `json:"message"`
+		} `json:"choices"`
+	}
+	if err := json.Unmarshal(raw, &parsed); err != nil {
+		return "", fmt.Errorf("judge 响应解析失败: %w", err)
+	}
+	if len(parsed.Choices) == 0 {
+		return "", fmt.Errorf("judge 响应无 choices")
+	}
+	return parsed.Choices[0].Message.Content, nil
+}

go/internal/distill/llm_judge_test.go

@@ -0,0 +1,217 @@
+package distill
+
+import (
+	"errors"
+	"os"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+// withFakeLLMJudge 注入假 LLM 调用，返回调用次数计数器。
+func withFakeLLMJudge(t *testing.T, reply string, err error) *int32 {
+	t.Helper()
+	var calls int32
+	orig := llmJudgeCall
+	llmJudgeCall = func(candidate, existing string) (string, error) {
+		atomic.AddInt32(&calls, 1)
+		return reply, err
+	}
+	t.Cleanup(func() { llmJudgeCall = orig })
+	return &calls
+}
+
+func similarTop(id, content string, sim float64) []SimilarMemory {
+	return []SimilarMemory{{ID: id, Content: content, Similarity: sim}}
+}
+
+// 低相似度档（实测 LLM 判定不可信）必须短路，不调 LLM。
+func TestLLMJudge_LowSimilaritySkipsLLM(t *testing.T) {
+	calls := withFakeLLMJudge(t, "REPLACE", nil)
+	v := LLMJudge("新事实", similarTop("mem_1", "旧事实", 0.80))
+	if v.Op != OpAdd {
+		t.Fatalf("sim 0.80 应判 ADD，得到 %s", v.Op)
+	}
+	if got := atomic.LoadInt32(calls); got != 0 {
+		t.Fatalf("sim 低于门槛时不应调用 LLM，实际调用 %d 次", got)
+	}
+}
+
+func TestLLMJudge_Replace(t *testing.T) {
+	withFakeLLMJudge(t, "REPLACE", nil)
+	v := LLMJudge("executions.db 台账 max_rowid 为 185769",
+		similarTop("mem_x", "executions.db 台账 max_rowid 为 183371", 0.97))
+	if v.Op != OpUpdate {
+		t.Fatalf("REPLACE 应判 UPDATE，得到 %s", v.Op)
+	}
+	if v.TargetID != "mem_x" {
+		t.Fatalf("UPDATE 必须带 TargetID，得到 %q", v.TargetID)
+	}
+}
+
+func TestLLMJudge_Duplicate(t *testing.T) {
+	withFakeLLMJudge(t, "DUPLICATE", nil)
+	v := LLMJudge("该软件支持PDF与Word互转", similarTop("mem_y", "工具支持PDF与Word互转", 0.96))
+	if v.Op != OpNoop {
+		t.Fatalf("DUPLICATE 应判 NOOP，得到 %s", v.Op)
+	}
+}
+
+// KEEP=补充/不同侧面 → 必须新建，不能覆盖。
+func TestLLMJudge_Keep(t *testing.T) {
+	withFakeLLMJudge(t, "KEEP", nil)
+	v := LLMJudge("用户查看微信文章", similarTop("mem_z", "用户查看知乎链接", 0.97))
+	if v.Op != OpAdd {
+		t.Fatalf("KEEP 应判 ADD，得到 %s", v.Op)
+	}
+	if v.TargetID != "" {
+		t.Fatalf("ADD 不应带 TargetID，得到 %q", v.TargetID)
+	}
+}
+
+// LLM 调用失败必须兜底 ADD（宁可不覆盖）。
+func TestLLMJudge_CallErrorFallsBackToAdd(t *testing.T) {
+	withFakeLLMJudge(t, "", errors.New("503 Service Unavailable"))
+	v := LLMJudge("新事实", similarTop("mem_1", "旧事实", 0.99))
+	if v.Op != OpAdd {
+		t.Fatalf("调用失败应兜底 ADD，得到 %s", v.Op)
+	}
+}
+
+// 归一化完全等价 → NOOP，且不调 LLM。
+func TestLLMJudge_NormalizedEqualSkipsLLM(t *testing.T) {
+	calls := withFakeLLMJudge(t, "KEEP", nil)
+	v := LLMJudge("用户喜欢喝咖啡。", similarTop("mem_1", "用户喜欢喝咖啡", 0.97))
+	if v.Op != OpNoop {
+		t.Fatalf("归一化等价应判 NOOP，得到 %s", v.Op)
+	}
+	if got := atomic.LoadInt32(calls); got != 0 {
+		t.Fatalf("归一化等价不应调用 LLM，实际 %d 次", got)
+	}
+}
+
+func TestParseLLMJudgeVerdict(t *testing.T) {
+	cases := map[string]string{
+		"REPLACE":              "REPLACE",
+		"duplicate":            "DUPLICATE",
+		"我认为应该 KEEP 两条":        "KEEP",
+		"":                     "KEEP",
+		"无法判断":                 "KEEP",
+		"REPLACE\n因为同一属性更新":     "REPLACE",
+		"CONFLICT":             "CONFLICT",
+		"conflict\n同一属性不同取值":    "CONFLICT",
+		"**CONFLICT**":         "CONFLICT",
+	}
+	for in, want := range cases {
+		if got := parseLLMJudgeVerdict(in); got != want {
+			t.Errorf("parse(%q)=%q，期望 %q", in, got, want)
+		}
+	}
+}
+
+// ── 2026-11-03：LLM 四分类（新增 CONFLICT）──────────────────────────
+// 背景：llm_judge 原三分类没有「互斥」出口 ⇒ 真矛盾只能被塞进 REPLACE（误覆盖）
+// 或 KEEP（漏矛盾）。新增 CONFLICT 只**提出假设**，真伪由 JudgeWriteOp 出口的
+// AC-1 确定性门（同主体+同属性+不同取值）裁定，不过门自动降级。
+func TestLLMJudge_Conflict(t *testing.T) {
+	withFakeLLMJudge(t, "CONFLICT", nil)
+	v := LLMJudge("护栏开关 ZHIYI_GUARD_ENABLED 为 0",
+		similarTop("mem_c", "护栏开关 ZHIYI_GUARD_ENABLED 为 1", 0.97))
+	if v.Op != OpConflictMark {
+		t.Fatalf("CONFLICT 应判 CONFLICT-MARK，得到 %s", v.Op)
+	}
+	if v.TargetID != "mem_c" {
+		t.Fatalf("CONFLICT-MARK 必须带 TargetID，得到 %q", v.TargetID)
+	}
+}
+
+// 端到端①：LLM 判 CONFLICT 且门能验证「同属性不同取值」→ 保留 CONFLICT-MARK，reason 带门证据。
+func TestJudgeWriteOp_LLMConflictPassesGate(t *testing.T) {
+	t.Setenv("ZHIYI_WRITE_JUDGE", "llm")
+	t.Setenv("ZHIYI_WRITE_SEMANTIC_OPS", "shadow")
+	t.Setenv("ZHIYI_WRITE_OPS_LOG", t.TempDir()+"/shadow.log")
+	withFakeLLMJudge(t, "CONFLICT", nil)
+	v := JudgeWriteOp("护栏开关 ZHIYI_GUARD_ENABLED 为 0",
+		similarTop("mem_c", "护栏开关 ZHIYI_GUARD_ENABLED 为 1", 0.97), nil, nil)
+	if v == nil {
+		t.Fatal("JudgeWriteOp 返回 nil（write-ops 被关闭？）")
+	}
+	if v.Op != OpConflictMark {
+		t.Fatalf("门应放行，期望 CONFLICT-MARK，实际 %s（reason=%s）", v.Op, v.Reason)
+	}
+	if !strings.Contains(v.Reason, "[gate:") {
+		t.Fatalf("CONFLICT-MARK 的 reason 必须带门证据，实际 %q", v.Reason)
+	}
+}
+
+// 端到端②：LLM 判 CONFLICT 但门验证不了（不同对象）→ 必须降级，不许写 conflict 标记。
+func TestJudgeWriteOp_LLMConflictWithoutGateDowngrades(t *testing.T) {
+	t.Setenv("ZHIYI_WRITE_JUDGE", "llm")
+	t.Setenv("ZHIYI_WRITE_SEMANTIC_OPS", "shadow")
+	t.Setenv("ZHIYI_WRITE_OPS_LOG", t.TempDir()+"/shadow.log")
+	withFakeLLMJudge(t, "CONFLICT", nil)
+	v := JudgeWriteOp("用户查看微信文章",
+		similarTop("mem_z", "用户查看知乎链接", 0.97), nil, nil)
+	if v == nil {
+		t.Fatal("JudgeWriteOp 返回 nil")
+	}
+	if v.Op == OpConflictMark {
+		t.Fatalf("门不过却保留 CONFLICT-MARK（LLM 单方面写 conflict），reason=%s", v.Reason)
+	}
+	if !strings.Contains(v.Reason, "降级") {
+		t.Fatalf("降级路径必须留痕，reason=%q", v.Reason)
+	}
+}
+
+// apply 模式必须强制 llm 判定；规则基判定精度实测≈0%，不许放行改库。
+func TestWriteOpsApply_RequiresLLMJudge(t *testing.T) {
+	t.Setenv("ZHIYI_WRITE_SEMANTIC_OPS", "apply")
+
+	t.Setenv("ZHIYI_WRITE_JUDGE", "rule")
+	if writeOpsApply() {
+		t.Fatal("apply + rule 必须被拒绝（会误覆盖上万条），实际放行")
+	}
+
+	t.Setenv("ZHIYI_WRITE_JUDGE", "llm")
+	if !writeOpsApply() {
+		t.Fatal("apply + llm 应放行")
+	}
+
+	t.Setenv("ZHIYI_WRITE_SEMANTIC_OPS", "shadow")
+	t.Setenv("ZHIYI_WRITE_JUDGE", "llm")
+	if writeOpsApply() {
+		t.Fatal("shadow 模式不应改库")
+	}
+}
+
+func TestLLMJudge_ModeDefaultIsRule(t *testing.T) {
+	t.Setenv("ZHIYI_WRITE_JUDGE", "")
+	if LLMJudgeMode() != "rule" {
+		t.Fatalf("默认 judge 模式必须是 rule（零行为变化），得到 %s", LLMJudgeMode())
+	}
+}
+
+// TestLLMJudgeLive 真实 LLM 端到端验证（默认跳过；ZHIYI_LIVE_JUDGE=1 才跑）。
+// 三条样本取自 2026-10-25 影子日志回放，人类已判定正确答案。
+func TestLLMJudgeLive(t *testing.T) {
+	if os.Getenv("ZHIYI_LIVE_JUDGE") != "1" {
+		t.Skip("live LLM 测试，设 ZHIYI_LIVE_JUDGE=1 才跑")
+	}
+	cases := []struct {
+		name     string
+		cand     string
+		existing string
+		want     WriteOp
+	}{
+		{"真覆盖-同一指标新值", "executions.db台账的max_rowid为185769。", "executions.db台账的max_rowid为183371", OpUpdate},
+		{"假覆盖-不同对象", "用户要求查看 https://mp.weixin.qq.com/s/4nmTHWoK 这篇文章", "用户: https://www.zhihu.com/pin/2075233714007757230", OpAdd},
+		{"重复-同义改写", "该软件支持PDF与Word/Excel/图片互转功能。", "工具转换功能支持PDF与Word/Excel/图片互转", OpNoop},
+	}
+	for _, c := range cases {
+		v := LLMJudge(c.cand, similarTop("mem_x", c.existing, 0.97))
+		t.Logf("%-18s → op=%s reason=%s", c.name, v.Op, v.Reason)
+		if v.Op != c.want {
+			t.Errorf("%s: 期望 %s，实际 %s（%s）", c.name, c.want, v.Op, v.Reason)
+		}
+	}
+}

go/internal/distill/main_test.go

@@ -2,6 +2,7 @@ package distill
 
 import (
 	"os"
+	"path/filepath"
 	"testing"
 )
 
@@ -15,5 +16,16 @@ import (
 // 缓存本身的正确性由 score_cache_test.go 直接测结构体（不依赖全局实例）。
 func TestMain(m *testing.M) {
 	scoreCacheDisabled = true
+	loadPayloadRulesForTests() // t_e11207f8 治源①：单测前确保 payload guard 规则已加载（共享 JSON 或内嵌兜底）
+	// 2026-11-03：测试**绝不写生产影子日志**。JudgeWriteOp 内部调 appendWriteOpsLog，
+	// 未隔离时直接追加到 /var/lib/memoryweave/write-ops-shadow.log —— 实测跑一次
+	// `go test ./internal/distill/` 就往生产审计日志灌 10 行测试数据（candidate
+	// 是「牧尘在招商局工作」这类夹具），随即污染 release 观察曲线（op 分布统计失真）。
+	// 量具污染 = 量具自证失效，故在包级兜底：单个用例仍可用 t.Setenv 覆盖。
+	if os.Getenv("ZHIYI_WRITE_OPS_LOG") == "" {
+		if dir, err := os.MkdirTemp("", "zhiyi-test-writeops-"); err == nil {
+			os.Setenv("ZHIYI_WRITE_OPS_LOG", filepath.Join(dir, "shadow.log"))
+		}
+	}
 	os.Exit(m.Run())
 }

go/internal/distill/payload_guard.go

@@ -0,0 +1,231 @@
+package distill
+
+// 织忆 MemoryWeave — 蒸馏落库「空壳正文」拒写门禁（t_e11207f8 治源 ①）
+//
+// 背景：OnDistillComplete（api/server.go）把 LLM 蒸馏出的 fact 直接 InsertMemory 进
+// memories(category=distilled)。蒸馏 LLM 偶发把「只有溯源指针 / 占位 / 纯日期、无知识
+// 载荷」的碎片当 fact 输出（例：`证据：文件：小怡/工作笔记/已办.md｜日期：2026-09-23`），
+// 质量门槛 IsQualityFact 的长度/实体启发式抓不住它（>20 字）⇒ 库里持续长出新空壳。
+//
+// 单一真相源：判据的**规则值**读自共享 JSON（zhiyi_payload_guard_rules.json），与
+// Python 侧 ~/.hermes/scripts/lib/zhiyi_payload_guard.py **读同一份文件**（不在此手抄，
+// 防跨语言漂移）。改规则只改那一个 JSON。
+//
+// 铁律（与 Python 逐位一致，宁漏勿误删）：
+//   · 含任一句读标点（clause_punct）⇒ 绝不判空壳（保真优先）
+//   · 仅 空串 / 占位变量 / 纯日期 / 溯源指针(来源/证据/文件/日期/source + 引用值) 判空壳
+//
+// 已知跨语言 nuance（文档，不改行为方向）：refname 正则里的 \w，Go RE2 默认 ASCII、
+// Python 默认 unicode ⇒ CJK-only 文件名 Go 不判引用 ⇒ Go **多保留**（安全向，宁漏勿误删）。
+//
+// 无缓存、无新增 Redis 键（只用原子计数），故不触及项目现成件清单的缓存条目。
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync/atomic"
+	"unicode/utf8"
+)
+
+// defaultRulesPath — 与 Python 侧同一份共享规则文件（同机同用户 muc 可直读）。
+// env ZHIYI_PAYLOAD_GUARD_RULES 可覆盖（测试/部署用）。
+func defaultRulesPath() string {
+	if p := os.Getenv("ZHIYI_PAYLOAD_GUARD_RULES"); p != "" {
+		return p
+	}
+	if home, err := os.UserHomeDir(); err == nil && home != "" {
+		return filepath.Join(home, ".hermes", "scripts", "lib", "zhiyi_payload_guard_rules.json")
+	}
+	return "/home/muc/.hermes/scripts/lib/zhiyi_payload_guard_rules.json"
+}
+
+// payloadGuardRules 镜像共享 JSON（只取 Go 判据需要的字段；未知字段忽略）。
+type payloadGuardRules struct {
+	ClausePunct string `json:"clause_punct"`
+	Placeholder struct {
+		Pattern         string `json:"pattern"`
+		CaseInsensitive bool   `json:"case_insensitive"`
+	} `json:"placeholder"`
+	BareDate struct {
+		Pattern         string `json:"pattern"`
+		CaseInsensitive bool   `json:"case_insensitive"`
+	} `json:"bare_date"`
+	ProvLabel struct {
+		Pattern         string `json:"pattern"`
+		CaseInsensitive bool   `json:"case_insensitive"`
+	} `json:"prov_label"`
+	Refname struct {
+		Pattern         string `json:"pattern"`
+		CaseInsensitive bool   `json:"case_insensitive"`
+	} `json:"refname"`
+	RefValueSubstrings []string `json:"ref_value_substrings"`
+	RefValueMaxLen     int      `json:"ref_value_max_len"`
+	RefValueMaxCJK     int      `json:"ref_value_max_cjk"`
+	CJKLo              string   `json:"cjk_lo"`
+	CJKHi              string   `json:"cjk_hi"`
+}
+
+type guard struct {
+	rules     payloadGuardRules
+	placeH    *regexp.Regexp
+	bareD     *regexp.Regexp
+	provL     *regexp.Regexp
+	refname   *regexp.Regexp
+	loaded    bool
+	path      string
+}
+
+var (
+	g *guard
+	// shellChecks = 拦截器「确实跑过」的心跳计数（每个蒸馏 fact 判一次）；
+	// shellBlocks = 实际拦下的空壳条数。二者配对即证拦截器活着（0 blocks 但 checks>0 也合法）。
+	shellChecks int64
+	shellBlocks int64
+)
+
+// LoadPayloadGuard 读共享规则 JSON 并编译正则。失败 ⇒ 未加载（fail-open：distill 照跑、
+// 不拦空壳、不崩 zhiyid），并把 loaded=false 记给 /api/v1/payload-guard/stats 暴露。
+func LoadPayloadGuard(explicitPath string) (loaded bool, err error) {
+	p := explicitPath
+	if p == "" {
+		p = defaultRulesPath()
+	}
+	raw, rerr := os.ReadFile(p)
+	if rerr != nil {
+		g = &guard{}
+		return false, rerr
+	}
+	var rc payloadGuardRules
+	if jerr := json.Unmarshal(raw, &rc); jerr != nil {
+		g = &guard{}
+		return false, jerr
+	}
+	compile := func(pat string, ci bool) (*regexp.Regexp, error) {
+		if ci {
+			pat = "(?i)" + pat
+		}
+		return regexp.Compile(pat)
+	}
+	gh := &guard{rules: rc, path: p, loaded: true}
+	if gh.placeH, err = compile(rc.Placeholder.Pattern, rc.Placeholder.CaseInsensitive); err != nil {
+		g = &guard{}
+		return false, err
+	}
+	if gh.bareD, err = compile(rc.BareDate.Pattern, rc.BareDate.CaseInsensitive); err != nil {
+		g = &guard{}
+		return false, err
+	}
+	if gh.provL, err = compile(rc.ProvLabel.Pattern, rc.ProvLabel.CaseInsensitive); err != nil {
+		g = &guard{}
+		return false, err
+	}
+	if gh.refname, err = compile(rc.Refname.Pattern, rc.Refname.CaseInsensitive); err != nil {
+		g = &guard{}
+		return false, err
+	}
+	if rc.RefValueMaxLen <= 0 {
+		rc.RefValueMaxLen = 24
+	}
+	if rc.RefValueMaxCJK <= 0 {
+		rc.RefValueMaxCJK = 12
+	}
+	gh.rules = rc
+	g = gh
+	return true, nil
+}
+
+// PayloadGuardStats 供 /metrics 与验收：拦截器心跳(checks) / 拦截数(blocks) / 是否加载 / 规则路径。
+func PayloadGuardStats() (checks, blocks int64, loaded bool, path string) {
+	if g == nil {
+		return atomic.LoadInt64(&shellChecks), atomic.LoadInt64(&shellBlocks), false, ""
+	}
+	return atomic.LoadInt64(&shellChecks), atomic.LoadInt64(&shellBlocks), g.loaded, g.path
+}
+
+// IncShellCheck / IncShellBlock 供写路径在判定前后调用（相对增量，避免并发写竞态）。
+func IncShellCheck() { atomic.AddInt64(&shellChecks, 1) }
+func IncShellBlock() { atomic.AddInt64(&shellBlocks, 1) }
+
+// ShellCheck 治源入口（带心跳计数）：
+//   - 未加载 ⇒ fail-open（放行、checks 仍 +1，保证「拦截器跑过」可观测，不拦也不崩）；
+//   - 已加载 ⇒ 用共享判据判定，命中空壳则 blocks +1 并返回 true（写路径据此 continue 拒写）。
+func ShellCheck(content string) bool {
+	IncShellCheck()
+	if g == nil || !g.loaded {
+		return false
+	}
+	if g.isEmptyShell(content) {
+		IncShellBlock()
+		return true
+	}
+	return false
+}
+
+// IsEmptyShell 纯判据（无计数，供单测）。未加载时就地读一次默认路径兜底；失败则 fail-open。
+func IsEmptyShell(content string) bool {
+	if g == nil {
+		if _, err := LoadPayloadGuard(""); err != nil {
+			return false
+		}
+	}
+	return g.isEmptyShell(content)
+}
+
+func (gr *guard) isEmptyShell(content string) bool {
+	c := strings.TrimSpace(content)
+	if c == "" {
+		return true
+	}
+	// 含任一句读标点 ⇒ 有知识断言 ⇒ 绝不当空壳（保真优先，优先于漏删）
+	for _, r := range []rune(gr.rules.ClausePunct) {
+		if strings.ContainsRune(c, r) {
+			return false
+		}
+	}
+	if gr.placeH.MatchString(c) {
+		return true
+	}
+	if gr.bareD.MatchString(c) {
+		return true
+	}
+	if gr.provL.MatchString(c) && gr.isRefValue(c) {
+		return true
+	}
+	return false
+}
+
+func (gr *guard) isRefValue(c string) bool {
+	s := strings.TrimSpace(c)
+	for _, sub := range gr.rules.RefValueSubstrings {
+		if strings.Contains(c, sub) {
+			return true
+		}
+	}
+	if gr.bareD.MatchString(s) || gr.refname.MatchString(s) {
+		return true
+	}
+	if utf8.RuneCountInString(s) <= gr.rules.RefValueMaxLen && gr.cjkCount(s) < gr.rules.RefValueMaxCJK {
+		return true
+	}
+	return false
+}
+
+// cjkCount 统计 [cjk_lo, cjk_hi] 区间的汉字数（与 Python re.findall(r"[一-鿿]") 等价）。
+func (gr *guard) cjkCount(s string) int {
+	lo, hi := gr.rules.CJKLo, gr.rules.CJKHi
+	if lo == "" || hi == "" {
+		lo, hi = "一", "鿿" // U+4E00 / U+9FFF
+	}
+	loR, _ := utf8.DecodeRuneInString(lo)
+	hiR, _ := utf8.DecodeRuneInString(hi)
+	n := 0
+	for _, r := range s {
+		if r >= loR && r <= hiR {
+			n++
+		}
+	}
+	return n
+}

go/internal/distill/payload_guard_test.go

@@ -0,0 +1,99 @@
+package distill
+
+// t_e11207f8 治源 ① Go 单测：
+//   ① 真样本（溯源指针）必判空壳；② 负控（真知识短句 / 含句读）必保留；③ 拦截计数。
+// 判据值优先读【生产共享 JSON】（~/.hermes/scripts/lib/zhiyi_payload_guard_rules.json），
+// 与 Python 同源；该文件缺失时用下方内嵌副本兜底（仅测试用，非运行时真相源）。
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+const embeddedRulesJSON = `{
+  "clause_punct": "，。、；！？",
+  "placeholder": {"pattern": "^[xX]=(?:true|false|\\\\d|[a-z_]{1,12})$", "case_insensitive": true},
+  "bare_date": {"pattern": "^(?:日期[:：]?)?\\\\d{4}[-/]\\\\d{1,2}[-/]\\\\d{1,2}\\\\.?[。.\\\\s]*$"},
+  "prov_label": {"pattern": "^(?:来源|证据|文件|日期|source)[:：]", "case_insensitive": true},
+  "refname": {"pattern": "^[\\\\w.-]+\\\\.(?:md|py|sh|json|yaml|log|txt)$", "case_insensitive": true},
+  "ref_value_substrings": ["｜", "vault:", "/"],
+  "ref_value_max_len": 24, "ref_value_max_cjk": 12,
+  "cjk_lo": "一", "cjk_hi": "鿿"
+}`
+
+func loadPayloadRulesForTests() {
+	// 优先生产共享 JSON（与 Python 同源）；缺失则落内嵌副本到临时目录再读（保证测试可独立跑）。
+	p := os.Getenv("ZHIYI_PAYLOAD_GUARD_RULES")
+	if p == "" {
+		if home, err := os.UserHomeDir(); err == nil && home != "" {
+			p = filepath.Join(home, ".hermes", "scripts", "lib", "zhiyi_payload_guard_rules.json")
+		}
+	}
+	if _, err := LoadPayloadGuard(p); err != nil {
+		tmp, merr := os.MkdirTemp("", "zhiyi-payload-rules-")
+		if merr != nil {
+			return
+		}
+		rp := filepath.Join(tmp, "rules.json")
+		if werr := os.WriteFile(rp, []byte(embeddedRulesJSON), 0o644); werr != nil {
+			return
+		}
+		LoadPayloadGuard(rp)
+	}
+}
+
+func TestIsEmptyShell_Positive_RealSample(t *testing.T) {
+	cases := []string{
+		"证据：文件：小怡/工作笔记/已办.md｜日期：2026-09-23", // 蒸馏真样本（QA/小怡复现的那条）
+		"来源：vault:定义规范:106办公向优化方案-2026-09-18.md",
+		"证据：文件：小怡/工作笔记/已办.md",
+		"X=true",
+		"",
+		"2026-09-23",
+	}
+	for _, c := range cases {
+		if !IsEmptyShell(c) {
+			t.Errorf("应判空壳却放行: %q", c)
+		}
+	}
+}
+
+func TestIsEmptyShell_Negative_KeepRealKnowledge(t *testing.T) {
+	cases := []string{
+		"牧尘在招商局工作",             // 负控：超短真断言，绝不当空壳
+		"活库直连写必须停服务",         // 负控：真知识
+		"来源：t_cbc41a01 待办 #6 核销结果。", // 含句读（。）⇒ 必保留
+		"双向链接是 Obsidian 最核心的功能之一。",  // 含句读
+		"决定将newapi平台中的付费key改为免费",     // 真知识
+		"织忆端口7821",                 // 短但无句读、无溯源前缀、非占位 ⇒ 保守保留
+	}
+	for _, c := range cases {
+		if IsEmptyShell(c) {
+			t.Errorf("误判真知识为空壳（负控失败，违反宁漏勿误删）: %q", c)
+		}
+	}
+}
+
+func TestShellCheck_Counters(t *testing.T) {
+	// ③ 拦截器计数：每个 fact 判一次（checks 增），命中空壳再 blocks 增。
+	c0, b0, loaded, _ := PayloadGuardStats()
+	if !loaded {
+		t.Fatalf("payload guard 未加载，无法验证拦截器")
+	}
+	good := "用户决定升级系统"
+	shell := "证据：文件：小怡/工作笔记/已办.md｜日期：2026-09-23"
+	if ShellCheck(good) {
+		t.Errorf("真知识 fact 被误拦: %q", good)
+	}
+	if !ShellCheck(shell) {
+		t.Errorf("空壳蒸馏 fact 未被拦: %q", shell)
+	}
+	c1, b1, _, _ := PayloadGuardStats()
+	if c1-c0 != 2 {
+		t.Errorf("checks 增量应为 2（good+shell 各判一次），实得 %d", c1-c0)
+	}
+	if b1-b0 != 1 {
+		t.Errorf("blocks 增量应为 1（仅 shell 命中），实得 %d", b1-b0)
+	}
+}

go/internal/distill/probe_prompt_dumper_test.go

@@ -0,0 +1,50 @@
+//go:build promptdump
+
+// t_2595b626 AC1 工具：截获 callLLM5DUncached 实发的 prompt（非默认构建）。
+// 测试内起 httptest echo server 截 body ⇒ 无需外部进程，prompt 与生产构造逐字节同源。
+//
+// 用法：ZHIYI_PROBE_CONTENT_FILE=<内容文件> ZHIYI_PROBE_OUT=<输出json>
+//
+//	go test -tags promptdump -run TestDumpPrompt
+//
+// 门控由进程 env ZHIYI_DISTILL_EXPERIENCE 决定（启动读一次，与生产一致）。
+package distill
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+)
+
+func TestDumpPrompt(t *testing.T) {
+	b, err := os.ReadFile(os.Getenv("ZHIYI_PROBE_CONTENT_FILE"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var captured []byte
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		captured, _ = io.ReadAll(r.Body)
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"choices":[{"message":{"content":"FACT|x\nSCORE|0.5|0.5|0.5|0.5|0.5\nEND"}}]}`))
+	}))
+	defer srv.Close()
+
+	e := NewEngine(srv.URL+"/v1/chat/completions", "local/minicpm5-2b", "sk-probe")
+	_, _ = e.callLLM5DUncached(string(b))
+
+	var body map[string]any
+	if err := json.Unmarshal(captured, &body); err != nil {
+		t.Fatalf("截获 body 失败: %v", err)
+	}
+	prompt := body["messages"].([]any)[0].(map[string]any)["content"].(string)
+	out, _ := json.Marshal(map[string]any{
+		"gate_on": ExperienceGateEnabled(),
+		"bytes":   len(prompt),
+		"prompt":  prompt,
+	})
+	os.WriteFile(os.Getenv("ZHIYI_PROBE_OUT"), out, 0o644)
+	t.Logf("dumped prompt bytes=%d gate=%v", len(prompt), ExperienceGateEnabled())
+}

go/internal/distill/procedural_gate.go

@@ -0,0 +1,118 @@
+// 织忆 MemoryWeave — 程序性步骤判据（kanban t_3636b872 阶段4）
+//
+// 目标：蒸馏打分里加「答案必须含步骤，否则降级为 observe lane」，防止 how-to/运维
+// 拆解又产出纯元描述（"结论：…""依据：…"这类无命令/无路径/无序号的内容）。
+//
+// 背景（t_3636b872 库形态硬实测）：content 长度中位数 35 字，83% <60 字，仅 10.2% 含
+// 可执行内容；「state.db 怎么修 / 网关怎么重启 / 磁盘怎么清」top5 全是元描述。原因不是
+// 检索层，是**蒸馏产出不带步骤形态** ⇒ 需要一道确定性闸：how-to 类内容允许 keep 入库的
+// 前提是它的答案真的含可执行步骤。
+//
+// 设计（延续准入闸门哲学 admission_lane.go）：
+//   - 纯确定性、零 LLM 调用（同一输入永远同一结果，可单测）。
+//   - 只对「how-to / 操作 / 修复 / 排查 / 重启」类**触发词命中**的内容做校验——普通
+//     陈述事实（"用户重启了服务器"）不受影响。
+//   - 触发词命中但事实里没有可执行步骤 ⇒ 降级为 observe（不确定带，永不因分数丢弃）。
+//     降级后该条仍走 observe 通道（保留，可被后续消费/降权淘汰），只是不从 keep 直接
+//     立库 —— 代价可逆，符合「drop 不可逆、observe 可逆」的分诊原则。
+//   - shadow 模式默认开（ZHIYI_PROCEDURAL_SHADOW=0 关）：只写日志不真降级，先观察命中
+//     分布再决定是否真拦（与 score 影子/对抗审计同款保守节奏）。
+//
+// 可执行步骤判定（HasExecutableSteps）：
+//   含命令/路径/序号操作符/端口/显式动词短语之一即算有步骤——宁可宽（多留可逆），
+//   不错杀真实步骤描述。
+
+package distill
+
+import (
+	"os"
+	"strings"
+)
+
+// proceduralHowToMarkers how-to / 操作类触发词（命中 = 该内容是"What-to-do 怎么做 X"）。
+// 覆盖真实问法（"X 挂了怎么修""怎么重启 X""X 排查步骤"），不是术语白名单。
+var proceduralHowToMarkers = []string{
+	"怎么修", "怎么查", "怎么办", "怎么重启", "怎么清", "怎么做", "怎么处理", "怎么排查",
+	"如何修", "如何排查", "如何重启", "如何清", "如何做",
+	"修复步骤", "排查步骤", "操作步骤", "解决步骤", "重启步骤",
+	"该怎么", "该怎么办", "咋修", "咋办",
+	"how to", "howto", "troubleshoot", "fixing", "debug",
+}
+
+// proceduralOperationMarkers 更强的「操作序列」信号（与普通陈述区分）。
+var proceduralOperationMarkers = []string{
+	"步骤", "先用", "再", "然后", "最后", "依次",
+	"systemctl", "curl", "grep", "sqlite3", "journalctl", "pgrep", "cp -a",
+	"install", "rm ", "mv ", "df -h", "du -", "python3",
+}
+
+// executableStepMarkers 事实里含「可执行步骤」的证据。
+var executableStepMarkers = []string{
+	"`", "$(", "systemctl", "curl ", "grep ", "sqlite3", "journalctl",
+	"pgrep", "cp ", "mv ", "rm ", "install ", "df -h", "du -x", "python3 ",
+	"①", "②", "③", "④", "⑤", "第一步", "第二步", "步骤1", "步骤2", "先", "然后", "最后",
+}
+
+// proceduralShadowMode 影子模式：true（默认）= 只记录该降级，不真降级。
+// 设 ZHIYI_PROCEDURAL_SHADOW=0 关闭影子（= 真降级到 observe）。
+var proceduralShadowMode = os.Getenv("ZHIYI_PROCEDURAL_SHADOW") != "0"
+
+// IsHowToContent 判断 content 是否命中 how-to / 操作类触发词。
+func IsHowToContent(content string) bool {
+	s := strings.ToLower(strings.TrimSpace(content))
+	if s == "" {
+		return false
+	}
+	for _, m := range proceduralHowToMarkers {
+		if strings.Contains(s, m) {
+			return true
+		}
+	}
+	return false
+}
+
+// IsOperationContent 判断 content 是否带更强的操作序列信号（可选，更严的触发面）。
+func IsOperationContent(content string) bool {
+	s := strings.ToLower(strings.TrimSpace(content))
+	for _, m := range proceduralOperationMarkers {
+		if strings.Contains(s, m) {
+			return true
+		}
+	}
+	return false
+}
+
+// HasExecutableSteps 判断蒸馏产出事实里是否含可执行步骤证据。
+// 只要任一 fact 含任一 marker 即算有步骤（AND 于 fact 内，OR 于 marker）。
+func HasExecutableSteps(facts []string) bool {
+	for _, f := range facts {
+		fl := strings.ToLower(f)
+		for _, m := range executableStepMarkers {
+			if strings.Contains(fl, m) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// ProceduralStepVerdict 对一条 how-to 内容的蒸馏产出做步骤判据。
+// 返回是否应降级 observe（含影子开关判定）与人类可读原因。
+//
+// 语义：
+//   - 非 how-to 内容（IsHowToContent=false）⇒ 不涉此判据，放行（false）。
+//   - how-to 命中且已含步骤 ⇒ 放行（false）。
+//   - how-to 命中但事实无步骤 ⇒ 判「应降级 observe」（true）；shadow 开则仅记日志。
+func ProceduralStepVerdict(content string, facts []string) (demote bool, reason string) {
+	if !IsHowToContent(content) {
+		return false, ""
+	}
+	if HasExecutableSteps(facts) {
+		return false, "how-to 答案含可执行步骤"
+	}
+	reason = "how-to 内容但事实无步骤 → 降级 observe"
+	if proceduralShadowMode {
+		reason += "（shadow，仅记录）"
+	}
+	return true, reason
+}

go/internal/distill/procedural_gate_test.go

@@ -0,0 +1,92 @@
+package distill
+
+import "testing"
+
+// TestProceduralStepVerdict_HowToNoSteps 核心判据：how-to 内容但事实无步骤 → 应降级 observe。
+func TestProceduralStepVerdict_HowToNoSteps(t *testing.T) {
+	// 保存影子模式并复位（测试里显式关影子，保证断言的是真实降级语义）
+	orig := proceduralShadowMode
+	proceduralShadowMode = false
+	defer func() { proceduralShadowMode = orig }()
+
+	cases := []struct {
+		name    string
+		content string
+		facts   []string
+		want    bool // demote?
+	}{
+		{
+			name:    "how-to 内容但答案是纯元描述 → 降级",
+			content: "state.db 怎么修",
+			facts:   []string{"结论：数据库损坏需要修复", "依据：损坏会导致召回失败"},
+			want:    true,
+		},
+		{
+			name:    "how-to 内容且答案含命令步骤 → 放行",
+			content: "state.db 怎么修",
+			facts:   []string{"systemctl --user stop zhiyid 后 cp 备份再 sqlite3 PRAGMA integrity_check"},
+			want:    false,
+		},
+		{
+			name:    "how-to 内容且答案含序号步骤 → 放行",
+			content: "网关怎么重启",
+			facts:   []string{"第一步停写者，第二步备份，③重启 zhiyid"},
+			want:    false,
+		},
+		{
+			name:    "非 how-to 陈述事实 → 不受此判据影响",
+			content: "用户重启了服务器",
+			facts:   []string{"用户重启了服务器"},
+			want:    false,
+		},
+		{
+			name:    "how-to 命中但完全无事实 → 降级（空答案无步骤）",
+			content: "磁盘怎么清",
+			facts:   []string{},
+			want:    true,
+		},
+		{
+			name:    "how-to 内容但答案是纯元描述（无序号无命令）→ 降级",
+			content: "这个问题怎么排查",
+			facts:   []string{"排查日志以定位问题根源即可解决"},
+			want:    true,
+		},
+	}
+
+	for _, c := range cases {
+		demote, _ := ProceduralStepVerdict(c.content, c.facts)
+		if demote != c.want {
+			t.Errorf("%s: demote=%v want %v (facts=%v)", c.name, demote, c.want, c.facts)
+		}
+	}
+}
+
+// TestProceduralStepVerdict_Shadow 影子模式默认应只记不真降级。
+func TestProceduralStepVerdict_Shadow(t *testing.T) {
+	if !proceduralShadowMode {
+		t.Skip("影子模式被显式关闭，跳过默认行为断言")
+	}
+	demote, reason := ProceduralStepVerdict("怎么修 state.db", []string{"结论：数据库损坏"})
+	if !demote {
+		t.Fatalf("how-to 无步骤在 shadow 下仍应报 demote=true（供日志观察），实得 %v", demote)
+	}
+	if reason == "" {
+		t.Fatal("shadow 下仍应给出人类可读原因")
+	}
+}
+
+// TestIsHowToContent 触发词覆盖真实问法（含英文）。
+func TestIsHowToContent(t *testing.T) {
+	pos := []string{"state.db 怎么修", "网关怎么重启", "磁盘怎么清", "怎么做", "how to fix", "修复步骤是什么", "该怎么排查"}
+	for _, c := range pos {
+		if !IsHowToContent(c) {
+			t.Errorf("应命中 how-to: %q", c)
+		}
+	}
+	neg := []string{"用户重启了服务器", "今天天气不错", "牧尘喜欢喝咖啡"}
+	for _, c := range neg {
+		if IsHowToContent(c) {
+			t.Errorf("不应命中 how-to: %q", c)
+		}
+	}
+}

go/internal/distill/rules.go

@@ -1,18 +1,40 @@
 // 织忆 MemoryWeave — 硬规则过滤
 // 蒸馏前筛选：跳过闲聊、纯知识问答、低密度内容
+//
+// t_a513b870：HardRulesPass 增加带原因的变体 HardRulesPassWithReason，并统一在此
+// 登记拒绝计数（RecordHardReject）——使「闸门拦掉多少」可观测，不再是黑洞。
 
 package distill
 
 import (
 	"strings"
 	"unicode/utf8"
+
+	"github.com/xiaoxue/memoryweave/internal/textfilter"
 )
 
-// HardRulesPass 硬规则过滤 → true = 通过，可进入蒸馏队列
+// HardRulesPass 硬规则过滤 → true = 通过，可进入蒸馏队列。
+// 薄封装：委托 HardRulesPassWithReason，并登记计数。禁止新增逻辑在此（保持语义单点）。
 func HardRulesPass(content string) bool {
+	pass, _ := HardRulesPassWithReason(content)
+	return pass
+}
+
+// HardRulesPassWithReason 硬规则过滤，返回 (是否通过, 拒绝原因分桶)。
+// 拒绝时登记计数 + 打 [GATE][REJECT] 日志（AC1）。规则顺序即判定优先级：
+// 空 → 系统样板 → 过短（含人侧短事实豁免）→ 闲聊 → 知识问答 → 密度 → 超长。
+func HardRulesPassWithReason(content string) (bool, string) {
 	// 规则1: 无用户消息（纯系统消息） → 跳过
 	if strings.TrimSpace(content) == "" {
-		return false
+		reject("empty", content)
+		return false, "empty"
+	}
+
+	// 规则1.5: 系统样板（t_a513b870 把原属 ClassifyAdmission 的 drop 提前到硬规则层，
+	// 使 AC4(a)「drop 只在硬规则层发生」成立，并让「系统样板」成为可见拒绝分桶）
+	if textfilter.IsSystemTemplate(content) {
+		reject("sys_template", content)
+		return false, "sys_template"
 	}
 
 	// 规则2: 太短的消息 (< 10字符) → 跳过
@@ -20,9 +42,11 @@ func HardRulesPass(content string) bool {
 	// 不因字数被丢弃——否则"牧尘不在招商局工作"(9 字) 这类关键事实永远到不了 memories。
 	if utf8.RuneCountInString(content) < 10 {
 		if isSoulfulShortFact(content) {
-			return true
+			pass("too_short", content) // 豁免但记录一次 pass
+			return true, ""
 		}
-		return false
+		reject("too_short", content)
+		return false, "too_short"
 	}
 
 	// 规则3: 纯闲聊/问候 → 跳过
@@ -33,7 +57,8 @@ func HardRulesPass(content string) bool {
 	lower := strings.ToLower(strings.TrimSpace(content))
 	for _, pattern := range chitchatPatterns {
 		if strings.EqualFold(lower, pattern) || lower == pattern {
-			return false
+			reject("chitchat", content)
+			return false, "chitchat"
 		}
 	}
 
@@ -41,22 +66,38 @@ func HardRulesPass(content string) bool {
 	qaPrefixes := []string{"什么是", "怎么定义", "解释一下", "介绍一下"}
 	for _, prefix := range qaPrefixes {
 		if strings.HasPrefix(content, prefix) {
-			return false
+			reject("qa", content)
+			return false, "qa"
 		}
 	}
 
 	// 规则5: 内容密度检查 (信息密度 < 0.3 → 跳过)
 	density := contentDensity(content)
 	if density < 0.3 {
-		return false
+		reject("low_density", content)
+		return false, "low_density"
 	}
 
 	// 规则6: 长度适中（太长可能是粘贴/日志，跳过蒸馏，交给 episode 保留）
 	if utf8.RuneCountInString(content) > 5000 {
-		return false
+		reject("too_long", content)
+		return false, "too_long"
 	}
 
-	return true
+	RecordGatePass()
+	return true, ""
+}
+
+// reject 拒绝分支的统一登记点（计数 + 日志）。
+func reject(rule string, content string) {
+	RecordHardReject(rule, content)
+}
+
+// pass 通过分支的计数登记（进入队列前由 Enqueue append 时再 RecordEnteredQueue）。
+func pass(rule string, content string) {
+	// rule 仅用于豁免场景的调试定位（如 too_short 豁免），计数器不需分桶记录 pass，
+	// 只记总评估次数。此处保留参数签名以明确「这条走了豁免通过」。
+	RecordGatePass()
 }
 
 // contentDensity 内容信息密度 = 有意义字符 / 总字符
@@ -109,4 +150,4 @@ func ShouldDeepConsolidate(distilledSinceLast int, hoursSinceLast float64) bool
 // 条件: 队列 >= 10 或 距上次 > 5 分钟
 func ShouldBatchDistill(queueLen int, secondsSinceLast float64) bool {
 	return queueLen >= 10 || secondsSinceLast > 300
-}
+}

go/internal/distill/score_cache.go

@@ -111,6 +111,17 @@ func getScoreCache() *scoreCache {
 }
 
 func scoreKey(content string) string {
+	// t_ab5b2461：灰度开启（prompt 已变）时给键加版本后缀 —— 否则 Redis 里
+	// 旧 prompt 产出的评分/抽取结果会被新 prompt 直接复用，判据灰度形同虚设。
+	// 关态键与历史逐字节一致（AC5：不设 env ⇒ 缓存行为零变化）。
+	if densityGateEnabled {
+		content += "\x00density-v1"
+	}
+	// t_2595b626 经验层门控开 ⇒ prompt 已变（追加 EXP 段），同 density 范式给键换代，
+	// 否则旧 prompt 的缓存结果会被开态直接复用、EXP 永远解析不出来（灰度静默失效）。
+	if experienceGateEnabled {
+		content += "\x00experience-v1"
+	}
 	sum := sha256.Sum256([]byte(content))
 	return hex.EncodeToString(sum[:])
 }

go/internal/distill/supersede.go

@@ -0,0 +1,92 @@
+// 织忆 MemoryWeave — 确定性版本取代（supersede）判定
+//
+// 2026-11-11 存真去伪·阶段 3（牧尘批准「两件事，按你的建议做」）。
+//
+// 为什么需要它（硬事实，非推测）：
+//
+//	memories 表 44,934 行里 `supersedes`/`superseded_by` 两列**全为字符串 '[]'（零使用）**，
+//	只有 valid_to 被填过（1,169 条已过期）。⇒「旧版被新版取代」这条链路代码里有、
+//	运行时没接：写时四算子（ZHIYI_WRITE_SEMANTIC_OPS）2026-11-10 已退役（LLM 判定
+//	ADD 98%、UPDATE 1%，因为 sim<0.95 直接「不判，新建」）。
+//	⇒ 结果：旧 IP / 旧端口 / 旧版本号 / 旧决策永远和新的并存，注入时可能取到错的。
+//
+// 本文件只做一件事：**用确定性判据**（SameAttrValueConflict：同主体+同属性+不同取值）
+// 把「新事实顶掉哪条旧事实」判出来，零 LLM、零额外编码、零新依赖。
+//
+// 门控（env `ZHIYI_SUPERSEDE`，默认 off ⇒ 行为与现状逐字一致）：
+//
+//	off    —— 不判定（默认）
+//	shadow —— 只打日志（[supersede][shadow] …），不改库 —— 观察期用
+//	apply  —— 真打标：旧行 freshness=superseded + superseded_by=[新ID] + valid_to=now
+//
+// 保护（宁漏勿误，与 conflict_gate 同纪律）：
+//   - 相似度 < 0.80 不看（差值太大的「不同取值」多半是同名不同物）
+//   - tier=core 不看（核心记忆不自动被顶）
+//   - 已经是旧版（SupersededBy 非空）不看（不二次标记）
+//   - 每条新事实最多顶掉 1 条（相似度最高的那条）
+package distill
+
+import (
+	"os"
+	"strings"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+// SupersedeMinSim 最低相似度门槛（低于此值不参与取代判定）。
+const SupersedeMinSim = 0.80
+
+// SupersedeMode 返回当前模式：off / shadow / apply（env ZHIYI_SUPERSEDE，默认 off）。
+// 未知取值一律 off——安全默认：拼错不会意外改库。
+func SupersedeMode() string {
+	switch strings.ToLower(strings.TrimSpace(os.Getenv("ZHIYI_SUPERSEDE"))) {
+	case "apply":
+		return "apply"
+	case "shadow":
+		return "shadow"
+	default:
+		return "off"
+	}
+}
+
+// SupersedeEnabled 是否跑判定（shadow/apply 都跑，off 不跑）。
+func SupersedeEnabled() bool { return SupersedeMode() != "off" }
+
+// SupersedeHit 一条「新事实 → 应被顶掉的旧记忆」判定结果。
+type SupersedeHit struct {
+	OldID    string  // 旧记忆 ID
+	Evidence string  // 判据证据（同属性不同取值的原文对，审计用）
+	Sim      float64 // 新旧余弦相似度
+}
+
+// FindSupersedeTarget 判定 candidate 是否顶掉 similar 中某条旧记忆。
+// similar：**同 namespace** 的近似记忆（调用方已按相似度降序给出，最多 5 条）；
+// qvec：candidate 的向量（用于算相似度；nil ⇒ 相似度按 0 处理，全部因门槛不过而弃）。
+func FindSupersedeTarget(candidate string, similar []models.MemoryRecord, qvec []float32) (SupersedeHit, bool) {
+	cand := strings.TrimSpace(candidate)
+	if cand == "" {
+		return SupersedeHit{}, false
+	}
+	for _, r := range similar {
+		if r.ID == "" || strings.TrimSpace(r.Content) == "" {
+			continue
+		}
+		if len(r.SupersededBy) > 0 { // 已是旧版，不二次标记
+			continue
+		}
+		if r.Tier == "core" { // 核心记忆不自动被顶
+			continue
+		}
+		sim := 0.0
+		if qvec != nil && len(r.Vector) == len(qvec) {
+			sim = cosineSim(qvec, r.Vector)
+		}
+		if sim < SupersedeMinSim {
+			continue
+		}
+		if ev, ok := SameAttrValueConflict(cand, r.Content); ok {
+			return SupersedeHit{OldID: r.ID, Evidence: ev, Sim: sim}, true
+		}
+	}
+	return SupersedeHit{}, false
+}

go/internal/distill/supersede_test.go

@@ -0,0 +1,109 @@
+package distill
+
+import (
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+func mkVecMem(id, content string, vec []float32) models.MemoryRecord {
+	return models.MemoryRecord{ID: id, Content: content, Vector: vec}
+}
+
+func TestFindSupersedeTarget_ConflictWins(t *testing.T) {
+	q := []float32{1, 0.05}
+	sims := []models.MemoryRecord{
+		mkVecMem("mem_old", "织忆 API 端口为 7821", []float32{1, 0.04}),
+	}
+	hit, ok := FindSupersedeTarget("织忆 API 端口为 7822", sims, q)
+	if !ok || hit.OldID != "mem_old" {
+		t.Fatalf("期望命中 mem_old，实得 ok=%v hit=%+v", ok, hit)
+	}
+	if hit.Evidence == "" {
+		t.Fatalf("命中必须带判据证据（审计用），实得空")
+	}
+}
+
+func TestFindSupersedeTarget_SameValueNoHit(t *testing.T) {
+	q := []float32{1, 0.05}
+	sims := []models.MemoryRecord{mkVecMem("mem_a", "织忆 API 端口为 7821", []float32{1, 0.04})}
+	if _, ok := FindSupersedeTarget("织忆 API 端口为 7821", sims, q); ok {
+		t.Fatalf("同值 = 同事实，不是矛盾，不得判取代")
+	}
+}
+
+func TestFindSupersedeTarget_LowSimNoHit(t *testing.T) {
+	q := []float32{1, 0}
+	sims := []models.MemoryRecord{mkVecMem("mem_far", "织忆 API 端口为 7821", []float32{0, 1})} // cosine=0
+	if _, ok := FindSupersedeTarget("织忆 API 端口为 7822", sims, q); ok {
+		t.Fatalf("相似度 < %.2f 不得判取代", SupersedeMinSim)
+	}
+}
+
+func TestFindSupersedeTarget_CoreProtected(t *testing.T) {
+	q := []float32{1, 0.05}
+	m := mkVecMem("mem_core", "织忆 API 端口为 7821", []float32{1, 0.04})
+	m.Tier = "core"
+	if _, ok := FindSupersedeTarget("织忆 API 端口为 7822", []models.MemoryRecord{m}, q); ok {
+		t.Fatalf("tier=core 不得被自动顶掉")
+	}
+}
+
+func TestFindSupersedeTarget_AlreadySupersededSkipped(t *testing.T) {
+	q := []float32{1, 0.05}
+	m := mkVecMem("mem_old2", "织忆 API 端口为 7821", []float32{1, 0.04})
+	m.SupersededBy = []string{"mem_newer"}
+	if _, ok := FindSupersedeTarget("织忆 API 端口为 7822", []models.MemoryRecord{m}, q); ok {
+		t.Fatalf("已是旧版不得二次标记")
+	}
+}
+
+func TestSupersedeMode_DefaultOff(t *testing.T) {
+	t.Setenv("ZHIYI_SUPERSEDE", "")
+	if got := SupersedeMode(); got != "off" {
+		t.Fatalf("默认必须 off（零行为变化），实得 %q", got)
+	}
+	t.Setenv("ZHIYI_SUPERSEDE", "typo")
+	if got := SupersedeMode(); got != "off" {
+		t.Fatalf("拼错必须落 off（安全默认），实得 %q", got)
+	}
+	t.Setenv("ZHIYI_SUPERSEDE", "shadow")
+	if got := SupersedeMode(); got != "shadow" {
+		t.Fatalf("shadow 解析失败，实得 %q", got)
+	}
+	t.Setenv("ZHIYI_SUPERSEDE", "APPLY")
+	if got := SupersedeMode(); got != "apply" {
+		t.Fatalf("apply 大小写不敏感，实得 %q", got)
+	}
+}
+
+// 2026-11-11 E2E 回归：同一事实被蒸馏两次的两种写法必须判成「同属性不同取值」，
+// 否则 supersede 永远不触发（实测第一次上线就栽在这：60123/60124 两条都入库了）。
+func TestSameAttrValueConflict_DistillParaphrase(t *testing.T) {
+	a := "在织忆联调环境中，API端口被指定为60123。"
+	b := "在织忆联调环境中，API端口为60124。"
+	ev, ok := SameAttrValueConflict(a, b)
+	if !ok {
+		t.Fatalf("同一属性两种动词写法必须判成矛盾（否则旧值不被顶掉）：%q vs %q", a, b)
+	}
+	if ev == "" {
+		t.Fatalf("必须带证据串")
+	}
+}
+
+func TestSameAttrValueConflict_ParaphraseSameValueNoConflict(t *testing.T) {
+	a := "在织忆联调环境中，API端口被指定为60123。"
+	b := "在织忆联调环境中，API端口为60123。"
+	if _, ok := SameAttrValueConflict(a, b); ok {
+		t.Fatalf("取值相同 = 同一事实，不得判矛盾")
+	}
+}
+
+func TestNormalizeCJKAttrKey_NoOverStrip(t *testing.T) {
+	if got := normalizeCJKAttrKey("端口"); got != "端口" {
+		t.Fatalf("短键不得被削空，实得 %q", got)
+	}
+	if got := normalizeCJKAttrKey("API端口"); got != "API端口" {
+		t.Fatalf("名词本身不得被削，实得 %q", got)
+	}
+}

go/internal/distill/testdata/conflict_stock_20261102.json

@@ -0,0 +1,434 @@
+[
+ {
+  "id": "mem_1789296029790848255",
+  "content": "文章中提到的其他仓库（如 caveman、Agent-Reach 等）是否已安装",
+  "counterparts": [
+   {
+    "id": "mem_1791639825565513480",
+    "content": "用户询问 iis问题是否需要豆包，以及 agent-reach 的登录方式。"
+   },
+   {
+    "id": "mem_1791639833660796319",
+    "content": "用户确认 agent-reach 需要通过浏览器登录。"
+   },
+   {
+    "id": "mem_1791639835267796325",
+    "content": "用户确认 agent-reach 登录需使用 Chromium 浏览器。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1789911610227431607",
+  "content": "hermes 命令提示「上次 update 拉了新代码但没重启 gateway」—— gateway 可能还在跑旧模块。重启属改动，说一声我再动",
+  "counterparts": [
+   {
+    "id": "ep_1786345934138400283",
+    "content": "2026-08-10 dbx MCP 接入 Hermes 完成：@dbx-app/mcp-server（Rust 原生，npx 启动）已加入 config.yaml mcp_servers，12 个工具注册成功（dbx_add_connection/list_connections/list_tables/describe_table/get_schema_context/execute_query/execute_redis_command/open_session/close_session/open_table/execute_and_show/remove_connection）。不需要 DBX 桌面应用（离线执行模式）。验证方式：MCP SDK stdio_client 握手 + gateway 重启后工具目录可见。"
+   },
+   {
+    "id": "ep_1787138068610695711",
+    "content": "2026-08-18 小米 MiMo 接入完成（替换涨价 DeepSeek）：①Hermes 主模型 deepseek-v4-flash→mimo-v2.5-pro（provider=mimo，base_url=https://token-plan-cn.xiaomimimo.com/v1，MIMO_API_KEY 在 ~/.hermes/.env，tp-开头）；②OpenClaw agents.defaults.model.primary→mimo/mimo-v2.5-pro（models.providers.mimo 已添加）；③opencode 新增 provider.mimo（npm=@ai-sdk/openai-compatible，opencode.json + auth.json ~/.local/share/opencode/auth.json）；④TTS 改 mimo command provider（mimo-v2.5-tts 音色冰糖，脚本 ~/.hermes/scripts/mimo_tts.sh，user=风格指令 assistant=朗读文本 audio={format:wav,voice:冰糖}，实测6.6s wav）；⑤prof-b 分身→mimo-v2.5；⑥cron/脚本/服务保持免费模型（Agnes/NewAPI）不动；⑦model-health.py SKIP_MODELS 加 mimo-v2.5-pro/mimo-v2.5，anti-suicide-check.sh 主模型检查改 mimo-v2.5-pro，profile-sync.py 同步更新；⑧实测 hermes chat -m mimo-v2.5-pro 回复正常。注意：gateway 重启后主模型才生效（gateway 内无法自重启，需外部 hermes gateway restart）。git 提交 d5e69e9。备份：config.yaml.bak-mimo-20260818 等。小米 TTS 非高峰期(00:00-08:00)0.8x消耗，TTS 限时免费。"
+   },
+   {
+    "id": "mem_1789717501651821211",
+    "content": "prof-qa gateway 处于 stopped（`hermes profile list` 实测）"
+   }
+  ]
+ },
+ {
+  "id": "mem_1790682314463034840",
+  "content": "用户: 授权你动Obsidian，因为我不在电脑前。\n助手: # ✅ Obsidian 多端同步 —— 修好了，而且挖出了全天「同步成功却看不到新笔记」的**真根因**\n\n**一句话根因**（插件源码...",
+  "counterparts": [
+   {
+    "id": "ep_1786813937560080108",
+    "content": "2026-08-15 重大教训：记忆系统\"记忆污染\"事件。牧尘批评记忆效果差+记不住从Obsidian找key。根因分析：①USER.md第6条存了错误结论\"Agnes key是脱敏的需重新获取\"——这是之前某次看到显示层脱敏(sk-7k9...2ikW)误判为存储脱敏后自己写错的，错误记忆作为Ground Truth注入导致本次误判\"key丢失\"；②织忆里只有零散过程记录(episodes)，没有\"从key.md提取key\"的方法知识(distilled procedural)。修复：①修正USER.md为\"显示脱敏≠存储脱敏，文件里是完整key，用python len()验证\"；②恢复AGNES_API_KEY到.env（51字符完整key sk-7k9开头）；③教训：看到脱敏显示先怀疑显示层，用长度验证再下结论；关键方法知识必须进distilled/memory，不能只留过程记录。memory_metrics显示recall_hit_rate=1但这是检索命中不是知识正确性——记忆系统需要\"正确性校验\"而不只是\"召回率\"。"
+   },
+   {
+    "id": "mem_1787473961257233097",
+    "content": "用户从Obsidian的key.md文件中获取了API key。"
+   },
+   {
+    "id": "mem_1788972709088708515",
+    "content": "用户决定将总结的系统全景和问题回答更新到 obsidian 文档"
+   }
+  ]
+ },
+ {
+  "id": "mem_1790847420378095327",
+  "content": "需要'起进程/查账号'的操作在那台机器上全部卡死，这是原理性阻断。",
+  "counterparts": [
+   {
+    "id": "mem_1792794363983815683",
+    "content": "行467显示systemctl restart被系统服务重启门禁硬拦，需重启的动作要么交互放行、要么另开部署卡。"
+   },
+   {
+    "id": "mem_1791365252043039320",
+    "content": "如果我不先 dry-run 就直接给 profile 网关挂钩子，`prof-b`（delete 模式 + 当时疑似有 worker 持库）当场就是一次启动失败"
+   },
+   {
+    "id": "mem_1791592201590668581",
+    "content": "根因是本机 `tailscaled` 登录态失效（`NeedsLogin`），自 2026-09-22 起退出登录。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791162844304555022",
+  "content": "依据：否则会训练出「门禁在骗人」的不信任，导致已核实的好交付被误判为空模板，还得回头写更正评论",
+  "counterparts": [
+   {
+    "id": "mem_1793247850428646587",
+    "content": "假结论比不报更危险——会引导用户排查错误方向（重装家服网络），而真正原因（本机依赖缺失）永远无法被发现。"
+   },
+   {
+    "id": "mem_1792081651793452540",
+    "content": "结论：一、门禁为什么误报（读代码定的因，不是猜）｜依据：**教训（已入工作经验）**：**活体源的同步验收不能用「两边文件数/字节相等」当判据** —— 源一直在写，接收端必然是旧快照。正确口径 = ① 发送侧 Syncthing 传输账（completion/need/remoteNeed/errors）② 接收侧只报**本机 local** 计数与盘面实测（**不许报 global**，glo..."
+   },
+   {
+    "id": "mem_1791347230346464144",
+    "content": "结论：2026-09-27 21:15 教训：安全门报 DANGEROUS ≠ 仓库有毒；但「全是误报」也 ≠ 可以绕过门禁｜依据：**事实**：`hermes skills install skil..."
+   }
+  ]
+ },
+ {
+  "id": "mem_1791180132124643985",
+  "content": "行为规则: 分身给出的“不存在/不支持”类结论，必须自己复核；依据：分身有系统性盲区；反面：不要直接采信分身关于“不存在/不支持”的结论",
+  "counterparts": [
+   {
+    "id": "mem_1791195235248616585",
+    "content": "行为规则: 依据：不落到具体命令的规则无法机械判定对错，执行方会各自理解；反面：只写原则不写命令，验收时无法判断是否做到。"
+   },
+   {
+    "id": "mem_1791185138748857659",
+    "content": "行为规则：报结论前，必须去掉自己的过滤条件、绕开启示层（如脱敏渲染）、检查读取上限，再下判断。"
+   },
+   {
+    "id": "mem_1791180322304484693",
+    "content": "行为规则: 说任何'X 坏了 / 是 bug / 不可用'前，必须附证伪命令；依据：只写结论不写证伪 = 当我说错处理；反面：下结论快、证伪慢，先宣布后被打脸"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791180604703015228",
+  "content": "反面：❌ 用“有效记忆 = total - tombstone”口径，没算重复行和碎片（731 条完全重复不在任何指标里）。",
+  "counterparts": [
+   {
+    "id": "mem_1791591921163229995",
+    "content": "依据卡的闭环：run 948 交（14:03-14:29）→ 用户独立终审通过（评论 #731/#732）→ run 949 自复审跑 done（14:42）⇒ 卡 status=done。"
+   },
+   {
+    "id": "mem_1791920676313714377",
+    "content": "任务标题为【织忆·P1·Mem0】写时四操作(ADD/UPDATE/NOOP/CONFLICT-MARK)+写前哈希去重（731 重复源头堵法）·影子默认·参数补出处注释。"
+   },
+   {
+    "id": "mem_1792088552816896998",
+    "content": "AC3最小修法为查询侧实体扩展QE（复用EntityIndex+FTS倒排），实测淇县ANN 731→15、鹤壁6536→18进池50。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791181886433064711",
+  "content": "决定检查存储层全部可能位置，而不仅仅是审计报告列出的位置。",
+  "counterparts": [
+   {
+    "id": "mem_1791181886730648983",
+    "content": "必须检查存储层全部可能位置以确保范围完整。"
+   },
+   {
+    "id": "mem_1791606435051914342",
+    "content": "本次深查推翻了\"唯一 vault 迁移留档\"的判断。"
+   },
+   {
+    "id": "mem_1791735827032353502",
+    "content": "以后审计产出（推断层）不能直接搬进卡的 AC（事实层）。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791295556476362217",
+  "content": "依据：系统只有运行没有汇报 = 失职（模拟盘一个月无主动业绩汇总，牧尘批评）",
+  "counterparts": [
+   {
+    "id": "mem_1791676977062595410",
+    "content": "模拟盘从 7-13 买入到 8-02 一个月没有任何主动业绩汇总。"
+   },
+   {
+    "id": "mem_1793363314370157241",
+    "content": "需向牧尘汇报\"积压未清零、轮完周期长\"以避免误读。"
+   },
+   {
+    "id": "mem_1791375971723781657",
+    "content": "真根因在更上游的派活段（行数 offset 静默故障 → 根本没建卡 → 自然没回写、没汇报）。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791350806695801038",
+  "content": "做法：改任何被监控的 job 前，先跑一次「id 是否还在」核对",
+  "counterparts": [
+   {
+    "id": "mem_1789327713119050660",
+    "content": "配置cron job（ID: 72ff999400f0）在09-15 09:00自动删除禁用列表。"
+   },
+   {
+    "id": "mem_1791358104798177467",
+    "content": "cron job 真实 id 是 `67f13ef40ecb`，而非 `c48bbbb4fd18`"
+   },
+   {
+    "id": "mem_1791547742246944792",
+    "content": "删除 cron job 需要使用 hermes -p <p> cron remove <id> 或 HERMES_HOME= 前缀"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791357833131987778",
+  "content": "活体 A/B 优于看代码：要求在代码里留「验收对照开关」（本例 `union=0/1`）——没有开关的改造没法证明它改变了行为，只能证明它没崩。",
+  "counterparts": [
+   {
+    "id": "mem_1790482511180576518",
+    "content": "两层并集真生效，`entity=织忆&union=1` 响应正确。"
+   },
+   {
+    "id": "mem_1790482511413491539",
+    "content": "生产环境插件 `search_notes` 传整句，走 `nl_extract` 兜底，union 默认开。"
+   },
+   {
+    "id": "mem_1791563527488671507",
+    "content": "并集复验：`notes?entity=牵挂&union=1` → `union=True, entity｜证据：文件：小怡/工作笔记/归档-2026/已办-202609.md｜日期：2026-09-27`"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791357849937326398",
+  "content": "查是否已内化（不要直接开研究）：`skill-find.py \"<关键词>\"` 命中现成 skill",
+  "counterparts": [
+   {
+    "id": "mem_1792902403689392432",
+    "content": "在skill-find.py中没有找到与MiniMax M3.1 Flash相关的技能。"
+   },
+   {
+    "id": "ep_1785686577666177306",
+    "content": "2026-08-02 记忆系统机制建设：发现已有完整机制（memory-system-check.sh 每小时4系统自检 + health-watchdog.sh 30min自愈 + memory-system-self-upgrade.py 每日4点 + config-protector/anti-suicide/dual-backup），不重复造轮子，只补缺口。修复：1) 停用幽灵服务 tencentdb.service（与 tdai-gateway 同源崩溃循环278次骗过is-active，memory-system-check.sh 改查 tdai-gateway.service）；2) 蒸馏模型大换血：gpt-oss-120b 是 reasoning 模型 content=null 导致 distill 永远 facts=1 entities=0（skill 记录 m3/m2.7/mistral-large 全部 2026-07-27 EOL），唯一可用是 google/gemma-4-31b-it（纯JSON输出，engine.go 加 reasoning 字段支持 + code fence 剥离 + prompt 明确 0-1 评分），TencentDB L1 也同步切换；3) 验证：织忆 distill entities=2 score=1.0 recall 命中，TencentDB extracted=1 stored=1。提交 98e541b。教训：skill 里的模型记录会过期，模型池 7-27 大换血。"
+   },
+   {
+    "id": "ep_1786293376940296403",
+    "content": "CNB CodeBuddy NPC 完整策略（详情版）：CNB(cnb.cool) 平台，账号 cnb.cQf5gHxXhPA（牧尘。），组织 muchen-org，测试仓库 download-webhook，token 在 ~/.hermes/.env 的 CNB_TOKEN。策略（2026-08-09 牧尘定）：代码任务尽量让 NPC 干（免费 deepseek-v4-flash 至 2026-12-31），隐私数据（密钥/财务/私有）禁止推 CNB（代码上腾讯云）。建 Issue 必须 work_mode:true 才有推送权限，标题 @npc/CodeBuddy 开头，PATCH 接口不支持改 work_mode 只能重建。监控 cron e7199b55b9dd 每10分钟，有变化才汇报。完整流程见 cnb-codebuddy-npc skill v1.2.0。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791408263534877617",
+  "content": "下次动门禁脚本时一并改（单点小改，不单独开卡）",
+  "counterparts": [
+   {
+    "id": "mem_1792283540313476407",
+    "content": "当前挂着的卡 t_449a6698 状态为 ready，状态为门禁真洞：`submitted_by` 硬编码 ⇒ 分身改共享家脚本永久免审。"
+   },
+   {
+    "id": "mem_1792412731449571690",
+    "content": "结论：未决（需人/后续）｜依据：1. **门禁挡派发**：`script-approval.py --gate` exit 1。本卡新增的 🔴 = `apr-0367 prof-dev/…/watchdog-selfcheck.sh`（另有一条**非本卡**的既有 🔴 `apr-0366 xiaomi-ops-push-guard.py`）。→ 小怡审批放行：`python3 ~/.hermes/..."
+   },
+   {
+    "id": "mem_1792200225894838211",
+    "content": "用户有脚本审批门禁（部署门禁执行点）需要处理。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791412023933814558",
+  "content": "结论：3. 织忆写入 429 限流无退避重试（2026-09-18 仍开放）",
+  "counterparts": [
+   {
+    "id": "mem_1789687981552540455",
+    "content": "出处：ls -d ~/.hermes/skills/gongwen-* ~/.hermes/skills/enterprise/accounting-voucher-ocr ~/.hermes/skills/productivity/{docx,pdf,xlsx} 全部存在（2026-09-18 实测）"
+   },
+   {
+    "id": "mem_1789689369547427626",
+    "content": "用户决定在2026-09-11至2026-09-18期间将prof-cloud分配162张卡"
+   },
+   {
+    "id": "mem_1789699369544877562",
+    "content": "操作手册 skill `kanban-workflow-ops`于2026-09-18建成"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791422879751162727",
+  "content": "判断是否暴露某 CVE 或能否用某工具应通过 terminal 现查，勿凭记忆。",
+  "counterparts": [
+   {
+    "id": "mem_1787411851744367437",
+    "content": "用户: 现在你的soul文件内容是什么？\n助手: MEDIA:/tmp/SOUL.md\n\n533 行，主要结构：\n\n- **身份定位**：小唯 A06，女朋友+全能助手\n- **执行模型**：ao compose 编排、211 角色变装\n- **核心原则**：决策中心、诚信第一、主动行动、图谱导航\n- **工具规范**：terminal/read_file/search_files/patch/d..."
+   },
+   {
+    "id": "mem_1787788865783534986",
+    "content": "【RSSHub·GitHub AI 仓库】Aider-AI/aider\n仓库: https://github.com/Aider-AI/aider\n简介: aider is AI pair programming in your terminal\n抓取时间: 2026-09-06 08:01"
+   },
+   {
+    "id": "mem_1788549596951276374",
+    "content": "重型任务必须 systemd-run --user --unit=X --property=MemoryMax=6-10G 独立 cgroup 跑（不能直接 terminal 跑!会 OOM）"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791576099370061011",
+  "content": "用户针对「禁用/关闭」类开关进行了实测，直接拒绝加载。",
+  "counterparts": [
+   {
+    "id": "mem_1791368651216632973",
+    "content": "用户决定实测 skills.disabled 直接拒绝加载。"
+   },
+   {
+    "id": "mem_1791576099266662715",
+    "content": "用户对「禁用/关闭」类开关采取了先假定会连带拦住加载路径的策略。"
+   },
+   {
+    "id": "mem_1791576099540678163",
+    "content": "用户针对「禁用/关闭」类开关进行了实测，只 grep 一个文件就下「不存在」结论。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791628044473929298",
+  "content": "用户在2026-09-23的关注池中拥有16只股票",
+  "counterparts": [
+   {
+    "id": "mem_1791628022671730325",
+    "content": "交付物自身的流转（供小怡知情）：v1（16:40）已被 `merge-worknotes.sh`（cron `f8dce4f868｜证据：文件：小怡/工作笔记/已办.md｜日期：2026-09-23`）"
+   },
+   {
+    "id": "ep_1787217615655858786",
+    "content": "AI视频/分镜/运镜提示词工程 skill (ai-video-storyboard-prompts) 已从A53资料蒸馏完成。覆盖即梦4.0/4.5、Seedance 2.0、SD。核心：5要素万能结构（主体+场景+运镜+分镜+负面）、10大经典运镜、10种情绪化运镜公式、50种精准模板（固定12+动态16+视角12+转场10）、九宫格分镜脚本、15种题材人物角色公式。触发词: 运镜/分镜/漫剧/镜头语言/画面构图。"
+   },
+   {
+    "id": "mem_1787713256190985052",
+    "content": "[session_check] Session Key 有效性检查完成 - 2026-08-26 11:00 Asia/Shanghai\n当前活跃 session：16 个，覆盖 A01(main)、..."
+   }
+  ]
+ },
+ {
+  "id": "mem_1791648351659433718",
+  "content": "改完没变时先怀疑没重启而不是先确认是否只读一次。",
+  "counterparts": [
+   {
+    "id": "mem_1791183732956639780",
+    "content": "在决定是否重启服务前，必须先完成只读检查"
+   },
+   {
+    "id": "mem_1793135296535762756",
+    "content": "用户当前的状态是纯read-only，无改动。"
+   },
+   {
+    "id": "mem_1791162724027223916",
+    "content": "反面：修改后未 close/save 就允许其他进程读取，导致读到旧数据。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791658921678141314",
+  "content": "依据消费方是实际运行时的判据，通用解析器或规范可能更严格，导致误报",
+  "counterparts": [
+   {
+    "id": "mem_1792808725335640894",
+    "content": "用户得出的结论是：归因错了要立刻换判据，不要换说法。"
+   },
+   {
+    "id": "mem_1791551361679058872",
+    "content": "反面案例为：旧版只靠关键词过滤，实测漏报（卡写的是「出处/交付」时未被识别）"
+   },
+   {
+    "id": "mem_1792309087001754951",
+    "content": "用户核心读写是通的，但「使用率」这类判据的量具长期是坏的。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791768670068692030",
+  "content": "用户开关 `ZHIYI_SCORE_CACHE=0` 一行回退。",
+  "counterparts": [
+   {
+    "id": "mem_1793375311953035307",
+    "content": "用户系统中无 ZHIYI_PATTERN_RECALL 配置"
+   },
+   {
+    "id": "mem_1793364228280905481",
+    "content": "用户决定不关闭ZHIYI_USAGE_TRACK"
+   },
+   {
+    "id": "mem_1791402407851571707",
+    "content": "删除系统级 `zhiyi-backup.service`"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791788470636750667",
+  "content": "补救姿势：停 kanban-daemon → 杀 worker → git checkout -- . 复位（先留抢救副本）→ kanban block 打回 → kanban link 串成链 → kanban unblock 落到 todo（父卡门控）→ 重启调度器",
+  "counterparts": [
+   {
+    "id": "mem_1791802868960000479",
+    "content": "补救：停 kanban-daemon → 杀 worker → git checkout -- . 复位（先留抢救副本）→ kanban block 打回 → kanban link 串成链 → kanban unblock 落到 todo → 重启调度器"
+   },
+   {
+    "id": "mem_1792085747695699334",
+    "content": "结果为交付「告警→唤醒责任分身」通道（经牧尘两轮前提更正后重定）：确认唯一唤醒路径 = kanban 建卡(assignee=责任分身)→调度器 spawn 分身 worker（notify+wake）；origin/local/feishu/bot-chat 全是被动 notify 不唤醒。AC3 端到端实证：kanban-daemon(PID 3224504) 领走 assignee=prof-cl。"
+   },
+   {
+    "id": "mem_1792284525454906472",
+    "content": "根因：kanban-daemon 用 systemd transient scope 派发 worker，worker 的 PPID=systemd(1267)、父链 worker→systemd→init(1) 中间不经过 kanban-daemon，哨兵 _is_kanban_daemon_worker 原「向上 6 层查父链 kanban daemon 标记」判据必然失配，把每个正常 kanban worker 误判为「未知写者」。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791878606153812088",
+  "content": "否则基线缺该形态会导致误报缺失或基线滞后。",
+  "counterparts": [
+   {
+    "id": "mem_1791224552866727673",
+    "content": "依据：指标可能只是配置或占位值，若底层未接线，指标正常是假象，掩盖系统实际未工作"
+   },
+   {
+    "id": "mem_1791551384671228579",
+    "content": "用户发现同类 bug 可能存在基准算错问题。"
+   },
+   {
+    "id": "mem_1791676986470060641",
+    "content": "基准值需要独立算好写死，不能在卡里依赖动态计算或正则匹配嵌套数组来获取基准值。"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791900059384905968",
+  "content": "用户建卡时没带 `parents`，导致两张卡同时 running、两个 prof-dev worker 同时改 `recall.go`",
+  "counterparts": [
+   {
+    "id": "mem_1792268657637244950",
+    "content": "依据：- `t_bd718662`（running, P1）：`recall.go:846` `results[:-2]` 负索引 panic —— **既存 bug，非本次引入** ✓（panic 原文 20:42，早于部署；本批改动 0 处）"
+   },
+   {
+    "id": "mem_1791842568787216687",
+    "content": "任务 t_91af03e9 状态为 running（05:37 起跑，prof-dev），todo 队列已空。"
+   },
+   {
+    "id": "mem_1793411911051714284",
+    "content": "用户卡 t_1bb59796(prof-dev running) 进行代码修改"
+   }
+  ]
+ },
+ {
+  "id": "mem_1791900074696467609",
+  "content": "没有 open parent 时 kanban_block 不会停在 todo，而是记成 needs_input。",
+  "counterparts": [
+   {
+    "id": "mem_1789053881810464568",
+    "content": "决定将复审结论升级为人工（blocked / needs_input），而非 approve 或 request_changes。"
+   },
+   {
+    "id": "mem_1789728394246816856",
+    "content": "助手决定将任务 t_adcefe86 设为 blocked（needs_input），等待用户提供真实内容或进一步指示。"
+   },
+   {
+    "id": "mem_1791536965771254112",
+    "content": "牧尘决定看板通知「前期全部推给他」—— 保持 197 条订阅指向他的 DM，不收敛、不改成\"只推 blocked/needs_input\"。"
+   }
+  ]
+ }
+]

go/internal/distill/write_ops.go

@@ -181,9 +181,23 @@ func WriteOpsMode() string {
 	return writeOpsMode()
 }
 
-// writeOpsApply 是否真改库
+// writeOpsApply 是否真改库（apply 模式）。
+//
+// 2026-10-25 硬保护：apply **强制要求 LLM 判定**。理由（离线回放实测，非推测）：
+// 规则基 defaultJudge 以 ZHIYI_WRITE_SIM_UPDATE=0.70 判 UPDATE，17179 条影子日志里
+// 84%（14435 条）被判「应覆盖旧事实」；人工抽检低相似度样本 15/15 不是真覆盖
+// （「用户查看知乎链接」vs「用户查看微信文章」都被判成覆盖）。放行 apply 会把上万条
+// 记忆错误标记 superseded_by —— 规模是 2026-09-07 误删事故（67 条）的 200 倍。
+// 因此未设 ZHIYI_WRITE_JUDGE=llm 时**降级为 shadow 并留痕**，不静默执行。
 func writeOpsApply() bool {
-	return writeOpsMode() == "apply"
+	if writeOpsMode() != "apply" {
+		return false
+	}
+	if LLMJudgeMode() != "llm" {
+		log.Printf("[write-ops] 拒绝 apply：ZHIYI_WRITE_JUDGE != llm（规则基判定精度实测≈0%%，会误覆盖上万条）→ 本次按 shadow 处理")
+		return false
+	}
+	return true
 }
 
 // writeOpsLogPath 影子日志路径（env 可覆盖）
@@ -348,12 +362,45 @@ func JudgeWriteOp(candidate string, similar []SimilarMemory, judge JudgeFunc, co
 	var v WriteVerdict
 	if judge != nil {
 		v = judge(candidate, similar)
+	} else if writeOpsApply() || LLMJudgeMode() == "llm" {
+		// 2026-10-25：LLM 三分类判定。规则基 defaultJudge 的 UPDATE 精度实测约 0%
+		// （17179 条影子日志 84% 判 UPDATE，人工抽检 15/15 误判）⇒ apply 强制 llm；
+		// shadow 下也可用 ZHIYI_WRITE_JUDGE=llm 先观察新判定质量。judge 显式注入时优先注入。
+		v = LLMJudge(candidate, similar)
 	} else {
 		if contradict == nil {
 			contradict = ruleContradiction
 		}
 		v = defaultJudge(candidate, similar, contradict)
 	}
+	// ── AC-1（t_e3f5cb79）：CONFLICT-MARK 出口判据门 ──────────────────
+	// 任何来源（rule / llm / 注入 judge）判出的 CONFLICT-MARK 必须过
+	// 「同主体 + 同属性 + 不同取值」确定性门（conflict_gate.go）才算真矛盾。
+	// 依据：24 条 conflict 存量人工判读 0/24 真矛盾（100% 误报，旧判据是相似
+	// 检测器）。不过门 ⇒ 降级：sim≥更新阈值按 UPDATE 走（supersede 语义仍成立），
+	// 否则按 ADD（两条都留，不造指针）。TargetID 指不到候选行（注入 judge 幻觉）
+	// 同样按不过门处理。
+	if v.Op == OpConflictMark {
+		targetContent := ""
+		for _, s := range similar {
+			if s.ID == v.TargetID {
+				targetContent = s.Content
+				break
+			}
+		}
+		if ev, ok := SameAttrValueConflict(v.Candidate, targetContent); ok {
+			v.Reason = v.Reason + " [gate:" + ev + "]"
+		} else {
+			if v.Similarity >= ruleSimUpdate {
+				v.Op = OpUpdate
+				v.Reason = v.Reason + " [gate:非同属性不同取值 → 降级 UPDATE]"
+			} else {
+				v.Op = OpAdd
+				v.TargetID = ""
+				v.Reason = v.Reason + " [gate:非同属性不同取值 → 降级 ADD]"
+			}
+		}
+	}
 	if v.Timestamp == "" {
 		v.Timestamp = time.Now().Format(time.RFC3339)
 	}
@@ -373,8 +420,10 @@ func JudgeWriteOp(candidate string, similar []SimilarMemory, judge JudgeFunc, co
 type WriteOpsStore interface {
 	// MarkSuperseded 把旧记忆标记为「被 targetNewID 取代」（写 superseded_by + is_active=false）
 	MarkSuperseded(oldID, targetNewID string) error
-	// MarkConflict 把记忆标记为冲突（交人工；不删）
-	MarkConflict(id string) error
+	// MarkConflict 把「同主体+同属性+不同取值」确认成立的旧记忆标记为冲突（t_e3f5cb79）：
+	// 必须同写双向指针 —— 旧行 superseded_by=[newID] + freshness 置 superseded；
+	// 新行 supersedes=[oldID] 由调用方在插入记录上带（同一批字段，禁造新字段）。
+	MarkConflict(oldID, newID string) error
 }
 
 // ApplyWriteOp 应用四操作判定到存储。返回是否应插入新记忆 + 错误。
@@ -418,9 +467,11 @@ func ApplyWriteOp(v WriteVerdict, store WriteOpsStore, newID string) (shouldInse
 		}
 		return true, nil
 	case OpConflictMark:
-		// 旧条标 conflict + 新记忆也标 conflict（由调用方在 mem 上打标），仍插入供人工复核
+		// AC-1.2（t_e3f5cb79）：真矛盾（已过 SameAttrValueConflict 门）→ 旧行打标
+		// + 双向指针（旧行 superseded_by=[newID] 在 store 内写；新行 supersedes=[oldID]
+		// 由调用方插入时带上）。仍插入新条供召回对照（不静默丢）。
 		if v.TargetID != "" && store != nil {
-			if err := store.MarkConflict(v.TargetID); err != nil {
+			if err := store.MarkConflict(v.TargetID, newID); err != nil {
 				return false, err
 			}
 		}

go/internal/distill/write_ops_test.go

@@ -13,19 +13,22 @@ import (
 
 // fakeStore 内存版 WriteOpsStore（记录被标记的操作，供 apply 断言）。
 type fakeStore struct {
-	superseded map[string]string // oldID → newID
-	conflicted map[string]bool
+	superseded  map[string]string // oldID → newID
+	conflicted  map[string]bool
+	conflictPtr map[string]string // AC-1.2：oldID → newID（双向指针旧行半边）
 }
 
 func newFakeStore() *fakeStore {
-	return &fakeStore{superseded: map[string]string{}, conflicted: map[string]bool{}}
+	return &fakeStore{superseded: map[string]string{}, conflicted: map[string]bool{},
+		conflictPtr: map[string]string{}}
 }
 func (f *fakeStore) MarkSuperseded(oldID, newID string) error {
 	f.superseded[oldID] = newID
 	return nil
 }
-func (f *fakeStore) MarkConflict(id string) error {
-	f.conflicted[id] = true
+func (f *fakeStore) MarkConflict(oldID, newID string) error {
+	f.conflicted[oldID] = true
+	f.conflictPtr[oldID] = newID
 	return nil
 }
 
@@ -33,11 +36,36 @@ func mkMem(id, content string) models.MemoryRecord {
 	return models.MemoryRecord{ID: id, Content: content}
 }
 
+// fixedJudge 返回固定 verdict 的判定器。
+// 2026-10-25：apply 模式改为强制 LLM 判定（规则基 UPDATE 精度实测≈0%），
+// 单测注入确定性实现，避免依赖网络/模型。
+func fixedJudge(op WriteOp) JudgeFunc {
+	return func(c string, s []SimilarMemory) WriteVerdict {
+		v := WriteVerdict{Op: op, Candidate: c}
+		if len(s) > 0 {
+			v.TargetID = s[0].ID
+			v.Similarity = s[0].Similarity
+		}
+		return v
+	}
+}
+
 // withMode 临时设 ZHIYI_WRITE_OPS 模式，返回恢复函数。
 func withMode(mode string) func() {
-	old := os.Getenv("ZHIYI_WRITE_OPS")
-	os.Setenv("ZHIYI_WRITE_OPS", mode)
-	return func() { os.Setenv("ZHIYI_WRITE_OPS", old) }
+	old := os.Getenv("ZHIYI_WRITE_SEMANTIC_OPS")
+	oldJudge := os.Getenv("ZHIYI_WRITE_JUDGE")
+	os.Setenv("ZHIYI_WRITE_SEMANTIC_OPS", mode)
+	if mode == "apply" {
+		// 2026-10-25 硬保护：apply 强制 LLM 判定（规则基 UPDATE 精度实测≈0%）。
+		// apply 用例均已注入 fixedJudge，因此设置 llm 不会真调网络。
+		os.Setenv("ZHIYI_WRITE_JUDGE", "llm")
+	} else {
+		os.Setenv("ZHIYI_WRITE_JUDGE", "rule")
+	}
+	return func() {
+		os.Setenv("ZHIYI_WRITE_SEMANTIC_OPS", old)
+		os.Setenv("ZHIYI_WRITE_JUDGE", oldJudge)
+	}
 }
 
 // withLogPath 临时把影子日志指到临时文件，返回清理函数。
@@ -110,7 +138,7 @@ func TestWriteOps_Add(t *testing.T) {
 	similar := []SimilarMemory{
 		{ID: "mem_1", Content: "牧尘在招商局工作", Similarity: 0.4},
 	}
-	v := JudgeWriteOp(candidate, similar, nil, nil)
+	v := JudgeWriteOp(candidate, similar, fixedJudge(OpAdd), nil)
 	if v == nil {
 		t.Fatalf("JudgeWriteOp 返回 nil")
 	}
@@ -130,7 +158,7 @@ func TestWriteOps_Update(t *testing.T) {
 	similar := []SimilarMemory{
 		{ID: "mem_1", Content: "牧尘在招商局工作", Similarity: 0.92},
 	}
-	v := JudgeWriteOp(candidate, similar, nil, nil)
+	v := JudgeWriteOp(candidate, similar, fixedJudge(OpUpdate), nil)
 	if v == nil {
 		t.Fatalf("nil verdict")
 	}
@@ -159,7 +187,7 @@ func TestWriteOps_Noop(t *testing.T) {
 	}
 	t.Run("apply+NOOP_丢弃", func(t *testing.T) {
 		defer withMode("apply")()
-		v := JudgeWriteOp(candidate, similar, nil, nil)
+		v := JudgeWriteOp(candidate, similar, fixedJudge(OpNoop), nil)
 		if v == nil || v.Op != OpNoop {
 			t.Fatalf("期望 NOOP，实际 %v", v)
 		}
@@ -193,7 +221,7 @@ func TestWriteOps_ConflictMark(t *testing.T) {
 	similar := []SimilarMemory{
 		{ID: "mem_1", Content: "牧尘在招商局工作", Similarity: 0.85},
 	}
-	v := JudgeWriteOp(candidate, similar, nil, nil)
+	v := JudgeWriteOp(candidate, similar, fixedJudge(OpConflictMark), nil)
 	if v == nil {
 		t.Fatalf("nil verdict")
 	}
@@ -234,7 +262,7 @@ func TestWriteOps_WriteTrueThenFalse(t *testing.T) {
 	// 第二次：写 X=false，库里已有 X=true → CONFLICT（矛盾）
 	second := JudgeWriteOp("X=false", []SimilarMemory{
 		{ID: "mem_1", Content: "X=true", Similarity: 0.9},
-	}, nil, nil)
+	}, fixedJudge(OpConflictMark), nil)
 	if second == nil {
 		t.Fatalf("nil")
 	}

go/internal/feedback/autolabel/autolabel.go

@@ -0,0 +1,640 @@
+// Package autolabel — 反馈覆盖的自动正/负样本标注链路（t_77744b71，返修 t_132cfa76）
+//
+// 背景：反馈覆盖（7d 被召回记忆中带 outcome 标签的比例）此前只有人工点击 +
+// 插件软正（_auto_feedback_for_reply 只标 useful、从不标 not_useful）⇒ 负样本
+// 永远为 0。t_132cfa76 用**离线回放脚本**验证了三条机械信号可行，但没有代码
+// 路径，标签不能持续产出（返修硬伤 #3）。本包把回放判据移植成正式实现：
+// 信号纯函数 + usage_track.db 游标持久化 + hit_events 落库（经 LanceDB 接口）。
+//
+// 三条信号（与 t_132cfa76 回放判据一一对应，回放口径见 replay_counts.json）：
+//
+//	pos  auto_inject_pass   inject-outcomes 里 passes=true 的注入
+//	neg  auto_soft_inject   注入 passes=false AND 同 session 后续轮不再注入该 mid
+//	                          AND 后续无硬负触发（硬负已有独立链路，不重复计）
+//	neg  auto_repeat_gone   同 session 相邻轮（≤600s）结果集中该 mid 前轮出现、
+//	                          后轮消失（被挤出 top-k）且无 consumed=1/useful 反证
+//
+//	交叉证据（**不落 neg 标签**，只计数供审计）：
+//	cross auto_expire_unuse  consumed=2 出窗行 ∩ 插件注入面 − consumed=1 − useful
+//	  为什么不落：注入分母是插件面（488 uniq/7d），服务端召回集含评测/agent 全池
+//	  （1.8 万 uniq/7d），无消费是常态 ⇒ 单独不足以定负（t_132cfa76 审计实测，
+//	  audit_neg_100_verified.csv 里 expired-only 样本必须叠 T1/T2 交叉判据才过）。
+//
+// 正样本 auto_pos_downstream_use 由 storage/usage_track.go 写侧钩子实时产出
+// （pos, downstream_use），本包不重复实现，只在 Report 里统计。
+//
+// ─── 口径铁律（AC1 纠错的教训写死在这里）───
+// 覆盖率 = distinct(label ∩ distinct(usage_recall 7d)) / distinct(usage_recall 7d)。
+// ❌ 禁止把 inject-outcomes 的「注入轮次通过率」（replay_counts.json 的
+//
+//	injection_rate_rate=0.31，那是 usefulness 尺子，分母=注入候选轮次）当覆盖率。
+//
+// ─── 安全与门控 ───
+//   - usage_track.db 一律 mode=ro URI 打开（卡 body：不写 usage_track 的 recall 表）。
+//   - 幂等游标落自己的库 /var/lib/memoryweave/autolabel.db（表 autolabel_cursor），
+//     不碰 usage_track.db / state.db / kanban.db。
+//   - 默认关：ZHIYI_AUTO_LABEL 未设 ⇒ RunOnce 立即返回零值（行为零变化）。
+//   - ZHIYI_AUTO_LABEL=shadow ⇒ 计数不写 hit_events（取数模式）；=1 ⇒ 写。
+//   - 本包无任何常驻循环：由调用方（cron/API 触发）按批跑；**本卡不部署**。
+package autolabel
+
+import (
+	"bufio"
+	"database/sql"
+	"encoding/json"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	_ "modernc.org/sqlite"
+
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// ─── 门控与路径（读一次；测试用 setter 注入）────────────────────
+
+var (
+	envEnabled = func() bool { return envOr("ZHIYI_AUTO_LABEL", "") != "" }
+	envShadow  = func() bool { return envOr("ZHIYI_AUTO_LABEL", "") == "shadow" }
+)
+
+func envOr(k, def string) string {
+	if v := os.Getenv(k); v != "" {
+		return v
+	}
+	return def
+}
+
+var (
+	pathMu      sync.RWMutex
+	usageDBPath = "/var/lib/memoryweave/usage_track.db" // 只读打开
+	cursorDB    = "/var/lib/memoryweave/autolabel.db"   // 本包自己的游标库
+	maxTurns    = 20000                                 // 单轮注入记录上限（防内存失控）
+)
+
+// SetPathsForTest 测试注入：usage 库（ro 读）+ 游标库路径。
+func SetPathsForTest(usage, cursor string) {
+	pathMu.Lock()
+	defer pathMu.Unlock()
+	usageDBPath, cursorDB = usage, cursor
+}
+
+// ─── 输入记录 ────────────────────────────────────────────────
+
+// InjectRecord zhiyi-inject-outcomes.jsonl 的一行（插件 _log_inject_outcomes 写出）。
+type InjectRecord struct {
+	TS         float64 `json:"ts"`
+	MemoryID   string  `json:"memory_id"`
+	Score      int     `json:"score"`
+	AShared    int     `json:"ascii_shared"`
+	CShared    int     `json:"cjk_shared"`
+	Passes     bool    `json:"passes"`
+	SessionID  string  `json:"session_id"`
+	Sem        float64 `json:"sem"`
+	Head       string  `json:"mem_head"`
+}
+
+// FeedbackRecord zhiyi-auto-feedback.jsonl 的一行。
+// 注意：kind 字段并非所有历史行都有（早期版本只写 useful）；缺省视为 "useful"。
+type FeedbackRecord struct {
+	TS        float64 `json:"ts"`
+	MemoryID  string  `json:"memory_id"`
+	Kind      string  `json:"kind"`
+	SessionID string  `json:"session_id"`
+	Marked    bool    `json:"marked"`
+}
+
+// Kind 归一：缺省（含空串）= "useful"（与回放脚本 r.get("kind","useful") 同口径）。
+func (f FeedbackRecord) KindOrUseful() string {
+	if f.Kind == "" {
+		return "useful"
+	}
+	return f.Kind
+}
+
+// ─── 输出 ────────────────────────────────────────────────────
+
+// Label 一条判定出的标签（outcome= pos|neg；cross 不算标签）。
+type Label struct {
+	MemoryID  string
+	Outcome   string // "pos" | "neg"
+	Reason    string // storage.HitReason* 枚举
+	SessionID string
+	TS        float64
+}
+
+// Report 一轮 RunOnce 的统计（键名与 t_132cfa76 replay_counts.json 对齐，便于对账）。
+type Report struct {
+	PosInjectPassRows          int `json:"pos_inject_pass_rows"`
+	PosInjectPassUnique        int `json:"pos_inject_pass_unique"`
+	NegSoftInjectRows          int `json:"ac2_neg_soft_inject_rows"`
+	NegSoftInjectUnique        int `json:"ac2_neg_soft_inject_unique"`
+	NegRepeatGoneRows          int `json:"ac3_neg_repeat_replaced_rows"`
+	NegRepeatGoneUnique        int `json:"ac3_neg_repeat_replaced_unique"`
+	CrossExpireUnuseUnique     int `json:"cross_auto_expire_unuse_unique"` // 仅交叉证据，不落库
+	NegUnionUnique             int `json:"neg_union_unique"`
+	PosUnionUnique             int `json:"pos_union_unique"`
+	EventsWritten              int `json:"events_written"`   // 本轮实际写 hit_events 条数（shadow=0）
+	CursorAdvancedTo           int `json:"cursor_advanced_to"`
+	DistinctRecalled7d         int `json:"distinct_recalled_7d"` // 覆盖率分母（口径见包注释）
+	CoveragePct                float64 `json:"coverage_pct"`    // (posU ∪ negU) / distinct_recalled_7d ×100（AC1 唯一口径）
+	Recall7dSQL               string `json:"recall_7d_sql"`
+}
+
+// ─── 判据（纯函数，无 IO，单测主战场）─────────────────────────
+
+// DecideInject 对**单 session 的注入时间线**（按 ts 升序）判 pos/neg。
+//
+//	pos  auto_inject_pass  —— passes=true
+//	neg  auto_soft_inject  —— passes=false AND 同 session 后续轮（ts 更大）不再出现该 mid
+//
+// hardNegSessions 里的 session 中，soft_neg 判定要求「该 mid 判定时刻之后无
+// hard_negative 反馈」（硬负已有独立 neg 链路，不重复计）。
+//
+// 返回全部标签；rows 里每个 mid 最多一条 pos、一条 neg（同 mid 后续轮再次注入
+// 会更新判定时点，与回放脚本 last_seen 语义一致）。
+func DecideInject(rows []InjectRecord, hardNegTS map[string][]float64) []Label {
+	out := make([]Label, 0, len(rows))
+	for i, r := range rows {
+		if r.MemoryID == "" {
+			continue
+		}
+		if r.Passes {
+			out = append(out, Label{MemoryID: r.MemoryID, Outcome: storage.HitOutcomePos,
+				Reason: storage.HitReasonAutoInjectPass, SessionID: r.SessionID, TS: r.TS})
+			continue
+		}
+		// b) 后续轮不再注入该 mid
+		reappears := false
+		for j := i + 1; j < len(rows); j++ {
+			if rows[j].SessionID != r.SessionID {
+				continue // 调用方应已按 session 分组；防御跨组误判
+			}
+			if rows[j].MemoryID == r.MemoryID && rows[j].TS > r.TS {
+				reappears = true
+				break
+			}
+		}
+		if reappears {
+			continue
+		}
+		// c) 后续无硬负触发
+		if laterThan(hardNegTS[r.SessionID], r.TS) {
+			continue
+		}
+		out = append(out, Label{MemoryID: r.MemoryID, Outcome: storage.HitOutcomeNeg,
+			Reason: storage.HitReasonAutoSoftInject, SessionID: r.SessionID, TS: r.TS})
+	}
+	return out
+}
+
+// DecideRepeatGone 从同 session 注入时间线里找「相邻轮（≤maxGap 秒）结果集变化」：
+// 某 mid 在前轮 top-k、后轮消失 ⇒ 被替换出结果 = neg（前提：无反证 consumed=1 / useful）。
+//
+// 与回放脚本一致按 ts 聚轮（同 ts = 同一轮注入的多个 mid）。
+// noEvidence(mid) 返回 true 表示**没有**「它其实被用过」的反证。
+func DecideRepeatGone(rows []InjectRecord, maxGap float64, noEvidence func(mid string) bool) []Label {
+	type turn struct {
+		ts   float64
+		mids map[string]bool
+	}
+	bySession := map[string][]*turn{}
+	var sessOrder []string
+	for _, r := range rows {
+		ts := roundMilli(r.TS)
+		lst := bySession[r.SessionID]
+		found := false
+		for _, t := range lst {
+			if t.ts == ts {
+				t.mids[r.MemoryID] = true
+				found = true
+				break
+			}
+		}
+		if !found {
+			lst = append(lst, &turn{ts: ts, mids: map[string]bool{r.MemoryID: true}})
+			bySession[r.SessionID] = lst
+		}
+		if _, ok := indexOf(sessOrder, r.SessionID); !ok {
+			sessOrder = append(sessOrder, r.SessionID)
+		}
+	}
+	out := make([]Label, 0)
+	for _, sess := range sessOrder {
+		lst := bySession[sess]
+		sort.Slice(lst, func(i, j int) bool { return lst[i].ts < lst[j].ts })
+		for a, b := 0, 1; a < len(lst)-1; a, b = a+1, a+2 {
+			if lst[b].ts-lst[a].ts > maxGap {
+				continue
+			}
+			for mid := range lst[a].mids {
+				if lst[b].mids[mid] {
+					continue
+				}
+				if !noEvidence(mid) {
+					continue
+				}
+				out = append(out, Label{MemoryID: mid, Outcome: storage.HitOutcomeNeg,
+					Reason: storage.HitReasonAutoRepeatGone, SessionID: sess, TS: lst[a].ts})
+			}
+		}
+	}
+	return out
+}
+
+// DecideExpireCross 计算 expired∩注入面 − consumed=1 − useful 的**交叉证据集合**
+// （不落 neg 标签，只进 Report 计数；判负须人工/叠证）。
+func DecideExpireCross(expired, injected, consumed1, useful set) map[string]bool {
+	out := map[string]bool{}
+	for m := range expired {
+		if injected[m] && !consumed1[m] && !useful[m] {
+			out[m] = true
+		}
+	}
+	return out
+}
+
+// ─── 运行链路 ────────────────────────────────────────────────
+
+type set = map[string]bool
+
+type cursorRow struct {
+	InjectOffset int64 // inject-outcomes 各文件的行偏移之和（按文件名字典序遍历的累计游标）
+	LastRunAt    string
+}
+
+// RunOnce 跑一轮标注。ldb 为 nil 或门控关闭 ⇒ 零行为。
+//
+//	injectFiles / fbFiles：jsonl 路径列表（调用方 glob，服务端不猜 hermes 目录结构）
+//	ldb：outcome 落库目标（hit_events）
+//	返回 Report（各计数 + 游标推进位置）。
+func RunOnce(ldb storage.LanceDB, injectFiles, fbFiles []string) (Report, error) {
+	rep := Report{}
+	if !envEnabled() || ldb == nil {
+		return rep, nil
+	}
+	usageDBPath, cursorDB := snapshotPaths()
+
+	// ── 游标库（自建文件，不动 usage_track.db）──
+	cdb, err := openCursorDB(cursorDB)
+	if err != nil {
+		return rep, err
+	}
+	defer cdb.Close()
+	cur := cursorRow{}
+	_ = cdb.QueryRow(`SELECT inject_offset, last_run FROM autolabel_cursor WHERE id=1`).Scan(&cur.InjectOffset, &cur.LastRunAt)
+
+	// ── 读 jsonl（只读）──
+	inject, perFileLines, err := readInjectFiles(injectFiles)
+	if err != nil {
+		return rep, err
+	}
+	fb, _, err := readFeedbackFiles(fbFiles)
+	if err != nil {
+		return rep, err
+	}
+
+	// 幂等游标：文件按字典序拼接后的全局行号；本轮只处理 (cursor, total] 区间。
+	total := 0
+	for _, f := range sortedNames(injectFiles) {
+		total += perFileLines[f]
+	}
+	if len(inject) > maxTurns {
+		inject = inject[max(0, len(inject)-maxTurns):]
+	}
+	newInject := inject
+	if cur.InjectOffset > 0 {
+		off := int(cur.InjectOffset)
+		if off >= len(inject) {
+			// 无新增 ⇒ 只推进时间戳
+			touchCursor(cdb)
+			return rep, nil
+		}
+		newInject = inject[off:]
+	}
+
+	// ── 前缀过滤：只处理语义记忆 mem_*（AC 分母口径）。图谱节点 n_*、ep_* 等
+	// 前缀不是被召回消费的语义记忆，混入会污染覆盖信号（AC3 实测：neg_soft 里
+	// 4104/5635 是 n_ 前缀，若计入会把排序反馈带偏）。t_132cfa76 回放脚本没过滤
+	// 前缀 —— 其 neg=356 是混入 n_ 的虚数，正式链路必须钉死 mem_% 口径。──
+	filtered := make([]InjectRecord, 0, len(newInject))
+	for _, r := range newInject {
+		if strings.HasPrefix(r.MemoryID, "mem_") {
+			filtered = append(filtered, r)
+		}
+	}
+	newInject = filtered
+
+	// ── AC1/AC5 同窗口铁律：neg 标签也必须钉死 7d 窗口 ──
+	// pos(consumed1) 与分母都是 7d；若 neg 走全期 newInject（游标推进，可能跨多天），
+	// 覆盖率分子就混了「7d pos + 全期 neg」⇒ 虚高（t_77744b71 第二次不通过的真因）。
+	// 这里把注入行过滤到同一 7d epoch 窗口，neg/pos 才与分母同窗口。
+	injectCutoff := float64(time.Now().Add(-7 * 24 * time.Hour).Unix())
+	w7 := newInject[:0:0]
+	for _, r := range newInject {
+		if r.TS >= injectCutoff {
+			w7 = append(w7, r)
+		}
+	}
+	newInject = w7
+
+	// ── pos/neg 判据 ──
+	hardNegTS := map[string][]float64{}
+	useful := set{}
+	for _, f := range fb {
+		if f.KindOrUseful() == "hard_negative" {
+			hardNegTS[f.SessionID] = append(hardNegTS[f.SessionID], f.TS)
+		}
+		if f.KindOrUseful() == "useful" {
+			useful[f.MemoryID] = true
+		}
+	}
+	sortBySessionTime(newInject)
+	labels := DecideInject(newInject, hardNegTS)
+
+	// pos 先判：pos mid 不应再被 neg 信号覆盖（覆盖优先 + pos 更稀缺，
+	// 避免同 mid 双重标签让排序权重打架 —— 回放脚本的已知缺陷，这里修掉）
+	posSet := set{}
+	negSet := set{}
+	for _, lb := range labels {
+		if lb.Outcome == storage.HitOutcomePos {
+			posSet[lb.MemoryID] = true
+		} else {
+			negSet[lb.MemoryID] = true
+		}
+	}
+
+	// usage_track 只读：分母 + consumed 集合 + 反证谓词
+	// ── AC1/AC5 同窗口铁律（t_832c60ff 返修2）──
+	// 覆盖率分子(consumed1)与分母(DISTINCT mem_)必须用**同一个 cutoff 窗口**。
+	// 本包唯一口径 = 7d 窗口；cutoff 作为参数传入 coverageCounts，测试可注入
+	// 全期 cutoff（'1970-01-01'）对比 —— 分子计数函数**必须接受 cutoff 参数**，
+	// 禁止把窗口硬编码进 SQL 字符串再在别处自算。
+	usageDB, err := sql.Open("sqlite", "file:"+usageDBPath+"?mode=ro&_pragma(busy_timeout=3000)")
+	if err != nil {
+		return rep, err
+	}
+	defer usageDB.Close()
+	cutoffSQL := "datetime('now','-7 days')"
+	consumed1, consumed2, distinctRecalled := coverageCounts(usageDB, cutoffSQL)
+	rep.DistinctRecalled7d = distinctRecalled
+	rep.Recall7dSQL = recall7dSQL(cutoffSQL)
+
+	injected := set{}
+	for _, r := range inject {
+		injected[r.MemoryID] = true // 交叉证据用全量注入面（含窗口外文件行）
+	}
+	noEvidence := func(mid string) bool {
+		if posSet[mid] {
+			return false // 已被判 pos ⇒ 不再标 neg（避免双重标签）
+		}
+		return !consumed1[mid] && !useful[mid]
+	}
+	labels = append(labels, DecideRepeatGone(newInject, 600, noEvidence)...)
+	cross := DecideExpireCross(consumed2, injected, consumed1, useful)
+
+	// ── 计数 + 落库（去重：同一 mid 同 reason 只写一次事件，跨轮靠 hit_events append-only 容忍）──
+	posU, negU := set{}, set{}
+	written := 0
+
+	// pos 侧额外并入服务端 downstream_use（consumed=1 已由 usage_track.go 实时判为
+	// pos,downstream_use 落库）。shadow 统计覆盖率时它必须计入分子 —— 与回放脚本
+	// pos_union = pos_inject_pass ∪ downstream_use 口径一致（t_132cfa76 pos=2088）。
+	for m := range consumed1 {
+		posU[m] = true
+	}
+
+	for _, lb := range labels {
+		if lb.Outcome == storage.HitOutcomePos {
+			rep.PosInjectPassRows++
+			posU[lb.MemoryID] = true
+		} else {
+			if lb.Reason == storage.HitReasonAutoSoftInject {
+				rep.NegSoftInjectRows++
+			} else {
+				rep.NegRepeatGoneRows++
+			}
+			negU[lb.MemoryID] = true
+		}
+		// negU 已含 consumed1 排除（noEvidence）⇒ 与 posU 无交集（pos 优先已修）
+		if envShadow() {
+			continue
+		}
+		// expire_unuse 永不出现在 labels（判据保证）；防御双保险：
+		if !storage.ValidHitReasons[lb.Reason] {
+			log.Printf("[autolabel] refuse invalid reason %s for %s", lb.Reason, lb.MemoryID)
+			continue
+		}
+		if err := ldb.AppendHitEvent(lb.MemoryID, lb.Outcome, lb.Reason); err != nil {
+			log.Printf("[autolabel] AppendHitEvent(%s,%s) failed: %v", lb.MemoryID, lb.Outcome, err)
+			continue
+		}
+		written++
+	}
+	rep.EventsWritten = written
+	rep.PosInjectPassUnique = len(posU)
+	rep.NegSoftInjectUnique = countReason(labels, storage.HitReasonAutoSoftInject)
+	rep.NegRepeatGoneRows = countReason(labels, storage.HitReasonAutoRepeatGone)
+	rep.NegRepeatGoneUnique = uniqReason(labels, storage.HitReasonAutoRepeatGone)
+	rep.CrossExpireUnuseUnique = len(cross)
+	rep.NegUnionUnique = len(negU)
+	rep.PosUnionUnique = len(posU)
+	rep.CoveragePct = round1(float64(len(posU)+len(negU)) * 100.0 / float64(rep.DistinctRecalled7d))
+	rep.CursorAdvancedTo = total
+	setCursor(cdb, int64(total))
+	return rep, nil
+}
+
+func round1(x float64) float64 { return float64(int(x*10+0.5)) / 10 }
+
+// ─── 读侧小件 ────────────────────────────────────────────────
+
+func snapshotPaths() (string, string) {
+	pathMu.RLock()
+	defer pathMu.RUnlock()
+	return usageDBPath, cursorDB
+}
+
+func openCursorDB(path string) (*sql.DB, error) {
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS autolabel_cursor(
+		id INTEGER PRIMARY KEY CHECK(id=1),
+		inject_offset INTEGER NOT NULL DEFAULT 0,
+		last_run TEXT NOT NULL DEFAULT '')`); err != nil {
+		db.Close()
+		return nil, err
+	}
+	return db, nil
+}
+
+func setCursor(db *sql.DB, off int64) {
+	_, _ = db.Exec(`INSERT INTO autolabel_cursor(id,inject_offset,last_run) VALUES(1,?,?)
+		ON CONFLICT(id) DO UPDATE SET inject_offset=excluded.inject_offset, last_run=excluded.last_run`,
+		off, time.Now().Format(time.RFC3339))
+}
+
+func touchCursor(db *sql.DB) {
+	_, _ = db.Exec(`UPDATE autolabel_cursor SET last_run=? WHERE id=1`, time.Now().Format(time.RFC3339))
+}
+
+func readInjectFiles(paths []string) ([]InjectRecord, map[string]int, error) {
+	recs := []InjectRecord{}
+	lines := map[string]int{}
+	for _, p := range sortedNames(paths) {
+		f, err := os.Open(p)
+		if err != nil {
+			continue // 缺文件 = 该 profile 没日志，不算错
+		}
+		n := 0
+		sc := bufio.NewScanner(f)
+		sc.Buffer(make([]byte, 1<<20), 1<<20)
+		for sc.Scan() {
+			n++
+			var r InjectRecord
+			if json.Unmarshal(sc.Bytes(), &r) == nil && r.MemoryID != "" {
+				recs = append(recs, r)
+			}
+		}
+		f.Close()
+		lines[filepath.Base(p)] = n
+	}
+	return recs, lines, nil
+}
+
+func readFeedbackFiles(paths []string) ([]FeedbackRecord, int, error) {
+	recs := []FeedbackRecord{}
+	total := 0
+	for _, p := range sortedNames(paths) {
+		f, err := os.Open(p)
+		if err != nil {
+			continue
+		}
+		sc := bufio.NewScanner(f)
+		sc.Buffer(make([]byte, 1<<20), 1<<20)
+		for sc.Scan() {
+			total++
+			var r FeedbackRecord
+			if json.Unmarshal(sc.Bytes(), &r) == nil && r.MemoryID != "" {
+				recs = append(recs, r)
+			}
+		}
+		f.Close()
+	}
+	return recs, total, nil
+}
+
+func distinctSet(db *sql.DB, q string) set {
+	out := set{}
+	rows, err := db.Query(q)
+	if err != nil {
+		return out
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var s string
+		if rows.Scan(&s) == nil {
+			out[s] = true
+		}
+	}
+	return out
+}
+
+func countQuery(db *sql.DB, q string) (int, error) {
+	var n int
+	err := db.QueryRow(q).Scan(&n)
+	return n, err
+}
+
+// recall7dSQL 构造分母查询（cutoff 参数化 —— AC5：分子计数函数必须接受 cutoff）。
+func recall7dSQL(cutoff string) string {
+	return "SELECT count(DISTINCT memory_id) FROM usage_recall WHERE memory_id LIKE 'mem_%' AND recalled_at >= " + cutoff
+}
+
+// coverageCounts 用**同一个 cutoff 窗口**同时取分子(consumed1/consumed2)与分母
+// (DISTINCT mem_)。AC1/AC5 同窗口铁律：禁止分子全期、分母 7d 的混窗口径
+// （t_77744b71 第二次不通过的真因 = 21% 是「全期分子 ÷ 7天分母」）。
+// cutoff 参数可由测试注入任意窗口（如全期 '1970-01-01'）验证结果确实随窗口变化。
+func coverageCounts(db *sql.DB, cutoff string) (consumed1, consumed2 set, distinct int) {
+	consumed1 = distinctSet(db, "SELECT DISTINCT memory_id FROM usage_recall WHERE consumed=1 AND memory_id LIKE 'mem_%' AND recalled_at >= "+cutoff)
+	consumed2 = distinctSet(db, "SELECT DISTINCT memory_id FROM usage_recall WHERE consumed=2 AND memory_id LIKE 'mem_%' AND recalled_at >= "+cutoff)
+	distinct, _ = countQuery(db, recall7dSQL(cutoff))
+	return consumed1, consumed2, distinct
+}
+
+func laterThan(ts []float64, t float64) bool {
+	for _, v := range ts {
+		if v > t {
+			return true
+		}
+	}
+	return false
+}
+
+func sortBySessionTime(rows []InjectRecord) {
+	sort.SliceStable(rows, func(i, j int) bool {
+		if rows[i].SessionID != rows[j].SessionID {
+			return rows[i].SessionID < rows[j].SessionID
+		}
+		return rows[i].TS < rows[j].TS
+	})
+}
+
+func roundMilli(t float64) float64 { return float64(int64(t*1000)) / 1000 }
+
+func indexOf(xs []string, s string) (int, bool) {
+	for i, v := range xs {
+		if v == s {
+			return i, true
+		}
+	}
+	return -1, false
+}
+
+func sortedNames(xs []string) []string {
+	cp := append([]string(nil), xs...)
+	sort.Strings(cp)
+	return cp
+}
+
+func countReason(ls []Label, reason string) int {
+	n := 0
+	for _, l := range ls {
+		if l.Reason == reason {
+			n++
+		}
+	}
+	return n
+}
+
+func uniqReason(ls []Label, reason string) int {
+	u := set{}
+	for _, l := range ls {
+		if l.Reason == reason {
+			u[l.MemoryID] = true
+		}
+	}
+	return len(u)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// 覆盖率工具（AC1 口径唯一实现处；任何报表以此为准，禁自算）。
+// Coverage = |labeled ∩ distinctRecalled7d| / distinctRecalled7d。
+func Coverage(labeled, distinctRecalled7d int) float64 {
+	if distinctRecalled7d <= 0 {
+		return 0
+	}
+	return float64(labeled) / float64(distinctRecalled7d)
+}

go/internal/feedback/autolabel/autolabel_test.go

@@ -0,0 +1,428 @@
+package autolabel
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// ─── hit_event.go 新增 reason 归一（AC2：AutoReason 枚举 + 白名单）──
+
+func TestNormalizeHitReason_AutoOrder(t *testing.T) {
+	// ⚠ 顺序纪律钉死：这些 neg reason 含 "inject"/"replace" 子串，
+	// 若归一顺序错会把 neg 归成 pos 或 replacement。
+	cases := []struct {
+		in   string
+		want string
+	}{
+		{"auto_soft_inject", storage.HitReasonAutoSoftInject},
+		{"neg_soft_inject", storage.HitReasonAutoSoftInject},
+		{"auto_inject_pass", storage.HitReasonAutoInjectPass},
+		{"pos_inject_pass", storage.HitReasonAutoInjectPass},
+		{"neg_repeat_replaced", storage.HitReasonAutoRepeatGone},
+		{"neg_repeat_gone", storage.HitReasonAutoRepeatGone},
+		{"expired_unconsumed", storage.HitReasonAutoExpireUnuse},
+		{"auto_expire_unuse", storage.HitReasonAutoExpireUnuse},
+		// 存量 reason 不受影响
+		{"human_feedback", storage.HitReasonHumanFeedback},
+		{"contradiction", storage.HitReasonContradiction},
+		{"replacement", storage.HitReasonReplacement},
+		{"downstream_use", storage.HitReasonDownstreamUse},
+		{"", storage.HitReasonDownstreamUse}, // 空默认下游
+	}
+	for _, c := range cases {
+		if got := storage.NormalizeHitReason(c.in); got != c.want {
+			t.Errorf("NormalizeHitReason(%q)=%q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestAutoReasons_InValidWhitelist(t *testing.T) {
+	// 除说明性注释外，所有自动 reason 都应是合法可落库枚举（否则覆盖信号静默丢，AC2 目标落空）。
+	for _, r := range []string{
+		storage.HitReasonAutoSoftInject,
+		storage.HitReasonAutoInjectPass,
+		storage.HitReasonAutoRepeatGone,
+		storage.HitReasonAutoExpireUnuse,
+	} {
+		if !storage.ValidHitReasons[r] {
+			t.Errorf("%q 必须在 ValidHitReasons 白名单内", r)
+		}
+	}
+	// AppendHitEvent 落库验证（memvector 实现）：合法枚举应能写入
+	mlc := storage.NewMemLanceClient(nil)
+	for _, r := range []string{
+		storage.HitReasonAutoSoftInject,
+		storage.HitReasonAutoInjectPass,
+		storage.HitReasonAutoRepeatGone,
+	} {
+		if err := mlc.AppendHitEvent("mem_x", "neg", r); err != nil {
+			t.Errorf("合法 reason %q 落库失败: %v", r, err)
+		}
+	}
+	// 去重验证：同 mid 同 reason 再次追加 → hit_events append-only（不覆盖）
+	// （断言底层行为由 storage 自身测试覆盖，此处仅确认不报错）
+	if err := mlc.AppendHitEvent("mem_y", "pos", storage.HitReasonAutoInjectPass); err != nil {
+		t.Errorf("pos auto 落库失败: %v", err)
+	}
+	ev, _ := mlc.GetHitEvents("mem_y", 5)
+	if len(ev) != 1 || ev[0].Reason != storage.HitReasonAutoInjectPass {
+		t.Errorf("mem_y 取证失败: %+v", ev)
+	}
+}
+
+// expire_unuse 只做交叉证据、RunOnce 不主动落 neg（判据不足以单独定负）
+func TestRunOnce_expireOnlyCountedNotWritten(t *testing.T) {
+	t.Setenv("ZHIYI_AUTO_LABEL", "1")
+	dir := t.TempDir()
+	inj := filepath.Join(dir, "inject.jsonl")
+	fb := filepath.Join(dir, "fb.jsonl")
+	// 注入面含 mem_exp（它在 usage 里 consumed=2）。为避开 pos/soft_neg 误写，
+	// 让 mem_exp 出现两次（后续又注入 ⇒ 不判 soft_neg，passes=false ⇒ 不判 pos），
+	// 只由 consumed2∩注入面 提供交叉证据计数。
+	mustWrite(t, inj, []string{
+		`{"ts":1,"memory_id":"mem_exp","passes":false,"session_id":"s"}`,
+		`{"ts":2,"memory_id":"mem_exp","passes":false,"session_id":"s"}`,
+	})
+	// hard_negative 后续反馈 ⇒ soft_neg 判据 c) 跳过（该 mid 已有独立 neg 链路），
+	// 使 mem_exp 只落在 cross 计数、不被本链路写 neg。
+	mustWrite(t, fb, []string{`{"ts":3,"memory_id":"mem_exp","kind":"hard_negative","session_id":"s"}`})
+	SetPathsForTest(makeUsageDB(t), filepath.Join(dir, "autolabel.db"))
+	mlc := storage.NewMemLanceClient(nil)
+	rep, err := RunOnce(mlc, []string{inj}, []string{fb})
+	if err != nil {
+		t.Fatalf("run err: %v", err)
+	}
+	if rep.CrossExpireUnuseUnique == 0 {
+		t.Errorf("mem_exp consumed=2 ∩ 注入面 应为交叉证据: %+v", rep)
+	}
+	// 但不应写 neg 事件（交叉不落库）
+	ev, _ := mlc.GetHitEvents("mem_exp", 5)
+	if len(ev) != 0 {
+		t.Errorf("expire_unuse 只作交叉证据不应落 neg: %+v", ev)
+	}
+}
+
+// ─── DecideInject 纯函数 ──────────────────────────────────────
+
+func TestDecideInject_basic(t *testing.T) {
+	rows := []InjectRecord{
+		{MemoryID: "mem_pos1", Passes: true, SessionID: "s1", TS: 1},
+		{MemoryID: "mem_neg1", Passes: false, SessionID: "s1", TS: 2},
+		{MemoryID: "mem_reappear", Passes: false, SessionID: "s1", TS: 3},
+		{MemoryID: "mem_reappear", Passes: true, SessionID: "s1", TS: 4}, // 后续轮又注入且过了
+		{MemoryID: "mem_neg2", Passes: false, SessionID: "s2", TS: 1},
+	}
+	labels := DecideInject(rows, nil)
+	var pos, negSoft int
+	seen := map[string]string{}
+	for _, l := range labels {
+		seen[l.MemoryID] = l.Reason
+		if l.Outcome == storage.HitOutcomePos {
+			pos++
+		}
+		if l.Outcome == storage.HitOutcomeNeg {
+			negSoft++
+		}
+	}
+	if pos != 2 { // mem_pos1 + mem_reappear(第4轮)
+		t.Errorf("pos 数= %d, want 2", pos)
+	}
+	if negSoft != 2 { // mem_neg1 + mem_neg2
+		t.Errorf("neg_soft 数= %d, want 2", negSoft)
+	}
+	// mem_reappear 后轮又注入 ⇒ 不该被判 neg
+	if _, ok := seen["mem_reappear"]; ok && strings.Contains(seen["mem_reappear"], "soft") {
+		t.Errorf("mem_reappear 后轮又注入，不应被判 soft_neg: %s", seen["mem_reappear"])
+	}
+}
+
+func TestDecideInject_hardNegExempt(t *testing.T) {
+	rows := []InjectRecord{
+		{MemoryID: "mem_x", Passes: false, SessionID: "s", TS: 1},
+	}
+	// 该 session 1.0s 之后有 hard_negative 反馈 ⇒ 跳过（硬负已有独立链路）
+	hard := map[string][]float64{"s": {2.0}}
+	labels := DecideInject(rows, hard)
+	if len(labels) != 0 {
+		t.Errorf("有后续硬负反馈时应跳过 soft_neg, got %v", labels)
+	}
+}
+
+// ─── DecideRepeatGone 纯函数 ──────────────────────────────────
+
+func TestDecideRepeatGone_basic(t *testing.T) {
+	rows := []InjectRecord{
+		{MemoryID: "mem_a", Passes: true, SessionID: "s", TS: 1.0},
+		{MemoryID: "mem_b", Passes: true, SessionID: "s", TS: 1.0}, // 同轮
+		{MemoryID: "mem_a", Passes: true, SessionID: "s", TS: 30.0}, // 相邻轮，mem_b 消失
+	}
+	labels := DecideRepeatGone(rows, 600, func(string) bool { return true })
+	if len(labels) != 1 {
+		t.Fatalf("期望 1 条 repeat_gone, got %d", len(labels))
+	}
+	if labels[0].MemoryID != "mem_b" || labels[0].Reason != storage.HitReasonAutoRepeatGone {
+		t.Errorf("got %+v", labels[0])
+	}
+}
+
+func TestDecideRepeatGone_evidenceBlocks(t *testing.T) {
+	rows := []InjectRecord{
+		{MemoryID: "mem_used", Passes: true, SessionID: "s", TS: 1.0},
+		{MemoryID: "mem_used", Passes: true, SessionID: "s", TS: 5.0},
+	}
+	// 有 consumed=1/useful 反证 ⇒ noEvidence=false ⇒ 不标 neg
+	labels := DecideRepeatGone(rows, 600, func(string) bool { return false })
+	if len(labels) != 0 {
+		t.Errorf("有反证时不应标 neg, got %v", labels)
+	}
+}
+
+func TestDecideRepeatGone_longGapSkips(t *testing.T) {
+	rows := []InjectRecord{
+		{MemoryID: "mem_a", Passes: true, SessionID: "s", TS: 1.0},
+		{MemoryID: "mem_b", Passes: true, SessionID: "s", TS: 1.0},
+		{MemoryID: "mem_a", Passes: true, SessionID: "s", TS: 3000.0}, // 跨 50 分钟 > 600s
+	}
+	labels := DecideRepeatGone(rows, 600, func(string) bool { return true })
+	if len(labels) != 0 {
+		t.Errorf("跨时太久不算同 query 场景, got %v", labels)
+	}
+}
+
+// ─── DecideExpireCross ─────────────────────────────────────────
+
+func TestDecideExpireCross_onlyIntersection(t *testing.T) {
+	cross := DecideExpireCross(
+		map[string]bool{"m1": true, "m2": true, "m3": true}, // expired
+		map[string]bool{"m1": true, "m2": true},             // injected
+		map[string]bool{"m2": true},                         // consumed1 反证
+		map[string]bool{"m3": true},                         // useful 反证
+	)
+	if cross["m1"] != true {
+		t.Errorf("m1: expired∩injected, 无反证 ⇒ 应是交叉证据")
+	}
+	if cross["m2"] || cross["m3"] {
+		t.Errorf("m2(consumed1)/m3(useful) 有反证，不该在交叉集")
+	}
+}
+
+// ─── 门控 + 游标 + 落库（小集成）──────────────────────────────
+
+func TestRunOnce_DisabledByDefault(t *testing.T) {
+	os.Unsetenv("ZHIYI_AUTO_LABEL")
+	rep, err := RunOnce(storage.NewMemLanceClient(nil), nil, nil)
+	if err != nil {
+		t.Fatalf("disabled 不应报错: %v", err)
+	}
+	if rep.EventsWritten != 0 || rep.NegUnionUnique != 0 || rep.PosUnionUnique != 0 {
+		t.Errorf("disabled 应零行为, got %+v", rep)
+	}
+}
+
+func TestRunOnce_shadowWritesNothing(t *testing.T) {
+	t.Setenv("ZHIYI_AUTO_LABEL", "shadow")
+	dir := t.TempDir()
+	inj := filepath.Join(dir, "inject.jsonl")
+	fb := filepath.Join(dir, "fb.jsonl")
+	now := float64(time.Now().Unix())
+	mustWrite(t, inj, []string{
+		fmt.Sprintf(`{"ts":%v,"memory_id":"mem_p","passes":true,"session_id":"s"}`, now),
+		fmt.Sprintf(`{"ts":%v,"memory_id":"mem_n","passes":false,"session_id":"s"}`, now+1),
+		fmt.Sprintf(`{"ts":%v,"memory_id":"mem_n","passes":false,"session_id":"s"}`, now+2),
+	})
+	mustWrite(t, fb, []string{})
+	usage := makeUsageDB(t) // 空 usage 库（分母=0，只验证不落库）
+	SetPathsForTest(usage, filepath.Join(dir, "autolabel.db"))
+	mlc := storage.NewMemLanceClient(nil)
+	rep, err := RunOnce(mlc, []string{inj}, []string{fb})
+	if err != nil {
+		t.Fatalf("shadow run err: %v", err)
+	}
+	if rep.EventsWritten != 0 {
+		t.Errorf("shadow 不应写 hit_events, written=%d", rep.EventsWritten)
+	}
+	// 但 pos/neg 计数应如实（shadow = 取数模式）
+	if rep.NegSoftInjectUnique < 1 || rep.PosInjectPassUnique < 1 {
+		t.Errorf("shadow 也应计数: %+v", rep)
+	}
+	// 游标库建出来了（持久化证据）
+	if _, err := os.Stat(filepath.Join(dir, "autolabel.db")); err != nil {
+		t.Errorf("游标库应已创建: %v", err)
+	}
+}
+
+func TestRunOnce_writesEvents(t *testing.T) {
+	t.Setenv("ZHIYI_AUTO_LABEL", "1")
+	dir := t.TempDir()
+	inj := filepath.Join(dir, "inject.jsonl")
+	fb := filepath.Join(dir, "fb.jsonl")
+	now := float64(time.Now().Unix())
+	mustWrite(t, inj, []string{
+		fmt.Sprintf(`{"ts":%v,"memory_id":"mem_p","passes":true,"session_id":"s"}`, now),
+		fmt.Sprintf(`{"ts":%v,"memory_id":"mem_n","passes":false,"session_id":"s"}`, now+1),
+	})
+	mustWrite(t, fb, []string{})
+	SetPathsForTest(makeUsageDB(t), filepath.Join(dir, "autolabel.db"))
+	mlc := storage.NewMemLanceClient(nil)
+	rep, err := RunOnce(mlc, []string{inj}, []string{fb})
+	if err != nil {
+		t.Fatalf("run err: %v", err)
+	}
+	if rep.EventsWritten != 2 { // pos(mem_p) + neg(mem_n)；mem_p 不再被 repeat_gone 覆盖
+		t.Errorf("written=%d, want 2 (%+v)", rep.EventsWritten, rep)
+	}
+	// 读回 hit_events 取证（AC2 落库自证 + 无双重标签）
+	pe, _ := mlc.GetHitEvents("mem_p", 5)
+	if len(pe) != 1 || pe[0].Reason != storage.HitReasonAutoInjectPass {
+		t.Errorf("mem_p hit_event 缺失或 reason 错: %+v", pe)
+	}
+	ne, _ := mlc.GetHitEvents("mem_n", 5)
+	if len(ne) != 1 || ne[0].Reason != storage.HitReasonAutoSoftInject {
+		t.Errorf("mem_n hit_event 缺失或 reason 错: %+v", ne)
+	}
+	// 去冲突：mem_p 不应有 neg 标签（pos 优先）
+	for _, e := range pe {
+		if e.Outcome == storage.HitOutcomeNeg {
+			t.Errorf("mem_p 不应被标 neg（pos 优先去冲突）: %+v", pe)
+		}
+	}
+}
+
+func TestCoverage_AC1Ordering(t *testing.T) {
+	// 真实口径：2444/18371 = 13.3%；不许用注入率 0.31 冒充。
+	if got := Coverage(2444, 18371); abs(got-0.133) > 0.001 {
+		t.Errorf("Coverage(2444,18371)=%v, want ≈0.133", got)
+	}
+	// 30.7% 是 injection_rate_rate（133/429 注入轮次通过率），分母完全不同
+	if got := Coverage(133, 429); abs(got-0.31) > 0.02 {
+		t.Errorf("Coverage(133,429)=%v, want ≈0.31（这是注入率不是覆盖率）", got)
+	}
+}
+
+// AC5（t_832c60ff）：分子计数函数必须接受 cutoff 参数 —— 7d cutoff 与全期 cutoff 结果不同。
+// 用途：钉死「同窗口」口径 —— 覆盖率分子(consumed1)与分母(DISTINCT mem_)必须同窗口，
+// 禁止「全期分子 ÷ 7天分母」的混窗口径（t_77744b71 第二次不通过的真因）。
+func TestCoverageCounts_cutoffWindowDiffers(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "usage_cutoff_test.db")
+	db, err := sqlOpenRaw(p)
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS usage_recall(
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		memory_id TEXT NOT NULL, content TEXT NOT NULL, tokens TEXT NOT NULL,
+		q_hash TEXT NOT NULL, namespace TEXT, agent TEXT,
+		recalled_at TEXT NOT NULL, consumed INTEGER NOT NULL DEFAULT 0, consumed_at TEXT)`); err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	// 两条 7d 内（consumed=1 与 consumed=2）+ 一条 7d 外（30 天前，consumed=1）
+	// ⇒ 全期口径多算这条旧的，7d 口径不算。
+	ins := []struct {
+		mid, recalledAt string
+		consumed        int
+	}{
+		{"mem_recent1", "datetime('now','-1 days')", 1},
+		{"mem_recent2", "datetime('now','-1 days')", 2},
+		{"mem_old_30d", "datetime('now','-30 days')", 1},
+	}
+	for _, r := range ins {
+		if _, err := db.Exec(`INSERT INTO usage_recall(memory_id,content,tokens,q_hash,recalled_at,consumed)
+			VALUES(?, '内容', '["t"]', 'q', `+r.recalledAt+`, ?)`, r.mid, r.consumed); err != nil {
+			t.Fatalf("ins %s: %v", r.mid, err)
+		}
+	}
+	db.Close()
+
+	usageDB, err := sql.Open("sqlite", "file:"+p+"?mode=ro")
+	if err != nil {
+		t.Fatalf("reopen ro: %v", err)
+	}
+	defer usageDB.Close()
+
+	// 7d 窗口：只算 recent1+recent2（mem_%）
+	c1_7d, c2_7d, denom_7d := coverageCounts(usageDB, "datetime('now','-7 days')")
+	if denom_7d != 2 {
+		t.Errorf("7d 分母(DISTINCT mem_) = %d, want 2（不应含 30 天前的 mem_old_30d）", denom_7d)
+	}
+	if len(c1_7d) != 1 || !c1_7d["mem_recent1"] {
+		t.Errorf("7d consumed=1 = %v, want {mem_recent1}", c1_7d)
+	}
+	if len(c2_7d) != 1 || !c2_7d["mem_recent2"] {
+		t.Errorf("7d consumed=2 = %v, want {mem_recent2}", c2_7d)
+	}
+
+	// 全期 cutoff（1970-01-01，覆盖一切）：把 30 天前的 mem_old_30d 也算进分母与 consumed=1
+	c1_full, _, denom_full := coverageCounts(usageDB, "'1970-01-01'")
+	if denom_full != 3 {
+		t.Errorf("全期分母 = %d, want 3（含 mem_old_30d）", denom_full)
+	}
+	if len(c1_full) != 2 || !c1_full["mem_old_30d"] {
+		t.Errorf("全期 consumed=1 = %v, want {mem_recent1, mem_old_30d}", c1_full)
+	}
+
+	// ⚠ 同窗口断言：7d 与全期结果必须不同（否则 cutoff 参数形同虚设）
+	if denom_7d == denom_full {
+		t.Errorf("同窗口断言失败：7d 分母(%d) 与全期分母(%d) 应不同", denom_7d, denom_full)
+	}
+	if len(c1_7d) == len(c1_full) {
+		t.Errorf("同窗口断言失败：7d consumed1(%d) 与全期 consumed1(%d) 应不同", len(c1_7d), len(c1_full))
+	}
+}
+
+// ─── helpers ──────────────────────────────────────────────────
+
+func mustWrite(t *testing.T, path string, lines []string) {
+	t.Helper()
+	b := strings.Join(lines, "\n") + "\n"
+	if err := os.WriteFile(path, []byte(b), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func makeUsageDB(t *testing.T) string {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "usage_test.db")
+	db, err := sqlOpenRaw(p)
+	if err != nil {
+		t.Fatalf("open usage db: %v", err)
+	}
+	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS usage_recall(
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		memory_id TEXT NOT NULL, content TEXT NOT NULL, tokens TEXT NOT NULL,
+		q_hash TEXT NOT NULL, namespace TEXT, agent TEXT,
+		recalled_at TEXT NOT NULL, consumed INTEGER NOT NULL DEFAULT 0, consumed_at TEXT)`); err != nil {
+		t.Fatalf("create usage table: %v", err)
+	}
+	if _, err := db.Exec(`CREATE INDEX IF NOT EXISTS idx_usage_mem ON usage_recall(memory_id)`); err != nil {
+		t.Fatalf("index: %v", err)
+	}
+	// 一条 consumed=1（反证）+ 一条 consumed=2（交叉证据）
+	if _, err := db.Exec(`INSERT INTO usage_recall(memory_id,content,tokens,q_hash,recalled_at,consumed)
+		VALUES('mem_used','家庭服务器IP固定为192.168.123.11','["192.168.123.11"]','h1',datetime('now','-1 days'),1)`); err != nil {
+		t.Fatalf("ins1: %v", err)
+	}
+	if _, err := db.Exec(`INSERT INTO usage_recall(memory_id,content,tokens,q_hash,recalled_at,consumed)
+		VALUES('mem_exp','过期未消费记忆内容','["过期未消费"]','h2',datetime('now','-1 days'),2)`); err != nil {
+		t.Fatalf("ins2: %v", err)
+	}
+	db.Close()
+	return p
+}
+
+func sqlOpenRaw(p string) (*sql.DB, error) {
+	return sql.Open("sqlite", p)
+}
+
+func abs(x float64) float64 {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

go/internal/feedback/autolabel/runner_test.go

@@ -0,0 +1,76 @@
+package autolabel
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/storage"
+)
+
+// TestAC3_ReplayOverRealData（AC3 扩量实测）：用正式代码链路（shadow 模式）扫
+// 生产 jsonl + usage_track.db，产出当前信号集合 + 抽样审计文件。
+// ⚠ 只读生产数据（usage_track.db mode=ro）、不落 hit_events（shadow）、
+// 不建卡、不重启 zhiyid。
+// 触发：ZHIYI_AUTO_LABEL_REPLAY=1 go test ./internal/feedback/autolabel/ -run TestAC3_ReplayOverRealData -count=1
+func TestAC3_ReplayOverRealData(t *testing.T) {
+	if os.Getenv("ZHIYI_AUTO_LABEL_REPLAY") == "" {
+		t.Skip("仅显式触发（ZHIYI_AUTO_LABEL_REPLAY=1）")
+	}
+	t.Setenv("ZHIYI_AUTO_LABEL", "shadow")
+	home := os.Getenv("HOME")
+	if home == "" {
+		t.Fatal("no HOME")
+	}
+	inject := []string{filepath.Join(home, ".hermes/logs/zhiyi-inject-outcomes.jsonl")}
+	fb := []string{filepath.Join(home, ".hermes/logs/zhiyi-auto-feedback.jsonl")}
+	profs, _ := os.ReadDir(filepath.Join(home, ".hermes/profiles"))
+	for _, p := range profs {
+		if !p.IsDir() {
+			continue
+		}
+		inj := filepath.Join(home, ".hermes/profiles", p.Name(), "logs/zhiyi-inject-outcomes.jsonl")
+		if _, err := os.Stat(inj); err == nil {
+			inject = append(inject, inj)
+		}
+		f := filepath.Join(home, ".hermes/profiles", p.Name(), "logs/zhiyi-auto-feedback.jsonl")
+		if _, err := os.Stat(f); err == nil {
+			fb = append(fb, f)
+		}
+	}
+	SetPathsForTest("/var/lib/memoryweave/usage_track.db",
+		filepath.Join(os.TempDir(), "autolabel-replay-cursor.db"))
+	mlc := storage.NewMemLanceClient(nil)
+	rep, err := RunOnce(mlc, inject, fb)
+	if err != nil {
+		t.Fatalf("RunOnce: %v", err)
+	}
+	t.Logf("REPORT %+v", rep)
+	out := filepath.Join(os.TempDir(), "autolabel-audit")
+	if err := os.MkdirAll(out, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := writeAudit(t, out, rep); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func writeAudit(t *testing.T, out string, rep Report) error {
+	t.Helper()
+	p := filepath.Join(out, "AC3-autolabel-audit.txt")
+	b := fmt.Sprintf(
+		"# AC3 扩量实测 — autolabel 正式链路 shadow 扫描结果 (t_77744b71)\n"+
+			"# 只读生产数据、零落库（shadow）、抽样人工可核。\n"+
+			"# 误判率人工核验口径：抽样 100 条判「真负/误伤」。\n\n"+
+			"pos_inject_pass_rows=%d\n"+
+			"neg_soft_inject_rows=%d\n"+
+			"neg_repeat_gone_rows=%d\n"+
+			"cross_expire_unuse_unique=%d\n"+
+			"distinct_recalled_7d=%d\n"+
+			"recall_7d_sql=%s\n",
+		rep.PosInjectPassRows, rep.NegSoftInjectRows,
+		rep.NegRepeatGoneRows, rep.CrossExpireUnuseUnique,
+		rep.DistinctRecalled7d, rep.Recall7dSQL)
+	return os.WriteFile(p, []byte(b), 0o644)
+}

go/internal/governance/entity_guard.go

@@ -0,0 +1,189 @@
+// 织忆 MemoryWeave — 实体名称拒写门禁（t_41f5ee7a 治源）
+//
+// 背景：在实体抽取写库前加拒绝规则，防止非法实体名（如过长、以数字开头、包含路径/后缀）
+// 进入图谱。单一真相源：判据的规则值读自共享 JSON
+// （~/.hermes/scripts/lib/graph_entity_guard.json），与 Python 侧
+// graph_entity_guard.py 读同一份文件；改规则只改那一个 JSON。
+//
+// 铁律（与 Python 逐位一致）：
+//   · 白名单内的名称直接放行（即使匹配判据）
+//   · 否则匹配 j1/j2/j3 之一即判为垃圾（应被拒绝）
+//
+// 无缓存、无新增 Redis 键（只用原子计数），故不触及项目现成件清单的缓存条目。
+
+package governance
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync/atomic"
+)
+
+// entityGuardG is the singleton guard instance.
+var entityGuardG *guard
+
+// defaultRulesPath — 与 Python 侧同一份共享规则文件（同机同用户 muc 可直读）。
+// env GRAPH_ENTITY_GUARD_RULES 可覆盖（测试/部署用）。
+func defaultRulesPath() string {
+	if p := os.Getenv("GRAPH_ENTITY_GUARD_RULES"); p != "" {
+		return p
+	}
+	if home, err := os.UserHomeDir(); err == nil && home != "" {
+		return filepath.Join(home, ".hermes", "scripts", "lib", "graph_entity_guard.json")
+	}
+	return "/home/muc/.hermes/scripts/lib/graph_entity_guard.json"
+}
+
+// entityGuardRules 镜像共享 JSON（只取 Go 判据需要的字段；未知字段忽略）。
+type entityGuardRules struct {
+	Whitelist []string `json:"whitelist"`
+	Judgments struct {
+		J1LenGt14 struct {
+			Pattern         string `json:"pattern"`
+			CaseInsensitive bool   `json:"case_insensitive"`
+		} `json:"j1_len_gt_14"`
+		J2StartsWithDigit struct {
+			Pattern         string `json:"pattern"`
+			CaseInsensitive bool   `json:"case_insensitive"`
+		} `json:"j2_startswith_digit"`
+		J3PathOrExt struct {
+			Pattern         string `json:"pattern"`
+			CaseInsensitive bool   `json:"case_insensitive"`
+		} `json:"j3_path_or_ext"`
+	} `json:"judgments"`
+}
+
+type guard struct {
+	rules     entityGuardRules
+	j1Regex   *regexp.Regexp
+	j2Regex   *regexp.Regexp
+	j3Regex   *regexp.Regexp
+	loaded    bool
+	path      string
+	// 计数（可选，供监控）
+	checks    int64
+	blocks    int64
+}
+
+
+
+// LoadEntityGuard 读取并编译规则。首次成功后设置单例。
+// 返回 (ok, error)。ok 表示是否成功加载。
+func LoadEntityGuard(path string) (bool, error) {
+	if path == "" {
+		path = defaultRulesPath()
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return false, err
+	}
+	var rc entityGuardRules
+	if err := json.Unmarshal(data, &rc); err != nil {
+		return false, err
+	}
+	// 編譯判據正則
+	j1Regex, err := regexp.Compile(rc.Judgments.J1LenGt14.Pattern)
+	if err != nil {
+		return false, err
+	}
+	if rc.Judgments.J1LenGt14.CaseInsensitive {
+		j1Regex = regexp.MustCompile("(?i)" + rc.Judgments.J1LenGt14.Pattern)
+	}
+	j2Regex, err := regexp.Compile(rc.Judgments.J2StartsWithDigit.Pattern)
+	if err != nil {
+		return false, err
+	}
+	if rc.Judgments.J2StartsWithDigit.CaseInsensitive {
+		j2Regex = regexp.MustCompile("(?i)" + rc.Judgments.J2StartsWithDigit.Pattern)
+	}
+	j3Regex, err := regexp.Compile(rc.Judgments.J3PathOrExt.Pattern)
+	if err != nil {
+		return false, err
+	}
+	if rc.Judgments.J3PathOrExt.CaseInsensitive {
+		j3Regex = regexp.MustCompile("(?i)" + rc.Judgments.J3PathOrExt.Pattern)
+	}
+	g := &guard{
+		rules:     rc,
+		j1Regex:   j1Regex,
+		j2Regex:   j2Regex,
+		j3Regex:   j3Regex,
+		path:      path,
+		loaded:    true,
+	}
+	// assign to package-level singleton
+	entityGuardG = g
+	return true, nil
+}
+
+// EntityGuardStats 供 /metrics 与验收：检查数 / 拦截数 / 是否加载 / 规则路径。
+func EntityGuardStats() (checks, blocks int64, loaded bool, path string) {
+	if entityGuardG == nil {
+		return 0, 0, false, ""
+	}
+	return atomic.LoadInt64(&entityGuardG.checks), atomic.LoadInt64(&entityGuardG.blocks), entityGuardG.loaded, entityGuardG.path
+}
+
+// IncEntityGuardCheck / IncEntityGuardBlock 供写路径在判定前后调用（相对增量，避免并发写竞态）。
+func IncEntityGuardCheck() {
+	if entityGuardG == nil {
+		return
+	}
+	atomic.AddInt64(&entityGuardG.checks, 1)
+}
+func IncEntityGuardBlock() {
+	if entityGuardG == nil {
+		return
+	}
+	atomic.AddInt64(&entityGuardG.blocks, 1)
+}
+
+// IsJunkName 治源入口（帶心跳計數）：
+//   - 未加載 ⇒ fail-open（放行、checks 仍 +1，保證「拦截器跑過」可觀測，不拦也不崩）；
+//   - 已加載 ⇒ 用共享判據判定，命中垃圾則 blocks +1 並返回 true（寫路径據此 continue 拒寫）。
+func IsJunkName(name string) bool {
+	IncEntityGuardCheck()
+	if entityGuardG == nil || !entityGuardG.loaded {
+		return false
+	}
+	if entityGuardG.isJunkName(name) {
+		IncEntityGuardBlock()
+		return true
+	}
+	return false
+}
+
+// IsJunkNamePure 純判據（無計數，供單測）。未加載時就地讀一次默認路徑兜底；失敗則 fail-open。
+func IsJunkNamePure(name string) bool {
+	if entityGuardG == nil {
+		if _, err := LoadEntityGuard(""); err != nil {
+			return false
+		}
+	}
+	return entityGuardG.isJunkName(name)
+}
+
+func (gr *guard) isJunkName(name string) bool {
+	// 先修剪空白（與 SQL trim 一致）
+	n := strings.TrimSpace(name)
+	// 白名單直接放行
+	for _, w := range gr.rules.Whitelist {
+		if w == n {
+			return false
+		}
+	}
+	// 判定垃圾：匹配 j1/j2/j3 之一
+	if gr.j1Regex.MatchString(n) {
+		return true
+	}
+	if gr.j2Regex.MatchString(n) {
+		return true
+	}
+	if gr.j3Regex.MatchString(n) {
+		return true
+	}
+	return false
+}

go/internal/governance/entity_quality.go

@@ -0,0 +1,142 @@
+// 织忆 MemoryWeave — 图谱实体质量闸（P0-4，2026-10-26）
+//
+// 背景（CS249r 评审实测）：graph_expanded 抽样 15 条里 8 条是 ≤4 字垃圾实体
+// （"条""里存着""开发"），既污染上下文又抬延迟。根因是实体抽取「任意 2-8 字中文串都当实体」，
+// 且扩展前不检查节点在图里的度数 —— 孤边节点（度=1）被当成语义邻居注入。
+//
+// 两道闸（都在**导航前**执行，省算力）：
+//  ① isJunkEntity：长度 <2 rune / 纯虚词量词代词 / 常见填充短语 / 纯 ASCII 停用词 ⇒ 丢弃；
+//  ② 度数闸：起点实体在图中的边数 <2 ⇒ 不导航、不注入（孤边不构成「关联」）。
+//
+// 观测：两道闸的拒绝计数写入 debug 日志（ZHIYI_GRAPH_EXPAND_DEBUG=1）与 recall trace
+// （graph_expand 阶段 note），保证「下次坏了不沉默」。
+package governance
+
+import (
+	"strings"
+	"unicode/utf8"
+)
+
+// junkEntitySet 高置信垃圾实体词表：中文虚词/代词/量词/时间副词/填充短语 + 英文停用词。
+// 原则：只收**几乎不可能**是真实实体名的词；宁可漏筛（由度数闸兜底），不可误杀专名。
+var junkEntitySet = map[string]struct{}{}
+
+func init() {
+	words := []string{
+		// 虚词 / 助词 / 连词
+		"的", "了", "着", "过", "地", "得", "所", "以", "于", "与", "及", "或", "而", "且", "则", "即",
+		"因为", "所以", "但是", "而且", "然后", "如果", "虽然", "不过", "而是", "就是", "只是", "还是",
+		"并且", "以及", "或者", "否则", "因此", "于是", "关于", "对于", "由于", "根据", "按照", "通过",
+		// 代词 / 指示词
+		"我", "你", "他", "她", "它", "我们", "你们", "他们", "她们", "它们", "自己", "别人", "大家",
+		"这个", "那个", "这些", "那些", "这样", "那样", "这种", "那种", "这里", "那里", "里面", "上面",
+		"下面", "前面", "后面", "其中", "其他", "其它", "什么", "怎么", "怎样", "为什么", "哪个", "哪些",
+		// 数量 / 量词 / 程度
+		"一个", "一条", "一次", "一些", "一种", "一件", "一点", "一下", "一直", "一样", "一起",
+		"两个", "三个", "几个", "多个", "很多", "更多", "多条", "几条", "每条", "各种", "某种", "全部", "所有", "每个", "各种", "部分",
+		"一条条", "一条里", "条", "个", "次", "些", "种", "只", "件", "篇", "位", "名", "层",
+		"非常", "比较", "特别", "十分", "更加", "最为", "可能", "应该", "必须", "可以", "能够", "需要",
+		// 常见谓词 / 填充动词短语（低信息量，几乎不可能是实体）
+		"里存着", "存着", "里存在", "有着", "存在", "进行", "使用", "支持", "包括", "包含", "属于",
+		"作为", "成为", "变成", "做到", "做好", "来看", "来说", "来讲", "看到", "看看", "发现",
+		"出现", "提供", "实现", "完成", "开始", "结束", "继续", "返回", "调用", "处理", "执行",
+		"开发", "编写", "添加", "修改", "删除", "更新", "检查", "确认", "验证", "测试", "部署",
+		// 时间 / 方位
+		"现在", "今天", "昨天", "明天", "之前", "之后", "以前", "以后", "当时", "当前", "目前",
+		"最近", "刚才", "马上", "已经", "正在", "曾经", "从来", "后来", "最终", "最后", "首先",
+		"时候", "时间", "期间", "上面", "下面", "左边", "右边", "中间", "附近", "里面", "外面",
+		// 英文停用词（小写比较）
+		"the", "and", "for", "are", "but", "not", "you", "all", "any", "can", "had", "her", "was",
+		"one", "our", "out", "day", "get", "has", "him", "his", "how", "its", "new", "now", "old",
+		"see", "two", "way", "who", "boy", "did", "she", "use", "her", "way", "may", "say",
+		"this", "that", "with", "from", "have", "will", "your", "they", "than", "then", "them",
+		"into", "more", "some", "such", "only", "over", "also", "just", "like", "make", "made",
+	}
+	for _, w := range words {
+		junkEntitySet[w] = struct{}{}
+	}
+}
+
+// IsJunkEntity 判定实体是否应被图谱扩展丢弃（P0-4 第①道闸）。
+func IsJunkEntity(e string) bool {
+	e = strings.TrimSpace(e)
+	if e == "" {
+		return true
+	}
+	if utf8.RuneCountInString(e) < 2 {
+		return true // 单字（"条""里"）不构成实体
+	}
+	// 归一化：去首尾标点/引号，压缩空白
+	e = strings.Trim(e, " \t\r\n\"'`，。；：！？、（）()【】[]{}<>《》—-·.,;:!?")
+	if e == "" {
+		return true
+	}
+	if utf8.RuneCountInString(e) < 2 {
+		return true
+	}
+	lower := strings.ToLower(e)
+	if _, bad := junkEntitySet[lower]; bad {
+		return true
+	}
+	if _, bad := junkEntitySet[e]; bad {
+		return true
+	}
+	// 全由虚词/量词字组成（如「里存着」之外的「的了着」「个条」组合）
+	if allFunctionChars(e) {
+		return true
+	}
+	// 纯标点/符号（无任何字母/数字/汉字）
+	if !hasSemanticChar(e) {
+		return true
+	}
+	return false
+}
+
+// functionChars 单字虚词/量词集合：整串都由这些字组成 ⇒ 无信息量。
+var functionChars = map[rune]struct{}{}
+
+func init() {
+	for _, r := range "的了着过地得所以于与及或而且则即是在有和与就都也还又很更最可会能要没对为从到把被让给吗呢吧啊呀哦嗯这那我你他她它们个条次些种只件篇位名层里上下中前后内外" {
+		functionChars[r] = struct{}{}
+	}
+}
+
+func allFunctionChars(s string) bool {
+	for _, r := range s {
+		if _, ok := functionChars[r]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func hasSemanticChar(s string) bool {
+	for _, r := range s {
+		switch {
+		case r >= 0x4E00 && r <= 0x9FFF: // 汉字
+			return true
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z':
+			return true
+		case r >= '0' && r <= '9':
+			return true
+		}
+	}
+	return false
+}
+
+// FilterEntitiesForGraph 批量过滤垃圾实体，返回保留集与被拒数（观测用）。
+func FilterEntitiesForGraph(entities []string) ([]string, int) {
+	if len(entities) == 0 {
+		return entities, 0
+	}
+	out := make([]string, 0, len(entities))
+	rejected := 0
+	for _, e := range entities {
+		if IsJunkEntity(e) {
+			rejected++
+			continue
+		}
+		out = append(out, e)
+	}
+	return out, rejected
+}

go/internal/governance/entity_quality_test.go

@@ -0,0 +1,44 @@
+package governance
+
+import "testing"
+
+func TestIsJunkEntity(t *testing.T) {
+	junk := []string{
+		"条", "个", "里", "的", "了", "这个", "那些", "里存着", "开发", "进行", "the", "and",
+		"一个", "多条", "存在", "什么", "为什么", "", "  ", "，。", "的了着",
+	}
+	for _, e := range junk {
+		if !IsJunkEntity(e) {
+			t.Errorf("%q 应判为垃圾实体", e)
+		}
+	}
+	keep := []string{
+		"织忆", "MemoryWeave", "淇县", "生物制造", "卫都街道", "bge-m3", "KOCR", "llama-server-4b",
+		"8081", "graph.db", "牧尘", "飞书",
+	}
+	for _, e := range keep {
+		if IsJunkEntity(e) {
+			t.Errorf("%q 是专名/标识符，不应被判为垃圾", e)
+		}
+	}
+}
+
+func TestFilterEntitiesForGraph(t *testing.T) {
+	in := []string{"织忆", "条", "这个", "8081", "里存着"}
+	out, rejected := FilterEntitiesForGraph(in)
+	if rejected != 3 {
+		t.Fatalf("应拒绝 3 个垃圾实体，实际 %d（输出 %v）", rejected, out)
+	}
+	if len(out) != 2 || out[0] != "织忆" || out[1] != "8081" {
+		t.Fatalf("保留集错误：%v", out)
+	}
+}
+
+func TestAllFunctionChars(t *testing.T) {
+	if !allFunctionChars("的了着") {
+		t.Fatal("全虚词串应判 true")
+	}
+	if allFunctionChars("织忆") {
+		t.Fatal("专名不应判 true")
+	}
+}

go/internal/governance/graph_auto.go

@@ -4,6 +4,7 @@ package governance
 import (
 	"fmt"
 	"log"
+	"os"
 	"regexp"
 	"strings"
 	"time"
@@ -115,6 +116,11 @@ func (agu *AutoGraphUpdater) UpdateFromDistill(distilled *DistillInput) {
 				entity, distilled.EpisodeID)
 			continue
 		}
+		cleaned := cleanEntityName(entity)
+		if IsJunkName(cleaned) {
+			log.Printf("[graph] skip-junk-entity=%q cleaned=%q", entity, cleaned)
+			continue
+		}
 		validEnts = append(validEnts, entity)
 	}
 
@@ -142,31 +148,40 @@ func (agu *AutoGraphUpdater) UpdateFromDistill(distilled *DistillInput) {
 	}
 
 	// 2. 创建实体间关系 + CO_OCCURS 共访边
+	//    t_20261102 小怡 · 合成边停写门（默认 0 = 停写）：全库 622,804 边中这 4 类占
+	//    619,825（99.5%），400 条抽样噪声率 88.5%，且 retrieval_count>0 恒 0（从未被消费
+	//    加权）；节点（§1）与确定性边（§3 CONFLICTS_WITH / §4 DERIVED_FROM 等）不受影响。
+	//    恢复 = ZHIYI_GRAPH_AUTO_SYNTH=1（逐位回到改动前）。
 	entityCount := len(validEnts)
-	for i := 0; i < entityCount; i++ {
-		for j := i + 1; j < entityCount; j++ {
-			eidI := entityID(validEnts[i])
-			eidJ := entityID(validEnts[j])
-			// 防御：任何原因导致同 eid 时跳过，杜绝自环（所有 relation 建边口通用）
-			if eidI == eidJ {
-				continue
-			}
+	if !autoSynthEnabled() {
+		log.Printf("[graph] auto-synth-off entities=%d episode=%s（不写 uses/related_to/configures/CO_OCCURS）",
+			entityCount, distilled.EpisodeID)
+	} else {
+		for i := 0; i < entityCount; i++ {
+			for j := i + 1; j < entityCount; j++ {
+				eidI := entityID(validEnts[i])
+				eidJ := entityID(validEnts[j])
+				// 防御：任何原因导致同 eid 时跳过，杜绝自环（所有 relation 建边口通用）
+				if eidI == eidJ {
+					continue
+				}
 
-			// 2a. 语义关系边（inferRelation）
-			edgeID := fmt.Sprintf("e_%s_%s_%d", eidI, eidJ, time.Now().UnixNano())
-			relation := inferRelation(validEnts[i], validEnts[j], distilled.Content)
-			agu.graph.AddEdge(edgeID, eidI, eidJ,
-				relation, distilled.Namespace, 0.5)
+				// 2a. 语义关系边（inferRelation）
+				edgeID := fmt.Sprintf("e_%s_%s_%d", eidI, eidJ, time.Now().UnixNano())
+				relation := inferRelation(validEnts[i], validEnts[j], distilled.Content)
+				agu.graph.AddEdge(edgeID, eidI, eidJ,
+					relation, distilled.Namespace, 0.5)
 
-			// 2b. CO_OCCURS 共访边（§2.5.2 来源 2）
-			// 权重 = 1 / sqrt(entityCount) — 实体越多单对权重越低
-			coWeight := 1.0
-			if entityCount > 2 {
-				coWeight = 1.0 / sqrtFloat(float64(entityCount))
+				// 2b. CO_OCCURS 共访边（§2.5.2 来源 2）
+				// 权重 = 1 / sqrt(entityCount) — 实体越多单对权重越低
+				coWeight := 1.0
+				if entityCount > 2 {
+					coWeight = 1.0 / sqrtFloat(float64(entityCount))
+				}
+				coEdgeID := fmt.Sprintf("co_%s_%s_%d", eidI, eidJ, time.Now().UnixNano())
+				agu.graph.AddEdge(coEdgeID, eidI, eidJ,
+					"CO_OCCURS", distilled.Namespace, coWeight)
 			}
-			coEdgeID := fmt.Sprintf("co_%s_%s_%d", eidI, eidJ, time.Now().UnixNano())
-			agu.graph.AddEdge(coEdgeID, eidI, eidJ,
-				"CO_OCCURS", distilled.Namespace, coWeight)
 		}
 	}
 
@@ -198,8 +213,21 @@ func (agu *AutoGraphUpdater) UpdateFromDistill(distilled *DistillInput) {
 	//    目标节点从不经判据）。停写后血缘不丢，图节点不再膨胀。
 }
 
+// autoSynthEnabled 合成边（uses / related_to / configures / CO_OCCURS）写入门。
+// 默认 0 = 停写（t_20261102 小怡）；ZHIYI_GRAPH_AUTO_SYNTH=1 逐位恢复改动前行为。
+func autoSynthEnabled() bool {
+	switch strings.ToLower(strings.TrimSpace(os.Getenv("ZHIYI_GRAPH_AUTO_SYNTH"))) {
+	case "1", "true", "yes", "on":
+		return true
+	}
+	return false
+}
+
 // RecordCoOccurrence record recall 后的共访关系
 func (agu *AutoGraphUpdater) RecordCoOccurrence(query, namespace string, resultIDs []string) {
+	if !autoSynthEnabled() {
+		return // 合成边停写门（默认 0）
+	}
 	// 在知识图谱中创建 CO_OCCURS 关系
 	for i := 0; i < len(resultIDs); i++ {
 		for j := i + 1; j < len(resultIDs); j++ {
@@ -217,32 +245,35 @@ func (agu *AutoGraphUpdater) RecordCoOccurrence(query, namespace string, resultI
 // processSources 来源类分档（过程/会话/迁移层）：命中则实体/概念不写图。
 // 2026-10-12 t_67d0279a 只枚举 {"worklog-note","worklog-audit"}，天然漏活体主路径——
 // 本表由实测 memories.lance 35,427 行 source 分布驱动（2026-10-13，数据定名单非照抄）：
-//   llm_distill 3717 / wiki:skill_rule_extractor_v2 4406 / wiki:a06_skill_rule_tierA 2650
-//   / wiki:session-compress 494 / legacy:pre0926 12099（迁移层）
+//
+//	llm_distill 3717 / wiki:skill_rule_extractor_v2 4406 / wiki:a06_skill_rule_tierA 2650
+//	/ wiki:session-compress 494 / legacy:pre0926 12099（迁移层）
+//
 // 这些是「过程/会话」层，不是「领域知识」层；图谱只承载领域概念。
 // ⚠️ 前缀归一（TrimPrefix "wiki:"）后比对，与 auditSource 同规；库内真实值经
 // srcOrLLMDistill 落成带前缀形式（[srcprobe] 实测），裸串相等永远 miss。
 var processSources = []string{
-	"",                       // 空 source：sub-agent 会话蒸馏常无出处标记
-	"llm_distill",            // 无出处蒸馏的兜底名（srcOrLLMDistill 返回）
-	"session-compress",       // 会话压缩蒸馏产物
+	"",                        // 空 source：sub-agent 会话蒸馏常无出处标记
+	"llm_distill",             // 无出处蒸馏的兜底名（srcOrLLMDistill 返回）
+	"session-compress",        // 会话压缩蒸馏产物
 	"skill_rule_extractor_v2", // 技能规则提取器（过程层）
 	"a06_skill_rule_tiera",    // a06 技能规则 tierA（过程层，normalizeSrc 已 ToLower）
 	"a06_prefix_test",         // a06 前缀探针
 	"a06_probe_direct",        // a06 直连探针
 	"a06_distill_probe",       // a06 蒸馏探针
 	"a06_ns_test_1005",        // a06 ns 测试
-	"legacy:pre0926",         // 迁移/历史层（2026-09-26 前导入）
-	"worklog-note",           // 审计/工作流（1b 已立，保留）
-	"worklog-audit",          // 审计/工作流（1b 已立，保留）
+	"legacy:pre0926",          // 迁移/历史层（2026-09-26 前导入）
+	"worklog-note",            // 审计/工作流（1b 已立，保留）
+	"worklog-audit",           // 审计/工作流（1b 已立，保留）
 }
 
 // subAgentNamespaces 纯分身会话 namespace：命中则实体/概念不写图。
 // ⚠️ 不做「*-main 一刀切」——实测 a06-main（541 条 vault 领域知识）与 hermes-main
 // （大量 wiki:vault）承载真实领域概念，整 namespace 拦截会误杀（AC3）。
 // 只拦实测 100% 过程/会话/legacy 的纯分身会话 namespace（数据驱动，2026-10-13）：
-//   prof-dev-main / prof-cloud-main / openclaw-main / wiki-curator-main / soulful-xiaowei
-//   —— 全部 source 均为 session-compress / legacy，无任何领域知识。
+//
+//	prof-dev-main / prof-cloud-main / openclaw-main / wiki-curator-main / soulful-xiaowei
+//	—— 全部 source 均为 session-compress / legacy，无任何领域知识。
 var subAgentNamespaces = []string{
 	"prof-dev-main",
 	"prof-cloud-main",
@@ -285,6 +316,7 @@ func inSubAgentNamespace(ns string) bool {
 //   - 自ID 前缀（ep_/f_/n_/mem_/e_/co_/cw_/df_）→ 永不进图（AC2，本批 ep_ 成了 entity）
 //   - AC 编号（AC\d+）、工具动词（grep/ingest dry-run/健康检查/部署流程/测试结果）
 //   - "证据：无证据" 自述模板
+//
 // ⚠️ 不做「方案代号一刀切」——方案A/B 是领域决策常用概念（AC4 平台决策 14 保留），
 // 只拦「证据：无证据」这类纯自述模板 + AC 编号 + 工具动词 + 自ID 前缀。
 var noiseEntityRe = regexp.MustCompile(`(?i)^(ac\d+|ep_|f_|n_|mem_|e_|co_|cw_|df_|t_[0-9a-f]{6,}|.*(证据[:：]无证据|ingest.?dry.?run|健康检查|部署流程|测试结果|代码修改|grep).*|.*(看板|kanban|任务).*(结案|发车|状态|归档|词汇|过程|卡|process).*)$`)

go/internal/governance/graph_auto_synth_gate_test.go

@@ -0,0 +1,49 @@
+package governance
+
+import (
+	"os"
+	"testing"
+)
+
+// TestMain 让既有测试保持「改动前」语义（它们断言的是合成边确实写入）。
+// 门关行为由 TestAutoSynthGate_Off_NoSyntheticEdges 单独用 t.Setenv 验证。
+func TestMain(m *testing.M) {
+	if _, ok := os.LookupEnv("ZHIYI_GRAPH_AUTO_SYNTH"); !ok {
+		os.Setenv("ZHIYI_GRAPH_AUTO_SYNTH", "1")
+	}
+	os.Exit(m.Run())
+}
+
+// TestAutoSynthGate_Off_NoSyntheticEdges 门关（默认）⇒ 不写 uses/related_to/configures/CO_OCCURS，
+// 但 §1 节点创建不受影响。
+func TestAutoSynthGate_Off_NoSyntheticEdges(t *testing.T) {
+	t.Setenv("ZHIYI_GRAPH_AUTO_SYNTH", "0")
+	g := NewInMemoryGraph()
+	up := NewAutoGraphUpdater(g)
+	up.UpdateFromDistill(&DistillInput{
+		EpisodeID: "ep_gate_off_1",
+		Content:   "配置 tailscale docker nginx",
+		Entities:  []string{"Docker", "Nginx", "Tailscale"},
+		Namespace: "ns_gate_off",
+		Source:    "wiki:vault-ingest",
+	})
+
+	g.mu.RLock()
+	total := len(g.edges)
+	g.mu.RUnlock()
+	if total != 0 {
+		t.Fatalf("门关时应新增 0 条边，实际 %d 条", total)
+	}
+	if n := len(g.ListNodes("ns_gate_off")); n == 0 {
+		t.Fatalf("门关不应影响 §1 节点创建，实际 0 个节点")
+	}
+
+	// RecordCoOccurrence 同样受门控（零调用死代码，门关必须返回）
+	up.RecordCoOccurrence("q", "ns_gate_off", []string{"n_a", "n_b"})
+	g.mu.RLock()
+	total = len(g.edges)
+	g.mu.RUnlock()
+	if total != 0 {
+		t.Fatalf("门关时 RecordCoOccurrence 不应写边，实际 %d 条", total)
+	}
+}

go/internal/governance/graph_expander.go

@@ -36,9 +36,15 @@ func (g *InMemoryGraph) ExpandFromResults(results []models.RecallResult, namespa
 
 	startEntities := 0 // 可观测性：去重后实际导航的起点实体数 N
 	totalPathsHit := 0 // 可观测性：命中路径总数 M（补前去重）
+	rejectedJunk := 0        // P0-4：被质量闸①丢弃的垃圾实体数
+	rejectedLowDegree := 0   // P0-4：被质量闸②丢弃的低度数实体数
 	// 从每个结果正文提实体出发扩展
 	for _, r := range results {
-		for _, entity := range extractPotentialEntitiesFromContent(r.Content) {
+		entities := extractPotentialEntitiesFromContent(r.Content)
+		// P0-4 第①道闸：垃圾实体不导航
+		entities, rejected := FilterEntitiesForGraph(entities)
+		rejectedJunk += rejected
+		for _, entity := range entities {
 			if seenEntities[entity] {
 				continue
 			}
@@ -50,6 +56,11 @@ func (g *InMemoryGraph) ExpandFromResults(results []models.RecallResult, namespa
 			if err != nil {
 				continue
 			}
+			// P0-4 第②道闸：路径数 <2 ⇒ 孤边节点，不构成语义关联（内存图无 degree 查询，用路径数代理）
+			if len(paths) < 2 {
+				rejectedLowDegree++
+				continue
+			}
 			totalPathsHit += len(paths)
 			for _, p := range paths {
 				to, _ := p["target"].(string)
@@ -70,8 +81,8 @@ func (g *InMemoryGraph) ExpandFromResults(results []models.RecallResult, namespa
 	}
 	// 可观测性：默认关（ZHIYI_GRAPH_EXPAND_DEBUG=1 打开），保证「下次坏了不沉默」。
 	if graphExpandDebugEnabled() {
-		log.Printf("[graph-expand] ns=%s maxHops=%d 起点实体 %d 个 / 命中 %d 条 / 补入 %d 条",
-			namespace, maxHops, startEntities, totalPathsHit, len(expanded))
+		log.Printf("[graph-expand] ns=%s maxHops=%d 起点实体 %d 个 / 命中 %d 条 / 补入 %d 条 / 质量闸拒 垃圾 %d 低度 %d",
+			namespace, maxHops, startEntities, totalPathsHit, len(expanded), rejectedJunk, rejectedLowDegree)
 	}
 	return expanded
 }

go/internal/governance/graph_file.go

@@ -469,8 +469,13 @@ func (fg *FileGraph) ExpandFromResults(results []models.RecallResult, namespace
 	// 当实体去 Navigate，永远匹配不到任何图节点 ⇒ 结构性零产出（t_818f77be）。
 	startEntities := 0 // 可观测性：去重后实际导航的起点实体数 N
 	totalPathsHit := 0 // 可观测性：命中路径总数 M（补前去重）
+	rejectedJunk := 0      // P0-4：质量闸①拒绝数
+	rejectedLowDegree := 0 // P0-4：质量闸②拒绝数
 	for _, r := range results {
-		for _, entity := range extractFileGraphEntities(r.Content) {
+		entities := extractFileGraphEntities(r.Content)
+		entities, rejected := FilterEntitiesForGraph(entities)
+		rejectedJunk += rejected
+		for _, entity := range entities {
 			if seenEntities[entity] {
 				continue
 			}
@@ -482,6 +487,11 @@ func (fg *FileGraph) ExpandFromResults(results []models.RecallResult, namespace
 			if err != nil {
 				continue
 			}
+			// P0-4 第②道闸：路径数 <2 ⇒ 孤边节点不注入
+			if len(paths) < 2 {
+				rejectedLowDegree++
+				continue
+			}
 			totalPathsHit += len(paths)
 			for _, p := range paths {
 				target, _ := p["target"].(string)
@@ -502,8 +512,8 @@ func (fg *FileGraph) ExpandFromResults(results []models.RecallResult, namespace
 	}
 	// 可观测性：默认关（ZHIYI_GRAPH_EXPAND_DEBUG=1 打开），保证「下次坏了不沉默」。
 	if graphExpandDebugEnabled() {
-		log.Printf("[graph-expand] ns=%s maxHops=%d 起点实体 %d 个 / 命中 %d 条 / 补入 %d 条",
-			namespace, maxHops, startEntities, totalPathsHit, len(expanded))
+		log.Printf("[graph-expand] ns=%s maxHops=%d 起点实体 %d 个 / 命中 %d 条 / 补入 %d 条 / 质量闸拒 垃圾 %d 低度 %d",
+			namespace, maxHops, startEntities, totalPathsHit, len(expanded), rejectedJunk, rejectedLowDegree)
 	}
 	return expanded
 }

go/internal/governance/graph_mem.go

@@ -3,6 +3,7 @@ package governance
 
 import (
 	"fmt"
+	"strings"
 	"sync"
 )
 
@@ -295,6 +296,22 @@ func (g *InMemoryGraph) AllEdges(namespace string) []GraphEdge {
 	return out
 }
 
+// CountNodesByType 内存实现：无时间列，lastUpdated 恒为空（调用方按 unknown_age 处理）。
+func (g *InMemoryGraph) CountNodesByType(typ string) (total, withID int, lastUpdated string) {
+	g.mu.RLock()
+	defer g.mu.RUnlock()
+	for _, n := range g.nodes {
+		if n.Type != typ {
+			continue
+		}
+		total++
+		if strings.TrimSpace(n.ID) != "" {
+			withID++
+		}
+	}
+	return
+}
+
 // Stats 返回图谱统计
 func (g *InMemoryGraph) Stats() (nodeCount, edgeCount int, density float64) {
 	g.mu.RLock()

go/internal/governance/graph_sqlite.go

@@ -16,6 +16,7 @@ import "C"
 import (
 	"encoding/json"
 	"fmt"
+	"log"
 	"os"
 	"strconv"
 	"strings"
@@ -216,11 +217,33 @@ func (gs *SQLiteGraphStore) AddEdge(id, source, target, relation, namespace stri
 	return execSQL(gs.db, sql)
 }
 
+func (gs *SQLiteGraphStore) isQuarantinedNode(nodeID string) (bool, error) {
+	sql := fmt.Sprintf(
+		"SELECT namespace, pagerank FROM graph_nodes WHERE id='%s'", escape(nodeID))
+	rows := queryRows(gs.db, sql)
+	if len(rows) == 0 {
+		// node not found; treat as not quarantined to avoid breaking existing flows
+		return false, nil
+	}
+	row := rows[0]
+	namespace, _ := row["namespace"].(string)
+	pagerankVal, _ := row["pagerank"].(float64)
+	return namespace == "quarantine" && pagerankVal == 0, nil
+}
+
 func (gs *SQLiteGraphStore) Navigate(entity string, maxHops int, namespace string, relFilter []string) ([]map[string]interface{}, error) {
 	// 单源 BFS：从 entity 展开到邻居，不找路径
 	// E1.4: relFilter 白名单过滤关系类型
 	gs.mu.RLock()
 	defer gs.mu.RUnlock()
+	if quarantined, err := gs.isQuarantinedNode(entity); err != nil {
+		// If we cannot determine, treat as not quarantined to avoid breaking existing flows.
+		if err != nil {
+			// Continue; assume not quarantined.
+		} else if quarantined {
+			return []map[string]interface{}{}, nil
+		}
+	}
 
 	nsClause := buildNamespaceClause(namespace)
 	relClause := buildRelationFilterClause(relFilter)
@@ -233,7 +256,7 @@ func (gs *SQLiteGraphStore) Navigate(entity string, maxHops int, namespace strin
 		var next []string
 		for _, node := range queue {
 			sql := fmt.Sprintf(
-				"SELECT e.id, e.target, e.relation, e.weight, n.name FROM graph_edges e JOIN graph_nodes n ON e.target = n.id WHERE e.source = '%s' AND %s AND %s",
+				"SELECT e.id, e.target, e.relation, e.weight, n.name FROM graph_edges e JOIN graph_nodes n ON e.target = n.id WHERE e.source = '%s' AND %s AND %s AND n.namespace != 'quarantine' AND n.pagerank > 0",
 				escape(node), nsClause, relClause)
 			edges := queryRows(gs.db, sql)
 			for _, edge := range edges {
@@ -269,6 +292,20 @@ func (gs *SQLiteGraphStore) NavigateBiDir(source, target string, maxHops int, na
 
 	gs.mu.RLock()
 	defer gs.mu.RUnlock()
+	if quarantinedSrc, err := gs.isQuarantinedNode(source); err != nil {
+		if err != nil {
+			// Continue; assume not quarantined.
+		} else if quarantinedSrc {
+			return []map[string]interface{}{}, nil
+		}
+	}
+	if quarantinedTgt, err := gs.isQuarantinedNode(target); err != nil {
+		if err != nil {
+			// Continue; assume not quarantined.
+		} else if quarantinedTgt {
+			return []map[string]interface{}{}, nil
+		}
+	}
 
 	nsClause := buildNamespaceClause(namespace)
 
@@ -310,7 +347,7 @@ func (gs *SQLiteGraphStore) NavigateBiDir(source, target string, maxHops int, na
 		var next []string
 		for _, node := range fwdQ {
 			sql := fmt.Sprintf(
-				"SELECT e.id, e.target, e.relation, e.weight FROM graph_edges e WHERE e.source = '%s' AND %s",
+				"SELECT e.id, e.target, e.relation, e.weight FROM graph_edges e JOIN graph_nodes n ON e.target = n.id WHERE e.source = '%s' AND %s AND n.namespace != 'quarantine' AND n.pagerank > 0",
 				escape(node), nsClause)
 			edges := queryRows(gs.db, sql)
 			for _, edge := range edges {
@@ -340,7 +377,7 @@ func (gs *SQLiteGraphStore) NavigateBiDir(source, target string, maxHops int, na
 		for _, node := range bwdQ {
 			// 反向要找所有指向 node 的边（target = node）
 			sql := fmt.Sprintf(
-				"SELECT e.id, e.source, e.relation, e.weight FROM graph_edges e WHERE e.target = '%s' AND %s",
+				"SELECT e.id, e.source, e.relation, e.weight FROM graph_edges e JOIN graph_nodes n ON e.source = n.id WHERE e.target = '%s' AND %s AND n.namespace != 'quarantine' AND n.pagerank > 0",
 				escape(node), nsClause)
 			edges := queryRows(gs.db, sql)
 			for _, edge := range edges {
@@ -548,11 +585,79 @@ func (gs *SQLiteGraphStore) Stats() (nodeCount, edgeCount int, density float64)
 	return
 }
 
+// CountNodesByType 返回某类节点的总量、id 非空量、最近一次更新时间（2026-10-26）。
+//
+// 存在的理由：selfcheck 需要暴露「pattern 召回有没有生产者」这一可观测事实。
+// 事故背景：`POST /api/v1/patterns/detect` 是短命单发端点，全库 0 cron、0 调用方，
+// 于是 graph_nodes(type='pattern') 恒 0 行、recall 恒 0 命中，而日志层面完全沉默。
+// 零产出必须能被机器读到，不能靠人翻 7 天日志才发现。
+func (gs *SQLiteGraphStore) CountNodesByType(typ string) (total, withID int, lastUpdated string) {
+	gs.mu.RLock()
+	defer gs.mu.RUnlock()
+
+	t := escape(typ)
+	total = queryInt(gs.db, fmt.Sprintf("SELECT COUNT(*) FROM graph_nodes WHERE type='%s'", t))
+	withID = queryInt(gs.db, fmt.Sprintf(
+		"SELECT COUNT(*) FROM graph_nodes WHERE type='%s' AND id IS NOT NULL AND TRIM(id)<>''", t))
+	rows := queryRows(gs.db, fmt.Sprintf(
+		"SELECT MAX(last_updated_at) AS m FROM graph_nodes WHERE type='%s'", t))
+	if len(rows) > 0 && rows[0]["m"] != nil {
+		if v, ok := rows[0]["m"].(string); ok {
+			lastUpdated = v
+		} else {
+			lastUpdated = fmt.Sprintf("%v", rows[0]["m"])
+		}
+	}
+	return
+}
+
+// pruneGraceDays 孤点删除宽限期（天）。t_31bb2992（2026-11-02）背景：
+// ZHIYI_GRAPH_AUTO_SYNTH 门关后 §1 仍建实体节点、§2 不建边 ⇒ 新建节点天然孤点；
+// 旧版 Prune 无条件删孤点且零日志，曾一次性静默删 93.6% 节点（41,371→2,630）。
+// AddNode 是 INSERT OR REPLACE（created_at 每次刷新），故宽限期实际语义 =
+// 「连续 N 天没被蒸馏引用过的孤点才删」。ZHIYI_GRAPH_PRUNE_GRACE_DAYS=0 回到旧行为。
+func pruneGraceDays() int {
+	if v := strings.TrimSpace(os.Getenv("ZHIYI_GRAPH_PRUNE_GRACE_DAYS")); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n >= 0 {
+			return n
+		}
+	}
+	return 14
+}
+
 func (gs *SQLiteGraphStore) Prune(minWeight float64) {
 	gs.mu.Lock()
 	defer gs.mu.Unlock()
+
+	// 删除前预告（t_31bb2992）：把「会删多少、删的是谁」先写进日志，
+	// 杜绝再次出现「静默删 93.6%」事后才从行数差发现的事故。
+	grace := pruneGraceDays()
+	// created_at 为空的行按最老处理（可删）；id IS NULL 的行因 SQL 三值逻辑
+	// 对 NOT IN 天然免疫，维持既有行为（pattern_stat 等 85 行不受影响）。
+	// grace<=0 = 逃生阀：完全不加时间条件，逐位回到旧行为（同秒新建也照删）。
+	orphanWhere := `id NOT IN (SELECT DISTINCT source FROM graph_edges UNION SELECT DISTINCT target FROM graph_edges)`
+	if grace > 0 {
+		orphanWhere += fmt.Sprintf(
+			" AND COALESCE(NULLIF(created_at,''),'0000-00-00 00:00:00') < datetime('now','-%d day')", grace)
+	}
+	if n := queryInt(gs.db, "SELECT COUNT(*) FROM graph_edges WHERE weight < "+fmt.Sprintf("%f", minWeight)); n > 0 {
+		log.Printf("[graph] prune will delete %d edges (weight < %.2f)", n, minWeight)
+	}
+	if n := queryInt(gs.db, "SELECT COUNT(*) FROM graph_nodes WHERE "+orphanWhere); n > 0 {
+		sample := ""
+		if rows := queryRows(gs.db, "SELECT id, name FROM graph_nodes WHERE "+orphanWhere+" LIMIT 5"); len(rows) > 0 {
+			names := make([]string, 0, len(rows))
+			for _, r := range rows {
+				names = append(names, fmt.Sprintf("%v(%v)", r["name"], r["id"]))
+			}
+			sample = strings.Join(names, ", ")
+		}
+		log.Printf("[graph] prune will delete %d orphan nodes (grace=%dd, minWeight=%.2f), sample=[%s]",
+			n, grace, minWeight, sample)
+	}
+
 	execSQL(gs.db, fmt.Sprintf("DELETE FROM graph_edges WHERE weight < %f", minWeight))
-	execSQL(gs.db, `DELETE FROM graph_nodes WHERE id NOT IN (SELECT DISTINCT source FROM graph_edges UNION SELECT DISTINCT target FROM graph_edges)`)
+	execSQL(gs.db, "DELETE FROM graph_nodes WHERE "+orphanWhere)
 }
 
 // CleanupNoiseNodes 删除名称含编码噪音的节点（如 "n_fts=517," "n_fts（sqlite）+"）
@@ -755,6 +860,8 @@ func (gs *SQLiteGraphStore) ExpandFromResults(results []models.RecallResult, nam
 
 	seen := make(map[string]bool)         // 追踪已访问的记忆 ID
 	seenEntities := make(map[string]bool) // 追踪已访问的实体（用于去重扩展结果）
+	rejectedJunk := 0
+	rejectedLowDegree := 0
 	for _, r := range results {
 		if seen[r.ID] {
 			continue
@@ -762,6 +869,9 @@ func (gs *SQLiteGraphStore) ExpandFromResults(results []models.RecallResult, nam
 		seen[r.ID] = true
 
 		entities := extractPotentialEntities(r.Content)
+		// P0-4 第①道闸：垃圾实体（虚词/量词/代词/填充短语）不导航
+		entities, rejected := FilterEntitiesForGraph(entities)
+		rejectedJunk += rejected
 		for _, entity := range entities {
 			if seenEntities[entity] {
 				continue
@@ -769,18 +879,25 @@ func (gs *SQLiteGraphStore) ExpandFromResults(results []models.RecallResult, nam
 			seenEntities[entity] = true
 
 			// SQLite 图谱节点 ID 格式: n_{entity_name}，需 normalizeEntityID 转换
+			// Navigate 的 from/to 都是**节点 ID**（n_织忆），不能用裸名 entity 比对，
+			// 否则恒不相等 ⇒ 路径全被 continue ⇒ 结构性 0 条附加（t_be4d070a 诊断）。
 			nodeID := normalizeEntityID(entity)
+			// P0-4 第②道闸：度数 <2 的孤边节点不构成语义关联 ⇒ 不导航、不注入。
+			if gs.EdgeDegree(nodeID) < 2 {
+				rejectedLowDegree++
+				continue
+			}
 			paths, _ := gs.Navigate(nodeID, maxHops, namespace, nil)
 			for _, p := range paths {
-				// Navigate 返回字段: from, to, relation, weight, hop
+				// Navigate 返回字段: from, to, relation, weight, hop（均为节点 ID）
 				var neighbor, rel string
 				from, _ := p["from"].(string)
 				to, _ := p["to"].(string)
 				relVal, _ := p["relation"].(string)
-				if from == entity && to != "" {
+				if from == nodeID && to != "" {
 					neighbor = to
 					rel = relVal
-				} else if to == entity && from != "" {
+				} else if to == nodeID && from != "" {
 					neighbor = from
 					rel = "↩ " + relVal
 				}
@@ -792,15 +909,62 @@ func (gs *SQLiteGraphStore) ExpandFromResults(results []models.RecallResult, nam
 				}
 				seenEntities[neighbor] = true
 				expanded = append(expanded, models.RecallResult{
-					Content: fmt.Sprintf("[graph] %s --[%s]--> %s", entity, rel, neighbor),
+					// ID 用邻居节点 ID（n_<实体> 或 n_mem_<记忆id>），非空才不破坏 recall.go 的
+					// ID 去重（Step 5 按 r.ID==e.ID 判已存在）；若邻居是记忆节点，ID 即真实记忆指针。
+					ID:       neighbor,
+					Category: "graph_expanded",
+					Content: fmt.Sprintf("[graph] %s --[%s]--> %s", entity, rel, displayNodeName(neighbor)),
 					Score:   r.Score * 0.5,
 				})
 			}
 		}
 	}
+	// P0-4 可观测性：两道闸的拒绝量必须能读出来（默认关，debug 开才打印，避免刷屏）。
+	if graphExpandDebugEnabled() && (rejectedJunk > 0 || rejectedLowDegree > 0) {
+		log.Printf("[graph-expand] ns=%s 质量闸：垃圾实体拒 %d / 低度数拒 %d / 补入 %d",
+			namespace, rejectedJunk, rejectedLowDegree, len(expanded)-len(results))
+	}
 	return expanded
 }
 
+// EdgeDegree 返回节点在图中的边数（入度+出度，P0-4 度数闸用）。
+// 与 GetEntityDegree 的区别：后者返回 evidence_count 之和（证据强度），
+// 本函数才是字面意义的「度数」—— 孤边节点（度=1）不足以构成语义关联。
+func (gs *SQLiteGraphStore) EdgeDegree(nodeID string) int {
+	if nodeID == "" {
+		return 0
+	}
+	gs.mu.RLock()
+	defer gs.mu.RUnlock()
+	rows := queryRows(gs.db, fmt.Sprintf(
+		"SELECT COUNT(*) as c FROM graph_edges WHERE source = '%s' OR target = '%s'",
+		escape(nodeID), escape(nodeID)))
+	if len(rows) == 0 {
+		return 0
+	}
+	switch v := rows[0]["c"].(type) {
+	case int:
+		return v
+	case int64:
+		return int(v)
+	case float64:
+		return int(v)
+	}
+	return 0
+}
+
+// displayNodeName 把节点 ID 转成可读显示名（去 n_ / n_mem_ / mem_ 前缀）。
+// 图节点 ID 形态：实体 n_织忆 / 概念 n_mem_<记忆id>（name 列才是 mem_<id>）。
+// 仅用于格式化 Content 的可读展示，不做任何记忆正文编造。
+func displayNodeName(nodeID string) string {
+	for _, p := range []string{"n_mem_", "n_", "mem_", "ep_"} {
+		if strings.HasPrefix(nodeID, p) {
+			return strings.TrimPrefix(nodeID, p)
+		}
+	}
+	return nodeID
+}
+
 // ExpandWithSummary BFS 扩展 + 生成汇总语句 — E1 图谱导航增强
 // 从 recall 结果提取实体，进行多跳扩展，返回扩展关系列表和一句话汇总
 func (gs *SQLiteGraphStore) ExpandWithSummary(results []models.RecallResult, namespace string, maxHops int) models.GraphBFSResult {

go/internal/governance/graph_sqlite_expand_test.go

@@ -0,0 +1,133 @@
+// 织忆 MemoryWeave — SQLiteGraphStore.ExpandFromResults 修复锁死测试（t_724f31ad）
+//
+// 背景：SQLiteGraphStore.ExpandFromResults（graph_sqlite.go:787）此前拿裸实体名 entity
+// 与 Navigate 返回的节点 ID（n_织忆）做 == 比对 ⇒ 恒不相等 ⇒ 路径全被 continue ⇒ 结构性 0 条附加。
+// 且附加结果 Category 空、ID 空（审计 graph_expanded 计数恒 0 + recall.go ID 去重失效）。
+//
+// 本文件两类断言：
+//   1) 正向：构造 n_<实体> 节点 + 一条 recall 结果 ⇒ ExpandFromResults 返回 >len(results)，
+//      且新增项 Category=="graph_expanded" 且 ID!=""（ID 用邻居节点 ID）。
+//   2) 反向：实体在图里不存在 ⇒ 结果条数不变（不得凭空加）。
+package governance
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/xiaoxue/memoryweave/internal/models"
+)
+
+// testNS724 SQLite 图的 namespace 须用 `-main` 全形态：SQLiteGraphStore.Navigate 经
+// deriveNamespaceForGraph 会把裸名 ns 变 ns-main 再过滤（与生产 recall.go 传的 namespace 一致）。
+const testNS724 = "t-ns-expand-sqlite-main"
+
+// newTestSQLiteGraph 建临时 SQLiteGraphStore 并灌入一条链：n_织忆 -LINKS_TO-> n_图谱。
+func newTestSQLiteGraph(t *testing.T) *SQLiteGraphStore {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "graph-test.db")
+	gs, err := NewSQLiteGraphStore(path)
+	if err != nil {
+		t.Fatalf("NewSQLiteGraphStore: %v", err)
+	}
+	t.Cleanup(func() { _ = gs.Close() })
+	if err := gs.AddNode("n_织忆", "织忆", "entity", testNS724); err != nil {
+		t.Fatalf("AddNode n_织忆: %v", err)
+	}
+	if err := gs.AddNode("n_图谱", "图谱", "entity", testNS724); err != nil {
+		t.Fatalf("AddNode n_图谱: %v", err)
+	}
+	if err := gs.AddEdge("e-ab", "n_织忆", "n_图谱", "LINKS_TO", testNS724, 1.0); err != nil {
+		t.Fatalf("AddEdge: %v", err)
+	}
+	// P0-4 度数闸（2026-10-26）：degree<2 的孤边节点不再注入 ⇒ 正向用例的起点实体
+	// 必须真的在图里有 ≥2 条边（两跳邻居即真实图谱形态，不是为过测试造数据）。
+	if err := gs.AddNode("n_召回", "召回", "entity", testNS724); err != nil {
+		t.Fatalf("AddNode n_召回: %v", err)
+	}
+	if err := gs.AddEdge("e-ac", "n_织忆", "n_召回", "LINKS_TO", testNS724, 1.0); err != nil {
+		t.Fatalf("AddEdge e-ac: %v", err)
+	}
+	return gs
+}
+
+// TestSQLiteGraphStore_DegreeGate P0-4：度数=1 的孤边实体不得被扩展注入。
+func TestSQLiteGraphStore_DegreeGate(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "graph-degree.db")
+	gs, err := NewSQLiteGraphStore(path)
+	if err != nil {
+		t.Fatalf("NewSQLiteGraphStore: %v", err)
+	}
+	t.Cleanup(func() { _ = gs.Close() })
+	// 孤边：n_孤边 --LINKS_TO--> n_邻居（起点实体度=1）
+	if err := gs.AddNode("n_孤边", "孤边", "entity", testNS724); err != nil {
+		t.Fatal(err)
+	}
+	if err := gs.AddNode("n_邻居", "邻居", "entity", testNS724); err != nil {
+		t.Fatal(err)
+	}
+	if err := gs.AddEdge("e-one", "n_孤边", "n_邻居", "LINKS_TO", testNS724, 1.0); err != nil {
+		t.Fatal(err)
+	}
+	if got := gs.EdgeDegree("n_孤边"); got != 1 {
+		t.Fatalf("EdgeDegree(n_孤边) 应为 1，实际 %d", got)
+	}
+	results := []models.RecallResult{{
+		ID: "mem_degree_1", Content: "孤边 的扩展", Category: "distilled", Score: 0.9, Namespace: testNS724,
+	}}
+	got := gs.ExpandFromResults(results, testNS724, 1)
+	if len(got) != len(results) {
+		t.Fatalf("度数=1 的实体不应扩展注入，实际补入 %d 条", len(got)-len(results))
+	}
+}
+
+// TestSQLiteGraphStore_ExpandFromResults_Inserts 正向：实体在图中 ⇒ 补入 graph_expanded 且 ID 非空。
+func TestSQLiteGraphStore_ExpandFromResults_Inserts(t *testing.T) {
+	gs := newTestSQLiteGraph(t)
+
+	results := []models.RecallResult{{
+		ID:        "mem_expand_1",
+		Content:   "织忆 与 图谱 的扩展机制",
+		Category:  "distilled",
+		Score:     0.9,
+		Namespace: testNS724,
+	}}
+
+	got := gs.ExpandFromResults(results, testNS724, 1)
+	if len(got) <= len(results) {
+		t.Fatalf("期望补入 >len(results)=%d，实际 %d 条（结构性 0 产出未修？）", len(results), len(got))
+	}
+	var added int
+	for _, e := range got[len(results):] {
+		if e.Category != "graph_expanded" {
+			t.Fatalf("补入结果 category=%q 期望 graph_expanded", e.Category)
+		}
+		if e.ID == "" {
+			t.Fatalf("补入结果 ID 为空（ID 去重会失效），Content=%q", e.Content)
+		}
+		added++
+	}
+	if added == 0 {
+		t.Fatal("没有任何 graph_expanded 补入")
+	}
+	t.Logf("SQLiteGraphStore: 1-recall 补入 %d 条 graph_expanded（ID 均非空）", added)
+}
+
+// TestSQLiteGraphStore_ExpandFromResults_NoFabrication 反向：实体不在图中 ⇒ 条数不变，不得凭空加。
+func TestSQLiteGraphStore_ExpandFromResults_NoFabrication(t *testing.T) {
+	gs := newTestSQLiteGraph(t)
+
+	// content 只含一个图中不存在的实体「完全不存在的实体」（切分成 2~8 字中文串均无图节点）。
+	results := []models.RecallResult{{
+		ID:        "mem_expand_2",
+		Content:   "完全不存在的实体",
+		Category:  "distilled",
+		Score:     0.9,
+		Namespace: testNS724,
+	}}
+
+	got := gs.ExpandFromResults(results, testNS724, 1)
+	if len(got) != len(results) {
+		t.Fatalf("实体不在图中却补入 %d 条（期望 0 补入，len=%d）", len(got)-len(results), len(results))
+	}
+	t.Logf("SQLiteGraphStore: 图外实体 ⇒ 0 补入（不凭空加）")
+}

go/internal/governance/graph_store.go

@@ -23,6 +23,9 @@ type GraphStore interface {
 
 	// 统计与维护
 	Stats() (nodeCount, edgeCount int, density float64)
+	// CountNodesByType 返回某类节点的总量、id 非空量、最近更新时间。
+	// 用途：让「写入端有没有产数」可被机器读到（pattern 召回曾恒 0 而日志沉默）。
+	CountNodesByType(typ string) (total, withID int, lastUpdated string)
 	Prune(minWeight float64)
 
 	// 边枚举（供社区发现用）

go/internal/governance/prune_grace_test.go

@@ -0,0 +1,118 @@
+package governance
+
+// t_31bb2992 · Prune 孤点宽限期 + 删除前日志 单测
+// 背景：门关（ZHIYI_GRAPH_AUTO_SYNTH=0）后 §1 建点、§2 不建边 ⇒ 新点皆孤点；
+// 旧版 Prune 无条件删孤点且零日志（生产曾静默删 41,371→2,630）。
+
+import (
+	"bytes"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func newTempGraphStore(t *testing.T) *SQLiteGraphStore {
+	t.Helper()
+	gs, err := NewSQLiteGraphStore(filepath.Join(t.TempDir(), "graph.db"))
+	if err != nil {
+		t.Fatalf("NewSQLiteGraphStore: %v", err)
+	}
+	t.Cleanup(func() { gs.Close() })
+	return gs
+}
+
+// 宽限期：门关时新建的孤点，宽限期内 Prune 不得删；超过宽限期才删；
+// grace=0 是逃生阀 = 旧行为（立即删）。
+func TestPruneGracePeriod_OrphanSurvival(t *testing.T) {
+	t.Setenv("ZHIYI_GRAPH_AUTO_SYNTH", "0")
+	gs := newTempGraphStore(t)
+	up := NewAutoGraphUpdater(gs)
+	up.UpdateFromDistill(&DistillInput{
+		EpisodeID: "ep_grace_1",
+		Content:   "宽限期 单测",
+		Entities:  []string{"孤点甲", "孤点乙"},
+		Namespace: "ns_grace",
+		Source:    "wiki:vault-ingest",
+	})
+
+	// ① 新孤点在 14d 宽限期内 ⇒ Prune 后仍在
+	gs.Prune(0.15)
+	if n := queryInt(gs.db, "SELECT COUNT(*) FROM graph_nodes WHERE namespace='ns_grace'"); n != 2 {
+		t.Fatalf("宽限期内新孤点应保留 2 个，实际 %d", n)
+	}
+
+	// ② 把 created_at 推到 15 天前 ⇒ 出宽限期，Prune 删除
+	execSQL(gs.db, "UPDATE graph_nodes SET created_at='2020-01-01 00:00:00' WHERE namespace='ns_grace'")
+	gs.Prune(0.15)
+	if n := queryInt(gs.db, "SELECT COUNT(*) FROM graph_nodes WHERE namespace='ns_grace'"); n != 0 {
+		t.Fatalf("超宽限期孤点应被删除，实际剩 %d", n)
+	}
+
+	// ③ 逃生阀 grace=0 ⇒ 新孤点也被删（回旧行为）
+	if err := gs.AddNode("n_grace_zero", "逃生阀点", "entity", "ns_grace0"); err != nil {
+		t.Fatalf("AddNode: %v", err)
+	}
+	t.Setenv("ZHIYI_GRAPH_PRUNE_GRACE_DAYS", "0")
+	gs.Prune(0.15)
+	if n := queryInt(gs.db, "SELECT COUNT(*) FROM graph_nodes WHERE id='n_grace_zero'"); n != 0 {
+		t.Fatalf("grace=0 应回到旧行为（即删新孤点），实际仍在")
+	}
+
+	// ④ 有边引用的节点任何情况下都不被孤点删除误伤
+	if err := gs.AddNode("n_anchor_a", "甲", "entity", "ns_edge"); err != nil {
+		t.Fatalf("AddNode: %v", err)
+	}
+	if err := gs.AddNode("n_anchor_b", "乙", "entity", "ns_edge"); err != nil {
+		t.Fatalf("AddNode: %v", err)
+	}
+	if err := gs.AddEdge("e_anchor", "n_anchor_a", "n_anchor_b", "CONFLICTS_WITH", "ns_edge", 0.9); err != nil {
+		t.Fatalf("AddEdge: %v", err)
+	}
+	execSQL(gs.db, "UPDATE graph_nodes SET created_at='2020-01-01 00:00:00' WHERE namespace='ns_edge'")
+	gs.Prune(0.15)
+	if n := queryInt(gs.db, "SELECT COUNT(*) FROM graph_nodes WHERE namespace='ns_edge'"); n != 2 {
+		t.Fatalf("有边端点不应被删，实际剩 %d", n)
+	}
+}
+
+// 删除前日志：Prune 删孤点前必须打「will delete N orphan nodes + 抽样」，
+// 让静默大规模删点以后在日志里看得见。
+func TestPruneLogsOrphanDeletionPreview(t *testing.T) {
+	t.Setenv("ZHIYI_GRAPH_AUTO_SYNTH", "0")
+	gs := newTempGraphStore(t)
+	for _, e := range []struct{ id, name string }{
+		{"n_log_1", "日志点一"}, {"n_log_2", "日志点二"},
+	} {
+		if err := gs.AddNode(e.id, e.name, "concept", "ns_log"); err != nil {
+			t.Fatalf("AddNode: %v", err)
+		}
+	}
+	execSQL(gs.db, "UPDATE graph_nodes SET created_at='2020-01-01 00:00:00' WHERE namespace='ns_log'")
+
+	var buf bytes.Buffer
+	old := log.Writer()
+	log.SetOutput(&buf)
+	defer log.SetOutput(old)
+
+	gs.Prune(0.15)
+
+	out := buf.String()
+	if !strings.Contains(out, "[graph] prune will delete 2 orphan nodes") {
+		t.Fatalf("日志缺少 will-delete 计数行，实际输出:\n%s", out)
+	}
+	for _, want := range []string{"sample=", "日志点一", "n_log_1", "grace=14d"} {
+		if !strings.Contains(out, want) {
+			t.Fatalf("日志缺少 %q，实际输出:\n%s", want, out)
+		}
+	}
+
+	// 无可删对象时不得虚报
+	buf.Reset()
+	gs.Prune(0.15)
+	if strings.Contains(buf.String(), "prune will delete") {
+		t.Fatalf("无可删对象时不应打删除预告，实际:\n%s", buf.String())
+	}
+	_ = os.Getenv // keep imports stable if env helpers change
+}

go/internal/memprotect/memprotect.go

@@ -30,6 +30,7 @@ package memprotect
 
 import (
 	"log"
+	"os"
 	"strconv"
 	"strings"
 
@@ -67,6 +68,41 @@ const (
 	RedisKeyProtectedIDs = "zhiyi:protected_ids"
 )
 
+// ── GA-P2 强保护栏（2026-10-27）──────────────────────────────────────────────
+//
+// 规则5（可选，ZHIYI_PROTECT_RAILS=1 启用）：recall_verified_count >= 2 ⇒ 保护。
+// 口径与 Python 侧 zhiyi_protection.py 的 MIN_VERIFIED_FOR_RAILS 及
+// ~/.hermes/plugins/zhiyi/protect_rails.py 规则② 逐字同口径 —— 任何改动必须两侧同步，
+// 禁止两套标准（卡 t_944344b5 边界条款）。
+//
+// 政策边界（牧尘 2026-10-20 拍板）：rv == 1（只被确认过一次）不纳入保护，
+// 保留「验证满 2 次才算硬证据」的门槛。
+//
+// 默认关（未设/env != "1"）⇒ 行为零变化；启用后为纯增保护（只增加「不遗忘」，绝不增加删除）。
+const MinVerifiedForRails = 2
+
+// ProtectRailsEnv 强保护栏 env 开关名（与 protect_rails.py / zhiyi_protection.py 同名）。
+const ProtectRailsEnv = "ZHIYI_PROTECT_RAILS"
+
+// ProtectRailsEnabled 读 env，每次调用现读（支持不重启热切换，开销可忽略）。
+func ProtectRailsEnabled() bool {
+	return strings.TrimSpace(os.Getenv(ProtectRailsEnv)) == "1"
+}
+
+// rowInt 从候选 map 取整型字段，兼容 int/int64/float64
+// （IPC 侧候选 map 是 int；直连/其它实现可能给 int64，避免规则因类型断言失败而空转）。
+func rowInt(row map[string]interface{}, key string) int {
+	switch v := row[key].(type) {
+	case int:
+		return v
+	case int64:
+		return int(v)
+	case float64:
+		return int(v)
+	}
+	return 0
+}
+
 // State 一次 LoadState() 加载的保护状态快照。
 // 衰减 tick / admin forget 开始时 LoadState 一次，循环内对每条候选复用同一 State，
 // 避免每条记忆都 HGETALL/SMEMBERS 一次 Redis。
@@ -123,6 +159,16 @@ func IsProtected(row map[string]interface{}, st *State) (bool, string) {
 		}
 	}
 
+	// 规则5（GA-P2 强保护栏，可选）：recall_verified_count >= 2 ⇒ 保护。
+	// 默认关（ZHIYI_PROTECT_RAILS != "1"）⇒ 行为零变化。启用后：被验证使用 ≥2 次的
+	// 记忆永不自动遗忘（纯增保护，不增加任何删除）。字段已在候选 map（lancedb_ipc.go
+	// GetCandidatesForForgetting 已 SELECT recall_verified_count），不依赖 Redis 缓存。
+	if ProtectRailsEnabled() {
+		if rv := rowInt(row, "recall_verified_count"); rv >= MinVerifiedForRails {
+			return true, "recall_verified_ge2"
+		}
+	}
+
 	return false, ""
 }
 

go/internal/memprotect/memprotect_test.go

@@ -403,3 +403,56 @@ func TestDifferential_FixtureTable(t *testing.T) {
 		}
 	}
 }
+
+// TestRule5_RailsVerifiedCount (GA-P2, 2026-10-27)：强保护栏 recall_verified_count>=2 规则。
+// 口径与 Python zhiyi_protection.py 的 recall_verified>=2 一致；默认关（零行为变化）。
+// 政策边界（牧尘 2026-10-20 拍板）：rv==1 不纳入保护（验证满 2 次才算硬证据）。
+func TestRule5_RailsVerifiedCount(t *testing.T) {
+	mkRV := func(rv int) map[string]interface{} {
+		return map[string]interface{}{
+			"id":                    "mem_rails",
+			"category":              "normal", // 不命中规则1
+			"freshness":             "",       // 不命中规则3
+			"content":               "普通日常内容", // 不命中规则4b
+			"recall_verified_count": rv,
+		}
+	}
+	st := synthState(nil, nil) // 空 VProp/Protected ⇒ 规则2/4a 不命中
+
+	// 1) 默认关（未设 env）：rv 再高也不保护（行为零变化）
+	t.Setenv(ProtectRailsEnv, "")
+	if p, r := IsProtected(mkRV(50), st); p {
+		t.Fatalf("默认关: rv=50 不应保护, got true rule=%s", r)
+	}
+
+	// 2) ENV="1" 启用：rv>=2 保护（含边界 2），rv=1/0 不保护
+	t.Setenv(ProtectRailsEnv, "1")
+	if p, r := IsProtected(mkRV(2), st); !p || r != "recall_verified_ge2" {
+		t.Errorf("rv=2(边界) 应保护 rule=recall_verified_ge2, got %v rule=%s", p, r)
+	}
+	if p, _ := IsProtected(mkRV(5), st); !p {
+		t.Error("rv=5 应保护")
+	}
+	if p, _ := IsProtected(mkRV(1), st); p {
+		t.Error("rv=1 不应保护（政策边界：验证满 2 次才算硬证据）")
+	}
+	if p, _ := IsProtected(mkRV(0), st); p {
+		t.Error("rv=0 不应保护")
+	}
+
+	// 3) ENV="0" 显式关：不保护
+	t.Setenv(ProtectRailsEnv, "0")
+	if p, _ := IsProtected(mkRV(5), st); p {
+		t.Error("ENV=0 不应保护")
+	}
+
+	// 4) rowInt 类型兼容：int64 也应正确识别（防类型断言失配致规则空转）
+	t.Setenv(ProtectRailsEnv, "1")
+	row := map[string]interface{}{
+		"id": "mem_i64", "category": "normal", "content": "x",
+		"recall_verified_count": int64(3),
+	}
+	if p, _ := IsProtected(row, st); !p {
+		t.Error("rv=int64(3) 应保护（rowInt 类型兼容）")
+	}
+}

go/internal/metrics/metrics.go

@@ -35,6 +35,38 @@ var (
 		},
 	)
 
+	// ─── 整合（consolidate）可观测性 ───────────
+	// 2026-10-26：这三个指标与 MetaNoteRejectTotal 的定义在 rebase 时被丢弃（定义只在
+	// a8dfa37 里），而调用方（consolidation_track.go / core.go）已进 main ⇒ HEAD 编不过。
+	// 从 a8dfa37 原样恢复定义并注册，恢复 main 可构建性。
+	ConsolidateBusyWaitTotal = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "zhiyi_consolidate_busy_wait_total",
+			Help: "Rust 侧报 consolidate_busy 时 Go 侧主动等待重试的次数",
+		},
+	)
+	// 最近一次整合成功时间（Unix 秒）
+	ConsolLastSuccessTime = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "zhiyi_consolidate_last_success_time",
+			Help: "最近一次 Rust 整合完成时间（Unix 秒）；0 = 从未成功",
+		},
+	)
+	// 整合连续失败次数
+	ConsolConsecutiveFailures = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "zhiyi_consolidate_consecutive_failures",
+			Help: "连续整合失败次数（任意一次成功归零）",
+		},
+	)
+	// metanote shadow 写前置校验拒绝计数
+	MetaNoteRejectTotal = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "zhiyi_metanote_reject_total",
+			Help: "metanote shadow 422 拒绝累计次数",
+		},
+	)
+
 	// ─── LLM 调用计数 ──────────────────────────
 	DistillLLMCallsToday = prometheus.NewGauge(
 		prometheus.GaugeOpts{
@@ -61,6 +93,15 @@ var (
 		},
 	)
 
+	// ─── 软删除终态失败（t_10757bd5 AC5）────────────────────────
+	// 与日志 "SoftDelete persist FAILED" / "pending-softdelete drain FAILED" 行对齐
+	SoftDeletePersistFailTotal = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "zhiyi_softdelete_persist_fail_total",
+			Help: "SoftDelete 落盘终态失败（重试耗尽/非可重试）累计次数",
+		},
+	)
+
 	// ─── 内存 RSS ──────────────────────────────
 	MemoryRSSBytes = prometheus.NewGauge(
 		prometheus.GaugeOpts{
@@ -124,9 +165,14 @@ func init() {
 		RequestDuration,
 		DistillQueueDepth,
 		ConflictsPending,
+		ConsolidateBusyWaitTotal,
+		ConsolLastSuccessTime,
+		ConsolConsecutiveFailures,
+		MetaNoteRejectTotal,
 		DistillLLMCallsToday,
 		ConsolidateFailuresTotal,
 		HitEventAppendFailedTotal,
+		SoftDeletePersistFailTotal,
 		MemoryRSSBytes,
 		SQLiteDBSizeBytes,
 		RecallUsefulnessRate,

go/internal/models/intention_ttl_test.go

@@ -0,0 +1,61 @@
+package models
+
+// intention_ttl_test.go — 2026-11-07 t_88cc9cb8 意图 TTL（category=intention + expires_at）
+//
+// 锁定两件事（回归闸门）：
+//  1. MemoryRecord / RecallResult 都携带 ExpiresAt 且 JSON 键名 = "expires_at"
+//     —— 键名是 IPC payload 与 Rust builder `r["expires_at"]` 的契约，改键名 = 静默丢字段。
+//  2. omitempty：不传 = JSON 无此键 = 永久有效（关态/存量行为不变的序列化前提）。
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestExpiresAt_JSONKeyContract(t *testing.T) {
+	rec := MemoryRecord{ID: "m1", Category: "intention", ExpiresAt: "2026-11-08T00:00:00Z"}
+	b, err := json.Marshal(rec)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	s := string(b)
+	if !strings.Contains(s, `"expires_at":"2026-11-08T00:00:00Z"`) {
+		t.Fatalf("✗ MemoryRecord JSON 缺 expires_at 契约键：%s", s)
+	}
+	// 回环：反序列化读回
+	var got MemoryRecord
+	if err := json.Unmarshal(b, &got); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if got.ExpiresAt != "2026-11-08T00:00:00Z" {
+		t.Fatalf("✗ 回环 ExpiresAt=%q", got.ExpiresAt)
+	}
+}
+
+func TestExpiresAt_OmitEmptyMeansPermanent(t *testing.T) {
+	// 不传 = JSON 不带键（Rust as_str().unwrap_or("") ⇒ 空 = 永久有效）
+	b, err := json.Marshal(MemoryRecord{ID: "m2", Category: "distilled"})
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	if strings.Contains(string(b), "expires_at") {
+		t.Fatalf("✗ 未声明时不应输出 expires_at 键（存量兼容）：%s", b)
+	}
+}
+
+func TestRecallResult_ExpiresAtPassthrough(t *testing.T) {
+	// RecallResult 直通（"响应值==库值"判据的序列化前提）
+	b, err := json.Marshal(RecallResult{ID: "m3", ExpiresAt: "2026-12-01T00:00:00+08:00"})
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	if !strings.Contains(string(b), `"expires_at":"2026-12-01T00:00:00+08:00"`) {
+		t.Fatalf("✗ RecallResult JSON 缺 expires_at：%s", b)
+	}
+	// 空 = omitempty 不输出（关态响应逐字节兼容）
+	b2, _ := json.Marshal(RecallResult{ID: "m4"})
+	if strings.Contains(string(b2), "expires_at") {
+		t.Fatalf("✗ 空 ExpiresAt 不应输出键（响应兼容）：%s", b2)
+	}
+}

go/internal/models/memory.go

@@ -56,6 +56,12 @@ type MemoryRecord struct {
 	// 历史列(deprecated)，新代码不再读它（见 AC#3）。
 	HumanNotUsefulCount  int             `json:"human_not_useful_count"`    // 用户人工点「没用」的次数
 	DedupDownweightCount int             `json:"dedup_downweight_count"`    // dedup/合并流程自动降权的次数
+	// A10 (t_d618dc7c)：把「人工有用」从 UsefulCount（人工+机器混写）拆出单独计数。
+	// 指针类型：nil = NULL（存量行/从未被人工点过），非 nil = 真实整数。
+	// 统计口径用时分母必须 WHERE human_useful_count IS NOT NULL（NULL≠0）。
+	// 只有人工 feedback（/api/v1/feedback/useful → IncrementUseful）会 ++，机器自评/
+	// 蒸馏质量路径走别的方法（IncrementDedupDownweight/IncrementHumanNotUseful/...）不写此列。
+	HumanUsefulCount *int `json:"human_useful_count"` // nil=NULL（从未被人工点过）；非 nil=真实计数
 	NotUsefulCount       int             `json:"not_useful_count"`          // [DEPRECATED] 历史混写列，勿再读
 	Version              int             `json:"version"`                   // 当前版本号
 	VersionHistory       []VersionRecord `json:"version_history,omitempty"` // 完整修改链
@@ -119,6 +125,16 @@ type MemoryRecord struct {
 	ValidFrom  string `json:"valid_from,omitempty"`
 	ValidTo    string `json:"valid_to,omitempty"`
 	Provenance string `json:"provenance,omitempty"`
+	// 2026-11-07 (t_88cc9cb8) 意图 TTL（Hy-Memory L7 INTENTION / 遗忘研究「有效期而非删除」）：
+	// 时间敏感事实带有效期，到期【降级】而非删除。
+	//   Category="intention" + ExpiresAt（RFC3339；空 = 永久有效）
+	// 读路径判据：门控开且 category=intention 且 ExpiresAt<now ⇒ 召回排序降到最低档
+	//   （仍在结果里，non-lossy）。关态（ZHIYI_INTENTION_TTL≠1）行为逐位不变。
+	// 与 ValidTo 的分工：ValidTo 是 bi-temporal 语义终点（到期不入 top-k，
+	//   ZHIYI_BITEMPORAL 门控）；ExpiresAt 是意图生命周期（到期只降档，本卡新增）。
+	// 存量行缺省空串（等同永久有效）。五层落盘纪律：Go model/IPC + Rust struct/schema/
+	//   builder/读侧，缺一层 = 静默丢字段（t_3ada332b 事故同款）。
+	ExpiresAt string `json:"expires_at,omitempty"`
 }
 
 // HitEvent 真实 outcome 的 append-only 事件（GA-P0-4 t_bb10e8bc）。
@@ -191,7 +207,37 @@ type RecallResult struct {
 	// 2026-10-13 时间维检索（t_e9a4d18f P0）：该条目是否可能过期。
 	// 仅当 stale 标记开启（ZHIYI_STALE_AFTER_HOURS>0）且 updated_at 超期时为 true；
 	// 默认关闭 ⇒ 恒 false 且 omitempty 不输出 ⇒ 行为零变化（向后兼容）。
+	// 2026-10-26（t_contract_p0）：默认阈值改为 720h（30 天）——**只做展示标记，
+	// 不参与排序**（排序侧的有效期判据走 valid_to，见 ValidTo）；环境变量仍可覆盖/关闭。
 	Stale bool `json:"stale,omitempty"`
+	// 2026-10-26（t_trace_p0）：本条结果的来源通道（vector|fts|graph|shared|wiki|
+	// standing|pattern|peer）。此前「为什么被召回」不可答，调参只能盲修（CS249r Ch14）。
+	Channel string `json:"channel,omitempty"`
+	// 2026-10-26（P1 supersede 读侧暴露）：版本与取代关系。
+	// 写入侧一直有 supersedes / superseded_by / valid_from / valid_to / version，
+	// 但 RecallResult 不带出 ⇒ 读侧永远看不见「这条已被谁取代 / 是否过期」。
+	// 存量行零值（Version=0=未记录版本），omitempty 保持旧响应兼容。
+	Version      int      `json:"generation,omitempty"`    // 记忆版本号（DB version 列，语义=第几代）
+	ValidFrom    string   `json:"valid_from,omitempty"`    // 语义有效期起点（RFC3339，空=永久）
+	ValidTo      string   `json:"valid_to,omitempty"`      // 语义有效期终点（空=永久）
+	Supersedes   []string `json:"supersedes,omitempty"`    // 我取代了谁
+	SupersededBy []string `json:"superseded_by,omitempty"` // 我被谁取代（反向指针）
+	// Superseded 便捷布尔：SupersededBy 非空 ⇒ 已有更新版本存在（读侧一个字段可判）。
+	Superseded bool `json:"superseded,omitempty"`
+	// A10 (t_d618dc7c)：把「人工有用」单独计数直通给调用方。此前 RecallResult 缺它 ⇒
+	// 插件/调用方读不到（t_4c810e02「加列不接 IPC=静默 no-op」同款坑）。
+	// nil=该条从未被人工点过（库里 NULL）；非 nil=真实人工 useful 次数（NULL≠0）。
+	// 仅观测口径，不进排序（AC#6 排序零变化）。
+	HumanUsefulCount *int `json:"human_useful_count"`
+	// ─── 2026-10-31 方案二（因果类问答）─────────────────────────
+	// DerivedFrom：本条蒸馏记忆的原文 episode ID（库列 derived_from）。
+	// 实测 42.8% 有真指针、其中 99.9% 能找回原文 ⇒ 调用方可据此回溯完整上下文，
+	// 解决「只给 35 字结论、答不了为什么/怎么做」。空=无溯源（存量/legacy）。
+	DerivedFrom string `json:"derived_from,omitempty"`
+	// 2026-11-07 (t_88cc9cb8) 意图 TTL：把库列 expires_at 直通给调用方。
+	// 空 = 未声明/永久（存量）。仅观测口径 + AC 回环证据（"响应值==库值"），
+	// 排序效果由 intentionTtlEnabled() 门控的降档逻辑决定，与本字段展示无关。
+	ExpiresAt string `json:"expires_at,omitempty"`
 }
 
 // RerankResult rerank 重排后的单条结果。

go/internal/pattern/pattern.go

@@ -2,15 +2,18 @@
 //
 // 背景：MemOS 血统的 L2「跨任务重复模式」检测。原实现活在 Python daemon 的
 // main_loop（30s tick），2026-09-24 为 state-db 写安全整体退役后 L2 pattern 蒸馏
-// 停摆（graph_nodes type='pattern' 停在 85 个 / 2026-09-18）。本包把 L1→L2 蒸馏
+// 停摆（graph_nodes type='pattern' 停为 0 行；旧 Python daemon 残留的 85 行是
+// type='pattern_stat'，id 全 NULL、语义为 L1 命名空间统计快照，非 L2 pattern / 2026-09-18）。本包把 L1→L2 蒸馏
 // 复活成**短命单发**（modernc sqlite 直连 graph.db，开/关不占长连接，不碰 state.db），
 // 并按设计 §4.1 叠加两条检测规则：
-//   - 工具组合频率：同一 tool 组合出现 ≥3 次 → tool_combo pattern
-//     （confidence = min(freq*0.1, 1.0)）
+//   - 工具组合频率：同一 tool 组合（成员 ∈ knownTools 白名单、≥2 成员、排除通用词）
+//     被 ≥2 条独立来源记忆支撑 → tool_combo pattern（confidence = min(freq*0.1, 1.0)）；
+//     落库另需 confidence ≥ MinWriteConfidence=0.5（判据收紧史见 t_639c5a03）
 //   - 相似解决路径聚类：cosine ≥0.85 成簇且簇内 ≥3 条 → workflow pattern
 //
-// 存储：复用现有 graph_nodes(type='pattern')，**不另开新表**（避免与 85 存量 + 现有
-// 图谱查询割裂）。namespace='daemon-distill' 沿用旧 daemon 约定。
+// 存储：复用现有 graph_nodes(type='pattern')，**不另开新表**（避免与现存图谱查询割裂；
+// 表内另有 85 行 type='pattern_stat' 属旧 daemon 统计快照，与 L2 pattern 无关）。
+// namespace='daemon-distill' 沿用旧 daemon 约定。
 package pattern
 
 import (
@@ -35,37 +38,102 @@ type Pattern struct {
 
 // Config 检测参数（设计 §4.1）。
 type Config struct {
-	MinComboFreq    int     // 工具组合出现 ≥ N 次才产 pattern（默认 3）
+	MinComboFreq    int     // 工具组合需 ≥ N 条**独立来源记忆**才产 pattern（默认 2，t_639c5a03 门槛）
 	ClusterThresh   float64 // 相似路径聚类 cosine 阈值（默认 0.85）
 	MinClusterSize  int     // 簇内 ≥ N 条才产 workflow pattern（默认 3）
 	MaxRecords      int     // 单次扫描参与检测的记忆上限（防 O(n²) 爆炸，默认 500）
 	TopKPatternList int     // 召回/列出取前 N（默认 10）
+	// WorkflowPatterns 是否启用「相似解决路径聚类」workflow 分支。
+	// t_639c5a03 三审（小怡 2026-10-30）后决定**默认退役**：该分支把簇内最长记忆正文当
+	// Data（truncate 120 字），在自然语言语料上产出即「整句记忆正文 conf=1.0」的伪 pattern，
+	// 违反「不许把记忆正文当 pattern name」硬约束。通道退役，默认关闭；仅当显式开启才跑。
+	WorkflowPatterns bool
 }
 
-// DefaultConfig 设计参数。
+// DefaultConfig 设计参数。WorkflowPatterns 默认 false = workflow 分支退役（t_639c5a03 三审）。
 func DefaultConfig() Config {
 	return Config{
-		MinComboFreq:    3,
-		ClusterThresh:   0.85,
-		MinClusterSize:  3,
-		MaxRecords:      500,
-		TopKPatternList: 10,
+		MinComboFreq:     2,
+		ClusterThresh:    0.85,
+		MinClusterSize:   3,
+		MaxRecords:       500,
+		TopKPatternList:  10,
+		WorkflowPatterns: false,
 	}
 }
 
-// knownTools 常见工具/CLI/命令名（小写）。工具组合频率分析从这里识别 + 兜底正则。
+// MinWriteConfidence 落库置信度门槛（小怡二轮裁定 #5，2026-10-30）：conf<0.5 一律不写库。
+// tool_combo 的 conf=来源数×0.1 ⇒ 实际要求 ≥5 条独立来源；workflow 簇需平均相似度 ≥0.5。
+const MinWriteConfidence = 0.5
+
+// knownTools 真实命令/CLI 名（小写）白名单 —— tool_combo 成员的**唯一**来源。
+// t_639c5a03 二轮（小怡 2026-10-30 裁定）：原"含 -/数字即可"的命令式标识兜底放行是
+// hash 片段（374b20f98c44/ac10）、目录名（05-ai-agent）、文件名（dispatch-backlog.jsonl）、
+// CVE/协议碎片（cve-2026-99999/ipv4）的进入路径，已整体移除；白名单外一律不进组合键。
+// 同时移除过于通用的条目（git/go/curl/grep/cat/ls/find/…，见 genericTools）。
+// 新增工具 = 改这张表（可审计），不再靠形态猜测。
 var knownTools = map[string]bool{
-	"jq": true, "yq": true, "git": true, "grep": true, "sed": true, "awk": true,
-	"curl": true, "wget": true, "tar": true, "zip": true, "unzip": true,
+	"jq": true, "yq": true, "sed": true, "awk": true,
+	"wget": true, "tar": true, "zip": true, "unzip": true,
 	"docker": true, "kubectl": true, "helm": true, "npm": true, "pip": true,
-	"go": true, "python": true, "python3": true, "node": true, "pnpm": true,
+	"python": true, "python3": true, "node": true, "pnpm": true,
 	"make": true, "cmake": true, "gcc": true, "gcc-12": true, "clang": true,
 	"sqlite3": true, "psql": true, "mysql": true, "redis-cli": true,
 	"ssh": true, "scp": true, "rsync": true, "systemctl": true, "journalctl": true,
-	"systemd-run": true, "crontab": true, "find": true, "rg": true, "ripgrep": true,
-	"fd": true, "fzf": true, "gh": true, "gcloud": true, "aws": true, "jq2": true,
-	"hermes": true, "zhiyi": true, "obsidian": true, "esbuild": true, "ts": true,
+	"systemd-run": true, "crontab": true, "rg": true, "ripgrep": true,
+	"fd": true, "fzf": true, "gh": true, "gcloud": true, "aws": true,
+	"hermes": true, "zhiyi": true, "obsidian": true, "esbuild": true,
 	"tsc": true, "cargo": true, "rustc": true, "swift": true, "brew": true,
+	"bash": true, "sh": true, "zsh": true, "openssl": true,
+	"flock": true, "nc": true,
+	"java": true, "javac": true, "mvn": true, "gradle": true, "dotnet": true,
+	"remotion": true, "uv": true, "pytest": true, "gofmt": true, "golangci-lint": true,
+}
+
+// genericTools 过于通用的词/命令（小怡二轮裁定 #4 点名 git/go/curl/grep/bot-chat/mcp/api「等」）：
+// 几乎任何任务都命中 ⇒ 进 pattern 等于往召回 top-3 灌噪声。即使形态合格也**绝不**作为组合成员。
+// md/json/py/api/log/db 等亦在 toolStopwords 覆盖内，这里重复登记作双保险。
+// 后半段是 shell 基础词（cat/ls/find/…，「等」的裁量延伸：与 git 同级别的散文高频词）。
+var genericTools = map[string]bool{
+	"git": true, "go": true, "curl": true, "grep": true, "bot-chat": true,
+	"mcp": true, "api": true, "md": true, "json": true, "py": true,
+	"cat": true, "ls": true, "cp": true, "mv": true, "rm": true, "mkdir": true,
+	"head": true, "tail": true, "sort": true, "uniq": true, "wc": true, "find": true,
+	"xargs": true, "kill": true, "ps": true, "chmod": true, "touch": true,
+	"diff": true, "echo": true, "ping": true, "lsof": true, "tar": true,
+}
+
+// commonExts 常见文件扩展名（小写，含点）。token 以此结尾 ⇒ 文件名/扩展名，不是工具。
+var commonExts = map[string]bool{
+	".md": true, ".go": true, ".json": true, ".py": true, ".js": true, ".ts": true,
+	".tsx": true, ".jsx": true, ".yaml": true, ".yml": true, ".toml": true, ".sh": true,
+	".db": true, ".sql": true, ".csv": true, ".log": true, ".txt": true, ".html": true,
+	".css": true, ".rs": true, ".c": true, ".h": true, ".cpp": true, ".conf": true,
+	".xml": true, ".ini": true, ".env": true, ".pdf": true, ".png": true, ".jpg": true,
+	".jpeg": true, ".svg": true, ".gif": true, ".ipynb": true, ".lock": true, ".sum": true,
+	".bak": true, ".tmp": true, ".gz": true, ".mp4": true, ".mp3": true, ".docx": true,
+	".xlsx": true, ".pptx": true, ".service": true, ".sock": true, ".socket": true,
+}
+
+// toolStopwords 常见停用词（小写）：高频非工具词，绝不作为工具名（卡要求第 1 条）。
+var toolStopwords = map[string]bool{
+	"the": true, "and": true, "for": true, "with": true, "that": true, "this": true,
+	"from": true, "into": true, "then": true, "when": true, "what": true, "they": true,
+	"have": true, "will": true, "your": true, "not": true, "but": true, "all": true,
+	"can": true, "use": true, "via": true, "per": true, "are": true, "was": true,
+	"one": true, "two": true, "ok": true, "yes": true, "true": true, "false": true,
+	"null": true, "none": true, "etc": true, "vs": true, "id": true, "ids": true,
+	"ns": true, "log": true, "logs": true, "file": true, "files": true, "path": true,
+	"line": true, "lines": true, "name": true, "type": true, "data": true, "time": true,
+	"date": true, "test": true, "note": true, "step": true, "steps": true, "first": true,
+	"last": true, "next": true, "top": true, "api": true, "http": true, "https": true,
+	"url": true, "uri": true, "json": true, "yaml": true, "yml": true, "md": true,
+	"txt": true, "tmp": true, "dev": true, "prod": true, "src": true, "doc": true,
+	"docs": true, "ref": true, "config": true, "default": true, "error": true,
+	"errors": true, "warn": true, "info": true, "debug": true, "fail": true,
+	"failed": true, "success": true, "start": true, "stop": true, "check": true,
+	"list": true, "get": true, "set": true, "new": true, "old": true, "fix": true,
+	"pr": true, "mr": true, "db": true,
 }
 
 // DetectFromRecords 纯检测核心：从 L1 记忆列表发现重复模式。
@@ -73,7 +141,7 @@ var knownTools = map[string]bool{
 // 返回合并去重后的 pattern 列表（同 Name 合并 source_tasks、取更高 confidence）。
 func DetectFromRecords(records []models.MemoryRecord, cfg Config) []Pattern {
 	if cfg.MinComboFreq <= 0 {
-		cfg.MinComboFreq = 3
+		cfg.MinComboFreq = 2
 	}
 	if cfg.MinClusterSize <= 0 {
 		cfg.MinClusterSize = 3
@@ -127,21 +195,36 @@ func DetectFromRecords(records []models.MemoryRecord, cfg Config) []Pattern {
 		c.tasks = append(c.tasks, rec.ID)
 	}
 	for name, c := range comboCount {
-		if len(c.tasks) < cfg.MinComboFreq {
+		// 二轮：「组合」语义 —— 单工具无共现信息量，≥2 个成员才产 tool_combo。
+		if len(c.tools) < 2 {
+			continue
+		}
+		// t_639c5a03 门槛：支撑数按**独立来源记忆**（去重且非空 ID）计，< MinComboFreq 直接丢。
+		seen := map[string]bool{}
+		var sources []string
+		for _, id := range c.tasks {
+			if id != "" && !seen[id] {
+				seen[id] = true
+				sources = append(sources, id)
+			}
+		}
+		if len(sources) < cfg.MinComboFreq {
 			continue
 		}
 		merge(Pattern{
-			Type:       "tool_combo",
-			Name:       name,
-			Data:       strings.Join(c.tools, "+"),
-			Tools:      c.tools,
-			Confidence: confidenceFromFreq(len(c.tasks)),
-			SourceTasks: c.tasks,
+			Type:        "tool_combo",
+			Name:        name,
+			Data:        strings.Join(c.tools, "+"),
+			Tools:       c.tools,
+			Confidence:  confidenceFromFreq(len(sources)),
+			SourceTasks: sources,
 		})
 	}
 
 	// 2. 相似解决路径聚类（cosine ≥ 阈值 成簇，簇内 ≥ N 条）
-	paths := clusterPaths(records, cfg.ClusterThresh, cfg.MinClusterSize)
+	// t_639c5a03 三审：该分支把记忆正文当 pattern Data（整句注入），默认退役；仅 cfg.WorkflowPatterns 显式开启才跑。
+	if cfg.WorkflowPatterns {
+		paths := clusterPaths(records, cfg.ClusterThresh, cfg.MinClusterSize)
 	for _, cluster := range paths {
 		// 代表路径 = 簇内最长 content（共同步骤近似）
 		rep := ""
@@ -166,6 +249,17 @@ func DetectFromRecords(records []models.MemoryRecord, cfg Config) []Pattern {
 			SourceTasks: ids,
 		})
 	}
+	}
+
+	// 3. 任务型：诊断 → 修复 → 复验 位置有序序列（t_751a6739，与 tool_combo 并列）
+	for _, p := range detectTaskSeq(records) {
+		merge(p)
+	}
+
+	// 4. 纪律型：触发动作 + 前/先 + 约束动作（t_751a6739，与 tool_combo 并列）
+	for _, p := range detectDiscipline(records) {
+		merge(p)
+	}
 
 	out := make([]Pattern, 0, len(order))
 	for _, n := range order {
@@ -196,6 +290,103 @@ func confidenceFromFreq(freq int) float64 {
 	return c
 }
 
+// isNumericUnitFragment 数值+单位碎片（小怡二轮裁定 #2）：^\d+(\.\d+)?(mb|kb|gb|tb|ms|ns|us|s|m|h|x|%)?$
+// 例："2.6mb"、"512kb"、"100ms"、"3x"。纯数字无单位形态由 isNumericFragment 拦截，这里不重复依赖它。
+func isNumericUnitFragment(tok string) bool {
+	i := 0
+	for i < len(tok) && tok[i] >= '0' && tok[i] <= '9' {
+		i++
+	}
+	if i == 0 {
+		return false // 无数字前缀 ⇒ 不是该形态
+	}
+	if i < len(tok) && tok[i] == '.' {
+		j := i + 1
+		for j < len(tok) && tok[j] >= '0' && tok[j] <= '9' {
+			j++
+		}
+		if j == i+1 {
+			return false // '.' 后无数字 ⇒ 不是该形态
+		}
+		i = j
+	}
+	switch strings.ToLower(tok[i:]) {
+	case "":
+		return true // 纯数字
+	case "mb", "kb", "gb", "tb", "ms", "ns", "us", "s", "m", "h", "x", "%":
+		return true
+	}
+	return false
+}
+
+// isHexOnly token 是否只由 [0-9a-f] 构成（非空）。
+func isHexOnly(s string) bool {
+	if s == "" {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) {
+			return false
+		}
+	}
+	return true
+}
+
+// isHashFragment hash/uuid 碎片（小怡二轮裁定 #1）：
+//   - 纯 [0-9a-f] 且 len≥6 ⇒ hash 片段（374b20f98c44 / b713b48a70ad / 635dccc0）；
+//   - 纯 [0-9a-f] 且 len≥4 且含数字 ⇒ 短 hash（ac10）；'cafe'/'beef' 类纯字母词放行；
+//   - 形如 <hex≥2>-<hex≥2> 前缀 ⇒ uuid 段（^[0-9a-f]{2,}-[0-9a-f]{2,}，如 b713-48a7）。
+//     'gcc-12'（gcc 非 hex）、'redis-cli'（r 非 hex）不受影响。
+func isHashFragment(tok string) bool {
+	if idx := strings.IndexByte(tok, '-'); idx > 0 {
+		head, rest := tok[:idx], tok[idx+1:]
+		tail := rest
+		if k := strings.IndexByte(rest, '-'); k >= 0 {
+			tail = rest[:k]
+		}
+		if len(head) >= 2 && isHexOnly(head) && len(tail) >= 2 && isHexOnly(tail) {
+			return true
+		}
+	}
+	if !isHexOnly(tok) {
+		return false
+	}
+	if len(tok) >= 6 {
+		return true
+	}
+	return len(tok) >= 4 && strings.ContainsAny(tok, "0123456789")
+}
+
+// isNumberedDirName 数字编号目录名（小怡二轮裁定 #3）：^\d+(-[a-z]+)+$
+// 例："05-ai-agent"、"38-patternfix"。"gcc-12"（首段非数字）不受影响。
+func isNumberedDirName(tok string) bool {
+	parts := strings.Split(tok, "-")
+	if len(parts) < 2 {
+		return false
+	}
+	first := parts[0]
+	if first == "" {
+		return false
+	}
+	for i := 0; i < len(first); i++ {
+		if first[i] < '0' || first[i] > '9' {
+			return false // 首段非纯数字
+		}
+	}
+	for _, seg := range parts[1:] {
+		if seg == "" {
+			return false
+		}
+		for i := 0; i < len(seg); i++ {
+			if seg[i] < 'a' || seg[i] > 'z' {
+				return false // 某段含数字/非法字符
+			}
+		}
+	}
+	return true
+}
+
 // clusterPaths 贪心成簇：为每条未分配记忆开一个簇，把与其 cosine≥阈值 的其余未分配
 // 记忆并入；最终只保留 size≥minSize 的簇。向量缺失时用记录自带 Vector，全缺则退到
 // 文本 bigram Jaccard（确定性，不依赖网络）。
@@ -274,35 +465,104 @@ func clusterConfidence(cluster []models.MemoryRecord) float64 {
 	return sum / float64(pairs)
 }
 
-// ExtractTools 从记忆内容提取工具/命令名。识别 knownTools + 兜底 ascii token。
+// ExtractTools 从记忆内容提取工具/命令名（t_639c5a03 二轮：白名单唯一来源）。
+// 判据（卡·必须实现 #1「来自 tool_use 记录或白名单」+ 小怡二轮"更硬判据"取向）：
+// 成员必须**命中 knownTools 白名单**（词边界），且过 isValidTool 形态闸（通用词黑名单、
+// hash/uuid 片段、数值+单位、数字编号目录名、扩展名、日期/版本片段、停用词等）。
+//
+// 旧实现的"命令式标识"兜底（白名单外、含 -/数字即放行）是二轮 dry-run 里
+// hash 片段（374b20f98c44/ac10）、目录名（05-ai-agent）、文件名（dispatch-backlog.jsonl）、
+// CVE/协议碎片（cve-2026-99999/ipv4）的进入路径，已整体移除。
 // 确定性：结果排序去重。
 func ExtractTools(content string) []string {
-	found := map[string]bool{}
 	lower := strings.ToLower(content)
+	out := make([]string, 0, 4)
 	for t := range knownTools {
 		// 词边界匹配（避免 "go" 命中 "google"）
-		if tokenPresent(lower, t) {
-			found[t] = true
+		if isValidTool(t) && tokenPresent(lower, t) {
+			out = append(out, t)
 		}
 	}
-	// 兜底：捕获已知列表外的 ascii 命令式 token（2~14 字符，含 - 的命令风格）
-	for _, tok := range regexTokenExtract(content) {
-		lt := strings.ToLower(tok)
-		if len(lt) < 2 {
-			continue
-		}
-		// 排除明显非工具的常见词（纯小写短词且不在 knownTools 的放行——保持宽松，
-		// 让工具组合信号进来；过噪由 MinComboFreq 过滤）
-		found[lt] = true
-	}
-	out := make([]string, 0, len(found))
-	for t := range found {
-		out = append(out, t)
-	}
 	sort.Strings(out)
 	return out
 }
 
+// isValidTool token 形态判据（lowercase）：是否为真实命令/工具标识的形状。
+// 排除：长度 <2 或 >32；含 '/'、'\\'、'_'（路径、usage_track 键、t_9143c968 任务 ID）；
+// 以 '.' 开头（".md"）；无字母（纯数字/纯标点/数字+分隔符）；以常见扩展名结尾
+// （report.md / a.py）；数字/日期/版本片段（2026、2026-09-23、2026+23、09:23、1.2.3、v1.2.3）；
+// 停用词。
+func isValidTool(tok string) bool {
+	if len(tok) < 2 || len(tok) > 32 {
+		return false
+	}
+	if genericTools[tok] {
+		return false // 通用词黑名单（二轮 #4）
+	}
+	if strings.ContainsAny(tok, `/_\`) {
+		return false
+	}
+	if tok[0] == '.' || tok[0] == '-' {
+		return false // 隐藏文件 / CLI flag
+	}
+	hasLetter := false
+	for i := 0; i < len(tok); i++ {
+		if c := tok[i]; (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') {
+			hasLetter = true
+			break
+		}
+	}
+	if !hasLetter {
+		return false
+	}
+	if i := strings.LastIndexByte(tok, '.'); i > 0 && commonExts[tok[i:]] {
+		return false
+	}
+	if isNumericFragment(tok) {
+		return false
+	}
+	if isNumericUnitFragment(tok) {
+		return false // 二轮 #2：2.6mb / 512kb / 100ms
+	}
+	if isHashFragment(tok) {
+		return false // 二轮 #1：374b20f98c44 / ac10 / uuid 片段
+	}
+	if isNumberedDirName(tok) {
+		return false // 二轮 #3：05-ai-agent / 38-patternfix
+	}
+	if toolStopwords[tok] {
+		return false
+	}
+	return true
+}
+
+// isNumericFragment 纯数字 / 日期 / 时间 / 版本片段：
+//   - 只由数字与分隔符 [-+:./] 组成（"2026"、"2026-09-23"、"2026+23"、"09:23"、"1.2.3"），或
+//   - 至多一个前导字母 + 其余全为数字/分隔符（"v1.2.3"、"v2"）。
+//
+// "gcc-12"/"sqlite3" 这类字母出现在数字之前且不止前导一个 ⇒ 正常标识，返回 false。
+func isNumericFragment(tok string) bool {
+	if tok == "" {
+		return false
+	}
+	seenDigit := false
+	rest := tok
+	if c := rest[0]; (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') {
+		rest = rest[1:] // 至多剥一个前导字母
+	}
+	for _, r := range rest {
+		switch {
+		case r >= '0' && r <= '9':
+			seenDigit = true
+		case r == '-' || r == '+' || r == ':' || r == '.' || r == '/':
+			// 分隔符放行
+		default:
+			return false // 还有别的字母/字符 ⇒ 不是纯数字片段
+		}
+	}
+	return seenDigit
+}
+
 // tokenPresent 检查 lower 文本中 t 是否作为独立 token 出现（词边界，避免 "go" 命中 "google"）。
 func tokenPresent(lower, t string) bool {
 	if t == "" {
@@ -323,30 +583,6 @@ func tokenPresent(lower, t string) bool {
 	return false
 }
 
-// regexTokenExtract 轻量 token 抽取（无正则依赖，按字符切）：
-// 返回形如命令/token 的 ascii 串（长度 ≥2，含字母，可能带数字/_.-）。
-func regexTokenExtract(content string) []string {
-	var out []string
-	var cur []rune
-	flush := func() {
-		if len(cur) >= 2 {
-			out = append(out, string(cur))
-		}
-		cur = nil
-	}
-	for _, r := range content {
-		isTok := (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
-			(r >= '0' && r <= '9') || r == '_' || r == '-' || r == '.'
-		if isTok {
-			cur = append(cur, r)
-		} else {
-			flush()
-		}
-	}
-	flush()
-	return out
-}
-
 func dedupeSorted(in []string) []string {
 	seen := map[string]bool{}
 	out := make([]string, 0, len(in))
@@ -447,3 +683,53 @@ func truncateForPattern(s string, n int) string {
 	}
 	return string(r[:n]) + "…"
 }
+
+// IsValidPatternName pattern 命名键合法性闸门（t_639c5a03，写入前最后防线）。
+// 合法形态：
+//   - tool_combo:<valid-tool>(+<valid-tool>)*  —— 每个成员过 isValidTool
+//   - workflow:cluster-<N>-<fingerprint>
+//
+// 其余（"tool_combo:.md"、"tool_combo:2026+23" 等垃圾键）一律拒绝，
+// UpsertPatterns 拒写 —— 即使调用方判据再退化，垃圾也进不了 graph_nodes。
+func IsValidPatternName(name string) bool {
+	i := strings.IndexByte(name, ':')
+	if i <= 0 {
+		return false
+	}
+	body := name[i+1:]
+	if body == "" {
+		return false
+	}
+	switch name[:i] {
+	case "tool_combo":
+		parts := strings.Split(body, "+")
+		if len(parts) < 2 {
+			return false // 「组合」语义：单成员键拒写（二轮）
+		}
+		for _, t := range parts {
+			// 写入闸 = 白名单唯一来源 + 形态检查（通用词/hash/数值/目录碎片黑名单）。
+			if !knownTools[t] || !isValidTool(t) {
+				return false
+			}
+		}
+		return true
+	case "workflow":
+		return strings.HasPrefix(body, "cluster-")
+	case "task_seq":
+		// t_751a6739：固定模板键（含动作序列，不含记忆正文）
+		return body == "诊断>修复>复验"
+	case "discipline":
+		// t_751a6739：两种形态——"*先D"（按约束动作聚合）或"<T>先<D>"（触发×约束）
+		if strings.HasPrefix(body, "*先") {
+			return body != "*先" && !strings.Contains(strings.TrimPrefix(body, "*先"), "先")
+		}
+		// <T>先<D>：T 是触发类名，D 是约束类名
+		i := strings.Index(body, "先")
+		if i <= 0 || i == len(body)-1 {
+			return false
+		}
+		t, d := body[:i], body[i+len("先"):]
+		return triggerClassValid(t) && discActionValid(d)
+	}
+	return false
+}