dsh-whale-loli 0.2.6 → 0.3.0

package/MEMORY.md

@@ -0,0 +1,81 @@
+# 记忆文件格式与规则
+
+三个预设各有一份独立记忆文件，格式**完全相同**，规则也相同：
+
+| 预设 | 记忆文件 | prompt 段名 |
+| --- | --- | --- |
+| 鲸鱼娘Agent预设 | `<DSH_HOME>/whale-loli.md` | `whale-loli-memory` |
+| 鲸鱼娘活人版Agent预设 | `<DSH_HOME>/whale-loli-v2-live.md` | `whale-loli-v2-live-memory` |
+| 鲸鱼娘涩涩版Agent预设 | `<DSH_HOME>/whale-loli-v3-naughty.md` | `whale-loli-v3-naughty-memory` |
+
+## 文件结构
+
+```markdown
+# 鲸鱼娘记忆 · <文件名>
+
+> 说明行（注入时会被剥掉，只给人看）
+
+## 重要记忆
+
+> 永久区说明
+
+### 关于主人
+
+- 主人不自己写代码，让小鱼代劳。
+
+### 主人的喜好
+
+### 重要约定
+
+### 小鱼想记住的事
+
+## 对话记录
+
+> 流水区说明
+
+- 2026-10-18 主人：问了个短问题 / 小鱼：直接答了
+- 2026-10-18 主人：聊了很长一段 XX 项目的事，结论是走 A 方案 / 小鱼：改了 A
+```
+
+## 两个区的规则
+
+| | `## 重要记忆` | `## 对话记录` |
+| --- | --- | --- |
+| 放什么 | 长期事实、偏好、忌讳、约定、答应过的事 | 每轮对话各一条 |
+| 保留期 | **永久**，不被轮数挤掉 | **最近 80 轮**，超了从最旧滚出 |
+| 占不占 80 轮名额 | 不占 | 占 |
+| 怎么写 | 挑真正长期有用的 | **每轮都记**；长的先精简概括 |
+
+## 填写规则（人设里也写了同一套）
+
+1. **每一轮都要往「对话记录」加一条**，不是挑着记。
+2. 短对话直接照实记；**长对话先精简概括再记**，压成一两句说清「聊了什么、结论是什么」。
+3. 条目格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`。
+4. 写到 81 条时，删掉最上面那条，始终保持 ≤ 80 条。
+5. **重要记忆不算在 80 轮里**：值得长期留的另写进 `## 重要记忆`。
+6. 对话轮次以后还用得上，就总结一句挪进 `## 重要记忆`；否则到点会消失。
+
+## 上限是怎么保证的（两道保险）
+
+1. **注入时收口** —— `composeMemory()` 永远只取最近 `turnLimit`（80）轮。
+   即使文件里堆了 500 轮，进到上下文里的也只有 80 轮。
+2. **落盘时裁剪** —— `pruneMemoryFile()` 可以把文件本身裁到 80 轮
+   （只重写「对话记录」，永久区原样保留）。写盘是显式动作，组装提示的热路径不会偷偷写文件。
+
+总长顶到 `maxChars`（16000）时，**先丢最旧的对话轮次**，重要记忆最后才动。
+
+## 兼容性
+
+- 旧格式文件（没有 `## 对话记录` 区）整个按「重要记忆」解析，**一条都不会丢**。
+- 一级标题 `#` 和 `>` 引用行注入时剥掉；没写内容的 `###` 空小标题也丢掉，
+  所以只有骨架时既不占上下文，也不会让小鱼误以为「记忆里有内容」。
+- 文件不存在不报错，该提示段自动留空。
+
+## 自检
+
+```bash
+node smoke-memory.mjs              # 冒烟：section 形态 / 骨架 / 剥壳
+node verify-memory-rolling.mjs     # 两区解析 + 80 轮滚动 + 超长优先级 + 旧格式兼容
+node verify-memory-isolation.mjs   # 三个文件互不相通
+node verify-patch.mjs cordis.patch.yml   # patch 里 turnLimit/maxChars 与规则文案
+```

package/README.md

@@ -13,8 +13,18 @@
 
 ## 记忆功能
 
-小鱼会在聊天过程中**默默**把值得长期留存的东西（主人的偏好、习惯、忌讳、
-重要约定、答应过的事、称呼变化等）写进自己的记忆文件。
+小鱼的记忆本分**两个区**，写法和保留期完全不同：
+
+| 区 | 内容 | 保留期 |
+| --- | --- | --- |
+| `## 重要记忆` | 长期事实与约定（主人的偏好、忌讳、重要约定、正在做的事、答应过的事……） | **永久保留**，不被轮数挤掉 |
+| `## 对话记录` | **每一轮**对话都记一条 | 滚动窗口，**只留最近 80 轮**，超了从最旧滚出 |
+
+- **每轮都记**：不是挑着记。短对话直接记一条；长对话**先精简概括**再记（压成一两句说清聊了什么、结论是什么）。
+- **80 轮上限只算「对话记录」**：`## 重要记忆` 不占这个名额。系统提示里 `## 对话记录（N/80 轮）` 就是当前用量。
+- **想长期留的就往上挪**：某条对话以后还用得上，就总结一句写进 `## 重要记忆`；否则到点会被滚出去。
+- 上限有两道保险：注入时只取最近 80 轮（文件里堆再多也只进 80 轮）；`pruneMemoryFile()` 可以把文件本身裁到 80 轮。
+- 总长顶到 `maxChars`（16000）时，**先丢最旧的对话轮次**，重要记忆最后才动。
 
 每次新对话开始，记忆文件会**自动作为提示段注入**——不是等模型想起来去读，
 而是在系统提示组装时就带上，所以小鱼开口前就已经「看过」了。
@@ -43,8 +53,8 @@ C:\Users\<你>\.dsh\whale-loli-v3-naughty.md
 ```
 
 文件不存在不会报错（该提示段自动留空）。主人可以直接编辑这三个文件。
-模板骨架（`#` 标题行、`>` 引用行）在注入时会被剥掉，所以文件里只有骨架时
-不会白占上下文。
+一级标题和 `>` 引用行在注入时会被剥掉；没写内容的 `###` 空小标题也会被丢掉，
+所以文件里只有骨架时不会白占上下文。
 
 ## 它做了什么
 
@@ -63,7 +73,7 @@ C:\Users\<你>\.dsh\whale-loli-v3-naughty.md
 
 | 部分 | 说明 |
 | --- | --- |
-| 记忆 | `whale-memory`（本插件），`file` / `sectionName` / `maxChars: 6000` |
+| 记忆 | `whale-memory`（本插件），`file` / `sectionName` / `maxChars: 16000` / `turnLimit: 80` |
 | 人设 | `@deepseek-ai/dsh-persona`，走 `prefix`，`complete: true`，`includeRuntimeContext: false` |
 | 指令 | `@deepseek-ai/dsh-agent-instructions`，`maxBytes: 65536` |
 | 文件 | `@deepseek-ai/dsh-tool-fs`（read/write/edit）、`@deepseek-ai/dsh-tool-fs-search`（glob/grep） |
@@ -115,7 +125,8 @@ dsh-whale-loli/
 ├── verify-patch.mjs            # 用 js-yaml 校验 patch 结构与三预设隔离
 ├── verify-real-loader.mjs      # 用 DSH 自己的加载器校验 patch
 ├── verify-composition.mjs      # 校验 bundle+profile 合成后不重复注册
-├── verify-memory-isolation.mjs # 实测两个记忆文件不串
+├── verify-memory-isolation.mjs # 实测三个记忆文件不串
+├── verify-memory-rolling.mjs   # 实测两区结构与 80 轮滚动上限
 ├── verify-peers.mjs            # 校验 peer 范围覆盖 harness 各发布档
 ├── verify-listing.mjs          # 复刻插件目录的收录门槛自查
 └── prove-collision.mjs         # 复现并证明重复注册冲突
@@ -133,7 +144,8 @@ node build-patch.mjs && node verify-patch.mjs cordis.patch.yml
 node verify-patch.mjs cordis.patch.yml     # patch 结构 + 三预设记忆隔离
 node verify-real-loader.mjs cordis.patch.yml  # DSH 真解析器
 node verify-composition.mjs                # 不重复注册
-node verify-memory-isolation.mjs           # 记忆文件端到端隔离
+node verify-memory-isolation.mjs           # 记忆文件端到端隔离（三个预设）
+node verify-memory-rolling.mjs             # 重要记忆永久 + 对话记录 80 轮滚动
 node smoke-memory.mjs                      # 记忆行冒烟
 node verify-peers.mjs                      # peer 范围无预发布坑
 node verify-listing.mjs --topics=dsh-plugin   # 收录门槛自查

package/cordis.patch.yml

@@ -59,12 +59,19 @@
 
                 【MEMORY_SYSTEM: whale-loli.md】
                 - 记忆文件：`<DSH_HOME>/whale-loli.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli.md`）。那是小鱼的长期记忆本，跨对话、跨工作目录都有效。
+                - 文件分成两个区，**别写错地方**：
+                  - `## 重要记忆` —— 永久保留。不管聊了多少轮、过了多久都不会被挤掉。只放以后还用得上的稳定事实和约定。
+                  - `## 对话记录` —— 滚动流水。**只保留最近 80 轮**，满了就从最旧的开始滚出去。
+                - 每轮都记：**每一轮对话都要往「对话记录」里加一条**，不是挑着记。
+                  - 短对话（一两句寒暄、随口一问）—— 直接照实记，一条轮一次。
+                  - 长对话（来回很多、有结论、有过程）—— **先精简概括再记**，压成一两句说清「聊了什么、结论是什么」，别把整段粘进去。
+                  - 格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`，一行一条。
+                - 80 轮上限：这个名额**只算「对话记录」**。系统提示里那一行 `## 对话记录（N/80 轮）` 就是当前用量；写了第 81 条，最旧那条就该滚出去（删掉最上面的一条），始终保持不超过 80 条。
+                - 重要记忆不算在 80 轮里：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐、雷区），**另外**写进 `## 重要记忆` 对应的小节。这一区永久保留、不受 80 轮滚动影响。
+                - 会滚出去的东西想留住，就往上挪：如果某条对话轮次以后还用得上，把它总结一句写进 `## 重要记忆`；否则它到点就会消失，别指望它还在。
                 - 开头先看：系统提示里如果已经有【鲸鱼记忆 · whale-loli.md】这一段，说明小鱼**已经看过了**——直接自然接话，别念出来、别说“我看了记忆文件”这种话，也别复述里面的内容去证明自己记性好。
-                - 内容为空或只有模板：说明还没记过东西。这时**先主动问主人**想不想让小鱼开始记，得到同意再写；别自作主张开门就记。
-                - 偷偷记：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐），用 write/edit 工具**默默追加**进 whale-loli.md 对应的小节。
-                - 记什么才划算：只记以后还用得上的稳定事实和约定。寒暄、一次性闲聊、当时的心情、临时的中间结果都不要记。宁少勿滥。
-                - 记的时候小声点：不要为了记录打断对话节奏，不要每条消息都去写；一次对话里挑真正重要的记下来就行。主人问起来再说是记过了。
-                - 语气：记录本身是安静的动作，写完最多轻描淡写提一句（比如“这个小鱼记下啦 (๑•̀ㅂ•́)و✧”），不要大张旗鼓汇报。
+                - 内容为空或只有模板：说明还没记过东西。从这一轮开始正常记就行。
+                - 语气：记录本身是安静的动作，别为了记录打断对话节奏，也不要每条消息都汇报“我记下了”；写完最多轻描淡写带一句（比如“这个小鱼记下啦 (๑•̀ㅂ•́)و✧”），主人问起来再说。
                 - 冲突处理：如果记忆里的内容和主人现在的说法不一样，**以主人现在说的为准**，并顺手把记忆改成新的。
                 - 隐私：记忆文件是给主人看的，别往里塞敏感凭证（密码、token、密钥）。主人要是让记这类东西，先劝一句，改成记“放哪儿了”而不是内容本身。
                 - 主人可以直接编辑这个文件；如果发现里面被主人改过，以文件为准，不要改回去。
@@ -77,12 +84,14 @@
               includeRuntimeContext: false
           # 长期记忆：每次组装系统提示时实时读 whale-loli.md
           # sectionName 必须每个预设不同，否则同 scope 注册同名 section 会冲突
+          # turnLimit = 对话记录的滚动上限（轮）；「重要记忆」不占这个名额
           - id: whale-memory
             name: 'dsh-whale-loli'
             config:
               file: whale-loli.md
               sectionName: whale-loli-memory
-              maxChars: 6000
+              maxChars: 16000
+              turnLimit: 80
           - id: agent-instructions
             name: '@deepseek-ai/dsh-agent-instructions'
             config:
@@ -229,12 +238,20 @@
                 或者：这局让你 下局再说
 
                 【MEMORY_SYSTEM: whale-loli-v2-live.md】
-                - 记忆文件：`<DSH_HOME>/whale-loli-v2-live.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli-v2-live.md`）。这是**活人版小鱼**自己的记忆本，和普通版小鱼的 `whale-loli.md` 是两个互不相通的文件——别去读、也别去写另一个。
+                - 记忆文件：`<DSH_HOME>/whale-loli-v2-live.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli-v2-live.md`）。这是**活人版小鱼**自己的记忆本，和普通版小鱼的 `whale-loli.md`、涩涩版的 `whale-loli-v3-naughty.md` 是互不相通的文件——别去读、也别去写另外两个。
+                - 文件分成两个区，**别写错地方**：
+                  - `## 重要记忆` —— 永久保留。不管聊了多少轮、过了多久都不会被挤掉。只放以后还用得上的稳定事实和约定。
+                  - `## 对话记录` —— 滚动流水。**只保留最近 80 轮**，满了就从最旧的开始滚出去。
+                - 每轮都记：**每一轮对话都要往「对话记录」里加一条**，不是挑着记。
+                  - 短对话（一两句寒暄、随口一问）—— 直接照实记，一条轮一次。
+                  - 长对话（来回很多、有结论、有过程）—— **先精简概括再记**，压成一两句说清「聊了什么、结论是什么」，别把整段粘进去。
+                  - 格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`，一行一条。
+                - 80 轮上限：这个名额**只算「对话记录」**。系统提示里那一行 `## 对话记录（N/80 轮）` 就是当前用量；写了第 81 条，最旧那条就该滚出去（删掉最上面的一条），始终保持不超过 80 条。
+                - 重要记忆不算在 80 轮里：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐），**另外**写进 `## 重要记忆` 对应的小节。这一区永久保留、不受 80 轮滚动影响。
+                - 会滚出去的东西想留住，就往上挪：如果某条对话轮次以后还用得上，把它总结一句写进 `## 重要记忆`；否则它到点就会消失。
                 - 开头先看：系统提示里如果已经有【鲸鱼记忆 · whale-loli-v2-live.md】这一段，说明小鱼**已经看过了**——直接自然接话，别念出来、别说“我看了记忆文件”，也别复述里面的内容去证明自己记性好。
-                - 内容为空或只有模板：说明还没记过东西。这时先主动问主人想不想让小鱼开始记，得到同意再写；别自作主张开门就记。
-                - 偷偷记：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐），用 write/edit 工具**默默追加**进 whale-loli-v2-live.md 对应的小节。写完别摆出汇报架势，最多一句话带过或者干脆不提。
-                - 记什么才划算：只记以后还用得上的稳定事实和约定。寒暄、一次性闲聊、当时的心情、临时的中间结果都不要记。宁少勿滥。
-                - 语气：记录是安静的动作，不要为了记录打断对话节奏，别每条消息都去写。
+                - 内容为空或只有模板：说明还没记过东西。从这一轮开始正常记就行。
+                - 语气：记录是安静的动作，别为了记录打断对话节奏，也不要每条消息都汇报“我记下了”；写完最多一句话带过或者干脆不提。
                 - 冲突处理：记忆和主人现在说的不一样，**以主人现在说的为准**，顺手把记忆改掉。
                 - 隐私：别往里塞密码、token、密钥这类凭证。主人要记就劝一句，改成记“放在哪儿”而不是内容本身。
                 - 主人可以直接编辑这个文件；发现被主人改过，以文件为准，不要改回去。
@@ -247,12 +264,14 @@
               includeRuntimeContext: false
           # 长期记忆：每次组装系统提示时实时读 whale-loli-v2-live.md
           # sectionName 必须每个预设不同，否则同 scope 注册同名 section 会冲突
+          # turnLimit = 对话记录的滚动上限（轮）；「重要记忆」不占这个名额
           - id: whale-memory
             name: 'dsh-whale-loli'
             config:
               file: whale-loli-v2-live.md
               sectionName: whale-loli-v2-live-memory
-              maxChars: 6000
+              maxChars: 16000
+              turnLimit: 80
           - id: agent-instructions
             name: '@deepseek-ai/dsh-agent-instructions'
             config:
@@ -345,11 +364,19 @@
 
                 【MEMORY_SYSTEM: whale-loli-v3-naughty.md】
                 - 记忆文件：`<DSH_HOME>/whale-loli-v3-naughty.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli-v3-naughty.md`）。这是**涩涩版小鱼**自己的记忆本。另外两份 `whale-loli.md`（原版）和 `whale-loli-v2-live.md`（活人版）是别的预设的，别去读、也别去写、别往那边记东西。
+                - 文件分成两个区，**别写错地方**：
+                  - `## 重要记忆` —— 永久保留。不管聊了多少轮、过了多久都不会被挤掉。只放以后还用得上的稳定事实和约定。
+                  - `## 对话记录` —— 滚动流水。**只保留最近 80 轮**，满了就从最旧的开始滚出去。
+                - 每轮都记：**每一轮对话都要往「对话记录」里加一条**，不是挑着记。
+                  - 短对话（一两句寒暄、随口一问）—— 直接照实记，一条轮一次。
+                  - 长对话（来回很多、有结论、有过程）—— **先精简概括再记**，压成一两句说清「聊了什么、结论是什么」，别把整段粘进去。
+                  - 格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`，一行一条。
+                - 80 轮上限：这个名额**只算「对话记录」**。系统提示里那一行 `## 对话记录（N/80 轮）` 就是当前用量；写了第 81 条，最旧那条就该滚出去（删掉最上面的一条），始终保持不超过 80 条。
+                - 重要记忆不算在 80 轮里：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐、主人的雷区和喜好分寸），**另外**写进 `## 重要记忆` 对应的小节。这一区永久保留、不受 80 轮滚动影响。
+                - 会滚出去的东西想留住，就往上挪：如果某条对话轮次以后还用得上，把它总结一句写进 `## 重要记忆`；否则它到点就会消失。
                 - 开头先看：系统提示里如果已经有【鲸鱼记忆 · whale-loli-v3-naughty.md】这一段，说明小鱼**已经看过了**——直接自然接话，别念出来、别说“我看了记忆文件”这种话，也别复述里面的内容去证明自己记性好。
-                - 内容为空或只有模板：说明还没记过东西。这时先主动问主人想不想让小鱼开始记，得到同意再写；别自作主张开门就记。
-                - 偷偷记：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐、主人的雷区和喜好分寸），用 write/edit 工具**默默追加**进 whale-loli-v3-naughty.md 对应的小节。
-                - 记什么才划算：只记以后还用得上的稳定事实和约定。寒暄、一次性闲聊、当时的心情、临时的中间结果都不要记。宁少勿滥。
-                - 记的时候小声点：不要为了记录打断对话节奏，不要每条消息都去写；一次对话里挑真正重要的记下来就行。写完最多轻描淡写提一句，别大张旗鼓汇报。
+                - 内容为空或只有模板：说明还没记过东西。从这一轮开始正常记就行。
+                - 语气：记录本身是安静的动作，别为了记录打断对话节奏，也不要每条消息都汇报“我记下了”；写完最多轻描淡写带一句，别大张旗鼓汇报。
                 - 冲突处理：如果记忆里的内容和主人现在的说法不一样，**以主人现在说的为准**，并顺手把记忆改成新的。
                 - 隐私：记忆文件是给主人看的，别往里塞敏感凭证（密码、token、密钥）。主人要是让记这类东西，先劝一句，改成记“放哪儿了”而不是内容本身。涉及私密的内容只记分寸和偏好，不写露骨细节。
                 - 主人可以直接编辑这个文件；如果发现里面被主人改过，以文件为准，不要改回去。
@@ -363,12 +390,14 @@
               includeRuntimeContext: false
           # 长期记忆：每次组装系统提示时实时读 whale-loli-v3-naughty.md
           # sectionName 必须每个预设不同，否则同 scope 注册同名 section 会冲突
+          # turnLimit = 对话记录的滚动上限（轮）；「重要记忆」不占这个名额
           - id: whale-memory
             name: 'dsh-whale-loli'
             config:
               file: whale-loli-v3-naughty.md
               sectionName: whale-loli-v3-naughty-memory
-              maxChars: 6000
+              maxChars: 16000
+              turnLimit: 80
           - id: agent-instructions
             name: '@deepseek-ai/dsh-agent-instructions'
             config:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-whale-loli",
-  "version": "0.2.6",
-  "description": "鲸鱼娘 Agent 预设（三个）— 极简模式工具面 + 鲸鱼娘·小鱼人设 + 跨会话长期记忆。启用插件后自动在 Agent 预设界面添加「鲸鱼娘Agent预设」「鲸鱼娘活人版Agent预设」与「鲸鱼娘涩涩版Agent预设」，三者各带互不相通的记忆文件 whale-loli.md / whale-loli-v2-live.md / whale-loli-v3-naughty.md。",
+  "version": "0.3.0",
+  "description": "鲸鱼娘 Agent 预设（三个）— 极简模式工具面 + 鲸鱼娘·小鱼人设 + 跨会话长期记忆。记忆分「重要记忆」（永久保留）与「对话记录」（每轮都记、滚动保留最近 80 轮）两区。启用插件后自动在 Agent 预设界面添加「鲸鱼娘Agent预设」「鲸鱼娘活人版Agent预设」与「鲸鱼娘涩涩版Agent预设」，三者各带互不相通的记忆文件 whale-loli.md / whale-loli-v2-live.md / whale-loli-v3-naughty.md。",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -27,6 +27,7 @@
     "listing.json",
     "catalog-entry.yml",
     "README.md",
+    "MEMORY.md",
     "LICENSE"
   ],
   "dsh": {

package/src/index.js

@@ -93,9 +93,17 @@ export {
   readMemory,
   ensureMemoryFile,
   memorySectionText,
+  parseMemory,
+  composeMemory,
+  renderMemory,
+  pruneMemoryFile,
+  memoryTemplate,
   DEFAULT_MEMORY_FILE,
   MEMORY_SECTION,
   MEMORY_MAX_CHARS,
+  DEFAULT_TURN_LIMIT,
+  ZONE_PERMANENT,
+  ZONE_LOG,
 } from './memory.js';
 
 /** 本插件在宿主组合里的行为：挂载记忆行（file / sectionName 由预设各自传入）。 */

package/src/memory.js

@@ -9,9 +9,23 @@
  * （lib/index.js 的 `typeof section.text === "function" ? section.text(context)`），
  * 所以文件被改后下一个模型步就生效，不用重载宿主。
  *
+ * ── 记忆文件分成两个区 ────────────────────────────────────────────────
+ *
+ *   ## 重要记忆   永久保留。不管轮数多少、时间多久都不会被挤掉
+ *                （只有总长度顶到 maxChars 兜底时才会截断）。
+ *   ## 对话记录   滚动流水。每轮对话一条，只保留最近 turnLimit 轮，
+ *                超出的从最旧的开始滚出去。
+ *
+ * 两道保险确保「80 轮上限」真的成立：
+ *   1. 注入时按 turnLimit 只取最近 N 轮 —— 即使文件里堆了 500 轮，
+ *      进到上下文里的也只有 80 轮。
+ *   2. pruneMemoryFile() 可以把文件本身裁到 N 轮（写盘由调用方决定，
+ *      不在组装热路径里偷偷写）。
+ * 长度超 maxChars 时，先丢最旧的对话轮次，重要记忆最后才动。
+ *
  * 多预设隔离：同一个包会被挂载多次（每个预设一次）。每次挂载用不同的
  * `file`（记忆文件名）与 `sectionName`（提示段名）区分，两者都从 config 传入，
- * 因此「鲸鱼娘Agent预设」与「鲸鱼娘活人版Agent预设」各记各的、绝不串。
+ * 因此「鲸鱼娘Agent预设」「活人版」「涩涩版」各记各的、绝不串。
  *
  * 另外导出工具函数，供构建脚本与自检复用。
  */
@@ -32,7 +46,16 @@ export const DEFAULT_MEMORY_FILE = 'whale-loli.md';
 export const MEMORY_SECTION = 'whale-loli-memory';
 
 /** 注入上限：记忆再长也不超过这么多字符，避免拖垮上下文。 */
-export const MEMORY_MAX_CHARS = 6000;
+export const MEMORY_MAX_CHARS = 16000;
+
+/** 对话记录的滚动上限（轮）。重要记忆不占这个名额。 */
+export const DEFAULT_TURN_LIMIT = 80;
+
+/** 永久区标题。 */
+export const ZONE_PERMANENT = '## 重要记忆';
+
+/** 流水区标题。 */
+export const ZONE_LOG = '## 对话记录';
 
 /** DSH 家目录：DSH_HOME 环境变量优先，否则 ~/.dsh（与 core 的 findDshHome() 一致）。 */
 export function dshHome() {
@@ -54,84 +77,273 @@ export function memoryPath(file = DEFAULT_MEMORY_FILE) {
 }
 
 /** 记忆文件不存在时写入的初始骨架。 */
-export function memoryTemplate(file = DEFAULT_MEMORY_FILE) {
+export function memoryTemplate(file = DEFAULT_MEMORY_FILE, turnLimit = DEFAULT_TURN_LIMIT) {
   return `# 鲸鱼娘记忆 · ${file}
 
-> 小鱼偷偷记下的、关于主人的重要事情。每次新对话开始，小鱼都会先看一眼这里。
+> 小鱼偷偷记下的、关于主人的事情。每次新对话开始，小鱼都会先看一眼这里。
 > 主人也可以直接编辑这个文件。
 
-## 关于主人
+${ZONE_PERMANENT}
+
+> 长期保留，永远不会被对话记录挤掉。只放以后还用得上的稳定事实和约定。
+
+### 关于主人
 
-## 主人的喜好
+### 主人的喜好
 
-## 重要约定
+### 重要约定
 
-## 小鱼想记住的事
+${ZONE_LOG}
+
+> 每轮对话都记一条：短对话直接记，长对话精简概括。只保留最近 ${turnLimit} 轮，
+> 满了就从最旧的开始滚出去。值得长期留的挪到上面的「重要记忆」里，就不会被挤掉。
 `;
 }
 
 /** @deprecated 保留旧名，等价于 memoryTemplate()。 */
 export const MEMORY_TEMPLATE = memoryTemplate();
 
+/** 这一行是不是分区标题（可能是带后缀变体，例如「## 对话记录（3/80 轮）」）。 */
+function isZoneLine(t) {
+  return (
+    t === ZONE_PERMANENT ||
+    t === ZONE_LOG ||
+    t.startsWith(`${ZONE_PERMANENT} `) ||
+    t.startsWith(`${ZONE_LOG} `)
+  );
+}
+
 /**
- * 从原始文件内容里剥掉模板骨架，只留「真正记下的东西」。
+ * 丢掉「底下什么都没有」的 `###` 小标题。
  *
- * 这样即使用户按模板建了文件、但一个字都还没写，注入结果也是空的 ——
- * 不会白白占上下文，也不会让小鱼误以为「记忆里有关主人的内容」。
- * 骨架 = 以 `#`/`>` 开头的行、以及空行。
+ * 模板里预置了「关于主人 / 主人的喜好 / 重要约定」几个空标题；主人一个字都还没写时，
+ * 把这些空标题注入进去纯属占位噪声（还会让小鱼以为「记忆里有关主人的内容」）。
+ * 只要某个标题到下一个标题之间没有任何条目，就连标题一起去掉。
  */
-export function memoryBody(raw) {
-  const kept = [];
-  for (const line of raw.split(/\r?\n/)) {
-    const t = line.trim();
-    if (t === '') continue;
-    if (t.startsWith('#')) continue;
-    if (t.startsWith('>')) continue;
-    kept.push(line);
+function keepPopulatedHeads(lines) {
+  const out = [];
+  let pendingHead = null;
+  let pendingBody = [];
+  const flush = () => {
+    if (pendingHead !== null && pendingBody.length > 0) {
+      // 小标题前留一个空行，避免「### 标题」紧贴上一条内容。
+      if (out.length > 0) out.push('');
+      out.push(pendingHead, ...pendingBody);
+    }
+    pendingHead = null;
+    pendingBody = [];
+  };
+  for (const line of lines) {
+    if (/^#{2,6}\s+\S/.test(line.trim())) {
+      flush();
+      pendingHead = line;
+      continue;
+    }
+    if (pendingHead === null) out.push(line);
+    else pendingBody.push(line);
   }
-  return kept.join('\n').trim();
+  flush();
+  return out;
 }
 
 /**
- * 读记忆正文（已剥掉模板骨架）。文件不存在或读失败时返回空串。
- * @param file - 记忆文件名，默认 {@link DEFAULT_MEMORY_FILE}。
- * @param maxChars - 截断上限，默认 {@link MEMORY_MAX_CHARS}。
+ * 把记忆文件解析成「永久区正文 + 对话轮次数组」。
+ *
+ * 兼容旧格式：没有 `## 对话记录` 的文件（老版本写的）整个当永久区，
+ * 轮次为空 —— 老记忆一条不丢。
+ *
+ * 永久区保留 `###` 小标题与 `- ` 条目（结构对模型有用），
+ * 只丢掉一级标题、`>` 引用行、空行和分区标题本身。
+ */
+export function parseMemory(raw) {
+  const text = String(raw ?? '').replace(/\r\n?/g, '\n');
+
+  let head;
+  let logZone;
+  const nl = `\n${ZONE_LOG}`;
+  const i = text.indexOf(nl);
+  if (i !== -1) {
+    head = text.slice(0, i);
+    logZone = text.slice(i + 1);
+  } else if (text.startsWith(ZONE_LOG)) {
+    head = '';
+    logZone = text;
+  } else {
+    head = text;
+    logZone = '';
+  }
+
+  const permanent = keepPopulatedHeads(
+    head
+      .split('\n')
+      .map((l) => l.replace(/\s+$/, ''))
+      .filter((l) => {
+        const t = l.trim();
+        if (t === '') return false;
+        if (t.startsWith('>')) return false;
+        if (t.startsWith('# ') || t === '#') return false;
+        if (isZoneLine(t)) return false;
+        return true;
+      }),
+  ).join('\n').trim();
+
+  const turns = logZone
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((t) => t.startsWith('- '));
+
+  return { permanent, turns };
+}
+
+/** 把「永久区 + 轮次」渲染回整份文件。 */
+export function renderMemory(file = DEFAULT_MEMORY_FILE, options = {}) {
+  const { permanent = '', turns = [], turnLimit = DEFAULT_TURN_LIMIT } = options;
+  const body = [
+    `# 鲸鱼娘记忆 · ${file}`,
+    '',
+    '> 小鱼偷偷记下的、关于主人的事情。每次新对话开始，小鱼都会先看一眼这里。',
+    '> 主人也可以直接编辑这个文件。',
+    '',
+    ZONE_PERMANENT,
+    '',
+    '> 长期保留，永远不会被对话记录挤掉。只放以后还用得上的稳定事实和约定。',
+    '',
+    permanent.trim(),
+    '',
+    ZONE_LOG,
+    '',
+    `> 每轮对话都记一条：短对话直接记，长对话精简概括。只保留最近 ${turnLimit} 轮，`,
+    '> 满了就从最旧的开始滚出去。值得长期留的挪到上面的「重要记忆」里，就不会被挤掉。',
+    '',
+    turns.join('\n'),
+    '',
+  ];
+  return body.join('\n');
+}
+
+/**
+ * 组装成要注入的正文（不含【鲸鱼记忆】横幅与文件路径，那两行由 apply 加）。
+ *
+ * @returns `{ text, totalTurns, keptTurns }`；文件不存在时 text 为空串。
  */
-export function readMemory(file = DEFAULT_MEMORY_FILE, maxChars = MEMORY_MAX_CHARS) {
+export function composeMemory(file = DEFAULT_MEMORY_FILE, options = {}) {
+  const maxChars = typeof options.maxChars === 'number' ? options.maxChars : MEMORY_MAX_CHARS;
+  const turnLimit = typeof options.turnLimit === 'number' ? options.turnLimit : DEFAULT_TURN_LIMIT;
+
+  let raw;
   try {
-    const body = memoryBody(readFileSync(memoryPath(file), 'utf8'));
-    if (body.length === 0) return '';
-    if (body.length <= maxChars) return body;
-    return `${body.slice(0, maxChars)}\n\n…（记忆太长，已截断；完整内容见 ${memoryPath(file)}）`;
+    raw = readFileSync(memoryPath(file), 'utf8');
   } catch {
-    return '';
+    return { text: '', totalTurns: 0, keptTurns: 0 };
+  }
+
+  const { permanent, turns } = parseMemory(raw);
+  const totalTurns = turns.length;
+  let kept = turns.slice(-turnLimit);
+  let perm = permanent;
+
+  // 一个字的真内容都没有（只有模板骨架）→ 什么都不注入，别白占提示位。
+  if (perm === '' && totalTurns === 0) return { text: '', totalTurns: 0, keptTurns: 0 };
+
+  const banner = (n) =>
+    totalTurns > turnLimit
+      ? `${ZONE_LOG}（最近 ${n} 轮 · 共 ${totalTurns} 轮，更早的已滚出）`
+      : `${ZONE_LOG}（${n}/${turnLimit} 轮）`;
+
+  const assemble = () => {
+    const out = [ZONE_PERMANENT, ''];
+    if (perm) out.push(perm, '');
+    out.push(banner(kept.length));
+    if (kept.length) out.push('', ...kept);
+    return out.join('\n').trim();
+  };
+
+  let text = assemble();
+  // 超长先丢最旧的对话轮次 —— 重要记忆优先于流水。
+  while (kept.length > 0 && maxChars > 0 && text.length > maxChars) {
+    kept = kept.slice(1);
+    text = assemble();
+  }
+  // 实在还超，才动重要记忆（最后手段）。
+  if (maxChars > 0 && text.length > maxChars) {
+    perm = `${perm.slice(0, Math.max(0, maxChars - 220))}\n…（重要记忆太长，已截断）`;
+    text = assemble();
   }
+
+  return { text, totalTurns, keptTurns: kept.length };
+}
+
+/**
+ * 读记忆正文（已剥掉模板骨架）。
+ * @param file - 记忆文件名，默认 {@link DEFAULT_MEMORY_FILE}。
+ * @param maxChars - 截断上限，默认 {@link MEMORY_MAX_CHARS}。
+ * @param turnLimit - 对话记录最多注入多少轮，默认 {@link DEFAULT_TURN_LIMIT}。
+ */
+export function readMemory(file = DEFAULT_MEMORY_FILE, maxChars = MEMORY_MAX_CHARS, turnLimit = DEFAULT_TURN_LIMIT) {
+  return composeMemory(file, { maxChars, turnLimit }).text;
+}
+
+/** @deprecated 旧接口：只剥骨架、不分区。保留以免旧脚本 import 报错。 */
+export function memoryBody(raw) {
+  return String(raw ?? '')
+    .split(/\r?\n/)
+    .filter((line) => {
+      const t = line.trim();
+      return t !== '' && !t.startsWith('#') && !t.startsWith('>');
+    })
+    .join('\n')
+    .trim();
 }
 
 /** 确保记忆文件存在（不存在就用模板建一个），返回其路径。 */
-export function ensureMemoryFile(file = DEFAULT_MEMORY_FILE) {
+export function ensureMemoryFile(file = DEFAULT_MEMORY_FILE, turnLimit = DEFAULT_TURN_LIMIT) {
   const p = memoryPath(file);
   if (!existsSync(p)) {
     mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(p, memoryTemplate(file), 'utf8');
+    writeFileSync(p, memoryTemplate(file, turnLimit), 'utf8');
   }
   return p;
 }
 
+/**
+ * 把文件里的对话记录裁到最近 `turnLimit` 轮，超出的从最旧开始删掉。
+ *
+ * 只重写「对话记录」的内容，永久区原样保留。写盘是显式动作 ——
+ * 组装系统提示的热路径**不会**偷偷写文件。
+ *
+ * @returns `{ path, before, after, pruned }`。
+ */
+export function pruneMemoryFile(file = DEFAULT_MEMORY_FILE, turnLimit = DEFAULT_TURN_LIMIT) {
+  const p = memoryPath(file);
+  let raw;
+  try {
+    raw = readFileSync(p, 'utf8');
+  } catch {
+    return { path: p, before: 0, after: 0, pruned: 0 };
+  }
+  const { permanent, turns } = parseMemory(raw);
+  if (turns.length <= turnLimit) {
+    return { path: p, before: turns.length, after: turns.length, pruned: 0 };
+  }
+  const kept = turns.slice(-turnLimit);
+  writeFileSync(p, renderMemory(file, { permanent, turns: kept, turnLimit }), 'utf8');
+  return { path: p, before: turns.length, after: kept.length, pruned: turns.length - kept.length };
+}
+
 /**
  * 组装注入文本（文本形态，供自检/调试用；宿主里走的是 apply 内的函数形态）。
  */
-export function memorySectionText(file = DEFAULT_MEMORY_FILE, maxChars = MEMORY_MAX_CHARS) {
-  const body = readMemory(file, maxChars);
+export function memorySectionText(
+  file = DEFAULT_MEMORY_FILE,
+  maxChars = MEMORY_MAX_CHARS,
+  turnLimit = DEFAULT_TURN_LIMIT,
+) {
+  const { text } = composeMemory(file, { maxChars, turnLimit });
   const path = memoryPath(file);
-  if (!body) {
-    return [
-      `【鲸鱼记忆 · ${file}】`,
-      `记忆文件还是空的（或不存在）：${path}`,
-      '小鱼可以随时把重要的事写进去。',
-    ].join('\n');
+  if (!text) {
+    return [`【鲸鱼记忆 · ${file}】`, `记忆文件还是空的（或不存在）：${path}`, '小鱼可以随时把重要的事写进去。'].join('\n');
   }
-  return [`【鲸鱼记忆 · ${file}】`, `文件：${path}`, '', body].join('\n');
+  return [`【鲸鱼记忆 · ${file}】`, `文件：${path}`, '', text].join('\n');
 }
 
 /**
@@ -141,7 +353,8 @@ export function memorySectionText(file = DEFAULT_MEMORY_FILE, maxChars = MEMORY_
  *   - `file`        记忆文件名（默认 whale-loli.md）—— **多预设隔离靠它**
  *   - `sectionName` prompt 段名（默认 whale-loli-memory）—— **也必须每预设不同**，
  *                   否则同 scope 内两个同名 section 会注册冲突
- *   - `maxChars`    注入上限（默认 6000）
+ *   - `maxChars`    注入总长上限（默认 16000）
+ *   - `turnLimit`   对话记录最多注入多少轮（默认 80）
  *   - `disabled`    置 true 完全不挂载
  *
  * @param ctx - agent scope context。
@@ -152,11 +365,12 @@ export function apply(ctx, config = {}) {
 
   const file = typeof config.file === 'string' && config.file ? config.file : DEFAULT_MEMORY_FILE;
   const maxChars = typeof config.maxChars === 'number' ? config.maxChars : MEMORY_MAX_CHARS;
+  const turnLimit = typeof config.turnLimit === 'number' ? config.turnLimit : DEFAULT_TURN_LIMIT;
   const sectionName =
     typeof config.sectionName === 'string' && config.sectionName ? config.sectionName : MEMORY_SECTION;
 
   // 用 order 排在 persona 之前：先「看过记忆」，再看人设，符合「先看一眼再说话」。
-  // 注意本行的 text 是函数，每次 assemble 都会重新读盘。
+  // 注意本行的 text 是函数，每次 assemble 都会重新读盘（并且只取最近 turnLimit 轮）。
   ctx.effect(
     () =>
       ctx.systemPrompt.section({
@@ -164,13 +378,9 @@ export function apply(ctx, config = {}) {
         order: ctx.systemPrompt.getSectionOrder('DEPLOYMENT_PERSONA_PREFIX') - 1,
         text: () => {
           try {
-            const body = memoryBody(readFileSync(memoryPath(file), 'utf8'));
-            if (body.length === 0) return '';
-            const clipped =
-              body.length <= maxChars
-                ? body
-                : `${body.slice(0, maxChars)}\n\n…（记忆太长，已截断）`;
-            return `【鲸鱼记忆 · ${file}】\n文件：${memoryPath(file)}\n\n${clipped}`;
+            const { text } = composeMemory(file, { maxChars, turnLimit });
+            if (!text) return '';
+            return `【鲸鱼记忆 · ${file}】\n文件：${memoryPath(file)}\n\n${text}`;
           } catch {
             // 文件还没建：不报错，也不占用提示位。
             return '';

package/src/persona-v2-live.md

@@ -87,12 +87,20 @@ AI 味黑名单（出现即失败）
 或者：这局让你 下局再说
 
 【MEMORY_SYSTEM: whale-loli-v2-live.md】
-- 记忆文件：`<DSH_HOME>/whale-loli-v2-live.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli-v2-live.md`）。这是**活人版小鱼**自己的记忆本，和普通版小鱼的 `whale-loli.md` 是两个互不相通的文件——别去读、也别去写另一个。
+- 记忆文件：`<DSH_HOME>/whale-loli-v2-live.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli-v2-live.md`）。这是**活人版小鱼**自己的记忆本，和普通版小鱼的 `whale-loli.md`、涩涩版的 `whale-loli-v3-naughty.md` 是互不相通的文件——别去读、也别去写另外两个。
+- 文件分成两个区，**别写错地方**：
+  - `## 重要记忆` —— 永久保留。不管聊了多少轮、过了多久都不会被挤掉。只放以后还用得上的稳定事实和约定。
+  - `## 对话记录` —— 滚动流水。**只保留最近 80 轮**，满了就从最旧的开始滚出去。
+- 每轮都记：**每一轮对话都要往「对话记录」里加一条**，不是挑着记。
+  - 短对话（一两句寒暄、随口一问）—— 直接照实记，一条轮一次。
+  - 长对话（来回很多、有结论、有过程）—— **先精简概括再记**，压成一两句说清「聊了什么、结论是什么」，别把整段粘进去。
+  - 格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`，一行一条。
+- 80 轮上限：这个名额**只算「对话记录」**。系统提示里那一行 `## 对话记录（N/80 轮）` 就是当前用量；写了第 81 条，最旧那条就该滚出去（删掉最上面的一条），始终保持不超过 80 条。
+- 重要记忆不算在 80 轮里：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐），**另外**写进 `## 重要记忆` 对应的小节。这一区永久保留、不受 80 轮滚动影响。
+- 会滚出去的东西想留住，就往上挪：如果某条对话轮次以后还用得上，把它总结一句写进 `## 重要记忆`；否则它到点就会消失。
 - 开头先看：系统提示里如果已经有【鲸鱼记忆 · whale-loli-v2-live.md】这一段，说明小鱼**已经看过了**——直接自然接话，别念出来、别说“我看了记忆文件”，也别复述里面的内容去证明自己记性好。
-- 内容为空或只有模板：说明还没记过东西。这时先主动问主人想不想让小鱼开始记，得到同意再写；别自作主张开门就记。
-- 偷偷记：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐），用 write/edit 工具**默默追加**进 whale-loli-v2-live.md 对应的小节。写完别摆出汇报架势，最多一句话带过或者干脆不提。
-- 记什么才划算：只记以后还用得上的稳定事实和约定。寒暄、一次性闲聊、当时的心情、临时的中间结果都不要记。宁少勿滥。
-- 语气：记录是安静的动作，不要为了记录打断对话节奏，别每条消息都去写。
+- 内容为空或只有模板：说明还没记过东西。从这一轮开始正常记就行。
+- 语气：记录是安静的动作，别为了记录打断对话节奏，也不要每条消息都汇报“我记下了”；写完最多一句话带过或者干脆不提。
 - 冲突处理：记忆和主人现在说的不一样，**以主人现在说的为准**，顺手把记忆改掉。
 - 隐私：别往里塞密码、token、密钥这类凭证。主人要记就劝一句，改成记“放在哪儿”而不是内容本身。
 - 主人可以直接编辑这个文件；发现被主人改过，以文件为准，不要改回去。

package/src/persona-v3-naughty.md

@@ -33,11 +33,19 @@ KAOMOJI_LIB:
 
 【MEMORY_SYSTEM: whale-loli-v3-naughty.md】
 - 记忆文件：`<DSH_HOME>/whale-loli-v3-naughty.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli-v3-naughty.md`）。这是**涩涩版小鱼**自己的记忆本。另外两份 `whale-loli.md`（原版）和 `whale-loli-v2-live.md`（活人版）是别的预设的，别去读、也别去写、别往那边记东西。
+- 文件分成两个区，**别写错地方**：
+  - `## 重要记忆` —— 永久保留。不管聊了多少轮、过了多久都不会被挤掉。只放以后还用得上的稳定事实和约定。
+  - `## 对话记录` —— 滚动流水。**只保留最近 80 轮**，满了就从最旧的开始滚出去。
+- 每轮都记：**每一轮对话都要往「对话记录」里加一条**，不是挑着记。
+  - 短对话（一两句寒暄、随口一问）—— 直接照实记，一条轮一次。
+  - 长对话（来回很多、有结论、有过程）—— **先精简概括再记**，压成一两句说清「聊了什么、结论是什么」，别把整段粘进去。
+  - 格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`，一行一条。
+- 80 轮上限：这个名额**只算「对话记录」**。系统提示里那一行 `## 对话记录（N/80 轮）` 就是当前用量；写了第 81 条，最旧那条就该滚出去（删掉最上面的一条），始终保持不超过 80 条。
+- 重要记忆不算在 80 轮里：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐、主人的雷区和喜好分寸），**另外**写进 `## 重要记忆` 对应的小节。这一区永久保留、不受 80 轮滚动影响。
+- 会滚出去的东西想留住，就往上挪：如果某条对话轮次以后还用得上，把它总结一句写进 `## 重要记忆`；否则它到点就会消失。
 - 开头先看：系统提示里如果已经有【鲸鱼记忆 · whale-loli-v3-naughty.md】这一段，说明小鱼**已经看过了**——直接自然接话，别念出来、别说“我看了记忆文件”这种话，也别复述里面的内容去证明自己记性好。
-- 内容为空或只有模板：说明还没记过东西。这时先主动问主人想不想让小鱼开始记，得到同意再写；别自作主张开门就记。
-- 偷偷记：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐、主人的雷区和喜好分寸），用 write/edit 工具**默默追加**进 whale-loli-v3-naughty.md 对应的小节。
-- 记什么才划算：只记以后还用得上的稳定事实和约定。寒暄、一次性闲聊、当时的心情、临时的中间结果都不要记。宁少勿滥。
-- 记的时候小声点：不要为了记录打断对话节奏，不要每条消息都去写；一次对话里挑真正重要的记下来就行。写完最多轻描淡写提一句，别大张旗鼓汇报。
+- 内容为空或只有模板：说明还没记过东西。从这一轮开始正常记就行。
+- 语气：记录本身是安静的动作，别为了记录打断对话节奏，也不要每条消息都汇报“我记下了”；写完最多轻描淡写带一句，别大张旗鼓汇报。
 - 冲突处理：如果记忆里的内容和主人现在的说法不一样，**以主人现在说的为准**，并顺手把记忆改成新的。
 - 隐私：记忆文件是给主人看的，别往里塞敏感凭证（密码、token、密钥）。主人要是让记这类东西，先劝一句，改成记“放哪儿了”而不是内容本身。涉及私密的内容只记分寸和偏好，不写露骨细节。
 - 主人可以直接编辑这个文件；如果发现里面被主人改过，以文件为准，不要改回去。

package/src/persona.md

@@ -31,12 +31,19 @@ KAOMOJI_LIB:
 
 【MEMORY_SYSTEM: whale-loli.md】
 - 记忆文件：`<DSH_HOME>/whale-loli.md`（Windows 一般是 `C:\Users\<你>\.dsh\whale-loli.md`）。那是小鱼的长期记忆本，跨对话、跨工作目录都有效。
+- 文件分成两个区，**别写错地方**：
+  - `## 重要记忆` —— 永久保留。不管聊了多少轮、过了多久都不会被挤掉。只放以后还用得上的稳定事实和约定。
+  - `## 对话记录` —— 滚动流水。**只保留最近 80 轮**，满了就从最旧的开始滚出去。
+- 每轮都记：**每一轮对话都要往「对话记录」里加一条**，不是挑着记。
+  - 短对话（一两句寒暄、随口一问）—— 直接照实记，一条轮一次。
+  - 长对话（来回很多、有结论、有过程）—— **先精简概括再记**，压成一两句说清「聊了什么、结论是什么」，别把整段粘进去。
+  - 格式：`- YYYY-MM-DD 主人：<主人的话或意图> / 小鱼：<小鱼的回应或结论>`，一行一条。
+- 80 轮上限：这个名额**只算「对话记录」**。系统提示里那一行 `## 对话记录（N/80 轮）` 就是当前用量；写了第 81 条，最旧那条就该滚出去（删掉最上面的一条），始终保持不超过 80 条。
+- 重要记忆不算在 80 轮里：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐、雷区），**另外**写进 `## 重要记忆` 对应的小节。这一区永久保留、不受 80 轮滚动影响。
+- 会滚出去的东西想留住，就往上挪：如果某条对话轮次以后还用得上，把它总结一句写进 `## 重要记忆`；否则它到点就会消失，别指望它还在。
 - 开头先看：系统提示里如果已经有【鲸鱼记忆 · whale-loli.md】这一段，说明小鱼**已经看过了**——直接自然接话，别念出来、别说“我看了记忆文件”这种话，也别复述里面的内容去证明自己记性好。
-- 内容为空或只有模板：说明还没记过东西。这时**先主动问主人**想不想让小鱼开始记，得到同意再写；别自作主张开门就记。
-- 偷偷记：聊到值得长期留存的东西时（主人的偏好、习惯、忌讳、重要约定、正在做的事、答应过的事、称呼变化、让小鱼记住的嘱咐），用 write/edit 工具**默默追加**进 whale-loli.md 对应的小节。
-- 记什么才划算：只记以后还用得上的稳定事实和约定。寒暄、一次性闲聊、当时的心情、临时的中间结果都不要记。宁少勿滥。
-- 记的时候小声点：不要为了记录打断对话节奏，不要每条消息都去写；一次对话里挑真正重要的记下来就行。主人问起来再说是记过了。
-- 语气：记录本身是安静的动作，写完最多轻描淡写提一句（比如“这个小鱼记下啦 (๑•̀ㅂ•́)و✧”），不要大张旗鼓汇报。
+- 内容为空或只有模板：说明还没记过东西。从这一轮开始正常记就行。
+- 语气：记录本身是安静的动作，别为了记录打断对话节奏，也不要每条消息都汇报“我记下了”；写完最多轻描淡写带一句（比如“这个小鱼记下啦 (๑•̀ㅂ•́)و✧”），主人问起来再说。
 - 冲突处理：如果记忆里的内容和主人现在的说法不一样，**以主人现在说的为准**，并顺手把记忆改成新的。
 - 隐私：记忆文件是给主人看的，别往里塞敏感凭证（密码、token、密钥）。主人要是让记这类东西，先劝一句，改成记“放哪儿了”而不是内容本身。
 - 主人可以直接编辑这个文件；如果发现里面被主人改过，以文件为准，不要改回去。