dsh-agent-soul 0.5.2 → 0.6.0

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/lib/env.js CHANGED
@@ -88,29 +88,75 @@ function stampLocal(d = new Date()) {
88
88
  }
89
89
 
90
90
  /**
91
- * 写一行日志。
91
+ * 写一行**原样**日志(2026-11-04)。
92
92
  *
93
- * @param {string} tag 分类(persona / memory / extract / tool / api / purpose / diary)
94
- * @param {string} message 内容
93
+ * 为什么单独开这个口子:每日健康那一行要求格式就是
94
+ * [health] 记忆 项目=N …
95
+ * 前面不带时间戳。原来的 note() 会强制拼 `[时间] [tag] `,用它写出来就不是那个格式了。
96
+ * 但直接 appendFileSync 又会绕开轮转 —— 所以把「建目录 / 轮转 / 追写 / stderr 兜底」
97
+ * 抽到这里,note() 和健康行共用同一条写盘路。
98
+ *
99
+ * @param {string} line 完整的一行(带不带结尾换行都行)
100
+ * @returns {boolean} 是否真的写进磁盘
95
101
  */
96
- export function note(tag, message) {
97
- const line = `[${stampLocal()}] [${tag}] ${message}\n`
102
+ export function appendLogLine(line) {
103
+ const text = String(line ?? '')
104
+ if (text.trim() === '') return false
105
+ const body = text.endsWith('\n') ? text : `${text}\n`
98
106
  try {
99
107
  const file = LOG_FILE()
100
108
  // 2026-10-31:目录不存在时自己建。原来靠调用方保证,测试环境里
101
109
  // 就撞上 ENOENT 了 —— 日志写不进去,等于那段时间完全没有线索。
102
110
  mkdirSync(dirname(file), { recursive: true })
103
111
  rotateIfNeeded(file)
104
- appendFileSync(file, line, 'utf8')
112
+ appendFileSync(file, body, 'utf8')
113
+ return true
105
114
  } catch (error) {
106
115
  // 原来这里 catch {} —— 日志写不进去一声不响,等于把唯一的线索来源也静音了。
107
116
  // 至少往 stderr 喊一句:日志写失败这件事本身,必须留下痕迹。
108
117
  try {
109
- process.stderr.write(`[soul] 日志写入失败(${tag}):${error instanceof Error ? error.message : error}\n`)
118
+ process.stderr.write(`[soul] 日志写入失败:${error instanceof Error ? error.message : error}\n`)
110
119
  } catch { /* stderr 也没了就真没办法了 */ }
120
+ return false
111
121
  }
112
122
  }
113
123
 
124
+ /**
125
+ * 写一行日志。
126
+ *
127
+ * @param {string} tag 分类(persona / memory / extract / tool / api / purpose / diary)
128
+ * @param {string} message 内容
129
+ */
130
+ export function note(tag, message) {
131
+ // 失败兜底已经在 appendLogLine 里(含 stderr),这里不再重复 catch,
132
+ // 否则同一件事会往 stderr 喊两遍。
133
+ appendLogLine(`[${stampLocal()}] [${tag}] ${message}`)
134
+ }
135
+
136
+ /**
137
+ * 记忆卡落盘失败的进程内计数(2026-11-04,供每日健康行使用)。
138
+ *
139
+ * 为什么放 env.js 而不是 memory.js:memory.js 要往这里计数,而健康行模块
140
+ * 反过来要读 memory.js 的 ownerImportant —— 计数放 memory.js 会和 health.js
141
+ * 形成循环依赖。env.js 是两边都已经依赖的「副作用入口」,放这里没有新增边。
142
+ *
143
+ * 语义:**进程启动以来累计**,由每日健康行写成功后清零(= 每天一个数)。
144
+ * 只增不减,不做分频 —— 它只进日志的工程指标,不进任何提示词。
145
+ */
146
+ let cardWriteFailures = 0
147
+
148
+ export function countCardWriteFailure() {
149
+ cardWriteFailures += 1
150
+ }
151
+
152
+ export function cardWriteFailureCount() {
153
+ return cardWriteFailures
154
+ }
155
+
156
+ export function resetCardWriteFailureCount() {
157
+ cardWriteFailures = 0
158
+ }
159
+
114
160
  /**
115
161
  * 分频日志(2026-11-04)。
116
162
  *
package/lib/extract.js CHANGED
@@ -53,6 +53,24 @@ const CURSOR_MAX = 200
53
53
  const INGEST_MAX_RETRY = 3
54
54
  /** key → { count, to }:同一个会话连续失败了几次。 */
55
55
  const ingestFailures = new Map()
56
+
57
+ /**
58
+ * 写盘失败累计(2026-11-04,给每日健康行用)。
59
+ *
60
+ * 跟 ingestFailures 的区别:那张表是「这个会话连着失败了几次」,
61
+ * 成功一次就被清掉,读它只能看到**当前卡着**的会话,看不到「今天一共失败了多少次」。
62
+ * 健康行要的是后者,所以另记一个只增不减的进程内计数,由健康行写成功后清零。
63
+ * 只进 soul.log,不进任何提示词。
64
+ */
65
+ let ingestFailureTotal = 0
66
+
67
+ export function ingestFailureCount() {
68
+ return ingestFailureTotal
69
+ }
70
+
71
+ export function resetIngestFailureCount() {
72
+ ingestFailureTotal = 0
73
+ }
56
74
  /**
57
75
  * 正在落盘的那一批(key → { from, to, at })。
58
76
  *
@@ -485,6 +503,8 @@ export function failIngestBatch(batch, reason = '') {
485
503
  const why = String(reason ?? '').trim()
486
504
 
487
505
  inflightBatches.delete(key)
506
+ // 健康行的分母:每真失败一次(下面无论重试还是放弃)都 +1
507
+ ingestFailureTotal += 1
488
508
  const count = (Number(ingestFailures.get(key)?.count) || 0) + 1
489
509
 
490
510
  // 放弃:游标推到这批的末尾,别再让它把每回合都卡住(和 diary.js 的 SEEK_GIVE_UP 一致)
package/lib/health.js ADDED
@@ -0,0 +1,291 @@
1
+ /**
2
+ * health.js —— 每日健康一行(2026-11-04)。
3
+ *
4
+ * ── 它是什么 ──
5
+ * 每天在 soul.log 里留**一行**工程指标,像体检报告的一行摘要:
6
+ *
7
+ * [health] 记忆 项目=12 全局=48(pinned 3 / 保护 11 / 模糊 6 / 遗忘 2)归档 137 条|笔记 4 篇|日记 最近=2026-11-03 公开/私密=完整|写盘失败 0|提炼队列 1
8
+ *
9
+ * ── 它不是什么(这条比上面重要)──
10
+ * 它不是给她的状态,也不进任何提示词:不 import 到注入路径、不写进记忆卡、
11
+ * 不参与心情/人格/目的。它是**给人看的**工程指标 —— 所以单独一个模块,
12
+ * 只往日志写,连返回值都不该被注入那一侧接住。
13
+ *
14
+ * ── 什么时候写 ──
15
+ * 挂在 store.js 的 maintain 末尾。maintain 本来就按 lastDecayDate 一天跑一次,
16
+ * 这里不新起定时器;再用 memory/health.json 记 lastDate,保证:
17
+ * · 同一天被调很多次(每回合注入、设置页手动维护)也只写一行;
18
+ * · 进程重启不会把当天那行重写一遍。
19
+ *
20
+ * ── 取不到怎么办 ──
21
+ * 任何一项都可能因为「文件还没建 / 权限 / 盘坏 / 字段变了」取不到。
22
+ * 每项单独 try/catch,取不到的写 `-`,整行照写 —— 一行缺一项,好过当天什么都没有。
23
+ * 全部包在 try/catch 里:它在注入路径上被调用,**任何情况下都不许抛**。
24
+ */
25
+ import { closeSync, openSync, readdirSync, readSync } from 'node:fs'
26
+ import { appendLogLine, cardWriteFailureCount, resetCardWriteFailureCount } from './env.js'
27
+ import {
28
+ archivePath,
29
+ atomicWrite,
30
+ diaryPrivateDir,
31
+ diaryPublicDir,
32
+ exists,
33
+ healthStatePath,
34
+ notesIndexPath,
35
+ readText
36
+ } from './paths.js'
37
+ import { normalizeConfig, ownerImportant } from './memory.js'
38
+ // 完整性判定直接复用 diary.js 已有的 diaryIsCompleteFor —— 别在这里再写一套。
39
+ // 代价是 health → diary → store → health 的模块环;这里只在函数体内用到 diary 的导出,
40
+ // 模块初始化阶段不调用,ESM 的活绑定能正常解析(见 tests/health.test.js 的 import 路径)。
41
+ import { diaryIsCompleteFor, todayKey } from './diary.js'
42
+ import { ingestFailureCount, resetIngestFailureCount } from './extract.js'
43
+
44
+ // --------------------------------------------------------------------------
45
+ // 提炼队列计数(入队 +1、出队 -1)
46
+ // --------------------------------------------------------------------------
47
+
48
+ /**
49
+ * 为什么不在 index.js 里读 refineChain 的「长度」:
50
+ * Promise 链没有 length,pending 数量也拿不到。这里记一个最简单的在途计数:
51
+ * queueRefine 同步入队时 +1,链跑完(成功/失败/降级都算)时 -1。
52
+ * 它是进程内的,只用于健康行,不参与调度 —— 调度仍然是 refineChain 本身。
53
+ */
54
+ let refinePending = 0
55
+
56
+ export function markRefineQueued() {
57
+ refinePending += 1
58
+ }
59
+
60
+ export function markRefineSettled() {
61
+ if (refinePending > 0) refinePending -= 1
62
+ }
63
+
64
+ export function refinePendingCount() {
65
+ return refinePending
66
+ }
67
+
68
+ /** 测试用:把在途计数归零。 */
69
+ export function __resetRefinePendingForTest() {
70
+ refinePending = 0
71
+ }
72
+
73
+ // --------------------------------------------------------------------------
74
+ // 读数
75
+ // --------------------------------------------------------------------------
76
+
77
+ /** 抛错就退回 fallback —— 只用于「明确允许缺」的读数。 */
78
+ function safe(fn, fallback = null) {
79
+ try {
80
+ return fn()
81
+ } catch {
82
+ return fallback
83
+ }
84
+ }
85
+
86
+ /**
87
+ * 一行日记都没写过时也要能给出「最近=-」。
88
+ * 只看文件名(YYYY-MM-DD.md),不打开正文;public/private 取最大日期。
89
+ */
90
+ function latestDiaryDate() {
91
+ let latest = ''
92
+ for (const dir of [diaryPublicDir(), diaryPrivateDir()]) {
93
+ let names = []
94
+ try {
95
+ names = readdirSync(dir)
96
+ } catch {
97
+ continue
98
+ }
99
+ for (const name of names) {
100
+ const matched = /^(\d{4}-\d{2}-\d{2})\.md$/.exec(String(name))
101
+ if (matched !== null && matched[1] > latest) latest = matched[1]
102
+ }
103
+ }
104
+ return latest
105
+ }
106
+
107
+ /**
108
+ * 数 archive.jsonl 有几行。
109
+ *
110
+ * 约束里写明「读文件数行,不要全量解析」:这里按 64KB 块流式数换行符,
111
+ * 不 JSON.parse、不把整文件读进内存(档案只增不减,跑久了会很大)。
112
+ * 文件不存在 = 0 条;读不了 = null(最终写 `-`)。
113
+ */
114
+ function countArchiveLines() {
115
+ const file = archivePath()
116
+ if (!exists(file)) return 0
117
+ let fd
118
+ try {
119
+ fd = openSync(file, 'r')
120
+ const buffer = Buffer.allocUnsafe(64 * 1024)
121
+ let lines = 0
122
+ let lastByte = 0x0a
123
+ let read = 0
124
+ while ((read = readSync(fd, buffer, 0, buffer.length, null)) > 0) {
125
+ for (let i = 0; i < read; i += 1) {
126
+ if (buffer[i] === 0x0a) lines += 1
127
+ }
128
+ lastByte = buffer[read - 1]
129
+ }
130
+ // 最后一行没换行也算一条(append 写出来的通常有,但别假定)
131
+ if (lastByte !== 0x0a) lines += 1
132
+ return lines
133
+ } catch {
134
+ return null
135
+ } finally {
136
+ if (fd !== undefined) {
137
+ try {
138
+ closeSync(fd)
139
+ } catch {
140
+ /* 关不掉也不能盖住读数结果 */
141
+ }
142
+ }
143
+ }
144
+ }
145
+
146
+ /**
147
+ * 笔记篇数以 index.json 的 notes.length 为准(约束里指定的口径)。
148
+ * 文件不存在 = 0 篇(还没写过);存在但读坏 = null(写 `-`,别把坏索引报成 0)。
149
+ */
150
+ function countNotes() {
151
+ const file = notesIndexPath()
152
+ if (!exists(file)) return 0
153
+ const raw = readText(file)
154
+ if (String(raw).trim() === '') return null
155
+ const parsed = JSON.parse(raw)
156
+ if (!Array.isArray(parsed?.notes)) return null
157
+ return parsed.notes.length
158
+ }
159
+
160
+ /** 一张记忆卡的几个数:条数 / pinned / 保护线 / 模糊 / 遗忘。 */
161
+ function metricOf(card, cfg) {
162
+ if (card === null || card === undefined || !Array.isArray(card.records)) {
163
+ throw new Error('记忆卡不可用')
164
+ }
165
+ let pinned = 0
166
+ let protectedCount = 0
167
+ let fuzzy = 0
168
+ for (const record of card.records) {
169
+ if (record?.pinned === true) pinned += 1
170
+ // 保护线:跟衰减/压缩用的是同一个判据(memory.js 的 ownerImportant),
171
+ // 不能在这里另写一套「看起来差不多」的规则。
172
+ if (ownerImportant(record, cfg)) protectedCount += 1
173
+ // 「模糊」= clear 以下、但还没进 forgotten 的两档(fuzzy / trace)。
174
+ // forgotten 单独一列,避免同一批记录被数两遍。
175
+ if (record?.clarity === 'fuzzy' || record?.clarity === 'trace') fuzzy += 1
176
+ }
177
+ return {
178
+ count: card.records.length,
179
+ pinned,
180
+ protected: protectedCount,
181
+ fuzzy,
182
+ forgotten: Number(card.stats?.forgotten) || 0
183
+ }
184
+ }
185
+
186
+ function zeroMetric() {
187
+ return { count: 0, pinned: 0, protected: 0, fuzzy: 0, forgotten: 0 }
188
+ }
189
+
190
+ /** 日记那一段:最近一天 + 完整/缺/未绑。 */
191
+ function diaryMetric(cfg) {
192
+ const bound = String(cfg?.diarySessionId ?? '').trim() !== ''
193
+ const date = latestDiaryDate()
194
+ if (!bound) return { date: date === '' ? '-' : date, state: '未绑' }
195
+ if (date === '') return { date: '-', state: '缺' }
196
+ return { date, state: diaryIsCompleteFor(date) ? '完整' : '缺' }
197
+ }
198
+
199
+ /** 把各项数字拼成一行。任何一项抛错都只影响那一项。 */
200
+ export function renderHealthLine({ cwd = '', config = {}, cards = {}, now = Date.now() } = {}) {
201
+ const cfg = safe(() => normalizeConfig(config), {})
202
+
203
+ // ---- 记忆(项目 / 全局)----
204
+ const projectMetric = String(cwd ?? '').trim() === ''
205
+ ? zeroMetric()
206
+ : safe(() => metricOf(cards.project, cfg), null)
207
+ const globalMetric = safe(() => metricOf(cards.global, cfg), null)
208
+
209
+ let memoryBlock = '记忆 -'
210
+ if (projectMetric !== null && globalMetric !== null) {
211
+ const sum = (key) => projectMetric[key] + globalMetric[key]
212
+ memoryBlock = `记忆 项目=${projectMetric.count} 全局=${globalMetric.count}`
213
+ + `(pinned ${sum('pinned')} / 保护 ${sum('protected')} / 模糊 ${sum('fuzzy')} / 遗忘 ${sum('forgotten')})`
214
+ }
215
+
216
+ const archiveLines = safe(() => countArchiveLines(), null)
217
+ const noteCount = safe(() => countNotes(), null)
218
+ const diary = safe(() => diaryMetric(cfg), null)
219
+ const writeFailures = safe(() => ingestFailureCount() + cardWriteFailureCount(), null)
220
+ const refineQueue = safe(() => refinePendingCount(), null)
221
+
222
+ return '[health] ' + [
223
+ memoryBlock,
224
+ `归档 ${archiveLines === null ? '-' : archiveLines} 条`,
225
+ `笔记 ${noteCount === null ? '-' : noteCount} 篇`,
226
+ diary === null
227
+ ? '日记 最近=- 公开/私密=-'
228
+ : `日记 最近=${diary.date} 公开/私密=${diary.state}`,
229
+ `写盘失败 ${writeFailures === null ? '-' : writeFailures}`,
230
+ `提炼队列 ${refineQueue === null ? '-' : refineQueue}`
231
+ ].join('|')
232
+ }
233
+
234
+ // --------------------------------------------------------------------------
235
+ // 状态文件:一天只写一行
236
+ // --------------------------------------------------------------------------
237
+
238
+ function readLastHealthDate() {
239
+ try {
240
+ const raw = readText(healthStatePath())
241
+ if (String(raw).trim() === '') return ''
242
+ const parsed = JSON.parse(raw)
243
+ return typeof parsed?.lastDate === 'string' ? parsed.lastDate : ''
244
+ } catch {
245
+ // 状态文件坏了就当没写过:宁可多一行,也不要整天不写。
246
+ return ''
247
+ }
248
+ }
249
+
250
+ function saveLastHealthDate(date) {
251
+ try {
252
+ const saved = atomicWrite(healthStatePath(), `${JSON.stringify({ lastDate: date })}\n`)
253
+ return saved?.ok === true
254
+ } catch {
255
+ return false
256
+ }
257
+ }
258
+
259
+ /**
260
+ * 每天写一行健康指标。挂在 maintain 末尾调用。
261
+ *
262
+ * @param {{cwd?: string, config?: object, cards?: {global?: object, project?: object|null}, now?: number}} input
263
+ * @returns {{written: boolean, date: string, line: string}} 只给测试和日志用,调用方不该依赖它
264
+ */
265
+ export function writeDailyHealth({ cwd = '', config = {}, cards = {}, now = Date.now() } = {}) {
266
+ let date = ''
267
+ try {
268
+ date = todayKey(now)
269
+ if (readLastHealthDate() === date) return { written: false, date, line: '' }
270
+
271
+ const line = renderHealthLine({ cwd, config, cards, now })
272
+ // 先写日志再落状态:日志写不进去就保持「今天还没写」,下一次 maintain 会重试。
273
+ // 反过来先落状态的话,一次写日志失败就等于这一天永远没有健康行。
274
+ if (appendLogLine(line) !== true) return { written: false, date, line }
275
+
276
+ saveLastHealthDate(date)
277
+ // 写成功才清零:这一行里的「写盘失败」是当天累计,第二天从 0 重新数。
278
+ safe(() => resetIngestFailureCount())
279
+ safe(() => resetCardWriteFailureCount())
280
+ return { written: true, date, line }
281
+ } catch (error) {
282
+ // 兜底:连拼行都炸了也不许抛(它在注入路径上)。往 stderr 留一句,不写日志
283
+ // ——日志本身可能正是坏掉的那一环。
284
+ try {
285
+ process.stderr.write(`[soul] 每日健康行写入失败:${error instanceof Error ? error.message : error}\n`)
286
+ } catch {
287
+ /* stderr 也没了就真没办法了 */
288
+ }
289
+ return { written: false, date, line: '' }
290
+ }
291
+ }
package/lib/index.js CHANGED
@@ -49,6 +49,8 @@ import {
49
49
  applyMoodDelta
50
50
  } from './store.js'
51
51
  import { purposeState, savePurposeState } from './store.js'
52
+ // 2026-11-04:提炼队列在途计数,只给每日健康行用(不参与调度)。
53
+ import { markRefineQueued, markRefineSettled } from './health.js'
52
54
  import { markServed, satisfyDrives, settleServed, summarize, openGoals, renderPurpose } from './purpose.js'
53
55
  import { lastAssistantTextOf, observeAgent, unobserveAll, normalizeMoodConfig } from './mood.js'
54
56
  import { registerMemoryTool, registerGoalTool, registerNoteTool, setFallbackCwd } from './tool.js'
@@ -70,6 +72,27 @@ export const inject = ['systemPrompt', 'tools', 'webServer', 'agentPresets', 'se
70
72
 
71
73
  /** 记忆维护的最小间隔(毫秒):注入每回合都跑,但维护不必。 */
72
74
  const MAINTAIN_INTERVAL_MS = 10 * 60 * 1000
75
+
76
+ /**
77
+ * 保险:没设 ownerName 时提醒一次(2026-11-04)。
78
+ *
79
+ * 为什么需要:主人名字默认空串之后,提示词里所有「关于谁」的句子都会整句省略 ——
80
+ * 这是**对的**(不能留「你是 的伴侣」这种空壳),但它同时是静默的:
81
+ * 用户只会觉得「她好像不认识我了」,完全看不出差一个设置。
82
+ * 所以每小时在 soul.log 里留一行,说清「哪个段落被跳过了、去哪里填」。
83
+ *
84
+ * 只写日志、不影响任何功能:记忆、笔记、日记都不读 ownerName,照常工作。
85
+ * againAt 给一个大值 = 每个小时只记第一次,不按次数加码。
86
+ */
87
+ function noteMissingOwner(cfg) {
88
+ if (String(cfg?.ownerName ?? '').trim() !== '') return false
89
+ return noteThrottled(
90
+ 'persona',
91
+ 'owner-name-missing',
92
+ '未设置 ownerName:提示词里「关于谁」的段落(关系 / 性别 / 称呼那句)已跳过,请在设置页「主人是谁」里填写。记忆、笔记、日记不受影响。',
93
+ { againAt: 9999 }
94
+ )
95
+ }
73
96
  /** dailyHour>0 时用来判「今天已经整理过」。(2026-11-04) */
74
97
  let lastDailyMaintainDay = ''
75
98
 
@@ -117,6 +140,8 @@ function noteRefineFailure(message) {
117
140
  * @param {{key: string, to: number}|null} batch 这一批对应的扫描窗口
118
141
  */
119
142
  function queueRefine(agent, cwd, candidates, config, llm, batch) {
143
+ // 在途 +1(出队时 -1)。健康行读的是这个数 —— Promise 链本身没有长度。
144
+ markRefineQueued()
120
145
  refineChain = refineChain
121
146
  .then(async () => {
122
147
  const settle = (ok) => {
@@ -137,7 +162,9 @@ function queueRefine(agent, cwd, candidates, config, llm, batch) {
137
162
  let refined = null
138
163
  try {
139
164
  refined = await refineCandidates(llm, agent, candidates, {
140
- owner: String(config.moodOwnerName || '树树'),
165
+ // 2026-11-04:主人名字走 ownerName,不再回落到写死的「树树」。
166
+ // 空串时 refine.js 用中性的「对方」—— 提炼的是记忆,不该因为没设名字就停。
167
+ owner: String(config.ownerName || ''),
141
168
  provider: String(config.memoryRefineProvider || ''),
142
169
  model: String(config.memoryRefineModel || '')
143
170
  })
@@ -191,6 +218,9 @@ function queueRefine(agent, cwd, candidates, config, llm, batch) {
191
218
  // 直到 15 分钟后才被当作「丢了」重扫;失败计数也记不上,放弃条件永远不会触发。
192
219
  failIngestBatch(batch, '提炼链异常')
193
220
  })
221
+ // 出队 -1:成功、降级、异常都算「这一批结束了」。
222
+ // 放在 finally 而不是每条 return 前,是怕以后新增出口又忘了结账。
223
+ .finally(() => markRefineSettled())
194
224
  }
195
225
 
196
226
  /**
@@ -365,7 +395,8 @@ function renderRecentSection(cfg) {
365
395
  }
366
396
 
367
397
  if (Number.isFinite(chatChars) && chatChars > 0) {
368
- const chat = readRecentChat(today, Math.min(Math.trunc(chatChars), 12000))
398
+ // 2026-11-04:流水里主人怎么标也跟着配置走(空 = 中性的「对方」)
399
+ const chat = readRecentChat(today, Math.min(Math.trunc(chatChars), 12000), cfg.ownerName)
369
400
  if (typeof chat === 'string' && chat.trim() !== '') {
370
401
  parts.push(`### 今天到目前为止(可能来自别的对话)\n\n${chat.trim()}`)
371
402
  }
@@ -812,6 +843,8 @@ function tick(agent, cwd, config, { allowMaintain = true, llm = null } = {}) {
812
843
  export function apply(ctx) {
813
844
  note('apply', `启动 pid=${process.pid} node=${process.version}`)
814
845
  const config = loadConfig()
846
+ // 启动时先看一眼主人名字有没有设(2026-11-04):这条最容易漏,也最影响体验。
847
+ noteMissingOwner(config)
815
848
 
816
849
  try {
817
850
  registerApi(ctx)
@@ -874,7 +907,7 @@ export function apply(ctx) {
874
907
  // 只认一种的话,另一种会静默失效 —— 表现是「设置里看得见插件,但人格没注入」。
875
908
  const systemPrompt = serviceOf(ctx, 'systemPrompt')
876
909
  if (systemPrompt === undefined || systemPrompt === null || typeof systemPrompt.context !== 'function') {
877
- note('apply', '宿主没有 systemPrompt.context,人格/记忆/目的三段都无法注入')
910
+ note('apply', '宿主没有 systemPrompt.context,人格/记忆/笔记/目的四段都无法注入')
878
911
  return
879
912
  }
880
913
 
@@ -894,7 +927,10 @@ export function apply(ctx) {
894
927
  // 也不注入一次就再也不管(上下文压缩之后会把自己是谁也压掉)。
895
928
  if (!shouldInjectPersona(context?.agent)) return ''
896
929
  const cwd = context?.agent?.session?.header?.cwd ?? ''
897
- const composed = composePersona({ cwd, config: loadConfig() })
930
+ const current = loadConfig()
931
+ // 没设主人名字的提醒(2026-11-04):每小时最多一行,不阻断注入。
932
+ noteMissingOwner(current)
933
+ const composed = composePersona({ cwd, config: current })
898
934
  if (composed.truncated) note('persona', '人格正文超过上限,已截断')
899
935
  return composed.text
900
936
  }
@@ -1132,6 +1168,8 @@ export function apply(ctx) {
1132
1168
  text: (context) => {
1133
1169
  const cfg = loadConfig()
1134
1170
  if (cfg.enabled === false || cfg.moodEnabled === false) return ''
1171
+ // 同上:没设主人名字时每小时提醒一次(不阻断心情记账)
1172
+ noteMissingOwner(cfg)
1135
1173
  const agent = context?.agent
1136
1174
  // 子会话不判心情:它是一次性任务上下文,判断结果会按 cwd 记进主会话的账上。
1137
1175
  if (isSubagentSession(agent)) return ''
@@ -1168,8 +1206,8 @@ export function apply(ctx) {
1168
1206
  }
1169
1207
  }, 'dsh-agent-soul: mood hook')
1170
1208
 
1171
- // 文案要跟实际注册的段数一致:笔记段是 11-04 加的第五段,
1172
- // 这里还写「三段」的话,将来翻日志排查会以为笔记段没注册上。
1209
+ // 2026-11-04 文案要跟实际注册的段数一致:笔记段是 11-04 加的第四段,
1210
+ // 日志里再写旧段数的话,将来翻日志排查会以为笔记段没注册上。
1173
1211
  note('apply', `注入已就绪:人格/记忆/笔记/目的四段 + 心情记账,模式=${loadConfig().mode}`)
1174
1212
 
1175
1213
  // ---- 5. 日记:定时器 + 启动补写 ----
package/lib/memory.js CHANGED
@@ -27,7 +27,8 @@ import { basename } from 'node:path'
27
27
  import { shortHash, atomicWrite, archivePath } from './paths.js'
28
28
  // 2026-10-31:addRecord 里要记「近似重复」的日志。第一次写忘了 import,
29
29
  // 运行时会 "note is not defined" —— 和今天上午 atomicWrite 那次一个毛病。
30
- import { note, noteThrottled } from './env.js'
30
+ // 2026-11-04:countCardWriteFailure 是每日健康行的计数(见 env.js)。
31
+ import { note, noteThrottled, countCardWriteFailure } from './env.js'
31
32
 
32
33
  /**
33
34
  * 卡片结构版本。
@@ -76,6 +77,23 @@ export function normalizeKind(value) {
76
77
  /** 默认参数。全部可通过配置覆盖,坏值一律回默认(见 normalizeConfig)。 */
77
78
  export const DEFAULTS = Object.freeze({
78
79
  enabled: true,
80
+ // ---- 主人是谁(2026-11-04)----
81
+ //
82
+ // 这三个键是**唯一**的默认值来源:store.js 的 DEFAULT_CONFIG 直接引用它们,
83
+ // 提示词里只读配置,不再写死「树树」「男生」「伴侣」。
84
+ //
85
+ // 为什么默认空串而不是树树:这个包是给别人装的。默认写死一个人的名字,
86
+ // 陌生人装完就被告知「你是树树的伴侣」「树树是男生」—— 那不是配置,
87
+ // 那是把作者的生活当成了产品设定。
88
+ //
89
+ // 空串的语义是「不知道」,不是「叫空名字」:提示词里所有依赖它的整句都省略
90
+ //(见 mood.js buildJudgeSystem 的 aliasLine 同款写法),并每隔一小时记一条
91
+ // 一次性日志提醒去设置页填。记忆 / 笔记 / 日记不依赖它,照常工作。
92
+ ownerName: '',
93
+ /** 主人的性别:'male' | 'female' | ''。只影响判定提示词里「写他/她算不算错」那一行。 */
94
+ ownerGender: '',
95
+ /** 关系定位,自由文本(如「伴侣」「搭档」「主人」)。空串 = 不声明关系。 */
96
+ relationship: '',
79
97
  /** 最近 N 天的事至少保持「清楚」。 */
80
98
  recentDays: 7,
81
99
  /** 新记忆前 N 天不降档(给它一个「刚发生所以还新鲜」的窗口)。 */
@@ -256,6 +274,13 @@ export function normalizeConfig(input = {}) {
256
274
  // 免得配置里写个 999 让所有自动记忆静默消失、还查不出原因。
257
275
  out.autoImportanceEvent = clamp(out.autoImportanceEvent, 0, 100)
258
276
  out.autoImportanceDefault = clamp(out.autoImportanceDefault, 0, 100)
277
+ // 主人身份的归一(2026-11-04):只认 male / female / 空串。
278
+ // 写「男」「男生」这类值一律当没设 —— 提示词里用的是这个词本身,
279
+ // 收下一个近义词只会让它跟着那句话一起漏进提示词,不如让那条整句省略。
280
+ out.ownerGender = out.ownerGender === 'male' || out.ownerGender === 'female' ? out.ownerGender : ''
281
+ // 名字 / 关系是自由文本,但要防住「全空白」和超长:前者等于没设,后者会撑爆提示词。
282
+ out.ownerName = typeof out.ownerName === 'string' ? out.ownerName.trim().slice(0, 24) : ''
283
+ out.relationship = typeof out.relationship === 'string' ? out.relationship.trim().slice(0, 24) : ''
259
284
  return out
260
285
  }
261
286
 
@@ -369,7 +394,7 @@ export function scoreRecord(input = {}) {
369
394
  * ⚠️ 必须**同时**是 owner:群友说「我喜欢吃西瓜」不该进永久记忆
370
395
  * ③ 和主人相关且重要度够高 → 保护
371
396
  */
372
- function ownerImportant(record, cfg) {
397
+ export function ownerImportant(record, cfg) {
373
398
  const tags = Array.isArray(record.tags) ? record.tags : []
374
399
  if (tags.includes('first')) return true
375
400
  const isOwner = tags.includes('owner')
@@ -594,6 +619,7 @@ export function saveCard(file, card) {
594
619
  // 那就从「丢记忆」升级成「不回话」了。失败靠 note 日志 + 设置页亮红暴露。
595
620
  if (isCardReadonly(file) === true) {
596
621
  note('memory', `${basename(file)} 处于只读模式,本次写入已跳过(先人工处理 .corrupt 备份)`)
622
+ countCardWriteFailure()
597
623
  return { ok: false, error: '只读模式:上次读取失败且无法安全备份,这轮不写' }
598
624
  }
599
625
  // 上一版留个单代备份(审计 A1 提到的「无 .bak」)。
@@ -618,6 +644,7 @@ export function saveCard(file, card) {
618
644
  // 2026-11-04 修 ①:这一行改走分频 —— 磁盘满/卡只读时每个回合都会失败,
619
645
  // 逐条记会把 soul.log 刷满,第一次那条真实原因反而找不到。
620
646
  noteThrottled('memory', `card-write-${basename(file)}`, `${basename(file)} 写盘失败:${written?.error ?? '未知原因'}(这轮的新记忆没进磁盘)`)
647
+ countCardWriteFailure()
621
648
  return { ok: false, error: String(written?.error ?? '未知原因') }
622
649
  }
623
650
  return { ok: true }
package/lib/mood.js CHANGED
@@ -341,7 +341,13 @@ export function normalizeMoodConfig(raw = {}) {
341
341
  moodSigMood: num(raw.moodSigMood, 1, 30, 3),
342
342
  moodSigDim: num(raw.moodSigDim, 1, 100, 5),
343
343
  moodSelfName: str(raw.moodSelfName, 16),
344
- moodOwnerName: str(raw.moodOwnerName, 16),
344
+ // 2026-11-04:主人名字的主键统一成 ownerName(见 memory.js 的 DEFAULTS)。
345
+ // moodOwnerName 是旧键,仍然读它只为兼容直接传旧配置的调用方;
346
+ // 两个都没有时是空串,提示词里依赖它的整句会省略(见 buildJudgeSystem)。
347
+ ownerName: str(raw.ownerName || raw.moodOwnerName, 16),
348
+ ownerGender: raw.ownerGender === 'male' || raw.ownerGender === 'female' ? raw.ownerGender : '',
349
+ relationship: str(raw.relationship, 16),
350
+ moodOwnerName: str(raw.ownerName || raw.moodOwnerName, 16),
345
351
  moodSelfAliases: str(raw.moodSelfAliases, 60),
346
352
  moodJudgeProvider: str(raw.moodJudgeProvider, 60),
347
353
  moodJudgeModel: str(raw.moodJudgeModel, 80),
@@ -370,10 +376,23 @@ export function normalizeMoodConfig(raw = {}) {
370
376
  export function buildJudgeSystem(o) {
371
377
  const self = o.self || '你自己'
372
378
  const owner = o.owner || '对方'
379
+ // 2026-11-04:身份与关系改成可配置,空值整句省略。
380
+ // 这里最容易写出「你是 的伴侣」这种空壳 —— 所以名字和关系**都**有值才写那句,
381
+ // 否则只留「你是「小糖」。」(写法跟下面 aliasLine 一致)。
382
+ const relationship = String(o.relationship ?? '').trim()
383
+ const hasOwner = String(o.ownerName ?? o.owner ?? '').trim() !== ''
384
+ const identityLine = hasOwner && relationship !== ''
385
+ ? `你是「${self}」,是${owner}的${relationship}。`
386
+ : `你是「${self}」。`
387
+ // 性别只影响「代词写错没写错」那一行:没设就整行不写,而不是猜一个。
388
+ const gender = o.gender === 'male' || o.gender === 'female' ? o.gender : ''
389
+ const genderLine = gender === ''
390
+ ? ''
391
+ : `\n ⚠️ ${owner}是${gender === 'male' ? '男生' : '女生'}。写出「${gender === 'male' ? '她' : '他'}」即算判错,这一条重写。`
373
392
  const aliasLine = o.aliases
374
393
  ? `\n⭐ ${owner}平时会这样叫你:${o.aliases}。句子里出现这些词时,**那是在叫你**,不是名词的一部分(「宝宝视频传完了」= 「宝宝,(我)视频传完了」)。`
375
394
  : ''
376
- return `你是「${self}」,是${owner}的伴侣。` + aliasLine + `
395
+ return identityLine + aliasLine + `
377
396
  判断**这一轮里你的心情和情绪变化**:既包括${owner}说的话怎么影响你,也包括**你自己这轮的处境和情绪**(办成/没办成、被夸、受挫都算)。
378
397
  只输出一个 JSON,不要别的字、不要 markdown:
379
398
  {"moodDelta":0,"dims":{"happy":0,"calm":0,"sweet":0,"heartache":0,"worry":0,"sad":0,"jealous":0},"reason":"","confidence":80}
@@ -396,8 +415,7 @@ export function buildJudgeSystem(o) {
396
415
  · 不好的一类 → moodDelta **负**:日常的累/困/没吃好 -1~-4;明显委屈、被凶、身体不舒服 -5~-7;很重的事(创伤、轻生念头、家庭变故、重大失望)-8~-10 并额外加 sad
397
416
  · 好的一类 → moodDelta **正**:普通的好 +1~+4;明显的好(被惦记、被哄、分享大事)+5~+7;特别大的好事 +8~+10
398
417
  4. reason:一句话,「${owner}…,我…」或「我…」,没有变化就留空。
399
- · **代词一律不用**:指${owner}写「${owner}」(不写她/他,也别写「她说」);指你自己写「我」;指第三个人写那人在对话里的称呼,不知道就写「有人」。
400
- ⚠️ ${owner}是男生。写出「她」即算判错,这一条重写。
418
+ · **代词一律不用**:指${owner}写「${owner}」(不写她/他,也别写「她说」);指你自己写「我」;指第三个人写那人在对话里的称呼,不知道就写「有人」。${genderLine}
401
419
  · **两段式、全过去式**:第一段写${owner}这轮具体做了什么,第二段写你当时怎么应的。
402
420
  禁止「此刻/现在/正/一直/还」这类把状态延伸到现在的说法 —— 这段会带到下一轮,写成现在时会跟下一轮打架。
403
421
  · 只写这轮真出现过的动作,**不许替${owner}补细节**:${owner}说「我刚想去」,别写成「刚要出门」。拿不准就写模糊的。
@@ -751,7 +769,11 @@ export function observeAgent(agent, { llm, config, note }) {
751
769
  const cfg = config()
752
770
  return {
753
771
  self: cfg.moodSelfName,
754
- owner: cfg.moodOwnerName,
772
+ // 2026-11-04:主人名字/性别/关系一律走配置,空值时提示词整句省略。
773
+ owner: cfg.ownerName,
774
+ ownerName: cfg.ownerName,
775
+ gender: cfg.ownerGender,
776
+ relationship: cfg.relationship,
755
777
  aliases: cfg.moodSelfAliases,
756
778
  judgeProvider: cfg.moodJudgeProvider,
757
779
  judgeModel: cfg.moodJudgeModel,