dsh-agent-board 1.9.0 → 1.9.2
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 +13 -8
- package/index.mjs +1 -0
- package/lib/client/board-list.js +1 -1
- package/lib/client/dashboard.js +52 -7
- package/lib/client/task-detail.js +2 -2
- package/lib/client.js +55 -10
- package/lib/core.mjs +48 -12
- package/lib/dispatch.mjs +135 -1142
- package/lib/hung.mjs +202 -0
- package/lib/model-health.mjs +553 -0
- package/lib/notify.mjs +37 -4
- package/lib/policy.mjs +19 -9
- package/lib/rpc.mjs +7 -3
- package/lib/settle.mjs +954 -0
- package/package.json +1 -1
- package/test/core.test.mjs +339 -77
- package/test/decompose.test.mjs +70 -16
- package/test/fault-e2e-circuit.test.mjs +187 -0
- package/test/fault-e2e-fallback-chain.test.mjs +249 -0
- package/test/fault-e2e-hung.test.mjs +504 -0
- package/test/fault-e2e-recovery.test.mjs +255 -0
- package/test/fault-e2e-softgate.test.mjs +206 -0
- package/test/fault-e2e-stale-dir.test.mjs +226 -0
- package/test/fault-injection-docs.test.mjs +132 -0
- package/test/fault-provider.test.mjs +458 -0
- package/test/helpers/fault-provider.mjs +475 -0
- package/test/helpers/mock-ctx.mjs +9 -0
- package/test/hung-frame-signal.test.mjs +630 -0
- package/test/integration.test.mjs +41 -0
- package/test/lane-gui-bysize.test.mjs +410 -0
- package/test/lane-models.test.mjs +134 -0
- package/test/popover-clamp.test.mjs +92 -0
- package/test/runtime-health.test.mjs +2 -1
- package/test/scorecard-data.test.mjs +2 -1
- package/test/settle-stop-interrupt.test.mjs +294 -3
- package/test/ui-zoom-client.test.mjs +9 -4
|
@@ -0,0 +1,255 @@
|
|
|
1
|
+
// ===== 故障 E2E:恢复旅程收口——秒拆 ×2 → 连败软闸跳 good → continuable 交付 → verifying → verifier 一次性 approved → resolved(健康模型收口,task-mvqi3uj4-7)=====
|
|
2
|
+
// 前序:task-mvqi3uj4-2 秒拆三连熔断(fault-e2e-circuit,一次性面 workerContinuable=false 恒 fresh spawn,
|
|
3
|
+
// 终局 blocked)。本卡补「健康模型上的完整旅程」:同一套基建故障层(helpers/fault-provider.mjs),
|
|
4
|
+
// 走 continuable 缺省路径全循环——卡最终在健康模型上交付、验收、resolved,把「故障注入→真派发→看板
|
|
5
|
+
// 行为」串成一条永久回归。本文件是「每起生产事故落端到端场景」的模板范式:后续新事故类照本文件
|
|
6
|
+
// 结构加文件即可。
|
|
7
|
+
//
|
|
8
|
+
// 机制锚点:
|
|
9
|
+
// · worker continuable 缺省开(dispatch.mjs L800 useContinuable = role==='worker' && workerContinuable!==false)
|
|
10
|
+
// → Worker 恒走 continuable 面(v0.2.1 宿主契约:startActivation delivery='parent',结算走 agent/status 事件);
|
|
11
|
+
// · verifier 恒一次性(L774 useContinuable 只对 worker 开)→ delivery='caller',run.result 结算;
|
|
12
|
+
// · 秒拆故障在 continuable 面走 activation.result 拒绝臂(dispatch.mjs activation 拆除臂)→ settleWorker
|
|
13
|
+
// 失败臂(isModelKillFailure 经「子会话 activation 异常:」前缀命中)→ 重排 pending + 熔断连击+1
|
|
14
|
+
// (2 连 < 3 不拉黑,软闸接管);
|
|
15
|
+
// · 连败软闸(task-mvd3li6):healthyModel 四闸之 recentRuns ≥2 全败(settleRunRecord 每次结算喂给
|
|
16
|
+
// observeModel)→ 软熔断不落 badModels 黑名单,仅取模/续跑跳过——本旅程 run3 靠它跳过 flaky 取次选 good;
|
|
17
|
+
// · board_report/board_verdict 工具通道 + settleRunRecord 补停(settle-stop-interrupt.test.mjs ①事故原形
|
|
18
|
+
// 路径):completed 落定无续跑位 → 结算收尾补停 interrupt;
|
|
19
|
+
// · history 流转断言 transitions()(integration.test.mjs L80 同款)。
|
|
20
|
+
//
|
|
21
|
+
// 旅程(真派发循环:rpc create-task → clock.advance(50) 踢 poolCycle → waitFor 收敛):
|
|
22
|
+
// laneModels.standard.worker=['prov/flaky','prov/good'](llm 目录接缝:set-board-config 槽位校验与
|
|
23
|
+
// dispatch modelDirectory 同源,两模型必须先在册);flaky=instant-kill 次数窗口=前 2 次(基建卡能力);
|
|
24
|
+
// 建卡(pipeline=full + acceptance 任意字符串 + size=standard——档位链命中前提,L640 if (sz && laneCfg[sz]))
|
|
25
|
+
// → run1 flaky 秒拆 → run2 flaky 秒拆 → run3 软闸跳 good → continuable 交付(writeChildLog 写分段交付文本
|
|
26
|
+
// + emitStatus 'running'→'idle' 事件通道结算,integration c/d 先例)→ verifying → verifier 一次性 spawn
|
|
27
|
+
// (无故障,run.result 落定 APPROVE_TEXT——fault 层 healthyText=该文本,与 mock resolveWith 同口径)
|
|
28
|
+
// → resolved。
|
|
29
|
+
//
|
|
30
|
+
// 断言(五条,对应任务口径):
|
|
31
|
+
// ① history 全序列 created→pending→in-progress→pending→in-progress→pending→in-progress→verifying→resolved
|
|
32
|
+
// 逐段在案(两次秒拆重排 + 交付 + 验收,无缺段无多余段);
|
|
33
|
+
// ② spawn 模型序列 [flaky,flaky,good] + verifier spawn 各在其位(fault 层 spawnLog 观测点 + 卡 runs 留档);
|
|
34
|
+
// ③ 终态 resolved 且 verifier 留档 outcome=completed(run 关账 + endedAt);
|
|
35
|
+
// ④ 活跃面零残留(幽灵 rec 零遗留:推进 2 轮 poolCycle 后 poolStatus 零行 + 卡面 runs 零 running);
|
|
36
|
+
// ⑤ 交付物 deliverable.summary 非空(settleContinuable 文本兜底真读子会话日志——这正是 mock 编不出的接缝)。
|
|
37
|
+
//
|
|
38
|
+
// 续跑劫持接缝(fault-e2e-circuit「为什么一次性回退开关」同款论证):秒拆后卡面留档经幽灵回收关账
|
|
39
|
+
// incomplete+continuable → 重派被续跑闸劫持(tryResumeWorker sendMessage 冷复活已死会话)。真宿主对
|
|
40
|
+
// 被拆除 activation 的冷复活按 NOT_RESUMABLE reject(dispatch.mjs tryResumeWorker「不可复活时 reject →
|
|
41
|
+
// 这里转成 fallback」);mock sendMessage 是纯记录器(永不拒)——测试显式覆写为 reject 模拟真宿主语义:
|
|
42
|
+
// 续跑 fallback(resume-fallback 留痕)→ fresh spawn。两次秒拆由此都走 fresh spawn(次数窗口前 2 次
|
|
43
|
+
// 逐次消耗);第二次重派再被续跑健康闸(recentRuns ≥2 全败,task-mvd3li6 软闸同款判定)拦下改
|
|
44
|
+
// fresh spawn,档位链软闸跳 flaky 取 good——两级「绕行」都在旅程里。
|
|
45
|
+
//
|
|
46
|
+
// autoIdle:false 的取舍:健康 continuable activation 缺省会自动写 healthyText 日志并重放 idle
|
|
47
|
+
//(fault-provider scheduleIdle)——关掉它让交付由测试显式驱动(writeChildLog + emitStatus),
|
|
48
|
+
// 断言⑤才有「真读日志」的接缝价值;healthyText 仍被 healthy activation 写一次子会话日志,
|
|
49
|
+
// 测试的 writeChildLog 同路径覆盖,settleContinuable 读到的必是测试写的交付文本。
|
|
50
|
+
import { test } from 'node:test'
|
|
51
|
+
import assert from 'node:assert/strict'
|
|
52
|
+
import fs from 'node:fs'
|
|
53
|
+
import path from 'node:path'
|
|
54
|
+
import zlib from 'node:zlib'
|
|
55
|
+
import { createMockCtx } from './helpers/mock-ctx.mjs'
|
|
56
|
+
import { installFaults } from './helpers/fault-provider.mjs'
|
|
57
|
+
import * as plugin from '../index.mjs'
|
|
58
|
+
|
|
59
|
+
var zstdOk = typeof zlib.zstdCompressSync === 'function'
|
|
60
|
+
|
|
61
|
+
var FLAKY = 'prov/flaky'
|
|
62
|
+
var GOOD = 'prov/good'
|
|
63
|
+
// 秒拆诊断文本:刻意避开冷却嗅探关键词(连接/超时/网关/socket/50x 等,dispatch.mjs CONNECTIVITY_RE)——
|
|
64
|
+
// 否则病模型被误登记冷却,软闸在第二拆前就被冷却闸截断(熔断/冷却/软闸三张表各管各的)。
|
|
65
|
+
var KILL_DIAG = '宿主秒拆注入(e2e 恢复旅程)'
|
|
66
|
+
// Verifier 结论文本:行首锚定 APPROVED(parseVerdict 口径),分段供 parseSections 提取
|
|
67
|
+
//(integration.test.mjs L76 同款口径:verifySummary 认「验证概要」,checks 认「核对项」)
|
|
68
|
+
var APPROVE_TEXT = 'APPROVED\n\n## 验证概要\n验收脚本独立复跑通过\n\n## 核对项\n- npm test 全绿'
|
|
69
|
+
|
|
70
|
+
// ===== 测试工具(integration.test.mjs 同形)=====
|
|
71
|
+
// 一帧 v4 日志:多帧 zstd 顺序拼接,帧内 jsonl(readLogFrames 同形)
|
|
72
|
+
function frameOf(events) { return zlib.zstdCompressSync(Buffer.from(events.map(function (e) { return JSON.stringify(e) }).join('\n') + '\n', 'utf8')) }
|
|
73
|
+
// 写 continuable 子会话日志(settleContinuable 文本兜底数据源):<home>/.dsh/sessions/<桶>/<childId>/session.v4.jsonl.zstd
|
|
74
|
+
function writeChildLog(env, childId, text) {
|
|
75
|
+
var dir = path.join(env.home, '.dsh', 'sessions', 'test-bucket', childId)
|
|
76
|
+
fs.mkdirSync(dir, { recursive: true })
|
|
77
|
+
var ev = { type: 'assistant/message', time: Date.now(), seq: 1, data: { message: { content: [{ type: 'text', text: text }] } } }
|
|
78
|
+
fs.writeFileSync(path.join(dir, 'session.v4.jsonl.zstd'), frameOf([ev]))
|
|
79
|
+
}
|
|
80
|
+
// os.homedir() 钉到临时 HOME(Windows 认 USERPROFILE 不认 HOME):事件结算的 findRunLog 回退路径
|
|
81
|
+
//(usage.mjs L29 os.homedir()/.dsh/sessions)才命中本用例临时目录
|
|
82
|
+
function pinHomedir(env) {
|
|
83
|
+
var had = Object.prototype.hasOwnProperty.call(process.env, 'USERPROFILE')
|
|
84
|
+
var prev = process.env.USERPROFILE
|
|
85
|
+
process.env.USERPROFILE = env.home
|
|
86
|
+
return function () { if (had) process.env.USERPROFILE = prev; else delete process.env.USERPROFILE }
|
|
87
|
+
}
|
|
88
|
+
// 建卡封装:显式 description 避开空描述软提示
|
|
89
|
+
async function createTask(env, id, extra) {
|
|
90
|
+
var args = { sessionId: env.sid, id: id, title: '恢复旅程 ' + id, description: '故障E2E恢复用例 ' + id }
|
|
91
|
+
if (extra) { for (var k in extra) args[k] = extra[k] }
|
|
92
|
+
var r = await env.rpc('create-task', args)
|
|
93
|
+
assert.equal(r.ok, true, 'create-task 成功: ' + id)
|
|
94
|
+
return r.task
|
|
95
|
+
}
|
|
96
|
+
// history 流转序列(integration.test.mjs L80 同款)
|
|
97
|
+
function transitions(t) { return (t.history || []).map(function (h) { return h.from + '→' + h.to }) }
|
|
98
|
+
// 补停记录(settle-stop-interrupt 同形)
|
|
99
|
+
function stopsOn(env, childId) { return env.interrupts.filter(function (x) { return x.childId === childId }) }
|
|
100
|
+
// Worker 交付文本(事件通道文本兜底用):分段格式,避开 [ESCALATE] 标记
|
|
101
|
+
function workerText(tag) {
|
|
102
|
+
return '## 开发描述\n完成 ' + tag + ' 的实现\n\n## 改动清单\n- src/' + tag + '.mjs:新增实现\n\n## 自测情况\nnpm test 全绿\n\n## diff 概要\n 1 file changed, 10 insertions(+)'
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
// ===== 主场景:秒拆×2 → 软闸跳 good → 事件通道交付 → verifier 一次性 approved → resolved(健康模型收口)=====
|
|
106
|
+
test('故障E2E·恢复旅程:秒拆×2→连败软闸跳 good→事件通道交付 verifying→verifier 一次性 approved→resolved(健康模型收口)', async (t) => {
|
|
107
|
+
if (!zstdOk) { t.skip('zstdCompressSync unavailable'); return }
|
|
108
|
+
var env = createMockCtx()
|
|
109
|
+
var restoreHome = pinHomedir(env)
|
|
110
|
+
try {
|
|
111
|
+
// 基建卡故障层(helpers/fault-provider.mjs):activation 契约(spawn 翻到 startActivation,v0.2.1
|
|
112
|
+
// 宿主路径)+ llm 目录(目录闸接缝)+ instant-kill 次数窗口=前 2 次;autoIdle:false = 交付由测试
|
|
113
|
+
// 显式驱动(见头注释)。诊断文本避开冷却关键词(见 KILL_DIAG 注)。
|
|
114
|
+
var h = installFaults(env, {
|
|
115
|
+
activation: true,
|
|
116
|
+
autoIdle: false,
|
|
117
|
+
directory: [FLAKY, GOOD],
|
|
118
|
+
healthyText: APPROVE_TEXT,
|
|
119
|
+
programs: [{ type: 'instant-kill', times: 2, diagnostic: KILL_DIAG, match: { role: 'worker' } }],
|
|
120
|
+
})
|
|
121
|
+
plugin.apply(env.ctx)
|
|
122
|
+
// 续跑劫持接缝:秒拆后留档 incomplete+continuable → 重派被续跑闸劫持(sendMessage 冷复活已死
|
|
123
|
+
// 会话)。真宿主对被拆除 activation 的冷复活按 NOT_RESUMABLE reject(tryResumeWorker「不可复活时
|
|
124
|
+
// reject → 转成 fallback」);mock sendMessage 是纯记录器永不拒——显式覆写为 reject 模拟真宿主,
|
|
125
|
+
// 续跑 fallback → fresh spawn,[flaky,flaky,good] 三次 fresh spawn 才成立。
|
|
126
|
+
env.ctx.subagents.sendMessage = async function () {
|
|
127
|
+
throw new Error('NOT_RESUMABLE: 子会话已被宿主拆除(秒拆注入),不可冷复活')
|
|
128
|
+
}
|
|
129
|
+
// 目录闸接缝:两模型先在册 → laneModels 槽位校验放行(rpc enumModels 与 dispatch modelDirectory 同源)
|
|
130
|
+
var lm = await env.rpc('set-board-config', { sessionId: env.sid, key: 'laneModels', value: { standard: { worker: [FLAKY, GOOD] } } })
|
|
131
|
+
assert.equal(lm.ok, true, '故障层 llm 目录在册 → set-board-config laneModels 槽位放行')
|
|
132
|
+
// 建卡:pipeline=full + acceptance(任意字符串,验收由 mock verifier 文本通道)+ size=standard
|
|
133
|
+
//(档位链命中前提:dispatch.mjs L640 if (sz && laneCfg[sz])——缺 size 不查档位表)
|
|
134
|
+
await createTask(env, 'task-rec', { pipeline: 'full', acceptance: 'node --test test/fault-e2e-recovery.test.mjs', size: 'standard' })
|
|
135
|
+
|
|
136
|
+
// ===== run1:flaky 秒拆(activation.result 秒拒 → activation 异常兜底臂 → settleWorker 失败臂重排)=====
|
|
137
|
+
// waitFor 一律等「结算链尾」:spawn 留痕在先、失败重排在后——与 fault-e2e-circuit 同款纪律。
|
|
138
|
+
await env.clock.advance(50)
|
|
139
|
+
var t1 = await env.waitFor(function () {
|
|
140
|
+
var x = env.task('task-rec')
|
|
141
|
+
return x && x.status === 'pending' && x.retryCount === 1 && x.runs && x.runs.length === 1 && x.runs[0].model === FLAKY && h.spawnLog.length >= 1 && h.spawnLog[0].model === FLAKY ? x : null
|
|
142
|
+
}, 'run1 flaky 秒拆:重排 pending 且 spawn 于 prov/flaky')
|
|
143
|
+
assert.equal(h.spawnLog[0].method, 'startActivation', 'continuable 面走 activation 契约(worker continuable 缺省开,L800)')
|
|
144
|
+
assert.equal(h.spawnLog[0].delivery, 'parent', 'continuable 面 delivery=parent(结算走事件通道)')
|
|
145
|
+
assert.equal(h.spawnLog[0].fault, 'instant-kill', '故障程序命中(次数窗口 1/2)')
|
|
146
|
+
assert.ok(String(t1.lastError).indexOf('被宿主拆除') >= 0, '失败原因落卡(lastError,排查不靠猜)')
|
|
147
|
+
assert.equal(t1.runs[0].modelSource, 'lane', 'modelSource=lane(档位链命中)')
|
|
148
|
+
assert.equal(env.runs.length, 0, 'Worker 走 continuable/activation 面,零一次性 start(L774 对偶:start 只留给 verifier)')
|
|
149
|
+
|
|
150
|
+
// ===== run2:NOT_RESUMABLE fallback → fresh spawn flaky 秒拆 ×2 =====
|
|
151
|
+
//(run1 留档经幽灵回收关账 incomplete+continuable → 重派被续跑闸劫持 → sendMessage reject →
|
|
152
|
+
// resume-fallback 留痕 → fresh spawn;recentRuns 1 败 < 2 未达软闸线 → 档位链首位 flaky 仍被选中)
|
|
153
|
+
await env.clock.advance(50)
|
|
154
|
+
var t2 = await env.waitFor(function () {
|
|
155
|
+
var x = env.task('task-rec')
|
|
156
|
+
return x && x.status === 'pending' && x.retryCount === 2 && x.runs && x.runs[0] && x.runs[0].outcome === 'incomplete' && x.runs[1] && x.runs[1].model === FLAKY && x.messages && x.messages.some(function (m) { return m.kind === 'resume-fallback' }) && h.spawnLog.length >= 2 && h.spawnLog[1].model === FLAKY ? x : null
|
|
157
|
+
}, 'run2 flaky 秒拆 ×2:续跑 fallback(NOT_RESUMABLE)→ fresh spawn 仍取 flaky(连败 1 次未达软闸线)')
|
|
158
|
+
assert.ok(t2.runs[0].endedAt, 'run1 留档关账有 endedAt(reapGhostRecs → settleRunRecord 只补收尾)')
|
|
159
|
+
var fb1 = t2.messages.filter(function (m) { return m.kind === 'resume-fallback' })
|
|
160
|
+
assert.equal(fb1.length, 1, '续跑 fallback 留痕恰一条(NOT_RESUMABLE → 已回退全新 Worker 重跑)')
|
|
161
|
+
assert.ok(fb1[0].text.indexOf('断点续跑不可用') === 0, 'fallback 留痕文本口径(先写说明再 spawn)')
|
|
162
|
+
assert.equal(t2.runs[1].modelSource, 'lane', 'run2 仍取档位链首位(recentRuns 1 败 < 2 未达软闸线)')
|
|
163
|
+
|
|
164
|
+
// ===== run3:续跑健康闸(recentRuns ≥2 全败)拦下重派 → fresh spawn 档位链软闸跳 good =====
|
|
165
|
+
await env.clock.advance(50)
|
|
166
|
+
var t3 = await env.waitFor(function () {
|
|
167
|
+
var x = env.task('task-rec')
|
|
168
|
+
return x && x.status === 'in-progress' && x.runs && x.runs[1].outcome === 'incomplete' && x.runs[2] && x.runs[2].model === GOOD && h.spawnLog.length >= 3 && h.spawnLog[2].model === GOOD ? x : null
|
|
169
|
+
}, 'run3 软闸跳 good:recentRuns 2 全败 → 续跑健康闸拦下重派 + healthyModel 拦下 flaky,槽内次选 prov/good 接手')
|
|
170
|
+
assert.equal(h.spawnLog[2].fault, null, '第 3 次 spawn 无故障(次数窗口已耗尽 + 软闸跳病模型)')
|
|
171
|
+
var fb2 = t3.messages.filter(function (m) { return m.kind === 'resume-fallback' })
|
|
172
|
+
assert.equal(fb2.length, 2, '第二次重派续跑同样 fallback 留痕(共两条)')
|
|
173
|
+
assert.ok(fb2[1].text.indexOf('续跑放弃') >= 0 && fb2[1].text.indexOf(FLAKY) >= 0, '第二次 fallback=续跑健康闸(recentRuns ≥2 全败 → 续跑放弃,点名原模型)')
|
|
174
|
+
assert.equal(t3.runs[2].modelSource, 'lane', 'run3 modelSource=lane(软闸槽内跳过,非降级非绕链)')
|
|
175
|
+
assert.equal(h.programs[0].used, 2, '次数窗口消耗 2 次(基建卡能力)')
|
|
176
|
+
assert.equal(h.programs[0].done, true, 'times 用尽即 done(自愈)')
|
|
177
|
+
|
|
178
|
+
// ===== continuable 交付(事件通道,integration c/d 先例):writeChildLog + emitStatus running→idle =====
|
|
179
|
+
// 健康子会话识别:fault 层合成 activation 带 __fault(秒拆命中)留档,健康 spawn __fault=null。
|
|
180
|
+
var workerKids = env.continuables.filter(function (c) { return c.label === 'worker:task-rec' && !c.__fault })
|
|
181
|
+
assert.equal(workerKids.length, 1, '健康 continuable 子会话恰一个(fault 层合成 childId)')
|
|
182
|
+
var goodChild = workerKids[0].childId
|
|
183
|
+
writeChildLog(env, goodChild, workerText('task-rec'))
|
|
184
|
+
env.emitStatus(goodChild, 'running')
|
|
185
|
+
env.emitStatus(goodChild, 'idle')
|
|
186
|
+
var t3b = await env.waitFor(function () {
|
|
187
|
+
var x = env.task('task-rec')
|
|
188
|
+
return x && x.status === 'verifying' && x.deliverable && x.deliverable.summary && x.runs && x.runs[2] && x.runs[2].outcome === 'completed' ? x : null
|
|
189
|
+
}, '事件通道交付:settleContinuable 文本兜底真读子会话日志 → deliverable.summary → verifying(full 档)')
|
|
190
|
+
assert.equal(t3b.deliverable.summary, '完成 task-rec 的实现', '⑤ 交付物走文本分段解析(settleContinuable 真读日志——mock 编不出的接缝)')
|
|
191
|
+
assert.ok(t3b.deliverable.changes, 'changes 段解析非空')
|
|
192
|
+
assert.ok(t3b.deliverable.selfTest, 'selfTest 段解析非空')
|
|
193
|
+
assert.ok(t3b.runs[2].endedAt, 'run3 关账 completed(settleRunRecord)')
|
|
194
|
+
assert.equal(t3b.runs[2].continuable, true, 'run3 continuable 留档')
|
|
195
|
+
assert.equal(t3b.runs[2].model, GOOD, 'run3 模型=prov/good')
|
|
196
|
+
|
|
197
|
+
// ===== verifier 一次性 spawn(无故障):run.result 落定 APPROVE_TEXT → approved → resolved =====
|
|
198
|
+
//(fault 层 healthyText=APPROVE_TEXT:delivery='caller' 健康合成 result 正常落定——与 mock
|
|
199
|
+
// resolveWith(APPROVE_TEXT) 同口径,run.result 结算 → settleVerifier parseVerdict。)
|
|
200
|
+
await env.clock.advance(50)
|
|
201
|
+
var t4 = await env.waitFor(function () {
|
|
202
|
+
var x = env.task('task-rec')
|
|
203
|
+
return x && x.status === 'resolved' && x.verification && x.verification.verdict === 'approved' && x.runs && x.runs.length === 4 && x.runs[3] && x.runs[3].outcome === 'completed' ? x : null
|
|
204
|
+
}, 'verifier 一次性 spawn(无故障)run.result=APPROVE_TEXT → approved → resolved 且 run 关账 completed')
|
|
205
|
+
var verifyKid = env.continuables.filter(function (c) { return c.label === 'verifier:task-rec' })[0]
|
|
206
|
+
assert.ok(verifyKid, 'verifier activation 在 fault 层留痕')
|
|
207
|
+
assert.equal(h.spawnLog[3].label, 'verifier:task-rec', 'verifier spawn 各在其位')
|
|
208
|
+
assert.equal(h.spawnLog[3].delivery, 'caller', 'verifier 恒一次性面(L774)delivery=caller')
|
|
209
|
+
assert.equal(h.spawnLog[3].fault, null, 'verifier spawn 无故障(次数窗口已耗尽 + match worker 不命中)')
|
|
210
|
+
assert.equal(h.spawnLog[3].model, '', 'verifier 不进档位链 → 父模型(无 agentOptions)')
|
|
211
|
+
assert.equal(t4.runs[3].id, verifyKid.childId, 'verifier run id 归因到 activation childId')
|
|
212
|
+
assert.equal(t4.verification.summary, '验收脚本独立复跑通过', 'L76 口径结论文本解析(verifySummary)')
|
|
213
|
+
assert.ok(t4.verifiedAt && t4.verifiedBy, '验收留痕 verifiedAt/verifiedBy')
|
|
214
|
+
assert.ok(t4.resolvedAt, 'resolvedAt 落卡')
|
|
215
|
+
|
|
216
|
+
// ===== ① history 全流转序列逐段在案 =====
|
|
217
|
+
assert.deepEqual(transitions(t4), [
|
|
218
|
+
'created→pending', 'pending→in-progress', 'in-progress→pending',
|
|
219
|
+
'pending→in-progress', 'in-progress→pending',
|
|
220
|
+
'pending→in-progress', 'in-progress→verifying', 'verifying→resolved',
|
|
221
|
+
], '① history 全序列:两次秒拆重排 + 交付 verifying + 验收 resolved 逐段在案')
|
|
222
|
+
// ===== ② spawn 模型序列 [flaky,flaky,good] + verifier 各在其位 =====
|
|
223
|
+
assert.deepEqual(h.spawnLog.map(function (e) { return e.model }), [FLAKY, FLAKY, GOOD, ''], '② spawn 模型序列 [flaky,flaky,good] + verifier 父模型')
|
|
224
|
+
assert.deepEqual(h.spawnLog.map(function (e) { return e.fault }), ['instant-kill', 'instant-kill', null, null], '② fault 分档:前 2 秒拆后自愈,verifier 无故障')
|
|
225
|
+
assert.deepEqual(h.spawnLog.map(function (e) { return e.method }), ['startActivation', 'startActivation', 'startActivation', 'startActivation'], '② 全程 activation 契约')
|
|
226
|
+
assert.ok(t4.runs.slice(0, 3).every(function (r) { return r.modelSource === 'lane' }), '三次 worker 取模全命中档位链(lane)')
|
|
227
|
+
assert.equal(t4.runs[3].modelSource, 'parent', 'verifier modelSource=parent')
|
|
228
|
+
// ===== ③ 终态 resolved 且 verifier 留档 outcome=completed =====
|
|
229
|
+
assert.equal(t4.status, 'resolved', '③ 终态 resolved')
|
|
230
|
+
assert.equal(t4.runs[3].outcome, 'completed', '③ verifier 留档 outcome=completed')
|
|
231
|
+
assert.ok(t4.runs[3].endedAt, '③ verifier 关账有 endedAt')
|
|
232
|
+
|
|
233
|
+
// ===== ④ 活跃面零残留(幽灵 rec 零遗留)=====
|
|
234
|
+
await env.clock.advance(50)
|
|
235
|
+
await env.clock.advance(50) // 推进 2 轮 poolCycle:卡 resolved → 空闲快进,池状态归零
|
|
236
|
+
var b = env.board()
|
|
237
|
+
assert.equal((b.poolStatus.workers || []).length, 0, '④ poolStatus.workers 零残留')
|
|
238
|
+
assert.equal((b.poolStatus.verifiers || []).length, 0, '④ poolStatus.verifiers 零残留')
|
|
239
|
+
var t5 = env.task('task-rec')
|
|
240
|
+
assert.ok(t5.runs.every(function (r) { return r.outcome !== 'running' }), '④ 卡面 runs 零 running 行(幽灵 rec 零遗留)')
|
|
241
|
+
assert.ok(t5.runs.every(function (r) { return r.endedAt }), '④ 全部留档关账(有 endedAt)')
|
|
242
|
+
assert.ok(t5.deliverable && t5.deliverable.summary, '⑤ deliverable.summary 非空(复锚定)')
|
|
243
|
+
|
|
244
|
+
// ===== 加餐:结算≠停止根修补停(settle-stop-interrupt ①通道)——completed 落定无续跑位 → 补停 =====
|
|
245
|
+
await env.waitFor(function () { return stopsOn(env, goodChild).length >= 1 }, 'continuable worker completed 落定补停(settleRunRecord 末尾)')
|
|
246
|
+
// ===== 加餐:软闸不落硬黑名单(连败软闸 vs 熔断语义分治)=====
|
|
247
|
+
var gt = await env.rpc('get-tasks', { sessionId: env.sid })
|
|
248
|
+
var mh = gt.modelHealth || (gt.data && gt.data.modelHealth) || {}
|
|
249
|
+
var fe = mh[FLAKY]
|
|
250
|
+
assert.ok(fe && fe.state !== 'circuit', '连败软闸不落 badModels 黑名单(软熔断仅取模跳过,与硬熔断语义分治)')
|
|
251
|
+
assert.ok(Array.isArray(fe.recentRuns) && fe.recentRuns.length >= 2 && fe.recentRuns.every(function (r) { return !r.ok }), '健康表 recentRuns ≥2 全败(软闸数据源)')
|
|
252
|
+
} finally { restoreHome(); await env.cleanup() }
|
|
253
|
+
})
|
|
254
|
+
|
|
255
|
+
|
|
@@ -0,0 +1,206 @@
|
|
|
1
|
+
// ===== 故障 E2E:连败软闸——病模型第二次派发被跳,同卡第三次落到健康模型完成(真派发循环,task-mvqi3uj4-3)=====
|
|
2
|
+
// 背景:事故类「连败仍调度」(原形:glm-5.2「78s 报错一次+挂死一次」病了还被优先派发)的端到端回归。
|
|
3
|
+
// 机制锚点:healthyModel 连败软闸 recentRuns≥2 全败 → 不健康(dispatch.mjs L224-229;软熔断:不落
|
|
4
|
+
// badModels 黑名单,仅取模/续跑跳过);recentRuns 由 observeModel 喂(L108-109,settleRunRecord L1261
|
|
5
|
+
// 每次可归因 run 落定喂给,滚动窗近 5 次)。档位槽=有序数组:槽内按序取首个健康模型(L648)——
|
|
6
|
+
// 首选病即次选赢(偏好序非故障序,不降级不绕链),modelSource 仍记 'lane'。
|
|
7
|
+
//
|
|
8
|
+
// 与 settle-stop-interrupt.test.mjs 续跑健康闸④(薄桩)差异:④ 是续跑路径单测(直种 modelHealth,
|
|
9
|
+
// 锁「放弃续跑改 fresh spawn」);本卡验证「软闸 → 同卡落到健康模型完成」的**派发闭环**:跑在
|
|
10
|
+
// 真实 index.mjs apply(faultCtx) 全循环上(fault-e2e-circuit.test.mjs harness 同款:rpc create-task →
|
|
11
|
+
// clock.advance(50) 踢 poolCycle → waitFor 收敛),病模型真秒拆×2 喂 recentRuns(真 observeModel 链路,
|
|
12
|
+
// 非直种),第三次取模软闸拦下病模型改取槽内次选健康模型,次选正常交付(resolveWith 分段交付文本,
|
|
13
|
+
// integration.test.mjs L71 workerText 同款)→ 卡 verifying。
|
|
14
|
+
//
|
|
15
|
+
// 场景:laneModels.standard.worker=['prov/flaky','prov/good'](槽位有序数组,首选病次选健康),
|
|
16
|
+
// prov/flaky=instant-kill 持续(按模型命中——病模型每次 spawn 即秒拆,与 fault-e2e-circuit 同款接缝)。
|
|
17
|
+
// 建 size=standard 卡 → run1 取 flaky(槽内首选健康检查通过:recentRuns 空)秒拆 → 重派 run2 仍 flaky
|
|
18
|
+
// (recentRuns 1 败 <2 未达软闸线)秒拆 → run3 软闸拦下 flaky 改取 good(槽内次选赢,L648)→
|
|
19
|
+
// good 正常交付 → verifying。
|
|
20
|
+
//
|
|
21
|
+
// 断言(四条,对应任务口径):
|
|
22
|
+
// ① 三次 worker spawn 日志模型序列恰为 [prov/flaky, prov/flaky, prov/good]——软闸「第二次派发
|
|
23
|
+
// 跳过病模型」的端到端证据(观测点=故障层 spawn spec,非单测直读 state);
|
|
24
|
+
// ② run3 modelSource 留档='lane'(三次全是槽内命中:软闸=槽内健康判定,不走降档不绕链);
|
|
25
|
+
// ③ 卡未进 blocked:第三次成功 retryCount 成功路径清除(L1679)→ verifying(resolveApply full 档),
|
|
26
|
+
// deliverable 随分段文本落卡,三次 run 全 fresh spawn(一次性路径零续跑干扰);
|
|
27
|
+
// ④ get-tasks RPC modelHealth 健康面:flaky recentRuns 滚动窗含败迹(2 条全败——observeModel 喂给
|
|
28
|
+
// 透出),且 state ≠ circuit/cooldown(2 连击 < 3 未达硬熔断线——软闸≠硬熔断语义分治);
|
|
29
|
+
// good recentRuns 含成功条目(第三次成功喂给)。
|
|
30
|
+
// 注意:拆机文案避开冷却嗅探关键词(连接/超时/网关/limit 等)——否则病模型被误登记冷却,软闸循环
|
|
31
|
+
// 会被冷却闸截断(熔断与冷却两张表各管各的,本场景只测连败软闸)。
|
|
32
|
+
import { test } from 'node:test'
|
|
33
|
+
import assert from 'node:assert/strict'
|
|
34
|
+
import { createMockCtx } from './helpers/mock-ctx.mjs'
|
|
35
|
+
import * as plugin from '../index.mjs'
|
|
36
|
+
|
|
37
|
+
var FLAKY = 'prov/flaky'
|
|
38
|
+
var GOOD = 'prov/good'
|
|
39
|
+
// 拆机原形文本(dispatch.mjs activation 拆除臂同款前缀;diagnostic 避开冷却嗅探关键词)
|
|
40
|
+
var TEARDOWN_TEXT = '子会话被宿主拆除(stopReason: error,宿主秒拆注入)'
|
|
41
|
+
// Worker 交付文本(integration.test.mjs L71 workerText 同款:分段格式,避开 [ESCALATE] 标记)
|
|
42
|
+
function workerText(tag) {
|
|
43
|
+
return '## 开发描述\n完成 ' + tag + ' 的实现\n\n## 改动清单\n- src/' + tag + '.mjs:新增实现\n\n## 自测情况\nnpm test 全绿\n\n## diff 概要\n 1 file changed, 10 insertions(+)'
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
// ===== 故障层:llm 目录接缝 + 故障表按模型秒拆 + 次选健康 resolveWith 同款交付 =====
|
|
47
|
+
// 接缝①:故障层 llm 目录(prov/flaky + prov/good 在册)——set-board-config laneModels 槽位校验经
|
|
48
|
+
// enumModels 枚举 llm 清单(rpc.mjs,list-models 同源)放行;dispatch modelDirectory 同源数据面:
|
|
49
|
+
// 病模型在册 = outOfDir 不拦,才进得了取模链(目录闸放行的接缝)。
|
|
50
|
+
// 接缝②:故障表按模型命中(spec.request.agentOptions.model)——flaky 每次 spawn 即秒拆:
|
|
51
|
+
// activation.result 以拆机原形文本**裸字符串**立即拒绝(run.result 拒绝经 withTimeout race 臂
|
|
52
|
+
// finish(null, err) → settleRun → settleWorker 失败臂 → settleRunRecord observeModel 喂 recentRuns)。
|
|
53
|
+
// 次选 good 的 worker run 以 resolveWith 同款 output text 正常落定(分段交付文本 → 成功臂 → verifying);
|
|
54
|
+
// verifier run 永不落定(卡停 verifying 不再推进——本场景只测 worker 闭环)。
|
|
55
|
+
// calls = spawn 日志观测点(断言①读 spec.request.agentOptions,不直读内部 state)。
|
|
56
|
+
function applyFaults(env) {
|
|
57
|
+
var origGet = env.ctx.get
|
|
58
|
+
env.ctx.get = function (name) {
|
|
59
|
+
if (name === 'llm') {
|
|
60
|
+
return {
|
|
61
|
+
listProviders: function () { return [{ id: 'prov', name: 'prov' }] },
|
|
62
|
+
listModels: async function (pid) { return pid === 'prov' ? [{ id: 'flaky', name: 'flaky' }, { id: 'good', name: 'good' }] : [] },
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
return origGet(name)
|
|
66
|
+
}
|
|
67
|
+
var calls = []
|
|
68
|
+
var n = 0
|
|
69
|
+
env.ctx.subagents.startActivation = async function (spec) {
|
|
70
|
+
calls.push(spec)
|
|
71
|
+
var ao = spec.request && spec.request.agentOptions
|
|
72
|
+
if (ao && ao.model && 'prov/' + ao.model === FLAKY) {
|
|
73
|
+
// 拒绝值=拆机原形文本字符串:settleRun 的 errText=String(err) → isModelKillFailure 前缀命中;
|
|
74
|
+
// 空窗 catch:race 臂挂载前的微任务窗口防 unhandled rejection(拒绝值另有 race 臂消费)
|
|
75
|
+
var result = Promise.reject(TEARDOWN_TEXT)
|
|
76
|
+
result.catch(function () {})
|
|
77
|
+
return { childId: 'child-' + (++n), messageId: 'm' + n, result: result, dispose: async function () {} }
|
|
78
|
+
}
|
|
79
|
+
if (String(spec.label || '').indexOf('worker:') === 0) {
|
|
80
|
+
// 次选健康:resolveWith 同款 output text 正常落定(settleRun 成功臂 → parseSections → verifying)
|
|
81
|
+
return {
|
|
82
|
+
childId: 'child-' + (++n), messageId: 'm' + n,
|
|
83
|
+
result: Promise.resolve({ output: [{ type: 'text', text: workerText('softgate') }], stopReason: 'completed' }),
|
|
84
|
+
dispose: async function () {},
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
return { childId: 'child-' + (++n), messageId: 'm' + n, result: new Promise(function () {}), dispose: async function () {} }
|
|
88
|
+
}
|
|
89
|
+
return { calls: calls }
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
// 槽位有序数组写入 + 一次性回退开关(接缝的实证步骤)
|
|
93
|
+
async function writeBoardConfig(env) {
|
|
94
|
+
// laneModels.standard.worker = ['prov/flaky','prov/good'](槽位有序数组,首选病次选健康)——
|
|
95
|
+
// llm 目录在册 → set-board-config 槽位校验放行(接缝①实证步骤)
|
|
96
|
+
var lm = await env.rpc('set-board-config', { sessionId: env.sid, key: 'laneModels', value: { standard: { worker: [FLAKY, GOOD] } } })
|
|
97
|
+
assert.equal(lm.ok, true, '故障层 llm 目录在册 → set-board-config laneModels 槽位有序数组放行')
|
|
98
|
+
// workerContinuable=false(一次性回退开关):失败重派恒 fresh spawn(resumeTarget 对非 continuable
|
|
99
|
+
// 恒空)——与 fault-e2e-circuit 同款:三连循环确定性收敛、零续跑干扰
|
|
100
|
+
var wc = await env.rpc('set-board-config', { sessionId: env.sid, key: 'workerContinuable', value: false })
|
|
101
|
+
assert.equal(wc.ok, true, 'workerContinuable=false(一次性回退开关)放行')
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
// 建卡封装:显式 description 避开空描述软提示;size=standard(槽内取模的前提)
|
|
105
|
+
async function createTask(env, id, extra) {
|
|
106
|
+
var args = { sessionId: env.sid, id: id, title: '故障E2E ' + id, description: '故障回归用例 ' + id }
|
|
107
|
+
if (extra) { for (var k in extra) args[k] = extra[k] }
|
|
108
|
+
var r = await env.rpc('create-task', args)
|
|
109
|
+
assert.equal(r.ok, true, 'create-task 成功: ' + id)
|
|
110
|
+
return r.task
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
function transitions(t) { return (t.history || []).map(function (h) { return h.from + '→' + h.to }) }
|
|
114
|
+
// 卡上 worker 角色的 runs 条目(pipeline=full 的 verifier spawn 晚于断言时点,全场景按 worker 过滤)
|
|
115
|
+
function workerRuns(t) { return (t.runs || []).filter(function (r) { return r.role === 'worker' }) }
|
|
116
|
+
// worker spawn 日志(label 前缀过滤——verifier spawn 不参与断言①)
|
|
117
|
+
function workerSpawns(calls) { return calls.filter(function (c) { return String(c.label || '').indexOf('worker:') === 0 }) }
|
|
118
|
+
|
|
119
|
+
// ===== 主场景:病模型秒拆×2 → 软闸拦下改取次选健康模型 → 正常交付 verifying(真 poolCycle 循环)=====
|
|
120
|
+
// 与 lane-models.test.mjs 连败软闸 S1/S2 的差异:S1/S2 是薄桩单测(直种 modelHealth、直调 spawnOneShot);
|
|
121
|
+
// 本用例跑真 poolCycle 重派循环,recentRuns 由**真 observeModel 链路**喂(run.result 拒绝 → settleRun →
|
|
122
|
+
// settleRunRecord L1261),锁「软闸 → 同卡落到健康模型完成」的派发闭环。
|
|
123
|
+
test('故障E2E·连败软闸:病模型秒拆×2 喂 recentRuns → 第三次软闸拦下改取槽内次选健康模型正常交付 → verifying(真 poolCycle 循环)', async () => {
|
|
124
|
+
var env = createMockCtx()
|
|
125
|
+
try {
|
|
126
|
+
var faults = applyFaults(env)
|
|
127
|
+
plugin.apply(env.ctx)
|
|
128
|
+
await writeBoardConfig(env)
|
|
129
|
+
// 建 size=standard 卡(槽内取模前提:standard 槽命中 laneModels.standard.worker)→ 50ms 去抖踢 poolCycle
|
|
130
|
+
await createTask(env, 'task-sg', { pipeline: 'full', size: 'standard' })
|
|
131
|
+
await env.clock.advance(50)
|
|
132
|
+
// 三个 waitFor 一律等「结算链尾」:settleWorker 的状态推进与 settleRunRecord 的 run 关账/
|
|
133
|
+
// observeModel 喂给是两次持锁写(settleRun L1329 → L1338)——只等状态会撞上「pending 已落盘
|
|
134
|
+
// 而 recentRuns 未喂」的窗口(与 fault-e2e-circuit「等链尾」同一口径)。
|
|
135
|
+
// run1:槽内首选 flaky(healthyModel:recentRuns 空 → 健康检查通过)→ 秒拆
|
|
136
|
+
var t = await env.waitFor(function () {
|
|
137
|
+
var x = env.task('task-sg')
|
|
138
|
+
return x && x.status === 'pending' && x.retryCount === 1 && x.runs && x.runs[0] && x.runs[0].outcome === 'timeout/error' ? x : null
|
|
139
|
+
}, '秒拆#1 结算:run.result 拒绝 → settleWorker 失败臂回 pending 且 run 关账 timeout/error(等链尾)')
|
|
140
|
+
assert.equal(workerSpawns(faults.calls).length, 1, '首拆一次 worker spawn')
|
|
141
|
+
assert.equal(workerSpawns(faults.calls)[0].request.agentOptions.model, 'flaky', 'run1 取槽内首选 flaky(recentRuns 空:软闸线未达,健康检查通过)')
|
|
142
|
+
assert.equal(workerRuns(t)[0].modelSource, 'lane', 'run1 modelSource=lane(槽内命中)')
|
|
143
|
+
// run2:重派仍 flaky——recentRuns 1 败 < 2 未达软闸线,取模行为不变(「第二次派发不跳」对照面)
|
|
144
|
+
await env.clock.advance(50)
|
|
145
|
+
t = await env.waitFor(function () {
|
|
146
|
+
var x = env.task('task-sg')
|
|
147
|
+
var wr = x && x.runs ? workerRuns(x) : null
|
|
148
|
+
return x && x.status === 'pending' && x.retryCount === 2 && wr && wr[1] && wr[1].outcome === 'timeout/error' ? x : null
|
|
149
|
+
}, '秒拆#2 自动重派同样秒拆且关账(等链尾:此刻 recentRuns 已喂 2 败)')
|
|
150
|
+
assert.equal(workerSpawns(faults.calls).length, 2, '两拆两次 worker spawn')
|
|
151
|
+
assert.equal(workerSpawns(faults.calls)[1].request.agentOptions.model, 'flaky', 'run2 仍取 flaky(recentRuns 1 败 <2 未达软闸线)——软闸不提前拦的对照面')
|
|
152
|
+
assert.equal(workerRuns(t)[1].modelSource, 'lane')
|
|
153
|
+
// run3:软闸拦下 flaky(recentRuns ≥2 全败 → healthyModel false,L224-229)改取槽内次选 good(L648)→ 正常交付
|
|
154
|
+
await env.clock.advance(50)
|
|
155
|
+
t = await env.waitFor(function () {
|
|
156
|
+
var x = env.task('task-sg')
|
|
157
|
+
var wr = x && x.runs ? workerRuns(x) : null
|
|
158
|
+
return x && x.status === 'verifying' && wr && wr[2] && wr[2].outcome === 'completed' ? x : null
|
|
159
|
+
}, 'run3 软闸改取 good 正常交付 → verifying 且第三条 run 关账(等链尾)')
|
|
160
|
+
// ===== ① 三次 spawn 日志模型序列恰为 [flaky, flaky, good](软闸端到端证据)=====
|
|
161
|
+
var ws = workerSpawns(faults.calls)
|
|
162
|
+
assert.equal(ws.length, 3, '三次 worker spawn(不多不少)')
|
|
163
|
+
assert.deepEqual(ws.map(function (c) { return 'prov/' + c.request.agentOptions.model }), [FLAKY, FLAKY, GOOD], 'spawn 日志模型序列恰为 [flaky, flaky, good]——第三次软闸拦下病模型改取次选(L648)')
|
|
164
|
+
// ===== ② run3 modelSource 留档='lane' =====
|
|
165
|
+
assert.deepEqual(workerRuns(t).map(function (r) { return r.modelSource }), ['lane', 'lane', 'lane'], '三次 modelSource 全=lane(软闸=槽内健康判定,不走降档不绕链)')
|
|
166
|
+
assert.deepEqual(workerRuns(t).map(function (r) { return r.model }), [FLAKY, FLAKY, GOOD], '卡 runs 留档模型序列与 spawn 日志同序(留档审计面)')
|
|
167
|
+
// ===== ③ 卡未进 blocked:第三次成功 retryCount 成功路径清除(L1679)→ verifying =====
|
|
168
|
+
assert.equal(t.status, 'verifying', '卡 verifying(未进 blocked——第三次成功)')
|
|
169
|
+
assert.ok(transitions(t).indexOf('→blocked') < 0, '全程零 blocked 流转(三连败语义未达:只拆 2 次)')
|
|
170
|
+
assert.equal('retryCount' in t, false, 'retryCount 成功路径清除(L1679)')
|
|
171
|
+
assert.equal('lastError' in t, false, 'lastError 成功路径一并清除(L1679)')
|
|
172
|
+
assert.equal(transitions(t)[transitions(t).length - 1], 'in-progress→verifying', '流转方向 in-progress→verifying')
|
|
173
|
+
assert.ok(t.deliverable && t.deliverable.summary && t.deliverable.summary.indexOf('softgate') >= 0, 'deliverable 随分段交付文本落卡(resolveWith 同款文本真走了成功臂)')
|
|
174
|
+
assert.ok(workerRuns(t).every(function (r) { return !r.resume }), '三次重派全 fresh spawn(一次性路径零续跑干扰)')
|
|
175
|
+
// ===== ④ get-tasks RPC modelHealth 健康面:recentRuns 滚动窗含败迹(若透出)=====
|
|
176
|
+
var gt = await env.rpc('get-tasks', { sessionId: env.sid })
|
|
177
|
+
var mh = gt.modelHealth || (gt.data && gt.data.modelHealth) || {}
|
|
178
|
+
var flaky = mh[FLAKY]
|
|
179
|
+
assert.ok(flaky && Array.isArray(flaky.recentRuns) && flaky.recentRuns.length === 2, '健康面透出 flaky recentRuns(observeModel 喂给,滚动窗 2 条)')
|
|
180
|
+
assert.ok(flaky.recentRuns.every(function (r) { return r.ok === false }), 'flaky recentRuns 滚动窗含败迹(2 条全败——软闸数据源)')
|
|
181
|
+
assert.ok(flaky.state !== 'circuit' && flaky.state !== 'cooldown', 'flaky 未进硬熔断/冷却(2 连击 < 3 未达 WORKER_MODEL_CIRCUIT_AFTER——软闸≠硬熔断语义分治)')
|
|
182
|
+
var good = mh[GOOD]
|
|
183
|
+
assert.ok(good && Array.isArray(good.recentRuns) && good.recentRuns.some(function (r) { return r.ok === true }), 'good recentRuns 含成功条目(第三次成功喂给)')
|
|
184
|
+
assert.ok(good.state === 'healthy', 'good 健康面 healthy(成功 observeModel)')
|
|
185
|
+
} finally { await env.cleanup() }
|
|
186
|
+
})
|
|
187
|
+
|
|
188
|
+
// ===== 接缝对照:槽位模型不在 llm 目录 → set-board-config laneModels 被目录闸拒写 =====
|
|
189
|
+
// 槽位值不在故障层 llm 目录 → enumModels 枚举不命中 → 拒写「非法模型 id」(不落脏值)——
|
|
190
|
+
// 不放行就永远进不了取模链,连败软闸回归无从谈起(与 fault-e2e-circuit workerModel 接缝对照同款,
|
|
191
|
+
// 本卡锁 laneModels 槽位写入路径)。
|
|
192
|
+
test('故障E2E·接缝对照:槽位模型不在 llm 目录 → set-board-config laneModels 被拒写(不落脏值)', async () => {
|
|
193
|
+
var env = createMockCtx()
|
|
194
|
+
try {
|
|
195
|
+
plugin.apply(env.ctx) // 默认 mock llm:listProviders 返回 [](空清单)
|
|
196
|
+
var r = await env.rpc('set-board-config', { sessionId: env.sid, key: 'laneModels', value: { standard: { worker: [FLAKY, GOOD] } } })
|
|
197
|
+
assert.equal(r.ok, false, '槽位模型不在 llm 目录 → 目录闸拒写')
|
|
198
|
+
assert.ok(String(r.error || '').indexOf('非法模型 id') === 0, '报错带「非法模型 id」前缀(带合法清单样例)')
|
|
199
|
+
var board = env.board()
|
|
200
|
+
var lm = board && board.laneModels && board.laneModels.standard ? board.laneModels.standard.worker : []
|
|
201
|
+
assert.equal(lm.length, 0, '看板不落脏值(槽位未写入)')
|
|
202
|
+
} finally { await env.cleanup() }
|
|
203
|
+
})
|
|
204
|
+
|
|
205
|
+
|
|
206
|
+
|