dsh-agent-soul 0.9.11 → 0.9.12

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 CHANGED
@@ -7,6 +7,37 @@
7
7
 
8
8
  ---
9
9
 
10
+ ## 0.9.12 · 2026-11-10
11
+
12
+ 外部复检轮 **R17(最后一个大文件)**,2 个提交 / 8 文件 / +353 −241。**对外行为零变化**:
13
+ 89 测试 / 11 契约 / lint / bundle 零 diff 全绿;四个搬迁函数的**函数体在旧新位置逐字一致**。
14
+
15
+ ### 重构
16
+
17
+ - **`diary/scheduler.js`(779 行五职责)拆分**(#26):
18
+ - `diary/deliver.js`(新)—— 投递与回执判定:`shouldAskAgain` / `askAgentToWrite` / `mtimeMsOf`
19
+ - `diary/agent.js` —— `diaryAgent` 并入(与 R16 移进来的 `composeDiarySetup` 同属「会话获取 / 冷启动」)
20
+ - `diary/scheduler.js` —— 只留定时器 / 双层锁 / 主流程 / `regenerateDiary` / `runCatchUp`(779 → 551 行)
21
+ - 函数体由脚本按段落切分,**逐字未改**;`askAgentToWrite` 因跨模块调用由私有改导出(已披露)。
22
+ - `lib/diary.js` 门面导出名集合(29 个)不变,`diaryAgent` 改从 `agent.js` re-export。
23
+
24
+ ### 测试
25
+
26
+ - 新增 `tests/r17-deliver-feature.test.js`(11 断言),**先于拆分提交**且在旧代码上全绿:
27
+ 补上了 `shouldAskAgain` 这块**零直接覆盖**的判定矩阵(force / 不存在 / since=0 老行为 /
28
+ 旧文件重写 / 新文件不重问 / mtime 被拨老),以及 `since` 语义的端到端验证 ——
29
+ 那就是 P1-D3「看门狗每 30 分钟空转、日志却写『日记完成』」那条事故的判据。
30
+ - 既有 `tests/r05-diary-state.test.js` 只改了 import 路径与调用点,**断言一字未动**(已逐行核对)。
31
+
32
+ ### 变更
33
+
34
+ - 契约快照走正规通道:`deliver.js` 新增 `askAgentToWrite` / `shouldAskAgain`,
35
+ `agent.js` +`diaryAgent`,`scheduler.js` −2。理由已记入 `SNAPSHOT_CHANGES.md`
36
+ (其中「R16 #26」是交付方的笔误,发布时更正为 R17)。
37
+ - **至此 `docs/KNOWN-ISSUES.md` 只剩 #23**(错误边界需宿主暴露 `React.Component`)。
38
+
39
+ ---
40
+
10
41
  ## 0.9.11 · 2026-11-10
11
42
 
12
43
  外部复检轮 **R16(重构轮)**,2 个提交 / 9 文件 / +583 −443。**对外行为零变化**:
package/docs/HANDOFF.md CHANGED
@@ -1,7 +1,7 @@
1
- # 交接文档 · dsh-agent-soul `0.9.11`
1
+ # 交接文档 · dsh-agent-soul `0.9.12`
2
2
 
3
3
  > 给接手的人(或 AI)。读完这一份就能开工,不需要翻聊天记录。
4
- > 写作时间:2026-11-08(0.9.11 于 2026-11-10 更新)· tag `v0.9.11` · npm `latest = 0.9.11`
4
+ > 写作时间:2026-11-08(0.9.12 于 2026-11-10 更新)· tag `v0.9.12` · npm `latest = 0.9.12`
5
5
 
6
6
  ---
7
7
 
@@ -33,7 +33,7 @@
33
33
 
34
34
  | 指标 | 数值 |
35
35
  |---|---|
36
- | 测试 | **88** 个测试文件 / 0 失败;契约 **11** / 0 |
36
+ | 测试 | **89** 个测试文件 / 0 失败;契约 **11** / 0 |
37
37
  | 代码量 | `lib/` 97 个文件 / ~19.9k 行 |
38
38
  | 运行时依赖 | **零**(`dependencies` 为空,刻意如此) |
39
39
  | 支持 | Node ≥ 22.19;CI 跑 Node 22 + 24 + Windows |
@@ -191,29 +191,23 @@ git switch -c fix/your-topic main # 从干净 main 拉
191
191
 
192
192
  ---
193
193
 
194
- ## 5. 当前遗留(2 条)
194
+ ## 5. 当前遗留(1 条)
195
195
 
196
196
  > 完整版在 [`docs/KNOWN-ISSUES.md`](KNOWN-ISSUES.md),每条带代码位置、影响、建议改法、验证程度(A 实测 / B 读代码 / C 仅归档)。
197
197
  >
198
- > **`0.9.11` 之后,「功能坏了」与「零散清理」类问题全部清零。** 只剩最后一个大文件 + 一条受宿主限制的。
198
+ > **`0.9.12` 之后,功能类 / 清理类 / 重构类已知问题全部清零。** 只剩这一条,而且**做不了**。
199
199
 
200
- ### 唯一的「用户能感觉到」的一条
201
-
202
- | # | 问题 | 位置 | 建议 |
200
+ | # | 问题 | 位置 | 为什么现在做不了 |
203
201
  |---|---|---|---|
204
- | **23** | 「错误边界」接不住**渲染期**异常 → 白屏 | `lib/client/app.js` | 需要 `React.Component` 基类;本 bundle 作用域里没有,**做不了**,只能等宿主暴露 |
205
-
206
- ### 最后一个大文件(1 条)
207
-
208
- | # | 问题 | 建议 |
209
- |---|---|---|
210
- | **26** | `diary/scheduler.js` 687 行混五种职责 | 拆 `diary/deliver.js`(投递 / 超时 / 等待她写)+ 会话相关部分并进 `diary/agent.js`(R16 已把 `composeDiarySetup` 放那儿了) |
202
+ | **23** | 「错误边界」接不住**渲染期**异常 → 白屏 | `lib/client/app.js` | 需要 `React.Component` 基类;本 bundle 的作用域里只有 `h` 与几个 hook,没有 `Component`。**等宿主暴露**,别自欺欺人地改成 `try/catch`(渲染发生在 React 内部,抓不到) |
211
203
 
212
- > 已清掉的:#28(`text()` 拆成三个私有函数)、#32(构建拒绝未登记片段)、
213
- > #33(`revOf` 收敛)、#34(死代码标注;并更正了「`force` 恒 false」这个**我方文档错误** ——
214
- > `regenerateDiary` 实际传了 `{ force: true }`)、#35(preview CSS 已漂移,现为逐字符门禁)、
215
- > #27(`compose.js` 切四块:`llm.js` / `history.js` / `agent.js` / `compose.js`,
216
- > 10 个函数体逐字未改、门面 29 个导出名前后一致)。
204
+ > 已清掉的(按轮次):#28 与 #32–#35(R15)、#27(R16)、#26(R17)、
205
+ > 以及更早的 #1–#22 大部分。三个大文件都已拆完:
206
+ > `segment-memory.js`(`text()` → 三个私有函数)、`diary/compose.js`(→ `llm` / `history` / `agent`)、
207
+ > `diary/scheduler.js`(→ `deliver` + `agent`,主文件 679 → 551 行)。
208
+ >
209
+ > 还有一个**我方文档错误**已更正:`askAgentToWrite` 的 `force` 参数不是死代码,
210
+ > `regenerateDiary` 确实传了 `{ force: true }`。
217
211
 
218
212
  ### 明确「不修」的(想清楚了,别捡起来)
219
213
 
@@ -232,15 +226,18 @@ git switch -c fix/your-topic main # 从干净 main 拉
232
226
 
233
227
  ---
234
228
 
235
- ## 6. 建议的下一轮顺序(0.9.11 后)
229
+ ## 6. 下一轮该做什么(0.9.12 后)
230
+
231
+ **代码层面的待修项已经清零。** 剩下的都不是「改代码」:
236
232
 
237
- **只剩最后一个大文件。**
233
+ 1. **`#23`** —— 等宿主暴露 `React.Component`。在那之前别动:`try/catch` 包不住渲染期异常
234
+ (渲染发生在 React 内部),改了只会得到一个假的错误边界。
235
+ 2. **两条「待确认」**(见 §5 之后的第六节)—— 都需要**真实环境**:压缩会话的 `snapshotEvents`
236
+ 会不会抛、反代 + 非默认端口下的 `Origin`/`Host` 形态。谁遇到谁先留日志。
238
237
 
239
- 1. **`#26 diary/scheduler.js`(687 行五职责)** —— 拆 `diary/deliver.js`(投递 / 超时 / 等待她写)
240
- + 会话相关部分并进 `diary/agent.js`(R16 已把 `composeDiarySetup` 放那儿了)。
241
- 2. **`#23`** —— 除非宿主文档明确暴露了 `React.Component`,否则不要动。
238
+ 如果还想继续改,方向应该是**新需求**,不是还债。
242
239
 
243
- > 重构的纪律(R15 / R16 两轮验证有效,照抄):
240
+ > 三条重构纪律(R15 / R16 / R17 三轮验证有效,照抄):
244
241
  > **先补特征测试钉住当下行为 → 再拆 → 特征测试一条不改必须全绿 → 毒化一次证明测试网有效。**
245
242
  >
246
243
  > 三个实践细节值得学:
@@ -1,4 +1,4 @@
1
- # 已知问题清单(截至 0.9.11;R13 划 23 条、R14 划 4 条、R15 划 5 条、R16 划 1 条)
1
+ # 已知问题清单(截至 0.9.12;R13 划 23、R14 划 4、R15 划 5、R16 划 1、R17 划 1)
2
2
 
3
3
  > 2026-11-08 R13 轮:~~划线~~ 条目已修,测试锚定在 `tests/r13-batch.test.js`(36 断言),
4
4
  > 修法见提交历史(fix/known-issues-r13 分支 R13 批次一~五)。
@@ -15,7 +15,14 @@
15
15
  > `llm.js` / `history.js` / `agent.js`(`composeDiarySetup` 移正)/ `compose.js` 只留 prompt 组装。
16
16
  > 特征测试 `tests/r16-compose-feature.test.js`(11 断言)先于拆分提交;复核时逐个函数比对,
17
17
  > **10 个函数体在新旧位置逐字一致**,门面导出 29 个名字前后完全相同。
18
- > **仍打开:#26(最后一个大文件)、#23(等宿主暴露 React.Component)与第五、六节。**
18
+ >
19
+ > **2026-11-10 R17 轮(0.9.12,重构)**:划掉 **#26**。`scheduler.js`(779 行)拆出
20
+ > `deliver.js`(`shouldAskAgain` / `askAgentToWrite` / `mtimeMsOf`)+ `diaryAgent` 并入 `agent.js`,
21
+ > 主文件降到 551 行。特征测试 `tests/r17-deliver-feature.test.js`(11 断言)先于拆分提交,
22
+ > 补上了 `shouldAskAgain` 这块**零直接覆盖**的判定矩阵。毒化复核是**双网**:
23
+ > 特征测试 4 条红 + 既有 `r05-diary-state` 1 条红。
24
+ >
25
+ > **至此 KNOWN-ISSUES 只剩 #23(需宿主暴露 `React.Component`)与第五、六节(明确不修 / 待确认)。**
19
26
  >
20
27
  > **2026-11-08 复核补丁(0.9.8)**:R13 的 #1(`/diary/list` 只读头部 400 字节)按字节切 UTF-8,
21
28
  > 中文预览末尾会出现 `�`(U+FFFD)—— 400 % 3 ≠ 0,边界必然落在汉字中间。
@@ -85,7 +92,7 @@
85
92
 
86
93
  | # | 问题 | 影响 | 建议 |
87
94
  |---|---|---|---|
88
- | 26 | `diary/scheduler.js` 687 行混五种职责 | 改一处要读整文件 | 拆 `diary/agent.js` + `diary/deliver.js` |
95
+ | ~~26~~ ✅已修(2026-11-10 R17) | `diary/scheduler.js` 779 行混五种职责 | 改一处要读整文件 | 拆出 `diary/deliver.js`(投递与回执判定)+ `diaryAgent` 并入 `diary/agent.js`;scheduler 留定时器/双层锁/主流程(551 行);函数体逐字未改 |
89
96
  | ~~27~~ ✅已修(2026-11-10 R16) | `diary/compose.js` 644 行四类职责,`composeDiarySetup` 放错位置 | 同上 | 已切四块:`llm.js`(LLM 调用)/ `history.js`(最近日记)/ `agent.js`(`composeDiarySetup` 移正)/ `compose.js` 只留 prompt 组装(217 行);10 个函数体逐字未改 |
90
97
  | ~~28~~ ✅已修(2026-11-08 R15) | `host/runtime/segment-memory.js` 的 `text()` 约 150 行、8 种职责的上帝函数 | 难以单测 | 拆 `collectDiaryMaterial` / `memoryBudgetPlan` / `computeRecallText`(均文件私有,无新导出) |
91
98
  | ~~29~~ ✅已修(2026-11-08 R13) | `index.js` 顶部注释的注入顺序漏了 `soul:data-policy` | 文档与代码漂移 | 补一句 |
@@ -117,27 +124,34 @@
117
124
 
118
125
  ---
119
126
 
120
- ## 七、建议的下一轮顺序(0.9.11 后更新)
127
+ ## 七、下一轮该做什么(0.9.12 后更新)
128
+
129
+ **代码层面的待修项已经清零。** 剩下的只有两类,都不是「改代码」:
130
+
131
+ 1. **#23(渲染期白屏)** —— 需要宿主的 `React.Component`。**先等等**:如果哪天 DSH 文档里
132
+ 明确暴露了基类,再做;否则做了也是假的(当前这个「错误边界」只能接住 window 错误与
133
+ unhandledrejection,接不住渲染期异常)。
134
+ 2. **两条「待确认」**(见第六节)—— 都需要**真实环境**才能验:压缩会话的 `snapshotEvents`
135
+ 会不会抛、反代 + 非默认端口下的 `Origin`/`Host` 形态。谁遇到谁先记日志。
121
136
 
122
- **只剩一条重构 + 一条受宿主限制的。**
137
+ 如果还想继续改,方向应该是「新需求」而不是「还债」了。
123
138
 
124
- 1. **#26 `diary/scheduler.js`(687 行五职责)** —— 拆 `diary/deliver.js`(投递 / 超时 / 等待她写)
125
- + 会话相关部分并进 `diary/agent.js`(R16 已经把 `composeDiarySetup` 放在那儿了)。
126
- 这是最后一条大文件。
127
- 2. **#23(渲染期白屏)** —— 除非宿主文档明确暴露了 `React.Component`,否则不要动。
139
+ ### 留给下一个重构者的话
128
140
 
129
- 重构纪律(R15/R16 两轮验证有效,照抄):
141
+ R15 / R16 / R17 三轮把三个大文件拆完了,过程中验证有效的六条做法,写在这里免得重走弯路:
130
142
 
131
143
  - **先补特征测试**,单独一个提交,且要在**拆分之前**就在旧代码上全绿 —— 否则它可能断言的是实现;
132
- - 拆分用**脚本按段落切分**(R16 的做法),别手抄 —— 手抄一定会在某处少一个空格或漏一行;
144
+ - 拆分用**脚本按段落切分**(R16 / R17 的做法),别手抄 —— 手抄一定会少一个空格或漏一行;
133
145
  - 拆完特征测试**一条不改**必须全绿;
134
146
  - **毒化一次**证明测试网有效。毒化不红时先怀疑毒化点或毒化写法:
135
147
  R15 第一版选了确定性路径(重算字节相同 → 不红),R16 第一版把条件写成 `A || B && false`
136
148
  (运算符优先级让毒化失效)—— **两次都是毒化写错,不是测试无效**;
137
- - 复核方会**逐个函数比对**「函数体在新旧位置是否逐字一致」,这是纯移动的唯一硬证据。
149
+ - 复核方会**逐个函数比对**「函数体在新旧位置是否逐字一致」,这是纯移动的唯一硬证据;
150
+ - 函数跨模块移动时,**既有测试的 import 路径与调用点必须跟着改**,但**断言一个字符都不许动**
151
+ —— R16、R17 都这么做的,diff 里能一眼看清。
138
152
 
139
- > 这一轮之后,**功能类与清理类已知问题全部清零,只剩最后一个大文件**。
140
- > 风险已经从「用户会踩到」变成「改的人会踩到」。
153
+ > 这三轮之后,**功能类、清理类、重构类已知问题全部清零**。
154
+ > 代码结构不再是「改一处要读整文件」的状态了。
141
155
 
142
156
  ---
143
157
 
@@ -7,6 +7,7 @@
7
7
  * scheduler.js),本轮一并删除。
8
8
  */
9
9
  import { note, serviceOf } from '../env.js'
10
+ import { loadConfig } from '../store.js'
10
11
  import { readSessionMeta } from '../session-title.js'
11
12
 
12
13
 
@@ -74,3 +75,92 @@ export async function composeDiarySetup(ctx, sessionId) {
74
75
  return undefined
75
76
  }
76
77
  }
78
+
79
+ /**
80
+ * 取绑定好的日记会话(2026-10-31:从「自建会话」改成「绑定已有会话」;2026-11-03 补冷启动 preset;
81
+ * 2026-11-05 补 agentOptions.model)。2026-11-10 #26 由 scheduler.js 并入本模块 ——
82
+ * 「会话获取/冷启动」与 composeDiarySetup 本来就是同一件事的两半。
83
+ * 完整的事故推理链见原 scheduler.js 版本(git 历史)与本函数体内注释。
84
+ */
85
+ export async function diaryAgent(ctx) {
86
+ const config = loadConfig()
87
+ const sessionId = String(config.diarySessionId ?? '').trim()
88
+
89
+ if (sessionId === '') {
90
+ // 没有绑定就是没有绑定。以前这里会去捞「最近活跃会话」,等于把日记写进
91
+ // 用户正在聊的那个会话 —— 语义错了,私密内容还可能摆到不该看的人面前。
92
+ note('diary', '没有绑定日记会话(diarySessionId 为空),跳过本次投递。去设置页「日记」里点「把当前会话指定为日记会话」')
93
+ return undefined
94
+ }
95
+
96
+ const agents = serviceOf(ctx, 'agents')
97
+ if (agents === undefined || agents === null || typeof agents.get !== 'function') {
98
+ note('diary', `绑定的日记会话不可用:宿主没有 agents 服务(${sessionId})`)
99
+ return undefined
100
+ }
101
+
102
+ const reasons = []
103
+
104
+ // ① 活着的
105
+ try {
106
+ const live = agents.get(sessionId)
107
+ if (live !== undefined && live !== null) {
108
+ note('diary', `绑定的日记会话已在运行:${sessionId}`)
109
+ return live
110
+ }
111
+ reasons.push('当前不活跃')
112
+ } catch (error) {
113
+ const message = error instanceof Error ? error.message : String(error)
114
+ note('diary', `取活会话 ${sessionId} 失败:${message}`)
115
+ reasons.push(`get 失败:${message}`)
116
+ }
117
+
118
+ // ② 冷启动
119
+ if (typeof agents.resume !== 'function') {
120
+ reasons.push('agents 服务没有 resume 方法')
121
+ } else {
122
+ try {
123
+ // 必须带上 setup:resume 只恢复会话,不恢复 preset。
124
+ // 不带的话日记会话会「活着但没有工具」,而且不报错(2026-11-03 事故)。
125
+ const setup = await composeDiarySetup(ctx, sessionId)
126
+
127
+ // 2026-11-05 修:还必须有 agentOptions.model。
128
+ //
129
+ // 文档原话:「agents[].provider / agents[].model —— 模型路由;分发前两者都必须存在」。
130
+ // resume 一个持久化会话时,模型**不会**从会话里恢复(session 头里根本没这个字段),
131
+ // 不显式传就得到一个没有模型的 agent。后果不是「模型选错了」,而是装配直接抛:
132
+ // prompt variable "{{model}}" has no value (section "deployment:persona-prefix")
133
+ // 每一轮都抛,日记一个字也写不出来 —— 而且界面只显示「本轮运行失败」,很难联想到模型。
134
+ //
135
+ // 路由取日记专用配置;没配就退回 diarySummarize*(也是给日记用的),
136
+ // 两个都没有时明确记一行,不要静默传空。
137
+ const provider = String(config.diaryAgentProvider ?? '').trim() || String(config.diarySummarizeProvider ?? '').trim()
138
+ const model = String(config.diaryAgentModel ?? '').trim() || String(config.diarySummarizeModel ?? '').trim()
139
+ let agentOptions
140
+ if (provider !== '' && model !== '') {
141
+ agentOptions = { provider, model }
142
+ } else {
143
+ note('diary', '没配 diaryAgentProvider/Model 也没配 diarySummarize*:冷启动的日记会话将没有模型,装配会失败')
144
+ }
145
+
146
+ const handle = await agents.resume({
147
+ resumeSessionId: sessionId,
148
+ ...(agentOptions === undefined ? {} : { agentOptions }),
149
+ ...(setup === undefined ? {} : { setup })
150
+ })
151
+ const agent = handle?.agent
152
+ if (agent !== undefined && agent !== null) {
153
+ note('diary', `冷启动绑定的日记会话成功:${sessionId}`)
154
+ return agent
155
+ }
156
+ reasons.push('resume 没有返回 agent')
157
+ } catch (error) {
158
+ const message = error instanceof Error ? error.message : String(error)
159
+ note('diary', `冷启动绑定的日记会话 ${sessionId} 失败:${message}`)
160
+ reasons.push(`resume 失败:${message}`)
161
+ }
162
+ }
163
+
164
+ note('diary', `绑定的日记会话不可用:${reasons.join(';') || '未知原因'}(${sessionId})`)
165
+ return undefined
166
+ }
@@ -0,0 +1,147 @@
1
+ /**
2
+ * 日记 · deliver.js(2026-11-10 KNOWN-ISSUES #26:由 scheduler.js 按职责拆出)
3
+ * 投递与回执判定:shouldAskAgain / askAgentToWrite(含 mtimeMsOf)。
4
+ * 「她写没写」的判据是目标文件在不在、mtime 是否新于本轮基线 —— 事故注释在函数体里。
5
+ * 定时器 / 双层锁 / 业务主流程仍在 scheduler.js;会话获取在 agent.js。
6
+ */
7
+ import { statSync } from 'node:fs'
8
+ import { exists } from '../paths.js'
9
+ import { waitForWrite } from './files.js'
10
+ import { note, serviceOf } from '../env.js'
11
+
12
+
13
+ /**
14
+ * 投一条消息给绑定会话,让她自己写日记,然后等文件出现(2026-11-04)。
15
+ *
16
+ * ── 回执为什么用「文件出现」而不是 followup 的返回值 ──
17
+ * 2026-10-31 就是栽在这儿:`agent.followup()` **同步返回 void**,旧判据
18
+ * 「没抛异常就算发送成功」对 void 函数恒为真 —— 日志天天报「已发送」,
19
+ * 取证的时候 335 个事件里 `source.kind='schedule'` 零命中,一个 turn 都没进。
20
+ *
21
+ * 官方 schedule 插件靠 `await sessions.flush(agent.session)` 拿回执,但那是从
22
+ * 打包好的 exe 里逆出来的接口,我在这边没法验证它一定存在。而 flush 也只能证明
23
+ * 「消息进了 turn」,证明不了「她把文章写完了」。
24
+ *
25
+ * 所以判据直接取最终事实:**目标文件在不在**。文件在就是写成了,别的一律不算。
26
+ *
27
+ * ── source.kind 为什么是 'schedule' ──
28
+ * extract.js 会跳过这个来源(不进记忆),mood.js 也跳过(不影响心情),
29
+ * 日记扫描自己也跳过(不进 JSONL)—— 否则「叫她写日记」这件事本身会被
30
+ * 记成一条对话,越滚越多。
31
+ *
32
+ * @returns {{ asked: boolean, wrote: boolean, reason: string }}
33
+ */
34
+ /**
35
+ * 文件的 mtime(毫秒)。读不到就返回 0 —— 调用方据此当成「比任何 since 都旧」,
36
+ * 也就是宁可重写一次,也不要把旧文件当成她的新产出。
37
+ */
38
+ function mtimeMsOf(file) {
39
+ try {
40
+ return statSync(file).mtimeMs
41
+ } catch {
42
+ return 0
43
+ }
44
+ }
45
+
46
+ /**
47
+ * 决定「还要不要再找她写一次」。
48
+ *
49
+ * 2026-11-07 R05 / P1-D3:抽成纯函数,一是给测试一个确定的入口,
50
+ * 二是把这条判断从 followup 的一大段代码里拎出来单独说清楚。
51
+ *
52
+ * - force(手动重写)→ 一定重新写
53
+ * - 文件不存在 → 要写
54
+ * - 文件存在 + since=0(没有时间基线,老调用方)→ 当她已经写过(保持老行为)
55
+ * - 文件存在 + since>0 → 只有比 since 新才算「她这轮写的」,否则是旧文件,重写
56
+ *
57
+ * @param {string} file
58
+ * @param {{ force?: boolean, since?: number }} [options]
59
+ * @returns {boolean} true = 要问她/重写
60
+ */
61
+ export function shouldAskAgain(file, { force = false, since = 0 } = {}) {
62
+ if (force === true) return true
63
+ if (!exists(file)) return true
64
+ if (!(since > 0)) return false
65
+ const mtime = mtimeMsOf(file)
66
+ // mtime 读不到(被删/权限)时按「更旧」处理:宁可重写一次,也不要把旧文件当成新产出
67
+ return mtime < since
68
+ }
69
+
70
+ export async function askAgentToWrite(ctx, agent, text, file, timeoutMs, { force = false, since = 0 } = {}) {
71
+ // 已经写过了就别再投 —— 投了也只能等来一个「已存在」的文件,白打扰她一次。
72
+ //
73
+ // 这条必须排在 agent 检查**之前**:否则没绑定会话的时候,哪怕她早就写好了,
74
+ // 也会一路掉进兜底生成,把她写的日记整篇覆盖掉。
75
+ // force(手动重写某一天)时跳过这个判断 —— 那种场景就是要重新写。
76
+ //
77
+ // ── 2026-11-07 R05 / P1-D3:光看「文件在不在」会把旧文件当成她刚写的 ──
78
+ //
79
+ // 事故链:某天有一篇「写于当天最后一句话之前」的半成品(下午手动补的),
80
+ // startupWork 判它不完整 → 决定重写 → 走到这里看到文件存在 → 认为"她写好了"
81
+ // → 记「日记完成」返回 true → 文件没变 → 下一轮仍不完整 → 再走一遍……
82
+ // 结果是**看门狗每 30 分钟空转一次**,而日志里写的是「日记完成」,看起来一切正常,
83
+ // 那段内容永远补不回来。
84
+ //
85
+ // 现在多一个时间判据:`since` = 这一轮开始重写的时间。文件比它旧,就说明是上一轮
86
+ // 留下的旧文件,不能算「她这次写的」。`since` 为 0 时保持老行为(其它调用方不受影响)。
87
+ if (!shouldAskAgain(file, { force, since })) {
88
+ return { asked: false, wrote: true, reason: '' }
89
+ }
90
+ if (exists(file) && force !== true) {
91
+ // 走到这里 = 文件在、但比 since 旧 → 是上一轮留下的旧文件,这次重新问她
92
+ note('diary', `${file} 是旧文件(写于本轮之前),这次重新找她写`)
93
+ }
94
+
95
+ if (agent === undefined || agent === null || typeof agent.followup !== 'function') {
96
+ return { asked: false, wrote: false, reason: '没有可投递的会话(followup 不可用)' }
97
+ }
98
+
99
+ let message
100
+ try {
101
+ const blocks = [{ type: 'text', text }]
102
+ const llm = serviceOf(ctx, 'llm')
103
+ message = llm !== undefined && llm !== null && typeof llm.createUserMessage === 'function'
104
+ ? llm.createUserMessage({ content: blocks, source: { kind: 'schedule' } })
105
+ : {
106
+ id: `soul-diary-${Date.now()}-${Math.random().toString(16).slice(2)}`,
107
+ role: 'user',
108
+ content: blocks,
109
+ source: { kind: 'schedule' }
110
+ }
111
+ } catch (error) {
112
+ return { asked: false, wrote: false, reason: `构造消息失败:${error instanceof Error ? error.message : error}` }
113
+ }
114
+
115
+ // 记下投递前的 mtime,用来判断「是不是这次写出来的」。
116
+ // followup 有可能是**同步**写盘的(插件内部的工具调用可以在同一个 tick 里跑完),
117
+ // 所以投完要立刻看一眼 —— 不能直接交给 waitForWrite:
118
+ // waitForWrite 的语义是「等 mtime 变化」,它进去时会把当前 mtime 当成基线,
119
+ // 文件要是已经写好了,基线就等于完成后的值,于是永远等不到「变化」。
120
+ const mtimeBefore = (() => {
121
+ try {
122
+ return exists(file) ? statSync(file).mtimeMs : 0
123
+ } catch {
124
+ return 0
125
+ }
126
+ })()
127
+
128
+ try {
129
+ agent.followup(message)
130
+ } catch (error) {
131
+ return { asked: false, wrote: false, reason: `投递抛异常:${error instanceof Error ? error.message : error}` }
132
+ }
133
+
134
+ // 同步就写完的情况:这里直接认,别再去等一个永远不会来的 mtime 变化
135
+ try {
136
+ if (exists(file) && statSync(file).mtimeMs > mtimeBefore) return { asked: true, wrote: true, reason: '' }
137
+ } catch {
138
+ /* 读不到就往下走,交给异步等待 */
139
+ }
140
+
141
+ const wrote = await waitForWrite(file, timeoutMs)
142
+ return {
143
+ asked: true,
144
+ wrote,
145
+ reason: wrote ? '' : `等了 ${Math.round(timeoutMs / 1000)} 秒没见她写出文件`
146
+ }
147
+ }
@@ -2,108 +2,21 @@
2
2
  * 日记 · scheduler.js
3
3
  * 由 lib/diary.js 按职责拆出(2026-11-06 模块化重构),函数体保持原样。
4
4
  */
5
- import { composeDiarySetup } from './agent.js'
5
+ import { diaryAgent } from './agent.js'
6
6
  import { readRecentDiaries } from './history.js'
7
7
  import { composeDiaryText } from './llm.js'
8
8
  import { buildMoodBlocks, composePrivateMessage, composePublicMessage } from './compose.js'
9
9
  import { closeMentioned, expireThreads, extractThreads, loadThreads, openThread, renderThreadSection, saveThreads } from '../threads.js'
10
10
  import { diaryIsCompleteFor, todayKey, yesterdayKey } from '../diary/completion.js'
11
11
  import { diaryPrivatePath, diaryPublicPath, exists, readText } from '../paths.js'
12
- import { findMissingDay, waitForWrite, writeDiaryFile } from './files.js'
12
+ import { findMissingDay, writeDiaryFile } from './files.js'
13
+ import { askAgentToWrite } from './deliver.js'
13
14
  import { join } from 'node:path'
14
15
  import { loadConfig } from '../store.js'
15
16
  import { note, serviceOf } from '../env.js'
16
17
  import { pickConversation } from '../core/diary-pick.js'
17
18
  import { readConversationRows, readDiaryConversations } from './feed.js'
18
- import { statSync } from 'node:fs'
19
19
 
20
-
21
- export async function diaryAgent(ctx) {
22
- const config = loadConfig()
23
- const sessionId = String(config.diarySessionId ?? '').trim()
24
-
25
- if (sessionId === '') {
26
- // 没有绑定就是没有绑定。以前这里会去捞「最近活跃会话」,等于把日记写进
27
- // 用户正在聊的那个会话 —— 语义错了,私密内容还可能摆到不该看的人面前。
28
- note('diary', '没有绑定日记会话(diarySessionId 为空),跳过本次投递。去设置页「日记」里点「把当前会话指定为日记会话」')
29
- return undefined
30
- }
31
-
32
- const agents = serviceOf(ctx, 'agents')
33
- if (agents === undefined || agents === null || typeof agents.get !== 'function') {
34
- note('diary', `绑定的日记会话不可用:宿主没有 agents 服务(${sessionId})`)
35
- return undefined
36
- }
37
-
38
- const reasons = []
39
-
40
- // ① 活着的
41
- try {
42
- const live = agents.get(sessionId)
43
- if (live !== undefined && live !== null) {
44
- note('diary', `绑定的日记会话已在运行:${sessionId}`)
45
- return live
46
- }
47
- reasons.push('当前不活跃')
48
- } catch (error) {
49
- const message = error instanceof Error ? error.message : String(error)
50
- note('diary', `取活会话 ${sessionId} 失败:${message}`)
51
- reasons.push(`get 失败:${message}`)
52
- }
53
-
54
- // ② 冷启动
55
- if (typeof agents.resume !== 'function') {
56
- reasons.push('agents 服务没有 resume 方法')
57
- } else {
58
- try {
59
- // 必须带上 setup:resume 只恢复会话,不恢复 preset。
60
- // 不带的话日记会话会「活着但没有工具」,而且不报错(2026-11-03 事故)。
61
- const setup = await composeDiarySetup(ctx, sessionId)
62
-
63
- // 2026-11-05 修:还必须有 agentOptions.model。
64
- //
65
- // 文档原话:「agents[].provider / agents[].model —— 模型路由;分发前两者都必须存在」。
66
- // resume 一个持久化会话时,模型**不会**从会话里恢复(session 头里根本没这个字段),
67
- // 不显式传就得到一个没有模型的 agent。后果不是「模型选错了」,而是装配直接抛:
68
- // prompt variable "{{model}}" has no value (section "deployment:persona-prefix")
69
- // 每一轮都抛,日记一个字也写不出来 —— 而且界面只显示「本轮运行失败」,很难联想到模型。
70
- //
71
- // 路由取日记专用配置;没配就退回 diarySummarize*(也是给日记用的),
72
- // 两个都没有时明确记一行,不要静默传空。
73
- const provider = String(config.diaryAgentProvider ?? '').trim() || String(config.diarySummarizeProvider ?? '').trim()
74
- const model = String(config.diaryAgentModel ?? '').trim() || String(config.diarySummarizeModel ?? '').trim()
75
- let agentOptions
76
- if (provider !== '' && model !== '') {
77
- agentOptions = { provider, model }
78
- } else {
79
- note('diary', '没配 diaryAgentProvider/Model 也没配 diarySummarize*:冷启动的日记会话将没有模型,装配会失败')
80
- }
81
-
82
- const handle = await agents.resume({
83
- resumeSessionId: sessionId,
84
- ...(agentOptions === undefined ? {} : { agentOptions }),
85
- ...(setup === undefined ? {} : { setup })
86
- })
87
- const agent = handle?.agent
88
- if (agent !== undefined && agent !== null) {
89
- note('diary', `冷启动绑定的日记会话成功:${sessionId}`)
90
- return agent
91
- }
92
- reasons.push('resume 没有返回 agent')
93
- } catch (error) {
94
- const message = error instanceof Error ? error.message : String(error)
95
- note('diary', `冷启动绑定的日记会话 ${sessionId} 失败:${message}`)
96
- reasons.push(`resume 失败:${message}`)
97
- }
98
- }
99
-
100
- note('diary', `绑定的日记会话不可用:${reasons.join(';') || '未知原因'}(${sessionId})`)
101
- return undefined
102
- }
103
-
104
-
105
-
106
- // --------------------------------------------------------------------------
107
20
  // 启动时写(2026-10-31 改造:去掉 22:00 闹钟)
108
21
  // --------------------------------------------------------------------------
109
22
 
@@ -259,11 +172,6 @@ export function startDiaryTimer(ctx, { budgetMs = DIARY_TOTAL_BUDGET_MS } = {})
259
172
  }
260
173
  }
261
174
 
262
-
263
- // --------------------------------------------------------------------------
264
- // 主流程
265
- // --------------------------------------------------------------------------
266
-
267
175
  /**
268
176
  * 执行一次完整的日记生成流程。
269
177
  *
@@ -279,142 +187,6 @@ export function startDiaryTimer(ctx, { budgetMs = DIARY_TOTAL_BUDGET_MS } = {})
279
187
  * @param {string} [manualNote] 手动触发时的备注(追加到对话内容之后)
280
188
  * @returns {Promise<boolean>} 是否成功投递
281
189
  */
282
- /**
283
- * 投一条消息给绑定会话,让她自己写日记,然后等文件出现(2026-11-04)。
284
- *
285
- * ── 回执为什么用「文件出现」而不是 followup 的返回值 ──
286
- * 2026-10-31 就是栽在这儿:`agent.followup()` **同步返回 void**,旧判据
287
- * 「没抛异常就算发送成功」对 void 函数恒为真 —— 日志天天报「已发送」,
288
- * 取证的时候 335 个事件里 `source.kind='schedule'` 零命中,一个 turn 都没进。
289
- *
290
- * 官方 schedule 插件靠 `await sessions.flush(agent.session)` 拿回执,但那是从
291
- * 打包好的 exe 里逆出来的接口,我在这边没法验证它一定存在。而 flush 也只能证明
292
- * 「消息进了 turn」,证明不了「她把文章写完了」。
293
- *
294
- * 所以判据直接取最终事实:**目标文件在不在**。文件在就是写成了,别的一律不算。
295
- *
296
- * ── source.kind 为什么是 'schedule' ──
297
- * extract.js 会跳过这个来源(不进记忆),mood.js 也跳过(不影响心情),
298
- * 日记扫描自己也跳过(不进 JSONL)—— 否则「叫她写日记」这件事本身会被
299
- * 记成一条对话,越滚越多。
300
- *
301
- * @returns {{ asked: boolean, wrote: boolean, reason: string }}
302
- */
303
- /**
304
- * 文件的 mtime(毫秒)。读不到就返回 0 —— 调用方据此当成「比任何 since 都旧」,
305
- * 也就是宁可重写一次,也不要把旧文件当成她的新产出。
306
- */
307
- function mtimeMsOf(file) {
308
- try {
309
- return statSync(file).mtimeMs
310
- } catch {
311
- return 0
312
- }
313
- }
314
-
315
- /**
316
- * 决定「还要不要再找她写一次」。
317
- *
318
- * 2026-11-07 R05 / P1-D3:抽成纯函数,一是给测试一个确定的入口,
319
- * 二是把这条判断从 followup 的一大段代码里拎出来单独说清楚。
320
- *
321
- * - force(手动重写)→ 一定重新写
322
- * - 文件不存在 → 要写
323
- * - 文件存在 + since=0(没有时间基线,老调用方)→ 当她已经写过(保持老行为)
324
- * - 文件存在 + since>0 → 只有比 since 新才算「她这轮写的」,否则是旧文件,重写
325
- *
326
- * @param {string} file
327
- * @param {{ force?: boolean, since?: number }} [options]
328
- * @returns {boolean} true = 要问她/重写
329
- */
330
- export function shouldAskAgain(file, { force = false, since = 0 } = {}) {
331
- if (force === true) return true
332
- if (!exists(file)) return true
333
- if (!(since > 0)) return false
334
- const mtime = mtimeMsOf(file)
335
- // mtime 读不到(被删/权限)时按「更旧」处理:宁可重写一次,也不要把旧文件当成新产出
336
- return mtime < since
337
- }
338
-
339
- async function askAgentToWrite(ctx, agent, text, file, timeoutMs, { force = false, since = 0 } = {}) {
340
- // 已经写过了就别再投 —— 投了也只能等来一个「已存在」的文件,白打扰她一次。
341
- //
342
- // 这条必须排在 agent 检查**之前**:否则没绑定会话的时候,哪怕她早就写好了,
343
- // 也会一路掉进兜底生成,把她写的日记整篇覆盖掉。
344
- // force(手动重写某一天)时跳过这个判断 —— 那种场景就是要重新写。
345
- //
346
- // ── 2026-11-07 R05 / P1-D3:光看「文件在不在」会把旧文件当成她刚写的 ──
347
- //
348
- // 事故链:某天有一篇「写于当天最后一句话之前」的半成品(下午手动补的),
349
- // startupWork 判它不完整 → 决定重写 → 走到这里看到文件存在 → 认为"她写好了"
350
- // → 记「日记完成」返回 true → 文件没变 → 下一轮仍不完整 → 再走一遍……
351
- // 结果是**看门狗每 30 分钟空转一次**,而日志里写的是「日记完成」,看起来一切正常,
352
- // 那段内容永远补不回来。
353
- //
354
- // 现在多一个时间判据:`since` = 这一轮开始重写的时间。文件比它旧,就说明是上一轮
355
- // 留下的旧文件,不能算「她这次写的」。`since` 为 0 时保持老行为(其它调用方不受影响)。
356
- if (!shouldAskAgain(file, { force, since })) {
357
- return { asked: false, wrote: true, reason: '' }
358
- }
359
- if (exists(file) && force !== true) {
360
- // 走到这里 = 文件在、但比 since 旧 → 是上一轮留下的旧文件,这次重新问她
361
- note('diary', `${file} 是旧文件(写于本轮之前),这次重新找她写`)
362
- }
363
-
364
- if (agent === undefined || agent === null || typeof agent.followup !== 'function') {
365
- return { asked: false, wrote: false, reason: '没有可投递的会话(followup 不可用)' }
366
- }
367
-
368
- let message
369
- try {
370
- const blocks = [{ type: 'text', text }]
371
- const llm = serviceOf(ctx, 'llm')
372
- message = llm !== undefined && llm !== null && typeof llm.createUserMessage === 'function'
373
- ? llm.createUserMessage({ content: blocks, source: { kind: 'schedule' } })
374
- : {
375
- id: `soul-diary-${Date.now()}-${Math.random().toString(16).slice(2)}`,
376
- role: 'user',
377
- content: blocks,
378
- source: { kind: 'schedule' }
379
- }
380
- } catch (error) {
381
- return { asked: false, wrote: false, reason: `构造消息失败:${error instanceof Error ? error.message : error}` }
382
- }
383
-
384
- // 记下投递前的 mtime,用来判断「是不是这次写出来的」。
385
- // followup 有可能是**同步**写盘的(插件内部的工具调用可以在同一个 tick 里跑完),
386
- // 所以投完要立刻看一眼 —— 不能直接交给 waitForWrite:
387
- // waitForWrite 的语义是「等 mtime 变化」,它进去时会把当前 mtime 当成基线,
388
- // 文件要是已经写好了,基线就等于完成后的值,于是永远等不到「变化」。
389
- const mtimeBefore = (() => {
390
- try {
391
- return exists(file) ? statSync(file).mtimeMs : 0
392
- } catch {
393
- return 0
394
- }
395
- })()
396
-
397
- try {
398
- agent.followup(message)
399
- } catch (error) {
400
- return { asked: false, wrote: false, reason: `投递抛异常:${error instanceof Error ? error.message : error}` }
401
- }
402
-
403
- // 同步就写完的情况:这里直接认,别再去等一个永远不会来的 mtime 变化
404
- try {
405
- if (exists(file) && statSync(file).mtimeMs > mtimeBefore) return { asked: true, wrote: true, reason: '' }
406
- } catch {
407
- /* 读不到就往下走,交给异步等待 */
408
- }
409
-
410
- const wrote = await waitForWrite(file, timeoutMs)
411
- return {
412
- asked: true,
413
- wrote,
414
- reason: wrote ? '' : `等了 ${Math.round(timeoutMs / 1000)} 秒没见她写出文件`
415
- }
416
- }
417
-
418
190
 
419
191
  /**
420
192
  * 同一天同时只允许一条写日记的流程在跑(2026-11-04 修 ④)。
package/lib/diary.js CHANGED
@@ -43,5 +43,6 @@ export { composeDiaryText, summarizeConversations } from './diary/llm.js'
43
43
  export { digestDiaries, readRecentDiaries } from './diary/history.js'
44
44
  export { buildMoodBlocks, composePrivateMessage, composePublicMessage, diaryWindowOf } from './diary/compose.js'
45
45
  export { findMissingDay, waitForWrite, writeDiaryFile } from './diary/files.js'
46
- export { __resetDiaryInFlightForTest, diaryAgent, regenerateDiary, runCatchUp, runDiaryOnce, startDiaryTimer } from './diary/scheduler.js'
46
+ export { diaryAgent } from './diary/agent.js'
47
+ export { __resetDiaryInFlightForTest, regenerateDiary, runCatchUp, runDiaryOnce, startDiaryTimer } from './diary/scheduler.js'
47
48
  export { todayKey, yesterdayKey, parseDateLocal, scheduleMinutes, diaryDayBoundaries, diaryIsCompleteFor } from './diary/completion.js'
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "dsh-agent-soul",
3
- "version": "0.9.11",
3
+ "version": "0.9.12",
4
4
  "type": "module",
5
5
  "description": "给 DSH 的 agent 一套会忘事的记忆、一份会变的人格和一份会起伏的心情:人格按小节合并(项目覆盖全局但不吃掉全局),记忆按人的规律衰减(清晰→模糊→只剩印象→遗忘),「心里惦记的事」让她的主动有连续性,心情跟着每轮对话自己判断、自己平复(不注入、无挂饰)。",
6
6
  "keywords": [