dsh-memory-trigger 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-memory-trigger contributors
+
+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/README.md

@@ -1,3 +1,206 @@
-# Temporary Holding Version
+# dsh-memory-trigger
 
-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 的上下文压缩只影响模型「眼前」的窗口，不删除会话事件日志（`~/.dsh/sessions/` 下的 zstd JSONL）。
+所以"忘记"是可见性问题，不是存储问题。本插件把可见性补回来。
+
+## 工作方式
+
+```
+用户消息
+  → [agent/inbox/claimed] 纯程序判定
+      ① 回忆关键词：「你忘了 / 我说过 / 之前提过 / 记得吗 / 你答应过 …」
+      ② 指代：「那个 / 那次 / 上次 / 这事 / 前几天 …」
+      ③ 实体缺失：消息里的英文词/引号词/路径在当前上下文没有，但历史里有
+  → 本地索引检索（BM25 + 中文 bigram，毫秒级，无网络、无 embedding）
+  → [agent/pre-step] 追加一条 user 消息，内容是带时间戳的回忆片段
+  → 模型拿着原文回答，不再"没印象"
+```
+
+注入示例：
+
+```text
+[记忆检索] 用户可能在引用过去的对话（触发：keyword/我说过）。从会话历史检索到 2 条相关片段：
+1. 2026-11-03 22:30（5 天前）· 我说过 · seq 10650
+   「Ghidra 配好了……Ghidra 12.1.4 … REA 只认 12.1.x…」
+2. 2026-11-03 22:32（5 天前）· 我说过 · seq 10666
+   「REA 的 MCP 配置已就位，下次重启 DSH 后 mcp__rea__* 工具就能用…」
+请结合上述原文回答；需要更多细节时可用 session_event_read 读对应 seq，不要笼统说"记不清"。
+```
+
+## 注入消息的来源（v4 格式硬要求）
+
+会话格式 v3 起（本机已是 v4）**只认「生产者自己的 kind」**：注入消息的 `source` 不能再用
+`{ kind: 'plugin', plugin: 'xxx' }` 这种 v3 包装，否则宿主会在写入 / 校验时直接抛
+
+```
+format v4 message requires a producer-owned source kind
+```
+
+整轮运行失败（用户侧看到「本轮运行失败 …」）。所以这里固定写自家 kind，与 dsh-heart
+（`kind: 'dsh-heart'`）保持一致：
+
+```js
+const message = createUserMessage({
+  content: [{ type: 'text', text: item.text }],
+  source: { kind: 'memory-trigger' },
+});
+```
+
+注意：`node_modules/dsh-memory-trigger` 是 `file:` 依赖的拷贝，改完 `plugins/` 里的源码要重新
+`pnpm add file:./plugins/dsh-memory-trigger`（或直接改拷贝）并重启 DSH 才生效。
+
+## 安装
+
+从 npm 安装（推荐）：
+
+```bash
+dsh plugin --profile <你的 profile> add dsh-memory-trigger
+# 然后把 "dsh-memory-trigger" 加进该 profile package.json 的 dsh.profile.bundles，并重启 DSH
+```
+
+从源码安装：
+
+```bash
+cd ~/.dsh/profiles/<你的 profile>
+pnpm add file:/path/to/dsh-memory-trigger
+# package.json 的 dsh.profile.bundles 里要有 "dsh-memory-trigger"
+```
+
+改完重启 DSH 生效（宿主插件在启动时加载）。
+
+### 首次回填历史
+
+实时消息会自动入库；但**插件安装前**的历史需要回填一次：
+
+```bash
+node plugins/dsh-memory-trigger/lib/backfill.mjs
+```
+
+需要支持 zstd 的 Node（>= 22.15 或 24 系列）。DSH 自带运行时若不含 zstd，用系统 Node 24 执行：
+
+```bash
+node plugins/dsh-memory-trigger/lib/backfill.mjs
+```
+
+回填产物在 `~/.dsh/memory-trigger/events/<sessionId>.jsonl`，一行一条：
+
+```json
+{"session":"…","seq":10650,"ts":1793706600000,"role":"assistant","text":"…"}
+```
+
+## 配置（`cordis.patch.yml` 的 `dsh-memory-trigger` 条目）
+
+```yaml
+- id: dsh-memory-trigger
+  name: 'dsh-memory-trigger'
+  config:
+    enabled: true
+    keywords: ['你忘', '我说过', '之前提过', '还记得', '你答应过']
+    anaphora: ['那个', '那次', '上次', '这事', '前几天']
+    timeAnaphora:  # 时间指代正则；留空 = 用内置表
+      - '\\d{1,3}\\s*天前'
+      - '昨天'
+      - '\\d{1,2}\\s*月\\s*\\d{1,2}\\s*[日号]'
+      - '星期[一二三四五六日天1-7]'
+      - '(?:下午|晚上)?\\s*\\d{1,2}\\s*[点时]'
+    entityTrigger: true
+    includeToolResults: true
+    topK: 3             # 每条消息最多注入几条片段
+    maxChars: 1200      # 注入总字数上限
+    minScore: 1.2       # BM25 阈值，低于此不注入
+    scope: all          # all = 全部历史会话（默认）；session = 只搜当前会话
+    groupByProject: true  # 跨项目时按项目分组标注
+    logTriggers: true
+```
+
+所有字段都有默认值，不写也能跑。改了配置重启 DSH 生效。
+
+## 拦截关键词（默认值）
+
+**回忆关键词**（命中必搜）：
+`你忘` `忘了` `我说过` `你说过` `之前说过` `之前提过` `提过` `记得吗` `还记得` `你答应过` `上次说的` `上次那个` `之前那个` `前面说的` `刚才说的` `回忆一下`
+
+**指代词**（命中后搜索，分数够才注入）：
+`那个` `那次` `这事` `这个事` `那件事` `上次` `之前` `前几天` `那天` `当时` `你说的` `我说过的` `接着说` `继续那个`
+
+**时间指代**（`timeAnaphora`，命中后解析成时间窗）：
+`3天前` `三天前` `昨天` `前天` `大前天` `今天` `11月3日` `星期三` `礼拜天` `3点` `下午3点半` `上周` `上个月` `最近7天` `今年` `去年` `本月` …
+
+解析结果会作为检索的 `since/until` 过滤条件，只搜那个时间窗内的事件；注入头部会标注「时间窗：2026-11-03」。
+解析失败或窗口内无结果时，会自动放开时间窗重搜一次，不会因为时间误差而完全没结果。
+
+| 说法 | 解析成 |
+|---|---|
+| 3 天前 / 三天前 | 那一天 00:00–24:00 |
+| 昨天 / 前天 / 大前天 | 对应自然日 |
+| 11 月 3 日 | 那一天（未来日期自动算去年） |
+| 星期三 / 礼拜天 / 周5 | 最近一个该星期几 |
+| 3 点 / 下午 3 点半 | 对应时刻 ±1 小时 |
+| 上周 / 上个月 / 去年 / 今年 / 本月 | 对应区间 |
+| 最近 N 天 | N 天前至今 |
+
+**实体缺失**（`entityTrigger`）：消息里的英文词、引号词、文件路径，在当前上下文没有但历史索引里有时触发。
+
+## 索引内容
+
+| 事件类型 | 是否入索引 | 注入时标注 |
+|---|---|---|
+| `user/message`（你说的） | ✅ | 你说过 |
+| `assistant/message`（我说的） | ✅ | 我说过 |
+| `tool/result`（工具输出） | ✅ 默认开启，只留前 4000 字 | 工具结果 |
+
+工具输出很长，默认截断到 4000 字参与索引；不想要可在配置里 `includeToolResults: false` 关掉。
+
+## 数据文件
+
+| 路径 | 内容 |
+|---|---|
+| `~/.dsh/memory-trigger/events/*.jsonl` | 明文事件索引（回填 + 实时追加） |
+| `~/.dsh/memory-trigger/trigger.log.jsonl` | 每次触发的记录（时间、触发词、命中条数） |
+
+## 自测
+
+```bash
+node plugins/dsh-memory-trigger/lib/selftest.mjs
+```
+
+会在真实历史上跑几条查询，打印命中片段和耗时（当前索引约 2300 条事件，查询 1–10ms）。
+
+## 已知限制
+
+- 触发是**字面匹配**：完全绕开关键词的暗示可能漏；开了 `entityTrigger` 后覆盖大部分情况
+- 注入是"给模型看原文"，不保证它一定引用；提示语里已要求"不要笼统说记不清"
+- 会话日志格式（`session.v4`）随 DSH 升级可能变；若 `history.` 读不到，插件会 log warn 并退化为"只捕获实时消息"
+- 注入片段占上下文预算，默认上限 1200 字；长会话可适当调小 `topK`
+- 跨会话检索（`scope: all`）默认开启：结果可能来自别的项目，注入时会按项目分组标注；只想看当前会话就设 `scope: session`
+
+## 日志
+
+`trigger.log.jsonl` 同时记录命中和**未命中**（`hit: 0, miss: true`），可用来调词典和阈值：
+
+```json
+{"at":"2026-11-08T06:30:00Z","kind":"keyword","trigger":"我说过","query":"…","hits":3}
+{"at":"2026-11-08T06:31:00Z","kind":"anaphora","trigger":"那个","query":"…","hits":0,"miss":true}
+```
+
+## 开发注意（血泪教训）
+
+1. **改插件前先读当前 DSH 的最新开发文档 / 源码**（DSH 安装目录下的 `resources/app.asar/dsh/`），不要凭旧版本的记忆写。
+2. **会话格式以宿主的 `SESSION_FORMAT_VERSION` 为准**。v4 起注入消息的 `source.kind` 必须是"生产者自己的 kind"；
+   旧写法 `{ kind: 'plugin', plugin: 'xxx' }` 会被宿主拒绝并**让整轮运行失败**。
+   本插件已用 `dshSession.SESSION_FORMAT_VERSION` 自动选择写法。
+3. **插件必须 fail-soft**：注入/判定逻辑全部包在 try/catch 里，出错只记 warn、跳过本次，绝不能让用户的当轮对话失败。
+4. **必须在真实宿主里验证**：离线 smoke（`lib/smoke.mjs`）只验证逻辑，不能证明宿主接受这条消息；
+   至少要重启一次 DSH，发一条会触发注入的消息，确认能正常往返。
+
+## 后续可做
+
+- 语义召回（embedding）作为 BM25 的补充
+- 词典热更新（改配置不用重启）
+- 未命中统计与自动调词（按 `trigger.log.jsonl` 分析）

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+# dsh-memory-trigger bundle patch
+#
+# 插入记忆触发插件：监听 agent/inbox/claimed 判定「用户在引用旧记忆」，
+# 检索本地会话事件索引，并在 agent/pre-step 时把带时间戳的回忆片段注入本轮上下文。
+- insert:
+    - id: dsh-memory-trigger
+      name: 'dsh-memory-trigger'

package/lib/backfill.mjs

@@ -0,0 +1,108 @@
+/**
+ * 一次性回填：把会话历史（zstd 压缩的 JSONL）解压成明文事件索引。
+ *
+ * 用法（需要支持 zstd 的 Node，>= 22.15 或 24 系列）：
+ *   node lib/backfill.mjs
+ *   node lib/backfill.mjs --store C:\path\to\store
+ *
+ * 产物：<store>/events/<sessionId>.jsonl，一行一条 {session,seq,ts,role,text}
+ * 只抽取 user/message 与 assistant/message 的正文；系统注入的噪音（心跳摘要、
+ * 运行时上下文）和插件消息会被跳过。
+ */
+import { readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { zstdDecompressSync } from 'node:zlib';
+
+const args = process.argv.slice(2);
+function argOf(name, fallback = '') {
+  const i = args.indexOf(name);
+  return i >= 0 && args[i + 1] ? args[i + 1] : fallback;
+}
+
+const dshHome = process.env.DSH_HOME || join(homedir(), '.dsh');
+const sessionsDir = join(dshHome, 'sessions');
+const storeDir = argOf('--store', join(dshHome, 'memory-trigger'));
+const eventsDir = join(storeDir, 'events');
+
+const NOISE_PREFIXES = ['Current runtime context', '[dsh-heart]', '眼前的对话快放不下'];
+
+function isNoise(text) {
+  const t = text.trimStart();
+  return NOISE_PREFIXES.some((p) => t.startsWith(p));
+}
+
+function toText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const parts = [];
+  for (const p of content) if (p && p.type === 'text' && typeof p.text === 'string') parts.push(p.text);
+  return parts.join('\n');
+}
+
+function walk(dir, out = []) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walk(p, out);
+    else if (e.name.endsWith('.jsonl.zstd')) out.push(p);
+  }
+  return out;
+}
+
+mkdirSync(eventsDir, { recursive: true });
+const files = walk(sessionsDir);
+let total = 0;
+const summary = [];
+
+for (const f of files) {
+  let lines;
+  try {
+    lines = zstdDecompressSync(readFileSync(f)).toString('utf8').split('\n');
+  } catch (error) {
+    summary.push(`${f}: 解压失败 ${String(error)}`);
+    continue;
+  }
+  const sessionId = f.split(/[\\/]/).slice(-2, -1)[0] || 'unknown';
+  const out = [];
+  let project = '';
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (ev.type === 'session') {
+      // 会话头里有 cwd：用它给每条事件标上项目
+      const cwd = ev.cwd ?? ev.data?.cwd ?? '';
+      if (cwd) project = basename(String(cwd)) || String(cwd);
+      continue;
+    }
+    if (ev.type === 'user/message') {
+      const text = toText(ev.data?.content);
+      const srcKind = ev.data?.source?.kind;
+      if (text && (srcKind === undefined || srcKind === 'user') && !isNoise(text))
+        out.push({ session: sessionId, project, seq: ev.seq, ts: ev.time, role: 'user', text });
+    } else if (ev.type === 'assistant/message') {
+      const text = toText(ev.data?.message?.content) || String(ev.data?.text ?? '');
+      if (text) out.push({ session: sessionId, project, seq: ev.seq, ts: ev.time, role: 'assistant', text });
+    } else if (ev.type === 'tool/result') {
+      const text = toText(ev.data?.message?.content).slice(0, 4000);
+      if (text) out.push({ session: sessionId, project, seq: ev.seq, ts: ev.time, role: 'tool', text });
+    }
+  }
+  if (out.length === 0) continue;
+  writeFileSync(join(eventsDir, `${sessionId}.jsonl`), out.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf8');
+  total += out.length;
+  summary.push(`${sessionId}: ${out.length} 条（${(statSync(f).size / 1048576).toFixed(1)} MB 源文件）`);
+}
+
+console.log(`回填完成：${files.length} 个会话文件，${total} 条事件 → ${eventsDir}`);
+for (const s of summary) console.log('  ' + s);

package/lib/index.js

@@ -0,0 +1,481 @@
+/**
+ * dsh-memory-trigger — 记忆触发插件
+ *
+ * 目的：上下文压缩后，较早的对话会从模型「眼前」消失，但会话事件日志一直都在。
+ * 当用户消息看起来在引用旧记忆时，本插件自己检索日志，把带时间戳的原文片段
+ * 注入本轮上下文，模型直接拿着原文回答，不必再"没印象"。
+ *
+ * 触发（纯程序判断，不依赖模型）：
+ *   1. 回忆关键词：「你忘了 / 我说过 / 之前提过 / 还记得吗 / 你答应过 …」
+ *   2. 指代：「那个 / 那次 / 上次 / 这事 / 前几天 …」
+ *   3. 实体缺失：消息里的专有名词 / 英文词 / 引号词 / 路径，在当前上下文里没出现，
+ *      但历史索引里搜得到 → 判定为引用旧记忆
+ *
+ * 注入：agent/pre-step 时追加一条 user 角色消息（带时间戳与 seq），
+ * 每轮最多一次、最多 topK 条、总字数受 maxChars 限制。
+ */
+import { appendFile, mkdir, readFile, readdir } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import * as dshSession from '@deepseek-ai/dsh-session';
+import z from '@deepseek-ai/schemastery';
+import { createIndex } from './search.js';
+
+export const name = 'memory-trigger';
+
+/** 宿主会话格式版本：v4 起注入消息只接受「生产者自己的 kind」。 */
+const SESSION_FORMAT = typeof dshSession.SESSION_FORMAT_VERSION === 'number' ? dshSession.SESSION_FORMAT_VERSION : 0;
+
+const DEFAULT_KEYWORDS = [
+  '你忘', '忘了', '我说过', '你说过', '之前说过', '之前提过', '提过', '记得吗', '还记得',
+  '你答应过', '上次说的', '上次那个', '之前那个', '前面说的', '刚才说的', '回忆一下',
+];
+const DEFAULT_ANAPHORA = [
+  '那个', '那次', '这事', '这个事', '那件事', '上次', '之前', '前几天', '那天', '当时',
+  '你说的', '我说过的', '接着说', '继续那个',
+];
+/**
+ * 时间指代（正则）：命中后解析成时间窗，只检索该窗口内的事件。
+ * 例：3天前 / 11月3日 / 星期三 / 昨天 / 上周 / 上个月 / 3点 / 下午3点
+ */
+const DEFAULT_TIME_PATTERNS = [
+  '大前天', '前天', '昨天', '昨日', '今天', '今日',
+  '\\d{1,3}\\s*天前', '[一二两三四五六七八九十]{1,3}\\s*天前',
+  '\\d{1,2}\\s*周前', '[一二两三四五六七八九十]{1,2}\\s*周前',
+  '\\d{1,3}\\s*个月前', '[一二两三四五六七八九十]{1,3}\\s*个月前',
+  '最近\\s*\\d{1,2}\\s*天', '前\\s*\\d{1,2}\\s*天',
+  '上周', '上星期', '上个?月', '去年', '今年', '本月', '这个月',
+  '星期[一二三四五六日天1-7]', '礼拜[一二三四五六日天1-7]', '周[一二三四五六日天1-7]',
+  '\\d{1,2}\\s*月\\s*\\d{1,2}\\s*[日号]',
+  '(?:上午|下午|晚上|早上|中午)?\\s*\\d{1,2}\\s*[点时](?:\\s*半|\\s*\\d{1,2}\\s*分)?',
+];
+const NOISE_PREFIXES = ['Current runtime context', '[dsh-heart]', '眼前的对话快放不下'];
+
+function isNoise(text) {
+  const t = text.trimStart();
+  return NOISE_PREFIXES.some((p) => t.startsWith(p));
+}
+
+export const Config = z.object({
+  enabled: z.boolean().default(true).description('总开关。'),
+  keywords: z.array(z.string()).default(DEFAULT_KEYWORDS).description('回忆关键词（子串匹配）。'),
+  anaphora: z.array(z.string()).default(DEFAULT_ANAPHORA).description('指代词（子串匹配）。'),
+  timeAnaphora: z.array(z.string()).default(DEFAULT_TIME_PATTERNS).description('时间指代正则：命中后解析成时间窗，只搜该窗口内的事件。'),
+  entityTrigger: z.boolean().default(true).description('实体缺失触发：消息里的专有名词/英文词在历史里有、当前上下文没有时触发。'),
+  includeToolResults: z.boolean().default(true).description('把 tool/result 也纳入索引（只留前 4000 字）。'),
+  topK: z.number().step(1).min(1).max(8).default(3).description('每次注入的最大片段数。'),
+  maxChars: z.number().step(1).min(200).max(4000).default(1200).description('注入内容总字数上限。'),
+  minScore: z.number().min(0).default(1.2).description('BM25 最低分，低于此不注入。'),
+  scope: z.union([z.const('session'), z.const('all')]).default('all').description('检索范围：all = 全部历史会话（默认）；session = 只搜当前会话。'),
+  groupByProject: z.boolean().default(true).description('跨项目检索时按项目分组展示。'),
+  storeDir: z.string().default('').description('索引目录；留空 = <DSH_HOME>/memory-trigger。'),
+  logTriggers: z.boolean().default(true).description('把每次触发写入 trigger.log.jsonl。'),
+});
+
+function toText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const parts = [];
+  for (const p of content) if (p && p.type === 'text' && typeof p.text === 'string') parts.push(p.text);
+  return parts.join('\n');
+}
+
+function extractEntities(text) {
+  const out = new Set();
+  for (const m of text.matchAll(/[「"“]([^「」"”]{2,40})[」"”]/g)) out.add(m[1].trim());
+  for (const m of text.matchAll(/[A-Za-z][A-Za-z0-9_.\-]{2,}/g)) out.add(m[0]);
+  for (const m of text.matchAll(/[A-Za-z]:\\[^\s，。；]+/g)) out.add(m[0]);
+  return [...out].filter((s) => s.length >= 2);
+}
+
+function fmtTime(ts) {
+  const d = new Date(ts);
+  const pad = (n) => String(n).padStart(2, '0');
+  const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+  const time = `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  const days = Math.floor((Date.now() - ts) / 86400000);
+  const rel = days <= 0 ? '今天' : days === 1 ? '昨天' : `${days} 天前`;
+  return `${date} ${time}（${rel}）`;
+}
+
+const ROLE_LABEL = { user: '你说过', assistant: '我说过', tool: '工具结果' };
+
+/** 会话所属项目（取 cwd 的最后一段）。 */
+function projectOf(session) {
+  const cwd = session?.header?.cwd ?? session?.cwd ?? '';
+  if (!cwd) return '未知项目';
+  return basename(String(cwd)) || String(cwd);
+}
+
+/**
+ * 注入消息的来源标记。
+ *
+ * 会话格式 v3 起（本机是 v4）只认「生产者自己的 kind」：消息 source 必须是插件自己的名字，
+ * 旧的 { kind: 'plugin', plugin } 包装会被直接拒绝
+ * （format v4 message requires a producer-owned source kind），整轮运行失败。
+ * 所以这里固定用自家 kind，和 dsh-heart（kind: 'dsh-heart'）的做法一致。
+ */
+function memorySource() {
+  // v4 起只接受「生产者自己的 kind」；v3 及更早用旧的 plugin 包装。
+  if (SESSION_FORMAT >= 4) return { kind: 'memory-trigger' };
+  return { kind: 'plugin', plugin: 'memory-trigger' };
+}
+
+export function apply(ctx, config) {
+  const conf = config ?? {};
+  if (conf.enabled === false) {
+    ctx.logger?.info?.('dsh-memory-trigger: disabled');
+    return;
+  }
+  const storeDir = conf.storeDir || dshHomePath('memory-trigger');
+  const eventsDir = join(storeDir, 'events');
+  const logPath = join(storeDir, 'trigger.log.jsonl');
+  const index = createIndex();
+  const pending = new Map(); // agentId -> { text, at }
+  let loaded = false;
+
+  const logger = {
+    info: (m) => ctx.logger?.info?.('dsh-memory-trigger: ' + m),
+    warn: (m) => ctx.logger?.warn?.('dsh-memory-trigger: ' + m),
+  };
+
+  async function loadStore() {
+    try {
+      await mkdir(eventsDir, { recursive: true });
+      const files = await readdir(eventsDir);
+      for (const f of files) {
+        if (!f.endsWith('.jsonl')) continue;
+        const raw = await readFile(join(eventsDir, f), 'utf8');
+        for (const line of raw.split('\n')) {
+          if (!line.trim()) continue;
+          try {
+            const ev = JSON.parse(line);
+            index.add({ session: ev.session, project: ev.project, seq: ev.seq, ts: ev.ts, role: ev.role, text: ev.text });
+          } catch {
+            /* 跳过坏行 */
+          }
+        }
+      }
+      loaded = true;
+      logger.info(`index ready: ${index.size} events from ${files.length} files`);
+    } catch (error) {
+      logger.warn(`loadStore failed: ${String(error)}`);
+    }
+  }
+
+  function appendEvent(sessionId, ev) {
+    const line = JSON.stringify(ev) + '\n';
+    appendFile(join(eventsDir, `${sessionId}.jsonl`), line, 'utf8').catch(() => {});
+  }
+
+  // 实时捕获会话事件，增量补进索引（新消息不必等回填）
+  ctx.on('session/event', (session, event) => {
+    if (!loaded) return;
+    const sid = String(session?.id ?? session?.header?.id ?? 'unknown');
+    const project = projectOf(session);
+    try {
+      if (event?.type === 'user/message') {
+        const text = toText(event.data?.content);
+        const srcKind = event.data?.source?.kind;
+        if (!text || isNoise(text) || (srcKind !== undefined && srcKind !== 'user')) return;
+        const ev = { session: sid, project, seq: event.seq, ts: event.time, role: 'user', text };
+        index.add(ev);
+        appendEvent(sid, ev);
+      } else if (event?.type === 'assistant/message') {
+        const text = toText(event.data?.message?.content) || String(event.data?.text ?? '');
+        if (!text) return;
+        const ev = { session: sid, project, seq: event.seq, ts: event.time, role: 'assistant', text };
+        index.add(ev);
+        appendEvent(sid, ev);
+      } else if (event?.type === 'tool/result' && conf.includeToolResults !== false) {
+        // 工具输出很长，只留前 4000 字参与索引，避免淹没对话
+        const text = toText(event.data?.message?.content).slice(0, 4000);
+        if (!text) return;
+        const ev = { session: sid, project, seq: event.seq, ts: event.time, role: 'tool', text };
+        index.add(ev);
+        appendEvent(sid, ev);
+      }
+    } catch (error) {
+      logger.warn(`capture failed: ${String(error)}`);
+    }
+  });
+
+  // 判定：用户消息是否在引用旧记忆
+  ctx.on('agent/inbox/claimed', ({ agent, message }) => {
+    if (!loaded || !agent?.id) return;
+    try {
+    const text = toText(message?.content);
+    if (!text || text.length < 4) return;
+    const sessionId = String(agent?.session?.id ?? agent?.id);
+    const hits = triggerReason(text, conf, index, sessionId);
+    if (!hits) return;
+    const searchOpts = {
+      topK: conf.topK ?? 3,
+      minScore: conf.minScore ?? 1.2,
+      sessionId: (conf.scope ?? 'session') === 'session' ? sessionId : null,
+      since: hits.since ?? null,
+      until: hits.until ?? null,
+    };
+    let results = index.search(hits.query || text, searchOpts);
+    if (results.length === 0 && searchOpts.sessionId) {
+      // 当前会话没搜到：退一步搜全部历史会话（时间窗仍保留）
+      results = index.search(hits.query || text, { ...searchOpts, sessionId: null });
+    }
+    if (results.length === 0 && (searchOpts.since || searchOpts.until)) {
+      // 时间窗内没有：放开时间窗再搜一次，避免时间解析误差导致完全没结果
+      results = index.search(hits.query || text, { ...searchOpts, sessionId: null, since: null, until: null });
+    }
+    if (results.length === 0) {
+      // 未命中也要记日志，方便事后调词典/阈值
+      if (conf.logTriggers !== false) {
+        appendFile(
+          logPath,
+          JSON.stringify({ at: new Date().toISOString(), agent: agent.id, session: sessionId, kind: hits.kind, trigger: hits.trigger, query: hits.query || text, hits: 0, miss: true }) + '\n',
+          'utf8',
+        ).catch(() => {});
+      }
+      if (hits.kind !== 'keyword') return; // 指代/实体/时间没搜到就不打扰
+      pending.set(agent.id, { text: '[记忆检索] 没找到相关记录。可以换关键词用 session_event_search 再找一次，再回答。', at: Date.now() });
+      return;
+    }
+    pending.set(agent.id, { text: formatBlock(results, hits, conf), at: Date.now() });
+    if (conf.logTriggers !== false) {
+      appendFile(
+        logPath,
+        JSON.stringify({ at: new Date().toISOString(), agent: agent.id, session: sessionId, kind: hits.kind, trigger: hits.trigger, query: hits.query || text, hits: results.length }) + '\n',
+        'utf8',
+      ).catch(() => {});
+    }
+    } catch (error) {
+      // 判定阶段失败只记日志，不影响本轮对话
+      logger.warn(`trigger skipped: ${String(error)}`);
+    }
+  });
+
+  // 注入：进入新一轮时，把回忆片段作为一条 user 消息追加
+  ctx.on('agent/pre-step', async (payload, next) => {
+    const decision = await next();
+    try {
+      const { agent } = payload;
+      if (decision.kind !== 'enter' || !agent?.id) return decision;
+      const item = pending.get(agent.id);
+      if (!item) return decision;
+      pending.delete(agent.id);
+      if (Date.now() - item.at > 120000) return decision; // 太久没轮到的丢弃
+      const message = createUserMessage({
+        content: [{ type: 'text', text: item.text }],
+        source: memorySource(),
+      });
+      return { ...decision, messages: [...decision.messages, message] };
+    } catch (error) {
+      // 关键：注入失败只跳过，绝不让整轮运行失败
+      logger.warn(`inject skipped: ${String(error)}`);
+      return decision;
+    }
+  });
+
+  loadStore();
+}
+
+const CN_DIGITS = { 零: 0, 〇: 0, 一: 1, 二: 2, 两: 2, 三: 3, 四: 4, 五: 5, 六: 6, 七: 7, 八: 8, 九: 9, 十: 10 };
+const CN_WEEKDAY = { 一: 1, 二: 2, 三: 3, 四: 4, 五: 5, 六: 6, 日: 7, 天: 7, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7 };
+
+function cnNumber(raw) {
+  const s = String(raw ?? '').trim();
+  if (!s) return NaN;
+  if (/^\d+$/.test(s)) return Number(s);
+  if (s === '十') return 10;
+  const m = s.match(/^([一二两三四五六七八九])?十([一二三四五六七八九])?$/);
+  if (m) return (m[1] ? CN_DIGITS[m[1]] : 1) * 10 + (m[2] ? CN_DIGITS[m[2]] : 0);
+  return CN_DIGITS[s] ?? NaN;
+}
+
+function startOfDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+function endOfDay(ts) {
+  const d = new Date(ts);
+  d.setHours(23, 59, 59, 999);
+  return d.getTime();
+}
+function fmtDate(ts) {
+  const d = new Date(ts);
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+function dayWindow(ts) {
+  return { since: startOfDay(ts), until: endOfDay(ts), label: fmtDate(ts) };
+}
+function shiftDays(base, n) {
+  const d = new Date(base);
+  d.setDate(d.getDate() + n);
+  return d.getTime();
+}
+function shiftMonths(base, n) {
+  const d = new Date(base);
+  d.setMonth(d.getMonth() + n);
+  return d.getTime();
+}
+
+/** 把时间指代解析成 [since, until]；解析不出返回 null。 */
+export function parseTimeWindow(text, now = Date.now()) {
+  let m;
+  if (text.match(/大前天/)) return dayWindow(shiftDays(now, -3));
+  if (text.match(/前天/)) return dayWindow(shiftDays(now, -2));
+  if (text.match(/昨[天日]/)) return dayWindow(shiftDays(now, -1));
+  if (text.match(/今[天日]/)) return dayWindow(now);
+  if ((m = text.match(/(\d{1,3}|[一二两三四五六七八九十]{1,3})\s*天前/))) {
+    const n = cnNumber(m[1]);
+    if (n > 0) return dayWindow(shiftDays(now, -n));
+  }
+  if ((m = text.match(/(\d{1,2}|[一二两三四五六七八九十]{1,2})\s*周前/))) {
+    const n = cnNumber(m[1]);
+    if (n > 0) return dayWindow(shiftDays(now, -7 * n));
+  }
+  if ((m = text.match(/(\d{1,3}|[一二两三四五六七八九十]{1,3})\s*个月前/))) {
+    const n = cnNumber(m[1]);
+    if (n > 0) return dayWindow(shiftMonths(now, -n));
+  }
+  if ((m = text.match(/最近\s*(\d{1,2}|[一二两三四五六七八九十]{1,2})\s*天/))) {
+    const n = cnNumber(m[1]);
+    if (n > 0) return { since: startOfDay(shiftDays(now, -n)), until: now, label: `最近 ${n} 天` };
+  }
+  if ((m = text.match(/前\s*(\d{1,2}|[一二两三四五六七八九十]{1,2})\s*天/))) {
+    const n = cnNumber(m[1]);
+    if (n > 0) return dayWindow(shiftDays(now, -n));
+  }
+  if (text.match(/上周|上星期/)) {
+    const d = new Date(now);
+    const wd = (d.getDay() + 6) % 7; // 周一=0
+    const monday = shiftDays(now, -wd - 7);
+    return { since: startOfDay(monday), until: endOfDay(shiftDays(monday, 6)), label: '上周' };
+  }
+  if (text.match(/上个?月/)) {
+    const d = new Date(now);
+    return {
+      since: new Date(d.getFullYear(), d.getMonth() - 1, 1).getTime(),
+      until: new Date(d.getFullYear(), d.getMonth(), 0, 23, 59, 59, 999).getTime(),
+      label: '上个月',
+    };
+  }
+  if (text.match(/去年/)) {
+    const y = new Date(now).getFullYear() - 1;
+    return { since: new Date(y, 0, 1).getTime(), until: new Date(y, 11, 31, 23, 59, 59, 999).getTime(), label: `${y} 年` };
+  }
+  if (text.match(/今年/)) {
+    const y = new Date(now).getFullYear();
+    return { since: new Date(y, 0, 1).getTime(), until: now, label: `${y} 年至今` };
+  }
+  if (text.match(/本月|这个月/)) {
+    const d = new Date(now);
+    return { since: new Date(d.getFullYear(), d.getMonth(), 1).getTime(), until: now, label: '本月' };
+  }
+  if ((m = text.match(/(?:星期|礼拜|周)\s*([一二三四五六日天1-7])/))) {
+    const target = CN_WEEKDAY[m[1]];
+    if (target) {
+      const d = new Date(now);
+      const cur = d.getDay() === 0 ? 7 : d.getDay();
+      let back = cur - target;
+      if (back < 0) back += 7;
+      return dayWindow(shiftDays(now, -back));
+    }
+  }
+  if ((m = text.match(/(\d{1,2})\s*月\s*(\d{1,2})\s*[日号]/))) {
+    const mon = Number(m[1]) - 1;
+    const day = Number(m[2]);
+    if (mon >= 0 && mon < 12 && day >= 1 && day <= 31) {
+      const y = new Date(now).getFullYear();
+      let t = new Date(y, mon, day).getTime();
+      if (t > now) t = new Date(y - 1, mon, day).getTime();
+      return dayWindow(t);
+    }
+  }
+  if ((m = text.match(/(上午|下午|晚上|早上|中午)?\s*(\d{1,2})\s*[点时](?:\s*半|\s*(\d{1,2})\s*分)?/))) {
+    let hour = Number(m[2]);
+    let minute = 0;
+    if (/半/.test(m[0])) minute = 30;
+    else if (m[3]) minute = Number(m[3]);
+    if (/下午|晚上/.test(m[0]) && hour < 12) hour += 12;
+    if (hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59) {
+      const d = new Date(now);
+      d.setHours(hour, minute, 0, 0);
+      let t = d.getTime();
+      if (t > now + 3600000) t -= 86400000;
+      return { since: t - 3600000, until: t + 3600000, label: `${fmtDate(t)} 附近` };
+    }
+  }
+  return null;
+}
+
+/** 命中时间指代 → 返回触发信息（含时间窗）。 */
+function parseTimeTrigger(text, conf) {
+  const patterns = conf.timeAnaphora ?? DEFAULT_TIME_PATTERNS;
+  for (const src of patterns) {
+    let m = null;
+    try {
+      m = text.match(new RegExp(src));
+    } catch {
+      m = null;
+    }
+    if (!m) continue;
+    const win = parseTimeWindow(text);
+    if (win) return { trigger: String(m[0]).trim(), ...win };
+  }
+  return null;
+}
+
+/** 判断触发原因，返回 {kind, trigger, query, since?, until?, label?} 或 null */
+function triggerReason(text, conf, index, sessionId) {
+  const keywords = conf.keywords ?? DEFAULT_KEYWORDS;
+  for (const k of keywords) if (text.includes(k)) return { kind: 'keyword', trigger: k, query: text };
+  const time = parseTimeTrigger(text, conf);
+  if (time) return { kind: 'time', trigger: time.trigger, query: text, since: time.since, until: time.until, label: time.label };
+  const anaphora = conf.anaphora ?? DEFAULT_ANAPHORA;
+  const anaphoraHit = anaphora.find((a) => text.includes(a));
+  if (anaphoraHit) return { kind: 'anaphora', trigger: anaphoraHit, query: text };
+  if (conf.entityTrigger !== false) {
+    const ents = extractEntities(text);
+    const minScore = conf.minScore ?? 1.2;
+    const hits = ents.filter((e) => index.search(e, { topK: 1, minScore, sessionId }).length > 0);
+    if (hits.length > 0) return { kind: 'entity', trigger: hits[0], query: hits.join(' ') + ' ' + text };
+  }
+  return null;
+}
+
+function formatBlock(results, hits, conf) {
+  const maxChars = conf.maxChars ?? 1200;
+  const perItem = Math.max(120, Math.floor((maxChars - 300) / Math.max(1, results.length)));
+  const lines = [];
+  lines.push(`[记忆检索] 用户可能在引用过去的对话（触发：${hits.kind}/${hits.trigger}${hits.label ? `，时间窗：${hits.label}` : ''}）。从会话历史检索到 ${results.length} 条相关片段：`);
+  let n = 0;
+  const render = (r) => {
+    n += 1;
+    const body = r.doc.text.replace(/\s+/g, ' ').slice(0, perItem);
+    const proj = r.doc.project ? ` · 项目 ${r.doc.project}` : '';
+    lines.push(`${n}. ${fmtTime(r.doc.ts)} · ${ROLE_LABEL[r.doc.role] ?? r.doc.role} · seq ${r.doc.seq}${proj}`);
+    lines.push(`   「${body}」`);
+  };
+  if (conf.groupByProject !== false) {
+    const groups = new Map();
+    for (const r of results) {
+      const key = r.doc.project || '未知项目';
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(r);
+    }
+    if (groups.size > 1) {
+      for (const [proj, list] of groups) {
+        lines.push(`【项目：${proj}】`);
+        for (const r of list) render(r);
+      }
+    } else {
+      for (const r of results) render(r);
+    }
+  } else {
+    for (const r of results) render(r);
+  }
+  lines.push('请结合上述原文回答；需要更多细节时可用 session_event_read 读对应 seq，不要笼统说"记不清"。');
+  return lines.join('\n').slice(0, maxChars + 400);
+}

package/lib/search.js

@@ -0,0 +1,112 @@
+/**
+ * 轻量全文检索：中文 bigram + 英文词，BM25 打分，纯 JS、零依赖。
+ * 文档模型：{ session, seq, ts, role, text }
+ */
+
+const CJK = /[\u3400-\u9fff]/;
+
+/** 分词：英文/数字按词，中文按单字 + 双字 bigram。 */
+export function tokenize(text) {
+  const out = [];
+  const lower = String(text ?? '').toLowerCase();
+  const latin = lower.match(/[a-z0-9_][a-z0-9_.\-]{1,}/g) ?? [];
+  for (const w of latin) out.push(w);
+  const cjkRuns = lower.match(/[\u3400-\u9fff]+/g) ?? [];
+  for (const run of cjkRuns) {
+    for (let i = 0; i < run.length; i += 1) {
+      out.push(run[i]);
+      if (i + 1 < run.length) out.push(run.slice(i, i + 2));
+    }
+  }
+  return out;
+}
+
+export function createIndex() {
+  /** @type {Array<{session:string,seq:number,ts:number,role:string,text:string,tokens:string[],len:number}>} */
+  const docs = [];
+  /** @type {Map<string, number[]>} token -> doc indexes */
+  const postings = new Map();
+  /** 去重：同一会话同一 seq 只收一次（跨项目目录重复的会话文件） */
+  const seen = new Set();
+  let totalLen = 0;
+
+  function add(doc) {
+    if (!doc || typeof doc.text !== 'string') return;
+    const text = doc.text.trim();
+    if (!text) return;
+    const key = `${doc.session}|${doc.seq}|${doc.role}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const tokens = tokenize(text);
+    if (tokens.length === 0) return;
+    const idx = docs.length;
+    docs.push({ ...doc, text, tokens, len: tokens.length });
+    totalLen += tokens.length;
+    for (const t of tokens) {
+      let list = postings.get(t);
+      if (!list) postings.set(t, (list = []));
+      if (list[list.length - 1] !== idx) list.push(idx);
+    }
+  }
+
+  function search(query, opts = {}) {
+    const topK = opts.topK ?? 5;
+    const minScore = opts.minScore ?? 1.2;
+    const sessionFilter = opts.sessionId ?? null;
+    const since = opts.since ?? null;
+    const until = opts.until ?? null;
+    const terms = [...new Set(tokenize(query))].filter((t) => t.length > 1 || CJK.test(t));
+    if (terms.length === 0 || docs.length === 0) return [];
+    const N = docs.length;
+    const avgdl = totalLen / N || 1;
+    const k1 = 1.2;
+    const b = 0.75;
+    const scores = new Map();
+    for (const term of terms) {
+      const list = postings.get(term);
+      if (!list) continue;
+      const df = list.length;
+      const idf = Math.log(1 + (N - df + 0.5) / (df + 0.5));
+      for (const idx of list) {
+        const doc = docs[idx];
+        if (sessionFilter && doc.session !== sessionFilter) continue;
+        if (since && doc.ts < since) continue;
+        if (until && doc.ts > until) continue;
+        let tf = 0;
+        for (const t of doc.tokens) if (t === term) tf += 1;
+        if (tf === 0) continue;
+        const denom = tf + k1 * (1 - b + (b * doc.len) / avgdl);
+        scores.set(idx, (scores.get(idx) ?? 0) + idf * ((tf * (k1 + 1)) / denom));
+      }
+    }
+    const ranked = [...scores.entries()]
+      .map(([idx, score]) => ({ doc: docs[idx], score }))
+      .sort((a, b2) => b2.score - a.score || b2.doc.ts - a.doc.ts);
+
+    // 去重：同会话里内容高度相似（如 tool/result 与 assistant 复述）只留一条，优先 user 原话
+    const picked = [];
+    for (const item of ranked) {
+      if (picked.length >= topK) break;
+      if (item.score < minScore) break;
+      const dup = picked.some((p) => p.doc.session === item.doc.session && similarity(p.doc.text, item.doc.text) > 0.7);
+      if (dup) {
+        const i = picked.findIndex((p) => p.doc.session === item.doc.session && similarity(p.doc.text, item.doc.text) > 0.7);
+        if (i >= 0 && item.doc.role === 'user' && picked[i].doc.role !== 'user') picked[i] = item;
+        continue;
+      }
+      picked.push(item);
+    }
+    return picked;
+  }
+
+  return { add, search, get size() { return docs.length; }, docs };
+}
+
+function similarity(a, b) {
+  const sa = new Set(tokenize(a));
+  const sb = new Set(tokenize(b));
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let inter = 0;
+  for (const t of sa) if (sb.has(t)) inter += 1;
+  return inter / (sa.size + sb.size - inter);
+}

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "dsh-memory-trigger",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "DSH 记忆触发插件：上下文压缩后，用户引用旧记忆时自动检索会话历史并注入带时间戳的片段。",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./backfill": "./lib/backfill.mjs"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/search.js",
+    "lib/backfill.mjs",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "memory",
+    "context",
+    "bm25",
+    "recall"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/G4bri3lYang/dsh-memory-trigger.git"
+  },
+  "engines": {
+    "node": ">=22.15"
+  },
+  "scripts": {
+    "backfill": "node lib/backfill.mjs",
+    "selftest": "node lib/selftest.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}