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/README.md +125 -31
- package/lib/attest.js +5 -5
- package/lib/client/mood-tab.js +3 -1
- package/lib/client/settings-tab.js +57 -0
- package/lib/client.js +60 -1
- package/lib/diary-pick.js +6 -3
- package/lib/diary.js +11 -7
- package/lib/env.js +53 -7
- package/lib/extract.js +20 -0
- package/lib/health.js +291 -0
- package/lib/index.js +44 -6
- package/lib/memory.js +29 -2
- package/lib/mood.js +27 -5
- package/lib/paths.js +8 -0
- package/lib/purpose.js +4 -1
- package/lib/refine.js +30 -16
- package/lib/store.js +95 -2
- package/package.json +4 -2
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
|
-
*
|
|
94
|
-
*
|
|
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
|
|
97
|
-
const
|
|
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,
|
|
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]
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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,
|