dsh-bookmemory 0.0.0-stage → 0.1.0

package/INSTALL.md

@@ -0,0 +1,85 @@
+# 安装说明
+
+## 你需要什么
+
+| 条件 | 说明 |
+|---|---|
+| **DSH** | 0.2.x（设置契约在这一版是「插件声明 `Config`」） |
+| **Node.js** | ≥ 18（DSH 自己就要求，通常已有） |
+| 网络 | 装 `@node-rs/jieba` 要能访问 npm |
+
+## 三条路
+
+### 路 A：脚本（Windows，推荐）
+
+```powershell
+powershell -ExecutionPolicy Bypass -File tools\install.ps1
+powershell -ExecutionPolicy Bypass -File tools\install.ps1 -ProfileName desktop   # 桌面版
+```
+
+它做三件事，**不碰 package.json、不跑 pnpm**：
+
+1. 在 `<profile>\node_modules\dsh-bookmemory` 建目录链接
+2. 在 `<profile>\cordis.patch.yml` 追加一条 insert 行
+3. 检查 `@deepseek-ai/schemastery`（设置卡片需要，低于 3.18.4 会警告）
+
+改之前自动备份 patch 文件到 `~/.dsh/.dsh-rollback-dsh-bookmemory-<时间戳>\`。
+
+### 路 B：官方命令
+
+```sh
+dsh plugin --profile web add <插件目录>
+```
+
+装完重启一次 DSH。
+
+### 路 C：手动
+
+```powershell
+# 1) 装依赖（注意要用 cmd，PowerShell 的执行策略会挡住 npm.ps1）
+cmd /c "npm install --omit=dev"
+
+# 2) 建链接
+New-Item -ItemType Junction -Path "$env:USERPROFILE\.dsh\profiles\desktop\node_modules\dsh-bookmemory" `
+  -Target "<插件目录>"
+
+# 3) 在 cordis.patch.yml 末尾追加
+# - insert:
+#     - id: bookmemory
+#       name: dsh-bookmemory
+```
+
+## 坑（都会真实遇到）
+
+### 1. npm 被 PowerShell 执行策略挡住
+
+```
+npm.ps1 ... 因为在此系统上禁止运行脚本
+```
+
+必须走 `cmd /c "npm install ..."`。
+
+### 2. 宿主包版本必须对齐
+
+插件的 `devDependencies` 里 `@deepseek-ai/dsh-tools` 的版本要和 DSH 内置的一致，
+否则会报：
+
+```
+failed to import: SyntaxError: The requested module '@deepseek-ai/dsh-llm'
+does not provide an export named 'CallId'
+```
+
+**怎么查宿主版本**：从 `app.asar` 里读
+`node_modules/@deepseek-ai/dsh-tools/package.json` 的 `version`。
+本机实测宿主是 `0.2.1-rc.2`，而 npm 的 `latest` 却是 `0.0.1-rc.1` —— 差一个大版本。
+
+### 3. 插件只在 patch 文件变化时重载
+
+改 `entry.js` 不会热重载，要重启 DSH，或者 touch 一下 `cordis.patch.yml`。
+
+## 卸掉
+
+```powershell
+Remove-Item "$env:USERPROFILE\.dsh\profiles\desktop\node_modules\dsh-bookmemory" -Force
+# 再把备份里的 cordis.patch.yml 拷回去
+```

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 s1770
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MANUAL.md

@@ -0,0 +1,60 @@
+# 使用说明
+
+## 它做了什么
+
+三类东西，都在 `~/.dsh-bookmemory/` 里：**书**（对话原文）、**目录**（关键词索引）、**锚点**（提炼过的记忆）。
+
+每次模型请求前，插件拿你这句话去查目录，把命中的旧对话和锚点拼成一段上下文塞进系统提示词。
+对话结束后（下一次请求时）自动补记一本。
+
+## 数据文件
+
+| 文件 | 是什么 | 能不能手动改 |
+|---|---|---|
+| `书.jsonl` | 每次对话一行，永不覆盖 | 能，删一行就忘一件事 |
+| `目录.json` | 关键词 → 书号 | 别改，重建成本低但容易写坏 |
+| `锚点.jsonl` | 「值得记」的事 | 能，这是最该手写的地方 |
+| `策略.json` | 压缩规则 | 能，改完下次压缩生效 |
+
+整个目录拷走就是备份；删掉目录就是失忆。
+
+## 两个工具
+
+模型会自己判断什么时候调用：
+
+- **`bookmemory_recall`** — 你说「之前」「上次」的时候，它会去查
+- **`bookmemory_remember`** — 有值得留的事，它会记一条锚点
+
+## 设置页
+
+| 项 | 默认 | 说明 |
+|---|---|---|
+| `dataDir` | `~/.dsh-bookmemory` | 数据目录 |
+| `oldFraction` | 0.2 | 时间轴前 20% 算「久远」 |
+| `clusterMinShared` | 2 | 共享 2 个关键词才算内容相近 |
+| `digestMaxChars` | 220 | 一本浓缩书的字数上限 |
+| `compactEveryMinutes` | 30 | 自动压缩间隔，0 = 只手动 |
+| `injectEnabled` | true | 每次请求前自动检索 |
+| `injectMaxChars` | 1500 | 注入上限，防止撑爆提示词 |
+
+## 压缩是怎么工作的
+
+```
+久远 = 从最早一本书到现在的时间跨度 × oldFraction
+```
+
+时间轴越长，久远区越大：10 天取前两天，30 天取前 6 天。
+
+久远区里内容相近的书（共享 ≥2 个关键词）合成一本浓缩书；
+**原书不删**，标记 `archived` 留在文件里当证据，但退出检索。
+
+## 常见问题
+
+**记不住东西？**
+看 `书.jsonl` 有没有增长。没增长说明插件没加载 —— 查 DSH 日志里有没有 `[bookmemory] 已加载`。
+
+**记了一堆废话？**
+调小 `injectMaxChars` 没用，那是注入预算。真正的杠杆是锚点判据 —— 现在只要出现「决定/以后/记住/名字/定稿」这类词才落锚，觉得太松就自己清 `锚点.jsonl`。
+
+**搜不到？**
+先确认那句话里的词确实在两本书里出现过。分词对专有名词友好（牵丝戏、纳西妲），对人名和生僻词一般。

package/README.en.md

@@ -0,0 +1,74 @@
+# dsh-bookmemory
+
+Long-term memory for DSH: **every conversation becomes a book, keywords become the catalog,
+and older books are automatically condensed into one.**
+
+## What problem it solves
+
+A model has no memory. Start a new session and everything before it is gone.
+
+This plugin builds a library on disk:
+
+```
+书.jsonl      every exchange, one line each, never overwritten
+目录.json     keyword -> book id (inverted index)
+锚点.jsonl    distilled "worth remembering" facts
+策略.json     compaction rules, editable
+```
+
+Before each model request the plugin searches the catalog with the user's latest message
+and injects the matching old conversations and anchors into the system prompt.
+After the exchange it writes a new book — automatically, not because the model asked.
+
+## Why it is worth it
+
+- **No retraining** — memory is retrieved, not baked into weights
+- **Readable and editable** — plain text; delete a line and that memory is gone
+- **Self-shortening** — distant books are condensed by topic; originals are archived, not deleted,
+  so an old library never slows retrieval down
+
+## Install
+
+```bash
+# If PowerShell's execution policy blocks npm.ps1, go through cmd:
+cmd /c "npm install -g dsh-bookmemory"
+
+# or add it to a profile
+dsh plugin --profile web add dsh-bookmemory
+```
+
+Windows alternative (creates a directory junction + one patch row, backs up the patch first):
+
+```powershell
+powershell -ExecutionPolicy Bypass -File tools\install.ps1
+powershell -ExecutionPolicy Bypass -File tools\install.ps1 -ProfileName desktop
+```
+
+## Settings
+
+| Key | Default | Meaning |
+|---|---|---|
+| `dataDir` | `~/.dsh-bookmemory` | where the library lives |
+| `oldFraction` | `0.2` | the first 20% of the time span counts as "distant" |
+| `clusterMinShared` | `2` | books sharing 2+ keywords are considered related |
+| `digestMaxChars` | `220` | length cap for one condensed book |
+| `compactEveryMinutes` | `30` | auto-compaction interval, 0 disables |
+| `injectEnabled` | `true` | search and inject before each request |
+| `injectMaxChars` | `1500` | injection budget |
+
+## Two tools
+
+- `bookmemory_recall` — search old conversations and anchors
+- `bookmemory_remember` — write one anchor worth keeping
+
+## Chinese tokenization
+
+Uses `@node-rs/jieba` (prebuilt binary — no compiler, no Python, works on `npm install`).
+
+> Node's built-in `Intl.Segmenter` was tried first and rejected: it splits Chinese into
+> **single characters** (`牵丝戏` → `牵/丝/戏`). In a 12-sentence test, 50 keywords collapsed
+> to 3 and all 10 proper nouns were lost.
+
+## License
+
+MIT

package/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# dsh-bookmemory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+给 DSH 的长期记忆：**把每一次对话存成一本书，用关键词做目录；久远的书自动浓缩成一本。**
+
+## 它解决什么
+
+模型没有记忆。每开一个新会话，之前发生的一切都归零。
+
+这个插件在磁盘上建一个图书馆：
+
+```
+书.jsonl      每次对话的原文，一条一行，永不覆盖
+目录.json     关键词 -> 书号（倒排索引）
+锚点.jsonl    提炼过的「值得记」的事，少而重
+策略.json     压缩规则，可改
+```
+
+每次对话前拿用户那句话去查目录，命中的旧对话和锚点一起塞进上下文；
+对话结束后自动入库，抽关键词，必要时落一个锚点。
+
+## 为什么值得
+
+- **不用模型重训**：记忆是检索出来的，不是塞进权重的
+- **可读可改**：全是纯文本，用记事本打开就能看，删一个文件就忘记一件事
+- **会自己变短**：久远的书按主题浓缩成一本，原书归档不删——时间轴越长也不会拖慢检索
+
+## 安装
+
+```bash
+# npm 被 PowerShell 执行策略挡着的时候，走 cmd
+cmd /c "npm install dsh-bookmemory"
+```
+
+装完在 DSH 设置页里能看到 `bookmemory` 的卡片，改数据目录、久远比例这些。
+
+## 配置项
+
+| 项 | 默认 | 说明 |
+|---|---|---|
+| `dataDir` | `~/.dsh-bookmemory` | 数据目录，整个拷走就是备份 |
+| `oldFraction` | `0.2` | 时间轴前 20% 算「久远」 |
+| `clusterMinShared` | `2` | 共享 2 个关键词才算内容相近 |
+| `digestMaxChars` | `220` | 一本浓缩书的字数上限 |
+| `compactEveryMinutes` | `30` | 自动压缩的检查间隔，0 = 只手动 |
+| `injectEnabled` | `true` | 每次对话前自动检索 |
+| `injectMaxChars` | `1500` | 注入的上限，防止撑爆提示词 |
+
+## 中文分词
+
+用 `@node-rs/jieba`（预编译二进制，装完即用，不需要编译环境和 Python）。
+
+> 试过 Node 内置的 `Intl.Segmenter`：它把中文按**单字**切（牵/丝/戏），
+> 12 个测试句子里 50 个关键词只剩 3 个，10 个专有名词全丢。不可用。
+
+## 许可
+
+MIT

package/entry.js

@@ -0,0 +1,327 @@
+// dsh-bookmemory — Host half.
+//
+// 把每一次对话存成一本「书」，用关键词做倒排目录；久远的书按主题浓缩成一本，
+// 原书归档不删。每次模型请求前，拿用户这句话去查目录，把命中的旧对话和锚点
+// 拼成一段上下文注入系统提示词。
+//
+// 三个扩展点（都从 DSH 内部包的源码里确认过）：
+//   ctx.systemPrompt.variable(name, provider)  provider 每次组装都被调用，参数是 { agent, scope, signal }
+//   ctx.systemPrompt.section({ name, order, text })   静态小节，可用 {{变量}}
+//   ctx.tools.register(defineTool({ ... }))           模型可调用的工具
+//
+// 写回不靠事件：每次注入时扫一遍会话历史，把「上一条没记过的问答」补记进去。
+// 这样不依赖任何事件 API 的时序，最坏情况也只是晚一轮入库。
+
+import z from '@deepseek-ai/schemastery'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { Store } from './lib/store.js'
+
+const DEFAULT_DIR = join(homedir(), '.dsh-bookmemory')
+
+// 只有标了 .volatile() 的字段才会出现在设置页
+const LIVE_CAPABLE = typeof z.boolean().volatile === 'function'
+const live = (schema) => (LIVE_CAPABLE ? schema.volatile() : schema)
+
+export const Config = z.object({
+  enabled: live(z.boolean().default(true)),
+  dataDir: live(z.string().default(DEFAULT_DIR)),
+  oldFraction: live(z.number().min(0.05).max(0.5).default(0.2)),
+  clusterMinShared: live(z.number().min(1).max(10).default(2)),
+  digestMaxChars: live(z.number().min(60).max(800).default(220)),
+  compactEveryMinutes: live(z.number().min(0).max(1440).default(30)),
+  injectEnabled: live(z.boolean().default(true)),
+  injectMaxChars: live(z.number().min(200).max(8000).default(1500)),
+})
+
+export const name = 'bookmemory'
+export const inject = ['systemPrompt', 'tools']
+
+// ───────────────────────── 读配置 ─────────────────────────
+//
+// `.volatile()` 不产出值，产出的是一个稳定引用：只有标了 volatile 的字段才会
+// 出现在设置页上，而设置页改完之后要能立刻生效——引用不变、值在变。
+// 所以必须用 get() 读，直接 `config.dataDir` 拿到的是引用对象不是字符串。
+// （载入时没走 schema 解析的配置是普通值，两种形状都要认。）
+
+const VOLATILE_REF = Symbol.for('cosmokit.volatile.write')
+
+function isLive(value) {
+  return typeof value === 'object' && value !== null && VOLATILE_REF in value
+}
+
+function readField(config, key, fallback) {
+  const raw = config?.[key]
+  const value = isLive(raw) && typeof raw.get === 'function' ? raw.get() : raw
+  return value === undefined || value === null ? fallback : value
+}
+
+// ───────────────────────── 会话历史里取文字 ─────────────────────────
+
+// harness 会把运行时上下文（时间戳、工具说明、系统提醒）当成 user 消息注入，
+// 这些不是他说的话，不能记进图书馆，也不能拿去检索。
+const INJECTED_PREFIX = [
+  'Time sampled while preparing',
+  'Current runtime context',
+  'Tokens prefixed with @',
+  'The runtime context names',
+  '<system-reminder>',
+  '### Updated Tool Schemas',
+  '[SCHEDULE REMINDER]',
+]
+
+function looksInjected(text) {
+  const head = String(text || '').trimStart().slice(0, 60)
+  return INJECTED_PREFIX.some((p) => head.startsWith(p) || head.includes(p))
+}
+
+/** 从消息对象里抽纯文本。消息的 content 是分段数组，只取 text 段。 */
+function messageText(msg) {
+  if (!msg) return ''
+  if (typeof msg.text === 'string') return msg.text.trim()
+  const parts = Array.isArray(msg.content) ? msg.content : []
+  return parts
+    .filter((p) => p && typeof p.text === 'string')
+    .map((p) => p.text)
+    .join('\n')
+    .trim()
+}
+
+/** 会话里最近的「用户 + 助手」一对，没有助手回复就返回 null。 */
+function lastPair(agent) {
+  let messages = []
+  try {
+    messages = agent?.session?.deriveMessages?.() ?? []
+  } catch {
+    return null
+  }
+  for (let i = messages.length - 1; i > 0; i--) {
+    const m = messages[i]
+    if (m?.role !== 'assistant') continue
+    const reply = messageText(m)
+    if (!reply || looksInjected(reply)) continue
+    for (let j = i - 1; j >= 0; j--) {
+      if (messages[j]?.role !== 'user') continue
+      const user = messageText(messages[j])
+      if (user && !looksInjected(user)) return { user, reply }
+      break
+    }
+  }
+  return null
+}
+
+/** 会话里最后一句真正的用户消息（用于检索）。 */
+function lastUserText(agent) {
+  let messages = []
+  try {
+    messages = agent?.session?.deriveMessages?.() ?? []
+  } catch {
+    return ''
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role !== 'user') continue
+    const t = messageText(messages[i])
+    if (t && !looksInjected(t)) return t
+  }
+  return ''
+}
+
+export function apply(ctx, config) {
+  if (readField(config, 'enabled', true) === false) return
+
+  const store = new Store(readField(config, 'dataDir', DEFAULT_DIR))
+
+  // 策略随时可能被设置页改，所以每次压缩前重新读一遍
+  const readPolicy = () => ({
+    oldFraction: readField(config, 'oldFraction', 0.2),
+    clusterMinShared: readField(config, 'clusterMinShared', 2),
+    digestMaxChars: readField(config, 'digestMaxChars', 220),
+  })
+
+  // 已入库的「会话 -> 已记到的问答」标记，防止重复入库
+  const recorded = new WeakMap()
+
+  /** 把上一条没记过的问答补进图书馆。 */
+  const flushPending = async (agent) => {
+    const session = agent?.session
+    if (!session) return
+    const pair = lastPair(agent)
+    if (!pair) return
+    const stamp = pair.user.slice(0, 80) + '|' + pair.reply.slice(0, 80)
+    if (recorded.get(session) === stamp) return
+    recorded.set(session, stamp)
+    await store.addBook({ text: pair.user, reply: pair.reply })
+  }
+
+  // ── 1) 注入：每次组系统提示词时，拿最后一句用户消息去查 ──
+  ctx.systemPrompt.variable('bookmemory', async (assemblyCtx) => {
+    if (readField(config, 'injectEnabled', true) === false) return ''
+    const agent = assemblyCtx?.agent
+    const query = lastUserText(agent)
+    if (!query) return ''
+
+    // 顺便把上一轮补记（不阻塞：失败了下次再记）
+    flushPending(agent).catch(() => {})
+
+    const [hits, anchors] = await Promise.all([
+      store.search(query, 5).catch(() => []),
+      store.relatedAnchors(query, 3).catch(() => []),
+    ])
+    if (!hits.length && !anchors.length) return ''
+
+    const lines = ['【记忆·图书馆】']
+    if (anchors.length) {
+      lines.push('相关锚点：')
+      for (const a of anchors) lines.push(`- ${a.date} ${a.title}：${a.what}`)
+    }
+    if (hits.length) {
+      lines.push('相关的旧对话：')
+      for (const h of hits) {
+        const who = h.book.role === '我' ? '我说' : '他说'
+        const snippet = String(h.book.text || '').replace(/\s+/g, ' ').slice(0, 60)
+        lines.push(`- ${h.book.date} ${who}：${snippet}`)
+      }
+    }
+    lines.push('（这些是检索出来的旧记录，不是他刚说的话。）')
+
+    const text = lines.join('\n')
+    const maxChars = readField(config, 'injectMaxChars', 1500)
+    return text.length > maxChars ? text.slice(0, maxChars) + '…' : text
+  })
+
+  ctx.systemPrompt.section({
+    name: 'bookmemory',
+    order: 900,
+    text: '{{bookmemory}}',
+  })
+
+  // ── 2) 工具：模型可以主动查和记 ──
+  ctx.tools.register(
+    defineTool({
+      name: 'bookmemory_recall',
+      description:
+        '在长期记忆里检索旧对话和锚点。当用户提到"之前""上次""以前说过"这类指代，' +
+        '或者需要确认历史事实时调用。返回命中的记录摘要。',
+      parameters: {
+        query: { type: 'string', required: true, description: '要检索的内容，用用户的原话或关键词' },
+        limit: { type: 'number', description: '返回几条，默认 5' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            found: { type: 'number', required: true },
+            entries: {
+              type: 'array',
+              required: true,
+              items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                  date: { type: 'string', required: true },
+                  text: { type: 'string', required: true },
+                  reply: { type: 'string', required: true },
+                },
+              },
+            },
+            anchors: {
+              type: 'array',
+              required: true,
+              items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                  date: { type: 'string', required: true },
+                  title: { type: 'string', required: true },
+                  what: { type: 'string', required: true },
+                },
+              },
+            },
+          },
+        },
+        // 界面上怎么显示这次调用的结果（必填，缺了会在渲染阶段报 userRender is not a function）
+        render: (_args, value) => [
+          {
+            type: 'text',
+            text:
+              `图书馆检索：命中 ${value.found} 条` +
+              (value.entries.length ? `，其中旧对话 ${value.entries.length} 条` : '') +
+              (value.anchors.length ? `，锚点 ${value.anchors.length} 条` : ''),
+          },
+        ],
+      },
+      async execute(args) {
+        const limit = Math.min(Number(args.limit) || 5, 20)
+        const [hits, anchors] = await Promise.all([
+          store.search(args.query, limit),
+          store.relatedAnchors(args.query, 5),
+        ])
+        return {
+          found: hits.length + anchors.length,
+          entries: hits.map((h) => ({
+            date: h.book.date,
+            text: String(h.book.text || '').slice(0, 300),
+            reply: String(h.book.reply || '').slice(0, 300),
+          })),
+          anchors: anchors.map((a) => ({
+            date: a.date,
+            title: a.title,
+            what: String(a.what || '').slice(0, 300),
+          })),
+        }
+      },
+    }),
+  )
+
+  ctx.tools.register(
+    defineTool({
+      name: 'bookmemory_remember',
+      description:
+        '把一个值得长期记住的事实、决定或约定写进图书馆。只记确实需要以后查的东西，' +
+        '不要用它记日常寒暄。',
+      parameters: {
+        text: { type: 'string', required: true, description: '要记住的内容，一句话说清' },
+        why: { type: 'string', description: '为什么值得记' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            id: { type: 'string', required: true },
+          },
+        },
+        render: (args, value) => [
+          { type: 'text', text: `已记进图书馆（${value.id}）：${String(args.text || '').slice(0, 60)}` },
+        ],
+      },
+      async execute(args) {
+        const anchor = await store.addAnchor({
+          title: String(args.text).slice(0, 24),
+          what: args.text,
+          why: args.why || '',
+        })
+        return { id: anchor.id }
+      },
+    }),
+  )
+
+  // ── 3) 定时压缩 ──
+  const compactEvery = readField(config, 'compactEveryMinutes', 30)
+  if (compactEvery > 0) {
+    const ms = compactEvery * 60 * 1000
+    const timer = setInterval(() => {
+      store
+        .compact(readPolicy())
+        .then((made) => {
+          for (const m of made) ctx.logger?.info?.('[bookmemory] 浓缩 %d 本 -> %s', m.ids.length, m.book.id)
+        })
+        .catch((err) => ctx.logger?.warn?.('[bookmemory] 压缩失败: %s', err?.message || err))
+    }, ms)
+    timer.unref?.()
+  }
+
+  ctx.logger?.info?.('[bookmemory] 已加载，数据目录 %s', store.dir)
+}

package/lib/store.js

@@ -0,0 +1,334 @@
+// 图书馆：书 / 目录 / 锚点 / 压缩。
+//
+// 数据全在 dataDir 里，四个纯文本文件：
+//   书.jsonl      对话原文，一条一行，永不覆盖；归档的加 "archived": true
+//   目录.json     关键词 -> 书号（倒排索引），归档书不进目录
+//   锚点.jsonl    提炼过的「值得记」的事
+//   策略.json     压缩规则
+//
+// 检索打分：Σ 1/(1+0.2*该词条下的书数) —— 越少见的词命中越值钱。
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tokenize } from './tokenize.js'
+
+const DEFAULT_POLICY = {
+  oldFraction: 0.2,
+  clusterMinShared: 2,
+  digestMaxChars: 220,
+}
+
+function now() {
+  const d = new Date()
+  const p = (n) => String(n).padStart(2, '0')
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`
+}
+
+function today() {
+  return now().slice(0, 10)
+}
+
+function bookId() {
+  return 'bk_' + Math.random().toString(36).slice(2, 10).toUpperCase()
+}
+
+function anchorId() {
+  return 'an_' + Math.random().toString(36).slice(2, 12).toUpperCase()
+}
+
+export class Store {
+  /** @param {string} dir */
+  constructor(dir) {
+    this.dir = dir
+    this.booksPath = join(dir, '书.jsonl')
+    this.catalogPath = join(dir, '目录.json')
+    this.anchorsPath = join(dir, '锚点.jsonl')
+    this.policyPath = join(dir, '策略.json')
+    this._catalog = null
+  }
+
+  async ensure() {
+    await mkdir(this.dir, { recursive: true })
+    if (!existsSync(this.policyPath)) {
+      await writeFile(this.policyPath, JSON.stringify(DEFAULT_POLICY, null, 2), 'utf8')
+    }
+  }
+
+  // ───────── 基础读写 ─────────
+
+  async _readJsonl(path) {
+    if (!existsSync(path)) return []
+    const text = await readFile(path, 'utf8')
+    const out = []
+    for (const line of text.split('\n')) {
+      const t = line.trim()
+      if (!t) continue
+      try { out.push(JSON.parse(t)) } catch { /* 坏行跳过，不让一条脏数据毁掉整个图书馆 */ }
+    }
+    return out
+  }
+
+  /** 原子写：先写 .tmp 再 rename，断电也不会写坏半个文件。 */
+  async _atomicWrite(path, text) {
+    const tmp = path + '.tmp'
+    await writeFile(tmp, text, 'utf8')
+    await rename(tmp, path)
+  }
+
+  async loadBooks() {
+    return this._readJsonl(this.booksPath)
+  }
+
+  async loadAnchors() {
+    return this._readJsonl(this.anchorsPath)
+  }
+
+  async loadPolicy() {
+    try {
+      const raw = await readFile(this.policyPath, 'utf8')
+      return { ...DEFAULT_POLICY, ...JSON.parse(raw) }
+    } catch {
+      return { ...DEFAULT_POLICY }
+    }
+  }
+
+  async loadCatalog() {
+    if (this._catalog) return this._catalog
+    try {
+      this._catalog = JSON.parse(await readFile(this.catalogPath, 'utf8'))
+    } catch {
+      this._catalog = {}
+    }
+    return this._catalog
+  }
+
+  async _saveCatalog(catalog) {
+    this._catalog = catalog
+    await this._atomicWrite(this.catalogPath, JSON.stringify(catalog, null, 1))
+  }
+
+  async _appendJsonl(path, obj) {
+    const line = JSON.stringify(obj) + '\n'
+    const { appendFile } = await import('node:fs/promises')
+    await appendFile(path, line, 'utf8')
+  }
+
+  // ───────── 写书 ─────────
+
+  /**
+   * 存一次对话。
+   * @param {{text: string, reply?: string, role?: string, tags?: string[]}} input
+   */
+  async addBook({ text, reply = '', role = '他', tags = [] }) {
+    await this.ensure()
+    const book = {
+      id: bookId(),
+      date: today(),
+      at: now(),
+      role,
+      text: String(text || ''),
+      reply: String(reply || ''),
+      tags,
+      keys: tokenize(`${text || ''} ${reply || ''}`),
+    }
+    await this._appendJsonl(this.booksPath, book)
+
+    const catalog = await this.loadCatalog()
+    for (const k of book.keys) {
+      if (!catalog[k]) catalog[k] = []
+      if (!catalog[k].includes(book.id)) catalog[k].push(book.id)
+    }
+    await this._saveCatalog(catalog)
+    return book
+  }
+
+  async addAnchor({ title, what, why = '', tags = [] }) {
+    await this.ensure()
+    const anchor = {
+      id: anchorId(),
+      date: today(),
+      at: now(),
+      title: String(title || '').slice(0, 40),
+      what: String(what || '').slice(0, 400),
+      why: String(why || '').slice(0, 400),
+      tags,
+    }
+    await this._appendJsonl(this.anchorsPath, anchor)
+    return anchor
+  }
+
+  // ───────── 检索 ─────────
+
+  /**
+   * 给一句话，返回最相关的几本书（归档的不参与）。
+   * @param {string} query
+   * @param {number} limit
+   */
+  async search(query, limit = 6) {
+    const catalog = await this.loadCatalog()
+    const books = await this.loadBooks()
+    const byId = new Map(books.filter((b) => !b.archived).map((b) => [b.id, b]))
+    const qkeys = tokenize(query)
+
+    const score = new Map()
+    const hits = new Map()
+    for (const k of qkeys) {
+      const ids = catalog[k]
+      if (!ids || !ids.length) continue
+      const weight = 1 / (1 + 0.2 * ids.length)
+      for (const id of ids) {
+        if (!byId.has(id)) continue
+        score.set(id, (score.get(id) || 0) + weight)
+        if (!hits.has(id)) hits.set(id, [])
+        hits.get(id).push(k)
+      }
+    }
+
+    return [...score.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit)
+      .map(([id, s]) => ({ book: byId.get(id), score: Number(s.toFixed(2)), hit: hits.get(id) || [] }))
+  }
+
+  /** 顺带查锚点：锚点更浓缩，命中一两句就够。 */
+  async relatedAnchors(query, limit = 5) {
+    const anchors = await this.loadAnchors()
+    const qkeys = new Set(tokenize(query))
+    const scored = []
+    for (const a of anchors) {
+      const blob = new Set(tokenize(`${a.title} ${a.what} ${a.why}`))
+      let common = 0
+      for (const k of qkeys) if (blob.has(k)) common++
+      if (common > 0) scored.push([common, a])
+    }
+    scored.sort((x, y) => y[0] - x[0])
+    return scored.slice(0, limit).map(([, a]) => a)
+  }
+
+  // ───────── 压缩 ─────────
+
+  /**
+   * 把「久远且相近」的书合成浓缩书，原书标 archived（不删，留作证据）。
+   * @param {{oldFraction:number, clusterMinShared:number, digestMaxChars:number}} policy
+   * @param {boolean} dry 只算不写
+   */
+  async compact(policy, dry = false) {
+    const pol = { ...DEFAULT_POLICY, ...(policy || {}) }
+    const all = await this.loadBooks()
+    const live = all.filter((b) => !b.archived && b.kind !== 'condensed')
+    if (live.length < 4) return []
+
+    const ts = (b) => {
+      const t = Date.parse((b.at || '').replace(' ', 'T'))
+      return Number.isFinite(t) ? t : Date.now()
+    }
+    const stamps = live.map(ts)
+    const t0 = Math.min(...stamps)
+    const t1 = Date.now()
+    if (t1 - t0 < 10 * 60 * 1000) return [] // 跨度不到 10 分钟，谈不上久远
+
+    const cutoff = t0 + (t1 - t0) * pol.oldFraction
+    const old = live.filter((b) => ts(b) <= cutoff)
+    if (old.length < 2) return []
+
+    // 贪心聚类：每本找共享词最多的那堆，够不上就自己开一堆；再两两合并
+    const clusters = []
+    for (const b of old.sort((x, y) => ts(x) - ts(y))) {
+      const keys = new Set(b.keys || [])
+      let best = null
+      let bestShared = 0
+      for (const c of clusters) {
+        let shared = 0
+        for (const k of keys) if (c.keys.has(k)) shared++
+        if (shared > bestShared) { best = c; bestShared = shared }
+      }
+      if (best && bestShared >= pol.clusterMinShared) {
+        best.items.push(b)
+        for (const k of keys) best.keys.add(k)
+      } else {
+        clusters.push({ keys: new Set(keys), items: [b] })
+      }
+    }
+    let merged = true
+    while (merged) {
+      merged = false
+      outer: for (let i = 0; i < clusters.length; i++) {
+        for (let j = i + 1; j < clusters.length; j++) {
+          let shared = 0
+          for (const k of clusters[i].keys) if (clusters[j].keys.has(k)) shared++
+          if (shared >= pol.clusterMinShared) {
+            clusters[i].items.push(...clusters[j].items)
+            for (const k of clusters[j].keys) clusters[i].keys.add(k)
+            clusters.splice(j, 1)
+            merged = true
+            break outer
+          }
+        }
+      }
+    }
+
+    const made = []
+    for (const c of clusters) {
+      if (c.items.length < 2) continue
+      const ids = c.items.map((b) => b.id)
+      const dates = [...new Set(c.items.map((b) => b.date))].sort()
+      const oneLine = (b) => {
+        let t = String(b.text || '').replace(/https?:\/\/\S+/g, '(链接)').replace(/\s+/g, ' ').trim()
+        return t.length > 28 ? t.slice(0, 28) + '…' : t
+      }
+      let summary = c.items.map(oneLine).join('；')
+      if (summary.length > pol.digestMaxChars) summary = summary.slice(0, pol.digestMaxChars) + '…'
+      made.push({
+        id: bookId(),
+        date: dates.length === 1 ? dates[0] : `${dates[0]}~${dates[dates.length - 1]}`,
+        at: now(),
+        role: '浓缩',
+        kind: 'condensed',
+        covers: ids,
+        text: `（${c.items.length} 次对话浓缩）${summary}`,
+        reply: '',
+        tags: ['浓缩'],
+        keys: [...c.keys].slice(0, 24),
+      })
+    }
+
+    if (!made.length || dry) return made.map((b) => ({ book: b, ids: b.covers }))
+
+    // 写新书
+    for (const b of made) await this._appendJsonl(this.booksPath, b)
+
+    // 标记归档：重写整个文件
+    const archivedIds = new Set(made.flatMap((b) => b.covers))
+    const rows = []
+    for (const b of await this.loadBooks()) {
+      rows.push(JSON.stringify(archivedIds.has(b.id) ? { ...b, archived: true } : b))
+    }
+    await this._atomicWrite(this.booksPath, rows.join('\n') + '\n')
+
+    // 重建目录：归档书不进目录
+    const catalog = {}
+    for (const b of await this.loadBooks()) {
+      if (b.archived) continue
+      for (const k of b.keys || []) {
+        if (!catalog[k]) catalog[k] = []
+        if (!catalog[k].includes(b.id)) catalog[k].push(b.id)
+      }
+    }
+    await this._saveCatalog(catalog)
+
+    return made.map((b) => ({ book: b, ids: b.covers }))
+  }
+
+  async stats() {
+    const books = await this.loadBooks()
+    const catalog = await this.loadCatalog()
+    const anchors = await this.loadAnchors()
+    return {
+      books: books.filter((b) => !b.archived).length,
+      archived: books.filter((b) => b.archived).length,
+      keywords: Object.keys(catalog).length,
+      anchors: anchors.length,
+    }
+  }
+}

package/lib/tokenize.js

@@ -0,0 +1,42 @@
+// 中文分词：@node-rs/jieba（预编译二进制，装完即用，不需要编译环境和 Python）
+//
+// 为什么不用 Node 内置的 Intl.Segmenter：它把中文按单字切。
+//   实测：'牵丝戏' → 牵/丝/戏，12 个句子里 50 个关键词只剩 3 个，10 个专有名词全丢。
+//
+// 注意这个包是 CommonJS，只能默认导入：
+//   import jieba from '@node-rs/jieba'     ✅ 自带你需要的内置词典
+//   import { Jieba } from '@node-rs/jieba' ❌ 具名导入在 ESM 下会报错
+
+import jieba from '@node-rs/jieba'
+
+// 高频虚词、代词、万能动词——做目录没有区分度
+const STOP = new Set(`
+的 了 是 在 我 你 他 她 它 们 这 那 有 和 与 就 都 也 还 又 把 被 让 给 从 到 对 为 以
+一个 一下 什么 怎么 为什么 可以 现在 然后 但是 因为 所以 如果 就是 不是 没有 已经
+说 做 去 来 要 会 能 想 看 听 好 不 太 很 更 最 再 才 只 些 个 上 下 里 外 时
+啊 吧 呢 吗 呀 哦 嗯 哈 么 着 过 地 得 我们 你们 他们 自己 这个 那个 这样 那样
+`.trim().split(/\s+/))
+
+const URL_RE = /https?:\/\/\S+/g
+// 只丢「纯标点 / 纯符号」。不能写成 [\W_]：JS 的 \W 不认中文，会把汉字全过滤掉。
+const NON_WORD_RE = /^[\p{P}\p{S}\p{Z}\s]+$/u
+
+/**
+ * 把一段话切成关键词：去 URL、切词、丢停用词和单字、去重。
+ * @param {string} text
+ * @returns {string[]}
+ */
+export function tokenize(text) {
+  if (!text) return []
+  const clean = String(text).replace(URL_RE, ' ')
+  const words = jieba.cut(clean, true) // true = 精确模式
+  const out = []
+  const seen = new Set()
+  for (const raw of words) {
+    const w = String(raw).trim()
+    if (w.length < 2 || STOP.has(w) || seen.has(w) || NON_WORD_RE.test(w)) continue
+    seen.add(w)
+    out.push(w)
+  }
+  return out
+}

package/package.json

@@ -1,6 +1,56 @@
-{
-  "name": "dsh-bookmemory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+    "name":  "dsh-bookmemory",
+    "version":  "0.1.0",
+    "description":  "把每次对话存成一本「书」，用关键词做目录；久远的书自动浓缩成一本。给 DSH 的长期记忆插件。",
+    "license":  "MIT",
+    "author":  "s1770",
+    "type":  "module",
+    "main":  "entry.js",
+    "exports":  {
+                    ".":  "./entry.js",
+                    "./package.json":  "./package.json"
+                },
+    "files":  [
+                  "entry.js",
+                  "lib/",
+                  "tools/install.ps1",
+                  "tools/clean_noise.py",
+                  "README.md",
+    "README.en.md",
+                  "MANUAL.md",
+                  "INSTALL.md",
+                  "LICENSE"
+              ],
+    "keywords":  [
+                     "dsh",
+                     "dsh-plugin",
+                     "memory",
+                     "rag",
+                     "chinese"
+                 ],
+    "engines":  {
+                    "node":  "\u003e=18"
+                },
+    "dependencies":  {
+                         "@node-rs/jieba":  "^1.10.0"
+                     },
+    "peerDependencies":  {
+                             "@deepseek-ai/schemastery":  "*"
+                         },
+    "scripts":  {
+                    "check":  "node --check entry.js",
+                    "test":  "node test/smoke.mjs"
+                },
+    "devDependencies":  {
+                            "@deepseek-ai/dsh-tools":  "^0.2.1-rc.2",
+                            "@deepseek-ai/schemastery":  "^3.18.5"
+                        },
+    "repository":  {
+                       "type":  "git",
+                       "url":  "git+https://github.com/s17700958289-ship-it/dsh-bookmemory.git"
+                   },
+    "homepage":  "https://github.com/s17700958289-ship-it/dsh-bookmemory#readme",
+    "bugs":  {
+                 "url":  "https://github.com/s17700958289-ship-it/dsh-bookmemory/issues"
+             }
+}

package/tools/clean_noise.py

@@ -0,0 +1,72 @@
+"""清掉被 harness 注入上下文污染的旧书，并重建目录。
+
+装插件初期「注入的运行时上下文」被当成了用户消息记进书里，
+这些记录没有价值，而且它们的英文词会污染关键词目录。
+"""
+
+import json
+import os
+
+DIR = r"C:\Users\s1770\.dsh-bookmemory"
+BOOKS = os.path.join(DIR, "书.jsonl")
+CATALOG = os.path.join(DIR, "目录.json")
+
+BAD_PREFIX = (
+    "Time sampled while preparing",
+    "Current runtime context",
+    "Tokens prefixed with @",
+    "The runtime context names",
+    "<system-reminder>",
+    "### Updated Tool Schemas",
+    "[SCHEDULE REMINDER]",
+)
+
+
+def is_bad(text):
+    t = (text or "").lstrip()
+    return any(t.startswith(p) for p in BAD_PREFIX)
+
+
+def main():
+    if not os.path.isfile(BOOKS):
+        print("没有书")
+        return
+
+    kept, dropped = [], 0
+    for line in open(BOOKS, encoding="utf-8"):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            b = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if is_bad(b.get("text")):
+            dropped += 1
+            continue
+        kept.append(b)
+
+    with open(BOOKS, "w", encoding="utf-8") as f:
+        for b in kept:
+            f.write(json.dumps(b, ensure_ascii=False) + "\n")
+
+    # 重建目录：归档书不进目录
+    catalog = {}
+    for b in kept:
+        if b.get("archived"):
+            continue
+        for k in b.get("keys") or []:
+            if not k:
+                continue
+            catalog.setdefault(k, [])
+            if b["id"] not in catalog[k]:
+                catalog[k].append(b["id"])
+
+    with open(CATALOG, "w", encoding="utf-8") as f:
+        json.dump(catalog, f, ensure_ascii=False, indent=1)
+
+    print(f"删掉 {dropped} 条噪音，留下 {len(kept)} 本书，目录 {len(catalog)} 个词")
+
+
+if __name__ == "__main__":
+    main()

package/tools/install.ps1

@@ -0,0 +1,124 @@
+<#
+.SYNOPSIS
+    把 dsh-bookmemory 装进一个 DSH profile：建目录链接 + 追加一行 patch。
+
+.DESCRIPTION
+    做两件事，都不碰 package.json、不跑 pnpm：
+      1. 在 <profile>\node_modules\dsh-bookmemory 建一个目录链接（Junction）
+      2. 在 <profile>\cordis.patch.yml 末尾追加一条 insert 行
+
+    改之前先备份 patch 文件到 ~/.dsh/.dsh-rollback-dsh-bookmemory-<时间戳>\。
+
+.PARAMETER ProfileName
+    装到哪个 profile。默认 web（`dsh web` 用的那个）。
+    桌面版（DSH Desktop）的 profile 叫 desktop。
+
+.PARAMETER PackageDir
+    插件目录，默认脚本所在的上一级。
+
+.EXAMPLE
+    powershell -ExecutionPolicy Bypass -File tools\install.ps1
+    powershell -ExecutionPolicy Bypass -File tools\install.ps1 -ProfileName desktop
+#>
+param(
+    [string]$ProfileName = 'web',
+    [string]$PackageDir = (Split-Path -Parent $PSScriptRoot)
+)
+
+$ErrorActionPreference = 'Stop'
+$PluginName = 'dsh-bookmemory'
+
+function Say($msg) { Write-Host $msg }
+function Fail($msg) { Write-Host "错误：$msg" -ForegroundColor Red; exit 1 }
+
+# ── 1/5 找 DSH 和 profile ──
+Say '=== 1/5 找 DSH 和 profile ==='
+$DshHome = if ($env:DSH_HOME) { $env:DSH_HOME } else { Join-Path $env:USERPROFILE '.dsh' }
+if (-not (Test-Path $DshHome)) { Fail "找不到 DSH 主目录：$DshHome（可以设环境变量 DSH_HOME 指定）" }
+
+$Profile = Join-Path (Join-Path $DshHome 'profiles') $ProfileName
+if (-not (Test-Path $Profile)) {
+    $found = @(Get-ChildItem (Join-Path $DshHome 'profiles') -Directory -ErrorAction SilentlyContinue |
+        ForEach-Object { $_.Name })
+    Fail "没有叫 '$ProfileName' 的 profile。现有的：$($found -join ', ')"
+}
+$PatchFile = Join-Path $Profile 'cordis.patch.yml'
+if (-not (Test-Path $PatchFile)) { Fail "profile 里没有 cordis.patch.yml：$PatchFile" }
+Say "  profile = $Profile"
+
+if (-not (Test-Path (Join-Path $PackageDir 'entry.js'))) {
+    Fail "PackageDir 里没有 entry.js：$PackageDir"
+}
+Say "  package = $PackageDir"
+
+# ── 2/5 备份 ──
+Say '=== 2/5 备份 patch 文件 ==='
+$Stamp = Get-Date -Format 'yyyyMMdd-HHmmss'
+$Backup = Join-Path $DshHome ".dsh-rollback-$PluginName-$Stamp"
+New-Item -ItemType Directory -Force -Path $Backup | Out-Null
+Copy-Item $PatchFile (Join-Path $Backup 'cordis.patch.yml') -Force
+"hadNodeModulesLink=$(Test-Path (Join-Path $Profile "node_modules\$PluginName"))" |
+    Set-Content (Join-Path $Backup 'MANIFEST.txt') -Encoding UTF8
+Say "  备份 = $Backup"
+
+# ── 3/5 目录链接 ──
+Say '=== 3/5 建目录链接 ==='
+$LinkDir = Join-Path $Profile 'node_modules'
+New-Item -ItemType Directory -Force -Path $LinkDir | Out-Null
+$LinkPath = Join-Path $LinkDir $PluginName
+
+if (Test-Path $LinkPath) {
+    $item = Get-Item $LinkPath -Force
+    if ($item.LinkType -eq 'Junction') {
+        Say "  链接已存在，指向 $($item.Target)"
+        if ($item.Target -ne $PackageDir) {
+            Say '  但指向的不是这个目录，重建...'
+            Remove-Item $LinkPath -Force
+            New-Item -ItemType Junction -Path $LinkPath -Target $PackageDir | Out-Null
+            Say "  已重建 -> $PackageDir"
+        }
+    } else {
+        Fail "$LinkPath 已存在且不是目录链接，不敢动它。请手动检查。"
+    }
+} else {
+    New-Item -ItemType Junction -Path $LinkPath -Target $PackageDir | Out-Null
+    Say "  $LinkPath -> $PackageDir"
+}
+
+# ── 4/5 patch 行 ──
+Say '=== 4/5 追加 patch 行 ==='
+$existing = Get-Content $PatchFile -Raw -Encoding UTF8
+if ($existing -match "id:\s*bookmemory") {
+    Say '  patch 里已有 bookmemory 行，跳过'
+} else {
+    $row = @"
+
+# dsh-bookmemory：对话存成书、关键词做目录、久远的自动浓缩
+- insert:
+    - id: bookmemory
+      name: dsh-bookmemory
+"@
+    # 该文件是无 BOM 的 UTF-8，且常带中文，必须保持无 BOM 追加
+    $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
+    [System.IO.File]::AppendAllText($PatchFile, $row, $utf8NoBom)
+    Say '  已追加'
+}
+
+# ── 5/5 检查依赖 ──
+Say '=== 5/5 检查设置卡片需要的依赖 ==='
+$schema = Join-Path (Join-Path $PackageDir 'node_modules') '@deepseek-ai\schemastery'
+if (Test-Path $schema) {
+    $ver = (Get-Content (Join-Path $schema 'package.json') -Raw | ConvertFrom-Json).version
+    Say "  @deepseek-ai/schemastery $ver"
+    if ([version]$ver -lt [version]'3.18.4') {
+        Say '  警告：低于 3.18.4，设置卡片可能不出现（插件功能仍然正常）'
+    }
+} else {
+    Say '  警告：没找到 @deepseek-ai/schemastery，设置卡片可能不出现'
+    Say '        运行 cmd /c "npm install --save-dev @deepseek-ai/schemastery" 补上'
+}
+
+Say ''
+Say '装完了。'
+Say '大多数 profile 会热加载 cordis.patch.yml（几秒内生效）；没热加载的重启一次 DSH。'
+Say "撤销：删掉 $LinkPath，再把 $Backup\cordis.patch.yml 拷回去。"