dsh-agent-soul 0.9.1 → 0.9.2
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 +101 -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/host/runtime/turns.js +15 -1
- 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 +31 -2
- package/package.json +2 -1
package/CHANGELOG.md
ADDED
|
@@ -0,0 +1,101 @@
|
|
|
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.2 · 2026-11-07
|
|
11
|
+
|
|
12
|
+
### 修复
|
|
13
|
+
|
|
14
|
+
- **合并路径会把主记忆文件挪走**(P2-12,数据安全级):`saveCardMerged` 在合并前调 `loadCard`,而它的 catch 会 `parkCorrupt` —— 一次瞬时读失败就把主卡改名 + 置只读,随后写盘往空路径写新卡。新增无副作用读 `readCardQuietly`,合并与写后回读都改用它;`loadCard` 只留给真正的加载路径。
|
|
15
|
+
- **鉴权链没有任何兜底**:Origin / Host / 回环 / 令牌四段校验原先裸奔在 handler 体里,任何一段将来抛错都会逃出 `webServer` → 未捕获 → **宿主进程退出**。现在整段包一层 catch,异常记日志 + 回 500 + 追踪码。
|
|
16
|
+
- **自定义 judge provider 静默失败**(P2-19):`judgeProvider` 配成非 siliconflow 时会把 provider 原样交给宿主,宿主不认识就每轮判定失败、只留一行日志,表现为「她情绪一直不变」。现在第一次调用就明确告警。
|
|
17
|
+
- **设置页改配置会丢**(P2-25/26):三个 Tab 原来都 POST **全量**配置,跨 Tab 保存互相覆盖;文本输入框还是逐键 POST。现在各 Tab 只发改动键(服务端本就按 key 合并),并加 300ms 防抖。
|
|
18
|
+
- **记忆搜索逐键重取**(P2-28):带 query 时 300ms 防抖。
|
|
19
|
+
- **日记「文件存在但不完整」死循环**:`startupWork` 判定要重写,但 `askAgentToWrite` 只要看到文件存在就认为「她写好了」,于是每轮空转、日志写「日记完成」,内容永远补不回来。现在「要不要再找她写」多了时间基线(`shouldAskAgain`)。
|
|
20
|
+
- **兜底覆盖她迟到写出的日记**:`waitForWrite` 超时后插件兜底写盘,会盖掉她几秒后落盘的那篇。`writeDiaryFile` 增加 `skipIfNewerThan`,比她旧才写。
|
|
21
|
+
- **`lastTalkAtOf` 只扫末 80 行**:文件本就整份读进内存,只遍历尾部纯属遗留写法;多会话交错时最后一句会被挤出窗口,导致「半天版」被判完整。
|
|
22
|
+
- **固定区(pinned / initial)无上限**:固定区有独立预算(`injectMaxChars × 2`),2 倍以内宁可超出也完整保留,超过才裁并明说「还有 N 条这轮没放下」。
|
|
23
|
+
- **游标在 `snapshotEvents` 抛错时不推进**:现在一定推进,且整卡注入只宽限一次。
|
|
24
|
+
- **`mountedOffs` 强引用**:改存 `WeakRef`,会话关闭后 agent 可被回收。
|
|
25
|
+
- **喂给 `drives` 的素材顺序**:由「数组尾部 12 条」改为按 `lastSeenAt`(最近被想起)优先排序。
|
|
26
|
+
- **跨进程写卡竞态**:写后回读 `rev`,发现被别人覆盖时记日志(**只检测,不自动重写**)。
|
|
27
|
+
|
|
28
|
+
### 变更
|
|
29
|
+
|
|
30
|
+
- `lib/state/maintain.js` 新增 `pickRecentMaterials`(纯函数,可单独测)。
|
|
31
|
+
- `lib/memory/card-io.js` 新增 `readCardQuietly`(无副作用读卡)。
|
|
32
|
+
- 客户端新增 `apiPostDebounced`(按 key 防抖的 POST)。
|
|
33
|
+
|
|
34
|
+
---
|
|
35
|
+
|
|
36
|
+
## 0.9.1 · 2026-11-07
|
|
37
|
+
|
|
38
|
+
### 修复(安全)
|
|
39
|
+
|
|
40
|
+
- **反代部署下 `/api/soul/*` 全量 403**([#1](https://github.com/danshuyue/dsh-agent-soul/issues/1)):
|
|
41
|
+
Host 判定改为**以宿主为准** —— 先问 `ctx.connection.requestRejection(req)`,
|
|
42
|
+
`null` 放行、`401`(宿主侧未登录)放行到插件自己的 `x-soul-token` 校验、`403` 才拒;
|
|
43
|
+
宿主不可用 / 抛错时退回插件白名单。原来插件自维护信任名单,与宿主 `--trusted-host` 两套 fence 打架。
|
|
44
|
+
- **任意文件读取**(`GET /state?cwd=<任意目录>` 可读该目录 `AGENT.md` 前 400 字):
|
|
45
|
+
cwd 归属校验收口,`GET /persona` 一并补上。
|
|
46
|
+
- **`GET /persona` 绕过 cwd 归属校验**且返回全文。
|
|
47
|
+
- **UNC / 设备路径**(`\\host\share`、`\\.\`、`\\?\`):`statSync` 会发起 SMB 连接并携带 NTLM 凭据,且同步阻塞事件循环。现在字符串阶段直接拒,`statSync` 挪到归属判定之后。
|
|
48
|
+
- **`sec-fetch-site` 值拼错**(`'samesite'` ≠ `'same-site'`),同站防线此前从未生效。
|
|
49
|
+
- **错误原文回显**:`/pick`、`/persona` 保存、`/open` 三处不再把含绝对路径的 `error.message` 回给客户端,改为固定文案 + 追踪码。
|
|
50
|
+
- **数据边界可伪造**:`<user_data>` 换成带内容哈希 nonce 的 `<untrusted_data>`,内容拼不出真闭合标签;人格段补 `PERSONA_GUARD` 声明。
|
|
51
|
+
- **配置数值无上限**:新增 `NUMBER_RANGES` 覆盖 35 个数值键,越界拒绝(此前 `diaryAgentTimeoutMs = 1e12` 也能存)。
|
|
52
|
+
- **日记主流程无总超时**:12 分钟总预算 + 超时后 orphan 防重入。
|
|
53
|
+
- **`/register` 反向放行归属校验**:新增写侧唯一入口 `resolvePostCwd`。
|
|
54
|
+
- **PowerShell 回退链是断的**(裸名字分支直接 return,第三级永远不可达);顺带校验 DPAPI 输出,避免存下解不开的空密文。
|
|
55
|
+
- **`POST /memory` 的 `edit` 分支绕过脱敏**。
|
|
56
|
+
- **`maintain` 无视 `projectMemoryEnabled`**。
|
|
57
|
+
- **记忆卡容量到顶且无可压缩项时仍 `push`**。
|
|
58
|
+
- **Origin/Host 端口比较**:`String(host).split(':')[1]` 对无端口的 Host 与 `[::1]:8080` 都恒不相等;改为规范化权威比较,两端同为回环时允许端口不同。
|
|
59
|
+
|
|
60
|
+
### 变更
|
|
61
|
+
|
|
62
|
+
- 新增一次性提示:接口被非本机 Host 访问时在日志里提醒(只记一次)。
|
|
63
|
+
|
|
64
|
+
### 破坏性
|
|
65
|
+
|
|
66
|
+
- **`POST /register` 不再接受任意路径**:只接受「已登记 / 宿主会话给的 / `DSH_HOME` 内」。设置页「把路径粘到输入框」这条路关闭,请改用「选择文件夹」。
|
|
67
|
+
- **`POST /config` 数值越界返回 400**(此前静默接受)。
|
|
68
|
+
- `DSH_SOUL_POWERSHELL` 指向不存在的路径时保存密钥直接失败,不再静默回退。
|
|
69
|
+
|
|
70
|
+
---
|
|
71
|
+
|
|
72
|
+
## 0.9.0 · 2026-11-06
|
|
73
|
+
|
|
74
|
+
### 变更
|
|
75
|
+
|
|
76
|
+
- **模块化重构**:`lib/` 拆成 95 个模块(`host/runtime`、`memory/`、`state/`、`diary/`、`http/`、`core/`)。
|
|
77
|
+
- 新增契约门禁三件套:导出快照、行为 golden、依赖图;刷基线必须写明理由并留痕。
|
|
78
|
+
|
|
79
|
+
### 破坏性
|
|
80
|
+
|
|
81
|
+
- **新增 Host 白名单**(见 `0.8.3`):`/api/soul/*` 只接受 `localhost` / `127.0.0.1` / `[::1]` / `::1`
|
|
82
|
+
以及 `DSH_SOUL_ALLOWED_HOSTS` 里的值。**反向代理 + 公网域名/IP 的部署会整页 403** ——
|
|
83
|
+
这就是 `0.9.1` 修的那条([#1](https://github.com/danshuyue/dsh-agent-soul/issues/1))。
|
|
84
|
+
当时没有写进任何变更说明,是本项目的流程失误。
|
|
85
|
+
|
|
86
|
+
---
|
|
87
|
+
|
|
88
|
+
## 0.8.3 · 2026-11-06
|
|
89
|
+
|
|
90
|
+
### 变更
|
|
91
|
+
|
|
92
|
+
- 加固(R2/R3/R4):**Host 白名单**、`localNames` 只认纯文件名、回环门控下沉。
|
|
93
|
+
|
|
94
|
+
> **注意**:`DSH_SOUL_ALLOWED_HOSTS` 是 `DSH_` 前缀的启动期变量,**只能**通过
|
|
95
|
+
> `systemd Environment=` / `docker -e` / shell `export` 设置。写进 `.env` 会让 dsh 直接启动失败。
|
|
96
|
+
|
|
97
|
+
---
|
|
98
|
+
|
|
99
|
+
## 0.8.0 – 0.8.2 · 2026-11-05 / 11-06
|
|
100
|
+
|
|
101
|
+
无变更记录(本文件从 `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
|
}
|
|
@@ -129,7 +129,21 @@ export function isFirstTurnOfSession(agent) {
|
|
|
129
129
|
return true
|
|
130
130
|
}
|
|
131
131
|
} catch {
|
|
132
|
-
return true
|
|
132
|
+
// 2026-11-07 R7 / P1-D1:原来这里直接 `return true`,游标和 human 计数都不动 ——
|
|
133
|
+
// 一旦宿主在压缩/继承会话上抛错,每轮都当「第一轮」:整卡注入 + 从头重扫。
|
|
134
|
+
//
|
|
135
|
+
// 现在的处理分两半,边界要说清:
|
|
136
|
+
// · 游标**一定推进**到 seq —— 这一半没有副作用,无论抛不抛都比原来好(省掉重扫);
|
|
137
|
+
// · 返回值**宽限一次**:第一次失败仍然当第一轮(保证新会话不失忆),
|
|
138
|
+
// 之后不再重复整卡注入(否则 token 白烧、上下文越滚越大)。
|
|
139
|
+
//
|
|
140
|
+
// 这条修法依赖「宿主到底会不会抛」这个前提。我在仓库里验证不了(宿主是打包的 asar),
|
|
141
|
+
// 所以选了最保守的一版:不改变成功路径的任何行为,失败路径只做「少做一次错事」。
|
|
142
|
+
// 如果以后有人报「新会话没有人格/记忆」,第一个该看的就是这里。
|
|
143
|
+
const firstFailure = (state.degraded ?? 0) === 0
|
|
144
|
+
state.degraded = (state.degraded ?? 0) + 1
|
|
145
|
+
state.cursor = Math.max(state.cursor, seq)
|
|
146
|
+
return firstFailure
|
|
133
147
|
}
|
|
134
148
|
|
|
135
149
|
if (!Array.isArray(events)) return true
|
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,31 @@ import { note } from '../env.js'
|
|
|
13
13
|
import { purposeState, savePurposeState } from './cache.js'
|
|
14
14
|
import { writeDailyHealth } from '../health.js'
|
|
15
15
|
|
|
16
|
+
/**
|
|
17
|
+
* 从记忆记录里挑「最近被想起的 N 条」喂给 deriveDrives。
|
|
18
|
+
*
|
|
19
|
+
* 2026-11-07 R7 / P1-L2,抽成纯函数是为了能单独测:
|
|
20
|
+
* · 口径按 lastSeenAt(最近被聊到)优先,缺了退回 createdAt;
|
|
21
|
+
* · 两者都没有的按 0 算 —— 不能让「没有时间的旧记录」假扮成最新;
|
|
22
|
+
* · 同分时保持原顺序(稳定排序),避免每次 maintain 的素材顺序抖动。
|
|
23
|
+
*/
|
|
24
|
+
export function pickRecentMaterials(records, limit = 12) {
|
|
25
|
+
const stampOf = (record) => {
|
|
26
|
+
const seen = Date.parse(String(record?.lastSeenAt ?? ''))
|
|
27
|
+
if (Number.isFinite(seen) && seen > 0) return seen
|
|
28
|
+
const created = Date.parse(String(record?.createdAt ?? ''))
|
|
29
|
+
if (Number.isFinite(created) && created > 0) return created
|
|
30
|
+
return 0
|
|
31
|
+
}
|
|
32
|
+
const n = Math.max(1, Math.trunc(Number(limit) || 12))
|
|
33
|
+
return (Array.isArray(records) ? records : [])
|
|
34
|
+
.map((record, index) => ({ record, index, stamp: stampOf(record) }))
|
|
35
|
+
.sort((a, b) => (b.stamp - a.stamp) || (a.index - b.index))
|
|
36
|
+
.slice(0, n)
|
|
37
|
+
.map(({ record }) => ({ text: record.text, title: record.title }))
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
|
|
16
41
|
|
|
17
42
|
/**
|
|
18
43
|
* 每日维护:衰减 + 压缩 + 遗忘存档。
|
|
@@ -99,10 +124,14 @@ export function maintain(cwd, config = {}) {
|
|
|
99
124
|
// 素材刺激:把最近记下的东西喂进 deriveDrives。
|
|
100
125
|
// 之前这里永远不传 materials,于是 curiosity / mastery 只能靠自然衰减 + 空闲上涨,
|
|
101
126
|
// README 写的「被聊到的内容会推高对应维度」从来没兑现过 —— 属于参数留了口子但没人接。
|
|
102
|
-
|
|
127
|
+
//
|
|
128
|
+
// 2026-11-07 R7 / P1-L2:原来用 `.slice(-12)`,隐含假设 records 按时间有序。
|
|
129
|
+
// 但 mergeCards 会把**别的进程的旧记录排到尾部** —— 跨进程合并过一次之后,
|
|
130
|
+
// 「最近 12 条」可能是很久以前的。现在显式按时间排序取前 12(口径见 pickRecentMaterials)。
|
|
131
|
+
const materials = pickRecentMaterials([
|
|
103
132
|
...globalCard().records,
|
|
104
133
|
...(String(cwd ?? '').trim() !== '' ? projectCard(cwd).records : [])
|
|
105
|
-
]
|
|
134
|
+
], 12)
|
|
106
135
|
const derived = deriveDrives({
|
|
107
136
|
drives: state.drives,
|
|
108
137
|
drivesAt: state.drivesAt,
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "dsh-agent-soul",
|
|
3
|
-
"version": "0.9.
|
|
3
|
+
"version": "0.9.2",
|
|
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": {
|