dsh-agent-soul 0.9.1 → 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 +119 -0
- package/lib/client/api.js +28 -0
- package/lib/client/diary-tab.js +13 -1
- package/lib/client/memory-tab.js +7 -1
- package/lib/client/mood-tab.js +13 -1
- package/lib/client/settings-tab.js +13 -1
- package/lib/client.js +74 -4
- package/lib/core/lru.js +46 -0
- package/lib/diary/feed.js +27 -3
- package/lib/env.js +54 -11
- package/lib/extract.js +2 -1
- package/lib/host/runtime/inject.js +2 -1
- package/lib/host/runtime/turns.js +55 -6
- package/lib/http/server.js +30 -4
- package/lib/memory/card-io.js +25 -0
- package/lib/memory/render.js +51 -9
- package/lib/memory.js +1 -1
- package/lib/mood/hooks.js +35 -5
- package/lib/mood/judge.js +16 -0
- package/lib/state/cards.js +17 -2
- package/lib/state/maintain.js +56 -3
- package/lib/tone.js +2 -1
- package/package.json +2 -1
package/CHANGELOG.md
ADDED
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
# 变更记录
|
|
2
|
+
|
|
3
|
+
本项目从 `0.9.2` 起维护本文件。更早版本只能靠 git tag 和提交记录回溯 —— 这正是本文件存在的原因:
|
|
4
|
+
`0.8.3` 加了一道会让反代部署整页 403 的 Host 白名单,却没有任何变更说明,最后是使用方撞上并报回来的([#1](https://github.com/danshuyue/dsh-agent-soul/issues/1))。
|
|
5
|
+
|
|
6
|
+
格式:`## 版本 · 日期` / 变更按「新增 / 变更 / 修复 / 破坏性」分类。
|
|
7
|
+
|
|
8
|
+
---
|
|
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
|
+
|
|
28
|
+
## 0.9.2 · 2026-11-07
|
|
29
|
+
|
|
30
|
+
### 修复
|
|
31
|
+
|
|
32
|
+
- **合并路径会把主记忆文件挪走**(P2-12,数据安全级):`saveCardMerged` 在合并前调 `loadCard`,而它的 catch 会 `parkCorrupt` —— 一次瞬时读失败就把主卡改名 + 置只读,随后写盘往空路径写新卡。新增无副作用读 `readCardQuietly`,合并与写后回读都改用它;`loadCard` 只留给真正的加载路径。
|
|
33
|
+
- **鉴权链没有任何兜底**:Origin / Host / 回环 / 令牌四段校验原先裸奔在 handler 体里,任何一段将来抛错都会逃出 `webServer` → 未捕获 → **宿主进程退出**。现在整段包一层 catch,异常记日志 + 回 500 + 追踪码。
|
|
34
|
+
- **自定义 judge provider 静默失败**(P2-19):`judgeProvider` 配成非 siliconflow 时会把 provider 原样交给宿主,宿主不认识就每轮判定失败、只留一行日志,表现为「她情绪一直不变」。现在第一次调用就明确告警。
|
|
35
|
+
- **设置页改配置会丢**(P2-25/26):三个 Tab 原来都 POST **全量**配置,跨 Tab 保存互相覆盖;文本输入框还是逐键 POST。现在各 Tab 只发改动键(服务端本就按 key 合并),并加 300ms 防抖。
|
|
36
|
+
- **记忆搜索逐键重取**(P2-28):带 query 时 300ms 防抖。
|
|
37
|
+
- **日记「文件存在但不完整」死循环**:`startupWork` 判定要重写,但 `askAgentToWrite` 只要看到文件存在就认为「她写好了」,于是每轮空转、日志写「日记完成」,内容永远补不回来。现在「要不要再找她写」多了时间基线(`shouldAskAgain`)。
|
|
38
|
+
- **兜底覆盖她迟到写出的日记**:`waitForWrite` 超时后插件兜底写盘,会盖掉她几秒后落盘的那篇。`writeDiaryFile` 增加 `skipIfNewerThan`,比她旧才写。
|
|
39
|
+
- **`lastTalkAtOf` 只扫末 80 行**:文件本就整份读进内存,只遍历尾部纯属遗留写法;多会话交错时最后一句会被挤出窗口,导致「半天版」被判完整。
|
|
40
|
+
- **固定区(pinned / initial)无上限**:固定区有独立预算(`injectMaxChars × 2`),2 倍以内宁可超出也完整保留,超过才裁并明说「还有 N 条这轮没放下」。
|
|
41
|
+
- **游标在 `snapshotEvents` 抛错时不推进**:现在一定推进,且整卡注入只宽限一次。
|
|
42
|
+
- **`mountedOffs` 强引用**:改存 `WeakRef`,会话关闭后 agent 可被回收。
|
|
43
|
+
- **喂给 `drives` 的素材顺序**:由「数组尾部 12 条」改为按 `lastSeenAt`(最近被想起)优先排序。
|
|
44
|
+
- **跨进程写卡竞态**:写后回读 `rev`,发现被别人覆盖时记日志(**只检测,不自动重写**)。
|
|
45
|
+
|
|
46
|
+
### 变更
|
|
47
|
+
|
|
48
|
+
- `lib/state/maintain.js` 新增 `pickRecentMaterials`(纯函数,可单独测)。
|
|
49
|
+
- `lib/memory/card-io.js` 新增 `readCardQuietly`(无副作用读卡)。
|
|
50
|
+
- 客户端新增 `apiPostDebounced`(按 key 防抖的 POST)。
|
|
51
|
+
|
|
52
|
+
---
|
|
53
|
+
|
|
54
|
+
## 0.9.1 · 2026-11-07
|
|
55
|
+
|
|
56
|
+
### 修复(安全)
|
|
57
|
+
|
|
58
|
+
- **反代部署下 `/api/soul/*` 全量 403**([#1](https://github.com/danshuyue/dsh-agent-soul/issues/1)):
|
|
59
|
+
Host 判定改为**以宿主为准** —— 先问 `ctx.connection.requestRejection(req)`,
|
|
60
|
+
`null` 放行、`401`(宿主侧未登录)放行到插件自己的 `x-soul-token` 校验、`403` 才拒;
|
|
61
|
+
宿主不可用 / 抛错时退回插件白名单。原来插件自维护信任名单,与宿主 `--trusted-host` 两套 fence 打架。
|
|
62
|
+
- **任意文件读取**(`GET /state?cwd=<任意目录>` 可读该目录 `AGENT.md` 前 400 字):
|
|
63
|
+
cwd 归属校验收口,`GET /persona` 一并补上。
|
|
64
|
+
- **`GET /persona` 绕过 cwd 归属校验**且返回全文。
|
|
65
|
+
- **UNC / 设备路径**(`\\host\share`、`\\.\`、`\\?\`):`statSync` 会发起 SMB 连接并携带 NTLM 凭据,且同步阻塞事件循环。现在字符串阶段直接拒,`statSync` 挪到归属判定之后。
|
|
66
|
+
- **`sec-fetch-site` 值拼错**(`'samesite'` ≠ `'same-site'`),同站防线此前从未生效。
|
|
67
|
+
- **错误原文回显**:`/pick`、`/persona` 保存、`/open` 三处不再把含绝对路径的 `error.message` 回给客户端,改为固定文案 + 追踪码。
|
|
68
|
+
- **数据边界可伪造**:`<user_data>` 换成带内容哈希 nonce 的 `<untrusted_data>`,内容拼不出真闭合标签;人格段补 `PERSONA_GUARD` 声明。
|
|
69
|
+
- **配置数值无上限**:新增 `NUMBER_RANGES` 覆盖 35 个数值键,越界拒绝(此前 `diaryAgentTimeoutMs = 1e12` 也能存)。
|
|
70
|
+
- **日记主流程无总超时**:12 分钟总预算 + 超时后 orphan 防重入。
|
|
71
|
+
- **`/register` 反向放行归属校验**:新增写侧唯一入口 `resolvePostCwd`。
|
|
72
|
+
- **PowerShell 回退链是断的**(裸名字分支直接 return,第三级永远不可达);顺带校验 DPAPI 输出,避免存下解不开的空密文。
|
|
73
|
+
- **`POST /memory` 的 `edit` 分支绕过脱敏**。
|
|
74
|
+
- **`maintain` 无视 `projectMemoryEnabled`**。
|
|
75
|
+
- **记忆卡容量到顶且无可压缩项时仍 `push`**。
|
|
76
|
+
- **Origin/Host 端口比较**:`String(host).split(':')[1]` 对无端口的 Host 与 `[::1]:8080` 都恒不相等;改为规范化权威比较,两端同为回环时允许端口不同。
|
|
77
|
+
|
|
78
|
+
### 变更
|
|
79
|
+
|
|
80
|
+
- 新增一次性提示:接口被非本机 Host 访问时在日志里提醒(只记一次)。
|
|
81
|
+
|
|
82
|
+
### 破坏性
|
|
83
|
+
|
|
84
|
+
- **`POST /register` 不再接受任意路径**:只接受「已登记 / 宿主会话给的 / `DSH_HOME` 内」。设置页「把路径粘到输入框」这条路关闭,请改用「选择文件夹」。
|
|
85
|
+
- **`POST /config` 数值越界返回 400**(此前静默接受)。
|
|
86
|
+
- `DSH_SOUL_POWERSHELL` 指向不存在的路径时保存密钥直接失败,不再静默回退。
|
|
87
|
+
|
|
88
|
+
---
|
|
89
|
+
|
|
90
|
+
## 0.9.0 · 2026-11-06
|
|
91
|
+
|
|
92
|
+
### 变更
|
|
93
|
+
|
|
94
|
+
- **模块化重构**:`lib/` 拆成 95 个模块(`host/runtime`、`memory/`、`state/`、`diary/`、`http/`、`core/`)。
|
|
95
|
+
- 新增契约门禁三件套:导出快照、行为 golden、依赖图;刷基线必须写明理由并留痕。
|
|
96
|
+
|
|
97
|
+
### 破坏性
|
|
98
|
+
|
|
99
|
+
- **新增 Host 白名单**(见 `0.8.3`):`/api/soul/*` 只接受 `localhost` / `127.0.0.1` / `[::1]` / `::1`
|
|
100
|
+
以及 `DSH_SOUL_ALLOWED_HOSTS` 里的值。**反向代理 + 公网域名/IP 的部署会整页 403** ——
|
|
101
|
+
这就是 `0.9.1` 修的那条([#1](https://github.com/danshuyue/dsh-agent-soul/issues/1))。
|
|
102
|
+
当时没有写进任何变更说明,是本项目的流程失误。
|
|
103
|
+
|
|
104
|
+
---
|
|
105
|
+
|
|
106
|
+
## 0.8.3 · 2026-11-06
|
|
107
|
+
|
|
108
|
+
### 变更
|
|
109
|
+
|
|
110
|
+
- 加固(R2/R3/R4):**Host 白名单**、`localNames` 只认纯文件名、回环门控下沉。
|
|
111
|
+
|
|
112
|
+
> **注意**:`DSH_SOUL_ALLOWED_HOSTS` 是 `DSH_` 前缀的启动期变量,**只能**通过
|
|
113
|
+
> `systemd Environment=` / `docker -e` / shell `export` 设置。写进 `.env` 会让 dsh 直接启动失败。
|
|
114
|
+
|
|
115
|
+
---
|
|
116
|
+
|
|
117
|
+
## 0.8.0 – 0.8.2 · 2026-11-05 / 11-06
|
|
118
|
+
|
|
119
|
+
无变更记录(本文件从 `0.9.2` 起才存在)。这几个版本没有 Host 白名单。
|
package/lib/client/api.js
CHANGED
|
@@ -87,6 +87,34 @@
|
|
|
87
87
|
}, false)
|
|
88
88
|
}
|
|
89
89
|
|
|
90
|
+
/**
|
|
91
|
+
* 2026-11-07 R8 / P2-25:**防抖的 POST**。
|
|
92
|
+
*
|
|
93
|
+
* 设置页的文本输入框原来每敲一键就 POST 一次全量配置 —— 打一行字发十几次请求,
|
|
94
|
+
* 而且请求乱序时后发先至,最后落盘的可能是中间某个状态。
|
|
95
|
+
* 这里按 key 合并:同一个 key(比如同一个输入框)在窗口内的多次调用只发最后一次。
|
|
96
|
+
*
|
|
97
|
+
* 返回一个 Promise:窗口结束、真正发出后 resolve;中途被新的调用取代时也 resolve(不 reject),
|
|
98
|
+
* 调用方不需要为「我这次被合并掉了」写特殊分支 —— 状态提示照旧显示「已保存」。
|
|
99
|
+
*/
|
|
100
|
+
var pendingPosts = {}
|
|
101
|
+
function apiPostDebounced(key, path, body, waitMs) {
|
|
102
|
+
var delay = typeof waitMs === 'number' && waitMs >= 0 ? waitMs : 300
|
|
103
|
+
var slot = pendingPosts[key]
|
|
104
|
+
if (slot) {
|
|
105
|
+
clearTimeout(slot.timer)
|
|
106
|
+
if (typeof slot.resolve === 'function') slot.resolve(null)
|
|
107
|
+
}
|
|
108
|
+
return new Promise(function (resolve, reject) {
|
|
109
|
+
var entry = { resolve: resolve, reject: reject, timer: null }
|
|
110
|
+
entry.timer = setTimeout(function () {
|
|
111
|
+
if (pendingPosts[key] === entry) delete pendingPosts[key]
|
|
112
|
+
apiPost(path, body).then(resolve).catch(reject)
|
|
113
|
+
}, delay)
|
|
114
|
+
pendingPosts[key] = entry
|
|
115
|
+
})
|
|
116
|
+
}
|
|
117
|
+
|
|
90
118
|
/** 从会话上下文里刨出 cwd —— 刨不到就全局视图,再不够还有服务端兜底与手选。 */
|
|
91
119
|
function cwdOf(props) {
|
|
92
120
|
var p = props || {}
|
package/lib/client/diary-tab.js
CHANGED
|
@@ -61,7 +61,19 @@
|
|
|
61
61
|
Object.keys(base).forEach(function (k) { merged[k] = base[k] })
|
|
62
62
|
Object.keys(next).forEach(function (k) { merged[k] = next[k] })
|
|
63
63
|
setConfig(merged)
|
|
64
|
-
|
|
64
|
+
// 2026-11-07 R8(P2-25/26):
|
|
65
|
+
// ① 只把**改动过的键**发上去 —— 服务端 saveConfig 是按 key 合并的,
|
|
66
|
+
// 发全量会让「另一个标签页刚改的项」被这份旧快照覆盖;
|
|
67
|
+
// ② 同一个输入框连续敲键只发最后一次(300ms 防抖)。
|
|
68
|
+
var changed = {}
|
|
69
|
+
Object.keys(next).forEach(function (k) {
|
|
70
|
+
if (next[k] !== base[k]) changed[k] = next[k]
|
|
71
|
+
})
|
|
72
|
+
if (Object.keys(changed).length === 0) {
|
|
73
|
+
setStatus('已保存,下一个回合生效')
|
|
74
|
+
return
|
|
75
|
+
}
|
|
76
|
+
apiPostDebounced('config:diary', '/config', { config: changed }, 300)
|
|
65
77
|
.then(function () { setStatus('已保存,下一个回合生效') })
|
|
66
78
|
.catch(function (e) { setStatus('保存失败:' + e.message) })
|
|
67
79
|
}
|
package/lib/client/memory-tab.js
CHANGED
|
@@ -50,7 +50,13 @@
|
|
|
50
50
|
apiGet(url).then(setData).catch(function (e) { setStatus('读取失败:' + e.message) })
|
|
51
51
|
}, [scope, cwd, query])
|
|
52
52
|
|
|
53
|
-
useEffect(function () {
|
|
53
|
+
useEffect(function () {
|
|
54
|
+
// 2026-11-07 R8 / P2-28:搜索框原来每敲一键就整页重取一次(后端还要全量打分)。
|
|
55
|
+
// 带 query 时延迟 300ms 再取;scope/cwd 变化仍然立刻取(那是明确的切换动作)。
|
|
56
|
+
if (query === '') { load(); return undefined }
|
|
57
|
+
var timer = setTimeout(load, 300)
|
|
58
|
+
return function () { clearTimeout(timer) }
|
|
59
|
+
}, [load])
|
|
54
60
|
|
|
55
61
|
function act(action, id, extra) {
|
|
56
62
|
var body = { scope: scope, cwd: cwd, action: action, id: id }
|
package/lib/client/mood-tab.js
CHANGED
|
@@ -51,7 +51,19 @@
|
|
|
51
51
|
Object.keys(base).forEach(function (k) { merged[k] = base[k] })
|
|
52
52
|
Object.keys(next).forEach(function (k) { merged[k] = next[k] })
|
|
53
53
|
setConfig(merged)
|
|
54
|
-
|
|
54
|
+
// 2026-11-07 R8(P2-25/26):
|
|
55
|
+
// ① 只把**改动过的键**发上去 —— 服务端 saveConfig 是按 key 合并的,
|
|
56
|
+
// 发全量会让「另一个标签页刚改的项」被这份旧快照覆盖;
|
|
57
|
+
// ② 同一个输入框连续敲键只发最后一次(300ms 防抖)。
|
|
58
|
+
var changed = {}
|
|
59
|
+
Object.keys(next).forEach(function (k) {
|
|
60
|
+
if (next[k] !== base[k]) changed[k] = next[k]
|
|
61
|
+
})
|
|
62
|
+
if (Object.keys(changed).length === 0) {
|
|
63
|
+
setStatus('已保存,下一个回合生效')
|
|
64
|
+
return
|
|
65
|
+
}
|
|
66
|
+
apiPostDebounced('config:mood', '/config', { config: changed }, 300)
|
|
55
67
|
.then(function () { setStatus('已保存,下一个回合生效') })
|
|
56
68
|
.catch(function (e) { setStatus('保存失败:' + e.message) })
|
|
57
69
|
}
|
|
@@ -16,7 +16,19 @@
|
|
|
16
16
|
Object.keys(config).forEach(function (k) { merged[k] = config[k] })
|
|
17
17
|
Object.keys(next).forEach(function (k) { merged[k] = next[k] })
|
|
18
18
|
setConfig(merged)
|
|
19
|
-
|
|
19
|
+
// 2026-11-07 R8(P2-25/26):
|
|
20
|
+
// ① 只把**改动过的键**发上去 —— 服务端 saveConfig 是按 key 合并的,
|
|
21
|
+
// 发全量会让「另一个标签页刚改的项」被这份旧快照覆盖;
|
|
22
|
+
// ② 同一个输入框连续敲键只发最后一次(300ms 防抖)。
|
|
23
|
+
var changed = {}
|
|
24
|
+
Object.keys(next).forEach(function (k) {
|
|
25
|
+
if (next[k] !== config[k]) changed[k] = next[k]
|
|
26
|
+
})
|
|
27
|
+
if (Object.keys(changed).length === 0) {
|
|
28
|
+
setStatus('已保存,下一个回合生效')
|
|
29
|
+
return
|
|
30
|
+
}
|
|
31
|
+
apiPostDebounced('config:settings', '/config', { config: changed }, 300)
|
|
20
32
|
.then(function () { setStatus('已保存,下一个回合生效') })
|
|
21
33
|
.catch(function (e) { setStatus('保存失败:' + e.message) })
|
|
22
34
|
}
|
package/lib/client.js
CHANGED
|
@@ -270,6 +270,34 @@ window.__ModuleLoader__.load({
|
|
|
270
270
|
}, false)
|
|
271
271
|
}
|
|
272
272
|
|
|
273
|
+
/**
|
|
274
|
+
* 2026-11-07 R8 / P2-25:**防抖的 POST**。
|
|
275
|
+
*
|
|
276
|
+
* 设置页的文本输入框原来每敲一键就 POST 一次全量配置 —— 打一行字发十几次请求,
|
|
277
|
+
* 而且请求乱序时后发先至,最后落盘的可能是中间某个状态。
|
|
278
|
+
* 这里按 key 合并:同一个 key(比如同一个输入框)在窗口内的多次调用只发最后一次。
|
|
279
|
+
*
|
|
280
|
+
* 返回一个 Promise:窗口结束、真正发出后 resolve;中途被新的调用取代时也 resolve(不 reject),
|
|
281
|
+
* 调用方不需要为「我这次被合并掉了」写特殊分支 —— 状态提示照旧显示「已保存」。
|
|
282
|
+
*/
|
|
283
|
+
var pendingPosts = {}
|
|
284
|
+
function apiPostDebounced(key, path, body, waitMs) {
|
|
285
|
+
var delay = typeof waitMs === 'number' && waitMs >= 0 ? waitMs : 300
|
|
286
|
+
var slot = pendingPosts[key]
|
|
287
|
+
if (slot) {
|
|
288
|
+
clearTimeout(slot.timer)
|
|
289
|
+
if (typeof slot.resolve === 'function') slot.resolve(null)
|
|
290
|
+
}
|
|
291
|
+
return new Promise(function (resolve, reject) {
|
|
292
|
+
var entry = { resolve: resolve, reject: reject, timer: null }
|
|
293
|
+
entry.timer = setTimeout(function () {
|
|
294
|
+
if (pendingPosts[key] === entry) delete pendingPosts[key]
|
|
295
|
+
apiPost(path, body).then(resolve).catch(reject)
|
|
296
|
+
}, delay)
|
|
297
|
+
pendingPosts[key] = entry
|
|
298
|
+
})
|
|
299
|
+
}
|
|
300
|
+
|
|
273
301
|
/** 从会话上下文里刨出 cwd —— 刨不到就全局视图,再不够还有服务端兜底与手选。 */
|
|
274
302
|
function cwdOf(props) {
|
|
275
303
|
var p = props || {}
|
|
@@ -946,7 +974,13 @@ window.__ModuleLoader__.load({
|
|
|
946
974
|
apiGet(url).then(setData).catch(function (e) { setStatus('读取失败:' + e.message) })
|
|
947
975
|
}, [scope, cwd, query])
|
|
948
976
|
|
|
949
|
-
useEffect(function () {
|
|
977
|
+
useEffect(function () {
|
|
978
|
+
// 2026-11-07 R8 / P2-28:搜索框原来每敲一键就整页重取一次(后端还要全量打分)。
|
|
979
|
+
// 带 query 时延迟 300ms 再取;scope/cwd 变化仍然立刻取(那是明确的切换动作)。
|
|
980
|
+
if (query === '') { load(); return undefined }
|
|
981
|
+
var timer = setTimeout(load, 300)
|
|
982
|
+
return function () { clearTimeout(timer) }
|
|
983
|
+
}, [load])
|
|
950
984
|
|
|
951
985
|
function act(action, id, extra) {
|
|
952
986
|
var body = { scope: scope, cwd: cwd, action: action, id: id }
|
|
@@ -1260,7 +1294,19 @@ window.__ModuleLoader__.load({
|
|
|
1260
1294
|
Object.keys(base).forEach(function (k) { merged[k] = base[k] })
|
|
1261
1295
|
Object.keys(next).forEach(function (k) { merged[k] = next[k] })
|
|
1262
1296
|
setConfig(merged)
|
|
1263
|
-
|
|
1297
|
+
// 2026-11-07 R8(P2-25/26):
|
|
1298
|
+
// ① 只把**改动过的键**发上去 —— 服务端 saveConfig 是按 key 合并的,
|
|
1299
|
+
// 发全量会让「另一个标签页刚改的项」被这份旧快照覆盖;
|
|
1300
|
+
// ② 同一个输入框连续敲键只发最后一次(300ms 防抖)。
|
|
1301
|
+
var changed = {}
|
|
1302
|
+
Object.keys(next).forEach(function (k) {
|
|
1303
|
+
if (next[k] !== base[k]) changed[k] = next[k]
|
|
1304
|
+
})
|
|
1305
|
+
if (Object.keys(changed).length === 0) {
|
|
1306
|
+
setStatus('已保存,下一个回合生效')
|
|
1307
|
+
return
|
|
1308
|
+
}
|
|
1309
|
+
apiPostDebounced('config:mood', '/config', { config: changed }, 300)
|
|
1264
1310
|
.then(function () { setStatus('已保存,下一个回合生效') })
|
|
1265
1311
|
.catch(function (e) { setStatus('保存失败:' + e.message) })
|
|
1266
1312
|
}
|
|
@@ -1550,7 +1596,19 @@ window.__ModuleLoader__.load({
|
|
|
1550
1596
|
Object.keys(base).forEach(function (k) { merged[k] = base[k] })
|
|
1551
1597
|
Object.keys(next).forEach(function (k) { merged[k] = next[k] })
|
|
1552
1598
|
setConfig(merged)
|
|
1553
|
-
|
|
1599
|
+
// 2026-11-07 R8(P2-25/26):
|
|
1600
|
+
// ① 只把**改动过的键**发上去 —— 服务端 saveConfig 是按 key 合并的,
|
|
1601
|
+
// 发全量会让「另一个标签页刚改的项」被这份旧快照覆盖;
|
|
1602
|
+
// ② 同一个输入框连续敲键只发最后一次(300ms 防抖)。
|
|
1603
|
+
var changed = {}
|
|
1604
|
+
Object.keys(next).forEach(function (k) {
|
|
1605
|
+
if (next[k] !== base[k]) changed[k] = next[k]
|
|
1606
|
+
})
|
|
1607
|
+
if (Object.keys(changed).length === 0) {
|
|
1608
|
+
setStatus('已保存,下一个回合生效')
|
|
1609
|
+
return
|
|
1610
|
+
}
|
|
1611
|
+
apiPostDebounced('config:diary', '/config', { config: changed }, 300)
|
|
1554
1612
|
.then(function () { setStatus('已保存,下一个回合生效') })
|
|
1555
1613
|
.catch(function (e) { setStatus('保存失败:' + e.message) })
|
|
1556
1614
|
}
|
|
@@ -2141,7 +2199,19 @@ window.__ModuleLoader__.load({
|
|
|
2141
2199
|
Object.keys(config).forEach(function (k) { merged[k] = config[k] })
|
|
2142
2200
|
Object.keys(next).forEach(function (k) { merged[k] = next[k] })
|
|
2143
2201
|
setConfig(merged)
|
|
2144
|
-
|
|
2202
|
+
// 2026-11-07 R8(P2-25/26):
|
|
2203
|
+
// ① 只把**改动过的键**发上去 —— 服务端 saveConfig 是按 key 合并的,
|
|
2204
|
+
// 发全量会让「另一个标签页刚改的项」被这份旧快照覆盖;
|
|
2205
|
+
// ② 同一个输入框连续敲键只发最后一次(300ms 防抖)。
|
|
2206
|
+
var changed = {}
|
|
2207
|
+
Object.keys(next).forEach(function (k) {
|
|
2208
|
+
if (next[k] !== config[k]) changed[k] = next[k]
|
|
2209
|
+
})
|
|
2210
|
+
if (Object.keys(changed).length === 0) {
|
|
2211
|
+
setStatus('已保存,下一个回合生效')
|
|
2212
|
+
return
|
|
2213
|
+
}
|
|
2214
|
+
apiPostDebounced('config:settings', '/config', { config: changed }, 300)
|
|
2145
2215
|
.then(function () { setStatus('已保存,下一个回合生效') })
|
|
2146
2216
|
.catch(function (e) { setStatus('保存失败:' + e.message) })
|
|
2147
2217
|
}
|
package/lib/core/lru.js
ADDED
|
@@ -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
|
-
|
|
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
|
-
|
|
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-
|
|
109
|
-
//
|
|
110
|
-
mkdirSync(dirname
|
|
111
|
-
rotateIfNeeded
|
|
112
|
-
//
|
|
113
|
-
//
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
113
|
+
trimMap(turnCursorBySession, 200)
|
|
113
114
|
// cursor = -1:第一次见到这个会话,从最早开始扫一次,把真实条数拿到
|
|
114
115
|
state = { cursor: -1, human: 0 }
|
|
115
116
|
turnCursorBySession.set(id, state)
|
|
@@ -129,7 +130,21 @@ export function isFirstTurnOfSession(agent) {
|
|
|
129
130
|
return true
|
|
130
131
|
}
|
|
131
132
|
} catch {
|
|
132
|
-
return true
|
|
133
|
+
// 2026-11-07 R7 / P1-D1:原来这里直接 `return true`,游标和 human 计数都不动 ——
|
|
134
|
+
// 一旦宿主在压缩/继承会话上抛错,每轮都当「第一轮」:整卡注入 + 从头重扫。
|
|
135
|
+
//
|
|
136
|
+
// 现在的处理分两半,边界要说清:
|
|
137
|
+
// · 游标**一定推进**到 seq —— 这一半没有副作用,无论抛不抛都比原来好(省掉重扫);
|
|
138
|
+
// · 返回值**宽限一次**:第一次失败仍然当第一轮(保证新会话不失忆),
|
|
139
|
+
// 之后不再重复整卡注入(否则 token 白烧、上下文越滚越大)。
|
|
140
|
+
//
|
|
141
|
+
// 这条修法依赖「宿主到底会不会抛」这个前提。我在仓库里验证不了(宿主是打包的 asar),
|
|
142
|
+
// 所以选了最保守的一版:不改变成功路径的任何行为,失败路径只做「少做一次错事」。
|
|
143
|
+
// 如果以后有人报「新会话没有人格/记忆」,第一个该看的就是这里。
|
|
144
|
+
const firstFailure = (state.degraded ?? 0) === 0
|
|
145
|
+
state.degraded = (state.degraded ?? 0) + 1
|
|
146
|
+
state.cursor = Math.max(state.cursor, seq)
|
|
147
|
+
return firstFailure
|
|
133
148
|
}
|
|
134
149
|
|
|
135
150
|
if (!Array.isArray(events)) return true
|
|
@@ -179,6 +194,40 @@ export function isFirstTurnOfSession(agent) {
|
|
|
179
194
|
*
|
|
180
195
|
* @returns {string} 拿不到 id 时返回空串(调用方据此决定不加缓存)
|
|
181
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
|
+
|
|
182
231
|
function turnKeyOf(agent) {
|
|
183
232
|
const sid = String(agent?.session?.header?.id ?? '')
|
|
184
233
|
if (sid === '') return ''
|
|
@@ -191,7 +240,7 @@ function turnKeyOf(agent) {
|
|
|
191
240
|
if (typeof session?.snapshotEvents !== 'function') return ''
|
|
192
241
|
let lastSeq = -1
|
|
193
242
|
try {
|
|
194
|
-
const events = session
|
|
243
|
+
const events = recentEvents(session)
|
|
195
244
|
for (let i = events.length - 1; i >= 0; i -= 1) {
|
|
196
245
|
const event = events[i]
|
|
197
246
|
if ((event && (event.type || event.kind)) !== 'assistant/message') continue
|
|
@@ -236,7 +285,7 @@ export function memoPerStep(name, compute) {
|
|
|
236
285
|
const hit = cache.get(slot)
|
|
237
286
|
if (hit !== undefined && hit.round === round) return hit.value
|
|
238
287
|
const value = compute(context)
|
|
239
|
-
|
|
288
|
+
trimMap(cache, MAX)
|
|
240
289
|
cache.set(slot, { round, value })
|
|
241
290
|
return value
|
|
242
291
|
}
|
|
@@ -266,7 +315,7 @@ export function hasHumanInputThisTurn(agent) {
|
|
|
266
315
|
try {
|
|
267
316
|
const session = agent?.session
|
|
268
317
|
if (typeof session?.snapshotEvents !== 'function') return false
|
|
269
|
-
const events = session
|
|
318
|
+
const events = recentEvents(session)
|
|
270
319
|
for (let i = events.length - 1; i >= 0; i -= 1) {
|
|
271
320
|
const event = events[i]
|
|
272
321
|
const type = event?.type ?? event?.kind
|
|
@@ -307,7 +356,7 @@ export function shouldInjectPersona(agent) {
|
|
|
307
356
|
|
|
308
357
|
// 首轮、或从来没记过注入点(重启后 Map 是空的,补一次)、或隔得够远了
|
|
309
358
|
if (first || last === undefined || human - last >= PERSONA_REFRESH_TURNS) {
|
|
310
|
-
|
|
359
|
+
trimMap(personaInjectAtBySession, 200)
|
|
311
360
|
personaInjectAtBySession.set(id, human)
|
|
312
361
|
return true
|
|
313
362
|
}
|
package/lib/http/server.js
CHANGED
|
@@ -128,10 +128,11 @@ export function registerApi(ctx) {
|
|
|
128
128
|
return undefined
|
|
129
129
|
}
|
|
130
130
|
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
131
|
+
/**
|
|
132
|
+
* 真正的请求处理(Origin / Host / 回环 / 令牌 / 路由分发都在这)。
|
|
133
|
+
* 2026-11-07 R8:从 register 的内联 handler 里提出来,外层好加统一的异常兜底。
|
|
134
|
+
*/
|
|
135
|
+
const handleApiRequest = async (req, res) => {
|
|
135
136
|
// ---- 跨源防护(CSRF) ----
|
|
136
137
|
// 这套接口没有任何鉴权:POST /persona 能改写人格注入内容,POST /open 能弹 explorer,
|
|
137
138
|
// POST /pick 能弹系统文件选择框。也就是说,你浏览器里随便一个恶意页面
|
|
@@ -349,6 +350,31 @@ export function registerApi(ctx) {
|
|
|
349
350
|
})
|
|
350
351
|
}
|
|
351
352
|
}
|
|
353
|
+
|
|
354
|
+
const dispose = webServer.register({
|
|
355
|
+
kind: 'prefix',
|
|
356
|
+
path: API_PREFIX,
|
|
357
|
+
handler: (req, res) => {
|
|
358
|
+
// 2026-11-07 R8(P3「鉴权链在 try/catch 之外裸奔」):
|
|
359
|
+
// Origin / Host / 回环 / 令牌四段校验原来直接写在 handler 体里,没有任何兜底。
|
|
360
|
+
// 今天这几段都不会抛,但只要将来有人往里加一句会抛的调用(解析、网络、宿主 API),
|
|
361
|
+
// 异常就会逃出 webServer → 未捕获 → **整个宿主进程退出**。
|
|
362
|
+
// 一层 catch 换来的代价是零,换来的是「最坏也只是这个请求 500」。
|
|
363
|
+
return handleApiRequest(req, res).catch((error) => {
|
|
364
|
+
const code = `SOUL_${Date.now().toString(36)}`
|
|
365
|
+
note('api', `接口处理异常(${code}):${error instanceof Error ? error.stack ?? error.message : error}`)
|
|
366
|
+
try {
|
|
367
|
+
if (res.headersSent === true) {
|
|
368
|
+
res.end()
|
|
369
|
+
return
|
|
370
|
+
}
|
|
371
|
+
res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' })
|
|
372
|
+
res.end(JSON.stringify({ ok: false, error: '内部错误,详情见 agents/soul.log', code }))
|
|
373
|
+
} catch {
|
|
374
|
+
/* 连接已经断了,没什么可做的 */
|
|
375
|
+
}
|
|
376
|
+
})
|
|
377
|
+
}
|
|
352
378
|
})
|
|
353
379
|
|
|
354
380
|
if (typeof dispose === 'function' && typeof ctx.effect === 'function') {
|
package/lib/memory/card-io.js
CHANGED
|
@@ -68,6 +68,31 @@ function parkCorrupt(file, reason) {
|
|
|
68
68
|
}
|
|
69
69
|
|
|
70
70
|
|
|
71
|
+
/**
|
|
72
|
+
* **无副作用**地读一张卡:不迁移、不备份、不置只读、不动 corruptState。
|
|
73
|
+
*
|
|
74
|
+
* 2026-11-07 R8 / P2-12:合并路径以前调 `loadCard`,而 `loadCard` 的 catch
|
|
75
|
+
* 会 `parkCorrupt` —— 把**主记忆文件改名成 `.corrupt-*` 并置只读**。
|
|
76
|
+
* 于是「写之前看一眼盘上有没有更新」这个动作,在遇到一次瞬时读失败时
|
|
77
|
+
* (Windows 文件被占、杀软扫描)会把用户的记忆整个挪走,随后写盘往空路径写新卡 ——
|
|
78
|
+
* 用户看到的是「记忆突然清空」,而备份还在那儿没人知道。
|
|
79
|
+
*
|
|
80
|
+
* 这条路径只需要「读到就读到,读不到当没有」,不需要抢救现场。
|
|
81
|
+
* 抢救是 `loadCard` 的事,只应该发生在真正的加载路径上。
|
|
82
|
+
*
|
|
83
|
+
* @returns {object|null} 解析好的卡;读不到 / 坏了 / 不存在都返回 null
|
|
84
|
+
*/
|
|
85
|
+
export function readCardQuietly(file) {
|
|
86
|
+
try {
|
|
87
|
+
if (!existsSync(file)) return null
|
|
88
|
+
const raw = JSON.parse(readFileSync(file, 'utf8').replace(/^\uFEFF/, ''))
|
|
89
|
+
return normalizeCard(raw)
|
|
90
|
+
} catch {
|
|
91
|
+
return null
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
|
|
71
96
|
/** 读盘 + 结构收敛。坏文件先落备份再返回 null;备份不了则进入只读。 */
|
|
72
97
|
export function loadCard(file) {
|
|
73
98
|
try {
|
package/lib/memory/render.js
CHANGED
|
@@ -196,8 +196,11 @@ export function renderCard(card, options = {}) {
|
|
|
196
196
|
|
|
197
197
|
/** 固定区:priority >= 100,永远不参与预算裁剪。 */
|
|
198
198
|
const FIXED_PLAN = Object.freeze([
|
|
199
|
-
|
|
200
|
-
|
|
199
|
+
// limit 是「这一轮最多注入几条」。2026-11-07 P1-D6:原来没有 limit,
|
|
200
|
+
// pinned 攒几十条就把预算撑爆。数值取自「开端」与「锚点」的语义:
|
|
201
|
+
// 开始那几条是人定的,很少;锚点是 pinned 的重要记忆,给到 20。
|
|
202
|
+
{ key: 'initial', title: '## 我们的开始', priority: 120, limit: 10 },
|
|
203
|
+
{ key: 'anchors', title: '## 永远不会忘的', priority: 100, limit: 20 }
|
|
201
204
|
])
|
|
202
205
|
|
|
203
206
|
|
|
@@ -298,17 +301,33 @@ export function renderRecalledBlock(cards, options = {}) {
|
|
|
298
301
|
return line
|
|
299
302
|
}
|
|
300
303
|
|
|
301
|
-
// ① 固定区:pinned + priority>=100
|
|
304
|
+
// ① 固定区:pinned + priority>=100 的分区。
|
|
305
|
+
//
|
|
306
|
+
// 2026-11-07 R7 / P1-D6:原来这里「一条都不裁(所以不 slice)」——
|
|
307
|
+
// 整卡路径对 anchors 是有 limit 5 的,固定区这条路没有,于是 pinned 攒到几十条
|
|
308
|
+
// 就每回合原样超出 injectMaxChars,预算机制对这个分区完全失效。
|
|
309
|
+
// 现在两步:
|
|
310
|
+
// a) 分区内先按 FIXED_PLAN 的 limit 截(保留最早的几条:它们是「开始」和「锚点」);
|
|
311
|
+
// b) 下面裁剪循环在相关区剔光后,允许继续剔固定区(见 ③),并明说还有几条没放下。
|
|
312
|
+
const droppedFixed = { initial: 0, anchors: 0 }
|
|
302
313
|
for (const card of list) {
|
|
303
314
|
const buckets = sectionize(card, now)
|
|
304
315
|
for (const plan of FIXED_PLAN) {
|
|
305
316
|
const section = sectionOf(plan)
|
|
306
|
-
|
|
317
|
+
const all = buckets[plan.key] ?? []
|
|
318
|
+
const room = plan.limit - section.lines.length
|
|
319
|
+
for (const record of all.slice(0, Math.max(0, room))) pushRecord(section, record)
|
|
320
|
+
if (all.length > Math.max(0, room)) droppedFixed[plan.key] += all.length - Math.max(0, room)
|
|
307
321
|
}
|
|
308
322
|
}
|
|
309
323
|
|
|
310
|
-
//
|
|
311
|
-
//
|
|
324
|
+
// 固定区的「可裁顺序」:优先级低的先裁(anchors 100 → initial 120)。
|
|
325
|
+
// 注意这是**这一轮不注入**,不是删数据 —— 卡里那条记录还在,下一轮还会尝试。
|
|
326
|
+
const fixedTrimOrder = [...FIXED_PLAN]
|
|
327
|
+
.sort((a, b) => a.priority - b.priority)
|
|
328
|
+
.map((plan) => sectionOf(plan))
|
|
329
|
+
|
|
330
|
+
// ② 相关区:项目卡 + 全局卡一起打分;多取几倍再按 topK 截,给去重留余量。 // 每行截到 RELATED_LINE_MAX(48 字)—— 见 recalledLine 的注释。
|
|
312
331
|
const merged = { records: list.flatMap((card) => card.records) }
|
|
313
332
|
// 2026-11-05 S3 / P3:原来用 `||` 会吞掉显式传进来的 0,且 options.topK
|
|
314
333
|
// 为 undefined 时 Number(undefined)=NaN 也走不进回退;改成显式判空 + 有限数校验。
|
|
@@ -340,14 +359,37 @@ export function renderRecalledBlock(cards, options = {}) {
|
|
|
340
359
|
}
|
|
341
360
|
|
|
342
361
|
let out = assemble()
|
|
343
|
-
// ③
|
|
362
|
+
// ③ 超预算时先剔相关区(分数最低的);固定区有**独立预算**(maxChars 的 2 倍)。
|
|
363
|
+
//
|
|
364
|
+
// 2026-11-07 P1-D6。这里的取舍是刻意的:
|
|
365
|
+
// · 固定区(「我们的开始」「永远不会忘的」)在 2 倍预算内**宁可超出也完整保留** ——
|
|
366
|
+
// 它的语义就是"永远不会忘",为了预算把它删掉等于插件自己毁约;
|
|
367
|
+
// · 只有极端情况(pinned 攒到几十条,固定区自己就超过 2 倍预算)才裁,
|
|
368
|
+
// 而且末尾明确写「还有 N 条这轮没放下」,让步是可见的;
|
|
369
|
+
// · 裁掉只是**这一轮不注入**,卡里的记录还在,下一轮还会尝试。
|
|
370
|
+
const fixedCeiling = maxChars * 2
|
|
344
371
|
let guard = 0
|
|
345
372
|
while (out.length > maxChars && guard < 1000) {
|
|
346
373
|
guard += 1
|
|
347
|
-
if (related.lines.length
|
|
348
|
-
|
|
374
|
+
if (related.lines.length > 0) {
|
|
375
|
+
popLast(related)
|
|
376
|
+
} else if (out.length > fixedCeiling && fixedTrimOrder.length > 0) {
|
|
377
|
+
const section = fixedTrimOrder[0]
|
|
378
|
+
if (section.lines.length === 0) {
|
|
379
|
+
fixedTrimOrder.shift()
|
|
380
|
+
continue
|
|
381
|
+
}
|
|
382
|
+
popLast(section)
|
|
383
|
+
droppedFixed[section.key] = (droppedFixed[section.key] ?? 0) + 1
|
|
384
|
+
} else {
|
|
385
|
+
break
|
|
386
|
+
}
|
|
349
387
|
out = assemble()
|
|
350
388
|
}
|
|
389
|
+
if (droppedFixed.initial + droppedFixed.anchors > 0) {
|
|
390
|
+
const total = droppedFixed.initial + droppedFixed.anchors
|
|
391
|
+
out = `${out}\n\n(还有 ${total} 条被保护记忆这轮没放下:固定区预算是 ${fixedCeiling} 字,已经用满了。想看得更全可以整理一下 pinned,或调大 injectMaxChars。)`
|
|
392
|
+
}
|
|
351
393
|
|
|
352
394
|
// ④ 兜底回填:还有余量就按分区顺序补。轮转取(每轮每个分区各一条),
|
|
353
395
|
// 否则「关于你的事」几十条会把预算吃光,「最近记得的」一条都进不来。
|
package/lib/memory.js
CHANGED
|
@@ -37,7 +37,7 @@ export { normalizeConfig } from './memory/config.js'
|
|
|
37
37
|
export { emotionScore, redact } from './memory/signals.js'
|
|
38
38
|
export { ownerImportant, scoreRecord, targetClarity } from './memory/scoring.js'
|
|
39
39
|
export { createCard, mergeCards, normalizeCard } from './memory/card.js'
|
|
40
|
-
export { corruptInfoOf, isCardReadonly, loadCard, makeArchiver, recallArchived, saveCard } from './memory/card-io.js'
|
|
40
|
+
export { corruptInfoOf, isCardReadonly, loadCard, makeArchiver, readCardQuietly, recallArchived, saveCard } from './memory/card-io.js'
|
|
41
41
|
export { addRecord, applyDecay, classifyScope, compactCard, daysSince, forgetRecord, setPinned, touchRecords } from './memory/mutation.js'
|
|
42
42
|
export { renderCard, renderRecallOnly, renderRecalledBlock, status } from './memory/render.js'
|
|
43
43
|
export { recall, recallQueryTerms, relatedScore } from './memory/recall.js'
|
package/lib/mood/hooks.js
CHANGED
|
@@ -20,6 +20,17 @@ import { lastAssistantTextOf, lastUserTurnOf, textOfMessage } from './session.js
|
|
|
20
20
|
*/
|
|
21
21
|
const mounted = new WeakMap()
|
|
22
22
|
|
|
23
|
+
/**
|
|
24
|
+
* 2026-11-07 R7 / P1-L1:原来这里存 `{ offs }` 的**强引用** —— 而 `offs` 里的回调
|
|
25
|
+
* 闭包直接引用 `agent`,于是 `mountedOffs → entry → offs → 闭包 → agent` 是一条
|
|
26
|
+
* 强引用链,会话关了 agent 也回收不掉(它身上挂着整个会话的事件历史)。
|
|
27
|
+
* WeakMap 的防泄漏设计被这个 Set 完全抵消了。
|
|
28
|
+
*
|
|
29
|
+
* 现在存 WeakRef:
|
|
30
|
+
* · `mounted` 是 WeakMap,只在 **agent 活着** 时才持有 entry —— 所以 entry 不可能
|
|
31
|
+
* 在 agent 存活期间被回收,不会出现「监听还挂着、off 却调不到」的静默泄漏;
|
|
32
|
+
* · agent 死了,entry 自然可回收,Set 里只留一个空壳,遍历时清掉。
|
|
33
|
+
*/
|
|
23
34
|
const mountedOffs = new Set()
|
|
24
35
|
|
|
25
36
|
let judgeChain = Promise.resolve() // 判断串行,避免多轮堆积互相覆盖
|
|
@@ -104,14 +115,18 @@ export function observeAgent(agent, { llm, config, note }) {
|
|
|
104
115
|
|
|
105
116
|
const entry = { offs }
|
|
106
117
|
mounted.set(agent, entry)
|
|
107
|
-
mountedOffs.add(entry)
|
|
118
|
+
mountedOffs.add(new WeakRef(entry))
|
|
108
119
|
}
|
|
109
120
|
|
|
110
121
|
|
|
111
122
|
/** 拆掉全部钩子(插件卸载/测试用)。 */
|
|
112
123
|
export function unobserveAll() {
|
|
113
|
-
// 遍历 mountedOffs 而不是 mounted:WeakMap
|
|
114
|
-
|
|
124
|
+
// 遍历 mountedOffs 而不是 mounted:WeakMap 不可枚举。
|
|
125
|
+
// 2026-11-07 P1-L1:里面存的是 WeakRef,agent 已经被回收的 entry 会 deref 成 undefined,
|
|
126
|
+
// 那种直接跳过(它的监听随 ctx 一起没了,不需要拆)。
|
|
127
|
+
for (const ref of mountedOffs) {
|
|
128
|
+
const entry = typeof ref?.deref === 'function' ? ref.deref() : ref
|
|
129
|
+
if (entry === undefined || entry === null) continue
|
|
115
130
|
for (const off of entry.offs) {
|
|
116
131
|
try { if (typeof off === 'function') off() } catch { /* ignore */ }
|
|
117
132
|
}
|
|
@@ -120,5 +135,20 @@ export function unobserveAll() {
|
|
|
120
135
|
}
|
|
121
136
|
|
|
122
137
|
|
|
123
|
-
/**
|
|
124
|
-
|
|
138
|
+
/**
|
|
139
|
+
* 测试用:当前还挂着的 agent 数。
|
|
140
|
+
*
|
|
141
|
+
* 2026-11-07 P1-L1:Set 里是 WeakRef,所以要数「deref 还有效」的那些 ——
|
|
142
|
+
* 否则 agent 被回收后这个数字会虚高(空壳也算一个)。
|
|
143
|
+
*/
|
|
144
|
+
export const observedCount = () => {
|
|
145
|
+
let live = 0
|
|
146
|
+
for (const ref of mountedOffs) {
|
|
147
|
+
if (typeof ref?.deref === 'function') {
|
|
148
|
+
if (ref.deref() !== undefined) live += 1
|
|
149
|
+
} else if (ref !== undefined && ref !== null) {
|
|
150
|
+
live += 1
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
return live
|
|
154
|
+
}
|
package/lib/mood/judge.js
CHANGED
|
@@ -25,6 +25,9 @@ const SILICONFLOW_URL = 'https://api.siliconflow.cn/v1/chat/completions'
|
|
|
25
25
|
/** 「没找到密钥」只提示一次(每回合都提示会把 soul.log 淹掉)。 */
|
|
26
26
|
let missingKeyNoted = false
|
|
27
27
|
|
|
28
|
+
/** 2026-11-07 P2-19:自定义 judge provider 的告警也只提示一次。 */
|
|
29
|
+
let customProviderNoted = false
|
|
30
|
+
|
|
28
31
|
|
|
29
32
|
/**
|
|
30
33
|
* 走硅基流动的 OpenAI 兼容接口判心情(2026-11-01)。
|
|
@@ -108,6 +111,19 @@ export async function judgeMood(llm, agent, userText, reply, mode, o, note) {
|
|
|
108
111
|
// ① 配了硅基流动就直接走它的 HTTP API(自己的密钥、自己的小模型)。
|
|
109
112
|
// 宿主的 llm 服务只认得它自己注册过的 provider,硅基流动不在里面,
|
|
110
113
|
// 所以这条路不经过 llm.stream —— 跟日记那条「自己调模型」是同一个思路。
|
|
114
|
+
//
|
|
115
|
+
// 2026-11-07 R8 / P2-19:如果 judgeProvider 填了**别的东西**,这里会落到 ②,
|
|
116
|
+
// 把 { provider, model } 原样交给宿主的 llm.stream。宿主不认识那个 provider 时,
|
|
117
|
+
// 每一轮判定都会失败、只留一行「判断失败」,而用户完全看不出来 ——
|
|
118
|
+
// 表现是「她好像再也不会因为什么事高兴或难过了」。
|
|
119
|
+
// 没法在这里枚举宿主注册了哪些 provider,所以退一步:**第一次**就明确告警。
|
|
120
|
+
if (note && customProviderNoted === false) {
|
|
121
|
+
const provider = String(o.judgeProvider ?? '').trim()
|
|
122
|
+
if (provider !== '' && provider !== 'siliconflow') {
|
|
123
|
+
customProviderNoted = true
|
|
124
|
+
note('mood', `心情判定用的是自定义 provider「${provider}」(不是 siliconflow):它会原样交给宿主的 llm 服务。宿主若不认识这个 provider,每一轮判定都会失败、心情将停止变化 —— 遇到「她情绪一直不变」先查这里。`)
|
|
125
|
+
}
|
|
126
|
+
}
|
|
111
127
|
if (o.judgeProvider === 'siliconflow' && o.judgeModel) {
|
|
112
128
|
const key = loadSecret('siliconflow')
|
|
113
129
|
if (key) return judgeViaSiliconFlow(key, o.judgeModel, sys, user, o, note)
|
package/lib/state/cards.js
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
* 状态与持久化编排 · cards.js
|
|
3
3
|
* 由 lib/store.js 按职责拆出(2026-11-06 模块化重构),函数体保持原样。
|
|
4
4
|
*/
|
|
5
|
-
import { addRecord, classifyScope, corruptInfoOf, createCard, isCardReadonly, loadCard, mergeCards, normalizeConfig, saveCard } from '../memory.js'
|
|
5
|
+
import { addRecord, classifyScope, corruptInfoOf, createCard, isCardReadonly, loadCard, mergeCards, normalizeConfig, readCardQuietly, saveCard } from '../memory.js'
|
|
6
6
|
import { cardCache, loadCached, mtimeOf } from './cache.js'
|
|
7
7
|
import { invalidate } from './file-cache.js'
|
|
8
8
|
import { globalMemoryPath, projectMemoryPath } from '../paths.js'
|
|
@@ -61,7 +61,7 @@ function saveCardMerged(key, file, card) {
|
|
|
61
61
|
const stamp = mtimeOf(file)
|
|
62
62
|
let target = card
|
|
63
63
|
if (hit !== undefined && stamp !== 0 && hit.stamp !== stamp) {
|
|
64
|
-
const disk =
|
|
64
|
+
const disk = readCardQuietly(file)
|
|
65
65
|
if (disk !== null) {
|
|
66
66
|
// R01 / T3:合并前比一次 rev,只做观测 —— 不改合并结果、不拒绝写、不加墓碑。
|
|
67
67
|
const ourRev = revOf(card.rev)
|
|
@@ -83,6 +83,21 @@ function saveCardMerged(key, file, card) {
|
|
|
83
83
|
// 由调用方依据 saved.ok 决定(本函数只负责不再丢数据)。
|
|
84
84
|
if (saved?.ok === true) {
|
|
85
85
|
invalidate(cardCache, key)
|
|
86
|
+
// 2026-11-07 R7 / P1-D5:写后回读一次 rev —— **只检测、不自动重写**。
|
|
87
|
+
//
|
|
88
|
+
// 背景:stamp → loadCard → mergeCards → saveCard 之间没有锁,两个 DSH 进程同时写时
|
|
89
|
+
// 后写者会整份盖掉先写者。彻底解法是文件锁或写后重合并,但那条路要给**每一次写盘**
|
|
90
|
+
// 加成本,而多进程并发是低频场景。
|
|
91
|
+
//
|
|
92
|
+
// 这里取的是折中:写完读一眼盘上的 rev,如果比我们刚写的还大,说明有人在我们之后
|
|
93
|
+
// 写成功了(我们的记录可能被盖)。只在日志里留一行,交给用户判断。
|
|
94
|
+
// 绝不静默 ——「另一条记忆莫名其妙没了」比「多一次 append-only 日志」难查得多。
|
|
95
|
+
const disk = readCardQuietly(file)
|
|
96
|
+
const diskRev = revOf(disk?.rev)
|
|
97
|
+
const ourRev = revOf(target.rev)
|
|
98
|
+
if (disk !== null && diskRev > ourRev) {
|
|
99
|
+
note('memory', `${key}:写完后盘上 rev=${diskRev} 比我们写的 rev=${ourRev} 新 —— 可能有另一个 DSH 进程同时写入,本次改动可能已被覆盖(检测到就报,不自动重试)`)
|
|
100
|
+
}
|
|
86
101
|
} else {
|
|
87
102
|
note('memory', `${key}:写盘失败,保留内存缓存待重试(${saved?.error ?? '未知原因'})`)
|
|
88
103
|
}
|
package/lib/state/maintain.js
CHANGED
|
@@ -13,6 +13,35 @@ 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
|
+
|
|
20
|
+
/**
|
|
21
|
+
* 从记忆记录里挑「最近被想起的 N 条」喂给 deriveDrives。
|
|
22
|
+
*
|
|
23
|
+
* 2026-11-07 R7 / P1-L2,抽成纯函数是为了能单独测:
|
|
24
|
+
* · 口径按 lastSeenAt(最近被聊到)优先,缺了退回 createdAt;
|
|
25
|
+
* · 两者都没有的按 0 算 —— 不能让「没有时间的旧记录」假扮成最新;
|
|
26
|
+
* · 同分时保持原顺序(稳定排序),避免每次 maintain 的素材顺序抖动。
|
|
27
|
+
*/
|
|
28
|
+
export function pickRecentMaterials(records, limit = 12) {
|
|
29
|
+
const stampOf = (record) => {
|
|
30
|
+
const seen = Date.parse(String(record?.lastSeenAt ?? ''))
|
|
31
|
+
if (Number.isFinite(seen) && seen > 0) return seen
|
|
32
|
+
const created = Date.parse(String(record?.createdAt ?? ''))
|
|
33
|
+
if (Number.isFinite(created) && created > 0) return created
|
|
34
|
+
return 0
|
|
35
|
+
}
|
|
36
|
+
const n = Math.max(1, Math.trunc(Number(limit) || 12))
|
|
37
|
+
return (Array.isArray(records) ? records : [])
|
|
38
|
+
.map((record, index) => ({ record, index, stamp: stampOf(record) }))
|
|
39
|
+
.sort((a, b) => (b.stamp - a.stamp) || (a.index - b.index))
|
|
40
|
+
.slice(0, n)
|
|
41
|
+
.map(({ record }) => ({ text: record.text, title: record.title }))
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
|
|
16
45
|
|
|
17
46
|
/**
|
|
18
47
|
* 每日维护:衰减 + 压缩 + 遗忘存档。
|
|
@@ -99,10 +128,14 @@ export function maintain(cwd, config = {}) {
|
|
|
99
128
|
// 素材刺激:把最近记下的东西喂进 deriveDrives。
|
|
100
129
|
// 之前这里永远不传 materials,于是 curiosity / mastery 只能靠自然衰减 + 空闲上涨,
|
|
101
130
|
// README 写的「被聊到的内容会推高对应维度」从来没兑现过 —— 属于参数留了口子但没人接。
|
|
102
|
-
|
|
131
|
+
//
|
|
132
|
+
// 2026-11-07 R7 / P1-L2:原来用 `.slice(-12)`,隐含假设 records 按时间有序。
|
|
133
|
+
// 但 mergeCards 会把**别的进程的旧记录排到尾部** —— 跨进程合并过一次之后,
|
|
134
|
+
// 「最近 12 条」可能是很久以前的。现在显式按时间排序取前 12(口径见 pickRecentMaterials)。
|
|
135
|
+
const materials = pickRecentMaterials([
|
|
103
136
|
...globalCard().records,
|
|
104
137
|
...(String(cwd ?? '').trim() !== '' ? projectCard(cwd).records : [])
|
|
105
|
-
]
|
|
138
|
+
], 12)
|
|
106
139
|
const derived = deriveDrives({
|
|
107
140
|
drives: state.drives,
|
|
108
141
|
drivesAt: state.drivesAt,
|
|
@@ -110,9 +143,29 @@ export function maintain(cwd, config = {}) {
|
|
|
110
143
|
idleHours: hours,
|
|
111
144
|
materials
|
|
112
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
|
+
})()
|
|
113
162
|
state.drives = derived.drives
|
|
114
163
|
state.drivesAt = derived.drivesAt
|
|
115
|
-
|
|
164
|
+
const nowMs = Date.now()
|
|
165
|
+
if (moved || nowMs - lastPurposeWriteAt > PURPOSE_WRITE_EVERY_MS) {
|
|
166
|
+
savePurposeState(state)
|
|
167
|
+
lastPurposeWriteAt = nowMs
|
|
168
|
+
}
|
|
116
169
|
}
|
|
117
170
|
|
|
118
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
|
-
|
|
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.
|
|
3
|
+
"version": "0.9.3",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"description": "给 DSH 的 agent 一套会忘事的记忆、一份会变的人格和一份会起伏的心情:人格按小节合并(项目覆盖全局但不吃掉全局),记忆按人的规律衰减(清晰→模糊→只剩印象→遗忘),「心里惦记的事」让她的主动有连续性,心情跟着每轮对话自己判断、自己平复(不注入、无挂饰)。",
|
|
6
6
|
"keywords": [
|
|
@@ -29,6 +29,7 @@
|
|
|
29
29
|
"tools",
|
|
30
30
|
"cordis.patch.yml",
|
|
31
31
|
"README.md",
|
|
32
|
+
"CHANGELOG.md",
|
|
32
33
|
"LICENSE"
|
|
33
34
|
],
|
|
34
35
|
"scripts": {
|