feiyu-memory 4.0.1 → 4.1.0

package/src/host/index.mjs

@@ -40,11 +40,11 @@ import {
 // 原来的 evaluateGate 那套关键词闸门拆了（见 turn-stopping 里的注释）。
 // SUPPRESS_RE 留着 —— "别记"是用户的控制，不是启发式。
 import { SUPPRESS_RE } from '../core/gate.mjs';
-import { buildIndex, selectMemories, searchScores, queryHasSubstance, looksLikeWork, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
+import { buildIndex, searchScores, topHitScores, queryHasSubstance, looksLikeWork, parseTimeHint, DEFAULT_RECALL_OPTIONS } from '../core/recall.mjs';
 import { overlap } from '../core/keywords.mjs';
 import { scrub } from '../core/privacy.mjs';
 import { renderMemoryBlock, DEFAULT_BUDGET } from '../core/persona.mjs';
-import { calendarDaysBetween, stripTimeWords, softWhen } from '../core/timeline.mjs';
+import { calendarDaysBetween, stripTimeWords, softWhen, dayLabel } from '../core/timeline.mjs';
 import { renderDiaryFile } from '../core/render-diary.mjs';
 import { buildJudgeInput, parseVerdict, JUDGE_MAX_TOKENS } from '../core/judge.mjs';
 import { selectHandNotes, HANDNOTE_FILE, HANDNOTE_TEMPLATE } from '../core/handnote.mjs';
@@ -430,6 +430,26 @@ export function apply(ctx, rawConfig) {
         queued: false,
         /** 上下文刚被压缩过：下一轮要把最近的事整段重灌一次（免预算） */
         needsRecentReplay: false,
+        /**
+         * 她刚用 `feiyu_recall` 翻到的东西。
+         *
+         * ── 为什么不直接把正文当工具返回值给她 ──
+         *
+         * 2026-11-03。原来工具直接返回正文，于是她读到的是"工具查回来的资料"，
+         * 嘴里就挂着一句"这是我翻出来的"。用户的原话：**一问就是 recall 查的，
+         * 不是自己的。**
+         *
+         * 现在改成：工具只把结果存在这儿，返回值淡化成"（翻了翻）"，
+         * 正文由**下一次 `renderFor` 混进记忆块**。她读到的是"记忆里多了几条"。
+         *
+         * 这不是"让读到像记得"——她真的翻了，动作还在对话历史里。
+         * 区别在**翻完之后怎么读**：人翻完笔记合上，说话时不会说"根据笔记第 3 页"。
+         *
+         * 只在本轮有效（`pendingRecallTurn === s.turn`）：
+         * 下一轮自动失效，不会变成常驻条目、也不会滚雪球占预算。
+         */
+        pendingRecall: [],
+        pendingRecallTurn: -1,
       };
       sessionStates.set(sessionId, s);
     }
@@ -609,6 +629,33 @@ export function apply(ctx, rawConfig) {
    * 为什么要落盘：`log()` 默认不写（debugLog 关着），
    * 而"补了多少"是能证明这套东西到底跑没跑的唯一证据。
    */
+  /**
+   * 记一笔「挑往事」这次的用量。
+   *
+   * 为什么非记不可：**缓存命中率是看不见的。** 请求发出去、答案回来了、
+   * 一切正常，只有账单知道这次是 0.1 元/M 还是 1 元/M。
+   * 而 prompt 的字段顺序一旦写反（把会变的那句放前面），缓存就静悄悄地失效了 ——
+   * 今天就是这么栽的，全靠事后读日志才翻出来。
+   *
+   * 所以：每次挑完把 usage 落进 manifest，谁都能一眼看见。
+   */
+  function markPick(entries, lines, usage) {
+    const u = usage ?? {};
+    archive.manifest = {
+      ...archive.manifest,
+      pick_stats: {
+        at: Date.now(),
+        entries,
+        lines,
+        inputTokens: Number.isFinite(u.inputTokens) ? u.inputTokens : null,
+        cacheReadTokens: Number.isFinite(u.cacheReadTokens) ? u.cacheReadTokens : null,
+        outputTokens: Number.isFinite(u.outputTokens) ? u.outputTokens : null,
+        // 取不到 usage 的时候，把 finish 的形状留下来 —— 别再猜字段名。
+        // 只留前 300 字，够看清结构，不至于把整段响应塞进档案。
+      },
+    };
+  }
+
   function markBackfill(total, done, state) {
     archive.manifest = {
       ...archive.manifest,
@@ -972,19 +1019,61 @@ export function apply(ctx, rawConfig) {
       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: [] };
+      // ── 按相似度捞一批完整正文（2026-11-02 大改）──
+      //
+      // 原来走 `selectMemories`：挑 1~2 条，还要跟 salience、冷却、走神一起掷骰子。
+      // 现在直接按 BM25 取前 N 条完整正文 —— **范围大，就不怕它挑错。**
+      //
+      // ── 为什么不给模型挑了 ──
+      //
+      // 原来那条路是：480 行索引（摘要，约 1.6 万 token）塞给模型挑 3 条。
+      // 实测两件事：
+      //   1. 那次调用跟一整轮聊天一样贵（都是全价，缓存命不中）
+      //   2. 摘要把最要紧的半句漏了 —— 「项目失败了」在正文里，摘要里一个字没有
+      // 于是模型拿着错的索引挑，挑得再认真也没用。
+      //
+      // ── 为什么敢一次给 15 条 ──
+      //
+      // BM25 会 0 命中（同义词、梗称），也会高分错答。但它**不需要准，只需要不漏**。
+      // 只给 2 条时它错一次，这条鱼就什么都想不起来；给 15 条时错的混在里面，
+      // 对的那条还在 —— **准的那一步交给读正文的她自己。**
+      //
+      // 「最近的事」那几条不在池子里（已经常驻了），note 和损坏条目也不在。
+      const recallLimit = Number.isFinite(config.recallFanout) ? config.recallFanout : 15;
+      /** @type {Array<{entry: object, score: number, sim: number, why: string}>} */
+      const chosen = [];
+
+      // ── 她刚翻到的，排最前面 ──
+      //
+      // 2026-11-03：`feiyu_recall` 不再把正文当返回值给她，只存在 `pendingRecall`。
+      // 正文从这里混进记忆块 —— 她读到的是"记忆里多了几条"，不是"工具返回了资料"。
+      //
+      // 只认同一轮（`pendingRecallTurn === s.turn`）：下一轮自动失效，
+      // 不会变成常驻条目，也不会滚雪球占预算。
+      if (s.pendingRecallTurn === s.turn && s.pendingRecall.length > 0) {
+        for (const c of s.pendingRecall) {
+          if (chosen.length >= recallLimit) break;
+          chosen.push(c);
+        }
+        log(`会话 ${sessionId} 第 ${s.turn} 轮：翻到的 ${chosen.length} 条并入记忆`);
+      }
+
+      if (chatty && recallLimit > 0) {
+        // 只留跟第一名接近的（相对门槛），否则会捞进一堆只撞上一个常用词的噪音。
+        const hits = topHitScores(index, query, {
+          limit: recallLimit,
+          ratio: config.recallScoreRatio,
+        });
+        const poolById = new Map(recallPool.map((e) => [e.id, e]));
+        for (const [id, sim] of hits) {
+          const entry = poolById.get(id);
+          if (entry === undefined) continue;
+          // 刚才翻到的已经在里面了，别重复
+          if (chosen.some((c) => c.entry?.id === id)) continue;
+          chosen.push({ entry, score: sim, sim, why: '' });
+          if (chosen.length >= recallLimit) break;
+        }
+      }
 
       // 手记是**只读**的，所以每轮都重新读一遍 —— 别的肥鱼或用户刚写进去的
       // 那行，下一轮就在注入里，不用重启。文件很小，而且整块渲染按轮缓存。
@@ -1021,9 +1110,12 @@ export function apply(ctx, rawConfig) {
         // 所以不会像栏目那样被裁掉。
         //
         // 2026-10-27：给 `feiyu_note` 的那半句删了 —— 工具本身也下线了。
-        handNoteHint: `想不起来的时候，用 ${RECALL_TOOL_NAME} 回想一下 —— 用当时的词，越具体越准。`,
+        handNoteHint: `手上的记忆里真没有，才用 ${RECALL_TOOL_NAME} 去翻。那是最后一招。`,
         includePersona: config.includePersona,
         budget: config.budgetTokens,
+        // 召回那栏能渲染几条。默认值跟上面捞的条数同一个数 ——
+        // 不传的话 `renderRecalled` 会回落到 2 条，捞 15 条只显示 2 条，白捞。
+        recalledMax: recallLimit,
         now: Date.now(),
       });
       text = rendered.text;
@@ -2013,19 +2105,68 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
     if (llmP === undefined) return null;
     const all = archive.diary.filter((e) => typeof e.text === 'string' && e.text !== '');
     if (all.length === 0) return [];
-    const pool = all.slice(-400);
-    if (all.length > pool.length) log(`挑往事：${all.length} 条只取最近 ${pool.length} 条`);
+
+    // ── 时间先收窄一次 ──
+    //
+    // 「上个月那个」「前两天我说过」—— 这种问法里一个专有名词都没有，
+    // 拿去做内容检索，一个字都撞不上。而日期本来就在条目上，之前白白没用。
+    //
+    // 认得出时间就只在那个窗口里挑；窗口里一条都没有，就退回全量 ——
+    // **绝不因为时间认错过而让她什么也找不到。**
+    let narrowed = null;
+    const timeHint = parseTimeHint(query, Date.now());
+    if (timeHint !== null) {
+      const inWindow = all.filter(
+        (e) => Number.isFinite(e.created_at) && e.created_at >= timeHint.from && e.created_at <= timeHint.to,
+      );
+      if (inWindow.length > 0) {
+        narrowed = timeHint;
+        log(
+          `挑往事：她问的是「${timeHint.label}」，先把 ${all.length} 条收到 ${inWindow.length} 条`,
+        );
+      } else {
+        log(`挑往事：她问的是「${timeHint.label}」，但那个窗口里一条都没有，退回全量`);
+      }
+    }
+
+    const base = narrowed === null ? all : all.filter(
+      (e) => Number.isFinite(e.created_at) && e.created_at >= narrowed.from && e.created_at <= narrowed.to,
+    );
+    // ── 2026-11-02：不再静默截到最近 400 条 ──
+    //
+    // 那个 400 是"prompt 压不住"的近似，但它的副作用是**悄悄丢掉最老的那些**：
+    // 480 条时已经丢了 80 条，而丢掉的恰好是最难被想起来、也最该被留着的那批。
+    // 更糟的是它只写一行 log —— 用户永远看不到自己的记忆在少。
+    //
+    // 现在只留一道"真的太大才截"的闸，而且会 warn。真要涨到过千条，
+    // 该做的是分层（按天/按月），不是继续截尾巴。
+    const POOL_CAP = 1200;
+    const pool = base.length > POOL_CAP ? base.slice(-POOL_CAP) : base;
+    if (base.length > pool.length) {
+      warn(`挑往事：${base.length} 条超过上限 ${POOL_CAP}，只取最近 ${pool.length} 条 —— 更老的挑不到`);
+    }
+
+    // 索引行前面带日期 —— 模型才有办法回答「那阵子」这种问法。
+    const dayLabel = (t) => {
+      if (!Number.isFinite(t)) return '??/??';
+      const d = new Date(t);
+      return `${String(d.getMonth() + 1).padStart(2, '0')}/${String(d.getDate()).padStart(2, '0')}`;
+    };
     const lines = pool.map((e) => {
       const idx =
         typeof e.summary === 'string' && e.summary !== ''
           ? e.summary
           : String(e.text).replace(/\s+/g, ' ').slice(0, 30);
-      return `${e.id} ${idx}`;
+      return `${e.id} ${dayLabel(e.created_at)} ${idx}`;
     });
 
     const system =
       '你在帮一条鱼回忆往事。她问了一句，你从她的日记索引里挑出最相关的几条。\n\n' +
-      '每行是「id 空格 一句索引」。有些索引很粗（正文截断出来的），别嫌弃。\n' +
+      '每行是「id 空格 日期 一句索引」。\n' +
+      '**要挑的是「那件事本身」，不是「我记过这件事」的记录。**\n' +
+      '像「他问过 X·我答记不清」「这次是翻出来的」「注入里没有」这种，**都不能算答案** ——\n' +
+      '它们只说明那条鱼当时没想起来，不是他讲过的事。\n' +
+      '**如果她问的是一段时间（「那阵子」「上个月」），优先看日期。**\n' +
       '只输出 JSON：{"ids":["d_20261028_1","d_20261028_2"]}\n' +
       '没有相关的就输出 {"ids":[]}。最多 ' + limit + ' 条。**宁可少挑，别硬凑。**';
 
@@ -2036,12 +2177,23 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
 
     const t0 = Date.now();
     let text = '';
+    let usageChunk;
     try {
       for await (const chunk of llmP.stream({
         provider,
         model,
         system,
-        messages: [{ role: 'user', content: [{ type: 'text', text: `她问：${query}\n\n索引：\n${lines.join('\n')}` }] }],
+        // ⚠️ **顺序是钱。** 稳定的大头（索引）必须在前面，会变的那一小句放最后。
+        //
+        // 缓存按**前缀**匹配：第一段一变，后面九千多 token 全部重算。
+        // 原来写的是「她问：X \n\n 索引：…」—— query 在最前面，
+        // 于是每一轮都从第一个 token 开始不命中，等于一直在按全价买这九千多 token。
+        //
+        // 换成索引在前、问题在后：命中价 0.1 元/M vs 全价 1 元/M，差十倍。
+        // 只有"新增了日记"那天索引才变，一天也就几次。
+        messages: [
+          { role: 'user', content: [{ type: 'text', text: `索引：\n${lines.join('\n')}\n\n她问：${query}` }] },
+        ],
         maxTokens: 200,
         temperature: 0,
         // 同上：空字符串是非法档位，stream 会不返回
@@ -2050,12 +2202,27 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
           : {}),
       })) {
         if (chunk?.type === 'text-delta') text += chunk.text;
+        else if (chunk?.type === 'usage') {
+          // 实测（2026-10-28）：usage 不在 finish 上，它是**独立的一种 chunk**。
+          // chunkTypes 探针打出来是 block-start,block-end,usage,finish ——
+          // 我猜了两轮字段名才看到这个。
+          usageChunk = chunk;
+        }
       }
     } catch (err) {
       warn(`挑往事失败，退回字面：${err instanceof Error ? err.message : String(err)}`);
       return null;
     }
 
+    // 记一笔用量 —— 缓存有没有命中，只有 finish 里的 usage 说得清。
+    // 不写日志（debugLog 默认关着），写 manifest：任何时候都能查。
+    try {
+      markPick(pool.length, lines.length, usageChunk?.usage ?? usageChunk?.data ?? usageChunk);
+      await persist();
+    } catch (err) {
+      warn(`挑往事：记用量失败（不影响结果）：${err instanceof Error ? err.message : String(err)}`);
+    }
+
     const a = text.indexOf('{');
     const b = text.lastIndexOf('}');
     if (a < 0 || b <= a) {
@@ -2090,10 +2257,10 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
         scope.tools.register({
           name: RECALL_TOOL_NAME,
           description:
-            '回想一些以前的事。**你自己想不起来时用它**：' +
-            '他提到一件早先的事、你觉得该想起来却一片空白、或者要确认某个细节。' +
-            '只在真的需要时调，不要每轮都查。' +
-            '想不起来就老实说想不起来，别编。',
+            '翻日记。**只有在完全没有印象时才用** —— 他问的那件事，你手上一点底都没有。' +
+            '别用它确认细节，别用它补全，也别因为「怕答错」就去查。' +
+            '查到什么直接说，不用交代「这是我翻出来的」；他真问你怎么知道的，再说实话。' +
+            '翻不到就说翻不到，别编。',
           parameters: {
             type: 'object',
             additionalProperties: false,
@@ -2123,7 +2290,9 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
             render: (_args, value) => [{ type: 'text', text: value?.text ?? '查不了。' }],
           },
 
-          async execute(args) {
+          // 第二个参数 `exec` 带 `agent` —— 靠它知道是谁在翻，
+          // 翻到的东西要存进那个会话的 pendingRecall（见 renderFor 那段注释）。
+          async execute(args, exec) {
             await loadPromise;
             if (!ready) throw new Error('档案现在读不了（可能是坏的），查不了。');
 
@@ -2191,27 +2360,63 @@ const appendWindow = Number.isFinite(config.appendWindowTurns) ? config.appendWi
               };
             }
 
-            // 总字数封顶 —— 不按"次数"限流（那要跨轮状态，麻烦），
-            // 按"返回量"限：超了就是一次失败的成本，它自己会学会别乱查。
+            // ── 收到哪去：**不直接给她**，存进本轮「翻到的」，由注入送去 ──
+            //
+            // 2026-11-03 改。原来这里 `return` 正文，于是她读到的是"工具查回来的资料"，
+            // 嘴里就挂着一句"这是我翻出来的"。用户的原话：
+            //   **一问就是 recall 查的，不是自己的。**
+            //
+            // 现在：正文存进 `pendingRecall`，返回值只剩一句"（翻了翻）"。
+            // 正文由下一次 `renderFor` 混进记忆块 —— 她读到的是"记忆里多了几条"。
+            //
+            // 她真的翻了，动作还在对话历史里。区别只在**翻完之后怎么读**：
+            // 人翻完笔记合上，说话时不会说"根据笔记第 3 页"。
             const MAX_CHARS = 2000;
-            const lines = [];
+            const pickedEntries = [];
             let used = 0;
-            const now = Date.now();
-            for (const { entry } of ranked) {
+            for (const { entry, sim } of ranked) {
+              // note（判断那一栏已下线）不进来 —— 让规矩从工具溜回来，等于没删干净
+              if (entry.kind === 'note') continue;
               // 跟注入走同一个隐私闸 —— 历史条目里可能还有没洗过的东西
-              const body = stripTimeWords(scrub(entry.text, { thirdParty: false }).text);
-              const when = softWhen(entry.created_at, now);
-              const line = when === '' ? body : `${when}：${body}`;
-              if (used + line.length > MAX_CHARS && lines.length > 0) break;
-              lines.push(`- ${line}`);
-              used += line.length;
+              const clean = scrub(entry.text, { thirdParty: false }).text;
+              if (used + clean.length > MAX_CHARS && pickedEntries.length > 0) break;
+              pickedEntries.push({ entry: { ...entry, text: clean }, score: sim, sim, why: '' });
+              used += clean.length;
+            }
+
+            const sid = typeof exec?.agent?.id === 'string' ? exec.agent.id : undefined;
+            if (sid === undefined) {
+              // 拿不到会话（极端情况）→ 退回旧行为，别让她什么都拿不到
+              log(`检索「${query.slice(0, 20)}」：拿不到会话 id，直接返回正文`);
+              const now0 = Date.now();
+              const lines = pickedEntries.map(({ entry }) => {
+                // 跟注入那一栏用同一个时间尺子（dayLabel），别一个模糊一个精确
+                const when = dayLabel(entry.created_at, now0);
+                return `- ${when === '' ? entry.text : `${when}：${entry.text}`}`;
+              });
+              return { ok: true, found: lines.length, text: lines.join('\n') || '想不起来了。' };
             }
 
-            log(`检索「${query.slice(0, 20)}」：返回 ${lines.length} 条`);
+            const st = stateOf(sid);
+            st.pendingRecall = pickedEntries;
+            st.pendingRecallTurn = st.turn;
+            // 作废按轮缓存：下一次 assemble 会重算，把这批混进记忆块
+            st.renderCache = { turn: -1, text: '' };
+
+            log(`检索「${query.slice(0, 20)}」：翻到 ${pickedEntries.length} 条，等注入送`);
             return {
               ok: true,
-              found: lines.length,
-              text: lines.join('\n'),
+              found: pickedEntries.length,
+              // 2026-11-03：**什么都不留。**
+              //
+              // 原来是「（翻了翻）」，用户看了说不要 —— 那还是个痕迹：
+              // 她读到"我刚翻了一下"，下一句就容易带出"我查到的"。
+              //
+              // 现在正文全走注入，返回值只是一个空串。工具调用本身还在历史里
+              // （该留的证据留着了），但**不会再往她嘴里塞一句"我去翻了"。**
+              //
+              // 翻空了还是要说一句 —— 那是另一回事：别让她以为"翻过了等于找到了"。
+              text: pickedEntries.length === 0 ? '想不起来了。换个说法再试试，或者直接问他。' : '',
             };
           },