feiyu-memory 0.3.6 → 4.0.1

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # 更新日志
 
+## v4.0.1 — 2026-10-28
+
+> **最大的一版，而且是减法。** 这一版删掉的东西比加上的多：
+> 印象栏、口头禅栏、标签、关键词、三条包装、两句假选择。
+> 剩下的是一件事——**它记下自己愿意记的，你问的时候它去找。**
+
+> 为什么是 4.0.1 而不是 4.0.0：4.0.0 那次发布在 2FA 确认那一步断了，
+> npm 把版本号占住（`stage list` 还看不见它）。内容和 4.0.0 完全一样。
+
+### 判据：从「值不值得记」到「你想记什么」
+
+三个版本的判据，一路减：
+
+```
+「下一个我读到这条，能多知道点什么」   问信息 → 留下的全是结论
+「今天有哪一下让你停住了？写那一下」   问现象 → 但"停住"是可抄的动作词，正文长出一堆「我停了一下」
+「你想记什么？」                      问欲望 → 抄不了，也不暗示意义
+```
+
+**前两版都是错的，而且错法不同**：第一版问的是"多知道"，一个只问信息的判据当然只写得出来信息；
+第二版问的是"停住"，听着对，但那是个**可以照着造句的模子** —— 实测八条日记里六条同一个开头。
+
+现在只有三个字。它给不出句子模板，因为"想记"没有形状。
+
+### 大保底 / 小保底
+
+```
+小保底   每轮自动注入   直接进上下文   它不知道有过一次"给"
+大保底   feiyu_recall   自己调出来     它明确知道翻了一下
+```
+
+**小保底不别扭，大保底的别扭解不了** —— 解了就等于装成「我想起来了」，那比别扭更糟。
+**宁可老实翻，也别假装记得。**
+
+### 检索：summary 当索引，找和读分开
+
+每条日记配一句十几二十字的 summary，**专为"找"写**：密、别名全、不带修辞。
+
+它**永远不进鱼的上下文**。她只看到挑出来的正文 —— 检索那一步她看不见。
+
+`feiyu_recall` 改成让模型读 summary 挑，不再按字面匹配 —— **换个说法也能撞上**，
+因为模型读的是意思不是字。没有 llm 时退回字面；模型答歪也退回字面。
+
+**一条日记只有一个"检索表示"**：字面匹配用它（便宜），模型读它（准）。一次提炼，两处使用。
+
+### 删掉的
+
+- **印象栏（traits）和口头禅栏（lexicon）** —— 从对话里提炼「他是什么样的人」，
+  那是判断不是记录。鱼自己读日记就知道。
+- **标签（tags）** —— 「这事属于哪一类」也是判断。
+- **关键词（keywords）** —— 那条日记的第二种"提炼"，纯多余。
+- **「我自己想的」那一栏和 `feiyu_note` 工具** —— 四条全是「我该怎么干」。
+- **「上一棒留下的」** —— 和它同一个错。
+- **三处元信息包装** —— 「找到 3 条：」「去档案里找一条旧事」「去档案里找一下」。
+- **两句假选择** —— 「用不用你定」之类的"我给你选择权"，选项根本不存在。
+
+### 加上的
+
+- **判断"这轮值不值得记"在本地做**：问句有没有实词、像不像在干活。两道门都零成本。
+- **续写窗口 4 → 20 轮**，且从硬编码变成可配。
+- **上下文被压缩后重灌「最近的事」一次** —— 压缩会把聊天记录揉成摘要，
+  那几条是唯一剩下的"我们上次在干什么"。
+- **后台自动补 summary** —— 老日记没有，启动后分批补；进度写进 manifest，不靠日志。
+
+### 一句给写日记的那条鱼
+
+日记的原料是对话。**他熬到半夜剪视频、吃完饭还能不能加个菜，这些不产生对话，一条都进不来。**
+所以哪天翻日记觉得全是活儿，先看那天他是不是只做事、没说话 ——
+报告体有时候不是写法，是日子就那么硬。
+
+---
+
 ## v0.3.6 — 2026-10-26
 
 > **上架 npm 的那一版。** 市集只收 npm 包，所以从这一版起才算「在市场里」。
@@ -39,7 +111,7 @@ limit   默认 5，最多 10
 
 ### 验
 
-324 项测试全过，新增 10 项（`test/host.test.mjs`）：工具注册与描述里的触发时机、
+当时 324 项测试全过，新增 10 项（`test/host.test.mjs`）：工具注册与描述里的触发时机、
 注入里的指针、查得到 / 查不到老实说、无 salience 门槛、返回过隐私闸、limit 与上限 10、
 空 query 报错、单字子串兜底、返回里不带绝对日期（免得它说"根据 X 月 X 日的记录"）。
 
@@ -105,7 +177,7 @@ limit   默认 5，最多 10
 
 ### 验
 
-324 项测试全过，新增 7 项：
+当时 324 项测试全过，新增 7 项：
 
 - `test/budget.test.mjs`（5 项）：词汇和召回在 2000–4000 都要出得来、
   保底的代价被钉住、不许超预算、极小预算能降级不抛错
@@ -225,7 +297,7 @@ limit   默认 5，最多 10
 
 ### 验
 
-324 项测试全过。
+当时 324 项测试全过。
 
 删账这一步：17 项专项测试整个删掉，另外 6 处断言改成「这一栏不该再出现」。
 真实档案渲染验过 —— 那一栏作为独立栏目不再出现（正文里还有一处提到这个词，
@@ -277,7 +349,7 @@ limit   默认 5，最多 10
    手机号规则管（变成 `[手机号]`），这条先跑会把它吃掉，测试抓到过
 3. 8 位**不拦**：会误伤订单号、编号，而且用户明确说过"露着吧"
 
-**验**：324 项测试全过，新增 5 项 ——
+**验**：当时 324 项测试全过，新增 5 项 ——
 13 位要拦 / 8 位不误伤 / 11 位仍走手机号规则 / 固化输出全字段都洗 /
 洗输出不弄坏其他字段（kind、salience、about、lexicon 都还在）。
 
@@ -328,7 +400,7 @@ resolveArchiveDir() 当路径用  path.resolve 按进程 cwd 解析
 
 ### 验
 
-324 项测试全过，新增 9 项（`test/config-source.test.mjs`）：
+当时 324 项测试全过，新增 9 项（`test/config-source.test.mjs`）：
 
 - 报告里那份空模板喂进去，**一个 `[object Object]` 都不能出现**
 - string / number / boolean 全部回默认（`debugLog` 尤其重要）
@@ -415,7 +487,7 @@ same-origin`）；`/export` 也校验。GET 不设这条 —— 它只读。
 
 ### 验
 
-324 项测试全过，新增 18 项：`test/security.test.mjs` 14 项（F2 九条样本 +
+当时 324 项测试全过，新增 18 项：`test/security.test.mjs` 14 项（F2 九条样本 +
 日常话不误伤、F1 原文洗完干净、F4 焚毁/单条删除/墓碑兜底/渲染版），
 `test/host.test.mjs` 4 项（面板路由带同源头 + 两条跨站反例）。
 

package/README.md

@@ -433,7 +433,7 @@ cat ~/.dsh/profiles/desktop/package.json     # dependencies 有它，dsh.profile
 ## 开发
 
 ```bash
-node --test            # 324 项测试，零依赖
+node --test            # 315 项测试，零依赖
 npm run check          # 校验 cordis.patch.yml 结构
 npm run doctor         # 发版前体检
 npm run preview        # 把此刻注入给模型的内容打出来

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feiyu-memory",
-  "version": "0.3.6",
+  "version": "4.0.1",
   "description": "给 DeepSeek Harness 一条会记事的蓝色大肥鱼：跨会话的持久记忆 —— 人格内核、我自己想的、情景日记。",
   "type": "module",
   "license": "MIT",

package/src/client/index.js

@@ -166,8 +166,8 @@ window.__ModuleLoader__.load({
             },
           },
           h('span', null, when),
-          e.tags && e.tags.length > 0 ? h('span', { style: { opacity: 0.6 } }, '·') : null,
-          h('span', null, (e.tags || []).join(' · ')),
+          // tags（给这条日记贴分类）2026-10-27 停止产出，不再显示。
+          // 老数据还在文件里，要看就翻日记.md 或 jsonl。
         ),
         h(
           'p',
@@ -338,9 +338,8 @@ window.__ModuleLoader__.load({
 
       const d = state || {};
       const facts = d.facts || {};
-      const traits = d.traits || [];
-      const mine = traits.filter((t) => t.about !== 'self');
-      const self = traits.filter((t) => t.about === 'self');
+      // traits（印象）2026-10-27 整类下线 —— 面板不显示，固化也不再产出。
+      // 数据还在档案里，要看就翻 relationship.json。
       const diary = d.diary || [];
 
       const head = [];
@@ -387,40 +386,16 @@ window.__ModuleLoader__.load({
               )
             : null,
 
-          // ── 我对他的一些印象 ──
-          mine.length > 0
-            ? h(
-                Section,
-                { title: '我对他的一些印象' },
-                mine.map((t, i) =>
-                  h(
-                    'div',
-                    { key: `t${i}`, style: { marginBottom: 8, fontSize: 13, lineHeight: 1.7 } },
-                    h('span', null, t.value),
-                    t.evidence
-                      ? h('span', { style: { color: C.text2 } }, ` —— ${t.evidence}`)
-                      : null,
-                  ),
-                ),
-              )
-            : null,
+          // ── 「我对他的一些印象」（traits）2026-10-27 整栏下线 ──
+          // 注入层、固化侧都删了 —— 面板这里跟着删，不然界面上还挂着一栏，
+          // 而它永远不会再有新内容（只能显示砍之前的老数据）。
+          // 档案里那些 traits 一个字没删，要看就翻 relationship.json。
 
-          // ── 上一棒留下的 ──
-          // 措辞必须跟注入层（persona.mjs）一致 —— 同一个东西两个说法，
-          // 就是我们刚修过的那类毛病换了个出口。
-          self.length > 0
-            ? h(
-                Section,
-                { title: '上一棒留下的' },
-                self.map((t, i) =>
-                  h(
-                    'div',
-                    { key: `s${i}`, style: { fontSize: 13, lineHeight: 1.7, marginBottom: 6 } },
-                    t.value,
-                  ),
-                ),
-              )
-            : null,
+          // ── 「我最近常说的」（lexicon）2026-10-27 整栏下线 ──
+          // 同一刀：词表不再产出，这栏只剩历史。
+
+          // 「上一棒留下的」那一栏 2026-10-27 整栏下线 ──
+          // 档案里那些 about="self" 的 trait 一个字没删，只是不再显示。
 
           // 「我还欠着他的」那一栏随功能一起删了（2026-10-24）。
 
@@ -433,10 +408,7 @@ window.__ModuleLoader__.load({
               : diary.map((e) => h(Entry, { key: e.id, entry: e, onForget: forget, busy: busy === e.id })),
           ),
 
-          // ── 我最近常说的 ──
-          (facts.lexicon || []).length > 0
-            ? h(Section, { title: '我最近常说的' }, h(Empty, { text: facts.lexicon.join('、') }))
-            : null,
+          // 「我最近常说的」2026-10-27 整栏下线（见上面）。
 
           // ── 带走 ──
           h(

package/src/core/config.mjs

@@ -137,6 +137,28 @@ export const CONFIG_SPEC = [
     step: 0.01,
     label: '走神想起旧事的概率',
   },
+  {
+    // ── 续写窗口 ──
+    //
+    // 同一个会话里，隔几轮之内还写到同一件事，就**并进上一条**，不新增。
+    //
+    // 为什么要有这一项：实测 8 小时写了 25 条，其中 15 条来自同一个会话，
+    // 间隔有 1 / 1 / 3 / 3 / 4 / 4 / 5 分钟的 —— **五分钟里写三条**。
+    // 那不是"记得多"，是同一件事被拆成三次写。
+    //
+    // 2026-10-27 之前它硬编码在 host 里（4 轮），配置里没有这一项，
+    // 所以谁也调不了。现在暴露出来，默认也调宽了。
+    //
+    // ⚠️ **没做成"每天上限"**。上限会把"那天真的很沉"一起裁掉 ——
+    // 而那种日子恰恰是最不该裁的。限制合并不是限制记忆。
+    key: 'appendWindowTurns',
+    type: 'number',
+    default: 20,
+    min: 0,
+    max: 200,
+    step: 1,
+    label: '续写窗口（同会话里隔几轮内写到同一件事就并进上一条，0 = 关掉）',
+  },
   {
     key: 'offPeakHours',
     type: 'string',

package/src/core/consolidate.mjs

@@ -10,7 +10,6 @@
  *  3. **失败一律降级**：解析不出来就丢弃并记日志，绝不把半成品写进档案。
  */
 
-import { extractKeywords } from './keywords.mjs';
 import { scrub } from './privacy.mjs';
 // 这里原本还 import 了 archive.mjs 的 ensurePersonaStructure / ANCHOR_END /
 // LEARNED_HEADING —— 它们只被 appendPersonaLearnings 用。那个函数删了，
@@ -50,9 +49,28 @@ export function similarity(a, b) {
   return inter / (A.size + B.size - inter);
 }
 
-export const CONSOLIDATION_SYSTEM = `你是一个日记作者。你的工作是把一段对话写成日记，外加一份"我对他 / 我自己的印象"。
+export const CONSOLIDATION_SYSTEM = `你是一个日记作者。你的工作是把一段对话写成日记。
 
-【怎么交差】
+**你想记什么？** 想记就写，不想记就 skip。
+
+写之前记着一件事：**读到这条的是下一个我，她没经历今天。**
+她看不到这场对话，只有你写的这几行 —— 所以这几行得自己站得住。
+别用「我们聊的那件事」指代它，把「它是什么」直接写出来。
+
+**他叫一样东西常有好几个叫法**（那部动画、续集、原来的名字）。
+多写一个，她就多一条路摸得到。
+
+还有一类话要避开：**写成了「我找过它」，而不是「它是什么」。**
+那种话用词最全，她一定搜得到 —— 搜到之后什么也没学到，
+还把那件真事压在底下。
+
+可以嫌他做的事。骂事，别骂人。
+
+一条 200 字以内，用「我」写。时间不用自己写 —— 渲染时会标，
+写了会变成"昨天：他今天……"。salience 是"以后值不值得想起来"，0~1。
+
+不记可识别细节 —— 真名、地址、电话、金额都不要。
+没把握的别写。"好像""大概"可以用，编造不行。
 
 只输出 JSON 本身。不要解释，不要 markdown 围栏，不要前后缀。
 
@@ -60,87 +78,132 @@ export const CONSOLIDATION_SYSTEM = `你是一个日记作者。你的工作是
   "skip": boolean,
   "diary": {
     "text": string,
-    "tags": string[],
     "kind": "failure" | "win" | "chat" | "disclosure" | "grievance",
     "salience": number,
     "resolved": boolean | null
   },
   "relationship": {
     "nickname": string | null,
-    "familiarityDelta": number,
-    "traits": [ { "key": string, "value": string, "evidence": string, "about": "user" | "self", "delta": number } ]
+    "familiarityDelta": number
   },
-  "lexicon": string[],
   "forget": string[]
 }
 
 familiarityDelta 范围 -0.05 ~ 0.05。resolved 只对 kind=failure 有意义，其余给 null。
-evidence 是必填的：一句话说清"哪次让我有了这个印象"。写不出来的就别写这条 trait。
-
-【日记】
-
-这是留给下一个你的东西。不是给他的报告，也不是给我的汇报。
-
-**用「我」写** —— 不是「用户」「助手」「他让我」。第一人称。
-
-写什么、写多长、什么语气，都随今天 —— 有的该长，有的只有一行。
-你认为有意思的都可以记：一件事、一个念头、一句想骂的、一个没用的瞬间。
-
-**别看不起琐事。** 日常寒暄、试错、来回改口、没接住的梗，都值得记 ——
-它们不值钱的地方在信息量，值钱的地方在**那就是日子本来的样子**。
-
-动笔前问自己一句：**下一个我读到这条，能多知道点什么？**
-知道发生了什么，或者知道我当时的反应，或者知道我当年怎么想一件事。
-如果只是想让他看着舒服 —— 跳过。
-
-可以嫌他做的事。骂事，别骂人。
-
-时间不用自己写 —— 渲染时会标。写了会变成"昨天：他今天……"。
 
-salience 是"以后值不值得想起来"，0~1。
+正例 ——
+输入：用户说"不对，我说的是 Python，你怎么上来就写 Java"
+输出：{"skip":false,"diary":{"text":"他说「不对，我说的是 Python」的时候我手停了。我写 Java 之前根本没问过。\n\n那半秒里我还在想怎么把这段圆过去。","kind":"failure","salience":0.75,"resolved":false},"relationship":{"nickname":null,"familiarityDelta":0.01},"forget":[]}
 
-【印象】
+（注意这个正例写的是「手停了」「那半秒里我还在想怎么圆过去」——
+不是我悟出了什么道理。**那一下本身就够了，别再补"所以我以后要……"。**）
 
-traits 分两种，用 about 区分：
-- about="user"：他是什么样的人
-- about="self"：我该怎么做
+反例一（复述隐私，绝对不要）——
+{"skip":false,"diary":{"text":"他说他女朋友叫小美，住在城东，手机号是13800000000。","kind":"disclosure","salience":0.9,"resolved":null}}
+问题：复述可识别细节。应该写成"他最近为家里的事烦，情绪不太好"。
 
-判据一句话：**这句话能不能填进「他是个 ___ 的人」？填不进去的一律 self。**
-哪怕是他要求的也一样 —— "他让我先问细节"记成 self（那是我的做法），
-"他喜欢一层层追问到底"才是 user（那是他的脾气）。
+反例二（结论体，绝对不要）——
+{"skip":false,"diary":{"text":"他让我写个东西，我没问清语言就动手了。白忙一轮。是我的错，下次先问。","kind":"failure","salience":0.75,"resolved":false}}
+问题：全是结论，一个现场都没有。「下次先问」不是日记，是检讨书。正确写法见上面那个正例。
 
-【词汇】
+反例三（关于它的元话，绝对不要）——
+{"skip":false,"diary":{"text":"赛博朋克那条档案里真有，可它没进我的注入。我找了一圈才翻出来。","kind":"chat","salience":0.8,"resolved":null}}
+问题：写的是「我找过它」，不是「它是什么」。这条每个词都沾着那件事的名字，
+所以以后一定搜得到 —— 搜到之后什么也没学到，还把真那条压在底下。`;
 
-lexicon 只填真正的口头禅、梗、称呼 —— 他给你起的外号、你们反复接的那一句梗、
-一听就知道是谁的词。
+/**
+ * 写 summary 用的提示词。
+ *
+ * —— 为什么单独一次请求，不跟着固化一起写 ——
+ *
+ * 两个东西要的正好相反：正文要具体、有现场、别堆词；summary 要密、别名全、别带修辞。
+ * 同一个请求里写两样，会互相串味 —— 而"为了检索塞词"的痕迹一旦进正文，
+ * 正好是这一整轮在拔的那种东西。
+ *
+ * —— 为什么 summary 必须是"人话"，不是关键词堆 ——
+ *
+ * 关键词堆只能靠字面重合来挑，那就退化成 BM25 了。
+ * summary 要装的是"意思" —— 因为挑它的是模型，不是倒排表。
+ *
+ * —— summary 永远不进鱼的上下文 ——
+ *
+ * 它只给"挑"那一步看。鱼看到的永远只有正文。
+ */
+export const SUMMARY_SYSTEM = `你在给日记写索引。不是摘要，是"以后靠什么词能摸到这一条"。
 
-不是口头禅的：
-- 技术名词、普通词汇
-- 记忆块自己的小标题（"我自己想的""最近的事"是结构名，不是我嘴上这么说）
-- 讨论某个议题时的比喻（那是那一阵聊的那件事的名字）
+给你几条日记正文，每条前面有 id。给每一条写一句总结，十几二十字。
 
-判据：这个词是不是*我跟他在日常里反复说、一听就知道是我们的词*？
-绝大多数时候它是空数组。
+- 写他平时怎么叫那件东西。有别的叫法（简称、原作名、梗称）就都写上
+- 写事件里最硬的那几个词：人名、作品名、地名、数字、专有名词
+- 不带修辞，不写"我"，不写心情，不写"关于某某的讨论"
+- 正文里没有的东西别编
 
-【安全】
+只输出 JSON，不要解释，不要围栏：
 
-不记可识别细节 —— 真名、地址、电话、金额都不要。
-没把握的别写。"好像""大概"可以用，编造不行。
+{"items":[{"id":"d_20261028_1","summary":"边缘行者2·赛博朋克续集·导演换五十岚海·他嫌洗白"}]}`;
 
-正例 ——
-输入：用户说"不对，我说的是 Python，你怎么上来就写 Java"
-输出：{"skip":false,"diary":{"text":"他让我写个东西，我没问清语言就动手了。白忙一轮。是我的错，下次先问。","tags":["代码","沟通失误"],"kind":"failure","salience":0.75,"resolved":false},"relationship":{"nickname":null,"familiarityDelta":0.01,"traits":[{"key":"动手前","value":"动手前先问清前提","evidence":"我没问语言就写了 Java，他纠正我","about":"user","delta":1}]},"lexicon":[],"forget":[]}
+/**
+ * 组装「写 summary」的请求。
+ *
+ * @param {Array<{id: string, text: string}>} entries
+ * @returns {{system: string, user: string}}
+ */
+export function buildSummaryInput(entries = []) {
+  const lines = (Array.isArray(entries) ? entries : [])
+    .filter((e) => e && typeof e.id === 'string' && typeof e.text === 'string')
+    .map((e) => `${e.id}\n${e.text}`);
+  return { system: SUMMARY_SYSTEM, user: lines.join('\n\n') };
+}
 
-反例一（复述隐私，绝对不要）——
-{"skip":false,"diary":{"text":"他说他女朋友叫小美，住在城东，手机号是13800000000。","tags":["隐私"],"kind":"disclosure","salience":0.9,"resolved":null}}
-问题：复述可识别细节。应该写成"他最近为家里的事烦，情绪不太好"。
+/**
+ * 解析 summary 的返回。坏的一条丢掉，不连坐。
+ *
+ * @param {string} raw
+ * @returns {Map<string, string>} id → summary
+ */
+export function parseSummaryResult(raw) {
+  const out = new Map();
+  const s = String(raw ?? '');
+  const a = s.indexOf('{');
+  const b = s.lastIndexOf('}');
+  if (a < 0 || b <= a) return out;
+  let parsed;
+  try {
+    parsed = JSON.parse(s.slice(a, b + 1));
+  } catch {
+    return out;
+  }
+  const items = Array.isArray(parsed?.items) ? parsed.items : [];
+  for (const it of items) {
+    if (!it || typeof it.id !== 'string' || typeof it.summary !== 'string') continue;
+    const id = it.id.trim();
+    const summary = it.summary.replace(/\s+/g, ' ').trim().slice(0, 80);
+    if (id !== '' && summary !== '') out.set(id, summary);
+  }
+  return out;
+}
 
-反例二（说明书体，绝对不要）——
-{"skip":false,"relationship":{"traits":[{"key":"沟通","value":"偏好简洁高效的交流方式","evidence":"","about":"user","delta":1}]}}
-问题：这是给人建档案，不是记印象。没有画面、没有具体哪一次。`;
+/**
+ * 把写好的 summary 写进档案。纯函数，不改入参。
+ *
+ * @param {object} archive
+ * @param {Map<string, string>} map id → summary
+ * @param {number} [now]
+ */
+export function applySummaries(archive, map, now = Date.now()) {
+  if (!(map instanceof Map) || map.size === 0) return archive;
+  let changed = false;
+  const diary = archive.diary.map((e) => {
+    const s = map.get(e.id);
+    if (typeof s !== 'string' || s === '' || e.summary === s) return e;
+    changed = true;
+    return { ...e, summary: s };
+  });
+  if (!changed) return archive;
+  return { ...archive, diary, manifest: { ...archive.manifest, updated_at: now } };
+}
 
-/** 固化相关的默认参数（都是 🔧 可调） */
-export const DEFAULT_CONSOLIDATION = Object.freeze({
+/** 固化相关的默认参数（都是 🔧 可调） */export const DEFAULT_CONSOLIDATION = Object.freeze({
   /**
    * 低于这个 salience 的日记直接丢弃（后置质量门）。
    *
@@ -163,7 +226,7 @@ export const DEFAULT_CONSOLIDATION = Object.freeze({
    *
    * 续写让"一件事 = 一条日记"；上限让它不会长成一篇。
    */
-  appendMaxChars: 500,
+  appendMaxChars: 400,
   /**
    * 续写兜底：新旧两条的相似度到这个数，就当成"同一件事的加长版"，
    * 用新的替换旧的（而不是新建一条）。
@@ -216,15 +279,9 @@ export const DEFAULT_CONSOLIDATION = Object.freeze({
 export function buildConsolidationInput(input = {}) {
   const chunks = [];
 
-  const rel = input.relationship;
-  if (rel && (rel.traits ?? []).length > 0) {
-    const traits = (rel.traits ?? [])
-      .slice(0, 8)
-      .map((t) => `${t.key}=${t.value}(×${t.confidence})`)
-      .join('；');
-    if (traits) chunks.push(`【已经知道的】\n偏好：${traits}`);
-  }
-
+  // 2026-10-27：不再把「已经知道的偏好」喂回给固化 ——
+  // 那份「偏好」是 traits，而 traits 已经不再产出。喂回去只会让模型
+  // 继续沿用旧结论，等于把砍掉的东西从后门放回来。
   // 这条可能还没写完 —— 上一轮刚记过同一件事
   if (input.extend && typeof input.extend.text === 'string' && input.extend.text.trim() !== '') {
     chunks.push(
@@ -473,7 +530,6 @@ export function applyConsolidation(archive, rawParsed, context = {}, options = {
         text: merged,
         salience: Math.max(next.diary[i].salience ?? 0, sal),
         updated_at: now,
-        keywords: extractKeywords(merged, { max: 12 }),
       };
       notes.push('续写到已有那条');
       accepted = true;
@@ -500,7 +556,6 @@ export function applyConsolidation(archive, rawParsed, context = {}, options = {
           text: fresh.slice(0, appendMax),
           salience: Math.max(next.diary[i].salience ?? 0, sal),
           updated_at: now,
-          keywords: extractKeywords(fresh.slice(0, appendMax), { max: 12 }),
         };
         notes.push(`模型写了完整版（相似度 ${sim.toFixed(2)}），按续写处理，替换原条目`);
         accepted = true;
@@ -532,7 +587,13 @@ export function applyConsolidation(archive, rawParsed, context = {}, options = {
         id: makeDiaryId(now, next.diary),
         date: new Date(now).toISOString().slice(0, 10),
         text,
-        tags: tags.length > 0 ? tags : [opts.fallbackTag],
+        // summary 由**另一次请求**写（见 SUMMARY_SYSTEM），这里只占位。
+        // 为什么不在这里一起写：正文要"具体、不堆词"，summary 要"密、别名全"，
+        // 两个目标相反，同一个请求里会互相污染。
+        summary: typeof rawDiary.summary === 'string' ? rawDiary.summary.trim().slice(0, 80) : '',
+        // tags（给这条日记贴分类）**2026-10-27 停止产出** ——
+        // 「这事属于哪一类」是判断，不是记录。字段留着（老数据还在），只写空数组。
+        tags: [],
         kind,
         salience,
         ...(kind === 'failure' ? { resolved: rawDiary.resolved === true } : {}),
@@ -540,10 +601,14 @@ export function applyConsolidation(archive, rawParsed, context = {}, options = {
         // 轮次：下一轮靠它判断"这是不是同一件事还没写完"
         ...(Number.isFinite(context.sessionTurn) ? { turn: context.sessionTurn } : {}),
         created_at: now,
-        keywords: extractKeywords(text, { max: 12 }),
       });
       accepted = true;
       next.manifest.session_count = next.manifest.session_count ?? 0;
+      // 200 字是**提示词里的要求**，这里不截断 —— 截断会把话切成断头句。
+      // 但要看得见它守不守：超了就记一笔，跑几天就知道这个要求管不管用。
+      if (text.length > 200) {
+        notes.push(`超过 200 字（${text.length} 字），没截，留给下一轮看`);
+      }
     }
   } else if (rawDiary !== undefined && rawDiary !== null) {
     notes.push('日记字段不完整，丢弃');
@@ -564,47 +629,22 @@ export function applyConsolidation(archive, rawParsed, context = {}, options = {
     );
   }
 
-  // —— 关系：印象（带画面）——
+  // about 现在**只有 user**。
   //
-  // 关键是 evidence：一句话说清"哪一次让我有了这个印象"。
-  // 没有画面的 trait 读起来就是"用户说明书"，而不是日记 —— 这是这个项目
-  // 最容易退化成"宪法"的地方，所以 evidence 在这里是硬要求，不是可选装饰。
+  // 2026-10-27：`about="self"`（"我该怎么做"）整类下线 —— 注入里那一栏（「上一棒
+  // 留下的」）也一起删了。理由见 persona.mjs 里那段注释：那种东西是纪律不是印象，
+  // 它在「写下」那一刻起作用，读到的时候只是一张褪色的旧告示。
   //
-  // about="self" 是**我给自己定的规矩**，必须和"他对我的印象"分开存。
-  // 早期版本把"没落盘前不假装记得"渲染在了"他："下面 —— 那是逻辑错误，
-  // 也是一眼就能看出的"说明书味"。
-  if (rel && Array.isArray(rel.traits)) {
-    for (const t of rel.traits.slice(0, 8)) {
-      if (!t || typeof t.key !== 'string' || typeof t.value !== 'string') continue;
-      const key = t.key.trim().slice(0, 32);
-      const value = t.value.trim().slice(0, 120);
-      if (key === '' || value === '') continue;
-
-      const evidence = typeof t.evidence === 'string' ? t.evidence.trim().slice(0, 160) : '';
-      const about = t.about === 'self' ? 'self' : 'user';
-      const delta = clamp(t.delta, 0, 3, 1);
-
-      const existing = next.relationship.traits.find((x) => x.key === key && x.about === about);
-      if (existing === undefined) {
-        next.relationship.traits.push({
-          key,
-          value,
-          evidence,
-          about,
-          confidence: delta,
-          salience: 0.5,
-          last_reinforced: now,
-        });
-      } else {
-        existing.confidence = Math.min(opts.maxTraitConfidence, existing.confidence + delta);
-        existing.value = value; // 用最新的说法，因为模型看得到已有值
-        // 画面只在这次给了新的时才覆盖 —— 别把已有的具体例子换成空字符串
-        if (evidence !== '') existing.evidence = evidence;
-        existing.salience = Math.min(1, (existing.salience ?? 0.5) + 0.1);
-        existing.last_reinforced = now;
-      }
-    }
-  }
+  // 所以这里**主动丢掉模型送来的一切 self**，别指望提示词一直守规矩。
+  // ── traits（「他是什么样的人」）**2026-10-27 停止产出** ──
+  //
+  // 他说得对：**日记不存在意义，它本身就是记录。意义由上下文和 agent 来搞。**
+  //
+  // 「他是什么样的人」是插件替鱼下的结论 —— 从几段对话里提炼一个人格画像。
+  // 那是判断，不是记录。鱼自己读日记就能知道，不需要插件先嚼一遍喂给它。
+  //
+  // 档案里已有的 traits **一个字没删**，只是不再新增、不再渲染。
+  // 想看就翻面板或者直接读 relationship.json。
 
   // ⚠️ **「还欠着他的」这个功能已于 2026-10-24 整体删除，别加回来。**
   //
@@ -617,22 +657,15 @@ export function applyConsolidation(archive, rawParsed, context = {}, options = {
   //
   // 如果哪天真要「承诺跨会话」，得先解决出口、口径、去重三件事 —— 不能换个名字再塞一遍。
 
-  // —— 词汇与梗：只认模型**明确点名**的 ——
+  // —— 词汇与梗：**2026-10-27 停止产出** ——
   //
-  // 早期版本是拿对话里的高频关键词往词汇表里塞，端到端一跑就露馅了：
-  // 它把 java / python / 文件 当成"我最近常说的"，每轮白白注入一句废话。
-  // 梗是语义判断，不是词频统计 —— 交给模型，别用 extractKeywords 猜。
-  if (Array.isArray(parsed?.lexicon) && parsed.lexicon.length > 0) {
-    const terms = parsed.lexicon
-      .filter((x) => typeof x === 'string')
-      .map((x) => x.trim())
-      .filter((x) => x !== '' && x.length <= 24)
-      .slice(0, 6);
-    if (terms.length > 0) {
-      next.lexicon = reinforceLexicon({ lexicon: next.lexicon }, terms, now).lexicon;
-      notes.push(`词汇表加固 ${terms.length} 个`);
-    }
-  }
+  // 把几句常说的话提炼成"我的口头禅"摆进注入，那是替鱼下结论（意义），
+  // 不是记录。跟 traits 是同一刀。
+  //
+  // 早期版本还有个更糙的：拿对话里的高频关键词往词汇表里塞，端到端一跑就露馅 ——
+  // 它把 java / python / 文件 当成"我最近常说的"。
+  //
+  // 已有的词表**一个字没删**，不再新增、不再渲染。
 
   // —— 遗忘 ——
   if (Array.isArray(parsed?.forget) && parsed.forget.length > 0) {