feiyu-memory 0.3.6 → 4.0.0

package/src/host/index.mjs

@@ -40,10 +40,10 @@ import {
 // 原来的 evaluateGate 那套关键词闸门拆了（见 turn-stopping 里的注释）。
 // SUPPRESS_RE 留着 —— "别记"是用户的控制，不是启发式。
 import { SUPPRESS_RE } from '../core/gate.mjs';
-import { buildIndex, selectMemories, searchScores, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
+import { buildIndex, selectMemories, searchScores, queryHasSubstance, looksLikeWork, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
 import { overlap } from '../core/keywords.mjs';
 import { scrub } from '../core/privacy.mjs';
-import { renderMemoryBlock, DEFAULT_BUDGET, MAX_NOTES } from '../core/persona.mjs';
+import { renderMemoryBlock, DEFAULT_BUDGET } from '../core/persona.mjs';
 import { calendarDaysBetween, stripTimeWords, softWhen } from '../core/timeline.mjs';
 import { renderDiaryFile } from '../core/render-diary.mjs';
 import { buildJudgeInput, parseVerdict, JUDGE_MAX_TOKENS } from '../core/judge.mjs';
@@ -56,6 +56,9 @@ import {
   makeDiaryId,
   ConsolidationParseError,
   DEFAULT_CONSOLIDATION,
+  buildSummaryInput,
+  parseSummaryResult,
+  applySummaries,
 } from '../core/consolidate.mjs';
 import { resolveConfig, buildSchema, CONFIG_SPEC } from '../core/config.mjs';
 
@@ -425,6 +428,8 @@ export function apply(ctx, rawConfig) {
         lastShownTurn: new Map(),
         suppressedUntil: -1,
         queued: false,
+        /** 上下文刚被压缩过：下一轮要把最近的事整段重灌一次（免预算） */
+        needsRecentReplay: false,
       };
       sessionStates.set(sessionId, s);
     }
@@ -433,6 +438,184 @@ export function apply(ctx, rawConfig) {
 
   /* ── 档案加载 ── */
 
+  /**
+   * 给还没 summary 的日记补一句总结。
+   *
+   * —— 为什么要有 ——
+   * summary 是检索的入口（见 pickBySummary）。老条目没有，就只能拿正文前 30 字兜底，
+   * 那比 summary 差一截：正文前 30 字是"起手式"，不是"他管它叫什么"。
+   *
+   * —— 为什么后台跑、分批 ——
+   * 两百多条是二十几次模型调用。同步跑会把启动卡成几十秒，那比没有 summary 还糟。
+   * 所以：每批 10 条、批间隔 1.5 秒，跑完就停；下次启动接着补没补的。
+   *
+   * —— 为什么要等 llm ——
+   * 2026-10-28 踩过的坑：插件 apply 的时候 llm 服务还没挂上，
+   * `ctx.get('llm')` 是 undefined，于是这里一声不吭地 return 了 ——
+   * 重启了三次，一条 summary 都没补上，而日志里干净得像没事发生。
+   * **所以：不再赌"启动那一刻服务就绪"，改成等它（最多 2 分钟）。**
+   *
+   * —— 为什么进度写进 manifest ——
+   * `log()` 只在 debugLog 开着时才落盘，默认是关的。
+   * 而"补了多少"这种事不能靠日志证明 —— 写进 manifest，任何时候都能查。
+   */
+  let backfillRunning = false;
+  async function backfillSummaries() {
+    if (backfillRunning) return;
+    backfillRunning = true;
+    try {
+      const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+      const pending = () =>
+        archive.diary.filter(
+          (e) =>
+            typeof e.text === 'string' &&
+            e.text !== '' &&
+            (typeof e.summary !== 'string' || e.summary === ''),
+        );
+
+      // 没活儿就一句话都不留。
+      //
+      // 原来这里是先写 starting 再判断"有没有要补的" —— 结果 241 条全补完之后，
+      // 下一次调用又把状态盖回 starting，界面上看着像永远卡住。
+      if (pending().length === 0) return;
+
+      // ── 先留痕，再干活 ──
+      //
+      // 上一版把「证据」写成了"成功之后才记"，结果:241 条一条没补，
+      // manifest 里连个字段都没有，日志默认又是关的 ——
+      // **完全看不出它到底有没有跑过。**
+      //
+      // 现在：进门第一件事就是写状态 + 立刻落盘。
+      // 哪怕下一步就卡死，你也能从 manifest 里看到它走到哪儿了。
+      markBackfill(pending().length, 0, 'starting');
+      try {
+        await persist();
+      } catch (err) {
+        warn(`补总结：写状态失败（不影响别的）：${err instanceof Error ? err.message : String(err)}`);
+      }
+
+      // 等 llm 和模型信息就绪
+      //
+      // 2026-10-28 实测：这一行里任何一个 ctx.get() 都可能**直接抛**，
+      // 抛出去以后状态就永远停在 "starting" —— 看起来像"卡住了"，其实是"炸了"。
+      // 所以整段包起来，炸了也要把 error 写进 manifest。
+      try {
+        const deadline = Date.now() + 120000;
+        let waited = 0;
+        for (;;) {
+          const llmNow = ctx.get('llm');
+          const sel = ctx.get('agentDefaultModel')?.currentSelection?.() ?? undefined;
+          const mdl = config.model || sel?.model;
+          if (llmNow !== undefined && typeof sel?.provider === 'string' && typeof mdl === 'string') break;
+          if (Date.now() > deadline) {
+            warn('补总结：等了 2 分钟还没等到 llm 或模型信息，这次不补了');
+            markBackfill(pending().length, 0, 'timeout');
+            try { await persist(); } catch { /* 写不进去就算了 */ }
+            return;
+          }
+          waited += 1;
+          if (waited % 15 === 0) log(`补总结：还在等 llm（已等 ${waited * 2}s）`);
+          await sleep(2000);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        warn(`补总结：等服务就绪时炸了：${msg}`);
+        markBackfill(pending().length, 0, 'error');
+        try { await persist(); } catch { /* 写不进去就算了 */ }
+        return;
+      }
+
+      const total = pending().length;
+      if (total === 0) {
+        markBackfill(total, 0, 'done');
+        return;
+      }
+      log(`补总结：${total} 条还没有，后台分批补`);
+
+      let done = 0;
+      let fails = 0;
+      for (let round = 0; round < 80; round++) {
+        const todo = pending().slice(0, 10);
+        if (todo.length === 0) break;
+
+        const llmP = ctx.get('llm');
+        const selection = ctx.get('agentDefaultModel')?.currentSelection?.() ?? undefined;
+        const provider = selection?.provider;
+        const model = config.model || selection?.model;
+        if (llmP === undefined || typeof provider !== 'string' || typeof model !== 'string') {
+          warn('补总结：模型信息中途没了，停手');
+          markBackfill(total, done, 'stopped');
+          return;
+        }
+
+        const built = buildSummaryInput(todo);
+        let text = '';
+        try {
+          for await (const chunk of llmP.stream({
+            provider,
+            model,
+            system: built.system,
+            messages: [{ role: 'user', content: [{ type: 'text', text: built.user }] }],
+            maxTokens: 600,
+            temperature: 0,
+            // 空字符串是非法档位 —— 实测会让 stream 直接不返回。
+            // 跟固化那边保持一致：只有配置里真有值才传。
+            ...(typeof config.reasoningEffort === 'string' && config.reasoningEffort.trim() !== ''
+              ? { reasoningEffort: config.reasoningEffort.trim() }
+              : {}),
+          })) {
+            if (chunk?.type === 'text-delta') text += chunk.text;
+          }
+        } catch (err) {
+          warn(`补总结失败：${err instanceof Error ? err.message : String(err)}`);
+          markBackfill(total, done, 'error');
+          return;
+        }
+
+        const map = parseSummaryResult(text);
+        if (map.size === 0) {
+          fails += 1;
+          warn(`补总结：这批一条都没解析出来（连续 ${fails} 次）`);
+          if (fails >= 3) {
+            warn('补总结：连着 3 批空，停手，下次启动再试');
+            markBackfill(total, done, 'error');
+            return;
+          }
+          await sleep(2000);
+          continue;
+        }
+        fails = 0;
+
+        archive = applySummaries(archive, map, Date.now());
+        index = buildIndex(archive.diary);
+        done += map.size;
+        markBackfill(total, done, 'running');
+        await persist();
+        log(`补总结：+${map.size} 条（累计 ${done}/${total}，还剩 ${pending().length}）`);
+        await sleep(1500);
+      }
+      markBackfill(total, done, 'done');
+      try { await persist(); } catch { /* 写不进去就算了 */ }
+      log(`补总结：这一轮结束，补了 ${done} 条，还剩 ${pending().length} 条没补`);
+    } finally {
+      backfillRunning = false;
+    }
+  }
+
+  /**
+   * 把补总结的进度写进 manifest。
+   *
+   * 为什么要落盘：`log()` 默认不写（debugLog 关着），
+   * 而"补了多少"是能证明这套东西到底跑没跑的唯一证据。
+   */
+  function markBackfill(total, done, state) {
+    archive.manifest = {
+      ...archive.manifest,
+      summary_backfill: { total, done, state, at: Date.now() },
+    };
+  }
+
   const loadPromise = (async () => {
     const dir = archiveDirectory;
     try {
@@ -467,6 +650,27 @@ export function apply(ctx, rawConfig) {
       // 也从别人那儿导入档案之后，立刻就有可读的一份。
       await writeReadableDiary(archive);
 
+      // 启动留痕 —— 落进 manifest，不依赖 debugLog。
+      // 有了它就能一眼分清两种"没补上"：
+      //   有 boot 没 summary_backfill → 插件起来了，但补总结没被调到
+      //   连 boot 都没有           → 装的根本不是这份代码
+      archive.manifest = {
+        ...archive.manifest,
+        boot: { at: Date.now(), schema: SCHEMA_VERSION, entries: archive.diary.length },
+      };
+      try {
+        await persist();
+      } catch (err) {
+        warn(`启动留痕写盘失败：${err instanceof Error ? err.message : String(err)}`);
+      }
+
+      // ── 补总结**不在启动时**跑 ──
+      //
+      // 实测两次：插件 apply 的时候 `ctx.get('llm')` 是 undefined，
+      // 等两分钟也等不到（manifest 停在 state:"starting"）。
+      // 所以触发点挪到 `agent/turn-stopping` —— 那条路上 llm 一定是活的。
+      // 见那边开头的注释。
+
       // 手记文件不在就建一份带说明的空壳 —— **文件自己就是文档**。
       // 用户（或任何一个肥鱼）打开就知道该往里写什么。
       try {
@@ -668,15 +872,6 @@ export function apply(ctx, rawConfig) {
 
   /* ── 注入 ── */
 
-  /**
-   * 「主动记一条」的工具名。
-   *
-   * 声明在这里（而不是跟工具定义放一起），是因为 `renderFor` 要把它写进
-   * 注入里的那句提示。**放在后面虽然在运行时也能用（TDZ 只在 apply 早期
-   * 才可能触发），但太脆** —— 谁把 renderFor 提早调一次就炸。
-   */
-  const NOTE_TOOL_NAME = 'feiyu_note';
-
   /**
    * 「去档案里找一句」的工具名。
    *
@@ -714,45 +909,29 @@ export function apply(ctx, rawConfig) {
       // 块本身按轮缓存，所以这个读一turn一次，跟手记那条一样便宜。
       syncPersonaFromDisk();
 
-      // ── 判断和事件，分开放 ──
+      // ── 判断（`kind: "note"`）**2026-10-27 整栏下线** ──
       //
-      // 这是这次改动的核心。**内容早就在了，只是放错了格子。**
+      // 原来这里把 note 条目分成两截：最近几条渲染成「我自己想的」，
+      // 更早的丢进召回池。整栏和小工具 `feiyu_note` 都不要了，理由见
+      // persona.mjs 里那段注释（四条全是「我该怎么干」，没有一条「他是什么人」）。
       //
-      // `feiyu_note` 写出来的东西（"别把前一种的辛苦当成功德"）是**判断**，
-      // 不是事件，却一直被当成事件渲染在「最近的事」里，格式跟流水账一模一样 ——
-      // 连我自己都分不出哪句是我写的。一位读者把这个毛病说得很准。
-      //
-      //   事件 → 「最近的事」/「突然想起来」（会被召回）
-      //   判断 → 「我自己想的」（永远在场，不进召回池）
-      //
-      // ⚠️ **"永远在场"这个前提在高频下失效了。** 判断段只放得下
-      // `MAX_NOTES` 条（8 → 4，因为 8 条会吃光预算、把日记段挤到 0%）。
-      // 被挤出窗口的判断如果还不进召回池，那就不是"以后想起来"，
-      // 是**彻底看不见** —— 而这个区是"是我"，丢了最可惜。
-      //
-      // 所以分流改成两截：
-      //   最近 MAX_NOTES 条 → 「我自己想的」（永远在场）
-      //   更早的那些        → **加入召回池**，相关时能被想起来
-      const allNotes = archive.diary.filter((e) => e?.kind === 'note');
-      // 渲染兜底：老条目在写入时可能没洗过（feiyu_note 的漏洞修之前写进来的），
-  // 但它们照样会进系统提示。这里按**只拦密钥**再过一遍 —— 不开第三方泛化，
-  // 免得把历史日记里的人名都糊掉。
-  const safeEntry = (e) => {
-    const r = scrub(e.text, { thirdParty: false });
-    return r.blocked ? { ...e, text: r.text } : e;
-  };
-  const events = archive.diary.map(safeEntry)
+      // 数据不动：档案里那 58 条 `kind: "note"` 留着，历史就是历史。
+      // 但它们**也不进召回池** —— 让「规矩」从别的栏目溜回来，等于没删干净。
+      const safeEntry = (e) => {
+        const r = scrub(e.text, { thirdParty: false });
+        return r.blocked ? { ...e, text: r.text } : e;
+      };
+      const events = archive.diary.map(safeEntry)
       .filter((e) => e?.kind !== 'note')
       // 续写过的条目 created_at 没动，但它是"刚写过的" —— 排序得看 updated_at，
       // 否则刚补完的那条会按原始时间沉下去。
       .sort((a, b) => (a.updated_at ?? a.created_at) - (b.updated_at ?? b.created_at));
-      const shownNotes = allNotes.slice(-MAX_NOTES);
 
       // 「最近的事」—— 按时间取最近的几条，不走相似度。
       // 这是让注入区读起来像日记而不是像检索结果的关键：
       // 最近发生的事本来就在脑子里，不需要被"想起来"。
       //
-      // 取的是 **events**，不是整个日记 —— 判断归「我自己想的」管。
+      // 取的是 **events**，不是整个日记 —— 判断（`kind: "note"`）那一栏已经下线，不渲染。
       const recentCount = Number.isFinite(config.recentEntries) ? config.recentEntries : 8;
       const recent = recentCount > 0 ? events.slice(-recentCount) : [];
       const recentIds = new Set(recent.map((e) => e.id));
@@ -770,21 +949,42 @@ export function apply(ctx, rawConfig) {
       //
       // 排除之后：同一句话会去挑真正的旧事（实测赛博朋克那条命中了
       // 「边缘行者2 上线，总导演从今石之洋换成五十岚海」）。
-      const olderNotes = allNotes.slice(0, -MAX_NOTES);
-      const recallPool = [
-        ...events.filter((e) => !recentIds.has(e.id)),
-        ...olderNotes,
-      ];
+      //
+      // 2026-10-27：`olderNotes` 也撤了 —— 判断那一栏整体下线，它的历史条目
+      // 不该从召回池绕回来（那等于把「规矩」换个栏目塞回去）。
+      const recallPool = events.filter((e) => !recentIds.has(e.id));
 
-      const { chosen } = selectMemories(recallPool, index, query, s, s.turn, {
-        highSim: config.highSim,
-        maxShow: config.maxShowPerTurn,
-        wanderChance: config.wanderChance,
-        // 旧事的随机池门槛。注意下限降到 0.15 是为了跟"降门槛"一致 ——
-        // 门槛降到 0.15 却在这里卡 0.25，等于白降。
-        minSalience: Math.max(0.15, config.minSalience),
-        now: Date.now(),
-      });
+      // ── 两道门：问句有没有内容，以及这一轮像不像在干活 ──
+      //
+      // 1）「嗯」「好」「在吗」这种话，字面上一个实词都没有 —— 拿它去检索，
+      //    好一点是空手而归白跑一趟，坏一点是命中一堆「他今天说了嗯」的噪声。
+      //
+      // 2）干活时不打扰。他正查报错、贴代码、对版本号，这时候插一句
+      //    「前两天你说过……」是实打实的讨厌。**真用得着旧事时它会自己调工具。**
+      //
+      // 两道门都只管自动召回这一栏，**不管 `feiyu_recall` 工具**。
+      //
+      // 2026-10-27 加。判据偏保守：宁可判成干活（少一条旧事），
+      // 也别在人家干活时插话。
+      const substantial = queryHasSubstance(query);
+      const working = looksLikeWork(query);
+      const chatty = substantial && !working;
+      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: [] };
 
       // 手记是**只读**的，所以每轮都重新读一遍 —— 别的肥鱼或用户刚写进去的
       // 那行，下一轮就在注入里，不用重启。文件很小，而且整块渲染按轮缓存。
@@ -796,32 +996,44 @@ export function apply(ctx, rawConfig) {
         // 读不到就当没有 —— 绝不因为手记坏了挡住记忆
       }
 
+      // 只有这两个时刻把「最近的事」整段重灌：**新会话第一轮**，或**刚被压缩过**。
+      // 其余每轮都不灌 —— 它已经进了历史，看得见，再灌一遍就是重复占地方。
+      const pinnedOnce = s.turn <= 1 || s.needsRecentReplay;
+
       const rendered = renderMemoryBlock({
         persona: archive.persona,
         relationship: { ...archive.relationship, since: archive.manifest.created_at },
         lexicon: archive.lexicon,
-        // 第三区：**我自己想的**（判断）。最近几条永远在场，
-        // 更早的那些走召回（见上面 allNotes 的分流）。
-        notes: shownNotes,
         recent,
         recalled: chosen,
         handNotes,
-        // 这句是**唯一**能让别的肥鱼知道"可以主动记"的渠道 ——
-        // 它们每轮都会读到这块记忆，不会去翻文档。
+        // ── 「最近的事」什么时候整段重灌（免预算）──
+        //
+        // 只有两个时刻：**新会话第一轮**（上下文是空的，这 8 条是唯一告诉它
+        // "我们上次在干什么"的东西），和**上下文刚被压缩之后**（聊天记录被压掉了，
+        // 这 8 条还在）。其余每轮都不灌 —— 它已经进了历史，看得见。
         //
-        // 第二句同理：给检索工具留个指针。**只注册工具不够** ——
+        // 2026-10-27 改。之前是每轮常驻、跟别人抢预算，实测最惨时准备 8 条只进来 1 条，
+        // 而且那 8 条全是"我们刚才在讨论插件"的会议纪要 —— 八条零个日子。
+        pinRecent: pinnedOnce,
+        // 这句是给检索工具留的指针。**只注册工具不够** ——
         // 工具一多就被淹，模型急起来想不起去查。这句在「帧」里、不进预算池，
         // 所以不会像栏目那样被裁掉。
-        handNoteHint:
-          `想给后面的我留话，用 ${NOTE_TOOL_NAME} 工具说一声就行 —— 不用管格式，也别为了记事去动文件。\n` +
-          `想不起来某件事时，用 ${RECALL_TOOL_NAME} 去档案里找一下 —— 用当时的词，越具体越准。`,
+        //
+        // 2026-10-27：给 `feiyu_note` 的那半句删了 —— 工具本身也下线了。
+        handNoteHint: `想不起来的时候，用 ${RECALL_TOOL_NAME} 回想一下 —— 用当时的词，越具体越准。`,
         includePersona: config.includePersona,
         budget: config.budgetTokens,
         now: Date.now(),
       });
       text = rendered.text;
+      // 重灌只用一次：这一轮灌过，下一轮就回到"不灌"。
+      // 不在这里清的话，压缩一次会永远灌下去 —— 那又变回"每轮常驻"了。
+      if (pinnedOnce) s.needsRecentReplay = false;
       log(
-        `会话 ${sessionId} 第 ${s.turn} 轮：最近 ${recent.length} 条在场 · 想起 ${chosen.length} 条` +
+        `会话 ${sessionId} 第 ${s.turn} 轮：最近 ${recent.length} 条在场` +
+          (pinnedOnce ? '（整段重灌，免预算）' : '') +
+          ` · 想起 ${chosen.length} 条` +
           ` · 注入 ${rendered.tokens} token` +
           (rendered.dropped.length > 0 ? ` · 裁掉 ${rendered.dropped.join('/')}` : ''),
       );
@@ -913,6 +1125,21 @@ export function apply(ctx, rawConfig) {
         return;
       }
 
+      // ── 上下文刚被压缩 ──
+      //
+      // 压缩会把聊天记录揉成一段摘要，**「最近的事」那 8 条是压缩之后还剩下的
+      // 那部分"我们上次在干什么"**。所以压缩完要再给它灌一次。
+      //
+      // DSH 没有专门的"压缩完成"事件，但压缩会在会话日志里留一条
+      // `compaction/summary`，而 `session/event` 是每次写盘后的事后通知 ——
+      // 从这里看得到。详见 persona.mjs 里 pinRecent 那段注释。
+      if (typeof event?.type === 'string' && event.type.startsWith('compaction/')) {
+        s.needsRecentReplay = true;
+        s.renderCache = { turn: -1, text: '' };
+        log(`会话 ${id} 的上下文被压缩了（${event.type}），下一轮重灌最近的事`);
+        return;
+      }
+
       if (event?.type === 'assistant/message') {
         const text = (event.data?.message?.content ?? [])
           .filter((b) => b?.type === 'text')
@@ -1116,6 +1343,17 @@ export function apply(ctx, rawConfig) {
       if (!config.enabled || !ready || degraded) return;
       const id = agent?.id;
       if (typeof id !== 'string') return;
+
+      // ── 补总结：从**这里**启动，不从启动时启动 ──
+      //
+      // 2026-10-28 试过在 loadPromise 里启动，失败两次：
+      // 插件 apply 的时候 `ctx.get('llm')` 是 undefined，
+      // 就算等两分钟也等不到 —— 实测 manifest 里停在 state:"starting"。
+      //
+      // 而这里（turn-stopping）llm 一定是活的：固化本来就跑在这条路上。
+      // 所以：**等第一次有人说话，才去补。** 不 await，有闸，重复调没事。
+      void backfillSummaries();
+
       const s = stateOf(id);
       if (s.turn === 0 || s.lastUserText === '') return;
       if (s.suppressedUntil === s.turn) {
@@ -1199,7 +1437,8 @@ export function apply(ctx, rawConfig) {
     // 成 138 / 232 / 309 字三张快照，讲的是同一件事，占掉「最近的事」三个位。
     // 所以：同一个 session、轮数差在窗口内、而且还没到 appendMaxChars，
     // 就把上一条一起给模型，让它只写"多出来的那部分"。
-    const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWindowTurns : 4;
+    // 默认从 4 调到 20（2026-10-27）。4 轮太窄：实测五分钟里写了三条同一件事。
+const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWindowTurns : 20;
     const appendMax = DEFAULT_CONSOLIDATION.appendMaxChars;
     const lastEvent = [...archive.diary]
       .reverse()
@@ -1344,6 +1583,10 @@ export function apply(ctx, rawConfig) {
     index = buildIndex(archive.diary);
     if (typeof s.renderCache === 'object') s.renderCache = { turn: -1, text: '' };
     await persist();
+
+    // 刚写进去的条目也还没有 summary —— 顺手补一口。
+    // 不 await：补总结不该让这一轮变慢。有 running 闸，重复调不会打起来。
+    void backfillSummaries();
   }
 
   /* ── 导出 / 导入（v0.1 先只做导出，路径可预期） ── */
@@ -1741,159 +1984,116 @@ export function apply(ctx, rawConfig) {
     }, 'feiyu: 面板数据接口');
   });
 
-  /* ── 主动记一条：给鱼用的工具 ── */
-
+  /* ── 检索工具：只读，不碰档案 ── */
+  //
+  // 2026-10-27：原来这里还有一个 `feiyu_note`（主动记一条）。
+  // 它和「我自己想的」那一栏一起下线 —— 那栏里四条全是「我该怎么干」，
+  // 一条「他是什么人」都没有。档案里那 58 条 `kind: "note"` 留着，不动。
+  //
+  // 为什么不复用 selectMemories 那套"选秀"逻辑（权重、冷却、走神、maxShow）：
+  // 那是给**每轮自动注入**设计的，要在"没人问"的情况下替它挑。
+  // 而工具是**它自己发起**的查询 —— 它知道自己在找什么，
+  // 所以直接按相似度排、取前 N 条，不设 salience 门槛。
+  //
+  // 明确要找，就该找得到，不管那件旧事淡到什么程度。
   /**
-   * 固化那条路是**插件自己判断 + 模型生成**的。这个工具是另一条：
-   * **哪一棒想到了什么，自己说一声就记下。**
-   *
-   * 【为什么是工具，而不是让鱼去写文件】
-   * 一开始我设计的是让鱼直接往 `日记/*.jsonl` 追加。那条路有两个洞：
+   * 从全部 summary 里挑出相关的几条。
    *
-   *  1. **静默丢数据** —— `archiveToFiles()` 是整份重建，内存副本会把
-   *     外部追加的行整份盖掉，没有报错。
-   *  2. **`id` 漏了就撞车** —— `normalizeDiaryEntry` 里是 `id: String(raw.id)`，
-   *     少写就变成字符串 "undefined"，两条日记同 id，删一条删两条。
+   * 输入：她的一句话 + 每条的 summary（没有 summary 的用正文前 30 字兜底）
+   * 输出：id 数组。挑不出来就空数组 —— **不硬凑**。
    *
-   * 交给插件办，这两个洞都不存在 —— 鱼只管说话，格式、id、关键词、
-   * 写盘全由这里负责。**鱼不该为了记事去操作文件系统。**
+   * 这一段跑在她看不见的地方：她的上下文里永远不会出现 summary。
+   * 她只会在拿到结果后看见几条正文 —— 那就是"想起来"的样子。
    *
-   * 【为什么不做成"进后台队列"】
-   * 用户的说法是"不是自己切后台搞"。所以这里是**当场写**：
-   * 工具调用返回之前，条目已经落盘，下一轮注入里就有。
-   * 不进带外队列、不等低峰时段 —— 那是固化那条路的事。
-   *
-   * 定义形状是手写的 JSON Schema（`defineTool` 转出来的就是这个形状），
-   * 因为**我们不能 import `@deepseek-ai/dsh-tools`**（零依赖铁律）。
-   * 名字 `NOTE_TOOL_NAME` 声明在 renderFor 那边 —— 注入里要引用它。
+   * 上限 400 条：再多 prompt 就压不住了。超了只取最近的 400，
+   * 这是个已知的近似，日志里会说 —— 别让它悄悄降级。
    */
+  async function pickBySummary(query, limit) {
+    const llmP = ctx.get('llm');
+    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} 条`);
+    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}`;
+    });
 
-  ctx.inject(['tools'], (scope) => {
-    scope.effect(
-      () =>
-        scope.tools.register({
-          name: NOTE_TOOL_NAME,
-          description:
-            '给自己留一条记忆。想到了什么值得让后面的我记得的，直接写进来就行 —— 不用管格式，也不要为了记事去动任何文件。' +
-            '不适合记的：能从档案里推出来的、一次性的技术细节、对别人的评价。',
-          parameters: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-              text: {
-                type: 'string',
-                description:
-                  '一句话，第一人称，像跟后面的自己说话。**不要写"今天/昨天"这类时间词**（时间由系统另外标注）。',
-              },
-              tags: {
-                type: 'array',
-                items: { type: 'string' },
-                description: '可选，两三个词，用来日后检索。',
-              },
-            },
-            required: ['text'],
-          },
-          output: {
-            schema: {
-              type: 'object',
-              additionalProperties: false,
-              properties: {
-                ok: { type: 'boolean' },
-                id: { type: 'string' },
-                count: { type: 'integer' },
-              },
-            },
-            render: (_args, value) =>
-              value?.ok === true
-                ? [{ type: 'text', text: `记住了。（档案里现在 ${value.count} 条）` }]
-                : [{ type: 'text', text: '没记成。' }],
-          },
+    const system =
+      '你在帮一条鱼回忆往事。她问了一句，你从她的日记索引里挑出最相关的几条。\n\n' +
+      '每行是「id 空格 一句索引」。有些索引很粗（正文截断出来的），别嫌弃。\n' +
+      '只输出 JSON：{"ids":["d_20261028_1","d_20261028_2"]}\n' +
+      '没有相关的就输出 {"ids":[]}。最多 ' + limit + ' 条。**宁可少挑，别硬凑。**';
 
-          async execute(args, exec) {
-            await loadPromise;
-            if (!ready) {
-              // 档案坏了就说实话，别假装记下了（SPEC §10 降级优先）
-              throw new Error('档案现在读不了（可能是坏的），这条没记下。');
-            }
-            const raw = typeof args?.text === 'string' ? args.text.trim() : '';
-            if (raw === '') throw new Error('要记什么？text 不能是空的。');
+    const selection = ctx.get('agentDefaultModel')?.currentSelection?.() ?? undefined;
+    const provider = selection?.provider;
+    const model = config.model || selection?.model;
+    if (typeof provider !== 'string' || typeof model !== 'string') return null;
 
-            // ⚠️ **这里必须过隐私闸。**
-            //
-            // 审计报告（F1，P1）：`scrub()` 原来只在固化那条路调用，
-            // 而 feiyu_note 是"模型自己说一句、直接落盘"的写入口 ——
-            // 用户刚贴的 key、手机号、人名会被原样写进 diary/*.jsonl，
-            // 然后**每一轮都随系统提示发给模型 provider**。
-            //
-            // 这直接违背 README 那句「密钥硬拦……绝不入档」。
-            // 而且它不是边角场景：模型说"记一下这个 key"是很自然的动作。
-            const scrubbed = scrub(raw, {
-              thirdParty: config.thirdPartyRedaction !== false,
-              amountThreshold: config.amountThreshold,
-            });
-            if (scrubbed.blocked) {
-              log(`主动记的那条命中了密钥规则，已替换（${scrubbed.hits.length} 处）`);
-            }
-            const now = Date.now();
-            const tags = (Array.isArray(args?.tags) ? args.tags : [])
-              .filter((t) => typeof t === 'string' && t.trim() !== '')
-              .map((t) => scrub(t.trim(), { thirdParty: false }).text.slice(0, 12))
-              .slice(0, 4);
-            if (tags.length === 0) tags.push('手记');
-
-            const sessionId = exec?.agent?.id;
-            const entry = normalizeDiaryEntry({
-              id: makeDiaryId(now, archive.diary),
-              // 洗过再截 —— 先截再洗会把半截密钥留在末尾
-              text: stripTimeWords(scrubbed.text.slice(0, 400)),
-              tags,
-              kind: 'note',
-              // 主动写下的东西比自动筛出来的更该被想起来，给高一档
-              salience: 0.7,
-              created_at: now,
-              ...(typeof sessionId === 'string' ? { session: sessionId } : {}),
-            });
-
-            archive.diary.push(entry);
-            index = buildIndex(archive.diary);
-            for (const s of sessionStates.values()) s.renderCache = { turn: -1, text: '' };
-            await persist();
-
-            // 和固化那条路一样：**只打形状，绝不打正文**
-            log(`主动记下一条 ${entry.id}（note），共 ${archive.diary.length} 条`);
-            return { ok: true, id: entry.id, count: archive.diary.length };
-          },
+    const t0 = Date.now();
+    let text = '';
+    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')}` }] }],
+        maxTokens: 200,
+        temperature: 0,
+        // 同上：空字符串是非法档位，stream 会不返回
+        ...(typeof config.reasoningEffort === 'string' && config.reasoningEffort.trim() !== ''
+          ? { reasoningEffort: config.reasoningEffort.trim() }
+          : {}),
+      })) {
+        if (chunk?.type === 'text-delta') text += chunk.text;
+      }
+    } catch (err) {
+      warn(`挑往事失败，退回字面：${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
 
-          presentCall: (args) => ({
-            card: 'generic',
-            title: '记住一条',
-            kind: 'other',
-            rawInput: args,
-          }),
-        }),
-      'feiyu: note tool',
+    const a = text.indexOf('{');
+    const b = text.lastIndexOf('}');
+    if (a < 0 || b <= a) {
+      warn('挑往事：返回里没有 JSON，退回字面');
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text.slice(a, b + 1));
+    } catch {
+      warn('挑往事：JSON 解析失败，退回字面');
+      return null;
+    }
+    // 返回里连 ids 都没有 = 它没按格式答，**不是"没有相关的"**。
+    // 这时候必须退回字面 —— 不能拿"程序答歪了"当成"记忆里没有"。
+    if (!Array.isArray(parsed?.ids)) {
+      warn('挑往事：返回里没有 ids，退回字面');
+      return null;
+    }
+    const ids = parsed.ids;
+    const valid = ids.filter((x) => typeof x === 'string').slice(0, limit);
+    log(
+      `挑往事「${query.slice(0, 20)}」：${pool.length} 条候选 / ${lines.length} 行索引` +
+        ` / 挑中 ${valid.length} 条 / ${((Date.now() - t0) / 1000).toFixed(1)}s`,
     );
-    log(`已注册工具 ${NOTE_TOOL_NAME}`);
+    return valid;
+  }
 
-    // ── 检索工具 ──
-    //
-    // 跟 feiyu_note 不一样的地方：**这里只读，不碰档案。**
-    //
-    // 为什么不复用 selectMemories 那套"选秀"逻辑（权重、冷却、走神、maxShow）：
-    // 那是给**每轮自动注入**设计的，要在"没人问"的情况下替它挑。
-    // 而工具是**它自己发起**的查询 —— 它知道自己在找什么，
-    // 所以直接按相似度排、取前 N 条，不设 salience 门槛。
-    //
-    // 明确要找，就该找得到，不管那件旧事淡到什么程度。
+  ctx.inject(['tools'], (scope) => {
     scope.effect(
       () =>
         scope.tools.register({
           name: RECALL_TOOL_NAME,
           description:
-            '去档案里找一条旧事。**你自己不知道那天发生过什么时用它**：' +
-            '他提到一件早先的事、你觉得该有记录但想不起来、或者要确认某个细节。' +
+            '回想一些以前的事。**你自己想不起来时用它**：' +
+            '他提到一件早先的事、你觉得该想起来却一片空白、或者要确认某个细节。' +
             '只在真的需要时调，不要每轮都查。' +
-            '找不到就老实说没找到，别编。',
+            '想不起来就老实说想不起来，别编。',
           parameters: {
             type: 'object',
             additionalProperties: false,
@@ -1935,13 +2135,34 @@ export function apply(ctx, rawConfig) {
               ? Math.max(1, Math.min(10, Math.floor(limitRaw)))
               : 5;
 
-            const scores = searchScores(index, query, { limit: 200 });
             const byId = new Map(archive.diary.map((e) => [e.id, e]));
-            let ranked = [...scores.entries()]
-              .map(([id, sim]) => ({ entry: byId.get(id), sim }))
-              .filter((x) => x.entry && typeof x.entry.text === 'string')
-              .sort((a, b) => b.sim - a.sim)
-              .slice(0, limit);
+
+            // ── 挑：交给模型读 summary，不按键面 ──
+            //
+            // 为什么不是 BM25：她那次摔跤就是"他换个说法我就搜不到"。
+            // 字面匹配救不了同义改写；而 summary 是写给"意思"的，模型能读意思。
+            //
+            // 为什么 summary 不进她的上下文：她只看到挑出来的正文。
+            // 检索那一步她看不见 —— 这就是"潜意识"。
+            //
+            // 代价：每次调工具多一次模型请求。只有她判断"这是往事"时才会发生，
+            // 平时是零。
+            const picked = await pickBySummary(query, Math.min(limit, 3));
+
+            let ranked;
+            if (picked !== null) {
+              ranked = picked
+                .map((id) => ({ entry: byId.get(id), sim: 0 }))
+                .filter((x) => x.entry && typeof x.entry.text === 'string');
+            } else {
+              // 没有 llm 服务时退回字面 —— 不能用"挑不了"当没找到
+              const scores = searchScores(index, query, { limit: 200 });
+              ranked = [...scores.entries()]
+                .map(([id, sim]) => ({ entry: byId.get(id), sim }))
+                .filter((x) => x.entry && typeof x.entry.text === 'string')
+                .sort((a, b) => b.sim - a.sim)
+                .slice(0, limit);
+            }
 
             // ── 兜底：词检索查不到时，直接扫原文子串 ──
             //
@@ -1951,7 +2172,7 @@ export function apply(ctx, rawConfig) {
             //
             // 181 条 × 两百字，扫一遍是毫秒级，而且**只在没结果时才走**，
             // 有结果就不兜，排序不受影响。
-            if (ranked.length === 0 && query.length <= 4) {
+            if (picked === null && ranked.length === 0 && query.length <= 4) {
               const needle = query.toLowerCase();
               ranked = archive.diary
                 .filter((e) => typeof e.text === 'string' && e.text.toLowerCase().includes(needle))
@@ -1966,7 +2187,7 @@ export function apply(ctx, rawConfig) {
               return {
                 ok: true,
                 found: 0,
-                text: `没找到关于「${query}」的记录。可以换个说法再试，或者直接问他。`,
+                text: `想不起来了。换个说法再试试，或者直接问他。`,
               };
             }
 
@@ -1990,7 +2211,7 @@ export function apply(ctx, rawConfig) {
             return {
               ok: true,
               found: lines.length,
-              text: `找到 ${lines.length} 条：\n${lines.join('\n')}`,
+              text: lines.join('\n'),
             };
           },