dsh-agent-soul 0.4.2 → 0.5.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +75 -2
- package/docs//345/276/205/345/201/232/347/232/204/344/270/211/344/273/266/344/272/213.md +259 -0
- package/lib/api.js +26 -1
- package/lib/client/diary-tab.js +4 -2
- package/lib/client/mood-tab.js +61 -2
- package/lib/client/overview-tab.js +39 -1
- package/lib/client.js +104 -5
- package/lib/diary.js +128 -16
- package/lib/extract.js +40 -5
- package/lib/host.js +271 -0
- package/lib/index.js +129 -2
- package/lib/memory.js +204 -37
- package/lib/mood.js +112 -55
- package/lib/secrets.js +173 -0
- package/lib/store.js +51 -8
- package/lib/threads.js +251 -0
- package/lib/tone.js +160 -0
- package/package.json +11 -3
package/lib/host.js
ADDED
|
@@ -0,0 +1,271 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* host.js —— 宿主私有字段的唯一入口 + 启动自检(2026-11-01,审计 C7)
|
|
3
|
+
*
|
|
4
|
+
* 为什么单独开一个文件:
|
|
5
|
+
* 插件读的全是 DSH 的内部实现 —— `session.snapshotEvents`、事件正文在
|
|
6
|
+
* `data.content`、`header.origin === 'subagent'`、`session.firstLiveSeq`。
|
|
7
|
+
* 这些都不是公开契约,宿主一升级就可能变。
|
|
8
|
+
*
|
|
9
|
+
* **而且已经静默碎过一次**:正文其实在 data.content,代码写成了
|
|
10
|
+
* data.message.content,可选链一路吃到 undefined,于是候选永远是 0、
|
|
11
|
+
* 扫描在跑、日志一句不报 —— 看文件查不出来,只有「她怎么什么都不记得」。
|
|
12
|
+
*
|
|
13
|
+
* 所以这里做两件事:
|
|
14
|
+
* ① 所有私有字段只从这个文件读(要碎就碎一处,别散落六个文件)
|
|
15
|
+
* ② probeHost() 在会话第一轮做一次形状自检,**形状不对就喊出来**:
|
|
16
|
+
* 写日志 + 落一个 host-probe.json,设置页亮红(api.js 读的就是它)
|
|
17
|
+
*
|
|
18
|
+
* 自检的判据是「能不能真的抠出文字」,不是「函数在不在」——
|
|
19
|
+
* 上一次事故里函数全都在,只是返回了空串。
|
|
20
|
+
*/
|
|
21
|
+
import { existsSync, readFileSync } from 'node:fs'
|
|
22
|
+
import { atomicWrite, agentsDir } from './paths.js'
|
|
23
|
+
import { note } from './env.js'
|
|
24
|
+
|
|
25
|
+
/** 自检结果的落盘位置(api.js / 设置页读它)。 */
|
|
26
|
+
export const HOST_PROBE_FILE = () => `${agentsDir()}/host-probe.json`
|
|
27
|
+
|
|
28
|
+
/** 事件正文的容器:新宿主用 data,mood 那条老链路用 payload。 */
|
|
29
|
+
export function holderOf(event) {
|
|
30
|
+
if (event === null || event === undefined) return undefined
|
|
31
|
+
return event.payload !== undefined ? event.payload : event.data
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
/**
|
|
35
|
+
* 抠正文。**只取 text 块**,reasoning(思考)不算正文 —— 那是在想,不是在说。
|
|
36
|
+
* 拿不到就返回空串,绝不猜。
|
|
37
|
+
*/
|
|
38
|
+
export function firstTextOf(event, depth = 0) {
|
|
39
|
+
const holder = holderOf(event)
|
|
40
|
+
if (holder === null || holder === undefined || depth > 4) return ''
|
|
41
|
+
const content = holder.content ?? holder.message?.content ?? holder.text
|
|
42
|
+
if (typeof content === 'string') return content.trim()
|
|
43
|
+
if (Array.isArray(content)) {
|
|
44
|
+
const parts = []
|
|
45
|
+
for (const block of content) {
|
|
46
|
+
if (typeof block === 'string') { parts.push(block); continue }
|
|
47
|
+
if (block === null || block === undefined) continue
|
|
48
|
+
if (block.type === 'text' && typeof block.text === 'string') parts.push(block.text)
|
|
49
|
+
}
|
|
50
|
+
return parts.join(' ').trim()
|
|
51
|
+
}
|
|
52
|
+
// 再往下一层(老格式 / 别的宿主写法)
|
|
53
|
+
if (holder.message !== undefined) return firstTextOf({ data: holder.message }, depth + 1)
|
|
54
|
+
return ''
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/**
|
|
58
|
+
* 这条会话是不是子智能体发起的(新版字段变了也算)。
|
|
59
|
+
*
|
|
60
|
+
* ⚠️ 只认明确的“子会话”标记,**不认 parentSessionId**:
|
|
61
|
+
* 从别的会话 fork 出来的主会话很可能也带 parentSessionId,
|
|
62
|
+
* 一旦把它判成子会话,记忆注入会在 index.js 里直接 return '' ——
|
|
63
|
+
* 那比“子会话多注入了记忆”严重得多(整场失忆且不报错)。
|
|
64
|
+
* 宁可漏判(退回旧行为),也不要误判。
|
|
65
|
+
*/
|
|
66
|
+
export function isSubagentAgent(agent) {
|
|
67
|
+
const header = agent?.session?.header
|
|
68
|
+
if (header === null || header === undefined) return false
|
|
69
|
+
if (header.origin === 'subagent') return true
|
|
70
|
+
if (header.kind === 'subagent' || header.agentKind === 'subagent') return true
|
|
71
|
+
return false
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
/** 拿会话事件快照:API 不在就返回 null(调用方必须当"拿不到"处理,别当"没有事件")。 */
|
|
75
|
+
export function snapshotOf(agent, from, to) {
|
|
76
|
+
const session = agent?.session
|
|
77
|
+
if (session === null || session === undefined) return null
|
|
78
|
+
if (typeof session.snapshotEvents !== 'function') return null
|
|
79
|
+
try {
|
|
80
|
+
const list = to === undefined ? session.snapshotEvents(from) : session.snapshotEvents(from, to)
|
|
81
|
+
return Array.isArray(list) ? list : null
|
|
82
|
+
} catch {
|
|
83
|
+
return null
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
/**
|
|
88
|
+
* 自检要看的区间:**不要从 0 开始**。
|
|
89
|
+
*
|
|
90
|
+
* `snapshotEvents(0)` 在压缩/继承会话上可能越界抛错,而且会把整场历史全拷一遍 ——
|
|
91
|
+
* 这是每轮都走的同步装配路径,长会话(几千条)会卡一下。
|
|
92
|
+
* 取最近 200 条足够验证形状,也避开了"从 0 取"这种边界。
|
|
93
|
+
*/
|
|
94
|
+
function probeWindowOf(session) {
|
|
95
|
+
const seq = Number(session?.seq)
|
|
96
|
+
const firstLive = Number.isFinite(Number(session?.firstLiveSeq)) ? Number(session.firstLiveSeq) : 0
|
|
97
|
+
const from = Math.max(0, firstLive, Number.isFinite(seq) ? seq - 200 : 0)
|
|
98
|
+
const to = Number.isFinite(seq) ? seq + 1 : undefined
|
|
99
|
+
return { from, to }
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/** 继承来的历史起点(拿不到就 0,等价于"从头发")。 */
|
|
103
|
+
export function firstLiveSeqOf(agent) {
|
|
104
|
+
const value = agent?.session?.firstLiveSeq
|
|
105
|
+
return typeof value === 'number' && Number.isFinite(value) ? value : 0
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/**
|
|
109
|
+
* 形状自检。返回 { ok, checks }:
|
|
110
|
+
* ok === true 形状是对的
|
|
111
|
+
* ok === false 确实坏了(该亮红灯)
|
|
112
|
+
* ok === null **未判定**(会话刚开、还没有事件)—— 不能算绿,否则任何新会话
|
|
113
|
+
* 首轮都能把别的会话留下的红灯撤掉,红灯就不可信了
|
|
114
|
+
*
|
|
115
|
+
* @param extractText 必须传**真正在用的那个抽取函数**(extract.js 那套)。
|
|
116
|
+
* 这里默认用本文件的 firstTextOf,但那是给自检用的容错版本 ——
|
|
117
|
+
* 真正干活的是 extract.js 的 messageContentOf + textOfContent。
|
|
118
|
+
* 两边一分叉,自检通过而提取照样失败,等于白查(这正是要防的那种"查不出来")。
|
|
119
|
+
* @param classify 可选,判断「这条是不是真人消息且认得出来」。注入事件本身也是
|
|
120
|
+
* user/message 且带正文,只看"能不能抠出字"会把注入的消息当成证据 ——
|
|
121
|
+
* 真人那条链路改名后自检全绿、候选恒 0,正是要防的漏报。
|
|
122
|
+
*/
|
|
123
|
+
export function probeHost(agent, { extractText = firstTextOf, classify = null } = {}) {
|
|
124
|
+
const session = agent?.session
|
|
125
|
+
const checks = []
|
|
126
|
+
const add = (name, ok, detail = '') => checks.push({ name, ok: ok === true, detail })
|
|
127
|
+
|
|
128
|
+
add('session.snapshotEvents', typeof session?.snapshotEvents === 'function',
|
|
129
|
+
'没有这个函数就拿不到任何事件')
|
|
130
|
+
// header.id 改名是最可能的宿主变更之一。extract.js 早就写了 `header?.id ?? session?.id`
|
|
131
|
+
// 的兜底,自检必须跟上 —— 否则这条检查永远走不到(拿不到 id 时 probeHostOnce 直接跳过)。
|
|
132
|
+
const headerId = session?.header?.id
|
|
133
|
+
const fallbackId = session?.id
|
|
134
|
+
add('session.header.id', (typeof headerId === 'string' && headerId !== '')
|
|
135
|
+
|| (typeof fallbackId === 'string' && fallbackId !== ''),
|
|
136
|
+
'会话 id 拿不到(header.id 也没有 session.id 兜底),粘性状态和"已说过"集合会串会话')
|
|
137
|
+
|
|
138
|
+
const { from, to } = probeWindowOf(session)
|
|
139
|
+
const sample = snapshotOf(agent, from, to)
|
|
140
|
+
add('snapshotEvents 返回数组', sample !== null, '返回的不是数组或调用抛错(宿主改了签名?)')
|
|
141
|
+
|
|
142
|
+
let undetermined = false
|
|
143
|
+
if (sample !== null && sample.length === 0) {
|
|
144
|
+
// 0 条事件:可能只是会话刚开。但 seq 已经走过了却取不到事件 → 一定是坏了
|
|
145
|
+
const seq = Number(session?.seq)
|
|
146
|
+
if (Number.isFinite(seq) && seq > 0) {
|
|
147
|
+
add('事件可取到', false, 'seq 已经推进了,快照却是空的(区间/签名变了?)')
|
|
148
|
+
} else {
|
|
149
|
+
undetermined = true // 还没有事件,判不了,不能算绿
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
if (sample !== null && sample.length > 0) {
|
|
154
|
+
const messageLike = sample.filter((event) => String(event?.type ?? event?.kind ?? '').endsWith('/message'))
|
|
155
|
+
const withText = sample.filter((event) => extractText(event) !== '')
|
|
156
|
+
|
|
157
|
+
if (messageLike.length === 0) {
|
|
158
|
+
// 2026-11-01 线上假红灯:刚重启的会话,快照里只有 4 条非消息事件,
|
|
159
|
+
// 于是「一条正文都抠不出来」直接失败 —— 可真实提取一直是好的。
|
|
160
|
+
//
|
|
161
|
+
// 样本里**根本没有消息类事件**时判不了,只能是「未判定」。
|
|
162
|
+
// 但样本够大(≥10 条)却一条消息类事件都没有,那就不是"还没开始聊",
|
|
163
|
+
// 而是消息事件类型改名了 —— 这种仍要报,否则 C7 的漏报又回来了。
|
|
164
|
+
if (sample.length >= 10) {
|
|
165
|
+
add('消息事件存在', false, `${sample.length} 条事件里没有一条消息类事件(type 可能改名了)`)
|
|
166
|
+
} else {
|
|
167
|
+
undetermined = true
|
|
168
|
+
}
|
|
169
|
+
} else {
|
|
170
|
+
// ⭐ 最要紧的一条:有消息事件但一条正文都抠不出来 = 当年那次静默失效的形状
|
|
171
|
+
add('事件正文可解析', withText.length > 0,
|
|
172
|
+
`${sample.length} 条事件里一条正文都抠不出来(正文位置可能变了)`)
|
|
173
|
+
add('消息事件带正文', messageLike.some((event) => extractText(event) !== ''),
|
|
174
|
+
'message 类型的事件里没有能用的正文')
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
// 只在「样本里确实有真人消息」时才要求 classify 认得出:
|
|
178
|
+
// 一条真人消息都没有(比如首轮全是注入)就不判,免得开个假红灯。
|
|
179
|
+
if (typeof classify === 'function') {
|
|
180
|
+
const humanLike = sample.filter((event) => String(holderOf(event)?.source?.kind ?? '') === 'user')
|
|
181
|
+
if (humanLike.length > 0) {
|
|
182
|
+
add('真人消息可识别', humanLike.some((event) => classify(event) === true),
|
|
183
|
+
`有 ${humanLike.length} 条 source.kind=user 的事件,一条都没被提取链认出来`)
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
const allOk = checks.every((check) => check.ok === true)
|
|
189
|
+
const ok = allOk === false ? false : (undetermined === true ? null : true)
|
|
190
|
+
return { ok, checks }
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
/** 有 id 的会话按 id 去重;拿不到 id 的按对象去重(WeakSet,不泄漏)。 */
|
|
194
|
+
const probed = new Set()
|
|
195
|
+
let probedWeak = new WeakSet()
|
|
196
|
+
|
|
197
|
+
/** 每个会话自检一次;坏了就喊(日志 + 落盘给设置页)。 */
|
|
198
|
+
export function probeHostOnce(agent, options = {}) {
|
|
199
|
+
const session = agent?.session
|
|
200
|
+
const id = String(session?.header?.id ?? session?.id ?? '')
|
|
201
|
+
if (id !== '') {
|
|
202
|
+
if (probed.has(id)) return null
|
|
203
|
+
// 超限删最旧,别 clear():一 clear,正在跑的长会话下一轮会被当成新会话重扫一遍
|
|
204
|
+
if (probed.size > 200) {
|
|
205
|
+
const oldest = probed.values().next().value
|
|
206
|
+
if (oldest !== undefined) probed.delete(oldest)
|
|
207
|
+
}
|
|
208
|
+
probed.add(id)
|
|
209
|
+
} else if (session !== null && typeof session === 'object') {
|
|
210
|
+
// 连 id 都拿不到也要照常自检 —— 让上面那条检查自己报出来,而不是静默返回
|
|
211
|
+
if (probedWeak.has(session)) return null
|
|
212
|
+
probedWeak.add(session)
|
|
213
|
+
} else {
|
|
214
|
+
return null
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
let result
|
|
218
|
+
try {
|
|
219
|
+
result = probeHost(agent, options)
|
|
220
|
+
} catch (error) {
|
|
221
|
+
// 自检自己炸了:这是「未判定」,不该指向某个具体字段
|
|
222
|
+
result = { ok: null, checks: [{ name: '自检本身', ok: false, detail: String(error?.message ?? error) }] }
|
|
223
|
+
}
|
|
224
|
+
// 未判定:不写盘、也不撤灯;**并且把会话从"查过了"里放回去**,
|
|
225
|
+
// 否则会话刚开那一下判完就再也不查了(等于永远没查过)。
|
|
226
|
+
if (result.ok === null) {
|
|
227
|
+
if (id !== '') probed.delete(id)
|
|
228
|
+
return result
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
if (result.ok === true) {
|
|
232
|
+
// 一切正常就把旧的红灯撤掉(宿主升级后恢复正常,不能一直红着)
|
|
233
|
+
try {
|
|
234
|
+
if (existsSync(HOST_PROBE_FILE())) atomicWrite(HOST_PROBE_FILE(), '')
|
|
235
|
+
} catch { /* 清不掉就算了,下次还会再试 */ }
|
|
236
|
+
return result
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
const failed = result.checks.filter((check) => check.ok !== true)
|
|
240
|
+
note('host', `⚠️ 宿主形状自检没过:${failed.map((c) => `${c.name}(${c.detail})`).join(';')}`)
|
|
241
|
+
note('host', '⚠️ 后果:记忆/心情提取会**静默失效**(扫描在跑、候选恒 0、日志不报)。'
|
|
242
|
+
+ '去 lib/extract.js 的 messageContentOf / lib/host.js 的 firstTextOf 里改事件形状。')
|
|
243
|
+
try {
|
|
244
|
+
atomicWrite(HOST_PROBE_FILE(), `${JSON.stringify({
|
|
245
|
+
at: new Date().toISOString(),
|
|
246
|
+
sessionId: id,
|
|
247
|
+
failed: failed.map((check) => ({ name: check.name, detail: check.detail }))
|
|
248
|
+
}, null, 2)}\n`)
|
|
249
|
+
} catch { /* 落不了盘也不影响喊出来 */ }
|
|
250
|
+
return result
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
/** 设置页用:上次自检失败留下的现场(没有 / 空文件 → null)。 */
|
|
254
|
+
export function hostProbeState() {
|
|
255
|
+
try {
|
|
256
|
+
const file = HOST_PROBE_FILE()
|
|
257
|
+
if (!existsSync(file)) return null
|
|
258
|
+
const raw = readFileSync(file, 'utf8').trim()
|
|
259
|
+
if (raw === '') return null
|
|
260
|
+
const parsed = JSON.parse(raw)
|
|
261
|
+
return parsed !== null && typeof parsed === 'object' ? parsed : null
|
|
262
|
+
} catch {
|
|
263
|
+
return null
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
/** 测试用。 */
|
|
268
|
+
export function __resetHostProbeForTest() {
|
|
269
|
+
probed.clear()
|
|
270
|
+
probedWeak = new WeakSet()
|
|
271
|
+
}
|
package/lib/index.js
CHANGED
|
@@ -25,7 +25,10 @@
|
|
|
25
25
|
*/
|
|
26
26
|
import { note, serviceOf } from './env.js'
|
|
27
27
|
import { composePersona } from './persona.js'
|
|
28
|
-
import { collectCandidates, currentUserText, ingestCandidates, isPromotable, isSubagentSession } from './extract.js'
|
|
28
|
+
import { collectCandidates, currentUserText, ingestCandidates, isHumanEvent, isPromotable, isSubagentSession, messageContentOf, textOfContent } from './extract.js'
|
|
29
|
+
import { toneLevelOf, takeTone, __resetToneForTest } from './tone.js'
|
|
30
|
+
import { randomUUID } from 'node:crypto'
|
|
31
|
+
import { probeHostOnce } from './host.js'
|
|
29
32
|
import { refineCandidates } from './refine.js'
|
|
30
33
|
import { addRecord, recallQueryTerms, renderRecallOnly } from './memory.js'
|
|
31
34
|
import { collectForDiary, startDiaryTimer, runCatchUp, readRecentDiaries, readRecentChat, todayKey } from './diary.js'
|
|
@@ -286,6 +289,18 @@ function renderRecentSection(cfg) {
|
|
|
286
289
|
}
|
|
287
290
|
}
|
|
288
291
|
|
|
292
|
+
/**
|
|
293
|
+
* 「本会话已经说过」的集合最多记这么多条(2026-11-01 审计 D12)。
|
|
294
|
+
*
|
|
295
|
+
* 原来这个 Set 在一个会话里**只增不减**:召回过的原文永远被 exclude,
|
|
296
|
+
* 而候选池只有 8 条。聊到后半段,"相关但说过"的记录一多,这一段就再也出不来 ——
|
|
297
|
+
* 表现是长会话里她后半段几乎想不起任何事,而日志里什么都不说。
|
|
298
|
+
*
|
|
299
|
+
* 语义改成「最近说过的不再重复」而不是「这个会话说过的都不再说」:
|
|
300
|
+
* 隔三十轮再提一次旧事是自然复述,不是刷屏。
|
|
301
|
+
*/
|
|
302
|
+
const RECALL_SEEN_MAX = 16
|
|
303
|
+
|
|
289
304
|
/** 第一轮之后的「想起来了」:按当前这句话召回,并排除本会话已经说过的。 */
|
|
290
305
|
function recallForTurn(cwd, cfg, query, sessionId) {
|
|
291
306
|
let seen = recallSeenBySession.get(sessionId)
|
|
@@ -298,9 +313,32 @@ function recallForTurn(cwd, cfg, query, sessionId) {
|
|
|
298
313
|
// 2026-10-30 修:以前直接把外壳传进去,被它的 Array.isArray(card.records) 过滤掉,
|
|
299
314
|
// 这条「第一轮之后唯一的记忆通路」一直是空跑 —— 日志不报错,只是永远想不起来。
|
|
300
315
|
const cards = cardsFor(cwd).map((entry) => entry.card)
|
|
301
|
-
|
|
316
|
+
let recalled = renderRecallOnly(cards, { config: cfg, query, exclude: seen })
|
|
317
|
+
|
|
318
|
+
// 空着,而且是被"说过了"挡空的 → 这套记忆在这个会话里已经讲完了,放开重来一次。
|
|
319
|
+
// 只有 blocked > 0 才算(真的没有相关记忆时不该白跑一遍)。
|
|
320
|
+
if (recalled.text === '' && (recalled.blocked ?? 0) > 0) {
|
|
321
|
+
const blockedBefore = recalled.blocked
|
|
322
|
+
// ⚠️ 不能 seen.clear():清完 exclude 为空,而 renderRecallOnly 是纯函数、
|
|
323
|
+
// 排序确定,重试结果就是这份 query 的历史最高分那几条 —— 多半跟上一轮
|
|
324
|
+
// 刚说过的整段重合,正中"同一件事别连着刷屏"的反面。
|
|
325
|
+
// 只留最近一半(最近说过的那几条),把更早的旧账放出来。
|
|
326
|
+
const keep = [...seen].slice(-Math.floor(RECALL_SEEN_MAX / 2))
|
|
327
|
+
seen.clear()
|
|
328
|
+
for (const key of keep) seen.add(key)
|
|
329
|
+
recalled = renderRecallOnly(cards, { config: cfg, query, exclude: seen })
|
|
330
|
+
// 重置即记录:不管重试有没有结果都要留痕,否则去重表被悄悄削掉没人知道
|
|
331
|
+
note('memory', `「想起来了」被去重挡空(挡掉 ${blockedBefore} 条),已把去重表收到 ${keep.length} 条重试`)
|
|
332
|
+
}
|
|
302
333
|
if (recalled.text === '') return ''
|
|
334
|
+
|
|
303
335
|
for (const key of recalled.keys) seen.add(key)
|
|
336
|
+
// 只留最近 N 条(Set 保插入顺序,最老的先出)
|
|
337
|
+
while (seen.size > RECALL_SEEN_MAX) {
|
|
338
|
+
const oldest = seen.values().next().value
|
|
339
|
+
if (oldest === undefined) break
|
|
340
|
+
seen.delete(oldest)
|
|
341
|
+
}
|
|
304
342
|
return recalled.text
|
|
305
343
|
}
|
|
306
344
|
|
|
@@ -384,6 +422,67 @@ function isFirstTurnOfSession(agent) {
|
|
|
384
422
|
const PERSONA_REFRESH_TURNS = 15
|
|
385
423
|
const personaInjectAtBySession = new Map()
|
|
386
424
|
|
|
425
|
+
// ---- 心情语气:挂在用户消息上(2026-11-01) ----
|
|
426
|
+
|
|
427
|
+
/**
|
|
428
|
+
* 哪些 agent 已经打过「追加一条注入消息」的补丁。
|
|
429
|
+
*
|
|
430
|
+
* ⚠️ 这里必须诚实:DSH 的公开接口只能**往系统提示里加文本**,没有
|
|
431
|
+
* 「改写当前这条用户消息」的钩子。所以"挂在消息上"是用 `agent/inbox/inserted`
|
|
432
|
+
* 事件在**消息已经落库之后**再投一条 user 消息来实现的 —— 效果上是
|
|
433
|
+
* 「树树那句话后面跟了一条心情」,但严格说它是**第二条消息**,不是改写。
|
|
434
|
+
*
|
|
435
|
+
* 为什么仍然这么做(而不是退回系统提示末尾):
|
|
436
|
+
* · 系统提示一个字不动 → 长缓存不受影响
|
|
437
|
+
* · 心情是「那一刻」的状态,跟着消息走才对;放在系统提示里会一直过时
|
|
438
|
+
*/
|
|
439
|
+
let tonePatchedSessions = new WeakSet()
|
|
440
|
+
|
|
441
|
+
/**
|
|
442
|
+
* 每轮算一次心情档位(计数器语义见 tone.js),该发的时候在当前消息后追加一条。
|
|
443
|
+
*
|
|
444
|
+
* 只在 `soul:memory` 的 text() 里调用,那是每轮必经之路。
|
|
445
|
+
*/
|
|
446
|
+
function registerToneForTurn(agent) {
|
|
447
|
+
const cfg = loadConfig()
|
|
448
|
+
if (cfg.enabled === false || cfg.moodEnabled === false) return
|
|
449
|
+
if (agent === null || agent === undefined) return
|
|
450
|
+
if (isSubagentSession(agent)) return
|
|
451
|
+
|
|
452
|
+
const session = agent.session
|
|
453
|
+
const id = String(session?.header?.id ?? '')
|
|
454
|
+
if (id === '') return
|
|
455
|
+
|
|
456
|
+
// 心情状态按 cwd 读(跟主注入同源),档位是纯查表,很便宜
|
|
457
|
+
const cwd = session?.header?.cwd ?? ''
|
|
458
|
+
let state = null
|
|
459
|
+
try {
|
|
460
|
+
state = moodState(cwd)
|
|
461
|
+
} catch {
|
|
462
|
+
return
|
|
463
|
+
}
|
|
464
|
+
const level = toneLevelOf(state, cfg)
|
|
465
|
+
const { emit, text } = takeTone(id, level, cfg)
|
|
466
|
+
if (emit === false || text === '') return
|
|
467
|
+
|
|
468
|
+
// 投一条 user 消息(不是 assistant)—— 它是「当时的心情」,属于对话的一部分。
|
|
469
|
+
// 走 agent.inbox.append(宿主公开的入站口),不自己拼事件塞进会话 ——
|
|
470
|
+
// bundle 里 `Inbox` 类型写着 `append / prepend / replace / remove / clear / splice`。
|
|
471
|
+
try {
|
|
472
|
+
const inbox = agent.inbox
|
|
473
|
+
if (inbox === null || inbox === undefined || typeof inbox.append !== 'function') return
|
|
474
|
+
inbox.append({
|
|
475
|
+
type: 'user',
|
|
476
|
+
id: randomUUID(),
|
|
477
|
+
content: [{ type: 'text', text }],
|
|
478
|
+
source: { kind: 'soul-tone', plugin: 'dsh-agent-soul' }
|
|
479
|
+
})
|
|
480
|
+
note('mood', `语气注入:${level}`)
|
|
481
|
+
} catch (error) {
|
|
482
|
+
note('mood', `语气注入失败:${error instanceof Error ? error.message : error}`)
|
|
483
|
+
}
|
|
484
|
+
}
|
|
485
|
+
|
|
387
486
|
/**
|
|
388
487
|
* 这次该不该注入人格段。
|
|
389
488
|
*
|
|
@@ -536,6 +635,11 @@ export function apply(ctx) {
|
|
|
536
635
|
// assemble:contexts.filter(entry => !suppressed || entry.required === true))。
|
|
537
636
|
required: true,
|
|
538
637
|
text: (context) => {
|
|
638
|
+
// 心情语气:挂在**当前这句用户消息**后面(2026-11-01)。
|
|
639
|
+
// 必须在任何 early return 之前算 —— 计数器是「每轮一次」,跳过去就不准了。
|
|
640
|
+
// 系统提示一个字不动,所以长缓存不受影响。
|
|
641
|
+
registerToneForTurn(context?.agent)
|
|
642
|
+
|
|
539
643
|
const cfg = loadConfig()
|
|
540
644
|
if (cfg.enabled === false || cfg.memoryEnabled === false) return ''
|
|
541
645
|
const agent = context?.agent
|
|
@@ -545,6 +649,17 @@ export function apply(ctx) {
|
|
|
545
649
|
// 提取本身很快(扫事件+过滤),真正调模型的"提炼"是排队后台跑的。
|
|
546
650
|
// 子会话的挡板在 tick 里(唯一收敛点),这里只负责不注入整卡。
|
|
547
651
|
tick(agent, cwd, cfg, { llm })
|
|
652
|
+
// 宿主形状自检:每个会话第一轮跑一次(2026-11-01 审计 C7)。
|
|
653
|
+
// 放在 tick 之后:提取已经读过事件了,这时候检查"到底抠不抠得出正文"最准。
|
|
654
|
+
// 传的抽取函数必须是**提取真正在用的那套**(messageContentOf + textOfContent),
|
|
655
|
+
// 不是 host.js 里那份容错版 —— 两边分叉的话自检会绿、提取照样空。
|
|
656
|
+
probeHostOnce(agent, {
|
|
657
|
+
extractText: (event) => textOfContent(messageContentOf(event)),
|
|
658
|
+
// 注入事件本身也是 user/message 且带正文。只查"能不能抠出字"的话,
|
|
659
|
+
// 真人那条链路改名后自检照样全绿、候选恒 0 —— 所以要再问一句
|
|
660
|
+
// "这条真人消息,提取链认得出来吗"。
|
|
661
|
+
classify: (event) => isHumanEvent(event) && textOfContent(messageContentOf(event)) !== ''
|
|
662
|
+
})
|
|
548
663
|
if (isSubagentSession(agent)) return ''
|
|
549
664
|
const query = currentUserText(agent)
|
|
550
665
|
// 2026-10-30:整卡只在会话第一轮注入;之后只按当前这句话召回。
|
|
@@ -569,6 +684,13 @@ export function apply(ctx) {
|
|
|
569
684
|
if (sticky !== null && sticky.rendered === true) return sticky.text
|
|
570
685
|
// 没有上次可沿用才走整卡。这一段本身也记进粘性状态:
|
|
571
686
|
// 否则同一个会话每遇到一句「嗯」,整卡就会被重新拼一次、再追加一条快照。
|
|
687
|
+
//
|
|
688
|
+
// 2026-11-01 审计 B6 说这里「绕过整卡只首轮契约、会每轮回放 3200 字」。
|
|
689
|
+
// 查过:确实会多注入一次整卡,但**不会每轮重复花钱** —— 宿主只在注入
|
|
690
|
+
// 文本变化时才重投,同一个字符串只算一次。而这行是当年修的**防死锁**兜底:
|
|
691
|
+
// 早期版本在这里返回空串,于是「窗口里只剩注入」的会话永远拿不到记忆,
|
|
692
|
+
// 模型整场都当自己是第一次见人(sticky.test.js ④ 就守着这条)。
|
|
693
|
+
// 所以保留,代价是一次整卡注入,收益是会话不会变成失忆。
|
|
572
694
|
const whole = renderMemoryBlockRecalled(cwd, cfg, '')
|
|
573
695
|
if (sticky !== null) {
|
|
574
696
|
sticky.terms = new Set()
|
|
@@ -731,6 +853,11 @@ export function __resetForTest() {
|
|
|
731
853
|
// 否则上一个用例的文本会被下一个用例当成「上次注入」复用了。
|
|
732
854
|
stickyRecallBySession.clear()
|
|
733
855
|
recallSeenBySession.clear()
|
|
856
|
+
// 2026-11-01 审计 C10:人设轮次表也是模块级状态(哪个会话已经注入过、注入到第几轮),
|
|
857
|
+
// 不跟着清的话,测试里第二个用例会继承第一个用例的计数,人设注入就测不出来。
|
|
858
|
+
personaInjectAtBySession.clear()
|
|
859
|
+
__resetToneForTest()
|
|
860
|
+
tonePatchedSessions = new WeakSet()
|
|
734
861
|
unobserveAll()
|
|
735
862
|
}
|
|
736
863
|
|