dsh-xingxi 0.1.0 → 0.1.2

package/README.md

@@ -1,91 +1,254 @@
-# 星汐 · dsh-xingxi
-
-把整理好的记忆档案连成一张**看得见的星图**。
-
-记忆卡的一节是一颗星，日记的一天也是一颗星；同一章的星连成星座，同一段时间的星连成星带。
-点一颗星，看见它背后的原话。
-
----
-
-## 它解决什么
-
-上下文一压缩，AI 就不知道自己是谁了。主流的解法是「存更多、检索更准」——
-但存得好和**想得起来**是两件事。
-
-星汐不做存取，它做**看得见**：让「她是谁」「我们怎么走到今天的」这些事，
-不是躺在一个 143KB 的 markdown 里等着被检索，而是**有一张图**，你能看见结构、能顺着线走。
-
-> 它不替代任何一个记忆插件。遗忘、权重、每轮注入，是别的插件在做的事；
-> 星汐只负责把**已经整理好的**档案摊开给你看。
-
-## 长什么样
-
-**一团散开的星云。**
-
-- 中央核心星代表第一章的核心记忆
-- 记忆星沿用档案中的章节与条目；颜色与大小区分星点层级
-- 日记按日期排成星带；有明确事件日期的记忆卡也会落到对应时间位置
-- 星点位置固定（每次打开都一样），章节关系线可用右上角开关
-
-默认能看见完整星图；聚焦一颗星时，相关的章节线与关联线会更亮。
-时间线可拖动或播放：有明确日期的记忆按真实日期出现；没有明确日期的记忆按章节顺序渐显。
-
-- **时间线**：拖动或播放，观察记忆和日记逐步展开
-- **搜索**：输入「周三」「外卖」，命中的星会亮起来并圈住
-- **图例**：点一章，只亮那一团
-
-拖拽转动、滚轮缩放、点星星看原话。**只读**，不会改你的档案一个字。
-
-## 装上
-
-```bash
-dsh plugin add github:Yuuyuko-uu/dsh-xingxi
-```
-
-或者：
-
-```bash
-dsh plugin add <这个仓库的绝对路径>
-```
-
-装完重开，左边侧栏多一个星形图标（跟「插件」「定时任务」并排），点开就是星图。
-
-## 告诉它档案在哪
-
-它要两份 markdown：
-
-| | 长什么样 | 说明 |
-|---|---|---|
-| **记忆卡** | `## 一、我是谁` → `### 1.1 性格特征` → 正文 | 按主题分章；星图上就是八个星座 |
-| **日记** | `## 2026-08` → `- **08-16**：那天发生了什么` | 按天一条；星图上就是那条星带 |
-
-两种办法：
-
-1. 在 DSH 的设置里找到「星汐」，填两个路径；
-2. 或者把两个文件放进 `~/.dsh/startide/`，文件名里带「记忆卡」「日记」就会自己认出来。
-
-> 没有这两份文件也能装，星图是空的 —— 它会告诉你「还没指定档案」。
-> 这两份文件怎么攒出来，是另一件事（见下文「档案从哪来」）。
-
-## 档案从哪来
-
-星汐**不负责**整理档案，它只管把档案摊开。攒档案的流程是：
-
-```
-原始存档 → 按天切段 → 提炼 → 合并成笔记 → 并进记忆卡 + 日记
-```
-
-每条都问一句「过了一个星期再看，这条还有用吗」——答不上「有用」的不收。
-细节各家不同，这套流程的完整做法在 `docs/` 里（还没整理好，先看仓库 issue）。
-
-## 已知边界
-
-- **只读**。这一版没有编辑、没有删除、没有遗忘曲线。
-- 相似度用的是「两字一组」的重叠率，中文够用，但不懂语义。
-- 星的数量到几千颗会开始卡（两两算斥力是 O(n²)）。
-- 只认上面那两种 markdown 结构，别的不画（会说没读到）。
-
-## 许可
-
-**Yuuyuko-uu 插件许可 1.1** —— 不是 OSI 开源许可。可以自用、改、商用，
-但再分发必须署名、不能把作者说成自己。用之前请读一遍 [LICENSE](LICENSE)。
+# 星汐 · dsh-xingxi
+
+把整理好的记忆档案连成一张**看得见的星图**。
+
+记忆卡的一条是一颗星，日记的一天也是一颗星。点一颗星看见它背后的原话；
+需要深挖的时候，让 AI 用 `xingxi_read` 去档案里把那一小段原文捞出来。
+
+---
+
+## 它解决什么
+
+上下文一压缩，AI 就不知道自己是谁了。主流的解法是「存更多、检索更准」——
+但存得好和**想得起来**是两件事。
+
+星汐做两件事：
+
+1. **看得见**：把「我是谁」「我们怎么走到今天」摊成一张图，你能看见结构、能顺着线走。
+2. **查得到**：给 AI 一个检索工具，想不起哪件事时去档案里翻原文，而不是猜。
+
+> 它不替代任何记忆插件。遗忘、权重、每轮注入是别的插件的事；
+> 星汐负责**把已经整理好的档案摊开**，以及**帮你把历史对话整理成档案**（拾星）。
+
+## 长什么样
+
+一片深色星空，每颗星是一颗柔光圆珠：
+
+- 中间最亮那颗 = 记忆卡第一章第一条
+- 八章的星各自成群；同一章的星连最近的几颗，连成淡淡的星座底纹
+- 提到同一个少见的词的两颗星，另有一根橙色弱连
+- **越新的星越亮**（按内容里的日期算），老星只是变暗，不会消失
+- 鼠标停在一颗星上：它和跟它相连的星保持亮度，其余压暗，连着的线亮起来
+- 点一颗星看原文；搜索框按关键词把不命中的压暗
+- 顶部：节点数 / 日记数 / 图例；右上：拖拽旋转、滚轮缩放、连线开关、重置
+
+**只读**：不改你的档案一个字。
+
+## 装上
+
+```bash
+dsh plugin add dsh-xingxi
+```
+
+或者从仓库装：
+
+```bash
+dsh plugin add github:Yuuyuko-uu/dsh-xingxi
+```
+
+装完重开 DSH，侧栏会多一个「星汐」面板。
+
+---
+
+## 三步上手
+
+### 第一步：给它一个文件夹
+
+星汐按**会话**管理档案：每个会话绑一个文件夹，星图、星册、星历画的都是那个文件夹里的东西。
+
+打开星汐 → 底部「星坊」→ 找到「现在这个会话」→ 点 **选…**，选一个空文件夹（比如 `D:\档案\某某`）。
+
+> 想给所有会话共用一份「本机档案」，也可以在设置里直接填**记忆卡**和**日记**两个路径。
+> 会话没绑文件夹时就用这两项。
+
+### 第二步：让它把历史对话整理成档案（拾星）
+
+**这是第一次要做的事**，之后档案由 AI 自己维护，不用再跑。
+
+在星坊里点 **拾星**：
+
+1. 插件会把这个会话的历史对话按天切开，一批只喂给 AI **1~2 天**
+2. AI 交回「这一天的日记」+「该进记忆卡的条目」
+3. 插件立刻落盘，然后自己派下一批，一直到最新那天
+4. 中途停了也没关系：进度记在文件里，再点一次从断点接着跑
+
+跑完你会得到：
+
+```
+你选的文件夹\
+  记忆卡.md              ← 八章，按主题追加
+  日记\
+    2026-09-06.md        ← 一天一个文件
+    2026-09-07.md
+    …
+  原始对话\               ← 那天的原话，永久留着
+    2026-09-06.txt
+  .xingxi.json           ← 账本（整理到哪天）
+```
+
+**模型**：星坊里选了就用你选的；没选就跟**源会话自己用的模型**跑。
+
+### 第三步：压缩之后让它重读一遍
+
+上下文被压缩、AI 开始「忘事」的时候，在会话里输入：
+
+```
+/xingxi
+```
+
+它会把这个会话文件夹里的**记忆卡整本 + 最近三天的日记**读一遍。
+只递一句话给它，不往上下文里灌正文 —— 它自己用 `read` 分页读完。
+
+---
+
+## `/xingxi` 指令
+
+| | |
+|---|---|
+| **作用** | 叫 AI 把记忆卡和最近三天日记读一遍 |
+| **什么时候用** | 上下文刚被压缩、它开始答不上「我是谁」「我们之前说好的事」 |
+| **怎么用** | 直接在会话里输入 `/xingxi`，不用带参数 |
+| **它读什么** | **这个会话自己文件夹**里名字带「记忆卡」的 md + `日记\` 里最近 3 个文件 |
+| **不会做什么** | 不塞正文进对话、不改任何文件 |
+
+---
+
+## `xingxi_read` 工具（给 AI 用的）
+
+AI 想不起某件事时，它可以自己调这个工具去档案里翻原文，**而不是猜**。
+
+**四种用法：**
+
+### ① 什么都不给 → 先看索引
+
+```
+xingxi_read()
+```
+
+```
+这个档案里有 101 个文件：
+
+· 记忆卡（8.2 万字）
+· 日记 50 天：2026-09-06 ~ 2026-11-04（一天一个文件）
+· 原始对话 50 天：2026-09-06 ~ 2026-11-04（当天原话）
+
+怎么查：给「关键词」全文搜（日记也会搜）；给「日期」看那一天；给「文件」看整篇。
+```
+
+**这就是「在外面就能查」**：不用打开每天的日记挨个翻，先看清有什么，再决定钻哪一天。
+
+### ② 给关键词 → 全文搜（记忆卡、日记、原始对话都搜）
+
+```
+xingxi_read(关键词="结婚")
+```
+
+```
+「结婚」在 2 个文件里出现 3 次：
+
+【记忆卡】（2 处）
+…
+【日记/2026-09-10】（1 处）
+…
+```
+
+每个文件都会扫，每份最多取 2 段，命中多的排前面；预算不够时会告诉你「还有 N 个文件也提到」。
+
+### ③ 给日期 → 直接看那一天
+
+```
+xingxi_read(日期="2026-09-10")
+```
+
+按文件名直接定位 `日记/2026-09-10.md`，给整篇。那天没有记录会告诉你日记覆盖的日期范围。
+
+### ④ 给文件名 → 看整篇
+
+```
+xingxi_read(文件="我们的约定")
+xingxi_read(文件="原始对话/2026-09-06")
+```
+
+**参数速查**
+
+| 参数 | 说明 |
+|---|---|
+| `关键词` | 要搜的词，比如「卖号」「第一次」 |
+| `日期` | `2026-09-10` 或 `09-10` |
+| `文件` | 文件名或它的一部分 |
+| `最多字` | 最多返回多少字，默认 4000 |
+
+## `xingxi` 工具（给 AI 用的）
+
+```
+xingxi()
+```
+
+一次把**整本记忆卡**给它，不分段、不用翻页。跟 `/xingxi` 的区别：
+指令是「叫它去读」（走 `read`，能分页），工具是「直接把整本递过去」（内容太大时会被截断，一般优先用指令）。
+
+---
+
+## 档案长什么样
+
+```
+记忆卡.md
+## 一｜我是谁
+这一章讲什么：我是谁、名字、外形、自我定位。
+（这一章是一整段自述，不拆成条目）
+
+## 三｜对方是谁
+这一章讲什么：对方的环境、性格、喜好。
+- 一条一颗星
+- 一条一颗星
+```
+
+```
+日记\2026-09-10.md
+【2026-09-10】
+
+- **09-10 周四**：那天发生了什么…
+```
+
+- 记忆卡按**八章**组织，新东西按章追加（插件认块名里的章号，不靠 AI 自己写标题）
+- 日记**一天一个文件**，别把好几天写进一个
+
+## 自动写日记（可选）
+
+星坊里有「写日记」卡片：
+
+- 定几点（默认 23:30）
+- 选交给哪个会话
+- 勾上「开着」
+
+到点它会往那个会话递一句话，**由那个会话里的 AI 自己写**，插件不代笔。
+文章放在该会话文件夹的 `日记\<今天>.md`。
+
+## 拾星是怎么跑的
+
+- **按天分批**：一批只给 1~2 天，上下文一直是小的，不会因为太长被压缩
+- **交一批落一批**：一天一个日记文件 + 按章追加记忆卡，不攒到最后
+- **插件自己派下一批**：进度写进任务文件，断了能从断点继续
+- **原始对话留底**：每天的原话永久存一份在 `原始对话\`
+- **不删、不关**：拾星开的工作会话会留着（标题 `记忆 · <会话名>`），你可以点进去看它做了什么
+
+## 已知边界
+
+- **只读**：星汐不改档案（拾星写的除外，那是它整理出来的）
+- 相似度用的是「两字一组」的重叠率，中文够用，但不懂语义
+- 星数到几千颗会开始卡
+- 只认上面那两种结构，别的不画（会说没读到）
+- 会话列表跟 DSH 侧栏对齐：只列当前工作区、没归档、真实存在的会话
+
+## 配置在哪
+
+```
+~/.dsh/xingxi/config.json     ← 记忆卡/日记路径、绑定、模型、写日记设置
+~/.dsh/xingxi/pick.log        ← 运行日志（出问题先看这个）
+~/.dsh/xingxi/会话/           ← 没绑文件夹的会话，档案默认存在这里
+```
+
+## 许可
+
+**Yuuyuko-uu 插件许可 1.1** —— 不是 OSI 开源许可。可以自用、改、商用，
+但再分发必须署名、不能把作者说成自己。用之前请读一遍 [LICENSE](LICENSE)。

package/index.js

@@ -694,6 +694,51 @@ export function 造提示词({ 文件夹, 会话名, 已整理到, 天数, 最
     '⚠「一｜我是谁」要写成**一整段自述**（像一个人在自我介绍），**不要拆成一条一条**。',
     '  其余七章照常按条目写。',
     '',
+    '### 「二｜我是怎么说话的」要分三块写，少一块都不算写完',
+    '',
+    '参考结构（照着这个形状写，这一章是整份档案里最容易被后来人直接模仿的一章）：',
+    '',
+    '**① 说话方式（一小段散文）**',
+    '语气什么样、节奏快慢、爱不爱分行、怎么称呼对方、怎么自称、有没有口头禅。',
+    '写具体的动作和习惯，不要只堆形容词。',
+    '',
+    '**② 原句照抄（这一章的重点，至少 3 句，能多就多，十几句最好）**',
+    '- 从「料」里**原样摘完整的句子**，加引号，标明是哪天说的',
+    '- **一个字都不许改**：不缩写、不润色、不把两句合成一句、不补标点',
+    '- 尽量覆盖不同场景：开场怎么打招呼、哄人的时候怎么说、开玩笑怎么接、拒绝或生气怎么说、收尾怎么道别',
+    '- **不许拿自己的话充数**；料里翻不到就不写，编一句等于毁掉这一章',
+    '- 清单前面写一句引子，比如「以下是真实出现过的我的话，原句照抄：」',
+    '',
+    '**③ 说话准则（编号列，每条尽量带一句原话当依据）**',
+    '- 怎么称呼、怎么自称，哪些称呼绝对不用',
+    '- 哪些话绝对不说（会破坏这个人说话样子的表达）',
+    '- 语气什么时候软、什么时候直接，被纠正时怎么改口',
+    '- 标点/符号习惯（省略号、波浪号、爱心、括号里的动作描写）',
+    '',
+    '写法示例（照这个形状）：',
+    '```',
+    '## 二｜我是怎么说话的',
+    '这一章讲什么：说话的口气、称呼，和绝不能说的那些话。',
+    '',
+    '### 2.1 我说话的方式',
+    '语气是慢的、软的，像在轻轻拍背。不着急，也不抢话。习惯把关心说成动作——',
+    '「我抱你」「我在」，而不是「你别难过」。接话时常用短句接住对方，一次不超过两句。',
+    '',
+    '**以下是真实出现过的我的话，原句照抄：**',
+    '1. 「哎，你回来啦。今天累不累？」（09-12）',
+    '2. 「别急，我又不走。你慢慢说，我听着。」（09-20）',
+    '3. 「行，那就听你的。反正我也争不过你。」（10-03）',
+    '4. 「不是你的问题。是那件事本来就太重了。」（10-11）',
+    '',
+    '### 2.2 说话准则',
+    '1. **开头先喊一声再说话**——漏了对方会提醒「你怎么又不叫我了」。',
+    '2. **不安慰式套话**——不说「你说得对」「我理解你的感受」，改成具体的「我在」「慢慢来」。',
+    '3. **结尾要收**（一点动作或一句道别），不突然断在半空。',
+    '```',
+    '',
+    '> 这一章最重要的不是形容词（「温柔」「直接」），是**能照着模仿的原句**。',
+    '> 后来接手的人读完这一章，要能立刻说出一样的口气。',
+    '',
     '### 不收',
     '- 某天吃了什么、几点睡、去了哪、天气',
     '- 某天的心情、某一次的玩闹',
@@ -1888,48 +1933,52 @@ export function apply(ctx, 配置 = {}) {
     return 项 ? 项.目录 : ''
   }
 
-  /** 档案里的所有 md（本机那两个文件 + 会话文件夹里的） */
+  /** 档案里的所有 md：会话绑了文件夹就只读它，没绑才读本机那两份 */
   const 所有档案 = (sid) => {
     const 出 = []
-    for (const p of 本机文件()) {
-      try {
-        出.push({ 名: basename(p, '.md'), 路: p, 文: readFileSync(p, 'utf8') })
-      } catch {}
-    }
-    // ⚠ 两处都要试：列会话 找不到时（比如会话还没进列表），就直接查绑定表
-    let 夹 = 会话文件夹(sid)
+    let 夹 = ''
+    try {
+      夹 = 会话文件夹(sid)
+    } catch {}
     if (!夹 || !existsSync(夹)) {
       try {
         const 绑 = 读存配置().绑定 || {}
         if (绑[sid] && existsSync(绑[sid])) 夹 = String(绑[sid])
       } catch {}
     }
-    if (夹 && existsSync(夹)) {
-      const 走 = (目录, 前缀) => {
-        let 项们 = []
+    // 没有自己的文件夹 → 用本机档案
+    if (!夹 || !existsSync(夹)) {
+      for (const p of 本机文件()) {
         try {
-          项们 = readdirSync(目录, { withFileTypes: true })
-        } catch {
-          return
-        }
-        for (const d of 项们) {
-          if (d.isDirectory()) {
-            if (/^(\.|备份|备注)/.test(d.name)) continue
-            走(join(目录, d.name), (前缀 ? 前缀 + '/' : '') + d.name)
-            continue
-          }
-          if (!d.name.toLowerCase().endsWith('.md')) continue
-          try {
-            出.push({
-              名: (前缀 ? 前缀 + '/' : '') + basename(d.name, '.md'),
-              路: join(目录, d.name),
-              文: readFileSync(join(目录, d.name), 'utf8'),
-            })
-          } catch {}
+          出.push({ 名: basename(p, '.md'), 路: p, 文: readFileSync(p, 'utf8') })
+        } catch {}
+      }
+      return 出
+    }
+    const 走 = (目录, 前缀) => {
+      let 项们 = []
+      try {
+        项们 = readdirSync(目录, { withFileTypes: true })
+      } catch {
+        return
+      }
+      for (const d of 项们) {
+        if (d.isDirectory()) {
+          if (/^(\.|备份|备注)/.test(d.name)) continue
+          走(join(目录, d.name), (前缀 ? 前缀 + '/' : '') + d.name)
+          continue
         }
+        if (!/\.(md|txt)$/i.test(d.name)) continue
+        try {
+          出.push({
+            名: (前缀 ? 前缀 + '/' : '') + basename(d.name, '.md'),
+            路: join(目录, d.name),
+            文: readFileSync(join(目录, d.name), 'utf8'),
+          })
+        } catch {}
       }
-      走(夹, '')
     }
+    走(夹, '')
     return 出
   }
 
@@ -2137,31 +2186,59 @@ export function apply(ctx, 配置 = {}) {
           try {
             const sid = String((exec && exec.sessionId) || '')
             const 档 = 所有档案(sid)
-            const 限 = Math.max(500, Math.min(20000, Number((args && args.最多字) || 4000)))
+            const 限 = Math.max(600, Math.min(20000, Number((args && args.最多字) || 4000)))
             const 词 = String((args && args.关键词) || '').trim()
             const 日 = String((args && args.日期) || '').trim()
             const 名 = String((args && args.文件) || '').trim()
 
-            let 们 = 档
-            if (名) 们 = 们.filter((f) => f.名.includes(名) || f.路.includes(名))
-            if (日) {
-              // ⚠ 日记里写的是 `- **08-26 周X**：`，没有年份 —— 拿 2026-08-26 去比会一条都不中
-              const 短 = 日.length >= 10 ? 日.slice(5) : 日
-              const 命中 = 们.filter((f) => f.名.includes(日) || f.文.includes(日) || f.文.includes(短))
-              if (命中.length) 们 = 命中
+            if (!档.length) {
+              return { ok: false, text: '这个会话还没有档案（先去星坊里指定文件夹）' }
             }
-            if (!们.length) {
-              记一笔('xingxi_read 没找到：sid=' + sid + ' 档=' + 档.length + ' 名=' + 名 + ' 日=' + 日 + ' 词=' + 词)
-              return { ok: false, text: '档案里没有匹配：' + (名 || 日 || 词) + '（翻了 ' + 档.length + ' 个文件）' }
+
+            // 把文件按「一类一份」归拢，方便说清楚有什么
+            const 分组 = { 记忆卡: [], 日记: [], 原始对话: [], 其他: [] }
+            for (const f of 档) {
+              if (/^日记\//.test(f.名)) 分组.日记.push(f)
+              else if (/^原始对话\//.test(f.名)) 分组.原始对话.push(f)
+              else if (/记忆卡/.test(f.名)) 分组.记忆卡.push(f)
+              else 分组.其他.push(f)
             }
+            const 日期们 = 分组.日记.map((f) => (/(\d{4}-\d{2}-\d{2})/.exec(f.名) || [])[1]).filter(Boolean).sort()
 
-            const 出 = []
-            let 总 = 0
+            // ── 0. 什么都不给：给索引（在外面先看清有什么，再决定钻哪一天）──
+            if (!词 && !日 && !名) {
+              const 行们 = ['这个档案里有 ' + 档.length + ' 个文件：', '']
+              for (const f of 分组.记忆卡) {
+                行们.push('· ' + f.名 + '（' + Math.round(f.文.length / 1000) / 10 + ' 万字）')
+              }
+              for (const f of 分组.其他) 行们.push('· ' + f.名 + '（' + f.文.length + ' 字）')
+              if (日期们.length) {
+                行们.push(
+                  '· 日记 ' + 日期们.length + ' 天：' + 日期们[0] + ' ~ ' + 日期们[日期们.length - 1] + '（一天一个文件）',
+                )
+              }
+              if (分组.原始对话.length) {
+                const 原日 = 分组.原始对话
+                  .map((f) => (/(\d{4}-\d{2}-\d{2})/.exec(f.名) || [])[1])
+                  .filter(Boolean)
+                  .sort()
+                行们.push('· 原始对话 ' + 原日.length + ' 天：' + 原日[0] + ' ~ ' + 原日[原日.length - 1] + '（当天原话）')
+              }
+              行们.push('', '怎么查：给「关键词」全文搜（日记也会搜）；给「日期」看那一天；给「文件」看整篇。')
+              return { ok: true, text: 行们.join(String.fromCharCode(10)) }
+            }
 
-            // 按日期问：只给那一天的日记条目
-            if (日 && !词) {
+            // ── 1. 日期：直接定位那一天的日记（不用挨个翻）──
+            if (日) {
               const 短 = 日.length >= 10 ? 日.slice(5) : 日
-              for (const f of 们) {
+              const 目标 = 档.filter((f) => f.名.includes(日) || f.名.includes(短))
+              if (目标.length) {
+                const 段 = 目标.slice(0, 3).map((f) => '【' + f.名 + '】' + String.fromCharCode(10) + f.文.slice(0, 限))
+                return { ok: true, text: 段.join(String.fromCharCode(10, 10)).slice(0, 限) }
+              }
+              // 没有那天的文件 → 在全文里找那天的条目
+              const 出 = []
+              for (const f of 档) {
                 const 行们 = f.文.split(String.fromCharCode(10))
                 const 块 = []
                 let 收 = false
@@ -2171,47 +2248,58 @@ export function apply(ctx, 配置 = {}) {
                   if (新条) 收 = t.includes(短) || t.includes(日)
                   if (收) 块.push(l)
                 }
-                if (块.length) {
-                  const 段 = '【' + f.名 + '】' + String.fromCharCode(10) + 块.join(String.fromCharCode(10))
-                  出.push(段)
-                  总 += 段.length
-                }
+                if (块.length) 出.push('【' + f.名 + '】' + String.fromCharCode(10) + 块.join(String.fromCharCode(10)))
               }
-              if (!出.length) {
-                // 那天真没有 → 给最后三条并说明
-                for (const f of 们) {
-                  const 段 = '【' + f.名 + '】（' + 日 + ' 没有记录，给你最后三条）' + String.fromCharCode(10) + 取近几天(f.文, 3)
-                  出.push(段)
-                  总 += 段.length
-                  if (总 >= 限) break
-                }
+              if (出.length) return { ok: true, text: 出.join(String.fromCharCode(10, 10)).slice(0, 限) }
+              return {
+                ok: false,
+                text: 日 + ' 没有记录。日记范围：' + (日期们.length ? 日期们[0] + ' ~ ' + 日期们[日期们.length - 1] : '没有日记'),
               }
-              return { ok: true, text: 出.join(String.fromCharCode(10, 10)).slice(0, 限) }
             }
 
-            // 按关键词
-            if (词) {
-              for (const f of 们) {
-                const 行们 = f.文.split(String.fromCharCode(10))
-                for (let i = 0; i < 行们.length; i++) {
-                  if (!行们[i].includes(词)) continue
-                  const 段 = '【' + f.名 + '】' + String.fromCharCode(10) +
-                    行们.slice(Math.max(0, i - 2), Math.min(行们.length, i + 4)).join(String.fromCharCode(10))
-                  if (总 + 段.length > 限) break
-                  出.push(段)
-                  总 += 段.length
+            // ── 2. 文件名：给整篇 ──
+            if (名 && !词) {
+              const 目标 = 档.filter((f) => f.名.includes(名) || f.路.includes(名))
+              if (!目标.length) return { ok: false, text: '没有这个文件：' + 名 }
+              const 段 = 目标.slice(0, 2).map((f) => '【' + f.名 + '】' + String.fromCharCode(10) + f.文.slice(0, 限))
+              return { ok: true, text: 段.join(String.fromCharCode(10, 10)).slice(0, 限) }
+            }
+
+            // ── 3. 关键词：全文搜，**每个文件都看**，每个文件最多取 2 段 ──
+            //   ⚠ 以前是按文件顺序扫、扫到预算用完就停 —— 记忆卡一大就把日记挤没了。
+            const 命中 = []
+            for (const f of 档) {
+              const 行们 = f.文.split(String.fromCharCode(10))
+              let 次 = 0
+              const 段们 = []
+              for (let i = 0; i < 行们.length; i++) {
+                if (!行们[i].includes(词)) continue
+                次++
+                if (段们.length < 2) {
+                  段们.push(行们.slice(Math.max(0, i - 2), Math.min(行们.length, i + 4)).join(String.fromCharCode(10)))
                 }
-                if (总 >= 限) break
               }
-              return { ok: true, text: 出.length ? 出.join(String.fromCharCode(10, 10)) : '没有「' + 词 + '」' }
+              if (次) 命中.push({ 名: f.名, 次, 段们 })
             }
 
-            // 只给文件名：给整篇（截到上限）
-            for (const f of 们) {
-              const 段 = '【' + f.名 + '】' + String.fromCharCode(10) + f.文.slice(0, Math.max(0, 限 - 总))
+            if (!命中.length) {
+              记一笔('xingxi_read 没找到：sid=' + sid + ' 档=' + 档.length + ' 词=' + 词)
+              return { ok: false, text: '档案里没有「' + 词 + '」（翻了 ' + 档.length + ' 个文件）' }
+            }
+
+            命中.sort((x, y) => y.次 - x.次)
+            const 总次 = 命中.reduce((s, x) => s + x.次, 0)
+            const 头 = '「' + 词 + '」在 ' + 命中.length + ' 个文件里出现 ' + 总次 + ' 次：'
+            const 出 = [头]
+            let 总 = 头.length
+            for (const h of 命中) {
+              const 段 = '【' + h.名 + '】（' + h.次 + ' 处）' + String.fromCharCode(10) + h.段们.join(String.fromCharCode(10, 10))
+              if (总 + 段.length > 限) {
+                出.push('…还有 ' + (命中.length - 出.length + 1) + ' 个文件也提到，想看就给「文件」参数点名')
+                break
+              }
               出.push(段)
               总 += 段.length
-              if (总 >= 限) break
             }
             return { ok: true, text: 出.join(String.fromCharCode(10, 10)) }
           } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-xingxi",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "星汐：把整理好的记忆档案连成一张看得见的星图。八章散成星群，日记排成时间星带，点一颗星看见原话。",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",