dsh-agent-board 1.7.4 → 1.7.6

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.
@@ -0,0 +1,543 @@
1
+ // dsh-agent-board — 集成套件(无头基建卡2 前半 + 卡3 后半):
2
+ // 前半(a-d):全链路 / 驳回重派 / dependsOn 接续 / touches 排他
3
+ // 后半(e-i,task-muxpgq5b):仲裁冻结时钟推进 / 回执聚合过滤 / 歧义去抖 / progress / 孤儿回收
4
+ // 九场景全部跑在「真实 index.mjs apply(mockCtx)」上(卡1 harness),不改生产代码;
5
+ // 每用例独立 mockCtx + 独立临时 HOME,互不污染(HOME env 是进程级,顶层用例默认串行,严禁并行)。
6
+ //
7
+ // 结算双通道各半(任务要求):
8
+ // 上报通道(board_report 工具直调——mock tools.register 捕获的 handler):场景 a / b
9
+ // 事件通道(agent/status 的 running→idle → settleContinuable 文本兜底):场景 c / d
10
+ // 事件通道文本兜底的前提:settleContinuable 从子会话 v4 日志读助手文本。生产经 findRunLog 回退
11
+ // os.homedir()/.dsh/sessions——Windows 下 os.homedir() 认 USERPROFILE 不认 HOME,故 c/d 两例把
12
+ // USERPROFILE 也钉到本用例临时 HOME(pinHomedir),再往 <home>/.dsh/sessions/<桶>/<childId>/
13
+ // session.v4.jsonl.zstd 写真 zstd 帧(与 usage 单测同形),事件结算即可读到本轮交付文本。
14
+ //
15
+ // 时钟纪律:看板时间戳仍走真实墙钟(Date.now 不动),kickCycle 的 50ms 去抖走虚拟时钟——
16
+ // 每个写操作后 advance(50) 触发一轮 poolCycle。前半(a-d)单场景推进 ≤300ms 虚拟,所有长窗口
17
+ // 均不触发;后半(e-i)开始主动跨窗断言:25s 歧义去抖(g)、45s 回执聚合(f)、15s 心跳轮
18
+ // (e 的幽灵回收 / i 的孤儿扫描)。30min 软超时 / 120min 硬超时仍远超推进幅度(单场景 ≤45s
19
+ // 虚拟),永不触发。注意 isOrphan 的 2min 门槛锚的是真实墙钟(Date.now),场景 i 用 patchBoard
20
+ // 把 claimedAt 按真实时间倒推 3 分钟来构造孤儿——虚拟时钟只负责把 poolCycle 推到扫描窗口。
21
+ import { test } from 'node:test'
22
+ import assert from 'node:assert/strict'
23
+ import fs from 'node:fs'
24
+ import path from 'node:path'
25
+ import zlib from 'node:zlib'
26
+ import { createMockCtx } from './helpers/mock-ctx.mjs'
27
+ import * as plugin from '../index.mjs'
28
+
29
+ var zstdOk = typeof zlib.zstdCompressSync === 'function'
30
+
31
+ // ===== 测试工具 =====
32
+ // 一帧 v4 日志(与 lib/usage.mjs readLogFrames 同形:多帧 zstd 顺序拼接,帧内 jsonl)
33
+ function frameOf(events) { return zlib.zstdCompressSync(Buffer.from(events.map(function (e) { return JSON.stringify(e) }).join('\n') + '\n', 'utf8')) }
34
+
35
+ // 写一份 continuable 子会话日志:内含一条 assistant/message 文本帧(settleContinuable 的文本兜底数据源)。
36
+ // 布局与真实一致 <home>/.dsh/sessions/<桶>/<childId>/session.v4.jsonl.zstd(findRunLog 按桶探测)。
37
+ function writeChildLog(env, childId, text) {
38
+ var dir = path.join(env.home, '.dsh', 'sessions', 'test-bucket', childId)
39
+ fs.mkdirSync(dir, { recursive: true })
40
+ var ev = { type: 'assistant/message', time: Date.now(), seq: 1, data: { message: { content: [{ type: 'text', text: text }] } } }
41
+ fs.writeFileSync(path.join(dir, 'session.v4.jsonl.zstd'), frameOf([ev]))
42
+ }
43
+
44
+ // 把 os.homedir() 钉到本用例临时 HOME(Windows 下认 USERPROFILE);返回恢复闭包(finally 里先于 cleanup 调)
45
+ function pinHomedir(env) {
46
+ var had = Object.prototype.hasOwnProperty.call(process.env, 'USERPROFILE')
47
+ var prev = process.env.USERPROFILE
48
+ process.env.USERPROFILE = env.home
49
+ return function () { if (had) process.env.USERPROFILE = prev; else delete process.env.USERPROFILE }
50
+ }
51
+
52
+ // 建卡封装:显式 description 避开空描述软提示;其余字段按需透传
53
+ async function createTask(env, id, extra) {
54
+ var args = { sessionId: env.sid, id: id, title: '集成任务 ' + id, description: '集成套件用例 ' + id }
55
+ if (extra) { for (var k in extra) args[k] = extra[k] }
56
+ var r = await env.rpc('create-task', args)
57
+ assert.equal(r.ok, true, 'create-task 成功: ' + id)
58
+ assert.equal(r.task.status, 'pending', '非 Team 模式即建即 pending: ' + id)
59
+ return r.task
60
+ }
61
+
62
+ // Worker 交付文本(事件通道文本兜底用):分段格式,避开 [ESCALATE] 标记
63
+ function workerText(tag) {
64
+ return '## 开发描述\n完成 ' + tag + ' 的实现\n\n## 改动清单\n- src/' + tag + '.mjs:新增实现\n\n## 自测情况\nnpm test 全绿\n\n## diff 概要\n 1 file changed, 10 insertions(+)'
65
+ }
66
+ // Verifier 结论文本:行首锚定 APPROVED/REJECTED(parseVerdict 口径),分段供 parseSections 提取
67
+ //(verifySummary 只认「测试概要|验证概要|审查概要」标题,checks 只认「核对项|核验项|检查项」——标题口径别写错)
68
+ var APPROVE_TEXT = 'APPROVED\n\n## 验证概要\n验收脚本独立复跑通过\n\n## 核对项\n- npm test 全绿'
69
+ var REJECT_TEXT = 'REJECTED\n\n## 验证概要\n验收脚本未通过:缺关键断言\n\n## 核对项\n- npm test 未见运行记录'
70
+
71
+ // history 流转序列(['created→pending', 'pending→in-progress', ...]),供全路径逐项断言
72
+ function transitions(t) { return (t.history || []).map(function (h) { return h.from + '→' + h.to }) }
73
+
74
+ // 取卡上某角色的 runs 条目
75
+ function runsOf(t, role) { return (t.runs || []).filter(function (r) { return r.role === role }) }
76
+
77
+ // 事件通道完成一个 continuable Worker turn:先写子会话日志(交付文本),再重放 running→idle
78
+ async function settleViaEvents(env, childId, tag) {
79
+ writeChildLog(env, childId, workerText(tag))
80
+ env.emitStatus(childId, 'running')
81
+ env.emitStatus(childId, 'idle')
82
+ }
83
+
84
+ // ===== 场景 a:全链路(上报通道)=====
85
+ // 创建 → 自动派发(continuable spawn)→ Worker board_report 完成 → verifying →
86
+ // Verifier 自动派发(一次性 run)→ APPROVED → resolved。状态机全路径 status/history/runs 逐项断言。
87
+ test('集成a·全链路:创建→自动派发→Worker board_report 完成→Verifier approved→resolved(上报通道)', async () => {
88
+ var env = createMockCtx()
89
+ try {
90
+ plugin.apply(env.ctx)
91
+ await createTask(env, 'task-a1', { pipeline: 'full', acceptance: 'npm test' })
92
+ // 自动派发:kickCycle 50ms 去抖 → poolCycle → continuable spawn
93
+ await env.clock.advance(50)
94
+ await env.waitFor(function () { return env.continuables.length >= 1 }, 'worker spawn 发生')
95
+ var child = env.continuables[0]
96
+ assert.equal(child.label, 'worker:task-a1', 'spawn label 形如 worker:<taskId>')
97
+ assert.equal(env.runs.length, 0, 'Worker 走 continuable 面,不动一次性 start')
98
+ var t = await env.waitFor(function () { var x = env.task('task-a1'); return x && x.status === 'in-progress' && x.claimedBy === child.childId ? x : null }, '落卡 in-progress 且 claimedBy=childId')
99
+ assert.deepEqual(transitions(t), ['created→pending', 'pending→in-progress'], '创建+占位 claim 两段历史')
100
+ assert.equal(t.runs.length, 1)
101
+ assert.equal(t.runs[0].role, 'worker')
102
+ assert.equal(t.runs[0].outcome, 'running', '在跑 run 记录 outcome=running')
103
+ assert.equal(t.runs[0].continuable, true)
104
+ // Worker 上报通道:board_report 工具直调(mock tools.register 捕获的 handler)
105
+ var rep = await env.tools.get('board_report').execute({ taskId: 'task-a1', kind: 'complete', summary: '实现全链路', changes: '改了 a', selfTest: 'npm test 全绿', diffStat: ' 1 file changed' })
106
+ assert.equal(rep.ok, true)
107
+ assert.equal(rep.task.status, 'verifying', 'full 档上报完成 → verifying')
108
+ t = env.task('task-a1')
109
+ assert.equal(t.deliverable.summary, '实现全链路', '交付物随工具参数落卡')
110
+ assert.equal(t.deliverable.selfTest, 'npm test 全绿')
111
+ // 上报通道收尾三件套之一:该轮 continuable run 记录当场关账(execute 内已 await settleReportedRun)
112
+ assert.equal(t.runs[0].outcome, 'completed', 'board_report 落定即关账,不等 idle 事件')
113
+ assert.ok(t.runs[0].endedAt, '关账写 endedAt')
114
+ // Verifier 自动派发(一次性 run 路径,run.result 结算)
115
+ await env.clock.advance(50)
116
+ var vrun = await env.waitFor(function () { return env.lastRun('verifier:task-a1') }, 'verifier spawn 发生')
117
+ assert.equal(vrun.req.label, 'verifier:task-a1')
118
+ t = await env.waitFor(function () { var x = env.task('task-a1'); return x && x.verifierRun === vrun.id ? x : null }, 'verifierRun 占位换成真实 run id')
119
+ assert.equal(t.status, 'verifying')
120
+ // Verifier 批准 → resolved(waitFor 必须等到整条结算链尾:状态推进与 run 关账是两次持锁写,
121
+ // 只等 status 会撞上「resolved 已落盘而 verifier run 还未关账」的窗口——与卡1 冒烟同口径)
122
+ vrun.resolveWith(APPROVE_TEXT)
123
+ t = await env.waitFor(function () { var x = env.task('task-a1'); return x && x.status === 'resolved' && runsOf(x, 'verifier')[0] && runsOf(x, 'verifier')[0].outcome === 'completed' ? x : null }, 'approved 落 resolved 且 verifier run 关账')
124
+ // ===== 状态机全路径逐项 =====
125
+ assert.deepEqual(transitions(t), ['created→pending', 'pending→in-progress', 'in-progress→verifying', 'verifying→resolved'], '全链路流转序列')
126
+ assert.equal(t.verification.verdict, 'approved')
127
+ assert.equal(t.verification.summary, '验收脚本独立复跑通过')
128
+ assert.ok(t.verifiedAt && t.verifiedBy, '验收留痕 verifiedAt/verifiedBy')
129
+ assert.ok(t.resolvedAt, 'resolvedAt 落卡')
130
+ assert.equal(t.runs.length, 2, 'worker + verifier 各一条 run 留档')
131
+ var vr = runsOf(t, 'verifier')
132
+ assert.equal(vr.length, 1)
133
+ assert.equal(vr[0].outcome, 'completed', 'verifier run 也关账 completed')
134
+ assert.equal(vr[0].id, vrun.id)
135
+ assert.equal(env.continuables.length, 1, '全程只有一个 Worker 子会话')
136
+ assert.equal(env.runs.length, 1, '全程只有一条一次性 verifier run')
137
+ } finally { await env.cleanup() }
138
+ })
139
+
140
+ // ===== 场景 b:驳回重派(上报通道)=====
141
+ // Worker board_report 完成 → Verifier REJECTED → 任务回 pending + 驳回包落 messages →
142
+ // 去抖后自动重派新 Worker(首轮 completed 无续跑资格 → fresh spawn,且驳回包随 prompt 注入)→
143
+ // 第二轮完成 → approved → resolved。
144
+ test('集成b·驳回重派:Verifier rejected→回 pending+驳回包落 messages→自动重派→approved(上报通道)', async () => {
145
+ var env = createMockCtx()
146
+ try {
147
+ plugin.apply(env.ctx)
148
+ await createTask(env, 'task-b1', { pipeline: 'full', acceptance: 'npm test' })
149
+ await env.clock.advance(50)
150
+ await env.waitFor(function () { return env.continuables.length >= 1 }, '第一轮 worker spawn')
151
+ var child1 = env.continuables[0]
152
+ await env.waitFor(function () { var x = env.task('task-b1'); return x && x.status === 'in-progress' && x.claimedBy === child1.childId ? x : null }, '第一轮落卡 in-progress')
153
+ // 第一轮 Worker 上报完成 → verifying
154
+ var rep1 = await env.tools.get('board_report').execute({ taskId: 'task-b1', kind: 'complete', summary: '第一版交付', changes: '改了 b', selfTest: 'npm test 全绿(谎报)', diffStat: '' })
155
+ assert.equal(rep1.ok, true)
156
+ await env.clock.advance(50)
157
+ var vrun1 = await env.waitFor(function () { return env.lastRun('verifier:task-b1') }, 'verifier spawn')
158
+ // Verifier 驳回 → 回 pending + 驳回包落 messages + rejectCount=1
159
+ //(等链尾:pending 落盘在先、verifier run 关账在后,一并等齐再断言)
160
+ vrun1.resolveWith(REJECT_TEXT)
161
+ var t = await env.waitFor(function () { var x = env.task('task-b1'); return x && x.status === 'pending' && runsOf(x, 'verifier')[0] && runsOf(x, 'verifier')[0].outcome === 'completed' ? x : null }, '驳回后回 pending 且 verifier run 关账')
162
+ assert.equal(t.rejectCount, 1)
163
+ assert.equal(t.claimedBy, null, '驳回后认领位清空待重派')
164
+ var rej = (t.messages || []).filter(function (m) { return m.kind === 'rejection' })
165
+ assert.equal(rej.length, 1, '驳回包落一条 kind=rejection 消息')
166
+ assert.ok(rej[0].text.indexOf('验收驳回 · 验收脚本未通过:缺关键断言') === 0, '驳回包带 summary')
167
+ assert.ok(rej[0].text.indexOf('核对项') >= 0, '驳回包带 checks 全量')
168
+ assert.deepEqual(transitions(t), ['created→pending', 'pending→in-progress', 'in-progress→verifying', 'verifying→in-progress', 'in-progress→pending'], '驳回流转序列(verifying→in-progress→pending 两段)')
169
+ assert.equal(t.runs.length, 2)
170
+ assert.equal(runsOf(t, 'worker')[0].outcome, 'completed')
171
+ assert.equal(runsOf(t, 'verifier')[0].outcome, 'completed', '驳回的 verifier run 本身正常关账')
172
+ // 去抖后自动重派:首轮 run 结局=completed 无续跑资格 → fresh spawn(不发 sendMessage)
173
+ await env.clock.advance(50)
174
+ await env.waitFor(function () { return env.continuables.length >= 2 }, '重派新 worker spawn')
175
+ var child2 = env.continuables[1]
176
+ assert.equal(child2.label, 'worker:task-b1')
177
+ assert.equal(env.sendMessages.length, 0, '结局 completed 不走断点续跑(无 sendMessage 冷复活)')
178
+ assert.ok(child2.request.prompt[0].text.indexOf('验收驳回') >= 0, '驳回包随 messages 注入新 Worker 首条 prompt')
179
+ t = await env.waitFor(function () { var x = env.task('task-b1'); return x && x.status === 'in-progress' && x.claimedBy === child2.childId ? x : null }, '第二轮落卡 in-progress')
180
+ // 第二轮 Worker 上报完成 → Verifier 批准 → resolved
181
+ var rep2 = await env.tools.get('board_report').execute({ taskId: 'task-b1', kind: 'complete', summary: '返工后交付', changes: '补上断言', selfTest: 'npm test 全绿', diffStat: '' })
182
+ assert.equal(rep2.ok, true)
183
+ await env.clock.advance(50)
184
+ var vrun2 = await env.waitFor(function () { var v = env.lastRun('verifier:task-b1'); return v && v !== vrun1 ? v : null }, '第二轮 verifier spawn')
185
+ vrun2.resolveWith(APPROVE_TEXT)
186
+ t = await env.waitFor(function () { var x = env.task('task-b1'); return x && x.status === 'resolved' && x.runs && x.runs.length === 4 && x.runs.every(function (r) { return r.outcome === 'completed' }) ? x : null }, '第二轮 approved 落 resolved 且全部 run 关账')
187
+ // ===== 全路径逐项 =====
188
+ assert.deepEqual(transitions(t), ['created→pending', 'pending→in-progress', 'in-progress→verifying', 'verifying→in-progress', 'in-progress→pending', 'pending→in-progress', 'in-progress→verifying', 'verifying→resolved'], '驳回重派全流转序列')
189
+ assert.equal(t.runs.length, 4, '两轮 worker + 两轮 verifier 各留档')
190
+ assert.ok(t.runs.every(function (r) { return r.outcome === 'completed' }), '四条 run 全部关账 completed')
191
+ assert.equal(runsOf(t, 'worker').length, 2)
192
+ assert.equal(runsOf(t, 'verifier').length, 2)
193
+ assert.equal(env.continuables.length, 2, '两轮 Worker 各一个子会话(fresh spawn)')
194
+ assert.equal(env.runs.length, 2, '两轮 Verifier 各一条一次性 run')
195
+ } finally { await env.cleanup() }
196
+ })
197
+
198
+ // ===== 场景 c:dependsOn 门控 + 依赖完成后自动接续(事件通道)=====
199
+ // B dependsOn [A]:A 未 resolved 时 B 不参与派发;A 经事件通道落定 resolved 后,下一轮 cycle 自动派 B。
200
+ test('集成c·dependsOn:B 门控不派→A 事件通道完成→B 自动接续(事件通道)', async (t) => {
201
+ if (!zstdOk) { t.skip('zstdCompressSync unavailable'); return }
202
+ var env = createMockCtx()
203
+ var restoreHome = pinHomedir(env) // 事件通道文本兜底读 os.homedir()/.dsh/sessions —— 钉到临时 HOME
204
+ try {
205
+ plugin.apply(env.ctx)
206
+ await createTask(env, 'task-ca', { pipeline: 'work' })
207
+ await createTask(env, 'task-cb', { pipeline: 'work', dependsOn: ['task-ca'] })
208
+ // 同一次去抖窗口只跑一轮 cycle:A 可派、B 被门控
209
+ await env.clock.advance(50)
210
+ await env.waitFor(function () { return env.continuables.length >= 1 }, 'A spawn 发生')
211
+ assert.equal(env.continuables[0].label, 'worker:task-ca', '先派依赖 A')
212
+ await env.waitFor(function () { var x = env.task('task-ca'); return x && x.status === 'in-progress' ? x : null }, 'A 落卡 in-progress')
213
+ // 门控断言:B 留在 pending、无认领、无 spawn、无多余历史
214
+ var tb = env.task('task-cb')
215
+ assert.equal(tb.status, 'pending', '依赖未落定 → B 门控在 pending')
216
+ assert.equal(tb.claimedBy, null)
217
+ assert.equal(env.continuables.length, 1, 'B 未派发(depsSatisfied 拦截)')
218
+ assert.deepEqual(transitions(tb), ['created→pending'], 'B 只有创建历史')
219
+ // A 事件通道完成(work 档文本兜底直落 resolved)
220
+ //(等链尾:resolved 落盘在先、run 关账在后——settleRunRecord 是第二次持锁写,一并等齐)
221
+ var childA = env.continuables[0].childId
222
+ await settleViaEvents(env, childA, 'A')
223
+ var ta = await env.waitFor(function () { var x = env.task('task-ca'); return x && x.status === 'resolved' && x.runs && x.runs[0] && x.runs[0].outcome === 'completed' ? x : null }, 'A 事件结算落 resolved 且 run 关账')
224
+ assert.equal(ta.deliverable.summary, '完成 A 的实现', '交付物走文本分段解析')
225
+ assert.equal(ta.runs[0].outcome, 'completed', '事件通道同样关账 completed')
226
+ assert.equal(ta.runs[0].continuable, true)
227
+ assert.deepEqual(transitions(ta), ['created→pending', 'pending→in-progress', 'in-progress→resolved'], 'A 全流转(work 档无 verifying)')
228
+ // 依赖落定 → 下一轮 cycle 自动接续派 B
229
+ await env.clock.advance(50)
230
+ await env.waitFor(function () { return env.continuables.length >= 2 }, 'B 自动接续 spawn')
231
+ assert.equal(env.continuables[1].label, 'worker:task-cb', 'A resolved 后 B 被自动派发')
232
+ tb = await env.waitFor(function () { var x = env.task('task-cb'); return x && x.status === 'in-progress' && x.claimedBy === env.continuables[1].childId ? x : null }, 'B 落卡 in-progress')
233
+ // B 同样走事件通道完成
234
+ await settleViaEvents(env, env.continuables[1].childId, 'B')
235
+ tb = await env.waitFor(function () { var x = env.task('task-cb'); return x && x.status === 'resolved' && x.runs && x.runs[0] && x.runs[0].outcome === 'completed' ? x : null }, 'B 事件结算落 resolved 且 run 关账')
236
+ assert.deepEqual(transitions(tb), ['created→pending', 'pending→in-progress', 'in-progress→resolved'], 'B 全流转')
237
+ assert.equal(tb.runs[0].outcome, 'completed')
238
+ assert.equal(env.runs.length, 0, 'work 档无 verifier,不动一次性 start')
239
+ } finally { restoreHome(); await env.cleanup() }
240
+ })
241
+
242
+ // ===== 场景 d:touches 排他拦截 + waitingForTouches 标注 + 落定放行(事件通道)=====
243
+ // A/B 声明同一路径 touches:同轮 cycle A 先派(同优先级按创建先后),B 进 blockedTouches →
244
+ // waitingForTouches=['task-da'] 落卡展示;A 经事件通道落定 resolved(锁随状态释放)后 B 自动放行。
245
+ test('集成d·touches 排他:同路径 B 被挡+waitingForTouches 标注→A 落定→B 放行(事件通道)', async (t) => {
246
+ if (!zstdOk) { t.skip('zstdCompressSync unavailable'); return }
247
+ var env = createMockCtx()
248
+ var restoreHome = pinHomedir(env)
249
+ try {
250
+ plugin.apply(env.ctx)
251
+ // contextNotes 避调研门禁 warning(touches 非空的软提示,不阻断但保持输出干净)
252
+ await createTask(env, 'task-da', { pipeline: 'work', touches: ['src/shared.mjs'], contextNotes: '调研:shared.mjs 是公共模块' })
253
+ await createTask(env, 'task-db', { pipeline: 'work', touches: ['src/shared.mjs'], contextNotes: '调研:同上' })
254
+ // 同轮 cycle:A 被派并即刻成为持有者,B 冲突进 blockedTouches
255
+ await env.clock.advance(50)
256
+ await env.waitFor(function () { return env.continuables.length >= 1 }, 'A spawn 发生')
257
+ assert.equal(env.continuables[0].label, 'worker:task-da', '同优先级按创建先后派 A')
258
+ await env.waitFor(function () { var x = env.task('task-da'); return x && x.status === 'in-progress' ? x : null }, 'A 落卡 in-progress')
259
+ // 排他拦截断言:B pending + waitingForTouches 标注持有者 + 未派发
260
+ var tb = env.task('task-db')
261
+ assert.equal(tb.status, 'pending', 'touches 冲突 → B 拦截在 pending')
262
+ assert.equal(tb.claimedBy, null)
263
+ assert.deepEqual(tb.waitingForTouches, ['task-da'], 'waitingForTouches 标注持有者任务 id')
264
+ assert.equal(env.continuables.length, 1, 'B 未派发(同轮 holds 动态增长拦下)')
265
+ assert.deepEqual(transitions(tb), ['created→pending'], 'B 只有创建历史')
266
+ // A 落定(事件通道,work 档直落 resolved)→ touches 锁随状态流转释放
267
+ var childA = env.continuables[0].childId
268
+ await settleViaEvents(env, childA, 'A')
269
+ var ta = await env.waitFor(function () { var x = env.task('task-da'); return x && x.status === 'resolved' && x.runs && x.runs[0] && x.runs[0].outcome === 'completed' ? x : null }, 'A 事件结算落 resolved 且 run 关账')
270
+ assert.deepEqual(transitions(ta), ['created→pending', 'pending→in-progress', 'in-progress→resolved'], 'A 全流转')
271
+ // 落定放行:下一轮 cycle B 自动派发,waitingForTouches 展示态清除
272
+ await env.clock.advance(50)
273
+ await env.waitFor(function () { return env.continuables.length >= 2 }, 'B 放行 spawn')
274
+ assert.equal(env.continuables[1].label, 'worker:task-db', 'A 落定后 B 自动放行')
275
+ tb = await env.waitFor(function () { var x = env.task('task-db'); return x && x.status === 'in-progress' && x.claimedBy === env.continuables[1].childId ? x : null }, 'B 落卡 in-progress')
276
+ assert.ok(!tb.waitingForTouches, '放行后 waitingForTouches 展示态清除(不留 🔒 假象)')
277
+ // B 完成:同样走事件通道
278
+ await settleViaEvents(env, env.continuables[1].childId, 'B')
279
+ tb = await env.waitFor(function () { var x = env.task('task-db'); return x && x.status === 'resolved' && x.runs && x.runs[0] && x.runs[0].outcome === 'completed' ? x : null }, 'B 事件结算落 resolved 且 run 关账')
280
+ assert.deepEqual(transitions(tb), ['created→pending', 'pending→in-progress', 'in-progress→resolved'], 'B 全流转')
281
+ assert.equal(tb.runs[0].outcome, 'completed')
282
+ assert.equal(env.runs.length, 0, 'work 档无 verifier')
283
+ } finally { restoreHome(); await env.cleanup() }
284
+ })
285
+
286
+ // ===== 场景 e:仲裁 hold 冻结 → 虚拟时钟推进 40s 不派发 → unfreeze → 派发(时钟推进主线)=====
287
+ // 本卡核心用例:hold 裁决后冻结卡必须在「去抖轮 + 两轮 15s 心跳」的 poolCycle 里全程被
288
+ // pickDispatch 跳过(!t.frozen 闸);unfreeze 后 mutateLocked 默认 kickCycle(50ms 去抖)立即补派。
289
+ // 附带两个时钟真推进的硬证据:① 首轮 Worker 的失联 rec 被 poolCycle 幽灵回收关账 incomplete
290
+ // (卡面 pending ≠ in-progress → recIsLive=false);② 25s 歧义去抖到点但 escalation 已被裁决
291
+ // 清除 → 投递前重查跳过(过期回声不投)。解冻后派发走续跑冷复活(首轮 continuable + incomplete
292
+ // 有续跑资格)→ sendMessage 唤醒原子会话,裁决答案随 messages 原文注入续跑指令。
293
+ test('集成e·仲裁冻结:hold 冻结→推进 40s 全程不派发→unfreeze→解冻即派(冷复活续跑)', async () => {
294
+ var env = createMockCtx()
295
+ try {
296
+ plugin.apply(env.ctx)
297
+ await createTask(env, 'task-e1', { pipeline: 'work' })
298
+ await env.clock.advance(50)
299
+ await env.waitFor(function () { return env.continuables.length >= 1 }, 'worker spawn 发生')
300
+ var child = env.continuables[0]
301
+ await env.waitFor(function () { var x = env.task('task-e1'); return x && x.status === 'in-progress' && x.claimedBy === child.childId ? x : null }, '落卡 in-progress')
302
+ // Worker 上报歧义 → escalation 落卡(25s 歧义去抖通知同步挂起,去抖本体断言在场景 g)
303
+ var esc = await env.tools.get('board_report').execute({ taskId: 'task-e1', kind: 'escalate', question: '方案 A 与方案 B 如何取舍?' })
304
+ assert.equal(esc.ok, true)
305
+ assert.equal(esc.escalated, true)
306
+ // 主窗口裁决 action=hold:in-progress 回 pending + frozen 三字段落卡 + 裁决消息入 messages
307
+ //(hold 走 skipKick——冻结任务本就不该派发,省一次无意义 poolCycle)
308
+ var arb = await env.tools.get('task_arbitrate').execute({ taskId: 'task-e1', answer: '按方案 A 做', action: 'hold' })
309
+ assert.equal(arb.ok, true)
310
+ assert.equal(arb.action, 'hold')
311
+ assert.equal(arb.frozen, true)
312
+ var t = env.task('task-e1')
313
+ assert.equal(t.status, 'pending', 'hold 裁决把 in-progress 打回 pending')
314
+ assert.equal(t.frozen, true, 'frozen 落卡')
315
+ assert.ok(t.frozenAt && t.frozenBy, 'frozenAt/frozenBy 留痕')
316
+ assert.equal(t.claimedBy, null, '认领位清空待补上下文')
317
+ assert.ok(!t.escalation, '裁决后 escalation 已清')
318
+ var arbMsg = (t.messages || []).filter(function (m) { return m.kind === 'arbitration' })
319
+ assert.equal(arbMsg.length, 1, '裁决答案落一条 kind=arbitration 消息')
320
+ assert.equal(arbMsg[0].text, '按方案 A 做')
321
+ assert.equal(arbMsg[0].action, 'hold')
322
+ // ===== 虚拟时钟推进 40s(跨去抖轮 + 15s/30s 两轮心跳 + 25s 歧义去抖点):冻结卡全程不派发 =====
323
+ await env.clock.advance(40000)
324
+ // 硬证据①:时钟推进下 poolCycle 真实跑过——首轮 run 已被幽灵回收关账 incomplete
325
+ t = await env.waitFor(function () { var x = env.task('task-e1'); return x && x.runs && x.runs[0] && x.runs[0].outcome === 'incomplete' ? x : null }, 'poolCycle 幽灵回收关账首轮 run(时钟真推进的证明)')
326
+ assert.equal(t.status, 'pending', '40s 推进后冻结卡仍 pending')
327
+ assert.equal(t.frozen, true, '冻结贯穿多轮 poolCycle')
328
+ assert.equal(env.continuables.length, 1, '冻结窗口内零新 spawn(pickDispatch 跳过 frozen)')
329
+ assert.equal(env.sendMessages.length, 0, '冻结窗口内零续跑投递')
330
+ // 硬证据②:25s 歧义去抖到点,但 escalation 已被裁决清掉 → deliverEscalation 投递前重查跳过
331
+ assert.equal(env.sent.length, 0, '歧义通知过期不投(投递前重查看板)')
332
+ // ===== unfreeze 解冻 → 默认 kickCycle(50ms 去抖)→ 立即补派 =====
333
+ var unf = await env.tools.get('task_update').execute({ taskId: 'task-e1', unfreeze: true })
334
+ assert.equal(unf.ok, true)
335
+ assert.ok(!env.task('task-e1').frozen, '解冻后 frozen 清除')
336
+ await env.clock.advance(50)
337
+ // 首轮 run 结局 incomplete + continuable → 有续跑资格 → sendMessage 冷复活原子会话(不新建)
338
+ await env.waitFor(function () { return env.sendMessages.length >= 1 }, '解冻后派发发生(续跑冷复活)')
339
+ assert.equal(env.continuables.length, 1, '续跑不新建子会话')
340
+ assert.equal(env.sendMessages[0].childId, child.childId, '冷复活目标是首轮 Worker 子会话')
341
+ var resumeText = env.sendMessages[0].content[0].text
342
+ assert.ok(resumeText.indexOf('断点续跑') >= 0, '续跑指令落薄框架文案')
343
+ assert.ok(resumeText.indexOf('按方案 A 做') >= 0, '裁决答案随 messages 原文注入续跑指令')
344
+ t = await env.waitFor(function () { var x = env.task('task-e1'); return x && x.status === 'in-progress' && x.claimedBy === child.childId ? x : null }, '解冻后落卡 in-progress(认领位=原子会话)')
345
+ assert.equal(t.runs.length, 2, '首派 + 续跑各留一条 run')
346
+ assert.equal(t.runs[1].resume, true, '第二条是续跑记录')
347
+ assert.equal(t.runs[1].outcome, 'running')
348
+ assert.deepEqual(transitions(t), ['created→pending', 'pending→in-progress', 'in-progress→in-progress', 'in-progress→in-progress', 'in-progress→pending', 'pending→pending', 'pending→pending', 'pending→in-progress'], '冻结/解冻全流转序列(上报歧义+裁决+回pending+冻结+解冻+重派)')
349
+ } finally { await env.cleanup() }
350
+ })
351
+
352
+ // ===== 场景 f:回执 45s 聚合 + 投递前过滤(移植 _scratch/verify-flush-filter.mjs 的已验证场景)=====
353
+ // 两张 work 档卡同窗口完成:f1 在投递前被人归档(已知悉)→ 回执吞掉;f2 resolved 保留。
354
+ // 窗口未到点零投递(聚合闸);到点 flush 投递前重读看板:f1 的「已派发+完成」两条都被过滤
355
+ // (archived 丢弃 / 非 in-progress 离场),f2 的派发回执同样离场过滤——四条入队只投一条摘要。
356
+ test('集成f·回执聚合过滤:45s 窗口聚合为一条,已归档任务回执被吞,存活任务保留', async () => {
357
+ var env = createMockCtx()
358
+ try {
359
+ plugin.apply(env.ctx)
360
+ await createTask(env, 'task-f1', { pipeline: 'work' })
361
+ await createTask(env, 'task-f2', { pipeline: 'work' })
362
+ await env.clock.advance(50)
363
+ await env.waitFor(function () { return env.continuables.length >= 2 }, '两卡同轮派发')
364
+ // 派发即回执 ×2 已入 45s 聚合队列——窗口未到点,主窗口零打扰
365
+ assert.equal(env.sent.length, 0, '聚合窗口未到点不投递')
366
+ // 两张卡先后 board_report 完成(work 档直落 resolved,完成回执入同一聚合队列)
367
+ var rep1 = await env.tools.get('board_report').execute({ taskId: 'task-f1', kind: 'complete', summary: 'f1 交付', changes: '改了 f1', selfTest: 'npm test 全绿', diffStat: '' })
368
+ assert.equal(rep1.ok, true)
369
+ assert.equal(rep1.task.status, 'resolved')
370
+ var rep2 = await env.tools.get('board_report').execute({ taskId: 'task-f2', kind: 'complete', summary: 'f2 交付', changes: '改了 f2', selfTest: 'npm test 全绿', diffStat: '' })
371
+ assert.equal(rep2.ok, true)
372
+ assert.equal(env.sent.length, 0, '窗口到点前完成回执同样压着不投')
373
+ // 投递前人去归档了 f1(已知悉)→ 它的回执该被吞
374
+ var arc = await env.rpc('archive-task', { sessionId: env.sid, taskId: 'task-f1' })
375
+ assert.equal(arc.ok, true, 'resolved 可归档')
376
+ assert.equal(env.task('task-f1').status, 'archived')
377
+ // ===== 45s 聚合窗口到点 → flushReceipts 投递前重读看板过滤 =====
378
+ await env.clock.advance(45000)
379
+ await env.waitFor(function () { return env.sent.length >= 1 }, '聚合窗口到点投递')
380
+ assert.equal(env.sent.length, 1, '四条回执(派发×2+完成×2)聚合为一条摘要')
381
+ var text = env.sent[0].content[0].text
382
+ assert.equal(env.sent[0].source.form, 'recall', '回执是 recall 形态(背景回执,非指令)')
383
+ assert.ok(text.indexOf('回执摘要(1 条)') >= 0, '计数用过滤后存活条数')
384
+ assert.ok(text.indexOf('(task-f2)') >= 0, 'f2 完成回执保留')
385
+ assert.ok(text.indexOf('(task-f1)') < 0, '已归档的 f1 回执被吞')
386
+ assert.ok(text.indexOf('已派发') < 0, 'f1 归档 / f2 resolved 都非 in-progress → 派发回执全部离场过滤')
387
+ assert.ok(text.indexOf('f2 交付') >= 0, '保留项带 summary')
388
+ assert.equal(env.task('task-f2').status, 'resolved')
389
+ } finally { await env.cleanup() }
390
+ })
391
+
392
+ // ===== 场景 g:歧义通知 25s 去抖——连报两次只投最新一条 =====
393
+ // 同一任务 25s 窗口内两次上报歧义:第一次调度被第二次顶替(escNotifyTimers 身份不匹配静默丢弃),
394
+ // 到点只投一条且内容是最新疑问(deliverEscalation 投递时才读 escalation.question)。
395
+ test('集成g·歧义去抖:25s 窗口内连报两次,只投最新一条', async () => {
396
+ var env = createMockCtx()
397
+ try {
398
+ plugin.apply(env.ctx)
399
+ await createTask(env, 'task-g1', { pipeline: 'work' })
400
+ await env.clock.advance(50)
401
+ await env.waitFor(function () { return env.continuables.length >= 1 }, 'worker spawn 发生')
402
+ await env.waitFor(function () { var x = env.task('task-g1'); return x && x.status === 'in-progress' ? x : null }, '落卡 in-progress')
403
+ // 第一次上报(去抖调度 T1 挂起)
404
+ var esc1 = await env.tools.get('board_report').execute({ taskId: 'task-g1', kind: 'escalate', question: '第一问:旧疑问(应被顶替)' })
405
+ assert.equal(esc1.ok, true)
406
+ // 同一虚拟时刻第二次上报(T1 被 T2 顶替;escalation.question 覆盖为最新)
407
+ var esc2 = await env.tools.get('board_report').execute({ taskId: 'task-g1', kind: 'escalate', question: '第二问:最新疑问(应投递)' })
408
+ assert.equal(esc2.ok, true)
409
+ assert.equal(env.sent.length, 0, '去抖窗口未到点零投递')
410
+ // 推进 25s:T1 到点身份不匹配丢弃;T2 到点投递最新疑问
411
+ await env.clock.advance(25000)
412
+ await env.waitFor(function () { return env.sent.length >= 1 }, '去抖到点投递')
413
+ assert.equal(env.sent.length, 1, '连报两次只投一条(旧调度被顶替丢弃)')
414
+ var msg = env.sent[0]
415
+ var text = msg.content[0].text
416
+ assert.ok(text.indexOf('Worker 上报歧义') >= 0, '歧义裁决通知投递')
417
+ assert.ok(text.indexOf('第二问:最新疑问') >= 0, '投递的是最新疑问')
418
+ assert.ok(text.indexOf('第一问') < 0, '旧疑问不出现')
419
+ assert.equal(msg.source.form, 'notice', '歧义通知是 notice 形态(带一行 summary)')
420
+ // 通知路径不碰卡面状态:仍 in-progress + escalation 待裁决
421
+ var t = env.task('task-g1')
422
+ assert.equal(t.status, 'in-progress')
423
+ assert.ok(t.escalation, 'escalation 仍在等裁决')
424
+ assert.equal(t.escalation.question, '第二问:最新疑问(应投递)', '卡面留的是最新疑问')
425
+ } finally { await env.cleanup() }
426
+ })
427
+
428
+ // ===== 场景 h:progress 上报落 lastProgress(覆盖式,静默不通知)=====
429
+ // 里程碑通道定位:长任务「还在正确路上」的轻量证明——覆盖式落 lastProgress、messages 留审计轨,
430
+ // 不写 ah 历史(防刷屏)、不进回执聚合、不通知主窗口、不触发 run 关账。
431
+ test('集成h·progress 上报:lastProgress 覆盖式落卡,不进历史/不通知/不结算', async () => {
432
+ var env = createMockCtx()
433
+ try {
434
+ plugin.apply(env.ctx)
435
+ await createTask(env, 'task-h1', { pipeline: 'work' })
436
+ await env.clock.advance(50)
437
+ await env.waitFor(function () { return env.continuables.length >= 1 }, 'worker spawn 发生')
438
+ var t = await env.waitFor(function () { var x = env.task('task-h1'); return x && x.status === 'in-progress' ? x : null }, '落卡 in-progress')
439
+ // 第一条里程碑进展
440
+ var p1 = await env.tools.get('board_report').execute({ taskId: 'task-h1', kind: 'progress', question: '里程碑一:骨架已落地' })
441
+ assert.equal(p1.ok, true)
442
+ assert.equal(p1.progress.text, '里程碑一:骨架已落地')
443
+ assert.ok(p1.progress.at)
444
+ // 第二条覆盖第一条
445
+ var p2 = await env.tools.get('board_report').execute({ taskId: 'task-h1', kind: 'progress', question: '里程碑二:断言全绿' })
446
+ assert.equal(p2.ok, true)
447
+ t = env.task('task-h1')
448
+ assert.equal(t.lastProgress.text, '里程碑二:断言全绿', 'lastProgress 覆盖式只留最新')
449
+ assert.ok(t.lastProgress.at)
450
+ var pmsgs = (t.messages || []).filter(function (m) { return m.kind === 'progress' })
451
+ assert.equal(pmsgs.length, 2, '两条进展都落 messages 审计轨')
452
+ assert.equal(pmsgs[1].text, '里程碑二:断言全绿')
453
+ assert.equal(t.status, 'in-progress', 'progress 不推进状态')
454
+ assert.deepEqual(transitions(t), ['created→pending', 'pending→in-progress'], 'progress 不写 ah 历史(防刷屏)')
455
+ assert.equal(t.runs[0].outcome, 'running', 'progress 不触发 run 关账')
456
+ assert.equal(env.sent.length, 0, 'progress 静默——不通知主窗口、不进回执聚合')
457
+ // 空白摘要拒绝
458
+ var p3 = await env.tools.get('board_report').execute({ taskId: 'task-h1', kind: 'progress', question: ' ' })
459
+ assert.equal(p3.ok, false, '空白进展摘要被拒')
460
+ // 去抖轮过后状态依旧(progress 写盘带的 kickCycle 不扰池)
461
+ await env.clock.advance(50)
462
+ t = env.task('task-h1')
463
+ assert.equal(t.status, 'in-progress')
464
+ assert.equal(t.lastProgress.text, '里程碑二:断言全绿')
465
+ assert.equal(env.continuables.length, 1, 'progress 全程不惹派发')
466
+ } finally { await env.cleanup() }
467
+ })
468
+
469
+ // ===== 场景 i:孤儿回收——isOrphan 路径经 poolCycle(推进时钟等孤儿扫描窗口)=====
470
+ // patchBoard 构造「in-progress + claimedBy=已死子会话 + 无活跃 rec + claimedAt 超 2min」的孤儿卡。
471
+ // 两个构造细节:① isOrphan 的 2min 门槛锚真实墙钟(poolCycle 里 now=Date.now()),claimedAt 按真实
472
+ // 时间倒推 3 分钟;② runs 留空——让首轮 reconcile 不掺和(它只认「末条 worker run continuable 且
473
+ // outcome=running」的卡),回收必须走 isOrphan 路径。assignMode=manual 钉住同轮重派:pickDispatch
474
+ // 跳过本卡,断言稳定在「回 pending」本身。
475
+ test('集成i·孤儿回收:in-progress 无活跃 rec 的卡推进时钟后回 pending', async () => {
476
+ var env = createMockCtx()
477
+ try {
478
+ plugin.apply(env.ctx)
479
+ await createTask(env, 'task-i1', { pipeline: 'work' })
480
+ // 构造孤儿卡:执行 run 已死(无活跃 rec、无 runs 留档)、认领于 3 分钟前(真实墙钟倒推)
481
+ env.patchBoard(function (d) {
482
+ var t = d.tasks.find(function (x) { return x.id === 'task-i1' })
483
+ t.status = 'in-progress'
484
+ t.claimedBy = 'child-ghost-9'
485
+ t.claimedAt = new Date(Date.now() - 180000).toISOString()
486
+ t.assignMode = 'manual' // 防回收后同轮自动重派——本场景断言的是「回收回 pending」本身
487
+ })
488
+ var t = env.task('task-i1')
489
+ assert.equal(t.status, 'in-progress', '构造生效:孤儿卡停在 in-progress')
490
+ // 推进时钟过孤儿扫描窗口:建卡 kickCycle 的 50ms 去抖轮即扫到;再跨一轮 15s 心跳兜底
491
+ await env.clock.advance(15000)
492
+ t = await env.waitFor(function () { var x = env.task('task-i1'); return x && x.status === 'pending' ? x : null }, '孤儿回收回 pending')
493
+ assert.equal(t.claimedBy, null, '认领位清空')
494
+ assert.equal(t.claimedAt, null, 'claimedAt 清空')
495
+ var trs = transitions(t)
496
+ assert.equal(trs[trs.length - 1], 'in-progress→pending', '回收流转方向')
497
+ var lastHist = t.history[t.history.length - 1]
498
+ assert.equal(lastHist.actor, 'system')
499
+ assert.equal(lastHist.note, '执行 run 已结束/丢失,回收重新排队', 'isOrphan 回收的历史注记(区别于 reconcile 的「重启后执行会话已丢失」)')
500
+ // 回收轮 dispatchInfo 留痕 + manual 钉住无重派
501
+ assert.ok((env.board().dispatchInfo || '').indexOf('reclaim task-i1') >= 0, 'dispatchInfo 留 reclaim 痕迹')
502
+ assert.equal(env.continuables.length, 0, 'manual 钉住:回收后同轮不重派')
503
+ assert.equal(env.sendMessages.length, 0)
504
+ assert.equal(env.sent.length, 0, '孤儿回收的系统通知攒在 sysNotesBuf 等回执冲刷,不单独投递')
505
+ } finally { await env.cleanup() }
506
+ })
507
+
508
+ // ===== 场景 j:归档数据源全量——老归档(>7 天)与仪表盘同口径,get-tasks 全量返回 =====
509
+ // 归档 tab 空 vs 仪表盘 68 的根因锁定(反馈 n-muyg3e0m9z7i):归档 tab 数据源必须与仪表盘「已归档」
510
+ // 计数同源(state.tasks 全量,无 7 日窗口、无字段缺失)。host 侧 get-tasks 本就返回全量含归档,
511
+ // 本用例锁死这条数据源契约:建卡→resolve→archive(含 archivedAt>7 天前构造)→断言归档数据源含该卡。
512
+ test('集成j·归档数据源全量:老归档(>7天)与仪表盘同口径,get-tasks 返回全部归档', async () => {
513
+ var env = createMockCtx()
514
+ try {
515
+ plugin.apply(env.ctx)
516
+ // 新归档 + 老归档各一张:先建卡再 resolve 再 archive(省去派发链路,直接走到可归档态)
517
+ await createTask(env, 'task-j1', { pipeline: 'work' })
518
+ await createTask(env, 'task-j2', { pipeline: 'work' })
519
+ env.patchBoard(function (d) {
520
+ d.tasks.forEach(function (t) { if (t.id === 'task-j1' || t.id === 'task-j2') { t.status = 'resolved'; t.resolvedAt = new Date(Date.now() - 86400000).toISOString() } })
521
+ })
522
+ var a1 = await env.rpc('archive-task', { sessionId: env.sid, taskId: 'task-j1' })
523
+ var a2 = await env.rpc('archive-task', { sessionId: env.sid, taskId: 'task-j2' })
524
+ assert.equal(a1.ok, true, 'task-j1 可归档')
525
+ assert.equal(a2.ok, true, 'task-j2 可归档')
526
+ // 构造老归档:task-j1 归档于 20 天前(>7 天),task-j2 归档于现在
527
+ env.patchBoard(function (d) {
528
+ var j1 = d.tasks.find(function (x) { return x.id === 'task-j1' })
529
+ j1.archivedAt = new Date(Date.now() - 20 * 86400000).toISOString()
530
+ })
531
+ // 归档数据源(get-tasks 全量):两张归档都在,老归档(>7 天)不被窗口滤掉
532
+ var d = await env.rpc('get-tasks', { sessionId: env.sid, includeArchived: true })
533
+ var arch = d.tasks.filter(function (t) { return t.status === 'archived' })
534
+ assert.equal(arch.length, 2, '归档数据源含全部归档(全量,无 7 日窗口)')
535
+ assert.ok(arch.some(function (t) { return t.id === 'task-j1' && new Date(Date.now()) - new Date(t.archivedAt) > 7 * 86400000 }), '老归档(>7 天)仍在归档数据源')
536
+ assert.ok(arch.some(function (t) { return t.id === 'task-j2' }), '新归档也在归档数据源')
537
+ // 归档字段完整:archivedAt 已落卡(客户端按归档时间倒序的数据源字段不缺)
538
+ assert.ok(arch.every(function (t) { return !!t.archivedAt }), '每张归档卡都带 archivedAt')
539
+ // 与仪表盘口径一致:仪表盘「已归档」= state.tasks 里 status==='archived' 的计数,二者同源同值
540
+ var d2 = await env.rpc('get-tasks', { sessionId: env.sid })
541
+ assert.equal(d2.tasks.filter(function (t) { return t.status === 'archived' }).length, 2, '无 includeArchived 时同样全量(与仪表盘计数同源)')
542
+ } finally { await env.cleanup() }
543
+ })