dsh-agent-soul 0.9.2 → 0.9.3

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
@@ -7,6 +7,24 @@
7
7
 
8
8
  ---
9
9
 
10
+ ## 0.9.3 · 2026-11-07
11
+
12
+ ### 性能
13
+
14
+ 这一批**不改变任何对外行为**,只是少做无用功。
15
+
16
+ - **第 201 个会话会让其余会话集体失忆**(P2-10):8 处 `if (map.size > N) map.clear()` 改成 `trimMap(map, N)`(只淘汰最旧的)。原来清空意味着重注人格、去重表失效、游标从头重扫全量事件。
17
+ - **日志每行 4 次系统调用**(P2-1):`mkdirSync` / `chmodSync` 改成每个文件只做一次(Windows 上 chmod 原来每行抛一次异常再吞掉)。目录被删、权限变化时会在同一次调用里自愈并重试一次。
18
+ - **`snapshotEvents()` 无参全量拷贝**(P2-2):`turnKeyOf` / `hasHumanInputThisTurn` 改成只取尾部 400 条;窗口里没有 assistant 消息(超长工具轮)时**自动退回全量**,不拿正确性换性能。
19
+ - **`readRecentChat` 每次全量 parse 当天 JSONL**(P2-5):按 `(size, mtimeMs)` 缓存,文件一被追加就失效 —— 不需要 TTL 计时器。
20
+ - **`purpose.json` 每回合写盘**(P2-8):drives 是 0~1 的对象,任一维变化 > 0.01 或距上次写盘超 10 分钟才落盘(时间漂移导致的缓慢变化也会定期持久化)。
21
+
22
+ ### 新增
23
+
24
+ - `lib/core/lru.js`:`trimMap` / `touchMap`。
25
+
26
+ ---
27
+
10
28
  ## 0.9.2 · 2026-11-07
11
29
 
12
30
  ### 修复
@@ -0,0 +1,46 @@
1
+ /**
2
+ * 有界 Map:只淘汰最旧的,不整体清空。
3
+ *
4
+ * 2026-11-07 R9 / P2-10。原来全仓库有 8 处这样写:
5
+ *
6
+ * if (map.size > 200) map.clear()
7
+ *
8
+ * 看着像「防止内存无限增长」,实际后果是**集体失忆**:第 201 个会话出现的瞬间,
9
+ * 另外 200 个会话的游标、去重表、注入记录全部作废 —— 它们下一轮会被当成新会话:
10
+ * · 重注人格(多花一份 token)
11
+ * · 去重表失效(同一段记忆被再注入一次)
12
+ * · 游标清空 → **从头重扫全量事件**(extract 那条更糟:丢掉在途的批)
13
+ *
14
+ * 正确做法是只淘汰最旧的那几条。这里给两个最小 API:
15
+ * · trimMap(map, max) —— 超限时按插入顺序淘汰最旧的,直到不超
16
+ * · touchMap(map, key) —— 把 key 挪到队尾(读一次也算「最近用过」)
17
+ *
18
+ * 为什么不在这一轮改成真正的 LRU:`trimMap` 是一行替换,风险接近零;
19
+ * 而把 8 处调用点全改成「读也刷新」需要逐个确认语义(有些 Map 的读是批量的,
20
+ * 刷新顺序会改变淘汰结果)。先止血,再谈精确。
21
+ */
22
+
23
+ /** 超过上限时按插入顺序淘汰最旧的键,直到不超。返回淘汰了几个。 */
24
+ export function trimMap(map, max) {
25
+ if (map === null || map === undefined || typeof map.keys !== 'function') return 0
26
+ const limit = Math.max(0, Math.trunc(Number(max) || 0))
27
+ let dropped = 0
28
+ // 多淘汰一小批(比如 10%),避免「每加一个就淘汰一个」变成每次都要走一遍
29
+ while (map.size > limit) {
30
+ const oldest = map.keys().next()
31
+ if (oldest.done === true) break
32
+ map.delete(oldest.value)
33
+ dropped += 1
34
+ }
35
+ return dropped
36
+ }
37
+
38
+ /** 把 key 挪到队尾(最近使用)。key 不存在时什么都不做。 */
39
+ export function touchMap(map, key) {
40
+ if (map === null || map === undefined || typeof map.has !== 'function') return false
41
+ if (!map.has(key)) return false
42
+ const value = map.get(key)
43
+ map.delete(key)
44
+ map.set(key, value)
45
+ return true
46
+ }
package/lib/diary/feed.js CHANGED
@@ -2,12 +2,13 @@
2
2
  * 日记 · feed.js
3
3
  * 由 lib/diary.js 按职责拆出(2026-11-06 模块化重构),函数体保持原样。
4
4
  */
5
+ import { trimMap } from '../core/lru.js'
5
6
  import { diaryDayBoundaries, todayKey } from '../diary/completion.js'
6
7
  import { diaryJsonlPath, ensureDirs, exists, readText } from '../paths.js'
7
8
  import { join } from 'node:path'
8
9
  import { note } from '../env.js'
9
10
  import { maybePruneConversations } from './files.js'
10
- import { appendFileSync, chmodSync } from 'node:fs'
11
+ import { appendFileSync, chmodSync, statSync } from 'node:fs'
11
12
  import { eventsSince, isHumanEvent, maxSeqOf, messageContentOf, textOfContent, unwrapBridgeText } from '../extract.js'
12
13
 
13
14
 
@@ -109,7 +110,7 @@ const SEEK_GIVE_UP_MS = 30 * 60 * 1000
109
110
 
110
111
 
111
112
  export function collectForDiary(agent) {
112
- if (diaryCursors.size > DIARY_CURSOR_MAX) diaryCursors.clear()
113
+ trimMap(diaryCursors, DIARY_CURSOR_MAX)
113
114
 
114
115
  // 2026-11-04 修 B7:清理挂在日记流程里(runDiaryOnce / 看门狗)是不够的 ——
115
116
  // diaryEnabled=false 时 startDiaryTimer 根本不启动,collectForDiary 却照旧每轮追加,
@@ -368,11 +369,32 @@ export function readConversationRows(dateStr, scheduleMin) {
368
369
  * @param {string} ownerName 对话里主人怎么标(空 = 中性的「对方」,2026-11-04)
369
370
  * @returns {string} 形如 `[14:20] 树树:…` 的多行文本
370
371
  */
372
+ /**
373
+ * `readRecentChat` 的结果缓存:同一天、同样参数、文件没变,就直接复用解析结果。
374
+ *
375
+ * 2026-11-07 R9 / P2-5:这个函数每轮都要读**一整天**的 JSONL 并逐行 parse
376
+ * (流水不清,一天几 MB)。而调用它的地方(记忆注入的「最近聊了什么」)
377
+ * 在同一轮里会被问好几次,间隔通常只有几十毫秒。
378
+ *
379
+ * 失效条件用 (size, mtimeMs):文件一被追加就变,天然准确,不需要 TTL 计时器。
380
+ */
381
+ let recentChatCache = { key: '', at: 0, text: '' }
382
+
371
383
  export function readRecentChat(dateStr, maxChars = 3000, ownerName = '') {
372
384
  const who = String(ownerName ?? '').trim() === '' ? '对方' : String(ownerName).trim()
373
385
  try {
374
386
  const file = diaryJsonlPath(dateStr)
375
387
  if (!exists(file)) return ''
388
+ // 缓存键:文件 + 大小 + mtime + 参数
389
+ let stamp = 0
390
+ try {
391
+ const info = statSync(file)
392
+ stamp = Number(info.size) * 1e6 + Math.floor(Number(info.mtimeMs) || 0)
393
+ } catch {
394
+ stamp = 0
395
+ }
396
+ const key = `${dateStr}|${maxChars}|${who}|${stamp}`
397
+ if (stamp !== 0 && recentChatCache.key === key) return recentChatCache.text
376
398
  const lines = readText(file).split('\n').filter((line) => line.trim() !== '')
377
399
  if (lines.length === 0) return ''
378
400
  // 2026-11-05:按事件时间排,不按行序。
@@ -404,7 +426,9 @@ export function readRecentChat(dateStr, maxChars = 3000, ownerName = '') {
404
426
  out.unshift(line)
405
427
  used += line.length
406
428
  }
407
- return out.join('\n')
429
+ const text = out.join('\n')
430
+ if (stamp !== 0) recentChatCache = { key, at: Date.now(), text }
431
+ return text
408
432
  } catch {
409
433
  return ''
410
434
  }
package/lib/env.js CHANGED
@@ -12,6 +12,7 @@
12
12
  * 现在改成带日期的归档:soul.log.20261031-1423,按名字就能定位时间。
13
13
  * 保留最近 KEEP_ARCHIVES 份,更早的删掉(否则磁盘会被无声吃满)。
14
14
  */
15
+ import { trimMap } from './core/lru.js'
15
16
  import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from 'node:fs'
16
17
  import { dirname } from 'node:path'
17
18
  import { agentsDir } from './paths.js'
@@ -36,16 +37,24 @@ function stamp(at = new Date()) {
36
37
  * 目录被删,日志全写不进去也一声不响。现在把「轮转/清理失败」这件事本身
37
38
  * 尝试记一行到 stderr(不能写文件时,stderr 是最后一根救命稻草)。
38
39
  */
40
+ /**
41
+ * 日志文件的「准备状态」:目录建过没有、权限补过没有。
42
+ * 2026-11-07 R9 / P2-1:这两件事只与文件有关,与写多少行无关,不该每行都做。
43
+ */
44
+ let preparedLogFile = ''
45
+ let preparedChmod = false
46
+
47
+
39
48
  function rotateIfNeeded(file) {
40
49
  try {
41
- if (!existsSync(file)) return
42
- if (statSync(file).size < MAX_BYTES) return
50
+ if (!existsSync(file)) return false
51
+ if (statSync(file).size < MAX_BYTES) return false
43
52
  renameSync(file, `${file}.${stamp()}`)
44
53
  } catch (error) {
45
54
  try {
46
55
  process.stderr.write(`[soul] 日志轮转失败:${error instanceof Error ? error.message : error}\n`)
47
56
  } catch { /* stderr 也没了就真没办法了 */ }
48
- return
57
+ return false
49
58
  }
50
59
 
51
60
  // 清理老归档:只认 soul.log.YYYYMMDD-HHMM 这种名字,按名字倒序留最新的几份。
@@ -64,6 +73,8 @@ function rotateIfNeeded(file) {
64
73
  process.stderr.write(`[soul] 清理旧日志归档失败:${error instanceof Error ? error.message : error}\n`)
65
74
  } catch { /* 同上 */ }
66
75
  }
76
+ // 轮转成功(旧文件已改名,下一次写入会创建新文件)
77
+ return true
67
78
  }
68
79
 
69
80
  /**
@@ -105,16 +116,48 @@ export function appendLogLine(line) {
105
116
  const body = text.endsWith('\n') ? text : `${text}\n`
106
117
  try {
107
118
  const file = LOG_FILE()
108
- // 2026-10-31:目录不存在时自己建。原来靠调用方保证,测试环境里
109
- // 就撞上 ENOENT 了 —— 日志写不进去,等于那段时间完全没有线索。
110
- mkdirSync(dirname(file), { recursive: true })
111
- rotateIfNeeded(file)
112
- // 2026-11-05 S2 / P1-5:日志里曾出现对话原话,Linux/macOS 上默认是 0644。
113
- // 写时带 0o600;已存在的老文件 mode 不会被 append 改掉,补一次 chmod。
119
+ // 2026-11-07 R9 / P2-1:这 4 次系统调用原来**每一行都做**。
120
+ //
121
+ // mkdirSync(dirname) 每行一次
122
+ // rotateIfNeeded → exists/stat 每行一次
123
+ // appendFileSync 必要
124
+ // chmodSync 每行一次(Windows 上没有 mode,每行抛一次异常再吞掉)
125
+ //
126
+ // soul.log 现在几千行,启动一次就要几千次 mkdir + chmod —— 而这两件事的正确性
127
+ // 只与「文件是否存在 / 这次是不是刚建过」有关,与行数无关。
128
+ // 现在:目录与 chmod 每个文件只做一次(建过就记下来);轮转检查仍然每行做,
129
+ // 因为它是**正确性**相关的(写之前必须知道要不要换文件)。
130
+ if (preparedLogFile !== file) {
131
+ mkdirSync(dirname(file), { recursive: true })
132
+ preparedLogFile = file
133
+ preparedChmod = false
134
+ }
135
+ // 轮转成功 = 写的是新文件,权限要重新补一次
136
+ if (rotateIfNeeded(file) === true) preparedChmod = false
137
+ // 权限每个文件只补一次(Windows 上 mode 无效,第一次抛就被吞,后面不再白抛)
138
+ if (preparedChmod !== true) {
139
+ try { chmodSync(file, 0o600) } catch { /* Windows 下 mode 无效,由 ACL 兜底 */ }
140
+ preparedChmod = true
141
+ }
114
142
  appendFileSync(file, body, { encoding: 'utf8', mode: 0o600 })
115
- try { chmodSync(file, 0o600) } catch { /* Windows 下 mode 无效,由 ACL 兜底 */ }
116
143
  return true
117
144
  } catch (error) {
145
+ // 2026-11-07 R9:准备状态是缓存的(目录建过、chmod 过就跳过),所以目录被删、
146
+ // 权限被改之后第一次写会失败。这里**重置并重试一次**,把自愈留在同一次调用里 ——
147
+ // 否则调用方会看到一次莫名其妙的丢日志。
148
+ preparedLogFile = ''
149
+ preparedChmod = false
150
+ try {
151
+ const file = LOG_FILE()
152
+ mkdirSync(dirname(file), { recursive: true })
153
+ preparedLogFile = file
154
+ try { chmodSync(file, 0o600) } catch { /* Windows 下 mode 无效 */ }
155
+ preparedChmod = true
156
+ appendFileSync(file, body, { encoding: 'utf8', mode: 0o600 })
157
+ return true
158
+ } catch {
159
+ /* 重试也失败,走下面的 stderr */
160
+ }
118
161
  // 原来这里 catch {} —— 日志写不进去一声不响,等于把唯一的线索来源也静音了。
119
162
  // 至少往 stderr 喊一句:日志写失败这件事本身,必须留下痕迹。
120
163
  try {
@@ -193,7 +236,7 @@ export function noteThrottled(tag, key, message, { againAt = 5, againMessage = '
193
236
 
194
237
  // 表不能无限涨:key 里带会话 id / 文件名,跑久了会攒。超了整体清空 ——
195
238
  // 清空只影响"这一小时算到第几次",最坏是多记两条日志,不会丢线索。
196
- if (throttleWindows.size > 200) throttleWindows.clear()
239
+ trimMap(throttleWindows, 200)
197
240
 
198
241
  const state = throttleWindows.get(id)
199
242
  if (state === undefined || state.slot !== slot) {
package/lib/extract.js CHANGED
@@ -16,6 +16,7 @@
16
16
  * 按 sessionId 记「上次扫到哪个 seq」。DSH 的 session.seq 是单调的,
17
17
  * 用 firstLiveSeq 排除继承来的历史事件(冷启动/重连时的快照里含历史)。
18
18
  */
19
+ import { trimMap } from './core/lru.js'
19
20
  import { note, noteThrottled } from './env.js'
20
21
  import { isSubagentAgent } from './core/host.js'
21
22
  import { normalizeConfig, normalizeKind, scoreRecord } from './memory.js'
@@ -384,7 +385,7 @@ export function maxSeqOf(agent) {
384
385
  */
385
386
  export function collectCandidates(agent, { limit = 12 } = {}) {
386
387
  // 游标表防泄漏:长期进程里会话会越攒越多,先回收再继续
387
- if (cursors.size > CURSOR_MAX) cursors.clear()
388
+ trimMap(cursors, CURSOR_MAX)
388
389
 
389
390
  const sessionId = String(agent?.session?.header?.id ?? agent?.session?.id ?? '')
390
391
  const key = sessionId !== '' ? sessionId : 'default'
@@ -2,6 +2,7 @@
2
2
  * 宿主装配 · inject.js
3
3
  * 由 lib/host/runtime.js 按职责拆出(2026-11-06 模块化重构),函数体保持原样。
4
4
  */
5
+ import { trimMap } from '../../core/lru.js'
5
6
  import { ECHO_LINE_MAX_CHARS, ECHO_SECTION_MAX_CHARS, RECALL_SEEN_MAX } from '../meta.js'
6
7
  import { cardsFor, loadConfig, moodState } from '../../store.js'
7
8
  import { digestDiaries, readRecentChat, readRecentDiaries, todayKey } from '../../diary.js'
@@ -100,7 +101,7 @@ export function renderRecentSection(cfg) {
100
101
  export function recallForTurn(cwd, cfg, query, sessionId, maxChars) {
101
102
  let seen = recallSeenBySession.get(sessionId)
102
103
  if (seen === undefined) {
103
- if (recallSeenBySession.size > 200) recallSeenBySession.clear()
104
+ trimMap(recallSeenBySession, 200)
104
105
  seen = new Set()
105
106
  recallSeenBySession.set(sessionId, seen)
106
107
  }
@@ -2,6 +2,7 @@
2
2
  * 宿主装配 · turns.js
3
3
  * 由 lib/host/runtime.js 按职责拆出(2026-11-06 模块化重构),函数体保持原样。
4
4
  */
5
+ import { trimMap } from '../../core/lru.js'
5
6
  import { PERSONA_REFRESH_TURNS, STICKY_MAX_SESSIONS, STICKY_NOTE_INTERVAL_MS, name } from '../meta.js'
6
7
  import { isHumanEvent } from '../../extract.js'
7
8
  import { note } from '../../env.js'
@@ -109,7 +110,7 @@ export function isFirstTurnOfSession(agent) {
109
110
 
110
111
  let state = turnCursorBySession.get(id)
111
112
  if (state === undefined) {
112
- if (turnCursorBySession.size > 200) turnCursorBySession.clear()
113
+ trimMap(turnCursorBySession, 200)
113
114
  // cursor = -1:第一次见到这个会话,从最早开始扫一次,把真实条数拿到
114
115
  state = { cursor: -1, human: 0 }
115
116
  turnCursorBySession.set(id, state)
@@ -193,6 +194,40 @@ export function isFirstTurnOfSession(agent) {
193
194
  *
194
195
  * @returns {string} 拿不到 id 时返回空串(调用方据此决定不加缓存)
195
196
  */
197
+ /** 往回看多少条事件算「这一轮」。超过这个窗口的很长的 turn 会退回全量。 */
198
+ const EVENT_TAIL_WINDOW = 400
199
+
200
+ /**
201
+ * 取「最近一段」事件。
202
+ *
203
+ * 2026-11-07 R9 / P2-2:`turnKeyOf` 和 `hasHumanInputThisTurn` 原来都调
204
+ * `session.snapshotEvents()`(**无参 = 全量拷贝**),而它们每一步、每一段各调一次 ——
205
+ * 长会话里这是每步复制几千个事件对象。
206
+ *
207
+ * 真正需要的只是「最后一条 assistant 消息」和「它之后有没有人话」,都在尾部。
208
+ * 但**正确性不能赌**:如果窗口里一条 assistant 消息都没有(超长的工具轮),
209
+ * 说明这一轮比窗口还长,就老老实实退回全量。
210
+ */
211
+ function recentEvents(session) {
212
+ const seq = Number(session?.seq)
213
+ if (Number.isFinite(seq) && typeof session.snapshotEvents === 'function') {
214
+ const from = Math.max(0, seq - EVENT_TAIL_WINDOW)
215
+ try {
216
+ const tail = session.snapshotEvents(from, seq + 1)
217
+ if (Array.isArray(tail) && tail.some((event) => (event?.type ?? event?.kind) === 'assistant/message')) {
218
+ return tail
219
+ }
220
+ } catch {
221
+ /* 尾部读失败就退回全量 */
222
+ }
223
+ }
224
+ try {
225
+ return session?.snapshotEvents() ?? []
226
+ } catch {
227
+ return []
228
+ }
229
+ }
230
+
196
231
  function turnKeyOf(agent) {
197
232
  const sid = String(agent?.session?.header?.id ?? '')
198
233
  if (sid === '') return ''
@@ -205,7 +240,7 @@ function turnKeyOf(agent) {
205
240
  if (typeof session?.snapshotEvents !== 'function') return ''
206
241
  let lastSeq = -1
207
242
  try {
208
- const events = session.snapshotEvents() ?? []
243
+ const events = recentEvents(session)
209
244
  for (let i = events.length - 1; i >= 0; i -= 1) {
210
245
  const event = events[i]
211
246
  if ((event && (event.type || event.kind)) !== 'assistant/message') continue
@@ -250,7 +285,7 @@ export function memoPerStep(name, compute) {
250
285
  const hit = cache.get(slot)
251
286
  if (hit !== undefined && hit.round === round) return hit.value
252
287
  const value = compute(context)
253
- if (cache.size > MAX) cache.clear()
288
+ trimMap(cache, MAX)
254
289
  cache.set(slot, { round, value })
255
290
  return value
256
291
  }
@@ -280,7 +315,7 @@ export function hasHumanInputThisTurn(agent) {
280
315
  try {
281
316
  const session = agent?.session
282
317
  if (typeof session?.snapshotEvents !== 'function') return false
283
- const events = session.snapshotEvents() ?? []
318
+ const events = recentEvents(session)
284
319
  for (let i = events.length - 1; i >= 0; i -= 1) {
285
320
  const event = events[i]
286
321
  const type = event?.type ?? event?.kind
@@ -321,7 +356,7 @@ export function shouldInjectPersona(agent) {
321
356
 
322
357
  // 首轮、或从来没记过注入点(重启后 Map 是空的,补一次)、或隔得够远了
323
358
  if (first || last === undefined || human - last >= PERSONA_REFRESH_TURNS) {
324
- if (personaInjectAtBySession.size > 200) personaInjectAtBySession.clear()
359
+ trimMap(personaInjectAtBySession, 200)
325
360
  personaInjectAtBySession.set(id, human)
326
361
  return true
327
362
  }
@@ -13,6 +13,10 @@ import { note } from '../env.js'
13
13
  import { purposeState, savePurposeState } from './cache.js'
14
14
  import { writeDailyHealth } from '../health.js'
15
15
 
16
+ /** drives 的持久化节流:drives 会随时间自然漂移,即使没被聊到也要定期落盘。 */
17
+ const PURPOSE_WRITE_EVERY_MS = 10 * 60_000
18
+ let lastPurposeWriteAt = 0
19
+
16
20
  /**
17
21
  * 从记忆记录里挑「最近被想起的 N 条」喂给 deriveDrives。
18
22
  *
@@ -139,9 +143,29 @@ export function maintain(cwd, config = {}) {
139
143
  idleHours: hours,
140
144
  materials
141
145
  })
146
+ // 2026-11-07 R9 / P2-8:`deriveDrives` 每回合都跑(成本极低),但**写盘**不该每回合做。
147
+ // 原来这里无条件 savePurposeState —— 一次对话几十轮,就几十次 purpose.json 写盘。
148
+ //
149
+ // 判据两条(OR):
150
+ // ① 任何一维真的动了(> 0.01,drives 是 0~1 的比例)—— 「被聊到」造成的实质变化;
151
+ // ② 距上次写盘超过 10 分钟 —— drives 会随时间自然漂移,只靠①会让缓慢漂移永远落不了盘。
152
+ // 注意 drives 是**对象**(按 NEEDS 分维),不是数组。
153
+ const before = state.drives
154
+ const moved = (() => {
155
+ if (before === null || before === undefined || typeof before !== 'object') return true
156
+ const keys = new Set([...Object.keys(before), ...Object.keys(derived.drives)])
157
+ for (const key of keys) {
158
+ if (Math.abs(Number(before[key]) - Number(derived.drives[key])) > 0.01) return true
159
+ }
160
+ return false
161
+ })()
142
162
  state.drives = derived.drives
143
163
  state.drivesAt = derived.drivesAt
144
- savePurposeState(state)
164
+ const nowMs = Date.now()
165
+ if (moved || nowMs - lastPurposeWriteAt > PURPOSE_WRITE_EVERY_MS) {
166
+ savePurposeState(state)
167
+ lastPurposeWriteAt = nowMs
168
+ }
145
169
  }
146
170
 
147
171
  // 2026-11-04:每日健康一行。
package/lib/tone.js CHANGED
@@ -28,6 +28,7 @@
28
28
  * 计数器按「发出去几条」算,不按「第几轮」算 —— 按轮次算的话,
29
29
  * 中间换档会错位,两条之间可能只隔 1 轮。
30
30
  */
31
+ import { trimMap } from './core/lru.js'
31
32
  import { DIM_FULL } from './mood.js'
32
33
  import { note } from './env.js'
33
34
 
@@ -127,7 +128,7 @@ export function takeTone(sessionId, level, cfg = {}) {
127
128
  if (cfg.moodToneInject === false) return { emit: false, text: '' }
128
129
  const id = String(sessionId ?? '')
129
130
  if (id === '') return { emit: false, text: '' }
130
- if (counters.size > COUNTER_MAX) counters.clear()
131
+ trimMap(counters, COUNTER_MAX)
131
132
 
132
133
  const stay = counters.get(id)
133
134
  const pending = stay === undefined ? 0 : stay.pending
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "dsh-agent-soul",
3
- "version": "0.9.2",
3
+ "version": "0.9.3",
4
4
  "type": "module",
5
5
  "description": "给 DSH 的 agent 一套会忘事的记忆、一份会变的人格和一份会起伏的心情:人格按小节合并(项目覆盖全局但不吃掉全局),记忆按人的规律衰减(清晰→模糊→只剩印象→遗忘),「心里惦记的事」让她的主动有连续性,心情跟着每轮对话自己判断、自己平复(不注入、无挂饰)。",
6
6
  "keywords": [