dsh-fish-memory 1.4.3 → 1.4.5

package/README.md

@@ -49,15 +49,16 @@
 在 DSH 里：**设置 → 插件 → 安装**，填下面这一行；或者命令行：
 
 ```
-github:Yuuyuko-uu/dsh-fish-memory
+dsh-fish-memory
 ```
 
 ```sh
-dsh plugin --profile web add github:Yuuyuko-uu/dsh-fish-memory
+dsh plugin --profile web add dsh-fish-memory
 ```
 
-> ⚠ 上面这行会让包管理器去 **clone 仓库**，机器上没装 `git` 会报 `ERR_PNPM_GIT_FETCH_FAILED`。
-> 没 git 就用下面这条 **tarball 直链**，一样能装，不用 git：
+> 也可以在 npm 上直接看到这个包（含历史版本）：<https://www.npmjs.com/package/dsh-fish-memory>
+
+> 上面那条要是碰到网络问题（npm 抽风、或者想固定某一次的代码快照），可以改用 tarball 直链，不用 git：
 
 ```bash
 dsh plugin --profile web add https://codeload.github.com/Yuuyuko-uu/dsh-fish-memory/tar.gz/refs/heads/main
@@ -70,8 +71,7 @@ dsh plugin --profile web add https://codeload.github.com/Yuuyuko-uu/dsh-fish-mem
 
 重启后，打开 **设置 → 鱼的记忆**。
 
-> 还没上 npm，所以**要用上面那条 GitHub 的**。
-> （以后要是上了 npm，`dsh plugin add dsh-fish-memory` 也能用。）
+> 也可以直接装 npm 包：`dsh plugin add dsh-fish-memory`。
 > ⭐ 最省事的一条：把仓库链接贴给你自己的 DSH，说「**帮我装这个插件**」。
 
 ### 装完起不来？先看这个
@@ -122,7 +122,7 @@ $p = "把上面 BOM=True 那一行的路径粘到这里"
 
 ```bash
 dsh plugin --profile desktop remove dsh-fish-memory
-dsh plugin --profile desktop add github:Yuuyuko-uu/dsh-fish-memory
+dsh plugin --profile desktop add dsh-fish-memory
 ```
 
 > ⚠️ **必须先卸再装**：直接装可能拿到缓存里的旧副本，装完还是老的。

package/lib/client.js

@@ -3949,6 +3949,36 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
               : '全关着 —— 哪个会话都不记也不读，工具列表里也不会出现它。',
           ),
         ),
+        // ⭐ 1.4.5：记忆按什么归类 —— 按会话 / 按工作区
+        React.createElement(
+          'div',
+          { style: Object.assign({}, S.row, S.条, { alignItems: 'center' }) },
+          React.createElement(
+            'button',
+            {
+              style: Object.assign({}, S.btn, {
+                flex: 'none',
+                color: d.模式 === 'workspace' ? '#8fd0a0' : 'inherit',
+                borderColor: d.模式 === 'workspace' ? 'rgba(143,208,160,.6)' : 'rgba(128,128,128,.35)',
+              }),
+              disabled: busy,
+              onClick: () => {
+                setBusy(true)
+                post('/mode', { 模式: d.模式 === 'workspace' ? 'session' : 'workspace' })
+                  .then(() => { setBusy(false); load() })
+                  .catch(() => setBusy(false))
+              },
+            },
+            (d.模式 === 'workspace' ? '按工作区' : '按会话'),
+          ),
+          React.createElement(
+            'div',
+            { style: Object.assign({}, S.dim, { flex: 1, minWidth: 0 }) },
+            d.模式 === 'workspace'
+              ? '整个工作区共用一个记忆库 —— 新开的会话自动接上，归档旧会话记忆也不会跟着走。'
+              : '每个会话各记各的。会话开久了变卡、要归档换新会话时，切成「按工作区」就接得上了。',
+          ),
+        ),
         (d.sessions || []).map((s) =>
           React.createElement(
             'div',

package/lib/index.js

@@ -39,6 +39,50 @@ const CFG_DIR = process.env.DSH_HOME || join(homedir(), '.dsh')
 const STORE_DIR = join(CFG_DIR, 'fish-memory')
 const BACKUP_DIR = join(CFG_DIR, 'fish-memory-backup')
 const CFG_PATH = join(CFG_DIR, 'fish-memory-config.json')
+
+/**
+ * ⭐ 1.4.5：工作区标识 —— 跟 DSH 自己的 `projectKey(cwd)` **一字不差**。
+ *
+ * DSH 把会话存在 `~/.dsh/sessions/<工作区目录名>/<会话id>/`，那层目录名就是它算出来的键。
+ * 规则（跟着 DSH 抄，别自己发明）：
+ *   · 分隔符（`/` `\` `:`）压成一个 `-`（连续的分隔符只留一个）；
+ *   · 只有 `[A-Za-z0-9._-]` 原样保留 —— 其余字符（含 `~`、`'`、中文）一律写成
+ *     `~` + 4 位大写十六进制（按 UTF-16 码元）；
+ *   · 去掉开头连续的 `-`（空了就是 `root`），截到 251 个字符，两头各包一个 `-`。
+ * 例：`C:\Users\me\Desktop\项目目录\dsh`
+ *   → `--C-Users-me-Desktop-~9879~76EE~76EE~5F55-dsh--`
+ *
+ * ⚠ 算法必须跟 DSH 完全一致：差一个字符，同一个工作区就会裂成两份。
+ *   单引号 / `~` 以前被简化成 `-` 就踩过这个坑（心情插件那边修过一次）。
+ */
+export function 工作区目录名(p) {
+  const s = String(p == null ? '' : p).trim()
+  if (!s) return ''
+  if (/^--.*--$/.test(s)) return s          // 给的本来就是目录名
+  let 可读 = ''
+  let 连续分隔 = false
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    if (ch === '/' || ch === '\\' || ch === ':') {
+      if (!连续分隔) 可读 += '-'
+      连续分隔 = true
+    } else if (ch !== '~' && /^[A-Za-z0-9._-]$/.test(ch)) {
+      可读 += ch
+      连续分隔 = false
+    } else {
+      可读 += '~' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')
+      连续分隔 = false
+    }
+  }
+  可读 = 可读.replace(/^-+/, '') || 'root'
+  return '--' + 可读.slice(0, 251) + '--'
+}
+
+/** 工作区的可读路径：从会话目录名反查不回来，就直接给目录名 */
+function 工作区可读名(键) {
+  return String(键 || '').replace(/^--/, '').replace(/--$/, '') || '（未分组）'
+}
+
 const DAY = 86400000
 // ⭐⭐ 2026-09-21（反馈：「别人导入会踩什么坑」时改的）：**时区不能再写死北京** ✗
 //   原来写死 +8。实测：换纽约、换东京，日期显示一模一样 ——
@@ -225,9 +269,93 @@ function diag(msg) {
 // ---------- 每个会话一份库 ----------
 
 function storePath(sid) {
-  return join(STORE_DIR, String(sid).replace(/[^a-zA-Z0-9_-]/g, '_') + '.json')
+  // ⭐ 1.4.5：工作区模式下，同一工作区的所有会话指向**同一个库文件**。
+  //   放在最底层改（而不是改每个调用点）—— 少一处漏改就少一个「这个库怎么没带上记忆」。
+  //   模式从配置里读一次（用户可能在设置页切）；读不到 / 算不出工作区都退回按会话，
+  //   绝不因为工作区算不出来就把记忆弄丢。
+  const 用名 = String(库名(sid, { 模式: 读模式() }) || sid)
+  return join(STORE_DIR, 用名.replace(/[^a-zA-Z0-9_-]/g, '_') + '.json')
+}
+
+// --------------------------------------------------------------------------
+// ⭐ 1.4.5：工作区模式
+//   DSH 的会话都躺在 `~/.dsh/sessions/<工作区目录名>/<会话 id>/`，所以：
+//     · 工作区标识 = 中间那层目录名（跨机器可复制、不依赖绝对路径）
+//     · 工作区模式下：**同一工作区的会话共用一个记忆库**
+//     · 跟「按会话」二选一：同时开等于一份记忆被两套归属抢，必出 bug
+//
+//   为什么需要：一个会话久了会大到打开都卡，为了流畅只能归档、开新会话。
+//   可记忆是按会话存的，新会话里什么都不记得 —— 工作区模式就是治这个的。
+// --------------------------------------------------------------------------
+const 工作区缓存 = { at: 0, 数据: null }
+
+function 目录们(p) {
+  try {
+    return readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+  } catch (error) {
+    return []
+  }
+}
+
+/**
+ * 扫一遍会话根目录：会话 → 工作区目录名、工作区目录名 → 会话 ids。
+ * 结果缓存 5 秒（心跳每 3 秒一次，别每次都读盘）。
+ * ⚠ 跟心情插件一个写法：**只认 CFG_DIR**，不给测试留参数（测试靠先设 DSH_HOME 再 import）。
+ */
+export function 扫会话目录(强制 = false) {
+  const 现在 = Date.now()
+  if (!强制 && 工作区缓存.数据 && 现在 - 工作区缓存.at < 5000) return 工作区缓存.数据
+  const 根 = join(CFG_DIR, 'sessions')
+  const bySession = new Map()    // 会话 id -> 工作区目录名
+  const byWorkspace = new Map()  // 工作区目录名 -> [会话 id]
+  for (const ws of 目录们(根)) {
+    const 会话们 = []
+    for (const sid of 目录们(join(根, ws))) {
+      const k = String(sid || '').trim()
+      if (!k) continue
+      会话们.push(sid)
+      if (!bySession.has(k)) bySession.set(k, ws)
+      // 老会话可能带 `session-` 前缀，两种写法都记上
+      if (k.startsWith('session-')) {
+        const 短 = k.slice('session-'.length)
+        if (短 && !bySession.has(短)) bySession.set(短, ws)
+      } else if (!bySession.has('session-' + k)) {
+        bySession.set('session-' + k, ws)
+      }
+    }
+    if (会话们.length) byWorkspace.set(ws, 会话们)
+  }
+  const 数据 = { bySession, byWorkspace, at: 现在 }
+  工作区缓存.data = 数据
+  工作区缓存.at = 现在
+  return 数据
+}
+
+/** 这个会话属于哪个工作区（认不出来就空串 → 退回按会话） */
+export function 会话的工作区(sid) {
+  const k = String(sid == null ? '' : sid).trim()
+  if (!k) return ''
+  const 表 = 扫会话目录()
+  return 表.bySession.get(k) || ''
+}
+
+/**
+ * ⭐ 1.4.5：工作区模式下，一份记忆归**哪个库**。
+ *
+ * 用工作区目录名当库名（加个前缀，别跟会话 id 撞）。这样：
+ *   · 同一个工作区里开多少新会话，读写的都是同一份；
+ *   · 归档旧会话不会把记忆带走 —— 新会话一开就接上了。
+ */
+export function 库名(sid, 配置) {
+  // ⚠ 不在这里读全局配置 —— 调用方把「模式」传进来。
+  //   自己读配置会让这个函数没法单测（而且 storePath 在模块加载早期就会被调用）。
+  const 模式 = String((配置 && 配置.模式) || 'session')
+  if (模式 !== 'workspace') return String(sid)
+  const ws = 会话的工作区(sid)
+  return ws ? 'ws_' + ws : String(sid)
 }
 
+
 // ⭐ 1.2.7（issue #7）：**全局参数**
 //   以前参数只存在每个记忆库（memory-store/<会话>.json）里 —— 一个库都没有时，
 //   保存等于没保存，F5 一刷就回默认值。
@@ -279,12 +407,21 @@ function loadStore(sid) {
       return data
     }
     corruptIncidents.delete(path)
+    // ⭐ 1.4.4：老版本把「运行环境 / 记忆提醒列表项 / 技能目录」这些机器文本当成线索存了进来，
+    //   白占召回记录的 100 条上限。读的时候清一遍：净化之后什么都不剩的，那条记录本来就没有用。
+    //   （只动 traces 这种诊断记录，记忆本身一条都不碰。）
+    const 旧记录 = Array.isArray(raw.traces) ? raw.traces : []
+    const traces = 旧记录.filter((t) => {
+      const q = typeof (t && t.query) === 'string' ? t.query : ''
+      if (!q) return true // 没有 query 的老记录不动
+      return !明显是机器写的(清掉注入上下文(q))
+    })
     return {
       version: 2,
       purgeEpoch: purgeEpochOf(raw),
       policy: 合并参数(raw.policy),
       memories: Array.isArray(raw.memories) ? raw.memories : [],
-      traces: Array.isArray(raw.traces) ? raw.traces : [],
+      traces,
       deleted: Array.isArray(raw.deleted) ? raw.deleted : [],
     }
   } catch (error) {
@@ -442,6 +579,15 @@ function saveStore(sid, data, 选项) {
     if (!(选项 && 选项.raw)) {
       if (盘 && Array.isArray(盘.memories)) data = 合并库(盘, data, 选项)
     }
+    // ⭐ 1.4.4：合并会把盘上的旧 trace 捡回来，所以**这里也得清一遍**
+    //   （只在加载时清没用：下一次保存又原样回来了）。
+    if (Array.isArray(data.traces) && data.traces.length) {
+      data.traces = data.traces.filter((t) => {
+        const q = typeof (t && t.query) === 'string' ? t.query : ''
+        if (!q) return true
+        return !明显是机器写的(清掉注入上下文(q))
+      })
+    }
     // 与内容一起原子发布；其他实例后续读取时也能识别旧代际（并非跨进程事务）。
     // 先构造待写副本；写失败时保留恢复候选的原代际，允许同对象安全重试。
     data = { ...data, purgeEpoch: 选项 && 选项.raw ? randomUUID() : epoch }
@@ -528,6 +674,17 @@ function setGlobalOn(on) {
   }
 }
 
+// ⭐ 1.4.5：记忆按什么归类 —— 'session'（默认，跟以前一样）/ 'workspace'（同一工作区共用一份）。
+//   两种模式二选一：同时开等于一份记忆被两套归属抢，必出 bug。
+function 读模式() {
+  try {
+    const c = loadCfg()
+    return String(c.模式 || 'session') === 'workspace' ? 'workspace' : 'session'
+  } catch (error) {
+    return 'session'
+  }
+}
+
 // 取消一个注册（DSH 那套返回的是**函数**，个别地方是 { off }）
 function 卸掉效果(d) {
   try {
@@ -1826,13 +1983,18 @@ export function 清掉注入上下文(文) {
   //   ③ 记忆提醒里的固定句子（下面是你们过去真实发生过的事 / （如果此刻你想起什么 …））。
   let 跳到空行 = false
   let 跳元信息 = false
-  const 元信息行 = /^(Current runtime context|Current DSH|Current working directory|Current DeepSeek Harness|Browser time zone|Time sampled|Approval prompts)/i
+  // ⭐ 1.4.4：方块（【…】）跳过之后，**紧跟的列表项也算那块的一部分** ——
+  //   render() 写出来的是 `- 3 天前（10-27）：…`、`- 一直：…`，以前那张白名单只认
+  //   昨天/前天/今天/日期，这些全漏了出来，被当成「她这一轮说的话」去检索。
+  let 方块之后 = false
+  const 元信息行 = /^(Current runtime context|Current DSH|Current working directory|Current DeepSeek Harness|Browser time zone|Time sampled|Elapsed since|Approval (policy|prompts))/i
   const 固定句 = /^(下面是你们过去真实发生过的事|（?如果此刻你想起什么|有时间的事会写在前面)/
   for (const 行 of 行们) {
     const 净 = 行.trim()
     if (跳到空行) {
       if (!净) {
         跳到空行 = false
+        方块之后 = true
         留.push('')
       }
       continue
@@ -1850,6 +2012,11 @@ export function 清掉注入上下文(文) {
       跳到空行 = true
       continue
     }
+    // 刚跳过一块之后，跟着的列表项（不管前面写的是「3 天前」还是「一直」）都是那块的东西
+    if (方块之后) {
+      if (/^[-*]\s/.test(净)) continue
+      方块之后 = false
+    }
     // 记忆提醒里的列表项（`- 前天 12:56：…`）也一起跳 —— 那是「提醒」，不是她这一轮说的话
     if (/^-\s*(前天|昨天|今天|\d{1,2}-\d{1,2}|\d{4}-\d{2}-\d{2})/.test(净) && 净.includes('：')) {
       continue
@@ -1867,6 +2034,29 @@ export function 清掉注入上下文(文) {
   return 留.join(String.fromCharCode(10)).trim()
 }
 
+/**
+ * ⭐ 1.4.4：这一行**明显是机器写的**，不是人说的话。
+ *
+ * 只给「清老记录」用（召回记录里那些历史烂条目）：trace 里只剩下净化后的残渣，
+ * 没有上下文了，认不出「它原本跟着哪一块」，所以按长相判。
+ * ⚠ 别拿它去决定「这一轮用哪句检索」—— 那个走 source.kind（见 不是人说的话）。
+ */
+export function 明显是机器写的(文) {
+  const q = String(文 == null ? '' : 文).trim()
+  if (!q) return true
+  if (/^(Current runtime context|Current DSH|Current working directory|Current DeepSeek Harness|Browser time zone|Time sampled|Elapsed since|Approval (policy|prompts))/i.test(q)) return true
+  if (/^<system-reminder>/i.test(q)) return true
+  if (/^\[model changed/i.test(q)) return true
+  if (/^This is an automatically generated checkpoint/i.test(q)) return true
+  // 记忆提醒里的列表项：`- 昨天 16:10：…` / `- 3 天前（10-27）：…` / `- 一直：…`
+  // ⚠ 「N 天前」这种写法以前漏了，正是面板上一堆 `- 3 天前（10-27）` 的来源。
+  if (/^[-*]\s*(一直|今天|昨天|前天|\d+\s*(天|个月|年)前|\d{1,2}-\d{1,2}|\d{4}-\d{2}-\d{2})/.test(q)) return true
+  // 别的插件塞进来的提示（心情 / 陪看字幕 / 骰子喊她聊天 / 自动刷B站）——
+  // 这些是「插件对模型说的话」，不是她说的，老记录里混进来的一样清掉。
+  if (/^（(此刻你|下面这句是|上面这些是|你俩正一起看着|这是我游戏里|到谷时)/.test(q)) return true
+  return false
+}
+
 /**
  * ⭐ 1.4.2：线索太短就**借上文**。
  *
@@ -1912,6 +2102,7 @@ function 最近几句(session, n = 3) {
       const e = ev[i]
       const type = e && (e.type || e.kind)
       if (type !== 'user/message') continue
+      if (不是人说的话(e)) continue // ⭐ 1.4.4：宿主塞的上下文整条跳过
       const p = e.payload !== undefined ? e.payload : e.data
       const txt = textOfMessage(p)
       if (!txt) continue
@@ -1927,22 +2118,77 @@ function 最近几句(session, n = 3) {
   return 出
 }
 
+// ⭐ 1.4.4：哪些来源**根本不是人说的话** —— 直接跳过，别指望文本白名单兜得住。
+//
+// 坑的来历：以前只靠「净化后是不是空的」来判断，而净化是一张文本白名单
+// （`Current …` / `Approval prompts` / `- 昨天 …`）。可宿主每加一句新措辞就漏一条：
+//   · 审批策略从 "never" 换成 "ask" 之后，那一行变成 `Approval policy: ask. …`，白名单没跟上；
+//   · 插件自己 render 出来的列表项是 `- 3 天前（10-27）：…` / `- 一直：…`，也不在白名单里。
+// 漏出来的那几行就成了「这一轮她说的那句话」，被拿去检索 —— 面板上一堆重复的英文/列表项。
+//
+// 源头上 DSH 每条 user/message 都带 `source.kind`，比猜文本可靠得多。
+// 这里列的是**宿主/插件塞进来的、不是人说的话**那些来源：
+//   runtime-context / time-context / skill-catalog / model-selection / compact-checkpoint …
+//   是 DSH 自己往会话里补的上下文；speak-up / her-words（插件定时替人开口那种「该去找他聊天了」）、
+//   fishbuddy-watch（片子字幕）、bili-duty-scan（自动刷B站）是插件替她开口或替她看的。
+// ⚠ **用黑名单不用白名单**：别的 IM 桥（im-connect 之类）用的是什么 kind 我们不知道，
+//   认成「不是人话」就等于让那些用户永远检索不到记忆 —— 比原来的毛病更糟。
+//   认不出来的来源**一律当人话**，靠上面的文本净化兜底。
+const 机器来源 = new Set([
+  'runtime-context', 'time-context', 'skill-catalog', 'model-selection',
+  'compact-checkpoint', 'repeat-tool-reminder', 'user-approval',
+  'system-prompt', 'working-directory', 'ptc-mode', 'tool-registry',
+  'agent-instructions', 'subagent-settled', 'team-message', 'agent-message',
+  'speak-up', 'her-words', 'bili-duty-scan', 'fishbuddy-watch',
+])
+
+function 来源种类(e) {
+  try {
+    const 源 = e && e.data && e.data.source
+    return (源 && typeof 源.kind === 'string' && 源.kind) || ''
+  } catch (error) {
+    return ''
+  }
+}
+
+// 认不出来源的老会话 / 第三方渠道：**不拦**（交给文本净化兜底），免得把真话也丢了
+function 不是人说的话(e) {
+  const 种 = 来源种类(e)
+  if (!种) return false
+  if (机器来源.has(种)) return true
+  // `plugin:xxx` 那种是插件自报家门塞进来的（如 plugin:chat-import / plugin:meow-memory）
+  return 种.startsWith('plugin:')
+}
+
+/**
+ * ⭐ 1.4.4：从事件流里挑「这一轮她真正说的那句话」——抽成纯函数，好单测。
+ * 返回原（未净化）文本；调用方再净化一次（跟以前一样，净化结果为空就说明这条不算）。
+ * @param {Array} 事件们 session.snapshotEvents() 的结果
+ * @returns {string} 原文本；找不到返回 ''
+ */
+export function 挑这一轮的真话(事件们) {
+  const ev = Array.isArray(事件们) ? 事件们 : []
+  for (let i = ev.length - 1; i >= 0; i--) {
+    const e = ev[i]
+    const type = e && (e.type || e.kind)
+    if (type !== 'user/message') continue
+    // ⭐ 1.4.4：宿主塞的上下文（运行环境 / 时间 / 技能目录 / 记忆提醒 / 压缩摘要 …）整条跳过
+    if (不是人说的话(e)) continue
+    const p = e.payload !== undefined ? e.payload : e.data
+    const txt = textOfMessage(p)
+    if (!txt) continue
+    // ⭐ 1.4.1：宿主会把「运行环境」「【你记得的事】」这类东西跟真话夹在同一条里 ——
+    //   净化之后是空的就**往前再找一条**，别拿它当线索。
+    const 净 = 清掉注入上下文(txt)
+    if (净 && 净.trim()) return txt
+  }
+  return ''
+}
+
 function lastUserTextOf(session) {
   try {
     if (!session || typeof session.snapshotEvents !== 'function') return ''
-    const ev = session.snapshotEvents() || []
-    for (let i = ev.length - 1; i >= 0; i--) {
-      const e = ev[i]
-      const type = e && (e.type || e.kind)
-      if (type !== 'user/message') continue
-      const p = e.payload !== undefined ? e.payload : e.data
-      const txt = textOfMessage(p)
-      if (!txt) continue
-      // ⭐ 1.4.1：宿主会把「运行环境」「【你记得的事】」这类东西当成 user 消息塞进来 ——
-      //   有的轮次里整条就只剩这些。净化之后是空的就**往前再找一条**，别拿它当线索。
-      const 净 = 清掉注入上下文(txt)
-      if (净 && 净.trim()) return txt
-    }
+    return 挑这一轮的真话(session.snapshotEvents() || [])
   } catch (error) {}
   return ''
 }
@@ -2533,6 +2779,9 @@ function 补历史尺(sid, session) {
     for (let i = ev.length - 1; i >= 0 && 收 < 2000; i--) {
       const e = ev[i]
       if (!e || e.type !== 'user/message') continue
+      // ⭐ 1.4.4：尺子是「她怎么说话」，喂进去的全得是人话；
+      //   运行环境 / 片子字幕 / 骰子提示那些会把词频带偏。
+      if (不是人说的话(e)) continue
       const p = e.payload !== undefined ? e.payload : e.data && e.data.message !== undefined ? e.data.message : e.data
       const txt = textOfMessage(p)
       if (!txt) continue
@@ -3056,7 +3305,7 @@ function recall(data, query, now, sid) {
   }
   // ⭐⭐ 2026-10-27（issue #14）：**常驻层** —— 长期事实不看这句话问的是什么，每轮都带上
   //
-  //   她的原话（转给用户那条建议）：「把长期事实改为每轮注入，其他记忆打分淡忘」。
+  //   当时的建议（转给用户那条）：「把长期事实改为每轮注入，其他记忆打分淡忘」。
   //   以前事实也走召回：这句话没撞上「我住在杭州」，这条就进不来 —— 可它明明是「要记一辈子」的事。
   //   现在：
   //     · **长期事实**：每轮固定带 factsMax 条（按重要度、再按时间取前几名），
@@ -3533,7 +3782,7 @@ function 分支来处Of(ctx, sid) {
 }
 
 function buildMemoryList(ctx) {
-  const out = { ok: true, sessions: [], policy: null, ghosts: 0, 全局开关: globalOn() }
+  const out = { ok: true, sessions: [], policy: null, ghosts: 0, 全局开关: globalOn(), 模式: 读模式() }
   // ⭐ 1.2.7：设置页显示「全局参数」—— 以前是「碰到的第一个库的参数」，没有库就什么都没有
   try {
     const c0 = loadCfg()
@@ -3812,6 +4061,9 @@ export function apply(ctx) {
     try {
       agent.ctx.on('agent/inbox/inserted', (payload) => {
         const msg = payload && payload.message ? payload.message : payload
+        // ⭐ 1.4.4：插件替人开口的那些（骰子喊人聊天 / 自动刷B站 …）不算人说的话，
+        //   既不能当线索兜底，也不能喂进「她自己怎么说话」那把尺子。
+        if (msg && 不是人说的话({ data: msg })) return
         const txt = textOfMessage(msg)
         if (txt) {
           lastText = txt
@@ -3979,7 +4231,14 @@ export function apply(ctx) {
           //   而每轮都要把整份读进来再整份写回去 → 每轮白白多花几十毫秒
           //   （每轮开销大就是这儿）
           //   scored 已经按 P 排好序了，所以前 24 条 = 挑中的 + 最接近的落选 ✓
-          data.traces.push({
+          // ⭐ 1.4.4：**同一轮别记两遍**。这段 text() 在一次请求里会被调用两次
+          //   （装配一次、真正发请求再一次），每次都 push 一条 trace —— 实测 222 条里
+          //   有 108 条是「同一句、相隔 3 秒内」的重复，100 条上限白白占掉一半。
+          //   判据：上一句跟这一句一模一样、而且才过了一小会儿 → 当作同一次，直接覆盖。
+          const 上一条 = data.traces[data.traces.length - 1]
+          const 同一次 = 上一条 && 上一条.query === query.slice(0, 200) &&
+            Math.abs(now - Number(上一条.at || 0)) < 3000
+          const 这条 = {
             at: now,
             session: sid,
             query: query.slice(0, 200),
@@ -3996,7 +4255,9 @@ export function apply(ctx) {
               // 进到提示词里的算 assembled；后面她回复里用上了就变 consumed ✓
               status: r.omission ? null : 'assembled',
             })),
-          })
+          }
+          if (同一次) data.traces[data.traces.length - 1] = 这条
+          else data.traces.push(这条)
           // Trace persistence is auxiliary: an I/O failure must not hide a valid
           // snapshot already read from disk. saveStore records the failure.
           try { saveStore(sid, data) } catch (error) {}
@@ -4422,8 +4683,25 @@ export function apply(ctx) {
       res.end(JSON.stringify({ ok: true, on }))
     })
 
-    mroute('/dsh-fish-memory/toggle', async (req, res) => {
+    // ⭐ 1.4.5：切换「按会话 / 按工作区」。切换不会搬动已有记忆 ——
+    //   只是此后读写的库文件换了，旧的还在（想合并得单独做，不在这条路上）。
+    mroute('/dsh-fish-memory/mode', async (req, res) => {
       let body = ''
+      for await (const chunk of req) body += chunk
+      let b = {}
+      try { b = JSON.parse(body || '{}') } catch (error) {}
+      const 模式 = String(b.模式 || '') === 'workspace' ? 'workspace' : 'session'
+      try {
+        const c = loadCfg()
+        c.模式 = 模式
+        saveCfg(c)
+        diag('记忆归类模式 → ' + 模式)
+      } catch (error) {}
+      res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' })
+      res.end(JSON.stringify({ ok: true, 模式 }))
+    })
+
+    mroute('/dsh-fish-memory/toggle', async (req, res) => {      let body = ''
       for await (const chunk of req) body += chunk
       let b = {}
       try {
@@ -6241,7 +6519,7 @@ mroute('/dsh-fish-memory/wash-keys/undo', async (req, res) => {
 
     // 把记忆复制到**另一个会话** —— 她想在新对话里测（新对话没有上下文，最干净）✓
     // { session: 从哪来, to: 到哪去 }
-    // ⭐ 1.3.7（她 2026-10-28 报的）：以前是**整份覆盖** —— 目标会话原来记的东西全没了。
+    // ⭐ 1.3.7（2026-10-28 报的）：以前是**整份覆盖** —— 目标会话原来记的东西全没了。
     //   现在改成**并进去**：那边原有的都留着，只补它还没有的（同一句话算重复，跳过）。
     mroute('/dsh-fish-memory/copy-to', async (req, res) => {
       let body = ''
@@ -6498,3 +6776,15 @@ export {
   标作废,
   真重复门槛,
 }
+
+/**
+ * ⭐ 1.4.5：给自测用的出口（跟心情插件一个写法）。
+ *   ⚠ 只给测试用，不要在生产代码里调；里面都是纯函数或内部状态读取。
+ */
+export const __测试 = {
+  工作区目录名,
+  扫会话目录,
+  会话的工作区,
+  库名,
+  读模式,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fish-memory",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "给 DSH 里的会话一份会淡忘的长期记忆，每条都带时间。",
   "license": "MIT",
   "type": "module",