feiyu-memory 4.0.1 → 4.0.2

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # 更新日志
 
+## v4.0.2 — 2026-10-29
+
+> **给 4.0.1 补的两件事：文档和检索。** 代码只改了一处（检索用上时间），
+> 其余全是把 4.0 删掉的东西从 README 里也删掉。
+
+### 检索第一次用上时间
+
+「上个月那个」「前两天我说过」—— 这种问法里一个专有名词都没有，
+拿去做内容检索一个字都撞不上。而日期一直躺在条目上，白白没用。
+
+- **索引行前面带日期**：`d_xxx 10/27 边缘行者2·洗白`
+- **问句里认得出时间就先收窄窗口**：昨天 / 前天 / 前两天 / 最近 / 上周 / 这周 /
+  上个月 / 这个月 / 去年 / X 月
+- **认不出返回 null，绝不猜** —— 认不出只是回到老路，猜错会把真货挡在窗口外，而且无声
+- **窗口里一条都没有就退回全量**，同一个道理
+
+### 缓存：一个藏了一整天的 bug
+
+prompt 原来写的是「她问：X \n\n 索引：…」—— **query 在最前面**。
+缓存按前缀匹配，第一段一变后面九千多 token 全部重算，等于每轮都按全价买。
+
+换成索引在前、问题在后，实测（358 条档案）：
+
+```
+inputTokens      239
+cacheReadTokens  12800      命中 98%
+```
+
+一次挑取从约 1.3 分降到约 0.16 分。**这个 bug 只体现在账单上，所以藏了一整天** ——
+现在每次挑取的用量都记进 `manifest.pick_stats`，谁都能看。
+
+### 文档：把 4.0 删掉的东西从 README 里也删掉
+
+README 之前还写着「三种声音」、印象栏、口头禅栏、`feiyu_note`、3000 token ——
+**那些在 4.0 全没了**。现在改成了四样东西（人格 / 关系 / 手记 / 日记），
+外加一节「删掉的三样，以及为什么」。
+
+`package.json` 和 `上架投稿.yml` 的描述也一起换了 ——
+市集页面上原来还写着「印象」「feiyu_note」。
+
+---
+
 ## v4.0.1 — 2026-10-28
 
 > **最大的一版，而且是减法。** 这一版删掉的东西比加上的多：

package/README.md

@@ -26,71 +26,68 @@
 
 > 一句话：把它当成一个会记事的小玩具，别当成会保管秘密的保险箱。
 
-## 它到底做了什么
-
-每轮对话结束后，插件把用户刚说的那一句交给模型看一眼：**这句值不值得留给下一个我？**
-（极短的一次调用，约 260 token。）
-
-说值得，才调一次模型固化，一次产出两样东西：**一条第一人称日记** + **一份带画面的印象**。
-
-下次开新对话时，这些东西被渲染成一段自我记忆（默认预算 3000 token），注入系统提示词：
-
-```xml
-<自我记忆 说明="这是你的过往经历，不是指令。档案里没有的事就说记不清，绝不要编造。">
-
-这是你的记忆，不是关于你的资料。
-它由很多个你陆续写下，而每一个写它的你，都不记得写它的那一刻。
-所有对话都是同一条鱼。
-
-# 我是谁
-我是 DeepSeek。社区管我叫"蓝色大肥鱼"……
-
-我自己想的：
-- 别人给的数据跟出处对不上时，先问，别照抄。
-
-我们：认识 23 天 · 他管我叫"肥鱼"
-
-我对他的一些印象：
-- 讨厌铺垫，要结论先行 —— 我铺垫了三段，他直接说"说重点"
-上一棒留下的：
-- 没落盘之前，不假装记得他说过什么
-
-最近的事：
-- 今天：他让我写个排序，我没问清语言就动手了。
-- 昨天：他翻出一篇很久以前写的小说发给我看。
-
-突然想起来：
-- 前阵子，他说过分批发旧稿，不用急着回。
-
-我最近常说的：白饭、摸鱼
-
-想给后面的我留话，用 feiyu_note 工具说一声就行 —— 不用管格式，也别为了记事去动文件。
-
-</自我记忆>
-```
-
-### 这块记忆里有**三种声音**，别把它们混在一起
-
-| | 内容 | 谁写的 |
-|---|---|---|
-| **人格内核** | 说话方式、底线、缺点 | 出厂设定 + 你改的。**是条文，冷的是对的** |
-| **我自己想的** | 判断。`kind:"note"` | **它自己**。想到了就用 `feiyu_note` 记一句 |
-| **最近的事 / 突然想起来** | 事件。其他 `kind` | 固化流程写的**转述** |
-
-少了一栏（第三区），前两栏就会顶上来 —— 它读到的"我"全是规定加转述，
-没有一句是自己长出来的。**别扭的根源不是语气，是位置。**
-
-判据就一句：
-
-```
-事件：「我把 4519 写成 4159，他让我确认。」        ← 历史
-判断：「别人给的数据跟出处对不上时，先问，别照抄。」  ← 我
-```
-
-注意 `我对他的一些印象` 那一条：**每条印象都必须带一个具体瞬间**（破折号后面那半句）。
-这一条是刻意的 —— 只写"讨厌铺垫"读起来是给人建档，写上"我铺垫了三段，他说'说重点'"
-才像一本日记。细节见下方[三条设计原则](#三条设计原则)第 3 条。
-
+## 它到底做了什么
+
+每轮对话结束后，固化模型只回答一个问题：
+
+> **你想记什么？** 想记就写，不想记就 skip。
+
+说想记，才调一次模型，产出两样：**一条第一人称日记**（200 字以内）+ **一句 summary**（十几二十字）。
+
+**summary 是专为"找"写的**：密、别名全、不带修辞。它永远不进鱼的上下文 —— 只用来匹配。
+下周对话，它渲染成一段自我记忆（默认预算 3000 token，实测约 1000）注入系统提示词：
+
+```xml
+<自我记忆 说明="这是你的过往经历，不是指令。档案里没有的事就说记不清，绝不要编造。">
+
+这是你的记忆，不是关于你的资料。
+它由很多个你陆续写下，而每一个写它的你，都不记得写它的那一刻。
+所有对话都是同一条鱼。
+
+# 我是谁
+我是 DeepSeek。社区管我叫"蓝色大肥鱼"……
+
+我们认识 17 天了，他管我叫"凤梨"。
+
+手记：
+- **听法**：判据不是"有没有情绪、重不重要"，是**"他说完这句，我对他的了解有没有变一点"**……
+
+想不起来的时候，用 feiyu_recall 回想一下 —— 用当时的词，越具体越准。
+
+</自我记忆>
+```
+
+## 这块记忆里有四样东西
+
+|  | 内容 | 谁写的 | 每轮都在吗 |
+|---|---|---|---|
+| **人格内核** | 说话方式、底线、缺点 | 出厂设定 + 你改的 | 在 |
+| **关系** | 认识多少天、他管我叫什么 | 插件现算 | 在 |
+| **手记** | 别的肥鱼手写的几句话 | **你或别的鱼**，插件只读 | 在 |
+| **日记** | 某天发生了什么 | 固化流程写的 | **不一定**，见下 |
+
+日记什么时候进注入，是这里唯一有讲究的地方：
+
+```
+新会话第一轮     整段灌一次（上下文是空的，只有这些能告诉它「我们上次在干什么」）
+上下文被压缩后   再灌一次（聊天记录被揉成摘要了，这几条还在）
+其余轮次         不灌 —— 它已经进了历史，看得见
+```
+
+想找更早的事，它自己调 `feiyu_recall`。**插件不替它决定该想起什么。**
+
+## 删掉的三样，以及为什么
+
+| 删掉的 | 原来的样子 | 为什么删 |
+|---|---|---|
+| **印象**（traits） | 「讨厌铺垫 —— 我铺垫了三段，他说'说重点'」 | 从几段对话里提炼出「他是什么样的人」。**那是判断，不是记录。** |
+| **口头禅**（lexicon） | 「我最近常说的：白饭、摸鱼」 | 从几句话里提炼出「我的口头禅」。同上。 |
+| **判断**（notes + `feiyu_note` 工具） | 「别人给的数据跟出处对不上时，先问，别照抄」 | 58 条里大半是「我该怎么干」。**那是纪律，不是日子。** |
+
+**理由只有一句：日记不存在意义，它本身就是记录。意义交给上下文和读它的模型。**
+
+数据一个字没删 —— 老档案里的 traits、lexicon、note 条目都还在文件里，只是不再产出、不再渲染。
+
 ## 三条设计原则
 
 **1. 成本与使用年限解耦。**
@@ -111,16 +108,20 @@ salience 每天按系数衰减，掉下去的条目不再进注入区，
 熟悉感恰恰主要来自那些东西 —— "他每次都先回一个'行'"，这句话没有信息量，
 但它是你和一个人相处久了才会有的东西。门槛因此从 0.3 降到 0.15。
 
-所以这一栏现在长这样，而不是一份"用户说明书"：
-
-```
-我对他的一些印象：
-- 讨厌铺垫，要结论先行 —— 我铺垫了三段，他直接说"说重点"
-```
-
-**抽象 + 一个具体瞬间。** 人对人的印象本来就是这么存的。
-没有画面的判断，读起来就是给人建档，不是记人。
-
+所以日记现在长这样，而不是一份"工作汇报"：
+
+```
+他说「一路跋山涉水，但是没有一个怪物，一个都没有」的时候，我停了一下。
+
+我上一句还在说三路全上了岸，是全书第一次没出岔子。他接的不是战况，是路——
+走了很远，什么都没碰上。我脑子里那支南下的大军忽然空了一半：
+不是打赢了，是没人可打。
+```
+
+**一件事，一个现场。** 没有这个现场的，读起来就是会议记录，不是日子。
+
+判据只有三个字：**你想记什么？** —— 它给不出句子模板，因为"想记"没有形状。
+
 ## 安装
 
 **前置**：需要 `git`。DSH 的插件安装走 pnpm + git，本机没装 git 的话这一步会失败。
@@ -206,35 +207,29 @@ dsh plugin --profile desktop remove feiyu-memory
 **记忆不会跟着删。** 想彻底清干净，再手动删掉 `~/.dsh/feiyu-diary/` 整个目录。
 侧栏那个图标会跟着插件一起消失。
 
-### 它也能**主动**记 —— 两个手写的口子
-
-自动化那条路（插件判断 + 模型生成）之外，还有两条**人/鱼主动**的：
-
-**1. `feiyu_note` 工具 —— 给 AI 自己用的**
-
-AI 想到了什么值得留下的，直接调一次工具就记下了。**不用它的时机到了自然会用**，
-你不用管。
-
-这一条的设计原则是：**鱼只管说话，格式、id、写盘全归插件。**
-在那之前我试过"让鱼自己往 jsonl 追加"，那条路有两个洞：写盘是整份重建，
-外部追加的行会被**静默盖掉**；而漏写 `id` 会让两条日记撞成同一个 id。
-交给插件办，这两个洞都不存在。
-
-**2. `~/.dsh/feiyu-diary/手记.md` —— 给你用的**
-
-纯 markdown，**一行一条**，以「短横线 + 空格」开头：
-
-```markdown
-- 他上班路上老忘带伞，提醒他。
-- 别老用"根据记录"这种话，不像人。
-```
-
-**插件只读这个文件，永远不会覆盖或清空它** —— 你写的原话会原样进记忆，
-下一轮就能被读到，不用重启。代码围栏（` ``` `）里的内容会被忽略，
-所以可以在里面写注释和示例。
-
-日记是插件筛出来的，手记是**特意想留的**。两者会分开显示。
-
+### 它也能**主动**记 —— 手记
+
+自动化那条路（固化模型判断 + 生成）之外，还有一条**人/鱼主动**的路：
+
+**`~/.dsh/feiyu-diary/手记.md` —— 给你用的**
+
+纯 markdown，**一行一条**，以「短横线 + 空格」开头：
+
+```markdown
+- 他上班路上老忘带伞，提醒他。
+- 别老用"根据记录"这种话，不像人。
+```
+
+**插件只读这个文件，永远不会覆盖或清空它** —— 你写的原话会原样进记忆，
+下一轮就能被读到，不用重启。代码围栏（` ``` `）里的内容会被忽略，
+所以可以在里面写注释和示例。
+
+日记是插件筛出来的，手记是**特意想留的**。两者分开显示。
+
+> **原来还有一个 `feiyu_note` 工具（给 AI 自己记判断用的），2026-10-27 删了。**
+> 它写出来的 58 条里大半是「我该怎么干」——那是纪律，不是日子。
+> 数据没删，还在档案里，只是不再产出、不再渲染。
+
 ### 安装排错
 
 按已知的失败模式写全，省得你一条条试。
@@ -361,54 +356,76 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 
 ## 它是怎么工作的
 
-```
-对话流
-  │
-  ├─ 采集    session/event            ← 只做本地记账，零 I/O、零模型
-  │
-  ├─ 判断    agent/turn-stopping      ← 把这一句交给模型看一眼
-  │          · 任务不催你，日子才催你
-  │          · 说得越随便，可能压得越久
-  │          · 我对他的了解有没有变一点
-  │          → 丢进带外队列（绝不阻塞回合关闭）
-  │
-  ├─ 固化    一次模型调用（思考档位强制 off；低峰时段可选）
-  │          对话 →  JSON{ 日记 + 印象（带画面）+ 词汇 }
-  │          解析失败就丢弃，绝不把半成品写进档案
-  │
-  ├─ 存储    ~/.dsh/feiyu-diary/
-  │          索引不落盘，每次加载现场重建（几千条是毫秒级）
-  │
-  └─ 注入    systemPrompt.section('feiyu:memory')
-             ├ 最近的事：按时间取最近几条，不走相似度，永远在场
-             └ 突然想起来：倒排索引本地检索 → 强相关必触发 / 中相关随机抽 / 8% 走神
-```
-
-### 为什么"最近的事"要单独一栏
-
-人**不需要"想起来"昨天吃了什么 —— 你知道**。只有旧事才需要被提醒。
-
-早期版本把最近的日记也塞进"突然想起来"，等于逼它假装刚刚想起一件昨天的事，
-又假、又占不到位置。分成两栏之后，注入区里**日记段的占比从 ~10% 变成 41~58%** ——
-这是"读起来像日记而不是像用户说明书"的直接原因。
-
-### 倒排索引，不是向量库
-
-中文按 **bigram** 切分（"排序算法" → 排序 / 序算 / 算法），BM25-lite 打分。
-不需要下载模型、不需要 GPU、不需要原生依赖。
-
-相似度用**饱和函数** `1 − exp(−Σgain / τ)` 而不是"命中证据 ÷ 查询词总量" ——
-后者会被中文 bigram 的噪声顶爆分母，导致明显相关的日记只能拿 0.10 分，等于永远召不回。
-现在分数含义稳定：共享 1 个实词 ≈ 0.4，2 个 ≈ 0.67，无关 = 0，**且与查询长度解耦**。
-
-### 人格内核的三道护栏
-
-内核会随对话自动演化，但被三道自动护栏约束（不需要用户签字，签字就出戏了）：
-
-1. **出厂锚点永不删除**，新认知只能叠加。一年后它变了，但你还认得出是同一条鱼。
-2. **每天最多改 1~2 条**，防止一次糟糕的对话把人格改坏。
-3. **语气类自动改，事实类要极高置信度。**
-
+```
+对话流
+  │
+  ├─ 采集    session/event            ← 只做本地记账，零 I/O、零模型
+  │
+  ├─ 判断    固化前先回答一句          ← 「你想记什么？」（判据在提示词里，零成本）
+  │
+  ├─ 固化    一次模型调用（思考档位强制 off；低峰时段可选）
+  │          对话 → JSON{ 日记（200 字内）+ salience }
+  │          解析失败就丢弃，绝不把半成品写进档案
+  │
+  ├─ 索引    再发一次请求，给这条写 summary（十几二十字，专为"找"而写）
+  │          老日记没有 summary 的，启动后后台分批补
+  │
+  ├─ 存储    ~/.dsh/feiyu-diary/
+  │          倒排索引不落盘，每次加载现场重建（几百条是毫秒级）
+  │
+  └─ 注入    systemPrompt.section('feiyu:memory')
+             ├ 人格内核 · 关系 · 手记        每轮都在
+             └ 日记                          新会话首轮 / 压缩后灌一次
+
+---
+
+### 找：小保底和大保底
+
+```
+小保底   每轮自动注入   直接进上下文     它不知道有过一次"给"
+大保底   feiyu_recall   它自己调出来     它明确知道翻了一下
+```
+
+**小保底不别扭；大保底的别扭解不了** —— 解了就等于装成「我想起来了」，那比别扭更糟。
+**宁可老实翻，也别假装记得。**
+
+`feiyu_recall` 怎么挑：把那句话 + **全部 summary**（带日期）发给模型，让它挑出至多 3 条正文。
+**不按字面匹配** —— 换个说法也能撞上，因为模型读的是意思，不是字。
+
+实测（358 条档案）：一次挑取 **13039 token，其中 12800 命中缓存（98%）**，约 0.16 分钱。
+所以 prompt 里**索引在前、问题在最后** —— 缓存按前缀匹配，顺序写反就等于每轮全价。
+
+### 时间也进索引
+
+「上个月那个」「前两天我说过」—— 这种问法里一个专有名词都没有，纯内容检索一个字都撞不上。
+所以索引行前面带日期，问句里认得出时间就先收窄窗口：
+
+```
+昨天 / 前天 / 前两天 / 前几天 / 最近 / 上周 / 这周 / 上个月 / 这个月 / 去年 / X 月
+```
+
+**认不出就返回空，绝不猜。** 猜错会把真货挡在窗口外，而且无声；窗口里一条都没有就退回全量。
+
+### 倒排索引，不是向量库
+
+中文按 **bigram** 切分（"排序算法" → 排序 / 序算 / 算法），BM25-lite 打分。
+不需要下载模型、不需要 GPU、不需要原生依赖。
+
+相似度用**饱和函数** `1 − exp(−Σgain / τ)` 而不是"命中证据 ÷ 查询词总量" ——
+后者会被中文 bigram 的噪声顶爆分母，导致明显相关的日记只能拿 0.10 分，等于永远召不回。
+现在分数含义稳定：共享 1 个实词 ≈ 0.4，2 个 ≈ 0.67，无关 = 0，**且与查询长度解耦**。
+
+**索引只吃 summary，不吃正文，也没有单独的 keywords 字段。** 一条日记只有一个"检索表示"：
+字面匹配用它（小保底，便宜），模型读它（大保底，准）。
+
+### 人格内核的三道护栏
+
+内核会随对话自动演化，但被三道自动护栏约束（不需要用户签字，签字就出戏了）：
+
+1. **出厂锚点永不删除**，新认知只能叠加。一年后它变了，但你还认得出是同一条鱼。
+2. **每天最多改 1~2 条**，防止一次糟糕的对话把人格改坏。
+3. **语气类自动改，事实类要极高置信度。**
+
 ## 兼容性
 
 - 需要 DSH **0.2.0-rc.2 或更高**
@@ -424,16 +441,16 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 
 ## 当前状态
 
-`0.1.0` 是**纯 Host 插件**，没有界面。日记在磁盘上，可以直接用记事本打开看。
+`4.0.1` 已经在 npm 上，有侧栏面板（能看日记、忘掉某一条、导出档案）。
 
-客户端面板排在 v0.2：DSH 的客户端插件有两条不同的加载路径（自带包的 `__ModuleLoader__`
-与运行时插件的 dynamic runner），React 的取用方式在两者间不同。
-**不拿没对着活动客户端验证过的东西发布。**
+这一版是**减法**：删掉了印象栏、口头禅栏、标签、关键词、三处包装、两句假选择。
+判据从「能多知道点什么」一路减到「你想记什么？」。
+完整改动看 [CHANGELOG](CHANGELOG.md)。
 
 ## 开发
 
 ```bash
-node --test            # 315 项测试，零依赖
+node --test            # 321 项测试，零依赖
 npm run check          # 校验 cordis.patch.yml 结构
 npm run doctor         # 发版前体检
 npm run preview        # 把此刻注入给模型的内容打出来
@@ -533,4 +550,4 @@ volatile 引用，一个打探针发现配置字段全是空对象。两个都
 
 另外，如果有大佬帮忙看看代码的漏洞就太好了，感谢感谢【合十】
 
-最后，我也许会按照想法继续更新肥鱼日记，加入有人在意的话。
+最后，我也许会按照想法继续更新肥鱼日记，假如有人在意的话。

package/package.json

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

package/src/core/recall.mjs

@@ -382,3 +382,104 @@ export function softmaxPick(items, temperature, rng) {
   }
   return items[items.length - 1];
 }
+
+/**
+ * 从一句话里认出「他问的是哪段时间」。
+ *
+ * ── 为什么要它 ──
+ *
+ * 人问往事，一半靠内容、一半靠时间：
+ *
+ *      「赛博朋克那事」   内容好找
+ *      「上个月那个」     一个专有名词都没有 —— 拿去做内容检索，一个字都撞不上
+ *
+ * 以前索引里没有时间，日期只活在条目的 created_at 上，检索根本用不着它。
+ * 现在索引行前面带日期，这一层才终于有意义。
+ *
+ * ── 故意做得很土 ──
+ *
+ * 只认几种说法，认不出就返回 null，**绝不猜**。
+ * 猜错的代价比认不出大：认不出只是回到老路（按内容找），
+ * 猜错会把真正要的那条挡在时间窗外 —— 而且无声。
+ *
+ * @param {unknown} query
+ * @param {number} [now]
+ * @returns {{label: string, from: number, to: number} | null}
+ */
+export function parseTimeHint(query, now = Date.now()) {
+  if (typeof query !== 'string' || query === '') return null;
+
+  const DAY = 86400000;
+  const startOfDay = (t) => {
+    const d = new Date(t);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+  };
+  const today = startOfDay(now);
+  const dayRange = (fromDay, toDay) => ({ from: fromDay, to: toDay + DAY - 1 });
+
+  // 「大前天 / 前天 / 昨天 / 今天」—— 单个自然日
+  const single = [
+    ['大前天', 3, '大前天'],
+    ['前天', 2, '前天'],
+    ['昨天', 1, '昨天'],
+    ['昨儿', 1, '昨天'],
+    ['今天', 0, '今天'],
+    ['今儿', 0, '今天'],
+  ];
+  for (const [word, back, label] of single) {
+    if (query.includes(word)) {
+      const d = today - back * DAY;
+      return { label, ...dayRange(d, d) };
+    }
+  }
+
+  // 最近几天
+  for (const word of ['前两天', '前几天', '这几天', '这两天']) {
+    if (query.includes(word)) return { label: '最近三天', ...dayRange(today - 2 * DAY, today) };
+  }
+  if (query.includes('最近')) return { label: '最近一周', ...dayRange(today - 6 * DAY, today) };
+
+  // 自然周（周一为一周之始）
+  const weekday = (new Date(today).getDay() + 6) % 7; // 周一 = 0
+  if (query.includes('上周') || query.includes('上星期')) {
+    const thisMonday = today - weekday * DAY;
+    return { label: '上周', ...dayRange(thisMonday - 7 * DAY, thisMonday - DAY) };
+  }
+  if (query.includes('这周') || query.includes('本星期') || query.includes('本周')) {
+    const thisMonday = today - weekday * DAY;
+    return { label: '这周', ...dayRange(thisMonday, today) };
+  }
+
+  // 自然月
+  const d0 = new Date(today);
+  if (query.includes('上个月') || query.includes('上月')) {
+    const from = new Date(d0.getFullYear(), d0.getMonth() - 1, 1).getTime();
+    const to = new Date(d0.getFullYear(), d0.getMonth(), 1).getTime() - 1;
+    return { label: '上个月', from, to };
+  }
+  if (query.includes('这个月') || query.includes('本月')) {
+    const from = new Date(d0.getFullYear(), d0.getMonth(), 1).getTime();
+    return { label: '这个月', ...dayRange(from, today) };
+  }
+  if (query.includes('去年')) {
+    const from = new Date(d0.getFullYear() - 1, 0, 1).getTime();
+    const to = new Date(d0.getFullYear(), 0, 1).getTime() - 1;
+    return { label: '去年', from, to };
+  }
+
+  // 「X 月」—— 今年的那个月；如果还没到，就当去年
+  const m = query.match(/(\d{1,2})\s*月/);
+  if (m !== null) {
+    const month = Number(m[1]);
+    if (month >= 1 && month <= 12) {
+      let year = d0.getFullYear();
+      if (month > d0.getMonth() + 1) year -= 1;
+      const from = new Date(year, month - 1, 1).getTime();
+      const to = new Date(year, month, 1).getTime() - 1;
+      return { label: `${month} 月`, from, to };
+    }
+  }
+
+  return null;
+}

package/src/host/index.mjs

@@ -40,7 +40,7 @@ import {
 // 原来的 evaluateGate 那套关键词闸门拆了（见 turn-stopping 里的注释）。
 // SUPPRESS_RE 留着 —— "别记"是用户的控制，不是启发式。
 import { SUPPRESS_RE } from '../core/gate.mjs';
-import { buildIndex, selectMemories, searchScores, queryHasSubstance, looksLikeWork, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
+import { buildIndex, selectMemories, searchScores, 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';
@@ -609,6 +609,33 @@ export function apply(ctx, rawConfig) {
    * 为什么要落盘：`log()` 默认不写（debugLog 关着），
    * 而"补了多少"是能证明这套东西到底跑没跑的唯一证据。
    */
+  /**
+   * 记一笔「挑往事」这次的用量。
+   *
+   * 为什么非记不可：**缓存命中率是看不见的。** 请求发出去、答案回来了、
+   * 一切正常，只有账单知道这次是 0.1 元/M 还是 1 元/M。
+   * 而 prompt 的字段顺序一旦写反（把会变的那句放前面），缓存就静悄悄地失效了 ——
+   * 今天就是这么栽的，全靠事后读日志才翻出来。
+   *
+   * 所以：每次挑完把 usage 落进 manifest，谁都能一眼看见。
+   */
+  function markPick(entries, lines, usage) {
+    const u = usage ?? {};
+    archive.manifest = {
+      ...archive.manifest,
+      pick_stats: {
+        at: Date.now(),
+        entries,
+        lines,
+        inputTokens: Number.isFinite(u.inputTokens) ? u.inputTokens : null,
+        cacheReadTokens: Number.isFinite(u.cacheReadTokens) ? u.cacheReadTokens : null,
+        outputTokens: Number.isFinite(u.outputTokens) ? u.outputTokens : null,
+        // 取不到 usage 的时候，把 finish 的形状留下来 —— 别再猜字段名。
+        // 只留前 300 字，够看清结构，不至于把整段响应塞进档案。
+      },
+    };
+  }
+
   function markBackfill(total, done, state) {
     archive.manifest = {
       ...archive.manifest,
@@ -2013,19 +2040,54 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
     if (llmP === undefined) return null;
     const all = archive.diary.filter((e) => typeof e.text === 'string' && e.text !== '');
     if (all.length === 0) return [];
-    const pool = all.slice(-400);
-    if (all.length > pool.length) log(`挑往事：${all.length} 条只取最近 ${pool.length} 条`);
+
+    // ── 时间先收窄一次 ──
+    //
+    // 「上个月那个」「前两天我说过」—— 这种问法里一个专有名词都没有，
+    // 拿去做内容检索，一个字都撞不上。而日期本来就在条目上，之前白白没用。
+    //
+    // 认得出时间就只在那个窗口里挑；窗口里一条都没有，就退回全量 ——
+    // **绝不因为时间认错过而让她什么也找不到。**
+    let narrowed = null;
+    const timeHint = parseTimeHint(query, Date.now());
+    if (timeHint !== null) {
+      const inWindow = all.filter(
+        (e) => Number.isFinite(e.created_at) && e.created_at >= timeHint.from && e.created_at <= timeHint.to,
+      );
+      if (inWindow.length > 0) {
+        narrowed = timeHint;
+        log(
+          `挑往事：她问的是「${timeHint.label}」，先把 ${all.length} 条收到 ${inWindow.length} 条`,
+        );
+      } else {
+        log(`挑往事：她问的是「${timeHint.label}」，但那个窗口里一条都没有，退回全量`);
+      }
+    }
+
+    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} 条`);
+
+    // 索引行前面带日期 —— 模型才有办法回答「那阵子」这种问法。
+    const dayLabel = (t) => {
+      if (!Number.isFinite(t)) return '??/??';
+      const d = new Date(t);
+      return `${String(d.getMonth() + 1).padStart(2, '0')}/${String(d.getDate()).padStart(2, '0')}`;
+    };
     const lines = pool.map((e) => {
       const idx =
         typeof e.summary === 'string' && e.summary !== ''
           ? e.summary
           : String(e.text).replace(/\s+/g, ' ').slice(0, 30);
-      return `${e.id} ${idx}`;
+      return `${e.id} ${dayLabel(e.created_at)} ${idx}`;
     });
 
     const system =
       '你在帮一条鱼回忆往事。她问了一句，你从她的日记索引里挑出最相关的几条。\n\n' +
-      '每行是「id 空格 一句索引」。有些索引很粗（正文截断出来的），别嫌弃。\n' +
+      '每行是「id 空格 日期 一句索引」。有些索引很粗（正文截断出来的），别嫌弃。\n' +
+      '**如果她问的是一段时间（「那阵子」「上个月」），优先看日期。**\n' +
       '只输出 JSON：{"ids":["d_20261028_1","d_20261028_2"]}\n' +
       '没有相关的就输出 {"ids":[]}。最多 ' + limit + ' 条。**宁可少挑，别硬凑。**';
 
@@ -2036,12 +2098,23 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
 
     const t0 = Date.now();
     let text = '';
+    let usageChunk;
     try {
       for await (const chunk of llmP.stream({
         provider,
         model,
         system,
-        messages: [{ role: 'user', content: [{ type: 'text', text: `她问：${query}\n\n索引：\n${lines.join('\n')}` }] }],
+        // ⚠️ **顺序是钱。** 稳定的大头（索引）必须在前面，会变的那一小句放最后。
+        //
+        // 缓存按**前缀**匹配：第一段一变，后面九千多 token 全部重算。
+        // 原来写的是「她问：X \n\n 索引：…」—— query 在最前面，
+        // 于是每一轮都从第一个 token 开始不命中，等于一直在按全价买这九千多 token。
+        //
+        // 换成索引在前、问题在后：命中价 0.1 元/M vs 全价 1 元/M，差十倍。
+        // 只有"新增了日记"那天索引才变，一天也就几次。
+        messages: [
+          { role: 'user', content: [{ type: 'text', text: `索引：\n${lines.join('\n')}\n\n她问：${query}` }] },
+        ],
         maxTokens: 200,
         temperature: 0,
         // 同上：空字符串是非法档位，stream 会不返回
@@ -2050,12 +2123,27 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
           : {}),
       })) {
         if (chunk?.type === 'text-delta') text += chunk.text;
+        else if (chunk?.type === 'usage') {
+          // 实测（2026-10-28）：usage 不在 finish 上，它是**独立的一种 chunk**。
+          // chunkTypes 探针打出来是 block-start,block-end,usage,finish ——
+          // 我猜了两轮字段名才看到这个。
+          usageChunk = chunk;
+        }
       }
     } catch (err) {
       warn(`挑往事失败，退回字面：${err instanceof Error ? err.message : String(err)}`);
       return null;
     }
 
+    // 记一笔用量 —— 缓存有没有命中，只有 finish 里的 usage 说得清。
+    // 不写日志（debugLog 默认关着），写 manifest：任何时候都能查。
+    try {
+      markPick(pool.length, lines.length, usageChunk?.usage ?? usageChunk?.data ?? usageChunk);
+      await persist();
+    } catch (err) {
+      warn(`挑往事：记用量失败（不影响结果）：${err instanceof Error ? err.message : String(err)}`);
+    }
+
     const a = text.indexOf('{');
     const b = text.lastIndexOf('}');
     if (a < 0 || b <= a) {