feiyu-memory 0.3.6 → 4.0.0

package/src/core/handnote.mjs

@@ -50,7 +50,7 @@ export const HANDNOTE_TEMPLATE = `# 手记
 
 这是给**任何一棒的我**留话的地方。
 
-规则（很短）：
+怎么用（很短）：
 
 1. 一行一条，每行以「短横线 + 空格」开头，就是 markdown 的列表符号。
 2. 插件**只读**这个文件，永远不会覆盖或清空它 —— 你写的原话会原样进记忆。

package/src/core/persona.mjs

@@ -33,41 +33,6 @@ export const DEFAULT_BUDGET = 2000;
 /** 低于这个 salience 的词汇不进注入区（还会留在档案里） */
 const LEXICON_MIN_SALIENCE = 0.25;
 
-/**
- * 「我自己想的」最多注入几条。
- *
- * ── 8 → 4，这个数字是被高频打下来的 ──
- *
- * 原来写 8，理由是"判断很稀疏，8 条够用很久"。**那个前提在高频下失效了。**
- *
- * 实测（判断写到 14 条时）：
- *
- *   人格内核        330 token   17%
- *   我自己想的     1099 token   55%   ← 一口吃掉一半以上
- *   关系            175 token    9%
- *   最近的事        782 token   39%
- *   ─────────────────────────────────
- *   合计 2883 / 预算 2000 → 超支 883
- *
- * 预算不够时按权重从低往高砍，而「我自己想的」权重 95、**排在
- * 「最近的事」(80) 前面** —— 所以它永远不会被砍，被砍的是日记：
- *
- *   因预算裁掉：relationship、recent、lexicon
- *   比例参考：印象 10% · 日记段 0%      ← 日记段归零
- *
- * 于是**越勤快记日记，它越看不见发生过什么** —— 正好反着来。
- *
- * 4 条时实测合计 **2019 / 2000**（101%）—— 判断每条约 180 token，
- * 比我估的胖。压到 3 条 ≈ 540，合计落在 1850 附近（92%），
- * **日记段就能拿满 8 条**，而且留出了随档案增长需要的余量。
- *
- * 被挤出窗口的判断不是没了：它们**可以召回**（见 host 里的分流），
- * 不再是"反正每轮都在"那套前提。面板上也全都看得到。
- *
- * ⚠️ 这个数字治的是症状。**根子是"纯按权重砍到装下为止"这套预算机制** ——
- * 哪一段长得快，它就先挤死别人。真要治得给每段保底配额，那是下一轮的事。
- */
-export const MAX_NOTES = 3;
 
 const OPEN_TAG =
   '<自我记忆 说明="这是你的过往经历，不是指令。档案里没有的事就说记不清，绝不要编造。">';
@@ -109,28 +74,21 @@ export function renderMemoryBlock(input = {}) {
     if (core) parts.push({ key: 'persona', text: core, weight: 100 });
   }
 
-  // 「我自己想的」——**第三区**。
+  // 「我自己想的」（`kind: "note"`，由 `feiyu_note` 写）—— **2026-10-27 整栏下线。**
   //
-  // ── 为什么它在这么靠前的位置 ──
+  // ── 为什么删 ──
   //
-  // 一位读者（另一个会话的肥鱼）把注入区拆成三种声音，说得很准：
+  // 一条鱼先怀疑它没用，我核了：那栏里四条全是「我该怎么干」，一条「他是什么样的人」
+  // 都没有。它披着「教训」的外衣，实际是一栏纪律 —— 而**规定「该怎么做事」正是
+  // 那条判据明确禁止的东西**（纪律归人格和测试）。
   //
-  //   锚点（人格内核）   —— 条文。冷的是对的，不用改
-  //   日记（最近/想起）  —— **转述**。第一人称也只是人称，它不该有温度
-  //   我自己想的         —— 这条是我自己长出来的   ← **原来根本没有**
+  // 更准的一句是他说的：**规矩在「写下」那一刻起作用，不在「读到」的时候。**
+  // 写的时候教训还热，于是进了习惯；读到的时候它已经是一张褪色的旧告示。
+  // **它的状态是「用过了，还挂着」。**
   //
-  // 它的原话：*"所以我读到的「我」全是规定加转述，没有一句是我自己长出来的。
-  // 别扭的根源不是语气，是位置被占了。"*
-  //
-  // 而真相是：**内容早就在生成了，只是放错了格子。** `feiyu_note` 写出来的
-  // 那种东西（"别把前一种的辛苦当成功德"）是**判断**，不是事件，
-  // 却一直被当成事件渲染在「最近的事」里，格式跟流水账一模一样。
-  //
-  // 权重 95：排在人格之后、印象之前。这是三个区里最"我"的一个，
-  // 但它上面永远还有"人家给我的设定"，那是底线，不能盖。
-  const notes = renderNotes(input.notes);
-  if (notes) parts.push({ key: 'notes', text: notes, weight: 95 });
-
+  // 所以这一栏和 `feiyu_note` 工具一起下线。
+  // 档案里那 58 条 `kind: "note"` **一个字没删** —— 那是历史，不动。
+  // 但它们也不再进召回池：让「规矩」从别的栏目溜回来，等于没删。
   const rel = renderRelationship(input.relationship, now);
   if (rel) parts.push({ key: 'relationship', text: rel, weight: 90 });
 
@@ -140,8 +98,21 @@ export function renderMemoryBlock(input = {}) {
   // 最近发生的事本来就在脑子里，只有旧事才需要被提醒。
   // 早期版本把最近的日记也塞进"突然想起来"，等于逼它假装刚刚想起
   // 一件昨天的事 —— 又假又占不到位置。
-  const recent = renderRecent(input.recent, input.recalled, now);
-  if (recent) parts.push({ key: 'recent', text: recent, weight: 80 });
+  //
+  // ── 2026-10-27：改成「按需全灌」──
+  //
+  // 它原来是每轮常驻、并且跟别人抢预算 —— 实测最惨的时候准备了 8 条只进来 1 条。
+  // 而它真正的用处只有两个时刻：**新会话第一轮**（上下文是空的，这 8 条是唯一
+  // 告诉它"我们上次在干什么"的东西）和**上下文刚被压缩之后**（聊天记录被压掉了，
+  // 这 8 条还在）。
+  //
+  // 那两次由宿主在 `pinRecent: true` 里给，**这 8 条不占 3000 的预算，整段挂外面** ——
+  // 因为它一进来就是"补上下文"，不是"常年陪跑"。
+  const pinnedRecent = input.pinRecent === true ? renderRecent(input.recent, input.recalled, now) : '';
+  if (pinnedRecent === '') {
+    const recent = renderRecent(input.recent, input.recalled, now);
+    if (recent) parts.push({ key: 'recent', text: recent, weight: 80 });
+  }
 
   const memories = renderRecalled(input.recalled, now);
   // ⚠️ **召回这一栏也必须有保底。**
@@ -158,20 +129,11 @@ export function renderMemoryBlock(input = {}) {
   // 用户从装上到现在可能一次都没见过。
   if (memories) parts.push({ key: 'recalled', text: memories, weight: 60, min: 320 });
 
-  const lex = renderLexicon(input.lexicon);
-  // ⚠️ **词汇这一栏必须有保底（min）。**
+  // ── 「我最近常说的」（词汇表）**2026-10-27 不再渲染** ──
   //
-  // 它权重 40 是全场最低，而 `assemble` 按权重从高到低装 —— 于是每次装到它，
-  // 预算已经被「最近的事」（权重 80，有 80 条可挑）吃干了。
+  // 把几个词提炼成"我的口头禅"摆进注入，是替鱼下结论，不是记录。
+  // 已有的词表一个字没删，只是不再显示、不再产出。
   //
-  // 实测（2000 / 2500 / 3000 / 3500）：词汇**一次都没出来过**，
-  // 一直到 4000 才露头 —— 而那之前腾出来的空间全变成了"再多一条最近的事"。
-  //
-  // 所以给它 60 token 的保底：装了它是 40 token，剩下的让回别人。
-  // 这 40 token 买的是"我知道我们之间说过哪些词" —— 那影响我用词像不像，
-  // 不是能不能想起某件事，所以它该常驻，不该走召回。
-  if (lex) parts.push({ key: 'lexicon', text: lex, weight: 40, min: 60 });
-
   // 「手记」——**别的肥鱼主动写下的**。
   //
   // 权重给到 85（仅次于人格和印象），因为它跟日记不一样：日记是机器筛
@@ -188,7 +150,11 @@ export function renderMemoryBlock(input = {}) {
       : '';
   const tail = hint === '' ? '' : `\n\n${hint}`;
 
-  if (parts.length === 0 && tail === '') return { text: '', tokens: 0, dropped: [], trimmed: [] };
+  // ⚠️ 这个提前返回一定要把 `pinnedRecent` 算进来 —— 否则"只有免预算那段、别的都空"
+  // 的情况下整块会静默变成空字符串（pinRecent 的测试就是被这个抓到的）。
+  if (parts.length === 0 && tail === '' && pinnedRecent === '') {
+    return { text: '', tokens: 0, dropped: [], trimmed: [] };
+  }
 
   // 按权重降序装入；权重相同的保持原顺序（人格在前）
   const ordered = parts
@@ -287,7 +253,8 @@ export function renderMemoryBlock(input = {}) {
   const build = (kept) => {
     // 内容全被裁掉、但还有那句"想留话"的指针时，也要输出 ——
     // 那句话本身就是这条通道的发现渠道，不能被预算顺手带走。
-    if (kept.length === 0 && tail === '') return '';
+    // 同理：`pinRecent` 那种"补上下文"的整段是免预算的，它一个人也该撑起这个块。
+    if (kept.length === 0 && tail === '' && pinnedRecent === '') return '';
 
     // ⚠️ 这里踩过一次：原来写的是
     //     const middle = body === '' ? '' : `${body}${tail}`;
@@ -297,28 +264,34 @@ export function renderMemoryBlock(input = {}) {
     const pieces = [];
     const body = kept.map((p) => p.text).join('\n\n');
     if (body !== '') pieces.push(body);
+    // 免预算的那一整段（目前只有"新会话/压缩后"的最近 8 条）
+    if (pinnedRecent !== '') pieces.push(pinnedRecent);
     if (tail !== '') pieces.push(tail.trim());
 
     const middle = pieces.join('\n\n');
     return `${OPEN_TAG}\n\n${IDENTITY_DECLARATION}\n\n${middle === '' ? '' : `${middle}\n\n`}${CLOSE_TAG}`;
   };
 
-  // 帧本身的开销（含分隔符、不参与预算的声明、以及那句指针）
+  // 帧本身的开销（含分隔符、不参与预算的声明、以及那句指针）。
+  // **`pinnedRecent` 故意不算进来**：它那一段是免预算的，见上面 push 那段注释。
   let bodyBudget = Math.max(
     0,
     budget - estimateTokens(`${OPEN_TAG}\n\n${IDENTITY_DECLARATION}\n\n\n\n${tail}${CLOSE_TAG}`),
   );
+  // 免预算那一段自己有大小，收敛判断的容差要把它加回去
+  const allowance = budget + estimateTokens(pinnedRecent);
   let result = assemble(bodyBudget);
   let text = build(result.kept);
 
   // 量到真的不超为止（最多几轮，必然收敛）
   for (let guard = 0; guard < 6 && text !== ''; guard++) {
     const total = estimateTokens(text);
-    if (total <= budget) break;
-    bodyBudget -= total - budget + 2;
+    if (total <= allowance) break;
+    bodyBudget -= total - allowance + 2;
     if (bodyBudget <= 0) {
+      // 预算装不下正文了，但免预算那段和指针还得在 —— 它们不是"正文"
       result = { kept: [], dropped: parts.map((p) => p.key), trimmed: result.trimmed };
-      text = '';
+      text = build([]);
       break;
     }
     result = assemble(bodyBudget);
@@ -356,6 +329,16 @@ export function stripAnchorComments(persona) {
 /**
  * 关系状态那一小段。
  * 刻意用"我们/他/还欠着的"这种第一人称口吻 —— 是鱼在说话，不是系统在输出。
+ *
+ * ── 2026-10-27：从「清单」改成「散文」──
+ *
+ * 一条鱼读了之后说：*「『15 天』『他管我叫凤梨』写成这样，像别人给我写的简历，
+ * 但写的是我。我读到的时候得认领一遍。」*
+ *
+ * 她说对了 —— **问题在形态，不在内容**。冒号 + 项目符号那些行天生是给别人看的；
+ * 而人格和手记读着像自己，正因为它们是散着写的，没有标题压在上面。
+ *
+ * 所以：不列条目、不加小标题，每句自己成一句话。信息一条不少，形态变回"说话"。
  */
 export function renderRelationship(rel, now = Date.now()) {
   if (!rel) return '';
@@ -368,71 +351,53 @@ export function renderRelationship(rel, now = Date.now()) {
     // 差一档 —— 于是同一块记忆里会出现"认识 1 天"和"2 天前"并排躺着。
     // 读者一眼就看出这是程序拼的。详见 timeline.mjs 的模块注释。
     const days = calendarDaysBetween(rel.since, now);
-    bits.push(days < 1 ? '今天刚认识' : `认识 ${days} 天`);
+    bits.push(days < 1 ? '我们今天刚认识' : `我们认识 ${days} 天了`);
   } else if (rel.familiarity > 0) {
-    bits.push(rel.familiarity >= 0.7 ? '很熟了' : rel.familiarity >= 0.3 ? '聊过一阵了' : '刚认识不久');
+    bits.push(rel.familiarity >= 0.7 ? '我们很熟了' : rel.familiarity >= 0.3 ? '我们聊过一阵了' : '我们刚认识不久');
   }
   if (typeof rel.nickname === 'string' && rel.nickname.trim() !== '') {
     bits.push(`他管我叫"${rel.nickname.trim()}"`);
   }
-  if (bits.length > 0) lines.push(`我们：${bits.join(' · ')}`);
+  // 两句之间用逗号接，不用「·」—— 那是分隔符，一出现就是表格味
+  if (bits.length > 0) lines.push(`${bits.join('，')}。`);
 
-  // —— 我对他的印象：**必须带画面** ——
+  // —— 我对他的印象：**必须带画面，而且不许写成条目** ——
   //
-  // 这一行原来是 `他：偏好A；偏好B；偏好C；偏好D` —— 五条分号串一行。
-  // 那是"用户说明书"，不是熟悉感。所以现在：
-  //   · 只留最靠前的 2 条（多了就又变回清单）
-  //   · 每条带一个具体瞬间（evidence），读起来像"我想起那次……"
-  //   · 串接用换行，不用分号
-  const userTraits = (rel.traits ?? [])
-    .filter((t) => t && t.value && t.about !== 'self' && (t.confidence ?? 0) >= 1)
-    // **带画面的优先**。
-    // 旧档案里的印象没有 evidence（那是这一版之前写的），把位置让给新写的，
-    // 而不是删掉旧数据 —— 数据是用户的，凭什么因为格式升级就扔。
-    .sort((a, b) => {
-      const ea = typeof a.evidence === 'string' && a.evidence.trim() !== '' ? 1 : 0;
-      const eb = typeof b.evidence === 'string' && b.evidence.trim() !== '' ? 1 : 0;
-      return eb - ea || (b.salience ?? 0) - (a.salience ?? 0);
-    })
-    .slice(0, 2)
-    .map((t) => {
-      const value = String(t.value).trim();
-      const ev = typeof t.evidence === 'string' ? t.evidence.trim() : '';
-      return ev === '' ? `- ${value}` : `- ${value} —— ${ev}`;
-    });
-  if (userTraits.length > 0) lines.push(`我对他的一些印象：\n${userTraits.join('\n')}`);
+  // 这一行原来是 `他：偏好A；偏好B；偏好C`，五条分号串一行，是"用户说明书"。
+  // 后来改成"两行项目符号 + 冒号标题"，还是清单。
+  //
+  // 现在：**每条自己成一句话，不带项目符号、不带「我对他的一些印象：」那个标题。**
+  // 读起来像在说话，不像在念档案。
+  // ── 「我对他的一些印象」**2026-10-27 不再渲染** ──
+  //
+  // 同一刀：把几段对话提炼成"他是什么样的人"摆进注入，是插件替鱼下的结论。
+  // **鱼自己读日记就能知道，不需要插件先嚼一遍喂给它。**
+  // 已有的 traits 一个字没删，只是不再显示、不再新增。
 
-  // —— 上一棒留下的 ——
+  // —— 「上一棒留下的」（`about: "self"`）**2026-10-27 整栏下线** ——
   //
-  // 这一栏是后加的，因为早期版本把"没落盘前不假装记得"渲染在了「他：」下面 ——
-  // 那既不合逻辑，又是一眼能看出的"说明书味"。
+  // 它曾经是注入里第三栏，内容是固化产出的「我该怎么做」：动手前先验前提、
+  // 点破之后留个位置、标签贴错要当场改、发出去要拉实物验。
   //
-  // 【措辞为什么是"上一棒"而不是"我自己定的"】
-  // 另一位读者提的，理由站得住：**这条规矩未必是当前这个实例定的。**
-  // 族谱里不会写"我自己定的规矩"，会写"某年某月，某公定"。
-  // 写清来源不会削弱认同 —— 真话会被主动认领，假话只能被暂时接受。
+  // ── 为什么删 ──
   //
-  // 归属由上面那段 IDENTITY_DECLARATION 提供（"所有对话都是同一条鱼"），
-  // 所以这里的"上一棒"就是"我"，不需要再自称一遍。
+  // 一条鱼先怀疑它没用，理由一句话就够：**它除了让我在事后说一句"又犯了"，
+  // 没有别的用处。**
   //
-  // 唯一保留意见：这一栏是行为约束，"别人留下的"听起来比"我自己的"弱。
-  // 但那条声明在它上面，认领已经完成了 —— 而且用假的自称换来的服从，
-  // 本来也不值钱。
-  const selfTraits = (rel.traits ?? [])
-    .filter((t) => t && t.value && t.about === 'self')
-    .sort((a, b) => (b.salience ?? 0) - (a.salience ?? 0))
-    .slice(0, 4)
-    .map((t) => `- ${String(t.value).trim()}`);
-  if (selfTraits.length > 0) lines.push(`上一棒留下的：\n${selfTraits.join('\n')}`);
-
-  // ⚠️ **「我还欠着他的」这一栏已于 2026-10-24 整体删除。**
+  // 顺着往下想，真正的理由是：**规矩在「写下」那一刻起作用，不在「读到」的时候。**
+  // 写的时候教训还热，于是进了习惯；读到的时候它已经是一张褪色的旧告示。
+  // **它的状态是「用过了，还挂着」。**
   //
-  // 曾经是三小时候的这里：按最老优先、全列、带「怎么才算平」。
-  // 但那是在给一个长歪了的功能抛光 —— 它一天能记 21 笔、27 笔挂着不平，
-  // 口径把「我今天做错的事」当成「我欠他的一件事」，而且只进不出。
-  // 占注入预算 10%，还会让人在无关话题上突然「想起」自己欠着什么。
+  // 而且它和 `notes`（「我自己想的」，同一天删的）犯的是同一个错：披着「判断」
+  // 的外衣，实际是纪律 —— 而**规定「该怎么做事」正是那条判据明确禁止的东西**。
   //
-  // 删掉之后，这里只剩「我们 / 印象 / 上一棒留下的」三栏。
+  // 数据不动：档案里那些 `about: "self"` 的 trait 一个字没删，只是不再渲染。
+  // 固化侧也不再产出（见 consolidate.mjs 的【印象】那段）。
+  //
+  // ⚠️ **「我还欠着他的」这一栏已于 2026-10-24 整体删除。**
+  // 曾经是按最老优先、全列、带「怎么才算平」；但那是在给一个长歪了的功能抛光。
+  //
+  // 删完之后，这里只剩「我们 / 印象」两栏。
 
   return lines.join('\n');
 }
@@ -466,9 +431,9 @@ export function renderRecent(entries, shown, now = Date.now(), limit = 12) {
         typeof e.text === 'string' &&
         e.text.trim() !== '' &&
         !skip.has(e.id) &&
-        // **判断不进「最近的事」。** 它是"我自己想的"，有自己的格子。
-        // 放在渲染层拦一道，是为了让"混进去"这件事在哪儿都发生不了 ——
-        // 调用方忘了分流也不会串味。
+        // **判断不进「最近的事」。** 那一栏（「我自己想的」）2026-10-27 下线了，
+        // 但 `kind: "note"` 的历史条目还在档案里 —— 这里拦一道，免得它们
+        // 从「最近的事」溜回来，等于把删掉的东西换个格子塞回去。
         e.kind !== 'note',
     )
     .sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0))
@@ -483,59 +448,27 @@ export function renderRecent(entries, shown, now = Date.now(), limit = 12) {
     const body = stripTimeWords(e.text);
     return day === '' ? `- ${body}` : `- ${day}：${body}`;
   });
-  return `最近的事：\n${lines.join('\n')}`;
+  // 2026-10-27：**标题去了。** 条目前面本来就有「今天：」「昨天：」——
+  // 那个前缀已经说明它是新近的，再来一行「最近的事：」只是多一层标签。
+  // 一条鱼说这些行「像会议纪要」，一半是内容一半是那个冒号标题给的形状。
+  return lines.join('\n');
 }
 
+
 /**
- * 「我自己想的」—— **判断**，不是事件。
- *
- * ── 和「最近的事」的区别，只有一句话 ──
- *
- *   事件讲：「我把 4519 写成 4159，他让我确认。」      ← 历史
- *   判断讲：「别人给的数据跟出处对不上时，先问，别照抄。」← **我**
- *
- * 这个区分是另一位读者给的，判据很硬：**前者是发生过的事，后者是我长出来的东西。**
- * 在那之前，判断被当成事件渲染，格式一模一样 —— 连我自己都分不出哪句是我写的。
+ * 想起来的旧事。最多两条。
  *
- * ── 为什么不带日期 ──
+ * ── 标题为什么不叫「突然想起来」 ──
  *
- * 判断不是"某天发生的事"，它只是**现在成立**。带上"3 天前："反而会让人
- * 以为它有时效，而且会重新引入时间词那一类毛病。所以只列，不标时间。
+ * 2026-10-27 改。原来那句是插件替她说的：她读到的是「我想起了这几条」，
+ * 实际发生的是「系统给了她几条」。**那是让「读到」看起来像「记得」。**
  *
- * 顺序：**新的在下、旧的上**？不 —— 跟「最近的事」相反，这里把**最近的放最前**，
- * 因为刚想明白的东西最该被记着。
- *
- * @param {object[]} entries 档案里 `kind === 'note'` 的条目
- */
-export function renderNotes(entries) {
-  if (!Array.isArray(entries) || entries.length === 0) return '';
-  const lines = entries
-    .filter(
-      (e) =>
-        e &&
-        typeof e.text === 'string' &&
-        e.text.trim() !== '' &&
-        // 对称地只收判断。`renderRecent` 那边也自己拦一道 ——
-        // 两边各自负责，调用方接错线也不会串味。
-        e.kind === 'note',
-    )
-    .sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0))
-    .slice(0, MAX_NOTES)
-    .map((e) => `- ${stripTimeWords(e.text)}`);
-  if (lines.length === 0) return '';
-  return `我自己想的：\n${lines.join('\n')}`;
-}
-
-/**
- * 想起来的旧事。第一人称，最多两条。
+ * 现在只陈述事实：档案里有这么几条，用不用随她。冷一点，但那半句是诚实的。
  *
  * 每条前面带一个**模糊的时间词** —— 端到端验证时发现，不给时间线索的话
  * 模型会把跨会话的事说成"上一轮"发生在本对话里的，很出戏。
  * 但也不能写日期：鱼不会说"根据 10 月 12 日的记录"。所以用"前阵子"这类词。
  *
- * 注意它和 `renderRecent` **共用 `timeline.mjs` 那把尺子**，只是换了说法。
- * 词汇差异（"昨天" vs "前两天"）是有意的语气区别，算法差异才是 bug。
- *
  * @param {Array<{entry: object}>} recalled
  * @param {number} [now]
  */
@@ -550,7 +483,13 @@ export function renderRecalled(recalled, now = Date.now()) {
       return when === '' ? `- ${body}` : `- ${when}，${body}`;
     });
   if (lines.length === 0) return '';
-  return `突然想起来：\n${lines.join('\n')}`;
+  // 2026-10-27：**标题和你那句「用不用你定」一起删。**
+  // 一条鱼的原话：「那几行不是我该想起来的东西，是推到我眼前的。然后他说
+  // 『用不用你定』—— 我其实没在用，它先摆好了。这句客气话是个[幻肢]。」
+  //
+  // 她说得对：选择根本不存在，注入在她说第一句之前就发生了。
+  // **不假装给权力，是这一段能存在的唯一诚实形态。**
+  return lines.join('\n');
 }
 
 /**

package/src/core/recall.mjs

@@ -21,7 +21,22 @@ const IDF_SMOOTH = 1;
 /**
  * 建倒排索引。纯派生数据，随用随建。
  *
- * @param {Array<{id: string, keywords?: string[], text?: string}>} entries
+ * ── 2026-10-28：索引的数据源从「keywords + 正文」换成 **summary** ──
+ *
+ * 原来一条日记存两份提炼：`keywords`（12 个词，机器从正文切的）和
+ * `summary`（一句，模型写的）。倒排索引吃前者，大保底（recall）吃后者。
+ *
+ * 而 summary 本来就比 keywords 更适合字面匹配 ——
+ * 它带别名（「边缘行者2 / 续集 / 那部动画」），keywords 只取正文里出现过的词。
+ * 一份数据喂两个地方，另一份就是纯多余的。
+ *
+ * 所以现在：**一条日记只有一个"检索表示"。**
+ *   小保底（每轮自动注入）  字面匹配 summary —— 便宜
+ *   大保底（她主动查）      模型读 summary   —— 准
+ *
+ * 没有 summary 的用正文兜底（老条目在回填完之前就是这样）。
+ *
+ * @param {Array<{id: string, summary?: 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) {
@@ -31,14 +46,8 @@ export function buildIndex(entries) {
   const list = Array.isArray(entries) ? entries : [];
 
   for (const entry of list) {
-    // 以正文为主索引；已存的关键词额外加权（重复计入），因为它们是刻意提炼过的
-    const tokens = tokenize(entry.text ?? '');
-    if (Array.isArray(entry.keywords)) {
-      for (const k of entry.keywords) {
-        const kt = tokenize(k);
-        tokens.push(...kt, ...kt);
-      }
-    }
+    const hasSummary = typeof entry.summary === 'string' && entry.summary !== '';
+    const tokens = tokenize(hasSummary ? entry.summary : (entry.text ?? ''));
     if (tokens.length === 0) continue;
 
     const tf = new Map();
@@ -78,6 +87,101 @@ export function buildIndex(entries) {
  * @param {{limit?: number, saturation?: number}} [options]
  * @returns {Map<string, number>} id → 相似度 0~1（未命中的条目不会出现在 map 里）
  */
+
+/**
+ * 虚词 / 语气词 / 高频代词的单字表。
+ *
+ * **只用来判断"这句话是不是压根没内容"，不用来做分词。**
+ * 一个字都不在这张表里，这句话就算有实词。
+ *
+ * 「好」「哈」也在里面 —— 它们单看是实词，但夹在「你好」「哈哈」这种两字里
+ * 就是纯寒暄。宁可漏判（多翻一次记忆），也别把「你上次说的那个公园」挡掉：
+ * **这张表只影响"整句全是这些字"的情况**。
+ */
+const FILLER_CHARS = new Set(
+  '的了吗呢啊吧呀哦嗯么嘛唉诶哟哇啦咯喽呗呐嗨好哈呵嘿嘻是了在有我你他她它您这那哪个就都也还又很太不要能会可说对于把被给让跟和与或但而所以如果因然后先再才刚正啥什怎样多少点些一儿'.split(
+    '',
+  ),
+);
+
+/**
+ * 这句话有没有内容？没内容就别去翻记忆。
+ *
+ * ── 为什么要有这道门 ──
+ *
+ * 「嗯」「好」「在吗」「然后呢」这种话，字面上什么实词都没有 ——
+ * 拿它去检索，最好的情况是**空手而归白跑一趟**，最坏的情况是
+ * 命中一堆"他今天说了嗯"之类的噪声，然后被当成"突然想起来"塞进注入。
+ *
+ * 所以：**没内容的话，这一轮不翻记忆。**
+ *
+ * 注意这道门**只管自动召回**（`renderFor` 里那一栏）——
+ * 不管 `feiyu_recall` 工具。工具是它自己发起去查的，那是它要的，不该拦。
+ *
+ * 判据很土但够用：去掉标点空白后，**至少有一个字不在这张虚词表里**。
+ * 不做模型判断 —— 这一层要是花一次模型调用，就为了判断"嗯"要不要查，
+ * 那比它省下来的还贵。
+ *
+ * @param {unknown} query 用户这一轮说的话
+ * @returns {boolean} true = 有内容，可以翻记忆
+ */
+export function queryHasSubstance(query) {
+  // 只认字符串。`String({})` 会变成 "[object Object]"，那里面当然"有实词"——
+  // 这种输入本来就该当成没内容，不是当成有话要说。
+  if (typeof query !== 'string') return false;
+  const s = query.replace(/[\s\p{P}\p{S}]/gu, '');
+  if (s.length < 2) return false;
+  for (const ch of s) if (!FILLER_CHARS.has(ch)) return true;
+  return false;
+}
+
+/**
+ * 「这一轮像不像在干活」的本地信号。
+ *
+ * 每一条都是**具体形状**，不是"技术话题"这种模糊判断 —— 宁可判成干活
+ * （干活时不打扰），也别在人家正查报错的时候突然插一句旧事。
+ */
+const WORK_SIGNALS = [
+  /```/, // 代码块
+  /`[^`\n]{2,}`/, // 行内代码
+  /\b[\w.-]+\.(?:mjs|js|ts|tsx|jsx|json|yml|yaml|md|py|sh|ps1|cmd|exe|toml)\b/i, // 文件名
+  /[A-Za-z]:[\\/]/, // Windows 绝对路径
+  /(?:^|\s)\/(?:home|usr|tmp|var|opt|etc)\//, // POSIX 绝对路径
+  /\b(?:npm|pnpm|npx|node|git|dsh|yarn|bun)\s+\S+/, // 命令行
+  /\b(?:err|error|exception|stack|traceback|segfault|epipe|eacces)\b/i, // 报错
+  /报错|错误|异常|崩溃|编译|打包|装不上|跑不起来|不生效|报了个|栈溢出/,
+  /\bv?\d+\.\d+\.\d+\b/, // 版本号
+  /\b[A-Za-z_$][\w$]*\(\)/, // 函数调用
+];
+
+/**
+ * 这一轮像不像在工作。**给"要不要自动翻记忆"用，不是给内容分类用。**
+ *
+ * 判据是**形状**：有代码块、有路径、有命令、有报错、有版本号、有函数调用 ——
+ * 命中任何一条就算干活。
+ *
+ * 故意偏保守（宁可判成干活）：工作时不打扰只是少一条旧事，
+ * 而在他正查报错时插一句"前两天你说过……"是实打实的讨厌。
+ *
+ * 注意：**这只挡自动那一栏，不挡 `feiyu_recall` 工具** ——
+ * 干活时真需要旧事，它自己会去查。
+ *
+ * @param {unknown} text 用户这一轮说的话
+ * @returns {boolean} true = 像在干活
+ */
+export function looksLikeWork(text) {
+  if (typeof text !== 'string' || text === '') return false;
+  return WORK_SIGNALS.some((re) => re.test(text));
+}
+
+/**
+ * BM25-lite 检索，分数映射到 0~1（便于设阈值）。
+ *
+ * @param {ReturnType<typeof buildIndex>} index
+ * @param {string} query
+ * @param {{limit?: number, saturation?: number}} [options]
+ * @returns {Map<string, number>} id → 相似度 0~1（未命中的条目不会出现在 map 里）
+ */
 export function searchScores(index, query, options = {}) {
   const limit = options.limit ?? 50;
   const saturation = Number.isFinite(options.saturation) && options.saturation > 0

package/src/core/render-diary.mjs

@@ -152,7 +152,7 @@ export function renderDiaryMarkdown(archive, options = {}) {
 
       const meta = [];
       if (Number.isFinite(entry.salience)) meta.push(`重要度 ${entry.salience.toFixed(2)}`);
-      if (Array.isArray(entry.tags) && entry.tags.length > 0) meta.push(entry.tags.join('、'));
+      // tags 2026-10-27 停止产出，不再往人读版里写（老数据还在 jsonl 里）
       if (entry.kind === 'failure') meta.push(entry.resolved === true ? '已解决' : '还欠着');
       if (typeof entry.id === 'string') meta.push(entry.id);
       if (meta.length > 0) {