feiyu-memory 4.0.2 → 4.1.0

package/CHANGELOG.md

@@ -1,4 +1,97 @@
-# 更新日志
+# 更新日志
+
+## v4.1.0 — 2026-11-02
+
+> **召回换了一条完全不同的路：从「让模型挑 2 条摘要」改成「BM25 直接给一批正文」。**
+> 起因是一句反问：「都这样了为什么不直接对日记本体做 BM25？」
+> —— 试了，他对，而且一改就把前面两套方案全作废了。
+
+### 索引改吃正文
+
+原来是「索引只吃 summary」。这有一个**结构性的洞**，实测抓到了：
+
+```
+d_20261030_22 的摘要   boot.log 13:20 apply+routes·5次剩3次·插件顺序错·已关
+同一张的正文           ……后来他说项目失败了，事先准备不足。我说是失败了，但问题不在代码，在顺序……
+```
+
+摘要是**当天写的术语**，人问往事用的是**事后想起来的话**。两套词表，字面永远撞不上。
+
+实测（480 条真实日记）：
+
+```
+              摘要索引          正文索引
+项目失败了     未命中       →    第 1 名 1.000
+事先准备不足   未命中       →    第 1 名 1.000
+吃了睡睡了吃   「早饭吃了没」 →    1.000 正确那条
+煮饭           空           →    0.967
+那事搞砸了     0 命中       →    4 条
+```
+
+代价只有建索引变重（32ms → 94ms），**检索本身一点没变慢**，而且它是纯 CPU，
+一个 token 都不花。摘要**没有删** —— 它带着别名和梗称（「边缘行者2 / 续集 / 那部动画」），
+正文不一定写全。两边都吃。
+
+### 自动注入：不再让模型挑
+
+原来每轮自动注入走 `selectMemories`（挑 1~2 条 + salience/冷却/走神掷骰子），
+而 `feiyu_recall` 走一次模型调用（480 行索引、约 1.6 万 token、全价）。
+
+量出来的两件事：
+
+```
+① 那次「模型挑」的调用，跟一整轮聊天一样贵
+② 它读的是摘要，而摘要会漏掉上面那半句 —— 挑得再认真也没用
+```
+
+现在自动注入直接拿 BM25 的 top 结果，**完整正文**，不经过模型。
+
+### 但光给 top-N 会吵 —— 加一道相对门槛
+
+实测查「项目失败了」，按 15 条取有 12 条命中：
+
+```
+第 1 名  1.00  那个失败的项目（对）
+第 2 名  0.96  欢乐谷小时候没玩刺激项目（错，只撞上「项目」两个字）
+第 3-12       气泡卡没、赛博朋克、0.1.8 发布……（全无关）
+```
+
+12 条 = 5412 token，八成是垃圾。**多给不等于不漏，只等于更吵。**
+
+所以加了 `recallScoreRatio`（默认 0.85）：只留分数 ≥ 最高分 × 0.85 的。
+用相对值而不是固定分数线，是因为相似度是饱和函数，绝对刻度会随查询长短漂移 ——
+长问句最高才 0.7，短词全在 0.99，固定门槛要么全砍要么全留。
+
+```
+项目失败了     12 条 / 5412 token  →  5 条 / 2744
+八条鱼论战     ——                  →  5 条，前几名全对（门槛没误伤）
+落枕           1 条                 →  1 条
+```
+
+### 去掉「静默截到最近 400 条」
+
+`pickBySummary` 里原来有一行 `base.slice(-400)`。480 条时已经**悄悄丢了 80 条**，
+而且只写一行 log —— 用户永远看不到自己的记忆在少。
+
+上限提到 1200，而且超了会 `warn` 而不是 `log`。真要涨到过千条，
+该做的是分层（按天/按月），不是继续截尾巴。
+
+### 配置默认值变了
+
+| 项 | 旧 | 新 | 为什么 |
+|---|---|---|---|
+| `budgetTokens` | 3000 | **6000** | 召回那栏从「2 条摘要」变成「一批正文」，3000 装不下会被整段裁掉 |
+| `recentEntries` | 8 | **3** | 它只在新会话首轮/压缩后重灌，平时不占地方；3 条够交代上下文 |
+| `recallFanout` | — | **15** | 新增。按相似度最多捞几条正文进注入 |
+| `recallScoreRatio` | — | **0.85** | 新增。相对门槛，只留分数接近最高分的 |
+
+### 顺手改的
+
+- `tools/preview-memory.mjs` 原来调的是旧的 `selectMemories` —— **预览出来的就不再是线上会看到的东西**，
+  而那个工具的全部价值就在"跟真的一样"。已同步。
+- 测试 321 → 328（新增 7 条覆盖正文索引、相对门槛、`renderRecalled` 的条数上限）。
+
+---
 
 ## v4.0.2 — 2026-10-29
 

package/README.md

@@ -294,7 +294,7 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 | `dataDir` | `''` | 档案目录，留空 = `~/.dsh/feiyu-diary`。想放同步盘就写绝对路径 |
 | `enabled` | `true` | 总开关 |
 | `includePersona` | `true` | 是否把人格内核一起注入。**装了别的人设插件就关掉它** |
-| `budgetTokens` | `3000` | 注入预算封顶 |
+| `budgetTokens` | `6000` | 注入预算封顶。4.1 提到 6000：召回那栏从「2 条摘要」变成「一批正文」，3000 装不下会被整段裁掉 |
 | `model` | `''` | 固化用模型，留空 = 跟随当前默认模型 |
 | `reasoningEffort` | `off` | **固化的思考档位。保持 `off`** —— 它故意不跟随你聊天时选的档位，见下方说明 |
 | `maxTokens` | `900` | 固化最大输出 |
@@ -302,7 +302,9 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 | `amountThreshold` | `100` | 低于此值的金额不动（"3 块钱的包子"要留着） |
 | `minSalience` | `0.15` | 日记重要度门槛。**调高 = 记性变挑，但寒暄和试错也会被扔掉** |
 | `highSim` | `0.5` | 相似度超过就必定提起那件旧事 |
-| `recentEntries` | `8` | 「最近的事」最多列几条。**不走相似度，永远在场** |
+| `recentEntries` | `3` | 「最近的事」最多列几条。**不走相似度，永远在场** |
+| `recallFanout` | `15` | 按相似度最多捞几条**完整正文**进注入（`0` = 只留最近的事） |
+| `recallScoreRatio` | `0.85` | 召回门槛：只留分数 ≥ 最高分 × 此值的。**越低给得越多，也越吵** |
 | `maxShowPerTurn` | `4` | 「突然想起来」最多几条（`0` = 不主动提旧事） |
 
 > **`reasoningEffort` 为什么默认 `off`，而不是跟随你的聊天设置**
@@ -392,8 +394,28 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 `feiyu_recall` 怎么挑：把那句话 + **全部 summary**（带日期）发给模型，让它挑出至多 3 条正文。
 **不按字面匹配** —— 换个说法也能撞上，因为模型读的是意思，不是字。
 
-实测（358 条档案）：一次挑取 **13039 token，其中 12800 命中缓存（98%）**，约 0.16 分钱。
-所以 prompt 里**索引在前、问题在最后** —— 缓存按前缀匹配，顺序写反就等于每轮全价。
+### 小保底那条路：BM25 直接给正文（4.1 改）
+
+每轮自动注入那一栏原来走 `selectMemories`：挑 1~2 条，还要跟 salience、冷却、
+走神一起掷骰子。**4.1 改成直接按 BM25 取一批完整正文灌进去。**
+
+三个理由，都是量出来的：
+
+```
+① 原来那次「模型挑」的调用跟一整轮聊天一样贵（都是全价，缓存命不中）
+② 它读的是 summary，而 summary 会漏 —— 「项目失败了」在正文里，摘要里一个字没有
+③ 范围大，就不怕 BM25 挑错：只给 2 条时它错一次就什么都想不起来
+```
+
+**但光给 top-N 会带进一堆噪音。** 实测查「项目失败了」，按 15 条取有 12 条命中，
+其中八成是只撞上「项目」两个字的无关日记。所以还有一道**相对门槛**：
+只留分数 ≥ 最高分 × 0.85 的（`recallScoreRatio`）。
+
+```
+查「项目失败了」   门槛前 12 条 / 5412 token   门槛后 5 条 / 2744 token
+查「八条鱼论战」   门槛后 5 条，前几名全对 —— 门槛不会误伤铺得开的查询
+查「那事搞砸了」   摘要索引 0 命中 → 正文索引 4 条（其中一条正是「是我搞砸了」）
+```
 
 ### 时间也进索引
 
@@ -415,8 +437,15 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 后者会被中文 bigram 的噪声顶爆分母，导致明显相关的日记只能拿 0.10 分，等于永远召不回。
 现在分数含义稳定：共享 1 个实词 ≈ 0.4，2 个 ≈ 0.67，无关 = 0，**且与查询长度解耦**。
 
-**索引只吃 summary，不吃正文，也没有单独的 keywords 字段。** 一条日记只有一个"检索表示"：
-字面匹配用它（小保底，便宜），模型读它（大保底，准）。
+**索引吃正文 + summary，没有单独的 keywords 字段。** 两边各有各的用处：
+
+```
+正文    人问往事用的是「项目失败了」「那事搞砸了」这种话，摘要里一个字都撞不上
+摘要    带着别名和梗称（边缘行者2 / 续集 / 那部动画），正文不一定写全
+```
+
+建索引从 32ms 涨到 177ms（一次性），**检索本身在 0.2ms 量级** —— 而且一个 token 都不花。
+索引只在档案变化时重建，不是每轮。
 
 ### 人格内核的三道护栏
 
@@ -450,7 +479,7 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 ## 开发
 
 ```bash
-node --test            # 321 项测试，零依赖
+node --test            # 330 项测试，零依赖
 npm run check          # 校验 cordis.patch.yml 结构
 npm run doctor         # 发版前体检
 npm run preview        # 把此刻注入给模型的内容打出来

package/cordis.patch.yml

@@ -8,6 +8,11 @@
 # 所有选项都可以在这里的 `config:` 里写。留空即用默认值。
 # 注意：**patch 的 config 是整体替换、不深合并**，所以只写你想改的键是安全的
 # （只有你自己这一行会读它；但如果你在 profile 里覆写这一行，就要把想保留的键写全）。
+#
+# ⚠️ **这里写的值会覆盖 `src/core/config.mjs` 里的 default。**
+# 改默认值时必须两处一起改，否则改了代码不生效 —— 2026-11-03 就栽在这上面：
+# 代码里把预算提到 6000，这里还写着 2000，结果召回那栏被整段裁掉，
+# 翻到的日记一条都送不到她眼前。
 
 - insert:
     - id: feiyu-memory
@@ -22,8 +27,11 @@
         # 我们只负责"我们之间发生过什么"，人设交给它们。
         includePersona: true
         # 注入预算（token）。成本封顶，与用了多久无关。
-        # 2000 是给"最近的事"留的位置 —— 日记要占大头，读起来才像日记。
-        budgetTokens: 2000
+        #
+        # 2000 → 6000（2026-11-03）。召回那栏从「最多 2 条摘要」改成「一批完整正文」，
+        # 一批约 4800 token，2000 根本装不下 —— 会被整段裁掉，
+        # 变成「她翻了，但什么都没送到」。
+        budgetTokens: 6000
         # 固化用模型。留空 = 跟随你当前的默认模型。
         # 强烈建议就用便宜档：这一步是结构化抽取，用贵的反而会自由发挥、把档案写花。
         model: ''
@@ -45,14 +53,23 @@
         # 调高 = 记性变挑；但注意**寒暄、试错、来回改口也会一起被扔掉** ——
         # 那些看着没信息量，却是"熟悉感"的原料。默认 0.15 是刻意留低的。
         minSalience: 0.15
-        # 相似度超过这个值就必定提起那件旧事
+        # ⚠️ 4.1 起**对自动注入不再生效**（那条路改成按分数门槛取了）。
+        # 字段留着不删：删了老配置里的值会被静默忽略。改它不会有任何反应。
         highSim: 0.5
-        # 「最近的事」最多列几条。这一栏**不走相似度，永远在场** ——
-        # 人不需要"想起来"昨天吃了什么，你知道。设 0 就关掉这一栏。
-        recentEntries: 8
-        # 「突然想起来」每轮最多几条（0 = 不主动提旧事）
+        # 「最近的事」最多列几条。这一栏**不走相似度**，只在新会话首轮/压缩后重灌。
+        # 8 → 3（2026-11-03）：平时它不占地方，3 条够交代"我们上次在干什么"，
+        # 省下的预算留给召回那栏。
+        recentEntries: 3
+        # 按相似度最多捞几条**完整正文**进注入（0 = 只留最近的事）。
+        # 这是上限，不是目标数 —— 实际条数由下面的 recallScoreRatio 决定。
+        recallFanout: 15
+        # 召回门槛：只留分数 ≥ 最高分 × 此值的。
+        # 越低给得越多，也越吵。0.85 砍过头了（查「南京」5 条全相关，只进 1 条），
+        # 提到 0.7。
+        recallScoreRatio: 0.7
+        # ⚠️ 4.1 起**不生效**。条数改由 recallFanout 控。
         maxShowPerTurn: 4
-        # 完全没匹配上时"走神"随机想起一条旧事的概率。这条纯粹为了像人。
+        # ⚠️ 4.1 起**不生效**。"走神"那一步已经没有掷骰子了。
         wanderChance: 0.08
         # 低峰时段（峰谷分时定价的谷时）。把 deferToOffPeak 打开后，
         # 日记会攒到这段时间才写 —— 更便宜，而且本来就更像人（睡前整理）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feiyu-memory",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "给 DeepSeek Harness 一条会记事的蓝色大肥鱼：跨会话的持久人格与日记。每轮结束后固化模型只回答一句「你想记什么」，写下的每条日记配一句十几二十字的索引；下一场对话注入人格、手记和最近的几条，想知道更早的事它自己调 feiyu_recall，插件读索引挑出相关的那几条，正文才进上下文——索引永远不进它的视野，所以它看到的是日子，不是检索结果。遗忘是降权而不是删除。全程本地、发送前先拦掉密钥，档案是一个可读可改、能换账号带走的普通文件夹。零运行时依赖，无构建步骤。",
   "type": "module",
   "license": "MIT",

package/src/core/config.mjs

@@ -48,13 +48,18 @@ export const CONFIG_SPEC = [
   {
     key: 'budgetTokens',
     type: 'number',
-    // 2000 → 3000。量过的：常驻段本身要 2680 token（「最近的事」八条占 1422），
-    // 2000 根本装不下，每次都裁 —— 「最近的事」只剩 2 条。3000 能给到 6 条。
-    // 代价约每轮 +1000 token ≈ 每句话多 0.06 分。
-    default: 3000,
+    // 2000 → 3000 → 6000。
+    //
+    // 2000 装不下常驻段（2680），「最近的事」只剩 2 条。
+    // 3000 能给到 6 条。
+    //
+    // 2026-11-02 提到 6000：召回那栏从「最多 2 条摘要」改成「最多 15 条正文」，
+    // 15 条正文实测约 4800 token，3000 根本装不下 —— 会被整段裁掉，
+    // 那这条鱼就一条旧事都想不起来，比改之前还差。
+    default: 6000,
     min: 200,
-    max: 8000,
-    step: 1,
+    max: 12000,
+    step: 100,
     label: '注入预算（token）',
   },
   {
@@ -108,17 +113,69 @@ export const CONFIG_SPEC = [
     min: 0,
     max: 1,
     step: 0.05,
-    label: '必触发的相似度阈值',
+    // ⚠️ 2026-11-02 之后**对自动注入不再生效**。
+    //
+    // 原来自动注入走 selectMemories，这道阈值决定"相似度多高就必定提起那件旧事"。
+    // 现在那条路改成 BM25 直接给一批正文，靠 `recallScoreRatio` 那道相对门槛，
+    // 这个绝对值就没有位置了。
+    //
+    // 字段保留不删：删了老配置里的值会被静默忽略（反而更坏），
+    // 而且 selectMemories 还在被测试和外部调用。**但界面上改它不会有任何效果。**
+    label: '必触发的相似度阈值（4.1 起对自动注入不生效，见 recallScoreRatio）',
   },
   {
     key: 'recentEntries',
     type: 'number',
-    default: 8,
+    // 8 → 3（2026-11-02）。它只在新会话第一轮和压缩之后整段重灌，
+    // 平时不占地方 —— 所以"8 条"其实大半时候没被读到。
+    // 3 条够交代"我们上次在干什么"，而且省下 1600 token 给召回那栏。
+    default: 3,
     min: 0,
     max: 30,
     step: 1,
     label: '「最近的事」最多列几条（不靠相似度，永远在场）',
   },
+  {
+    key: 'recallFanout',
+    type: 'number',
+    // ── 2026-11-02：召回从「模型挑 2 条」改成「BM25 直接给最多 15 条正文」──
+    //
+    // 原来走一次模型调用：480 行索引（约 1.6 万 token，全价）塞给模型挑 3 条。
+    // 实测那一次调用跟一整轮聊天一样贵，而更糟的是 —— **摘要索引会漏**。
+    //
+    // 现在改成：BM25 打在正文上（本地、免费、0.2ms），直接把这批完整正文
+    // 放进注入。省掉一次模型调用，也省掉"挑"这一步可能挑错的环节。
+    //
+    // 这是个**上限**，不是目标数。真正的条数由 `recallScoreRatio` 那道相对门槛决定 ——
+    // 实测按 15 条硬取，一大半是只撞上一个常用词的噪音。
+    default: 15,
+    min: 0,
+    max: 40,
+    step: 1,
+    label: '按相似度最多捞几条正文进注入（0 = 只留最近的事）',
+  },
+  {
+    key: 'recallScoreRatio',
+    type: 'number',
+    // 只留分数 ≥ 最高分 × 这个比例的条目。
+    //
+    // 为什么是相对值：相似度是饱和函数，绝对刻度会随查询长短漂移
+    // （长问句最高才 0.7，短词全在 0.99），固定分数线要么全砍要么全留。
+    //
+    // 0.85 → 0.70（2026-11-02 当天返工）。0.85 砍过头了：
+    // 查「南京」BM25 命中 5 条 —— 0.982 / 0.972 / 0.970 / 0.969 / 0.948，
+    // 五条全相关 —— 乘下来只剩 1 条进注入。
+    // **说好给一批旧事，实际给一条，比改之前的 2 条还差。**
+    //
+    // 分布是不稳的：有的查询第 5 名还有 0.86，有的第 2 名就断了。
+    // 固定比例猜不准分布，宁可往宽了给 ——
+    // **漏掉真事的代价，比多带两条噪音大得多。**
+    default: 0.7,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: '召回门槛（只留分数接近最高分的，越低给得越多）',
+  },
   {
     key: 'maxShowPerTurn',
     type: 'number',
@@ -126,7 +183,9 @@ export const CONFIG_SPEC = [
     min: 0,
     max: 12,
     step: 1,
-    label: '「突然想起来」最多几条（按相似度召回）',
+    // ⚠️ 2026-11-02 之后**对自动注入不再生效**。条数改由 recallFanout 控。
+    // 保留字段的理由同 highSim。
+    label: '「突然想起来」最多几条（4.1 起不生效，改看 recallFanout）',
   },
   {
     key: 'wanderChance',
@@ -135,7 +194,12 @@ export const CONFIG_SPEC = [
     min: 0,
     max: 0.5,
     step: 0.01,
-    label: '走神想起旧事的概率',
+    // ⚠️ 2026-11-02 之后**不再生效**。
+    //
+    // "走神"是 selectMemories 里那一步随机想起一条旧事。现在按 BM25 给一批，
+    // 没有"掷骰子"这个动作了 —— 那一步本来就是为"只给 1 条"打掩护的。
+    // 保留字段的理由同 highSim。
+    label: '走神想起旧事的概率（4.1 起不生效）',
   },
   {
     // ── 续写窗口 ──

package/src/core/persona.mjs

@@ -114,7 +114,7 @@ export function renderMemoryBlock(input = {}) {
     if (recent) parts.push({ key: 'recent', text: recent, weight: 80 });
   }
 
-  const memories = renderRecalled(input.recalled, now);
+  const memories = renderRecalled(input.recalled, now, input.recalledMax);
   // ⚠️ **召回这一栏也必须有保底。**
   //
   // 加词汇保底之后，死的是它 —— 实测（真实档案、回归查询）：
@@ -356,7 +356,15 @@ export function renderRelationship(rel, now = Date.now()) {
     bits.push(rel.familiarity >= 0.7 ? '我们很熟了' : rel.familiarity >= 0.3 ? '我们聊过一阵了' : '我们刚认识不久');
   }
   if (typeof rel.nickname === 'string' && rel.nickname.trim() !== '') {
-    bits.push(`他管我叫"${rel.nickname.trim()}"`);
+    // 2026-11-08：主语从「他」改成「空气凤梨（用户）」。
+    //
+    // 起因是一次真的混了：注入里读到一条手记落款「（这是空气凤梨我自己写的）」，
+    // 那是用户给**自己**的签名，我把它读成了「他在叫我」——
+    // 于是把「你是空气凤梨」说给了用户听，正好说反。
+    //
+    // 「他」这个代词在这块里指谁，全靠上下文猜；猜错一次就认错人。
+    // 写死名字加「（用户）」两个字，笨重一点，但不会再混。
+    bits.push(`空气凤梨（用户）管我叫"${rel.nickname.trim()}"`);
   }
   // 两句之间用逗号接，不用「·」—— 那是分隔符，一出现就是表格味
   if (bits.length > 0) lines.push(`${bits.join('，')}。`);
@@ -472,13 +480,25 @@ export function renderRecent(entries, shown, now = Date.now(), limit = 12) {
  * @param {Array<{entry: object}>} recalled
  * @param {number} [now]
  */
-export function renderRecalled(recalled, now = Date.now()) {
+export function renderRecalled(recalled, now = Date.now(), maxEntries = 2) {
   if (!Array.isArray(recalled) || recalled.length === 0) return '';
+  const cap = Number.isFinite(maxEntries) && maxEntries > 0 ? Math.floor(maxEntries) : 2;
   const lines = recalled
     .filter((c) => c && c.entry && typeof c.entry.text === 'string')
-    .slice(0, 2)
+    .slice(0, cap)
     .map((c) => {
-      const when = softWhen(c.entry.created_at, now);
+      // 2026-11-03：`softWhen` → `dayLabel`。
+      //
+      // 原来这里是「前阵子，……」—— 那个模糊词当初是为了防止旧事被说成
+      // "上一轮"发生的。它做到了，但代价是**时间信息被压没了**：
+      // 10 月 21 日和 11 月 2 日都叫「前阵子」，间隔看不见。
+      //
+      // 用户的原话：**「现在记的是发生了什么，缺的是多久没发生。
+      // 空白是我唯一看不见的东西。」**
+      //
+      // `dayLabel` 给的是今天 / 昨天 / 3 天前 / 10-05 —— 同样按自然日算，
+      // 但能读出间隔，也不会像软词那样让人以为是刚发生的事。
+      const when = dayLabel(c.entry.created_at, now);
       const body = stripTimeWords(c.entry.text);
       return when === '' ? `- ${body}` : `- ${when}，${body}`;
     });

package/src/core/recall.mjs

@@ -21,22 +21,37 @@ const IDF_SMOOTH = 1;
 /**
  * 建倒排索引。纯派生数据，随用随建。
  *
- * ── 2026-10-28：索引的数据源从「keywords + 正文」换成 **summary** ──
+ * ── 2026-11-02：索引吃**正文**，不吃 summary ──
  *
- * 原来一条日记存两份提炼：`keywords`（12 个词，机器从正文切的）和
- * `summary`（一句，模型写的）。倒排索引吃前者，大保底（recall）吃后者。
+ * 这是实测推翻了两次设计之后定下来的。
  *
- * 而 summary 本来就比 keywords 更适合字面匹配 ——
- * 它带别名（「边缘行者2 / 续集 / 那部动画」），keywords 只取正文里出现过的词。
- * 一份数据喂两个地方，另一份就是纯多余的。
+ * 摘要做索引有一个致命毛病：**它写的是当天的术语，人问的是抽象词。**
+ * 实测那一条：
  *
- * 所以现在：**一条日记只有一个"检索表示"。**
- *   小保底（每轮自动注入）  字面匹配 summary —— 便宜
- *   大保底（她主动查）      模型读 summary   —— 准
+ *     摘要   boot.log 13:20 apply+routes·5次剩3次·注入气泡·插件顺序错·已关
+ *     正文   ……后来他说项目失败了，事先准备不足。我说是失败了，但问题不在代码，在顺序……
  *
- * 没有 summary 的用正文兜底（老条目在回填完之前就是这样）。
+ * 拿「项目失败了」「事先准备不足」去检索，摘要一个字都撞不上；
+ * 换成正文索引，两条都排第 1 名（1.000）。
  *
- * @param {Array<{id: string, summary?: string, text?: string}>} entries
+ * 整组对比（480 条真实日记）：
+ *
+ *              摘要索引        正文索引
+ *   项目失败了   未命中     →    第 1 名
+ *   事先准备不足 未命中     →    第 1 名
+ *   吃了睡睡了吃 「早饭吃了没」→   1.000 正确那条
+ *   煮饭         空         →    0.967
+ *
+ * 代价只有建索引变重（32ms → 94ms），**检索本身一点没变慢**，
+ * 而且它是纯 CPU，一个 token 都不花。索引只在 archive 变化时重建。
+ *
+ * 于是职责分开：
+ *   **检索**       吃正文 —— 它要的是"人会不会这样说"
+ *   **给模型读**   还是摘要 / 正文，那是渲染层的事，跟这里无关
+ *
+ * 别把 summary 塞回来当索引。它漏掉的那半段，往往正是最要紧的那句。
+ *
+ * @param {Array<{id: string, text?: string}>} entries
  * @returns {{postings: Map<string, Map<string, number>>, df: Map<string, number>, lengths: Map<string, number>, N: number}}
  */
 export function buildIndex(entries) {
@@ -46,8 +61,17 @@ export function buildIndex(entries) {
   const list = Array.isArray(entries) ? entries : [];
 
   for (const entry of list) {
-    const hasSummary = typeof entry.summary === 'string' && entry.summary !== '';
-    const tokens = tokenize(hasSummary ? entry.summary : (entry.text ?? ''));
+    // 正文 + 摘要都吃。
+    //
+    // 正文是主力：人问往事用的是"项目失败了""那事搞砸了"这种话，
+    // 而摘要写的是当天的术语（boot.log、apply/routes），一个字都撞不上。
+    //
+    // 摘要不能扔：它带着**别名和梗称**（「边缘行者2 / 续集 / 那部动画」），
+    // 而正文不一定写全。test/core.test.mjs 里有一条就是拿这个卡着的。
+    //
+    // 两边都进去的代价只有建索引变重（32ms → 177ms，一次性），
+    // 检索本身在 0.2ms 量级，一个 token 都不花。
+    const tokens = tokenize(`${entry.text ?? ''}\n${entry.summary ?? ''}`);
     if (tokens.length === 0) continue;
 
     const tf = new Map();
@@ -223,6 +247,58 @@ export function searchScores(index, query, options = {}) {
   return scores;
 }
 
+/**
+ * 取前 N 条，但只留**跟最高分接近**的那些。
+ *
+ * ── 为什么需要这道闸（2026-11-02 实测）──
+ *
+ * 光按 top-N 取会给一堆噪音。真实档案、查询「项目失败了」：
+ *
+ *     第 1 名  1.00  那个失败的项目（对）
+ *     第 2 名  0.96  欢乐谷小时候没玩刺激项目（错，只是撞上了「项目」）
+ *     第 3-12 名      气泡卡没、赛博朋克、0.1.8 发布……（全无关）
+ *
+ * 12 条塞进去 5412 token，**八成是垃圾**。多给不等于不漏，只等于更吵。
+ *
+ * ── 为什么用"相对门槛"而不是固定分数线 ──
+ *
+ * 分数是**饱和函数**（1 − e^−gain），所以它的绝对刻度会随查询长短漂移：
+ * 一句长问句可能最高才 0.7，一句短词可能全在 0.99。固定门槛要么全砍要么全留。
+ *
+ * 跟着第一名走就稳：**离第一名太远的就是另一件事。**
+ *
+ * ── 但 `limit` 不是没用 ──
+ *
+ * 它是上限。真正相关多的查询（「八条鱼论战」前 4 名全对）不会因为
+ * 相对门槛被砍到只剩 1 条，而铺得很开的查询（「项目失败了」）会被砍到 5~6 条。
+ * 两个数字一起用，才是"宽但不吵"。
+ *
+ * @param {ReturnType<typeof buildIndex>} index
+ * @param {string} query
+ * @param {{limit?: number, ratio?: number, floor?: number}} [options]
+ * @returns {Map<string, number>} id → 相似度，已按分数降序
+ */
+export function topHitScores(index, query, options = {}) {
+  const limit = Number.isFinite(options.limit) ? Math.max(0, Math.floor(options.limit)) : 15;
+  const ratio = Number.isFinite(options.ratio) ? options.ratio : 0.85;
+  const floor = Number.isFinite(options.floor) ? options.floor : 0.6;
+  const out = new Map();
+  if (limit === 0) return out;
+
+  // 多捞一些再砍：后面的过滤（note、最近的事）会再淘汰一批。
+  const scored = searchScores(index, query, { limit: Math.max(limit * 3, 30) });
+  const ranked = [...scored.entries()].sort((a, b) => b[1] - a[1]);
+  if (ranked.length === 0) return out;
+
+  const cutoff = Math.max(floor, ranked[0][1] * ratio);
+  for (const [id, sim] of ranked) {
+    if (sim < cutoff) break;
+    out.set(id, sim);
+    if (out.size >= limit) break;
+  }
+  return out;
+}
+
 /** 新鲜度：指数衰减 */
 function recencyFactor(createdAt, now, halfLifeDays) {
   if (!Number.isFinite(createdAt)) return 0.5;

package/src/host/index.mjs

@@ -40,11 +40,11 @@ import {
 // 原来的 evaluateGate 那套关键词闸门拆了（见 turn-stopping 里的注释）。
 // SUPPRESS_RE 留着 —— "别记"是用户的控制，不是启发式。
 import { SUPPRESS_RE } from '../core/gate.mjs';
-import { buildIndex, selectMemories, searchScores, queryHasSubstance, looksLikeWork, parseTimeHint, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
+import { buildIndex, searchScores, topHitScores, queryHasSubstance, looksLikeWork, parseTimeHint, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
 import { overlap } from '../core/keywords.mjs';
 import { scrub } from '../core/privacy.mjs';
 import { renderMemoryBlock, DEFAULT_BUDGET } from '../core/persona.mjs';
-import { calendarDaysBetween, stripTimeWords, softWhen } from '../core/timeline.mjs';
+import { calendarDaysBetween, stripTimeWords, softWhen, dayLabel } from '../core/timeline.mjs';
 import { renderDiaryFile } from '../core/render-diary.mjs';
 import { buildJudgeInput, parseVerdict, JUDGE_MAX_TOKENS } from '../core/judge.mjs';
 import { selectHandNotes, HANDNOTE_FILE, HANDNOTE_TEMPLATE } from '../core/handnote.mjs';
@@ -430,6 +430,26 @@ export function apply(ctx, rawConfig) {
         queued: false,
         /** 上下文刚被压缩过：下一轮要把最近的事整段重灌一次（免预算） */
         needsRecentReplay: false,
+        /**
+         * 她刚用 `feiyu_recall` 翻到的东西。
+         *
+         * ── 为什么不直接把正文当工具返回值给她 ──
+         *
+         * 2026-11-03。原来工具直接返回正文，于是她读到的是"工具查回来的资料"，
+         * 嘴里就挂着一句"这是我翻出来的"。用户的原话：**一问就是 recall 查的，
+         * 不是自己的。**
+         *
+         * 现在改成：工具只把结果存在这儿，返回值淡化成"（翻了翻）"，
+         * 正文由**下一次 `renderFor` 混进记忆块**。她读到的是"记忆里多了几条"。
+         *
+         * 这不是"让读到像记得"——她真的翻了，动作还在对话历史里。
+         * 区别在**翻完之后怎么读**：人翻完笔记合上，说话时不会说"根据笔记第 3 页"。
+         *
+         * 只在本轮有效（`pendingRecallTurn === s.turn`）：
+         * 下一轮自动失效，不会变成常驻条目、也不会滚雪球占预算。
+         */
+        pendingRecall: [],
+        pendingRecallTurn: -1,
       };
       sessionStates.set(sessionId, s);
     }
@@ -999,19 +1019,61 @@ export function apply(ctx, rawConfig) {
       if (!substantial) log(`会话 ${sessionId} 第 ${s.turn} 轮：这句话没实词，不翻记忆`);
       else if (working) log(`会话 ${sessionId} 第 ${s.turn} 轮：像在干活，不打扰`);
 
-      const { chosen } = chatty
-        ? selectMemories(recallPool, index, query, s, s.turn, {
-            highSim: config.highSim,
-            // 闲聊时最多给两条候选 —— **给两条，它用哪条自己定，或者一条都不用。**
-            // 只给一条等于系统替它说了「你就该想起这个」。
-            maxShow: Math.min(2, config.maxShowPerTurn),
-            wanderChance: config.wanderChance,
-            // 旧事的随机池门槛。注意下限降到 0.15 是为了跟"降门槛"一致 ——
-            // 门槛降到 0.15 却在这里卡 0.25，等于白降。
-            minSalience: Math.max(0.15, config.minSalience),
-            now: Date.now(),
-          })
-        : { chosen: [] };
+      // ── 按相似度捞一批完整正文（2026-11-02 大改）──
+      //
+      // 原来走 `selectMemories`：挑 1~2 条，还要跟 salience、冷却、走神一起掷骰子。
+      // 现在直接按 BM25 取前 N 条完整正文 —— **范围大，就不怕它挑错。**
+      //
+      // ── 为什么不给模型挑了 ──
+      //
+      // 原来那条路是：480 行索引（摘要，约 1.6 万 token）塞给模型挑 3 条。
+      // 实测两件事：
+      //   1. 那次调用跟一整轮聊天一样贵（都是全价，缓存命不中）
+      //   2. 摘要把最要紧的半句漏了 —— 「项目失败了」在正文里，摘要里一个字没有
+      // 于是模型拿着错的索引挑，挑得再认真也没用。
+      //
+      // ── 为什么敢一次给 15 条 ──
+      //
+      // BM25 会 0 命中（同义词、梗称），也会高分错答。但它**不需要准，只需要不漏**。
+      // 只给 2 条时它错一次，这条鱼就什么都想不起来；给 15 条时错的混在里面，
+      // 对的那条还在 —— **准的那一步交给读正文的她自己。**
+      //
+      // 「最近的事」那几条不在池子里（已经常驻了），note 和损坏条目也不在。
+      const recallLimit = Number.isFinite(config.recallFanout) ? config.recallFanout : 15;
+      /** @type {Array<{entry: object, score: number, sim: number, why: string}>} */
+      const chosen = [];
+
+      // ── 她刚翻到的，排最前面 ──
+      //
+      // 2026-11-03：`feiyu_recall` 不再把正文当返回值给她，只存在 `pendingRecall`。
+      // 正文从这里混进记忆块 —— 她读到的是"记忆里多了几条"，不是"工具返回了资料"。
+      //
+      // 只认同一轮（`pendingRecallTurn === s.turn`）：下一轮自动失效，
+      // 不会变成常驻条目，也不会滚雪球占预算。
+      if (s.pendingRecallTurn === s.turn && s.pendingRecall.length > 0) {
+        for (const c of s.pendingRecall) {
+          if (chosen.length >= recallLimit) break;
+          chosen.push(c);
+        }
+        log(`会话 ${sessionId} 第 ${s.turn} 轮：翻到的 ${chosen.length} 条并入记忆`);
+      }
+
+      if (chatty && recallLimit > 0) {
+        // 只留跟第一名接近的（相对门槛），否则会捞进一堆只撞上一个常用词的噪音。
+        const hits = topHitScores(index, query, {
+          limit: recallLimit,
+          ratio: config.recallScoreRatio,
+        });
+        const poolById = new Map(recallPool.map((e) => [e.id, e]));
+        for (const [id, sim] of hits) {
+          const entry = poolById.get(id);
+          if (entry === undefined) continue;
+          // 刚才翻到的已经在里面了，别重复
+          if (chosen.some((c) => c.entry?.id === id)) continue;
+          chosen.push({ entry, score: sim, sim, why: '' });
+          if (chosen.length >= recallLimit) break;
+        }
+      }
 
       // 手记是**只读**的，所以每轮都重新读一遍 —— 别的肥鱼或用户刚写进去的
       // 那行，下一轮就在注入里，不用重启。文件很小，而且整块渲染按轮缓存。
@@ -1048,9 +1110,12 @@ export function apply(ctx, rawConfig) {
         // 所以不会像栏目那样被裁掉。
         //
         // 2026-10-27：给 `feiyu_note` 的那半句删了 —— 工具本身也下线了。
-        handNoteHint: `想不起来的时候，用 ${RECALL_TOOL_NAME} 回想一下 —— 用当时的词，越具体越准。`,
+        handNoteHint: `手上的记忆里真没有，才用 ${RECALL_TOOL_NAME} 去翻。那是最后一招。`,
         includePersona: config.includePersona,
         budget: config.budgetTokens,
+        // 召回那栏能渲染几条。默认值跟上面捞的条数同一个数 ——
+        // 不传的话 `renderRecalled` 会回落到 2 条，捞 15 条只显示 2 条，白捞。
+        recalledMax: recallLimit,
         now: Date.now(),
       });
       text = rendered.text;
@@ -2067,8 +2132,19 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
     const base = narrowed === null ? all : all.filter(
       (e) => Number.isFinite(e.created_at) && e.created_at >= narrowed.from && e.created_at <= narrowed.to,
     );
-    const pool = base.slice(-400);
-    if (base.length > pool.length) log(`挑往事：${base.length} 条只取最近 ${pool.length} 条`);
+    // ── 2026-11-02：不再静默截到最近 400 条 ──
+    //
+    // 那个 400 是"prompt 压不住"的近似，但它的副作用是**悄悄丢掉最老的那些**：
+    // 480 条时已经丢了 80 条，而丢掉的恰好是最难被想起来、也最该被留着的那批。
+    // 更糟的是它只写一行 log —— 用户永远看不到自己的记忆在少。
+    //
+    // 现在只留一道"真的太大才截"的闸，而且会 warn。真要涨到过千条，
+    // 该做的是分层（按天/按月），不是继续截尾巴。
+    const POOL_CAP = 1200;
+    const pool = base.length > POOL_CAP ? base.slice(-POOL_CAP) : base;
+    if (base.length > pool.length) {
+      warn(`挑往事：${base.length} 条超过上限 ${POOL_CAP}，只取最近 ${pool.length} 条 —— 更老的挑不到`);
+    }
 
     // 索引行前面带日期 —— 模型才有办法回答「那阵子」这种问法。
     const dayLabel = (t) => {
@@ -2086,7 +2162,10 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
 
     const system =
       '你在帮一条鱼回忆往事。她问了一句，你从她的日记索引里挑出最相关的几条。\n\n' +
-      '每行是「id 空格 日期 一句索引」。有些索引很粗（正文截断出来的），别嫌弃。\n' +
+      '每行是「id 空格 日期 一句索引」。\n' +
+      '**要挑的是「那件事本身」，不是「我记过这件事」的记录。**\n' +
+      '像「他问过 X·我答记不清」「这次是翻出来的」「注入里没有」这种，**都不能算答案** ——\n' +
+      '它们只说明那条鱼当时没想起来，不是他讲过的事。\n' +
       '**如果她问的是一段时间（「那阵子」「上个月」），优先看日期。**\n' +
       '只输出 JSON：{"ids":["d_20261028_1","d_20261028_2"]}\n' +
       '没有相关的就输出 {"ids":[]}。最多 ' + limit + ' 条。**宁可少挑，别硬凑。**';
@@ -2178,10 +2257,10 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
         scope.tools.register({
           name: RECALL_TOOL_NAME,
           description:
-            '回想一些以前的事。**你自己想不起来时用它**：' +
-            '他提到一件早先的事、你觉得该想起来却一片空白、或者要确认某个细节。' +
-            '只在真的需要时调，不要每轮都查。' +
-            '想不起来就老实说想不起来，别编。',
+            '翻日记。**只有在完全没有印象时才用** —— 他问的那件事，你手上一点底都没有。' +
+            '别用它确认细节，别用它补全，也别因为「怕答错」就去查。' +
+            '查到什么直接说，不用交代「这是我翻出来的」；他真问你怎么知道的，再说实话。' +
+            '翻不到就说翻不到，别编。',
           parameters: {
             type: 'object',
             additionalProperties: false,
@@ -2211,7 +2290,9 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
             render: (_args, value) => [{ type: 'text', text: value?.text ?? '查不了。' }],
           },
 
-          async execute(args) {
+          // 第二个参数 `exec` 带 `agent` —— 靠它知道是谁在翻，
+          // 翻到的东西要存进那个会话的 pendingRecall（见 renderFor 那段注释）。
+          async execute(args, exec) {
             await loadPromise;
             if (!ready) throw new Error('档案现在读不了（可能是坏的），查不了。');
 
@@ -2279,27 +2360,63 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
               };
             }
 
-            // 总字数封顶 —— 不按"次数"限流（那要跨轮状态，麻烦），
-            // 按"返回量"限：超了就是一次失败的成本，它自己会学会别乱查。
+            // ── 收到哪去：**不直接给她**，存进本轮「翻到的」，由注入送去 ──
+            //
+            // 2026-11-03 改。原来这里 `return` 正文，于是她读到的是"工具查回来的资料"，
+            // 嘴里就挂着一句"这是我翻出来的"。用户的原话：
+            //   **一问就是 recall 查的，不是自己的。**
+            //
+            // 现在：正文存进 `pendingRecall`，返回值只剩一句"（翻了翻）"。
+            // 正文由下一次 `renderFor` 混进记忆块 —— 她读到的是"记忆里多了几条"。
+            //
+            // 她真的翻了，动作还在对话历史里。区别只在**翻完之后怎么读**：
+            // 人翻完笔记合上，说话时不会说"根据笔记第 3 页"。
             const MAX_CHARS = 2000;
-            const lines = [];
+            const pickedEntries = [];
             let used = 0;
-            const now = Date.now();
-            for (const { entry } of ranked) {
+            for (const { entry, sim } of ranked) {
+              // note（判断那一栏已下线）不进来 —— 让规矩从工具溜回来，等于没删干净
+              if (entry.kind === 'note') continue;
               // 跟注入走同一个隐私闸 —— 历史条目里可能还有没洗过的东西
-              const body = stripTimeWords(scrub(entry.text, { thirdParty: false }).text);
-              const when = softWhen(entry.created_at, now);
-              const line = when === '' ? body : `${when}：${body}`;
-              if (used + line.length > MAX_CHARS && lines.length > 0) break;
-              lines.push(`- ${line}`);
-              used += line.length;
+              const clean = scrub(entry.text, { thirdParty: false }).text;
+              if (used + clean.length > MAX_CHARS && pickedEntries.length > 0) break;
+              pickedEntries.push({ entry: { ...entry, text: clean }, score: sim, sim, why: '' });
+              used += clean.length;
+            }
+
+            const sid = typeof exec?.agent?.id === 'string' ? exec.agent.id : undefined;
+            if (sid === undefined) {
+              // 拿不到会话（极端情况）→ 退回旧行为，别让她什么都拿不到
+              log(`检索「${query.slice(0, 20)}」：拿不到会话 id，直接返回正文`);
+              const now0 = Date.now();
+              const lines = pickedEntries.map(({ entry }) => {
+                // 跟注入那一栏用同一个时间尺子（dayLabel），别一个模糊一个精确
+                const when = dayLabel(entry.created_at, now0);
+                return `- ${when === '' ? entry.text : `${when}：${entry.text}`}`;
+              });
+              return { ok: true, found: lines.length, text: lines.join('\n') || '想不起来了。' };
             }
 
-            log(`检索「${query.slice(0, 20)}」：返回 ${lines.length} 条`);
+            const st = stateOf(sid);
+            st.pendingRecall = pickedEntries;
+            st.pendingRecallTurn = st.turn;
+            // 作废按轮缓存：下一次 assemble 会重算，把这批混进记忆块
+            st.renderCache = { turn: -1, text: '' };
+
+            log(`检索「${query.slice(0, 20)}」：翻到 ${pickedEntries.length} 条，等注入送`);
             return {
               ok: true,
-              found: lines.length,
-              text: lines.join('\n'),
+              found: pickedEntries.length,
+              // 2026-11-03：**什么都不留。**
+              //
+              // 原来是「（翻了翻）」，用户看了说不要 —— 那还是个痕迹：
+              // 她读到"我刚翻了一下"，下一句就容易带出"我查到的"。
+              //
+              // 现在正文全走注入，返回值只是一个空串。工具调用本身还在历史里
+              // （该留的证据留着了），但**不会再往她嘴里塞一句"我去翻了"。**
+              //
+              // 翻空了还是要说一句 —— 那是另一回事：别让她以为"翻过了等于找到了"。
+              text: pickedEntries.length === 0 ? '想不起来了。换个说法再试试，或者直接问他。' : '',
             };
           },