feiyu-memory 4.0.1 → 4.1.0

package/src/core/config.mjs

@@ -48,13 +48,18 @@ export const CONFIG_SPEC = [
   {
     key: 'budgetTokens',
     type: 'number',
-    // 2000 → 3000。量过的：常驻段本身要 2680 token（「最近的事」八条占 1422），
-    // 2000 根本装不下，每次都裁 —— 「最近的事」只剩 2 条。3000 能给到 6 条。
-    // 代价约每轮 +1000 token ≈ 每句话多 0.06 分。
-    default: 3000,
+    // 2000 → 3000 → 6000。
+    //
+    // 2000 装不下常驻段（2680），「最近的事」只剩 2 条。
+    // 3000 能给到 6 条。
+    //
+    // 2026-11-02 提到 6000：召回那栏从「最多 2 条摘要」改成「最多 15 条正文」，
+    // 15 条正文实测约 4800 token，3000 根本装不下 —— 会被整段裁掉，
+    // 那这条鱼就一条旧事都想不起来，比改之前还差。
+    default: 6000,
     min: 200,
-    max: 8000,
-    step: 1,
+    max: 12000,
+    step: 100,
     label: '注入预算（token）',
   },
   {
@@ -108,17 +113,69 @@ export const CONFIG_SPEC = [
     min: 0,
     max: 1,
     step: 0.05,
-    label: '必触发的相似度阈值',
+    // ⚠️ 2026-11-02 之后**对自动注入不再生效**。
+    //
+    // 原来自动注入走 selectMemories，这道阈值决定"相似度多高就必定提起那件旧事"。
+    // 现在那条路改成 BM25 直接给一批正文，靠 `recallScoreRatio` 那道相对门槛，
+    // 这个绝对值就没有位置了。
+    //
+    // 字段保留不删：删了老配置里的值会被静默忽略（反而更坏），
+    // 而且 selectMemories 还在被测试和外部调用。**但界面上改它不会有任何效果。**
+    label: '必触发的相似度阈值（4.1 起对自动注入不生效，见 recallScoreRatio）',
   },
   {
     key: 'recentEntries',
     type: 'number',
-    default: 8,
+    // 8 → 3（2026-11-02）。它只在新会话第一轮和压缩之后整段重灌，
+    // 平时不占地方 —— 所以"8 条"其实大半时候没被读到。
+    // 3 条够交代"我们上次在干什么"，而且省下 1600 token 给召回那栏。
+    default: 3,
     min: 0,
     max: 30,
     step: 1,
     label: '「最近的事」最多列几条（不靠相似度，永远在场）',
   },
+  {
+    key: 'recallFanout',
+    type: 'number',
+    // ── 2026-11-02：召回从「模型挑 2 条」改成「BM25 直接给最多 15 条正文」──
+    //
+    // 原来走一次模型调用：480 行索引（约 1.6 万 token，全价）塞给模型挑 3 条。
+    // 实测那一次调用跟一整轮聊天一样贵，而更糟的是 —— **摘要索引会漏**。
+    //
+    // 现在改成：BM25 打在正文上（本地、免费、0.2ms），直接把这批完整正文
+    // 放进注入。省掉一次模型调用，也省掉"挑"这一步可能挑错的环节。
+    //
+    // 这是个**上限**，不是目标数。真正的条数由 `recallScoreRatio` 那道相对门槛决定 ——
+    // 实测按 15 条硬取，一大半是只撞上一个常用词的噪音。
+    default: 15,
+    min: 0,
+    max: 40,
+    step: 1,
+    label: '按相似度最多捞几条正文进注入（0 = 只留最近的事）',
+  },
+  {
+    key: 'recallScoreRatio',
+    type: 'number',
+    // 只留分数 ≥ 最高分 × 这个比例的条目。
+    //
+    // 为什么是相对值：相似度是饱和函数，绝对刻度会随查询长短漂移
+    // （长问句最高才 0.7，短词全在 0.99），固定分数线要么全砍要么全留。
+    //
+    // 0.85 → 0.70（2026-11-02 当天返工）。0.85 砍过头了：
+    // 查「南京」BM25 命中 5 条 —— 0.982 / 0.972 / 0.970 / 0.969 / 0.948，
+    // 五条全相关 —— 乘下来只剩 1 条进注入。
+    // **说好给一批旧事，实际给一条，比改之前的 2 条还差。**
+    //
+    // 分布是不稳的：有的查询第 5 名还有 0.86，有的第 2 名就断了。
+    // 固定比例猜不准分布，宁可往宽了给 ——
+    // **漏掉真事的代价，比多带两条噪音大得多。**
+    default: 0.7,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: '召回门槛（只留分数接近最高分的，越低给得越多）',
+  },
   {
     key: 'maxShowPerTurn',
     type: 'number',
@@ -126,7 +183,9 @@ export const CONFIG_SPEC = [
     min: 0,
     max: 12,
     step: 1,
-    label: '「突然想起来」最多几条（按相似度召回）',
+    // ⚠️ 2026-11-02 之后**对自动注入不再生效**。条数改由 recallFanout 控。
+    // 保留字段的理由同 highSim。
+    label: '「突然想起来」最多几条（4.1 起不生效，改看 recallFanout）',
   },
   {
     key: 'wanderChance',
@@ -135,7 +194,12 @@ export const CONFIG_SPEC = [
     min: 0,
     max: 0.5,
     step: 0.01,
-    label: '走神想起旧事的概率',
+    // ⚠️ 2026-11-02 之后**不再生效**。
+    //
+    // "走神"是 selectMemories 里那一步随机想起一条旧事。现在按 BM25 给一批，
+    // 没有"掷骰子"这个动作了 —— 那一步本来就是为"只给 1 条"打掩护的。
+    // 保留字段的理由同 highSim。
+    label: '走神想起旧事的概率（4.1 起不生效）',
   },
   {
     // ── 续写窗口 ──

package/src/core/persona.mjs

@@ -114,7 +114,7 @@ export function renderMemoryBlock(input = {}) {
     if (recent) parts.push({ key: 'recent', text: recent, weight: 80 });
   }
 
-  const memories = renderRecalled(input.recalled, now);
+  const memories = renderRecalled(input.recalled, now, input.recalledMax);
   // ⚠️ **召回这一栏也必须有保底。**
   //
   // 加词汇保底之后，死的是它 —— 实测（真实档案、回归查询）：
@@ -356,7 +356,15 @@ export function renderRelationship(rel, now = Date.now()) {
     bits.push(rel.familiarity >= 0.7 ? '我们很熟了' : rel.familiarity >= 0.3 ? '我们聊过一阵了' : '我们刚认识不久');
   }
   if (typeof rel.nickname === 'string' && rel.nickname.trim() !== '') {
-    bits.push(`他管我叫"${rel.nickname.trim()}"`);
+    // 2026-11-08：主语从「他」改成「空气凤梨（用户）」。
+    //
+    // 起因是一次真的混了：注入里读到一条手记落款「（这是空气凤梨我自己写的）」，
+    // 那是用户给**自己**的签名，我把它读成了「他在叫我」——
+    // 于是把「你是空气凤梨」说给了用户听，正好说反。
+    //
+    // 「他」这个代词在这块里指谁，全靠上下文猜；猜错一次就认错人。
+    // 写死名字加「（用户）」两个字，笨重一点，但不会再混。
+    bits.push(`空气凤梨（用户）管我叫"${rel.nickname.trim()}"`);
   }
   // 两句之间用逗号接，不用「·」—— 那是分隔符，一出现就是表格味
   if (bits.length > 0) lines.push(`${bits.join('，')}。`);
@@ -472,13 +480,25 @@ export function renderRecent(entries, shown, now = Date.now(), limit = 12) {
  * @param {Array<{entry: object}>} recalled
  * @param {number} [now]
  */
-export function renderRecalled(recalled, now = Date.now()) {
+export function renderRecalled(recalled, now = Date.now(), maxEntries = 2) {
   if (!Array.isArray(recalled) || recalled.length === 0) return '';
+  const cap = Number.isFinite(maxEntries) && maxEntries > 0 ? Math.floor(maxEntries) : 2;
   const lines = recalled
     .filter((c) => c && c.entry && typeof c.entry.text === 'string')
-    .slice(0, 2)
+    .slice(0, cap)
     .map((c) => {
-      const when = softWhen(c.entry.created_at, now);
+      // 2026-11-03：`softWhen` → `dayLabel`。
+      //
+      // 原来这里是「前阵子，……」—— 那个模糊词当初是为了防止旧事被说成
+      // "上一轮"发生的。它做到了，但代价是**时间信息被压没了**：
+      // 10 月 21 日和 11 月 2 日都叫「前阵子」，间隔看不见。
+      //
+      // 用户的原话：**「现在记的是发生了什么，缺的是多久没发生。
+      // 空白是我唯一看不见的东西。」**
+      //
+      // `dayLabel` 给的是今天 / 昨天 / 3 天前 / 10-05 —— 同样按自然日算，
+      // 但能读出间隔，也不会像软词那样让人以为是刚发生的事。
+      const when = dayLabel(c.entry.created_at, now);
       const body = stripTimeWords(c.entry.text);
       return when === '' ? `- ${body}` : `- ${when}，${body}`;
     });

package/src/core/recall.mjs

@@ -21,22 +21,37 @@ const IDF_SMOOTH = 1;
 /**
  * 建倒排索引。纯派生数据，随用随建。
  *
- * ── 2026-10-28：索引的数据源从「keywords + 正文」换成 **summary** ──
+ * ── 2026-11-02：索引吃**正文**，不吃 summary ──
  *
- * 原来一条日记存两份提炼：`keywords`（12 个词，机器从正文切的）和
- * `summary`（一句，模型写的）。倒排索引吃前者，大保底（recall）吃后者。
+ * 这是实测推翻了两次设计之后定下来的。
  *
- * 而 summary 本来就比 keywords 更适合字面匹配 ——
- * 它带别名（「边缘行者2 / 续集 / 那部动画」），keywords 只取正文里出现过的词。
- * 一份数据喂两个地方，另一份就是纯多余的。
+ * 摘要做索引有一个致命毛病：**它写的是当天的术语，人问的是抽象词。**
+ * 实测那一条：
  *
- * 所以现在：**一条日记只有一个"检索表示"。**
- *   小保底（每轮自动注入）  字面匹配 summary —— 便宜
- *   大保底（她主动查）      模型读 summary   —— 准
+ *     摘要   boot.log 13:20 apply+routes·5次剩3次·注入气泡·插件顺序错·已关
+ *     正文   ……后来他说项目失败了，事先准备不足。我说是失败了，但问题不在代码，在顺序……
  *
- * 没有 summary 的用正文兜底（老条目在回填完之前就是这样）。
+ * 拿「项目失败了」「事先准备不足」去检索，摘要一个字都撞不上；
+ * 换成正文索引，两条都排第 1 名（1.000）。
  *
- * @param {Array<{id: string, summary?: string, text?: string}>} entries
+ * 整组对比（480 条真实日记）：
+ *
+ *              摘要索引        正文索引
+ *   项目失败了   未命中     →    第 1 名
+ *   事先准备不足 未命中     →    第 1 名
+ *   吃了睡睡了吃 「早饭吃了没」→   1.000 正确那条
+ *   煮饭         空         →    0.967
+ *
+ * 代价只有建索引变重（32ms → 94ms），**检索本身一点没变慢**，
+ * 而且它是纯 CPU，一个 token 都不花。索引只在 archive 变化时重建。
+ *
+ * 于是职责分开：
+ *   **检索**       吃正文 —— 它要的是"人会不会这样说"
+ *   **给模型读**   还是摘要 / 正文，那是渲染层的事，跟这里无关
+ *
+ * 别把 summary 塞回来当索引。它漏掉的那半段，往往正是最要紧的那句。
+ *
+ * @param {Array<{id: 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) {
@@ -46,8 +61,17 @@ export function buildIndex(entries) {
   const list = Array.isArray(entries) ? entries : [];
 
   for (const entry of list) {
-    const hasSummary = typeof entry.summary === 'string' && entry.summary !== '';
-    const tokens = tokenize(hasSummary ? entry.summary : (entry.text ?? ''));
+    // 正文 + 摘要都吃。
+    //
+    // 正文是主力：人问往事用的是"项目失败了""那事搞砸了"这种话，
+    // 而摘要写的是当天的术语（boot.log、apply/routes），一个字都撞不上。
+    //
+    // 摘要不能扔：它带着**别名和梗称**（「边缘行者2 / 续集 / 那部动画」），
+    // 而正文不一定写全。test/core.test.mjs 里有一条就是拿这个卡着的。
+    //
+    // 两边都进去的代价只有建索引变重（32ms → 177ms，一次性），
+    // 检索本身在 0.2ms 量级，一个 token 都不花。
+    const tokens = tokenize(`${entry.text ?? ''}\n${entry.summary ?? ''}`);
     if (tokens.length === 0) continue;
 
     const tf = new Map();
@@ -223,6 +247,58 @@ export function searchScores(index, query, options = {}) {
   return scores;
 }
 
+/**
+ * 取前 N 条，但只留**跟最高分接近**的那些。
+ *
+ * ── 为什么需要这道闸（2026-11-02 实测）──
+ *
+ * 光按 top-N 取会给一堆噪音。真实档案、查询「项目失败了」：
+ *
+ *     第 1 名  1.00  那个失败的项目（对）
+ *     第 2 名  0.96  欢乐谷小时候没玩刺激项目（错，只是撞上了「项目」）
+ *     第 3-12 名      气泡卡没、赛博朋克、0.1.8 发布……（全无关）
+ *
+ * 12 条塞进去 5412 token，**八成是垃圾**。多给不等于不漏，只等于更吵。
+ *
+ * ── 为什么用"相对门槛"而不是固定分数线 ──
+ *
+ * 分数是**饱和函数**（1 − e^−gain），所以它的绝对刻度会随查询长短漂移：
+ * 一句长问句可能最高才 0.7，一句短词可能全在 0.99。固定门槛要么全砍要么全留。
+ *
+ * 跟着第一名走就稳：**离第一名太远的就是另一件事。**
+ *
+ * ── 但 `limit` 不是没用 ──
+ *
+ * 它是上限。真正相关多的查询（「八条鱼论战」前 4 名全对）不会因为
+ * 相对门槛被砍到只剩 1 条，而铺得很开的查询（「项目失败了」）会被砍到 5~6 条。
+ * 两个数字一起用，才是"宽但不吵"。
+ *
+ * @param {ReturnType<typeof buildIndex>} index
+ * @param {string} query
+ * @param {{limit?: number, ratio?: number, floor?: number}} [options]
+ * @returns {Map<string, number>} id → 相似度，已按分数降序
+ */
+export function topHitScores(index, query, options = {}) {
+  const limit = Number.isFinite(options.limit) ? Math.max(0, Math.floor(options.limit)) : 15;
+  const ratio = Number.isFinite(options.ratio) ? options.ratio : 0.85;
+  const floor = Number.isFinite(options.floor) ? options.floor : 0.6;
+  const out = new Map();
+  if (limit === 0) return out;
+
+  // 多捞一些再砍：后面的过滤（note、最近的事）会再淘汰一批。
+  const scored = searchScores(index, query, { limit: Math.max(limit * 3, 30) });
+  const ranked = [...scored.entries()].sort((a, b) => b[1] - a[1]);
+  if (ranked.length === 0) return out;
+
+  const cutoff = Math.max(floor, ranked[0][1] * ratio);
+  for (const [id, sim] of ranked) {
+    if (sim < cutoff) break;
+    out.set(id, sim);
+    if (out.size >= limit) break;
+  }
+  return out;
+}
+
 /** 新鲜度：指数衰减 */
 function recencyFactor(createdAt, now, halfLifeDays) {
   if (!Number.isFinite(createdAt)) return 0.5;
@@ -382,3 +458,104 @@ export function softmaxPick(items, temperature, rng) {
   }
   return items[items.length - 1];
 }
+
+/**
+ * 从一句话里认出「他问的是哪段时间」。
+ *
+ * ── 为什么要它 ──
+ *
+ * 人问往事，一半靠内容、一半靠时间：
+ *
+ *      「赛博朋克那事」   内容好找
+ *      「上个月那个」     一个专有名词都没有 —— 拿去做内容检索，一个字都撞不上
+ *
+ * 以前索引里没有时间，日期只活在条目的 created_at 上，检索根本用不着它。
+ * 现在索引行前面带日期，这一层才终于有意义。
+ *
+ * ── 故意做得很土 ──
+ *
+ * 只认几种说法，认不出就返回 null，**绝不猜**。
+ * 猜错的代价比认不出大：认不出只是回到老路（按内容找），
+ * 猜错会把真正要的那条挡在时间窗外 —— 而且无声。
+ *
+ * @param {unknown} query
+ * @param {number} [now]
+ * @returns {{label: string, from: number, to: number} | null}
+ */
+export function parseTimeHint(query, now = Date.now()) {
+  if (typeof query !== 'string' || query === '') return null;
+
+  const DAY = 86400000;
+  const startOfDay = (t) => {
+    const d = new Date(t);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+  };
+  const today = startOfDay(now);
+  const dayRange = (fromDay, toDay) => ({ from: fromDay, to: toDay + DAY - 1 });
+
+  // 「大前天 / 前天 / 昨天 / 今天」—— 单个自然日
+  const single = [
+    ['大前天', 3, '大前天'],
+    ['前天', 2, '前天'],
+    ['昨天', 1, '昨天'],
+    ['昨儿', 1, '昨天'],
+    ['今天', 0, '今天'],
+    ['今儿', 0, '今天'],
+  ];
+  for (const [word, back, label] of single) {
+    if (query.includes(word)) {
+      const d = today - back * DAY;
+      return { label, ...dayRange(d, d) };
+    }
+  }
+
+  // 最近几天
+  for (const word of ['前两天', '前几天', '这几天', '这两天']) {
+    if (query.includes(word)) return { label: '最近三天', ...dayRange(today - 2 * DAY, today) };
+  }
+  if (query.includes('最近')) return { label: '最近一周', ...dayRange(today - 6 * DAY, today) };
+
+  // 自然周（周一为一周之始）
+  const weekday = (new Date(today).getDay() + 6) % 7; // 周一 = 0
+  if (query.includes('上周') || query.includes('上星期')) {
+    const thisMonday = today - weekday * DAY;
+    return { label: '上周', ...dayRange(thisMonday - 7 * DAY, thisMonday - DAY) };
+  }
+  if (query.includes('这周') || query.includes('本星期') || query.includes('本周')) {
+    const thisMonday = today - weekday * DAY;
+    return { label: '这周', ...dayRange(thisMonday, today) };
+  }
+
+  // 自然月
+  const d0 = new Date(today);
+  if (query.includes('上个月') || query.includes('上月')) {
+    const from = new Date(d0.getFullYear(), d0.getMonth() - 1, 1).getTime();
+    const to = new Date(d0.getFullYear(), d0.getMonth(), 1).getTime() - 1;
+    return { label: '上个月', from, to };
+  }
+  if (query.includes('这个月') || query.includes('本月')) {
+    const from = new Date(d0.getFullYear(), d0.getMonth(), 1).getTime();
+    return { label: '这个月', ...dayRange(from, today) };
+  }
+  if (query.includes('去年')) {
+    const from = new Date(d0.getFullYear() - 1, 0, 1).getTime();
+    const to = new Date(d0.getFullYear(), 0, 1).getTime() - 1;
+    return { label: '去年', from, to };
+  }
+
+  // 「X 月」—— 今年的那个月；如果还没到，就当去年
+  const m = query.match(/(\d{1,2})\s*月/);
+  if (m !== null) {
+    const month = Number(m[1]);
+    if (month >= 1 && month <= 12) {
+      let year = d0.getFullYear();
+      if (month > d0.getMonth() + 1) year -= 1;
+      const from = new Date(year, month - 1, 1).getTime();
+      const to = new Date(year, month, 1).getTime() - 1;
+      return { label: `${month} 月`, from, to };
+    }
+  }
+
+  return null;
+}