dsh-fish-memory 1.5.2 → 1.5.4

package/lib/client.js

@@ -193,10 +193,13 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
       const [confirm, setConfirm] = React.useState(null) // 正在等确认的删除（二次确认，手滑不了）
       const [并入, set并入] = React.useState(null) // ⭐ 1.4.5：切成按工作区前的「合并预览」
       const [showDeleted, setShowDeleted] = React.useState(false)
-      const [selfDraft, setSelfDraft] = React.useState({}) // 每个会话「她自己叫什么」的草稿
+      const [selfDraft, setSelfDraft] = React.useState({}) // 每个会话「它自己叫什么」的草稿
+      const [称草稿, set称草稿] = React.useState({}) // 每个会话「记忆里指对方用哪个字」
+      const [自草稿, set自草稿] = React.useState({}) // 每个会话「它自称什么」
       const [ownerDraft, setOwnerDraft] = React.useState({}) // 每个会话「怎么称呼对方」的草稿
-      const [pronounDraft, setPronounDraft] = React.useState(null) // 用户的称呼草稿
       const [edit, setEdit] = React.useState(null) // 正在改的那条：{id, text, importance}
+      // ⭐ 检索词当场改：{记忆id: 草稿}（模型写的词常常不靠谱，改一次比重新扩一遍快）
+      const [改词, set改词] = React.useState({})
       const [pronounAsk, setPronounAsk] = React.useState(null) // 改了称呼，问要不要连旧记忆一起改
       const [imp, setImp] = React.useState(null) // 档案导入：扫描结果 + 勾选状态
       const [impBusy, setImpBusy] = React.useState(false)
@@ -260,6 +263,8 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
       //   用户导入自己的会话 → 模型读一遍 → 出一份档案 → 再走「从旧档案导入」变成条目
       //   ⚠ 四步分开，因为**第三步调模型、花钱**，得一批一批停下来看 ✓
       const [生成开, set生成开] = React.useState(false) // 面板展开没有
+      // ⭐ 2026-11-04：停用后面板不开了，改成一个**贴在按钮下面**的小提示（不进 notes，免得看不见）
+      const [星汐提示, set星汐提示] = React.useState(false)
       const [生成会话, set生成会话] = React.useState(null) // 这个工作区有哪些会话
       const [生成选, set生成选] = React.useState({}) // 勾了哪几个
       const [生成计划, set生成计划] = React.useState(null) // 算出来的：几批、多少字、多少 token
@@ -548,6 +553,26 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
           )
 
         // 改一条：文本框 + 重要度 + 存 / 算了
+        // 检索词：空格 / 逗号 / 顿号分开，最多 12 个
+        const 拆词 = (文) =>
+          String(文 || '')
+            .split(/[\s,，、]+/)
+            .map((x) => x.trim())
+            .filter(Boolean)
+            .slice(0, 12)
+
+        // 小按钮长相：跟文字分开，别让人以为它是检索词里的一个字
+        const 词按钮 = {
+          flex: 'none',
+          fontSize: 11,
+          padding: '1px 8px',
+          borderRadius: 10,
+          border: '1px solid rgba(122,170,220,.55)',
+          color: '#7aaadc',
+          cursor: 'pointer',
+          whiteSpace: 'nowrap',
+        }
+
         const 改一条 = (m) =>
           React.createElement(
             'div',
@@ -580,7 +605,13 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
                   style: S.btn,
                   disabled: !String(edit.text || '').trim(),
                   onClick: () =>
-                    post('/edit', { session: open, id: m.id, text: edit.text, importance: edit.importance }).then(() => {
+                    post('/edit', {
+                      session: open,
+                      id: m.id,
+                      text: edit.text,
+                      importance: edit.importance,
+                      related: 拆词(edit.related !== undefined ? edit.related : (Array.isArray(m.related) ? m.related.join(' ') : '')),
+                    }).then(() => {
                       setEdit(null)
                       load()
                     }),
@@ -589,7 +620,84 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
               ),
               React.createElement('button', { style: S.btn, onClick: () => setEdit(null) }, '算了'),
             ),
+            // ⭐ 1.5.4：改正文这个框里也一起给了检索词 —— 以前只能改正文，
+            //   想改检索词得再去点下面那行，容易找不到
+            React.createElement(
+              'div',
+              { style: { display: 'flex', gap: 8, alignItems: 'center', marginTop: 6 } },
+              React.createElement('span', { style: { flex: 'none', ...S.dim } }, '检索词'),
+              React.createElement('input', {
+                style: Object.assign({}, S.inp, { flex: 1 }),
+                placeholder: '空格或逗号分开，最多 12 个',
+                value: edit.related !== undefined ? edit.related : (Array.isArray(m.related) ? m.related.join(' ') : ''),
+                onChange: (e) => setEdit(Object.assign({}, edit, { related: e.target.value })),
+              }),
+              React.createElement('span', { style: Object.assign({}, S.dim, { fontSize: 12, flex: 'none' }) }, '以后她说这些词就能捞到这条'),
+            ),
+          )
+
+        // ⭐ 检索词能当场改：模型写的词经常不靠谱，改一次比重新扩一遍快，也不动正文
+        const 存检索词 = (m, 文本) => {
+          const 词 = 拆词(文本)
+          post('/edit', {
+            session: open,
+            id: m.id,
+            text: m.text,
+            importance: typeof m.importance === 'number' ? m.importance : 0.5,
+            related: 词,
+          }).then(() => {
+            const 新 = Object.assign({}, 改词)
+            delete 新[m.id]
+            set改词(新)
+            load()
+          })
+        }
+        const 关掉改词 = (id) => {
+          const 新 = Object.assign({}, 改词)
+          delete 新[id]
+          set改词(新)
+        }
+        const 检索词行 = (m) => {
+          const 在改 = 改词[m.id] !== undefined
+          const 有 = Array.isArray(m.related) && m.related.length
+          if (在改) {
+            return React.createElement(
+              'div',
+              { style: Object.assign({}, S.dim, { margin: '0 0 6px 104px', fontSize: 11, display: 'flex', gap: 6, alignItems: 'center', flexWrap: 'wrap' }) },
+              React.createElement('span', null, '能搜到它的词：'),
+              React.createElement('input', {
+                style: Object.assign({}, S.inp, { width: 340, fontSize: 11 }),
+                value: 改词[m.id],
+                placeholder: '空格或逗号分开，最多 12 个',
+                onChange: (e) => set改词(Object.assign({}, 改词, { [m.id]: e.target.value })),
+              }),
+              React.createElement('span', { style: Object.assign({}, S.link, { fontSize: 11 }), onClick: () => 存检索词(m, 改词[m.id]) }, '存'),
+              React.createElement('span', { style: Object.assign({}, S.link, { fontSize: 11 }), onClick: () => 关掉改词(m.id) }, '算了'),
+            )
+          }
+          if (!有) {
+            return React.createElement(
+              'div',
+              { style: Object.assign({}, S.dim, { margin: '0 0 6px 104px', fontSize: 11, display: 'flex', gap: 6, alignItems: 'center' }) },
+              React.createElement('span', null, '还没有检索词'),
+              React.createElement(
+                'span',
+                { style: 词按钮, onClick: () => set改词(Object.assign({}, 改词, { [m.id]: '' })) },
+                '＋ 加检索词',
+              ),
+            )
+          }
+          return React.createElement(
+            'div',
+            { style: Object.assign({}, S.dim, { margin: '0 0 6px 104px', fontSize: 11, overflowWrap: 'anywhere', wordBreak: 'break-word', display: 'flex', gap: 8, alignItems: 'center' }) },
+            React.createElement('span', { style: { flex: 1 } }, '能搜到它的词：' + m.related.join(' ')),
+            React.createElement(
+              'span',
+              { style: 词按钮, onClick: () => set改词(Object.assign({}, 改词, { [m.id]: m.related.join(' ') })) },
+              '改检索词',
+            ),
           )
+        }
 
         const 一条记忆 = (m) =>
           React.createElement(
@@ -721,13 +829,7 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
                   '提炼前：' + m.textBefore,
                 )
               : null,
-            m.related && m.related.length
-              ? React.createElement(
-                  'div',
-                  { style: Object.assign({}, S.dim, { margin: '0 0 6px 104px', fontSize: 11, overflowWrap: 'anywhere', wordBreak: 'break-word' }) },
-                  '能搜到它的词：' + m.related.join(' '),
-                )
-              : null,
+            检索词行(m),
             // ⭐⭐ 2026-09-23：**「这条讲的是哪件事」** —— 挂在这儿（第二行小字），不占行里的宽度 ✓
             //   ⚠⚠ 别用「事实键」这种我自己造的词 ——
             //     她说了「让人看不懂，写通俗一点的」✗
@@ -1296,7 +1398,19 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
         //   ④ 存成档案文件 → 再走已有的「从旧档案导入」变成记忆条目
         // ═══════════════════════════════════════════════════════════════
         const 开生成 = () => {
-          set生成开(true)
+          // ⭐ 2026-11-04：这个自带流程**停用**了。
+          //   它一直有 bug（会话列表筛不准、批次落盘不稳），而且她几乎没用过。
+          //   生成档案这件事已经由独立插件「星汐」（dsh-xingxi）接管 ——
+          //   那边能绑文件夹、按天分批、原文留底，比这里靠谱。
+          //   点按钮不再进旧流程，只弹一句提示（旧面板代码留着，但这里不再打开）。
+          set生成开(false)
+          setNotes([
+            '「从会话生成档案」已经停用 —— 请改用它：**星汐（dsh-xingxi）**。',
+            '在 DSH 里装：dsh plugin add dsh-xingxi；装完侧栏会多一个「星汐」。',
+            '旧流程有 bug（会话列表筛不准、批次落盘不稳），这里不再提供入口。',
+          ])
+          return
+          /* eslint-disable no-unreachable */
           set生成会话(null)
           set生成计划(null)
           set生成条目([])
@@ -2353,43 +2467,69 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
           return 小件
         }
 
+        // ⭐ 四格排成同一个样子：左边标签等宽、中间输入框、右边说明（字一样大）
+        const 一格 = (标签, 节点, 说明) =>
+          React.createElement(
+            'div',
+            { style: { display: 'flex', alignItems: 'center', gap: 10, marginBottom: 8 } },
+            React.createElement('span', { style: { flex: 'none', width: 110, fontSize: 13 } }, 标签),
+            节点,
+            React.createElement('span', { style: Object.assign({}, S.dim, { fontSize: 12, flex: 1, lineHeight: 1.5 }) }, 说明),
+          )
+
         return React.createElement(
           'div',
           { style: S.wrap },
           React.createElement('div', { style: S.link, onClick: () => setOpen(null) }, '← 所有会话'),
           React.createElement('div', { style: S.h }, s.title || s.id),
-          React.createElement('div', { style: S.dim }, s.id + '　' + s.memories.length + ' 条记忆' + (已删.length ? '　（另外还收着 ' + 已删.length + ' 条）' : '')),
+          React.createElement('div', { style: S.dim }, s.id + '　' + s.memories.length + ' 条记忆' + (已删.length ? '　（另外还收着 ' + 已删.length + ' 条）' : '') + (d.模式 === 'workspace' && s.工作区 ? '　·　按工作区共用一份（' + (s.工作区名 || s.工作区) + '）' : '')),
           React.createElement(
             'div',
             { style: { padding: '10px 12px', borderRadius: 8, border: '1px solid rgba(128,128,128,.22)', background: 'rgba(127,127,127,.05)' } },
-            React.createElement(
-              'div',
-              { style: { display: 'flex', alignItems: 'center', gap: 10, marginBottom: 8 } },
-              React.createElement('span', { style: { flex: 'none', width: 96, fontSize: 13 } }, '她自己叫什么'),
+            // ⭐ 2026-11-04：称呼和自称都并进这张卡（以前吊在外面的「哪些会话用记忆」下面，两边说法还不一样）
+            一格(
+              '它自己叫什么',
               React.createElement('input', {
                 style: Object.assign({}, S.inp, { width: 160 }),
-                placeholder: '她在这儿的名字',
+                placeholder: '它在这儿的名字',
                 value: selfDraft[open] !== undefined ? selfDraft[open] : s.selfName || s.titleName || '',
                 onChange: (e) => setSelfDraft(Object.assign({}, selfDraft, { [open]: e.target.value })),
               }),
-              s.selfName
-                ? null
-                : (s.titleName ? React.createElement('span', { style: Object.assign({}, S.dim, { fontSize: 12 }) }, '（先填的是会话标题，确认没问题再点「存」）') : null),
+              s.selfName ? '记忆里，它的名字会换成「我」' : s.titleName ? '先填的是会话标题，确认没问题再点「存」' : '填了才会自动换人称',
             ),
-            React.createElement(
-              'div',
-              { style: { display: 'flex', alignItems: 'center', gap: 10, marginBottom: 8 } },
-              React.createElement('span', { style: { flex: 'none', width: 96, fontSize: 13 } }, '她怎么称呼你'),
+            一格(
+              '它怎么称呼你',
               React.createElement('input', {
                 style: Object.assign({}, S.inp, { width: 160 }),
-                placeholder: '她平时怎么叫你（小名、昵称都行）',
+                placeholder: '它平时怎么叫你（小名、昵称都行）',
                 value: ownerDraft[open] !== undefined ? ownerDraft[open] : s.ownerName || '',
                 onChange: (e) => setOwnerDraft(Object.assign({}, ownerDraft, { [open]: e.target.value })),
               }),
+              '记忆里，这个叫法会换成「你」',
+            ),
+            一格(
+              '记忆里指对方用',
+              React.createElement('input', {
+                style: Object.assign({}, S.inp, { width: 90 }),
+                placeholder: 'ta',
+                value: 称草稿[open] !== undefined ? 称草稿[open] : s.pronoun || 'ta',
+                onChange: (e) => set称草稿(Object.assign({}, 称草稿, { [open]: e.target.value })),
+              }),
+              'ta / 她 / 他 —— 默认 ta，设成哪个就按哪个记',
+            ),
+            一格(
+              '它自称什么',
+              React.createElement('input', {
+                style: Object.assign({}, S.inp, { width: 90 }),
+                placeholder: '我',
+                value: 自草稿[open] !== undefined ? 自草稿[open] : s.selfPronoun || '我',
+                onChange: (e) => set自草稿(Object.assign({}, 自草稿, { [open]: e.target.value })),
+              }),
+              '它平时自称什么（本小姐、在下…），默认「我」',
             ),
             React.createElement(
               'div',
-              { style: { display: 'flex', alignItems: 'center', gap: 10 } },
+              { style: { display: 'flex', alignItems: 'center', gap: 10, marginTop: 4 } },
               React.createElement(
                 'button',
                 {
@@ -2399,9 +2539,19 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
                       session: open,
                       selfName: (selfDraft[open] !== undefined ? selfDraft[open] : s.selfName) || '',
                       ownerName: (ownerDraft[open] !== undefined ? ownerDraft[open] : s.ownerName) || '',
-                    }).then(() => {
+                      pronoun: (称草稿[open] !== undefined ? 称草稿[open] : s.pronoun) || 'ta',
+                      selfPronoun: (自草稿[open] !== undefined ? 自草稿[open] : s.selfPronoun) || '我',
+                    }).then((r) => {
                       setSelfDraft({})
                       setOwnerDraft({})
+                      set称草稿({})
+                      set自草稿({})
+                      // 影响到旧记忆就先问一句，不偷偷改 ✓
+                      if (r && r.称呼影响几条 > 0 && !r.称呼已改) {
+                        setPronounAsk({ n: r.称呼影响几条, to: r.称呼 || '', 例子: r.称呼例子 || [], session: open })
+                      } else {
+                        setPronounAsk(null)
+                      }
                       load()
                     }),
                 },
@@ -2410,10 +2560,38 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
               React.createElement(
                 'span',
                 { style: Object.assign({}, S.dim, { fontSize: 12, flex: 1, lineHeight: 1.5 }) },
-                '她自己的名字写进记忆时会换成「我」；她怎么称呼你，会换成「你」。已有的记忆也会顺手洗一遍。',
+                '只改这个会话，别的会话各算各的；已有的记忆也会顺手洗一遍。',
               ),
             ),
           ),
+          // ⭐ 改称呼影响到旧记忆时，就地在这个会话里问一句（不偷偷改）
+          pronounAsk && pronounAsk.session === open
+            ? React.createElement(
+                'div',
+                { style: Object.assign({}, S.askBox, { marginTop: 10 }) },
+                React.createElement(
+                  'div',
+                  { style: { flex: 1 } },
+                  React.createElement('div', null, '这个会话里有 ' + pronounAsk.n + ' 条旧记忆还写着旧的字。要一起改成「' + pronounAsk.to + '」吗？'),
+                  (pronounAsk.例子 || []).slice(0, 2).map((e, i) =>
+                    React.createElement('div', { key: i, style: Object.assign({}, S.dim, { fontSize: 12, marginTop: 2 }) }, '　「' + e.旧 + '」→「' + e.新 + '」'),
+                  ),
+                ),
+                React.createElement(
+                  'button',
+                  {
+                    style: S.btn,
+                    onClick: () =>
+                      post('/names', { session: open, pronoun: pronounAsk.to, applyToExisting: true }).then(() => {
+                        setPronounAsk(null)
+                        load()
+                      }),
+                  },
+                  '一起改',
+                ),
+                React.createElement('button', { style: S.btn, onClick: () => setPronounAsk(null) }, '以后再说'),
+              )
+            : null,
           // ---- 2026-09-21 新加：她自己后台手动加一条 ----
           // 跟模型自己记是两回事：它记受上面那个开关管，**手动加不受管** ✓
           // （开关管的是「他自己记不记、注不注入」，管不到她手动写）
@@ -2539,19 +2717,44 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
               '查重',
             ),
             // ⭐⭐ 2026-09-22（她的第十件）：**从会话生成档案**
-            //   「别的用户导入自己的会话 → 模型读一遍 → 出一份档案」
-            //   ⚠ 这是**给别人用的功能**，跟「手工维护一份档案」是两码事 ✓
+            //   ⚠ 2026-11-04 停用：这条流程一直有 bug，已经由独立插件「星汐」(dsh-xingxi) 接管。
+            //     点按钮**就在它下面**展开一小段提示 —— 不再写进 notes
+            //     （那玩意儿在列表底下，列表没展开根本看不见，橙色字也太淡）。
             React.createElement(
-              'button',
-              {
-                style: S.btn,
-                title:
-                  '把你自己的会话读一遍，提炼出一份长期档案（分九章）。' +
-                  '出好的档案再走「从旧档案导入」变成记忆条目。' +
-                  '会调用模型、会花钱，所以分四步：先看会话 → 算一下要多少 → 一批一批跑 → 存文件',
-                onClick: () => 开生成(),
-              },
-              '从会话生成档案',
+              'div',
+              { style: { display: 'flex', flexDirection: 'column', gap: 6, maxWidth: 320 } },
+              React.createElement(
+                'button',
+                {
+                  style: S.btn,
+                  title: '生成档案：点一下看怎么做',
+                  onClick: () => set星汐提示((v) => !v),
+                },
+                '从会话生成档案',
+              ),
+              星汐提示
+                ? React.createElement(
+                    'div',
+                    {
+                      style: {
+                        fontSize: 11.5,
+                        lineHeight: 1.7,
+                        color: 'rgba(196,210,236,0.92)',
+                        background: 'rgba(28,38,58,0.55)',
+                        border: '1px solid rgba(120,150,205,0.25)',
+                        borderRadius: 8,
+                        padding: '7px 9px',
+                      },
+                    },
+                    React.createElement('div', null, '改用独立插件「星汐」——它专门干这件事。'),
+                    React.createElement(
+                      'div',
+                      { style: { marginTop: 4, fontFamily: 'monospace', fontSize: 11, color: '#9fd8ff' } },
+                      'dsh plugin add dsh-xingxi',
+                    ),
+                    React.createElement('div', { style: { marginTop: 4, opacity: 0.75 } }, '装完侧栏会多一个「星汐」。'),
+                  )
+                : null,
             ),
             // ⭐⭐ 2026-09-22（她要的）：**批量删除** —— 勾了几条就显示几条
             //   ⚠ 二次确认：点这里**不删**，只出确认条；确认条上再点「确定删」才真删 ✓
@@ -3881,6 +4084,123 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
           })
       }
 
+      // ⭐ 2026-11-04：工作区模式下，称呼/自称按**工作区**改（同一个工作区共用一份记忆）
+      //   打开工作区模式就整块展开，不再折在「改」后面
+      const 工作区一格 = (标签, 节点, 说明) =>
+        React.createElement(
+          'div',
+          { style: { display: 'flex', alignItems: 'center', gap: 10, marginBottom: 8 } },
+          React.createElement('span', { style: { flex: 'none', width: 110, fontSize: 13 } }, 标签),
+          节点,
+          React.createElement('span', { style: Object.assign({}, S.dim, { fontSize: 12, flex: 1, lineHeight: 1.5 }) }, 说明),
+        )
+      const 工作区块 =
+        d.模式 === 'workspace' && (d.工作区们 || []).length
+          ? [
+              React.createElement('div', { key: 'wsh', style: S.h }, '按工作区改'),
+              React.createElement(
+                'div',
+                { key: 'wst', style: S.dim },
+                '工作区模式下，同一个工作区的会话共用一份记忆 —— 昵称、称呼、人称也跟着共用一份，在这里改一次就够。',
+              ),
+              ...(d.工作区们 || []).map((g) => {
+                const 取名 = () => (selfDraft[g.键] !== undefined ? selfDraft[g.键] : g.selfName || '')
+                const 取称呼 = () => (ownerDraft[g.键] !== undefined ? ownerDraft[g.键] : g.ownerName || '')
+                const 取人称 = () => (称草稿[g.键] !== undefined ? 称草稿[g.键] : g.pronoun || 'ta')
+                const 取自称 = () => (自草稿[g.键] !== undefined ? 自草稿[g.键] : g.selfPronoun || '我')
+                return React.createElement(
+                  'div',
+                  { key: 'ws-' + g.键, style: Object.assign({}, S.条, { display: 'block', padding: '8px 0' }) },
+                  React.createElement(
+                    'div',
+                    { style: { display: 'flex', alignItems: 'center', gap: 10, marginBottom: 8 } },
+                    React.createElement('span', { style: { fontSize: 13, fontWeight: 600 } }, g.名 || g.工作区),
+                    React.createElement('span', { style: S.dim, title: g.路径 || '' }, (g.会话 || []).length + ' 间会话 · ' + (g.条数 || 0) + ' 条记忆'),
+                  ),
+                  React.createElement(
+                        'div',
+                        { style: { padding: '10px 12px', borderRadius: 8, border: '1px solid rgba(128,128,128,.22)', background: 'rgba(127,127,127,.05)' } },
+                        工作区一格(
+                          '它自己叫什么',
+                          React.createElement('input', {
+                            style: Object.assign({}, S.inp, { width: 160 }),
+                            placeholder: '它在这儿的名字',
+                            value: 取名(),
+                            onChange: (e) => setSelfDraft(Object.assign({}, selfDraft, { [g.键]: e.target.value })),
+                          }),
+                          '记忆里，它的名字会换成「我」',
+                        ),
+                        工作区一格(
+                          '它怎么称呼你',
+                          React.createElement('input', {
+                            style: Object.assign({}, S.inp, { width: 160 }),
+                            placeholder: '它平时怎么叫你（小名、昵称都行）',
+                            value: 取称呼(),
+                            onChange: (e) => setOwnerDraft(Object.assign({}, ownerDraft, { [g.键]: e.target.value })),
+                          }),
+                          '记忆里，这个叫法会换成「你」',
+                        ),
+                        工作区一格(
+                          '记忆里指对方用',
+                          React.createElement('input', {
+                            style: Object.assign({}, S.inp, { width: 90 }),
+                            placeholder: 'ta',
+                            value: 取人称(),
+                            onChange: (e) => set称草稿(Object.assign({}, 称草稿, { [g.键]: e.target.value })),
+                          }),
+                          'ta / 她 / 他 —— 默认 ta',
+                        ),
+                        工作区一格(
+                          '它自称什么',
+                          React.createElement('input', {
+                            style: Object.assign({}, S.inp, { width: 90 }),
+                            placeholder: '我',
+                            value: 取自称(),
+                            onChange: (e) => set自草稿(Object.assign({}, 自草稿, { [g.键]: e.target.value })),
+                          }),
+                          '它平时自称什么（本小姐、在下…），默认「我」',
+                        ),
+                        React.createElement(
+                          'div',
+                          { style: { display: 'flex', alignItems: 'center', gap: 10, marginTop: 4 } },
+                          React.createElement(
+                            'button',
+                            {
+                              style: S.btn,
+                              onClick: () =>
+                                post('/names', {
+                                  session: g.键,
+                                  selfName: 取名(),
+                                  ownerName: 取称呼(),
+                                  pronoun: 取人称() || 'ta',
+                                  selfPronoun: 取自称() || '我',
+                                }).then((r) => {
+                                  setSelfDraft({})
+                                  setOwnerDraft({})
+                                  set称草稿({})
+                                  set自草稿({})
+                                  if (r && r.称呼影响几条 > 0 && !r.称呼已改) {
+                                    setPronounAsk({ n: r.称呼影响几条, to: r.称呼 || '', 例子: r.称呼例子 || [] })
+                                  } else {
+                                    setPronounAsk(null)
+                                  }
+                                  load()
+                                }),
+                            },
+                            '存',
+                          ),
+                          React.createElement(
+                            'span',
+                            { style: Object.assign({}, S.dim, { fontSize: 12, flex: 1, lineHeight: 1.5 }) },
+                            '这个工作区里所有会话一起生效；已有的记忆也会顺手洗一遍。',
+                          ),
+                        ),
+                      ),
+                )
+              }),
+            ]
+          : []
+
       const blocks = []
       for (const [gid, gname, gtip] of GROUPS) {
         const rows = spec.filter((s) => s.group === gid)
@@ -3918,36 +4238,11 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
           { style: S.dim },
           '装好就是开着的 —— 每个会话都能记、也能读。想给某个会话单独关掉，点它右边那个「关」。每个会话一份记忆，淡了只是不容易被想起来，不会删。',
         ),
-        React.createElement(
-          'div',
-          { style: S.nameBox },
-          React.createElement('div', { style: { flex: 'none', width: 132 } }, '用户的称呼'),
-          React.createElement('input', {
-            style: Object.assign({}, S.inp, { width: 90 }),
-            placeholder: 'ta / 她 / 他',
-            value: pronounDraft !== null ? pronounDraft : d.userPronoun || 'ta',
-            onChange: (e) => setPronounDraft(e.target.value),
-          }),
-          React.createElement(
-            'button',
-            {
-              style: S.btn,
-              onClick: () => {
-                const p = pronounDraft !== null ? pronounDraft : d.userPronoun || 'ta'
-                post('/names', { userPronoun: p }).then((r) => {
-                  setPronounDraft(null)
-                  // 影响到了旧记忆就先问一句，不偷偷改 ✓
-                  if (r && r.称呼影响几条 > 0 && !r.称呼已改) setPronounAsk({ n: r.称呼影响几条, to: p, 例子: r.称呼例子 || [] })
-                  else setPronounAsk(null)
-                  load()
-                })
-              },
-            },
-            '存',
-          ),
-          React.createElement('span', { style: Object.assign({}, S.dim, { fontSize: 12, flex: 1 }) }, '记忆里提到你时用哪个字。默认「ta」；设成「她」或「他」就按你设的记。'),
-        ),
-        pronounAsk
+        // ⭐ 工作区模式：按工作区改称呼（同一个工作区共用一份记忆）
+        ...工作区块,
+        // ⭐ 2026-11-04：这两格搬到「每个会话」那张卡里去了 ——
+        //   一般人都是一间会话一个对象，吊在外面既不好找，也跟会话卡里的说法对不上。
+        pronounAsk && !open
           ? React.createElement(
               'div',
               { style: S.askBox },
@@ -3964,7 +4259,7 @@ const 洗键进度 = { 已: 0, 总: 0, 在跑: false, 干跑: false }
                 {
                   style: S.btn,
                   onClick: () =>
-                    post('/names', { userPronoun: pronounAsk.to, applyToExisting: true }).then(() => {
+                    post('/names', { session: pronounAsk.session || '', pronoun: pronounAsk.to, applyToExisting: true }).then(() => {
                       setPronounAsk(null)
                       load()
                     }),

package/lib/index.js

@@ -78,9 +78,31 @@ export function 工作区目录名(p) {
   return '--' + 可读.slice(0, 251) + '--'
 }
 
-/** 工作区的可读路径：从会话目录名反查不回来，就直接给目录名 */
+/** 工作区的可读名：DSH 自己存着「工作区 id → path / title」，拿它换个看得懂的名字 */
+function 工作区信息(键) {
+  const k = String(键 || '')
+  if (!k) return { 名: '（未分组）', 路径: '' }
+  try {
+    const p = join(CFG_DIR, 'storages', 'workspace.json')
+    const d = JSON.parse(readFileSync(p, 'utf8'))
+    const 表 = (d && d.tables && d.tables.workspaces) || {}
+    const 本区会话 = 扫会话目录().byWorkspace.get(k) || []
+    for (const w of Object.values(表)) {
+      const ids = w && Array.isArray(w.sessionIds) ? w.sessionIds : []
+      if (!ids.length) continue
+      if (!本区会话.some((s) => ids.includes(s))) continue
+      const 路径 = String(w.path || '')
+      const 段 = 路径.split(/[\\/]/).filter(Boolean)
+      // 名字取最后两段（「上一级\当前目录」这种），只有一段就那一段；完整路径放在 title 里
+      const 名 = 段.length >= 2 ? 段.slice(-2).join('\\') : 段[0] || String(w.title || '')
+      if (名) return { 名, 路径 }
+    }
+  } catch (error) {}
+  return { 名: String(k).replace(/^--/, '').replace(/--$/, '') || '（未分组）', 路径: '' }
+}
+
 function 工作区可读名(键) {
-  return String(键 || '').replace(/^--/, '').replace(/--$/, '') || '（未分组）'
+  return 工作区信息(键).名
 }
 
 const DAY = 86400000
@@ -834,9 +856,12 @@ function migrateSwitch() {
 // 记的时候、注入的时候，都把「她自己的名字」换成「我」✓
 
 // 她自己叫什么（每个会话一个）。没设 = 不替换。
+// ⭐ 1.5.4：工作区模式下按工作区取（同一个工作区的会话共用一份），老数据仍按会话 id 存着，两种都认。
 function selfNameOf(sid) {
   const c = loadCfg()
-  const n = c.selfNames && c.selfNames[String(sid)]
+  const 表 = c.selfNames && typeof c.selfNames === 'object' ? c.selfNames : {}
+  const k = 人称键(sid)
+  const n = (k && 表[k]) || 表[String(sid)]
   return typeof n === 'string' ? n.trim() : ''
 }
 
@@ -855,7 +880,9 @@ function titleNameOf(ctx, sid) {
 //   没设就退回全局的 userPronoun（默认 ta）。
 function ownerNameOf(sid) {
   const c = loadCfg()
-  const n = c.ownerNames && c.ownerNames[String(sid)]
+  const 表 = c.ownerNames && typeof c.ownerNames === 'object' ? c.ownerNames : {}
+  const k = 人称键(sid)
+  const n = (k && 表[k]) || 表[String(sid)]
   return typeof n === 'string' ? n.trim() : ''
 }
 
@@ -866,6 +893,60 @@ function userPronoun() {
   return p || 'ta'
 }
 
+// ⭐ 它自己自称什么：默认「我」。
+//   跑角色设定比较重的模型时，它会用「本小姐」「在下」这类自称 ——
+//   记忆里跟着它自己的说法写，比一律写「我」更像它自己。
+function selfPronoun() {
+  const c = loadCfg()
+  const p = typeof c.selfPronoun === 'string' ? c.selfPronoun.trim() : ''
+  return p || '我'
+}
+
+// ⭐ 2026-11-04：这两样也能按会话设（工作区模式按工作区设）。
+//   一般人都是一间会话一个对象，所以默认就跟着会话走；没设过才落回全局那个值。
+function 人称键(sid) {
+  const s = String(sid || '')
+  if (!s) return ''
+  try {
+    return String(库名(s, { 模式: 读模式() }) || s)
+  } catch (error) {
+    return s
+  }
+}
+
+// 记忆里指对方用哪个字（ta / 她 / 他）
+function pronounOf(sid) {
+  const c = loadCfg()
+  const k = 人称键(sid)
+  const v = k && c.pronouns && typeof c.pronouns === 'object' ? c.pronouns[k] : ''
+  return (typeof v === 'string' && v.trim()) || userPronoun()
+}
+
+// 记忆里它自己自称什么（我 / 本小姐 / 在下……）
+function selfPronounOf(sid) {
+  const c = loadCfg()
+  const k = 人称键(sid)
+  const v = k && c.selfPronouns && typeof c.selfPronouns === 'object' ? c.selfPronouns[k] : ''
+  return (typeof v === 'string' && v.trim()) || selfPronoun()
+}
+
+// 提示词里凡是拿「我」写它自己的地方，换成它自己的自称（「我们」不算）
+function 换自称成(文, 自称) {
+  const s = String(自称 || '').trim()
+  if (!s || s === '我') return 文
+  return String(文 || '').replace(/我(?!们)/g, s)
+}
+function 换自称(文) {
+  return 换自称成(文, selfPronoun())
+}
+
+// 提示词里拿「她」写对方的地方，换成这个会话设的那个字（ta / 她 / 他）
+function 换称呼(文, 称呼) {
+  const s = String(称呼 || '').trim()
+  if (!s || s === '她') return 文
+  return String(文 || '').split('她').join(s)
+}
+
 // 这些词不能当名字换（不然代词会被换坏）
 const NOT_A_NAME = new Set(['她', '他', '我', '你', 'ta', 'TA', 'Ta', 'tA', '用户', '助手', 'AI', 'ai', '人', '自己'])
 
@@ -889,7 +970,7 @@ function normalizeOwner(text, sid) {
 }
 
 function normalizePerson(text, name) {
-  return normalizePersonAs(text, name, '我')
+  return normalizePersonAs(text, name, selfPronoun())
 }
 
 // 同一套「认边界」的替换：换成「我」（她自己）还是「你」（用户），由调用方定
@@ -920,14 +1001,23 @@ function normalizePersonAs(text, name, 换成) {
 
 // 用户的称呼改了，**已有记忆里那个字也要跟着变** ✓
 // ⚠ 两种不能动：「其他」「其它」里的「他」不是称呼；英文单词里的 ta 也别切 ✗
-const PRONOUN_FORMS = ['ta', 'Ta', 'TA', 'tA', '他', '她']
+// ⚠ 只换「旧称呼」本身（config 里那个值，默认 ta）。
+//   「他 / 她」**不是称呼**，是代词 —— 书名、小说人物、引用里的他/她都不能动。
+//   （2026-11-04 修：以前把它们也当称呼，改一次称呼就把《没有人给他写信的上校》改成
+//     《没有人给老猫写信的上校》，把小说人物也换成用户的名字，而且是直接写盘的。）
 const ASCII_LETTER = /[a-zA-Z]/
 
-function changeUserPronoun(text, to) {
+const __旧称呼表 = (旧称呼) => {
+  const 旧 = String(旧称呼 || 'ta')
+  return [...new Set([旧, 旧.toLowerCase(), 旧.toUpperCase()])]
+}
+
+function changeUserPronoun(text, to, 旧称呼 = 'ta') {
   let t = String(text || '')
   if (!to) return t
-  for (const from of PRONOUN_FORMS) {
-    if (from === to || !t.includes(from)) continue
+  for (const from of __旧称呼表(旧称呼)) {
+    if (!from || from === to || !t.includes(from)) continue
+    const 是英文 = /^[a-zA-Z]+$/.test(from)
     let out = ''
     let i = 0
     for (;;) {
@@ -938,9 +1028,8 @@ function changeUserPronoun(text, to) {
       }
       const 前 = j > 0 ? t[j - 1] : ''
       const 后 = t[j + from.length] || ''
-      let 别动 = false
-      if (from === '他' && 前 === '其') 别动 = true // 其他 / 其它
-      if (/^[a-zA-Z]+$/.test(from) && (ASCII_LETTER.test(前) || ASCII_LETTER.test(后))) 别动 = true // 别切英文单词
+      // 英文/拼音的 ta 别切单词内部；中文称呼直接换
+      const 别动 = 是英文 && (ASCII_LETTER.test(前) || ASCII_LETTER.test(后))
       out += t.slice(i, j) + (别动 ? from : to)
       i = j + from.length
     }
@@ -949,6 +1038,7 @@ function changeUserPronoun(text, to) {
   return t
 }
 
+
 // ---------- 旧档案导入 ----------
 // 设计参考 AAAAGENT 的「导入旧聊天」，几条原则照抄：
 //   ① 原日期保留（猜不到就不写，绝不编）② 助手的话只作语境、不当事实
@@ -1308,7 +1398,7 @@ function 换用户名字(text, 名字, to) {
 // 正文过一遍人称：她自己 →「我」，用户的名字 → 称呼（跟记的时候同一套规矩）
 function 导入时改人称(text, sid, 用户名字们) {
   let t = normalizePerson(text, selfNameOf(sid))
-  const p = userPronoun()
+  const p = pronounOf(sid)
   for (const n of 用户名字们) {
     if (!n || n.length < 2) continue
     t = 换用户名字(t, n, p)
@@ -1671,7 +1761,7 @@ async function 自动扩词(ctx, sid, 上限 = 2) {
     if (!agent) { diag('自动扩词：' + sid + ' 这会儿没有活着的 agent，跳过'); return 0 }
     const 输入 = 要扩.map((m, k) => k + 1 + '|' + String(m.text || '')).join('\n')
     const t0 = Date.now()
-    const r = await 问模型(ctx, agent, 扩词系统_v2, 输入, 6000)
+    const r = await 问模型(ctx, agent, 换自称成(换称呼(扩词系统_v2, pronounOf(sid)), selfPronounOf(sid)), 输入, 6000)
     if (!r || !r.ok) { diag('自动扩词：模型没回（' + ((r && r.message) || '?') + '）'); return 0 }
     const 表 = 解析扩词(r.text, 要扩.length)
     // ⚠⚠ 2026-10-24 修（用户报「记忆静默丢失」的**真凶**就在这几行）：
@@ -1803,12 +1893,16 @@ function 提炼系统(称呼) {
   // ⭐⭐ 2026-09-22（反馈）：这份清单**漏了「重要的日子」** ——
   //   实测 135 条该「永远不淡」的被标成会淡，重要的日子就在里面。
   //   原因就是这里没写「生日/纪念日/结婚」，模型不知道那也算「要一直记得的」✗
-  //   ⚠ 措辞尽量短（「提示词、关键词得写得好一点」，token 也是钱）
-  '  1 = 要一直记得的（性格、关系、约定和承诺、称呼和名字、喜好、身体和病史、' +
-  '**重要的日子：生日、纪念日、结婚、第一次**、长期的经济状况、家里的情况）\n' +
-  '  0.5 = 平常的（发生过的事、当时的想法、一时的心情）\n' +
+  // ⚠ 措辞尽量短（「提示词、关键词得写得好一点」，token 也是钱）
+  // ⭐ 2026-11-04 修（反馈）：这一格说的是「要不要每轮都带上」，不是「重不重要」。
+  //   以前写成「重要 = 1」，模型就把「爱读什么书」「玩什么游戏」也打 1，
+  //   常驻位只有 2~3 个，被日常喜好占满，真正该一直挂着的（忌讳、约定）反而进不来。
+  '  1 = **每轮都要挂在她眼前、不主动提就会出事**的（称呼和忌讳、明确的约定和承诺、' +
+  '身体禁忌与过敏、重要的日子：生日、纪念日、结婚、第一次）\n' +
+  '  0.5 = 其余全部（性格、喜好、书单、游戏、发生过的事、当时的想法）—— **这些不需要每轮在场**，' +
+  '聊到了自然会被搜回来\n' +
   '  拿不准就填 0.5。这一格**必须填**，不许留空、不许写别的数。\n' +
-  '  ⚠ 填 1 的会**永远不淡**（一直想得起来），填 0.5 的会**慢慢淡掉** —— 所以重要的日子别漏。\n' +
+  '  ⚠ 填 1 的会**每轮固定注入**（位置很少，只有两三个），填 0.5 的按需检索 —— 别把喜好占进去。\n' +
   // ⭐⭐ 2026-09-23（反馈第二点）：**事实键** —— 「同一个 key 只留最新一条」✓
   //   根子：句子像不像**本来就不该拿来判「是不是同一件事」**。
   //     「她身高一米七」和「她长胖到 55 公斤」几乎是两件事，词面上却很像；
@@ -2184,8 +2278,12 @@ export function 补线索(query, 上文们, 最短 = 6, 上限 = 240) {
 export function 选查询词(会话里那句, 监听那句) {
   const 会话 = String(会话里那句 == null ? '' : 会话里那句).trim()
   const 监听 = String(监听那句 == null ? '' : 监听那句).trim()
-  if (会话) return 会话
-  return 监听
+  // ⚠ 2026-11-04 修（反馈：检索永远慢一轮）：
+  //   systemPrompt.context 的 text() 是在**请求装配时**求值的，而这一轮的 user 消息
+  //   要等装配完才落进 session.snapshotEvents()。所以「会话里最后一句」拿到的是**上一轮**。
+  //   监听 agent/inbox/inserted 拿到的 lastText 才是这一轮真话，必须优先。
+  if (监听) return 监听
+  return 会话
 }
 
 /**
@@ -3552,7 +3650,9 @@ function makeRememberTool(ctx) {
       },
       importance: {
         type: 'number',
-        description: '0 = 随口提过；0.5 = 比较重要；1 = 非常重要（约定、关系、她的核心状态）。不确定就写 0.5。',
+        description:
+          '**要不要每轮都挂在她眼前**（不是「重不重要」）：1 = 不主动提就会出事的（称呼忌讳、约定承诺、' +
+          '身体禁忌、生日纪念日）；0.5 = 其余全部（性格、喜好、书单、游戏、发生过的事）。拿不准写 0.5。',
       },
       tags: {
         type: 'array',
@@ -3931,9 +4031,16 @@ function buildMemoryList(ctx) {
       out.sessions.push({
         id: sid,
         title: titleOfSession(ctx, sid),
+        // ⭐ 1.5.4：工作区模式下，设置页按「工作区」分组改 —— 这两个字段给它用
+        工作区: 会话的工作区(sid) || '',
+        工作区名: 会话的工作区(sid) ? 工作区可读名(会话的工作区(sid)) : '',
+        工作区路径: 会话的工作区(sid) ? 工作区信息(会话的工作区(sid)).路径 : '',
         // ⭐ 1.2.9：这个会话里「怎么称呼对方」+「她自己叫什么」，设置页两个输入框要回显
         ownerName: ownerNameOf(sid),
         selfName: selfNameOf(sid),
+        // ⭐ 1.5.5：这个会话（工作区模式按工作区）记忆里用哪个人称
+        pronoun: pronounOf(sid),
+        selfPronoun: selfPronounOf(sid),
         enabled: isEnabled(sid),
         live: liveIds.has(sid),
         parent: 分支来处Of(ctx, sid),
@@ -4018,6 +4125,30 @@ function buildMemoryList(ctx) {
   out.defaults = { ...DEFAULT_POLICY }
   out.version = VERSION
   out.userPronoun = userPronoun()
+  out.selfPronoun = selfPronoun()
+  // ⭐ 1.5.4：工作区模式下，设置页要按「工作区」单独改 —— 给它一份工作区清单
+  try {
+    if (out.模式 === 'workspace') {
+      const 组 = new Map()
+      for (const s of out.sessions) {
+        const k = s.工作区 || ''
+        if (!k) continue
+        if (!组.has(k)) 组.set(k, { 键: 'ws_' + k, 工作区: k, 名: s.工作区名 || k, 路径: s.工作区路径 || '', 会话: [], 条数: 0 })
+        const g = 组.get(k)
+        g.会话.push(s.id)
+        g.条数 = Math.max(g.条数, Number(s.count) || 0)
+      }
+      out.工作区们 = [...组.values()].map((g) => ({
+        ...g,
+        selfName: selfNameOf('ws_' + g.工作区),
+        ownerName: ownerNameOf('ws_' + g.工作区),
+        pronoun: pronounOf('ws_' + g.工作区),
+        selfPronoun: selfPronounOf('ws_' + g.工作区),
+      }))
+    }
+  } catch (error) {
+    diag('工作区清点失败：' + ((error && error.message) || error))
+  }
   return out
 }
 
@@ -4241,13 +4372,13 @@ export function apply(ctx) {
         //   （这里会把用户设的「称呼」拼进去，称呼里带 {{ }} 一样会炸）
         interpolate: false,
         text: () => {
-          const p = ownerNameOf(sid) || userPronoun()
+          const p = ownerNameOf(sid) || pronounOf(sid)
           const self = selfNameOf(sid)
           return (
             '【记忆】这一轮如果有值得长期记住的事（' + p + '重要的话、约定、' + p + '的喜好、' + p + '的状态），' +
             '直接调用 remember 工具记下来 —— **不用等' + p + '提醒**。' +
             '日常琐事（吃了什么、今天天气）不用记。' +
-            '**人称**：你自己是「我」，用户是「' + p + '」，别人和别的 AI 直接写名字' +
+            '**人称**：你自己是「' + selfPronounOf(sid) + '」，用户是「' + p + '」，别人和别的 AI 直接写名字' +
             (self ? '（你写成「' + self + '」也会自动换成「我」）' : '') +
             '；也不要写「今天/昨天」，时间交给系统。'
           )
@@ -4287,8 +4418,11 @@ export function apply(ctx) {
       text: () => {
         try {
           const now = Date.now()
-          // ⭐ 1.4.0：**这一轮真正的那句优先**（会话里最后一条 user 消息）；
-          //   监听那句只在会话读不出来时兜底 —— 见 选查询词() 上面的说明。
+          // ⚠ 2026-11-04 修：**监听那句（这一轮刚收到的）优先**。
+          //   原来的注释假设「会话里最后一条 user 消息就是这一轮」，在 DSH 这个时序下不成立：
+          //   systemPrompt.context 在请求装配时求值，而 user 消息要等装配完才落进 session，
+          //   于是永远拿到上一轮 —— 实测问「莱拉是谁」，拿去检索的是前几轮那句 49 字的闲聊。
+          //   会话那句只在监听为空时兜底（插件中途挂上、重启后第一轮还没收到消息）。
           let query = 清掉注入上下文(选查询词(lastUserTextOf(agent.session), lastText))
           // ⭐ 1.4.2：一两个字的句子（「推」「在吗」）单独去搜什么都搜不到 —— 借上文一起搜
           try {
@@ -5076,10 +5210,11 @@ export function apply(ctx) {
             '你是记忆整理助手。下面每条是一条记忆，格式是「编号|内容」。\n' +
             '请判断每条**该不该一直记得**（永远不淡），只回两档。\n' +
             '\n' +
-            '判据只有一条：**这条记的是「一直成立的」，还是「某天发生的」？**\n' +
-            '1 = **一直成立**：性格、关系、称呼和名字、喜好、身体和病史、\n' +
-            '    约定和承诺本身、长期的经济状况、家里的情况、长期的住处或工作。\n' +
-            '0.5 = **某天发生的**：带日期的流水账、当时的心情、一次性的经历、某次对话。\n' +
+            '判据只有一条：**不主动提，会不会出事？** 常驻位只有两三个。\n' +
+            '1 = **每轮都得在场**：称呼和忌讳（不能叫错、不能碰的）、明确的约定和承诺、\n' +
+            '    身体禁忌与过敏、一直成立的硬事实（名字、家里的结构）。\n' +
+            '0.5 = **其余全部**：性格、喜好、书单、游戏、长期的住处或工作、某天发生的任何事。\n' +
+            '    （这些聊到了自然会被搜回来，不需要每轮挂着。）\n' +
             '\n' +
             '⚠⚠ **以日期开头的（09-17 / 8月26日 / 2026-09-04…），默认一律 0.5。**\n' +
             '  哪怕那件事很重要、很感人、是第一次、是求婚、是婚礼 —— 都算「某天发生的」。\n' +
@@ -5203,7 +5338,7 @@ export function apply(ctx) {
       const c = loadCfg()
       const 改了几条 = []
       const 换了称呼的 = []
-      const 称呼旧值 = userPronoun()
+      const 称呼旧值 = b.session ? pronounOf(String(b.session)) : userPronoun()
       let 称呼新值 = null
       if (typeof b.userPronoun === 'string') {
         const p = b.userPronoun.trim()
@@ -5218,6 +5353,34 @@ export function apply(ctx) {
         else delete c.archiveDir
         diag('档案目录设成：' + (c.archiveDir || '（还没选）'))
       }
+      // ⭐ 它自己自称什么（默认「我」）。
+      //   跟会话一起传过来 = 这个会话（工作区模式是这个工作区）的；不带会话 = 全局默认。
+      if (typeof b.selfPronoun === 'string') {
+        const p = b.selfPronoun.trim()
+        const k0 = b.session ? 人称键(String(b.session)) : ''
+        if (k0) {
+          if (!c.selfPronouns || typeof c.selfPronouns !== 'object') c.selfPronouns = {}
+          if (p && p !== '我') c.selfPronouns[k0] = p
+          else delete c.selfPronouns[k0]
+          diag('这个会话的它自称：' + k0 + ' → 「' + (p || '（默认 我）') + '」')
+        } else if (p && p !== '我') {
+          c.selfPronoun = p
+          diag('它的自称设成：' + c.selfPronoun)
+        } else {
+          delete c.selfPronoun
+          diag('它的自称设成：' + '（默认 我）')
+        }
+      }
+      // ⭐ 记忆里指对方用哪个字，也能按会话设
+      if (b.session && typeof b.pronoun === 'string') {
+        const k0 = 人称键(String(b.session))
+        if (!c.pronouns || typeof c.pronouns !== 'object') c.pronouns = {}
+        const p = b.pronoun.trim()
+        if (p && p !== 'ta') c.pronouns[k0] = p
+        else delete c.pronouns[k0]
+        称呼新值 = p || 'ta'
+        diag('这个会话记忆里指对方用：' + k0 + ' → 「' + (p || '（默认 ta）') + '」')
+      }
       if (Array.isArray(b.notNames)) {
         c.notNames = b.notNames
           .filter((x) => typeof x === 'string' && x.trim())
@@ -5283,17 +5446,31 @@ export function apply(ctx) {
       let 称呼影响几条 = 0
       let 称呼例子 = []
       const 要改 = b.applyToExisting === true
-      const 目标称呼 = 要改 ? userPronoun() : 称呼新值 !== null && 称呼新值 !== 称呼旧值 ? 称呼新值 : null
+      const 会话号 = String(b.session || '')
+      const 目标称呼 = 要改
+        ? 会话号
+          ? pronounOf(会话号)
+          : userPronoun()
+        : 称呼新值 !== null && 称呼新值 !== 称呼旧值
+          ? 称呼新值
+          : null
       if (目标称呼 !== null) {
         try {
-          for (const fn of readdirSync(STORE_DIR)) {
-            if (!fn.endsWith('.json')) continue
-            const sid = fn.replace(/\.json$/, '')
+          // ⭐ 1.5.5：改成**只洗这个会话（工作区模式是这个工作区）的库**。
+          //   以前扫全部库 —— A 会话改个叫法，B 会话的记忆也被一起洗了。
+          const 只洗 = 会话号 ? String(库名(会话号, { 模式: 读模式() }) || 会话号) : ''
+          const 名单 = 只洗
+            ? [只洗]
+            : readdirSync(STORE_DIR)
+                .filter((fn) => fn.endsWith('.json'))
+                .map((fn) => fn.replace(/\.json$/, ''))
+          for (const sid of 名单) {
+            const fn = sid + '.json'
             const data = loadStore(sid)
             let 动 = false
             for (const 区 of ['memories', 'deleted']) {
               for (const m of data[区] || []) {
-                const 新 = changeUserPronoun(m.text, 目标称呼)
+                const 新 = changeUserPronoun(m.text, 目标称呼, 称呼旧值 || 'ta')
                 if (新 !== m.text) {
                   称呼影响几条++
                   if (称呼例子.length < 3) 称呼例子.push({ id: m.id, 旧: m.text, 新: 新 })
@@ -5304,7 +5481,17 @@ export function apply(ctx) {
                 }
               }
             }
-            if (要改 && 动) saveStore(sid, data)
+            if (要改 && 动) {
+              // ⚠ 改称呼是**永久写盘**，先留一份快照，出问题能一键回退
+              try {
+                const 原文件 = join(STORE_DIR, sid + '.json')
+                if (existsSync(原文件)) {
+                  const 时 = new Date().toISOString().replace(/[:.]/g, '-')
+                  copyFileSync(原文件, 原文件 + '.bak-person-' + 时)
+                }
+              } catch {}
+              saveStore(sid, data)
+            }
           }
         } catch (error) {}
         if (要改) diag('称呼改成「' + 目标称呼 + '」，顺手改了 ' + 称呼影响几条 + ' 条记忆')
@@ -5320,6 +5507,7 @@ export function apply(ctx) {
           userNames: 用户名字列表(),
           llmModel: 选定模型(),
           洗了: 改了几条.length,
+          称呼: b.session ? pronounOf(String(b.session)) : userPronoun(),
           称呼影响几条,
           称呼例子,
           称呼已改: b.applyToExisting === true && 称呼影响几条 > 0,
@@ -5714,9 +5902,17 @@ export function apply(ctx) {
               m.importance = imp
               m.category = imp >= 1 ? 'stable_profile' : 'event'
             }
+            // ⭐ 检索词能当场改：模型给的词经常不靠谱，人直接改比重新扩一遍快，也不动正文
+            if (Array.isArray(b.related)) {
+              const 词 = b.related.map((x) => String(x || '').trim()).filter(Boolean).slice(0, 12)
+              m.related = 词
+              m.relatedAt = new Date().toISOString()
+              m.relatedBy = '手动'
+              diag('改检索词：' + sid + ' / ' + id + ' → ' + 词.join(' '))
+            }
             saveStore(sid, data)
             diag('改了一条：' + sid + ' / ' + id + '  「' + 旧.slice(0, 30) + '」→「' + m.text.slice(0, 30) + '」')
-            out = { ok: true, message: '改好了', text: m.text, importance: m.importance, category: m.category }
+            out = { ok: true, message: '改好了', text: m.text, importance: m.importance, category: m.category, related: Array.isArray(m.related) ? m.related : null }
           }
         } catch (error) {
           out = { ok: false, message: String((error && error.message) || error) }
@@ -6368,7 +6564,7 @@ export function apply(ctx) {
           const t0 = Date.now()
           // ⚠ 预算要给够：模型会先「思考」，思考的 token 也算在里面。
           //   给 2400 的时候实测被思考吃光、正文长度 0、整批被误判成「跳过」✗
-          const r = await 问模型(ctx, agent, 提炼系统(userPronoun()), 输入, 6000)
+          const r = await 问模型(ctx, agent, 换自称成(提炼系统(pronounOf(sid)), selfPronounOf(sid)), 输入, 6000)
           const ms = Date.now() - t0
           if (!r.ok) {
             out = { ok: false, message: r.message, 剩: 要提.length, provider: r.provider, model: r.model, ms: ms }
@@ -6555,7 +6751,7 @@ mroute('/dsh-fish-memory/wash-keys', async (req, res) => {
         已有键.length = Math.min(已有键.length, 400)
       }
       const t0 = Date.now()
-      const r = await 问模型(ctx, agent, 洗键系统(userPronoun(), 已有键), 输入, 6000)
+      const r = await 问模型(ctx, agent, 换自称成(洗键系统(pronounOf(sid), 已有键), selfPronounOf(sid)), 输入, 6000)
       const ms = Date.now() - t0
       if (!r.ok) {
         out = { ok: false, message: r.message, 剩: 要洗.length, provider: r.provider, model: r.model, ms: ms }
@@ -6880,7 +7076,7 @@ mroute('/dsh-fish-memory/wash-keys/undo', async (req, res) => {
           //   实测 6 条的时候：**正文 167 字，思考 2912 字**（思考是答案的 17 倍）——
           //   原来只给 900，连思考都不够，正文永远是空的，
           //   表现就是「连着几批没回可用的词，自己停了」✗（2026-09-20 踩到）
-          const r = await 问模型(ctx, agent, 扩词系统_v2, 输入, 6000)
+          const r = await 问模型(ctx, agent, 换自称成(换称呼(扩词系统_v2, pronounOf(sid)), selfPronounOf(sid)), 输入, 6000)
           const ms = Date.now() - t0
           if (!r.ok) {
             out = { ok: false, message: r.message, 剩: 要扩.length, provider: r.provider, model: r.model, ms: ms }
@@ -7041,4 +7237,12 @@ export const __测试 = {
   库名,
   读模式,
   合并工作区记忆,
+  // ⭐ 1.5.4：「它自称什么」是纯字符串替换，单独露出来好单测
+  换自称成,
+  换称呼,
+  // ⭐ 1.5.4：人称现在跟着会话走，这两条是「会话 → 库」的取值口
+  人称键,
+  pronounOf,
+  selfPronounOf,
+  自称: () => selfPronoun(),
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fish-memory",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "给 DSH 里的会话一份会淡忘的长期记忆，每条都带时间。",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -57,4 +57,4 @@
       "optional": true
     }
   }
-}
+}