@restregular/dsh-memory 0.16.2 → 0.17.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -2,6 +2,27 @@
2
2
 
3
3
  本项目的版本记录。安装 id 与 npm 版本一一对应。
4
4
 
5
+ ## 0.17.1 — memory_save 成功即把这条记忆记为「正文已注入」
6
+
7
+ - **现象**:在同一个会话里 `memory_save` 成功后,下一轮(或同一轮后续步骤)的召回会把刚保存的那条记忆再注入一遍,然后再被会话级去重标记。实况样本:某会话 turn 1 末尾保存一条发布记录,turn 2 第一步的召回又把它作为「相关记忆」塞回上下文,之后同一条再也不出现。
8
+ - **根因**:0.16.1 只把 `memory_get` 取正文记成 `content_injected`;`memory_save` 的正文其实也进了上下文 —— 写入语句就是模型产出的 `tool/call` 参数 —— 但保存路径没有写会话注入状态,于是下一次召回把它当成「还没注入过的新记忆」。
9
+ - **修复**:`session/event` 里跟踪 `memory_save` 的 `callId`;`tool/result` 成功、且能从结果里解析出记录 id 时(`getByIds` 再校验存在性),把该记录按 `updatedAt` 记为 `content_injected`。
10
+ - 只按 UUID 形态解析记录 id,不依赖结果文案,本地化 / 措辞改动不会让去重失效。
11
+ - 保存失败 / 被拒绝不标记;记录之后被更新(`updatedAt` 变化)仍会重新评估并重新注入。
12
+ - 去重标记独立于 `autoRecall` 开关,和 `memory_get` 的口径一致;compaction 时随会话状态一起清空。
13
+ - **审计**:保存成功时写一条 `kind=lifecycle / stage=content_pinned / reasonCode=saved_in_context` 事件(带 `operationId` = 这次 save 的 callId、`selected.contentIds`),面板按记忆 id 能查到「它为什么后面被去重跳过」。
14
+ - 回归测试:结果解析(保存 / 去重命中 / 非中文文案 / 无 id)、成功后下一次召回被去重且审计可见、保存失败不标记、版本变化重新注入、去重命中同样标记。
15
+
16
+ ## 0.17.0 — 会话去重状态持久化到工作区 `.dsh/dsh-memory`
17
+
18
+ - **状态现在可以跨插件重载 / 宿主重启恢复**:`InjectionState` 可按会话挂一个持久化 store,首次接触会话时读一次盘,之后写入由 store 合并。
19
+ - **位置**:`<会话工作区>/.dsh/dsh-memory/sessions/<session>.jsonl`。只存记录 id、状态、版本(`updatedAt`)和时间戳;**不存正文,也不存查询**(避免把凭据写进状态文件)。
20
+ - **运行效率**:JSONL 增量日志 + 默认 250ms 合并窗口,一次召回/摘要的多次标记只 append 一行;写延迟与状态大小无关。轮末与插件卸载会强制 flush。
21
+ - **存储效率**:行数 / 字节超过阈值时 compact 成一行快照,用临时文件 + rename 原子替换;每个工作区默认保留 30 天、最多 1000 个会话文件,首次接触该工作区时清理一次。
22
+ - **容错**:目录不可写、文件损坏、写盘失败都只退化为内存去重并告警一次,绝不阻断注入链路;`compaction` 清空状态时同步删掉对应文件。
23
+ - **接线**:`session/event` 与 `agent/pre-step` 都会在第一次拿到 `header.cwd` 时挂载 store;拿不到工作区时保持纯内存。配置项 `sessionState.{enabled,dir,debounceMs,maxAgeDays,maxFiles}` 可覆盖,默认开启并写到工作区。
24
+ - 回归测试:JSONL 往返、合并写一行、阈值 compact、evict 同步、remove/坏行容错、30 天清理、异常 sessionId 安全文件名;以及 `apply` 层“重载后仍去重、记录更新后重新注入”的端到端用例。
25
+
5
26
  ## 0.16.2 — memory_get 去重的审计与端到端覆盖
6
27
 
7
28
  - **补审计缺口**:所有候选都被会话级去重时,`renderRecallBlock` 返回 `null`,`dedupIds` 没有写进结果,审计只能看到 `dedupSkipped` 数量、看不到具体跳过了哪些 id。现在 `dedupIds` 在“全部去重”和“预算省略”路径上也会返回。
package/README.md CHANGED
@@ -239,6 +239,14 @@ memory_forget({ "id": "3f2a9c1d" }) // 按内容删:memory_forget({ q
239
239
 
240
240
  - 召回按 **sessionId + 记忆 id / 版本** 去重;只给过标签的记录,任务命中后可补正文;内容更新会重新评估。
241
241
  - `memory_get` 取到正文后,这条记忆会记成「正文已注入」;同一会话后续的普通召回 / 摘要 / 自动召回都不会再把同一段正文塞一遍。只取 `summary` / `tags` / 元数据不算正文,仍可被召回。
242
+ - `memory_save` **保存成功**同样算「正文已在上下文里」:写入语句(`content`)就是模型自己产出的 tool/call 参数,因此这条记录会立刻记成「正文已注入」,本会话后续的召回 / 摘要不会把刚保存的记忆原样再注入一次(去重命中既有记录时也一样)。保存失败不标记;记录之后被更新(`updatedAt` 变化)仍会重新评估。审计里会留一条 `content_pinned / saved_in_context` 的 lifecycle 事件,说明后面的「去重跳过」从哪来。
243
+ - **去重状态持久化**:状态写到会话工作区的插件目录
244
+ `<cwd>/.dsh/dsh-memory/sessions/<session>.jsonl`,插件重载 / 宿主重启后自动恢复;只有首次接触该会话时读一次盘。
245
+ - 只存记录 id、状态、版本(`updatedAt`)和时间戳,**不存正文,也不存查询**。
246
+ - JSONL 增量日志:默认 250ms 合并写一行,写延迟不随状态大小增长;行数 / 字节超过阈值时 compact 成一行快照(临时文件 + rename 原子替换)。
247
+ - 每个工作区默认保留 30 天、最多 1000 个会话文件;目录不可写或文件损坏时自动退化为内存去重,不阻断注入。
248
+ - 插件配置 `inject.sessionState.{enabled,dir,debounceMs,maxAgeDays,maxFiles}` 可覆盖默认值;默认开启。
249
+ - 工作区里的 `.dsh/` 已加入本仓库 `.gitignore`;其他项目按需自行忽略。
242
250
  - 被 `supersedes` 指向的旧记录不再进入 `memory_search`、`memory_list`、摘要、规则段和自动召回;`memory_get(id)` 与面板仍可查历史。需要历史检索时 `memory_search({ includeSuperseded: true })`。
243
251
  - 摘要排除 `kind=rule`;规则段实际进入系统提示的 id 会写进会话注入状态,recall 不再重复注入同一条规则。
244
252
  - 同一轮最多发生一次 signal 驱动召回;同 tag / 同 query 的第二个信号只记一条 `signal_dropped` 审计。
@@ -25,6 +25,7 @@
25
25
 
26
26
  import { createUserMessage } from '@deepseek-ai/dsh-llm'
27
27
 
28
+ import { join } from 'node:path'
28
29
  import {
29
30
  MemoryDigester,
30
31
  MemoryInjector,
@@ -45,6 +46,7 @@ import { renderRules, } from './rules.js'
45
46
  import { RulesDeltaInjector } from './rules-delta.js'
46
47
  import { POLICY_TEXT } from './policy.js'
47
48
  import { InjectionState } from './state.js'
49
+ import { createSessionStateStore } from './session-state-store.js'
48
50
  import {
49
51
  InjectAuditStore,
50
52
  auditBudget,
@@ -65,6 +67,7 @@ import {
65
67
  highRiskSignal,
66
68
  memoryGetRequestsContent,
67
69
  memoryGetResultIds,
70
+ memorySaveResultIds,
68
71
  textTagSignal,
69
72
  todoText,
70
73
  toolCallDescription,
@@ -72,6 +75,7 @@ import {
72
75
 
73
76
  } from './signals.js'
74
77
  import { normalizeInjectSettings, } from '../provider/inject-settings.js'
78
+ import { canonicalWorkspacePath } from '../provider/scope.js'
75
79
 
76
80
 
77
81
 
@@ -80,6 +84,21 @@ import { normalizeInjectSettings, } from '../provider/inject
80
84
 
81
85
                         
82
86
 
87
+
88
+             
89
+          
90
+
91
+
92
+
93
+                          
94
+
95
+              
96
+
97
+                
98
+
99
+                      
100
+
101
+
83
102
 
84
103
 
85
104
  /** provider 在注入侧能提供的那部分能力(多余的方法都用可选判断)。 */
@@ -131,6 +150,8 @@ export function apply(ctx , config = {}) {
131
150
  const callMeta = new Map ()
132
151
  /** memory_get 调用 → 这次是否取正文;tool/result 到达后用来写 content_injected。 */
133
152
  const memoryGetCalls = new Map ()
153
+ /** memory_save 调用中还没等到结果的 callId;成功后把被保存的记录记为 content_injected。 */
154
+ const memorySaveCalls = new Set ()
134
155
  const sessionScopes = new Map ()
135
156
  const sessionAutoScopes = new Map ()
136
157
  /** 本轮已经发生过的 signal 驱动召回:每轮最多一次,同 tag/query 也跳过。 */
@@ -145,6 +166,47 @@ export function apply(ctx , config = {}) {
145
166
  let systemPromptReady = false
146
167
  let attachedMemory = null
147
168
 
169
+ // ---- 去重状态持久化:<workspace>/.dsh/dsh-memory/sessions/<session>.jsonl ----
170
+ const stateConfig = config.sessionState ?? {}
171
+ const stateEnabled = stateConfig.enabled !== false
172
+ let stateWarned = false
173
+ /** attach 之后同步给摘要器补「已做过」标记(digester 在更后面创建)。 */
174
+ let onStateAttached
175
+
176
+ /** pre-step 的 agent / session/event 的 session 都能取到 header.cwd。 */
177
+ const workspaceOf = (value ) => {
178
+ const nested = (value )?.session?.header?.cwd
179
+ if (typeof nested === 'string' && nested.trim() !== '') return nested
180
+ const direct = (value )?.header?.cwd
181
+ return typeof direct === 'string' && direct.trim() !== '' ? direct : undefined
182
+ }
183
+
184
+ /** 第一次接触某个会话时挂上它的持久化 store;拿不到 cwd 就只走内存。 */
185
+ const attachSessionState = (sessionId , workspace ) => {
186
+ if (sessionId === undefined || !stateEnabled || injectionState.hasStore(sessionId)) return
187
+ let root = ''
188
+ try {
189
+ root = stateConfig.dir !== undefined && stateConfig.dir !== ''
190
+ ? stateConfig.dir
191
+ : workspace !== undefined ? join(canonicalWorkspacePath(workspace), '.dsh', 'dsh-memory') : ''
192
+ } catch { root = '' }
193
+ if (root === '') return
194
+ try {
195
+ injectionState.attach(sessionId, createSessionStateStore({
196
+ root,
197
+ sessionId,
198
+ ...(stateConfig.debounceMs !== undefined ? { debounceMs: stateConfig.debounceMs } : {}),
199
+ ...(stateConfig.maxAgeDays !== undefined ? { maxAgeDays: stateConfig.maxAgeDays } : {}),
200
+ ...(stateConfig.maxFiles !== undefined ? { maxFiles: stateConfig.maxFiles } : {}),
201
+ }))
202
+ onStateAttached?.(sessionId)
203
+ } catch (error) {
204
+ if (stateWarned) return
205
+ stateWarned = true
206
+ console.warn(`[dsh-memory] 初始化会话去重状态失败: ${error instanceof Error ? error.message : String(error)};本次退化为内存去重`)
207
+ }
208
+ }
209
+
148
210
  const attachAudit = (memory ) => {
149
211
  const target = memory
150
212
  if (!target || target === attachedMemory || typeof target.attachInjectAudit !== 'function') return
@@ -165,6 +227,8 @@ export function apply(ctx , config = {}) {
165
227
  } catch { /* 解绑失败不影响卸载 */ }
166
228
  attachedMemory = null
167
229
  audit.dispose()
230
+ // 卸载前把会话去重状态的待写增量刷掉;失败只告警,不影响卸载。
231
+ injectionState.dispose()
168
232
  }, 'dsh-memory: audit sink')
169
233
  } catch { /* 老宿主没有 ctx.effect */ }
170
234
 
@@ -229,6 +293,54 @@ export function apply(ctx , config = {}) {
229
293
  } catch { /* 去重状态是尽力而为,不能影响工具结果 */ }
230
294
  }
231
295
 
296
+ /** 记住这次 memory_save 的 callId;结果成功到达后才知道记录 id。 */
297
+ const rememberMemorySaveCall = (callId ) => {
298
+ if (typeof callId !== 'string' || callId === '') return
299
+ memorySaveCalls.add(callId)
300
+ if (memorySaveCalls.size > 500) {
301
+ const oldest = memorySaveCalls.values().next()
302
+ if (!oldest.done) memorySaveCalls.delete(oldest.value)
303
+ }
304
+ }
305
+
306
+ /**
307
+ * memory_save 成功 → 这条记忆的正文**已经由模型自己写进上下文**(写入语句就在
308
+ * tool/call 的参数里),和 memory_get 取正文同一口径记为 content_injected:
309
+ * 本会话后续的摘要 / 召回不再把刚写进去的内容原样塞回来(0.17.0 之前的实况是
310
+ * 下一轮 recall 会把保存的记忆再注入一遍,然后才被去重)。
311
+ *
312
+ * 只在保存成功时标记:失败 / 被拒绝的保存没有可信的记录 id,也没有"正文已在
313
+ * 上下文里"这一事实。与 memory_get 一样,去重标记独立于 autoRecall 开关。
314
+ */
315
+ const markMemorySaveContent = (
316
+ sessionId ,
317
+ memory ,
318
+ event ,
319
+ context = {},
320
+ ) => {
321
+ try {
322
+ const ids = memorySaveResultIds(event)
323
+ if (ids.length === 0 || typeof memory.getByIds !== 'function') return
324
+ const found = memory.getByIds(ids)
325
+ if (found.length === 0) return
326
+ injectionState.markContent(sessionId, found.map((record) => ({ id: record.id, updatedAt: record.updatedAt })))
327
+ // 这条状态变化要能从审计里查到,否则后续 recall 的 dedup 列表会显得没来由。
328
+ recordAudit({
329
+ kind: 'lifecycle',
330
+ channel: 'lifecycle',
331
+ stage: 'content_pinned',
332
+ outcome: 'success',
333
+ reasonCode: 'saved_in_context',
334
+ trigger: 'memory_save',
335
+ sessionId,
336
+ ...(context.callId !== undefined ? { operationId: context.callId } : {}),
337
+ ...(context.turn !== undefined ? { turn: context.turn } : {}),
338
+ ...(context.step !== undefined ? { step: context.step } : {}),
339
+ selected: { contentIds: found.map((record) => record.id), hintIds: [], count: found.length },
340
+ })
341
+ } catch { /* 去重状态是尽力而为,不能影响工具结果 */ }
342
+ }
343
+
232
344
  /** 记录本会话最近用过的工具名,给流程索引做触发词匹配。 */
233
345
  const rememberProcedureTool = (sessionId , tool ) => {
234
346
  const recent = procedureTools.get(sessionId) ?? []
@@ -402,6 +514,10 @@ export function apply(ctx , config = {}) {
402
514
  limit: 200,
403
515
  })
404
516
  })
517
+ // 持久化状态恢复后,把「摘要已做过」同步给摘要器,避免插件重载后重复注入。
518
+ onStateAttached = (sessionId) => {
519
+ if (injectionState.digestDoneOf(sessionId)) digester.seedDone(sessionId)
520
+ }
405
521
 
406
522
  // 规则增量:一个激活一个实例,跨轮记住每条规则上一轮的样子(编辑后才补提醒)。
407
523
  const rulesDelta = new RulesDeltaInjector()
@@ -419,6 +535,8 @@ export function apply(ctx , config = {}) {
419
535
  const data = (event )?.data ?? {}
420
536
  const memory = ctx.get('memory')
421
537
  if (memory) attachAudit(memory)
538
+ // 先挂持久化 store:compaction 的 clear 要能删到对应文件。
539
+ attachSessionState(sessionId, workspaceOf(session))
422
540
 
423
541
  // 记忆工具调用先落一条锚点审计:即使自动召回关闭、或该工具没有命中
424
542
  // 任何触发标签,用户也能从审计面板/记忆视图精确跳回轨迹里的那一次调用。
@@ -444,6 +562,7 @@ export function apply(ctx , config = {}) {
444
562
  for (const key of tagCache.keys()) if (key.startsWith(`${sessionId}|`)) tagCache.delete(key)
445
563
  callMeta.clear()
446
564
  memoryGetCalls.clear()
565
+ memorySaveCalls.clear()
447
566
  return
448
567
  }
449
568
 
@@ -451,13 +570,24 @@ export function apply(ctx , config = {}) {
451
570
  // 普通每轮召回 / 摘要仍会注入同一段正文。这里在 autoRecall 闸门前记录。
452
571
  if (type === 'tool/call' && data.name === 'memory_get') {
453
572
  rememberMemoryGetCall(data.callId, memoryGetRequestsContent(data.arguments))
573
+ } else if (type === 'tool/call' && data.name === 'memory_save') {
574
+ rememberMemorySaveCall(data.callId)
454
575
  } else if (type === 'tool/result') {
455
576
  const callId = (data.message )?.source?.callId
456
577
  if (typeof callId === 'string') {
457
578
  const takesContent = memoryGetCalls.get(callId)
458
579
  memoryGetCalls.delete(callId)
459
- if (takesContent === true && memory !== undefined && !toolResultFailure(event).isError) {
580
+ const isError = toolResultFailure(event).isError
581
+ if (takesContent === true && memory !== undefined && !isError) {
460
582
  markMemoryGetContent(sessionId, memory, event)
583
+ } else if (memorySaveCalls.delete(callId) && memory !== undefined && !isError) {
584
+ const turn = typeof data.turn === 'number' ? data.turn : undefined
585
+ const step = typeof data.step === 'number' ? data.step : undefined
586
+ markMemorySaveContent(sessionId, memory, event, {
587
+ callId,
588
+ ...(turn !== undefined ? { turn } : {}),
589
+ ...(step !== undefined ? { step } : {}),
590
+ })
461
591
  }
462
592
  }
463
593
  }
@@ -605,6 +735,8 @@ export function apply(ctx , config = {}) {
605
735
  let maxStep = 0
606
736
  let pendingNudge = false
607
737
  ctx.on('agent/turn-stopping', () => {
738
+ // 轮末把待写的去重增量刷掉:即使下一轮开始前进程退出,状态也只丢一个窗口。
739
+ injectionState.flushAll()
608
740
  if (!enabled || !settingsOf().turnEnd.enabled) return
609
741
  if (maxStep >= 2) pendingNudge = true
610
742
  })
@@ -628,6 +760,8 @@ export function apply(ctx , config = {}) {
628
760
  maxStep = Math.max(maxStep, step)
629
761
 
630
762
  const sessionId = sessionIdOf(agent)
763
+ // 第一步接触会话时恢复持久化去重状态(读盘只发生一次)。
764
+ attachSessionState(sessionId, workspaceOf(agent))
631
765
  if (sessionId !== undefined) rulesStepStart.set(sessionId, stepStartedAt)
632
766
  const scopes = readScopesFor(memory, agent)
633
767
  if (sessionId !== undefined && scopes !== undefined) sessionScopes.set(sessionId, [...scopes])
@@ -771,6 +905,8 @@ export function apply(ctx , config = {}) {
771
905
  digestStats = rendered?.stats
772
906
  return rendered
773
907
  })
908
+ // 失败也记 done(与内存行为一致:摘要不逐轮重试);落盘后重载不再重复发。
909
+ if (sessionId !== undefined && outcome.status !== 'skipped') injectionState.markDigestDone(sessionId)
774
910
  if (outcome.status === 'failed') {
775
911
  stage(auditBase('digest', {
776
912
  kind: 'evaluation', stage: 'source_load', outcome: 'failed', reasonCode: outcome.errorCode,
@@ -527,6 +527,15 @@ export class MemoryDigester {
527
527
  }
528
528
  }
529
529
 
530
+ /** 从持久化状态恢复「这个会话已经做过摘要」,避免插件重载后重复注入。 */
531
+ seedDone(sessionId ) {
532
+ if (sessionId !== undefined) this.markDone(sessionId)
533
+ }
534
+
535
+ isDone(sessionId ) {
536
+ return sessionId !== undefined && this.done.has(sessionId)
537
+ }
538
+
530
539
  /** 上下文被压缩/重建后重新允许摘要评估(旧摘要可能已不在上下文里)。 */
531
540
  reset(sessionId ) {
532
541
  if (sessionId !== undefined) this.done.delete(sessionId)
@@ -0,0 +1,332 @@
1
+ /**
2
+ * 会话级注入去重状态的持久化。
3
+ *
4
+ * 位置:<workspace>/.dsh/dsh-memory/sessions/<session>.jsonl
5
+ *
6
+ * 为什么不是"每次改都重写 JSON":
7
+ * - 一次召回/摘要会标记多条;全量重写会把 I/O 放大到 O(状态大小)。
8
+ * - 这里用 JSONL 增量日志:合并窗口(默认 250ms)内多次修改只 append 一行,
9
+ * 写延迟与状态大小无关。
10
+ * - 行数 / 字节超过阈值时 compact 成一行快照(临时文件 + rename,原子替换),
11
+ * 文件不会无限增长。
12
+ *
13
+ * 行格式(短键,减小体积):
14
+ * 快照 {"v":1,"d":1,"e":[["id",2,version,at],...]}
15
+ * 增量 {"d":1,"e":[...]}
16
+ * status: 1=hint_injected, 2=content_injected; d=1 表示本会话摘要已做过
17
+ *
18
+ * 只存记录 id / 状态 / 版本 / 时间戳与摘要标记,不落正文,也不落 lastQuery
19
+ * (查询可能含凭据)。
20
+ *
21
+ * 容错:读/写/清理任何一步失败都只退化为内存状态并告警一次,绝不把异常抛回
22
+ * 注入链路。目录不可写时同样退化。
23
+ */
24
+ import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
25
+ import { join } from 'node:path'
26
+ import { createHash } from 'node:crypto'
27
+
28
+
29
+ const STATUS_CODE = {
30
+ hint_injected: 1,
31
+ content_injected: 2,
32
+ }
33
+ const STATUS_BY_CODE = {
34
+ 1: 'hint_injected',
35
+ 2: 'content_injected',
36
+ }
37
+ const SNAPSHOT_VERSION = 1
38
+ const DEFAULT_DEBOUNCE_MS = 250
39
+ const DEFAULT_MAX_AGE_DAYS = 30
40
+ const DEFAULT_MAX_FILES = 1000
41
+ const DEFAULT_COMPACT_MIN_LINES = 200
42
+ const DEFAULT_COMPACT_MAX_BYTES = 512 * 1024
43
+ const DAY_MS = 86_400_000
44
+
45
+ /** 每个工作区只清理一次;清理是 best-effort,失败不影响读写。 */
46
+ const prunedRoots = new Set ()
47
+
48
+
49
+                    
50
+
51
+
52
+           
53
+
54
+                
55
+
56
+                      
57
+
58
+                    
59
+
60
+                     
61
+
62
+
63
+
64
+
65
+
66
+ export function createSessionStateStore(options ) {
67
+ return new JsonlSessionStateStore(options)
68
+ }
69
+
70
+
71
+
72
+
73
+
74
+
75
+
76
+
77
+
78
+ function encodeEntry(entry ) {
79
+ return [entry.id, STATUS_CODE[entry.status], entry.version, entry.at]
80
+ }
81
+
82
+ function decodeEntry(raw ) {
83
+ if (!Array.isArray(raw) || raw.length < 4) return undefined
84
+ const [id, code, version, at] = raw
85
+ if (typeof id !== 'string' || id === '') return undefined
86
+ const status = typeof code === 'number' ? STATUS_BY_CODE[code] : undefined
87
+ if (status === undefined || typeof version !== 'number' || typeof at !== 'number') return undefined
88
+ return { id, status, version, at }
89
+ }
90
+
91
+ /** 会话 id 通常已是 UUID;异常字符换成 `_`,超长/被改写的再加 8 位 hash 防碰撞。 */
92
+ function safeName(sessionId ) {
93
+ const cleaned = sessionId.replace(/[^A-Za-z0-9._-]+/g, '_').slice(0, 80)
94
+ if (cleaned === sessionId && cleaned !== '') return cleaned
95
+ const base = cleaned === '' ? 'session' : cleaned.slice(0, 64)
96
+ return `${base}-${createHash('sha1').update(sessionId).digest('hex').slice(0, 8)}`
97
+ }
98
+
99
+ class JsonlSessionStateStore {
100
+ dir
101
+ file
102
+ debounceMs
103
+ maxAgeDays
104
+ maxFiles
105
+ compactMinLines
106
+ compactMaxBytes
107
+ now
108
+ warn
109
+ /** 权威内存副本:load 出来 + append 合并进来的全部条目。 */
110
+ entries = new Map ()
111
+ /** 待写增量(按 id 合并);flush 后清空。 */
112
+ pending = new Map ()
113
+ digestDone = false
114
+ pendingDigestDone = false
115
+ lines = 0
116
+ bytes = 0
117
+ timer
118
+ loaded = false
119
+ disabled = false
120
+ warned = false
121
+
122
+ constructor(options ) {
123
+ this.dir = join(options.root, 'sessions')
124
+ this.file = join(this.dir, `${safeName(options.sessionId)}.jsonl`)
125
+ this.debounceMs = Math.max(0, options.debounceMs ?? DEFAULT_DEBOUNCE_MS)
126
+ this.maxAgeDays = Math.max(1, options.maxAgeDays ?? DEFAULT_MAX_AGE_DAYS)
127
+ this.maxFiles = Math.max(1, options.maxFiles ?? DEFAULT_MAX_FILES)
128
+ this.compactMinLines = Math.max(10, options.compactMinLines ?? DEFAULT_COMPACT_MIN_LINES)
129
+ this.compactMaxBytes = Math.max(4096, options.compactMaxBytes ?? DEFAULT_COMPACT_MAX_BYTES)
130
+ this.now = options.now ?? Date.now
131
+ this.warn = options.warn ?? ((message) => console.warn(message))
132
+ }
133
+
134
+ load() {
135
+ if (this.loaded) return this.snapshot()
136
+ this.loaded = true
137
+ this.prune()
138
+ try {
139
+ if (!existsSync(this.file)) return undefined
140
+ const text = readFileSync(this.file, 'utf8')
141
+ if (text.trim() === '') return undefined
142
+ const entries = new Map ()
143
+ let lines = 0
144
+ for (const line of text.split('\n')) {
145
+ const trimmed = line.trim()
146
+ if (trimmed === '') continue
147
+ lines += 1
148
+ let wire
149
+ try { wire = JSON.parse(trimmed) } catch { continue }
150
+ if (wire.v === SNAPSHOT_VERSION) {
151
+ entries.clear()
152
+ this.digestDone = wire.d === 1
153
+ } else if (wire.d === 1) {
154
+ this.digestDone = true
155
+ }
156
+ if (Array.isArray(wire.e)) {
157
+ for (const raw of wire.e) {
158
+ const entry = decodeEntry(raw)
159
+ if (entry !== undefined) entries.set(entry.id, entry)
160
+ }
161
+ }
162
+ }
163
+ for (const [id, entry] of entries) this.entries.set(id, entry)
164
+ this.lines = lines
165
+ this.bytes = Buffer.byteLength(text)
166
+ return this.snapshot()
167
+ } catch (error) {
168
+ this.disable('读取会话去重状态失败', error)
169
+ return undefined
170
+ }
171
+ }
172
+
173
+ append(entries ) {
174
+ if (this.disabled) return
175
+ this.load()
176
+ for (const entry of entries) {
177
+ this.entries.set(entry.id, entry)
178
+ this.pending.set(entry.id, entry)
179
+ }
180
+ if (this.pending.size === 0) return
181
+ this.schedule()
182
+ }
183
+
184
+ markDigestDone() {
185
+ if (this.disabled) return
186
+ this.load()
187
+ if (this.digestDone && !this.pendingDigestDone) return
188
+ this.digestDone = true
189
+ this.pendingDigestDone = true
190
+ this.schedule()
191
+ }
192
+
193
+ evict(ids ) {
194
+ for (const id of ids) {
195
+ this.entries.delete(id)
196
+ this.pending.delete(id)
197
+ }
198
+ }
199
+
200
+ flush() {
201
+ this.stopTimer()
202
+ if (this.disabled) return
203
+ if (this.pending.size === 0 && !this.pendingDigestDone) return
204
+ try {
205
+ this.ensureDir()
206
+ // 第一次写(或文件被清空)直接写一行快照,保证 load 时一定有基线。
207
+ if (!existsSync(this.file) || this.lines === 0) {
208
+ this.compact()
209
+ return
210
+ }
211
+ const line = {
212
+ ...(this.pendingDigestDone ? { d: 1 } : {}),
213
+ ...(this.pending.size > 0 ? { e: [...this.pending.values()].map(encodeEntry) } : {}),
214
+ }
215
+ const text = `${JSON.stringify(line)}\n`
216
+ appendFileSync(this.file, text, 'utf8')
217
+ this.lines += 1
218
+ this.bytes += Buffer.byteLength(text)
219
+ this.clearPending()
220
+ if (this.needCompact()) this.compact()
221
+ } catch (error) {
222
+ this.disable('写入会话去重状态失败', error)
223
+ }
224
+ }
225
+
226
+ remove() {
227
+ this.stopTimer()
228
+ this.pending.clear()
229
+ this.pendingDigestDone = false
230
+ this.digestDone = false
231
+ this.entries.clear()
232
+ this.lines = 0
233
+ this.bytes = 0
234
+ this.loaded = false
235
+ try {
236
+ rmSync(this.file, { force: true })
237
+ rmSync(`${this.file}.tmp`, { force: true })
238
+ } catch { /* best effort */ }
239
+ }
240
+
241
+ dispose() {
242
+ this.flush()
243
+ this.stopTimer()
244
+ }
245
+
246
+ snapshot() {
247
+ return { entries: [...this.entries.values()], digestDone: this.digestDone }
248
+ }
249
+
250
+ schedule() {
251
+ if (this.timer !== undefined) return
252
+ this.timer = setTimeout(() => {
253
+ this.timer = undefined
254
+ this.flush()
255
+ }, this.debounceMs)
256
+ // 不要让一个待写状态把进程/测试挂住。
257
+ ;(this.timer ).unref?.()
258
+ }
259
+
260
+ stopTimer() {
261
+ if (this.timer === undefined) return
262
+ clearTimeout(this.timer)
263
+ this.timer = undefined
264
+ }
265
+
266
+ clearPending() {
267
+ this.pending.clear()
268
+ this.pendingDigestDone = false
269
+ }
270
+
271
+ needCompact() {
272
+ const lineLimit = Math.max(this.compactMinLines, this.entries.size * 2)
273
+ return this.lines >= lineLimit || this.bytes >= this.compactMaxBytes
274
+ }
275
+
276
+ compact() {
277
+ this.ensureDir()
278
+ const line = {
279
+ v: SNAPSHOT_VERSION,
280
+ ...(this.digestDone ? { d: 1 } : {}),
281
+ e: [...this.entries.values()].map(encodeEntry),
282
+ }
283
+ const text = `${JSON.stringify(line)}\n`
284
+ const tmp = `${this.file}.tmp`
285
+ writeFileSync(tmp, text, 'utf8')
286
+ renameSync(tmp, this.file)
287
+ this.clearPending()
288
+ this.lines = 1
289
+ this.bytes = Buffer.byteLength(text)
290
+ }
291
+
292
+ ensureDir() {
293
+ if (!existsSync(this.dir)) mkdirSync(this.dir, { recursive: true })
294
+ }
295
+
296
+ prune() {
297
+ if (prunedRoots.has(this.dir)) return
298
+ prunedRoots.add(this.dir)
299
+ if (!existsSync(this.dir)) return
300
+ try {
301
+ const cutoff = this.now() - this.maxAgeDays * DAY_MS
302
+ const current = this.file.slice(this.dir.length + 1)
303
+ const kept = []
304
+ for (const name of readdirSync(this.dir)) {
305
+ if (!name.endsWith('.jsonl') || name === current) continue
306
+ const path = join(this.dir, name)
307
+ let mtime = 0
308
+ try { mtime = statSync(path).mtimeMs } catch { continue }
309
+ if (mtime < cutoff) rmSync(path, { force: true })
310
+ else kept.push({ path, mtime })
311
+ }
312
+ // 当前会话也占一个名额;超出上限时删最旧的。
313
+ const over = kept.length - (this.maxFiles - 1)
314
+ if (over > 0) {
315
+ kept.sort((a, b) => a.mtime - b.mtime)
316
+ for (const item of kept.slice(0, over)) rmSync(item.path, { force: true })
317
+ }
318
+ } catch (error) {
319
+ this.disable('清理旧会话去重状态失败', error)
320
+ }
321
+ }
322
+
323
+ disable(what , error ) {
324
+ this.disabled = true
325
+ if (this.warned) return
326
+ this.warned = true
327
+ this.warn(`[dsh-memory] ${what}: ${error instanceof Error ? error.message : String(error)};本次退化为内存去重`)
328
+ }
329
+ }
330
+
331
+
332
+ //# sourceURL=source/memory-inject/src/session-state-store.ts
@@ -420,6 +420,36 @@ export function memoryGetResultIds(event ) {
420
420
  return ids.slice(0, 50)
421
421
  }
422
422
 
423
+ /** 记录 id 的形态:`newId()` 生成 randomUUID,这里只认完整 UUID。 */
424
+ const RECORD_ID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi
425
+
426
+ /**
427
+ * 从 `memory_save` 的 tool/result 里取这次写入 / 去重命中的记录 id。
428
+ *
429
+ * 工具结果的渲染只有两种形态:「已保存记忆 <id> @ <scope>」与
430
+ * 「已更新既有记忆(内容相同,去重):<id> @ <scope>」,id 是 randomUUID。
431
+ * 这里**不按文案匹配**(本地化/措辞改动不该让去重失效),只按 UUID 形态取候选;
432
+ * 调用方还会用 `getByIds` 校验一次存在性,所以 scope 名字里的偶然片段不会误伤。
433
+ */
434
+ export function memorySaveResultIds(event ) {
435
+ const data = (event )?.data
436
+ const message = data?.message
437
+ const text = Array.isArray(message?.content)
438
+ ? message.content.filter((block) => block?.type === 'text' && typeof block.text === 'string').map((block) => block.text ).join('\n')
439
+ : ''
440
+ if (text === '') return []
441
+ const seen = new Set ()
442
+ const ids = []
443
+ for (const match of text.matchAll(RECORD_ID_PATTERN)) {
444
+ const id = match[0]
445
+ if (seen.has(id)) continue
446
+ seen.add(id)
447
+ ids.push(id)
448
+ if (ids.length >= 10) break
449
+ }
450
+ return ids
451
+ }
452
+
423
453
  /**
424
454
  * 每个会话只保留**最新一条未消费**的信号;相同 key 不重复排队。
425
455
  * `take()` 消费后保留 lastKey,同一失败不会因为重复事件反复搜索。
@@ -9,6 +9,10 @@
9
9
  *
10
10
  * 版本 = record.updatedAt。内容更新后允许重新注入;上下文重建(压缩/新会话)
11
11
  * 由调用方 clear(),绝不用"历史上出现过"代替"当前仍在上下文里"。
12
+ *
13
+ * 0.17.0 起可挂一个按会话的持久化 store(见 session-state-store.ts):状态在
14
+ * 插件重载 / 宿主重启后仍能恢复;读盘只在第一次接触该会话时发生,写入由 store
15
+ * 自己做合并与阈值 compact。
12
16
  */
13
17
 
14
18
 
@@ -29,6 +33,34 @@
29
33
 
30
34
 
31
35
 
36
+ /** 一个会话的可持久化状态:只存去重条目与会话摘要是否做过(不落正文、不落查询)。 */
37
+
38
+
39
+                 
40
+
41
+
42
+
43
+ /**
44
+ * 会话状态存储的最小接口。实现必须容错:读失败/写失败只能退化为内存状态,
45
+ * 绝不能把异常抛回注入链路。
46
+ */
47
+
48
+                    
49
+
50
+          
51
+
52
+                        
53
+
54
+                          
55
+
56
+                     
57
+
58
+                    
59
+
60
+             
61
+
62
+
63
+
32
64
 
33
65
 
34
66
 
@@ -46,6 +78,53 @@ const MAX_ENTRIES = 4000
46
78
 
47
79
  export class InjectionState {
48
80
  sessions = new Map ()
81
+ stores = new Map ()
82
+ /** 摘要每个会话只注入一次;这个标记也持久化,插件重载后不重复发。 */
83
+ digestDone = new Set ()
84
+
85
+ /** 挂上按会话的持久化 store;重复 attach 是 no-op。 */
86
+ attach(sessionId , store ) {
87
+ if (sessionId === undefined || this.stores.has(sessionId)) return
88
+ const state = this.stateOf(sessionId)
89
+ this.stores.set(sessionId, store)
90
+ let snapshot
91
+ try {
92
+ snapshot = store.load()
93
+ } catch { /* store 自己应容错;这里再兜一层 */ }
94
+ if (snapshot !== undefined) {
95
+ for (const entry of snapshot.entries) {
96
+ const previous = state.entries.get(entry.id)
97
+ if (previous === undefined || entry.at >= previous.at) {
98
+ state.entries.set(entry.id, { status: entry.status, version: entry.version, at: entry.at })
99
+ }
100
+ }
101
+ this.trim(state, sessionId)
102
+ }
103
+ if (snapshot?.digestDone === true) this.markDigest(sessionId)
104
+ }
105
+
106
+ hasStore(sessionId ) {
107
+ return sessionId !== undefined && this.stores.has(sessionId)
108
+ }
109
+
110
+ /** 摘要是否已经做过(含持久化恢复的标记)。 */
111
+ digestDoneOf(sessionId ) {
112
+ return sessionId !== undefined && this.digestDone.has(sessionId)
113
+ }
114
+
115
+ /** 摘要实际做过一次后调用:标记并尽快落盘。 */
116
+ markDigestDone(sessionId ) {
117
+ if (sessionId === undefined || this.digestDone.has(sessionId)) return
118
+ this.markDigest(sessionId)
119
+ this.storeOf(sessionId)?.markDigestDone()
120
+ }
121
+
122
+ markDigest(sessionId ) {
123
+ this.digestDone.add(sessionId)
124
+ if (this.digestDone.size <= MAX_SESSIONS) return
125
+ const oldest = this.digestDone.values().next()
126
+ if (!oldest.done) this.digestDone.delete(oldest.value)
127
+ }
49
128
 
50
129
  stateOf(sessionId ) {
51
130
  const key = sessionId ?? '__unknown__'
@@ -55,32 +134,53 @@ export class InjectionState {
55
134
  this.sessions.set(key, state)
56
135
  if (this.sessions.size > MAX_SESSIONS) {
57
136
  const oldest = this.sessions.keys().next()
58
- if (!oldest.done) this.sessions.delete(oldest.value)
137
+ if (!oldest.done) {
138
+ // 状态被容量淘汰时,先把该会话的待写增量刷掉,再释放 store;文件保留给下次加载。
139
+ const store = this.stores.get(oldest.value)
140
+ if (store !== undefined) {
141
+ try { store.dispose() } catch { /* best effort */ }
142
+ this.stores.delete(oldest.value)
143
+ }
144
+ this.digestDone.delete(oldest.value)
145
+ this.sessions.delete(oldest.value)
146
+ }
59
147
  }
60
148
  }
61
149
  return state
62
150
  }
63
151
 
152
+ storeOf(sessionId ) {
153
+ return sessionId === undefined ? undefined : this.stores.get(sessionId)
154
+ }
155
+
64
156
  /** 记录"只注入了标签"——正文仍未加载。 */
65
157
  markHint(sessionId , records ) {
66
158
  const state = this.stateOf(sessionId)
67
159
  const now = Date.now()
160
+ const changed = []
68
161
  for (const record of records) {
69
162
  const previous = state.entries.get(record.id)
70
163
  if (previous?.status === 'content_injected') continue
71
- state.entries.set(record.id, { status: 'hint_injected', version: record.updatedAt, at: now })
164
+ const entry = { status: 'hint_injected' , version: record.updatedAt, at: now }
165
+ state.entries.set(record.id, entry)
166
+ changed.push({ id: record.id, ...entry })
72
167
  }
73
- this.trim(state)
168
+ if (changed.length > 0) this.storeOf(sessionId)?.append(changed)
169
+ this.trim(state, sessionId)
74
170
  }
75
171
 
76
172
  /** 记录"正文已注入"(hint 状态被正文覆盖)。 */
77
173
  markContent(sessionId , records ) {
78
174
  const state = this.stateOf(sessionId)
79
175
  const now = Date.now()
176
+ const changed = []
80
177
  for (const record of records) {
81
- state.entries.set(record.id, { status: 'content_injected', version: record.updatedAt, at: now })
178
+ const entry = { status: 'content_injected' , version: record.updatedAt, at: now }
179
+ state.entries.set(record.id, entry)
180
+ changed.push({ id: record.id, ...entry })
82
181
  }
83
- this.trim(state)
182
+ if (changed.length > 0) this.storeOf(sessionId)?.append(changed)
183
+ this.trim(state, sessionId)
84
184
  }
85
185
 
86
186
  /**
@@ -121,12 +221,36 @@ export class InjectionState {
121
221
  }
122
222
 
123
223
  setLastQuery(sessionId , query ) {
224
+ // lastQuery 只用于同一进程内的重复检索保护;不落盘(查询可能含凭据)。
124
225
  this.stateOf(sessionId).lastQuery = query
125
226
  }
126
227
 
127
228
  /** 上下文重建(压缩/重置/新会话)时清空,不能沿用错误的去重状态。 */
128
229
  clear(sessionId ) {
129
- this.sessions.delete(sessionId ?? '__unknown__')
230
+ const key = sessionId ?? '__unknown__'
231
+ const store = this.stores.get(key)
232
+ if (store !== undefined) {
233
+ try { store.remove() } catch { /* 删文件失败不影响内存清空 */ }
234
+ this.stores.delete(key)
235
+ }
236
+ this.sessions.delete(key)
237
+ this.digestDone.delete(key)
238
+ }
239
+
240
+ /** 插件卸载 / 轮末:把每个会话的待写增量都刷掉。 */
241
+ flushAll() {
242
+ for (const store of this.stores.values()) {
243
+ try { store.flush() } catch { /* 持久化失败只记在 store 里 */ }
244
+ }
245
+ }
246
+
247
+ dispose() {
248
+ for (const store of this.stores.values()) {
249
+ try { store.dispose() } catch { /* 持久化失败不影响卸载 */ }
250
+ }
251
+ this.stores.clear()
252
+ this.sessions.clear()
253
+ this.digestDone.clear()
130
254
  }
131
255
 
132
256
  statusOf(sessionId , id ) {
@@ -149,13 +273,16 @@ export class InjectionState {
149
273
  }
150
274
  }
151
275
 
152
- trim(state ) {
276
+ trim(state , sessionId ) {
153
277
  if (state.entries.size <= MAX_ENTRIES) return
154
278
  // Map 保留插入顺序;淘汰最旧的一批即可(状态只用于去重,丢了最多多注入一次)。
279
+ const evicted = []
155
280
  for (const key of state.entries.keys()) {
156
281
  state.entries.delete(key)
282
+ evicted.push(key)
157
283
  if (state.entries.size <= MAX_ENTRIES) break
158
284
  }
285
+ if (evicted.length > 0) this.storeOf(sessionId)?.evict(evicted)
159
286
  }
160
287
  }
161
288
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@restregular/dsh-memory",
3
- "version": "0.16.2",
3
+ "version": "0.17.1",
4
4
  "description": "DeepSeek Harness 记忆系统(单包单入口):JSONL 存储 + 本地向量检索(BGE-M3)+ 五个模型工具 + 自动召回注入 + 管理面板。",
5
5
  "icon": "./icon.svg",
6
6
  "type": "module",