dsh-workplan 1.8.3 → 1.8.4
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 +54 -0
- package/README.en.md +1 -1
- package/README.md +1 -1
- package/client.js +47 -18
- package/docs/release-notes-1.8.4.md +65 -0
- package/lib/host.js +1 -1
- package/lib/plan.js +12 -0
- package/lib/runtime.js +62 -12
- package/package.json +1 -1
- package/src/client.ts +45 -17
- package/src/host.ts +1 -1
- package/src/plan.ts +12 -0
- package/src/runtime.ts +63 -12
package/CHANGELOG.md
CHANGED
|
@@ -1,3 +1,57 @@
|
|
|
1
|
+
## 1.8.4 — 2026-10-30
|
|
2
|
+
|
|
3
|
+
**修复:左侧栏「任务进度」同时显示「已结束」和「正在做」。**
|
|
4
|
+
|
|
5
|
+
> 现象(用户截图,2026-10-30 20:06:33,会话 `session-b83e4a75-…`):
|
|
6
|
+
> 同一张卡片既在「已结束」分组里、徽标写着「已结束,可续跑 · 正在做」,
|
|
7
|
+
> 第 4 步又写着「正在做」;而会话正文早已给出结果。同一张卡还给出两个完成度
|
|
8
|
+
> (计数 73% / 加权 80%),并承诺「可续跑」却不给续跑方法。
|
|
9
|
+
|
|
10
|
+
### 根因
|
|
11
|
+
|
|
12
|
+
计划结果由异步派发结算,**派发可以跨过宿主回合结束**(事故里 `turn/end`
|
|
13
|
+
在 19:58:39,派发又继续跑到 20:22:50)。`serialisePlan` 判断「本轮是否结束」
|
|
14
|
+
时只看最后一个 `turn/start|turn/end` 事件,没有看插件自己的存活信号
|
|
15
|
+
`record.dispatchPromise`,于是把「回合结束」当成「没有东西在跑」,把阶段改写成
|
|
16
|
+
`ended`,而子任务状态仍是 `in_progress`——两句话从此各说各的。
|
|
17
|
+
|
|
18
|
+
同一处还有三个次生矛盾:客户端 `planPhaseOf` 用计数覆盖服务端阶段;`resumeHint`
|
|
19
|
+
只在 `phase === 'blocked'` 时给指令(徽标却对 `ended` 承诺可续跑);展开页用
|
|
20
|
+
`stats.progress`(加权)而分组/环用计数百分比。
|
|
21
|
+
|
|
22
|
+
### 修复
|
|
23
|
+
|
|
24
|
+
- **存活事实优先**:`serialisePlan` 先读 `record.dispatchPromise`;有活派发时
|
|
25
|
+
不进入 `ended`,并把 `running` 随载荷下发(`src/runtime.ts`)。
|
|
26
|
+
- **收敛残留项**:回合真的结束且无活派发时,把残留的 `in_progress` 改判
|
|
27
|
+
`blocked` 并附「本轮结束时这一步仍未完成…可以续跑」的说明——只改下发的副本,
|
|
28
|
+
内存记录不动,续跑仍从原地继续(`settleStaleInflight`)。
|
|
29
|
+
- **口径统一**:展开页与分组/环改用同一个计数百分比,不再并列「加权」数字。
|
|
30
|
+
- **承诺与操作一致**:`ended`/`paused` 且原阶段可续跑时,也给出续跑指令。
|
|
31
|
+
- **新增不变量 I11**:`phase=ended` 且仍有 `in_progress` 时自检判红。
|
|
32
|
+
- **回归测试**:新增 `tests/ended-live-dispatch.test.ts`(6 例,含回放路径与
|
|
33
|
+
「收敛不改内存记录」),`tests/client-resume-hint.test.ts` 增 2 例(徽标与
|
|
34
|
+
续跑说明必须同时成立;载荷说「还在跑」时界面不得显示「已结束」)。
|
|
35
|
+
|
|
36
|
+
### 升级
|
|
37
|
+
|
|
38
|
+
```bash
|
|
39
|
+
dsh plugin --profile web add dsh-workplan@1.8.4
|
|
40
|
+
```
|
|
41
|
+
|
|
42
|
+
插件在 `dsh web` 启动时加载,**升级后需重启一次 `dsh web` 才生效**(重启会中断
|
|
43
|
+
正在运行的会话)。历史计划不需要数据订正:面板按新规则重算即可,旧记录里
|
|
44
|
+
「已结束 + 正在做」的组合不会再被渲染出来。
|
|
45
|
+
|
|
46
|
+
### 已知限制
|
|
47
|
+
|
|
48
|
+
- 「已结束」只代表「没有活派发」,不代表计划完成;未完成的计划仍会进「已结束」
|
|
49
|
+
分组并标出受阻数,这是刻意的:用户需要看到「这一轮结束了,但事情没做完」。
|
|
50
|
+
- 派发存活信号只在同一进程内有效。进程在派发中途被杀时,记录里不会留下
|
|
51
|
+
`dispatchPromise`,此时按「回合结束 + 残留 in_progress」收敛为受阻。
|
|
52
|
+
|
|
53
|
+
---
|
|
54
|
+
|
|
1
55
|
## 1.8.3 — 2026-10-30
|
|
2
56
|
|
|
3
57
|
**文档版:把首页第一句换成用户选定的措辞。不改代码。**
|
package/README.en.md
CHANGED
|
@@ -77,7 +77,7 @@ The full contract — roles, data shapes, state machine, recovery, and the three
|
|
|
77
77
|
## Install
|
|
78
78
|
|
|
79
79
|
```bash
|
|
80
|
-
dsh plugin --profile web add dsh-workplan@1.8.
|
|
80
|
+
dsh plugin --profile web add dsh-workplan@1.8.4
|
|
81
81
|
```
|
|
82
82
|
|
|
83
83
|
Restart the DSH Web process (or reload the page) so the bundle is picked up.
|
package/README.md
CHANGED
package/client.js
CHANGED
|
@@ -183,7 +183,7 @@ window.__ModuleLoader__.load({
|
|
|
183
183
|
"scopeAll": "当前各会话最新计划汇总",
|
|
184
184
|
"scopeThis": "本计划",
|
|
185
185
|
"vizStageTitle": "分步进度",
|
|
186
|
-
"
|
|
186
|
+
"vizOverall": "总体进度",
|
|
187
187
|
"allPlansHint": "上面是当前各会话最新计划的合计;历史计划不在此汇总,下面每张卡片只统计本计划。",
|
|
188
188
|
"openHint": "打开左侧「任务进度」看完整安排。"
|
|
189
189
|
},
|
|
@@ -354,7 +354,7 @@ window.__ModuleLoader__.load({
|
|
|
354
354
|
"scopeAll": "Latest plan per live session",
|
|
355
355
|
"scopeThis": "This plan",
|
|
356
356
|
"vizStageTitle": "Step progress",
|
|
357
|
-
"
|
|
357
|
+
"vizOverall": "Overall progress",
|
|
358
358
|
"allPlansHint": "These totals cover the latest plan in each live session; older plans are not included. Each card below counts only its own plan.",
|
|
359
359
|
"openHint": "Open “Task progress” on the left for the full plan."
|
|
360
360
|
}
|
|
@@ -1128,7 +1128,21 @@ window.__ModuleLoader__.load({
|
|
|
1128
1128
|
* build a fresh plan. Say out loud how to resume instead.
|
|
1129
1129
|
*/
|
|
1130
1130
|
function resumeHint(session, t) {
|
|
1131
|
-
|
|
1131
|
+
/*
|
|
1132
|
+
* [1.8.4] 谁承诺「可续跑」,谁就必须给出续跑方法。
|
|
1133
|
+
*
|
|
1134
|
+
* 旧实现只在 `phase === 'blocked'` 时给指令,而徽标在 ended 状态下拼的是
|
|
1135
|
+
* 「已结束,可续跑 · 卡住了」——同一张卡一边承诺能续跑,一边返回空字符串
|
|
1136
|
+
* 不给任何操作,这是事故截图里的第三处自相矛盾(T3 的互斥证据)。
|
|
1137
|
+
* 现在凡是徽标会说出「可续跑」的阶段(blocked / paused / ended 且原阶段
|
|
1138
|
+
* 是这类可续跑状态),一律给出同样的续跑指令。
|
|
1139
|
+
*/
|
|
1140
|
+
if (!session)
|
|
1141
|
+
return '';
|
|
1142
|
+
const phase = String(session.phase ?? '');
|
|
1143
|
+
const suspended = String(session.suspendedPhase ?? '');
|
|
1144
|
+
const resumable = phase === 'blocked' || phase === 'paused' || (phase === 'ended' && (suspended === '' || suspended === 'blocked' || suspended === 'paused' || suspended === 'executing' || suspended === 'planning'));
|
|
1145
|
+
if (!resumable)
|
|
1132
1146
|
return '';
|
|
1133
1147
|
if (session.resumeAvailable) {
|
|
1134
1148
|
const limit = Number(session.resumeLimit ?? 0);
|
|
@@ -1440,16 +1454,22 @@ window.__ModuleLoader__.load({
|
|
|
1440
1454
|
return phase;
|
|
1441
1455
|
}
|
|
1442
1456
|
/*
|
|
1443
|
-
* [1.
|
|
1457
|
+
* [1.8.4] 一张卡片的阶段只能有一个结论,且必须让「存活事实」拥有否决权。
|
|
1444
1458
|
*
|
|
1445
|
-
*
|
|
1446
|
-
*
|
|
1459
|
+
* 事故截图(2026-10-30 20:06:33)里同一张卡在「已结束」组,第 4 步却写着
|
|
1460
|
+
* 「正在做」。根因在后端(`turn/end` 早于异步派发结束),但展示层同样要能
|
|
1461
|
+
* 自保:服务端现在把 `running` 一起下发,这里据此兜一层——载荷同时说
|
|
1462
|
+
* 「已结束」和「派发仍在跑」时,以存活事实为准,绝不渲染「已结束」。
|
|
1463
|
+
* 老载荷没有 `running` 字段(undefined),行为保持原样。
|
|
1447
1464
|
*/
|
|
1448
|
-
function
|
|
1449
|
-
const
|
|
1450
|
-
|
|
1451
|
-
|
|
1452
|
-
|
|
1465
|
+
function sessionPhaseOf(session, counts) {
|
|
1466
|
+
const resolved = counts ?? planCounts(session?.stats || {});
|
|
1467
|
+
const phase = planPhaseOf(session?.phase || 'pending', resolved);
|
|
1468
|
+
if (phase === 'ended' && session?.running === true) {
|
|
1469
|
+
const suspended = String(session?.suspendedPhase ?? '');
|
|
1470
|
+
return suspended !== '' && suspended !== 'ended' ? suspended : 'executing';
|
|
1471
|
+
}
|
|
1472
|
+
return phase;
|
|
1453
1473
|
}
|
|
1454
1474
|
function planStatusMap(statuses) {
|
|
1455
1475
|
const byId = new Map();
|
|
@@ -1657,7 +1677,7 @@ window.__ModuleLoader__.load({
|
|
|
1657
1677
|
? h('span', { className: 'dsh-wp-planviz-alarm' }, `${counts.blocked} ${t('stats.blocked')}`)
|
|
1658
1678
|
: null, h('span', { className: 'dsh-wp-planviz-now', 'data-state': now.state }, h('span', { className: 'dsh-wp-planviz-now-dot', 'aria-hidden': 'true' }), h('span', { className: 'dsh-wp-planviz-now-text' }, now.text))), h(PlanSegments, { counts }), h(PlanLegend, { t, counts }), h(PlanStepper, { t, rows }));
|
|
1659
1679
|
}
|
|
1660
|
-
// 展开后的「分步进度」:逐阶段行 +
|
|
1680
|
+
// 展开后的「分步进度」:逐阶段行 + 总体进度(与环/组头同一个计数口径)。
|
|
1661
1681
|
function PlanOverview({ t, stats, counts, rows }) {
|
|
1662
1682
|
const stateOf = (tone) => (tone === 'done'
|
|
1663
1683
|
? t('stats.done')
|
|
@@ -1666,7 +1686,16 @@ window.__ModuleLoader__.load({
|
|
|
1666
1686
|
className: 'dsh-wp-planoverview',
|
|
1667
1687
|
'data-plan-total': String(counts.total),
|
|
1668
1688
|
'data-plan-done': String(counts.done),
|
|
1669
|
-
}, h('div', { className: 'dsh-wp-planoverview-head' }, h('span', { className: 'dsh-wp-planoverview-title' }, t('vizStageTitle')), h('span', null, `${counts.done}/${counts.total} ${t('stats.done')}`)), h('div', { className: 'dsh-wp-planoverview-stats' },
|
|
1689
|
+
}, h('div', { className: 'dsh-wp-planoverview-head' }, h('span', { className: 'dsh-wp-planoverview-title' }, t('vizStageTitle')), h('span', null, `${counts.done}/${counts.total} ${t('stats.done')}`)), h('div', { className: 'dsh-wp-planoverview-stats' },
|
|
1690
|
+
/*
|
|
1691
|
+
* [1.8.4] 一张卡只允许一个百分比口径。
|
|
1692
|
+
*
|
|
1693
|
+
* 这里以前显示加权进度,卡片其余位置显示计数百分比,于是同一张卡同时
|
|
1694
|
+
* 出现「73%」(环、组头、本计划 11/15)和「总体进度(加权)80%」——
|
|
1695
|
+
* 两者都算得对,但用户看到的是自相矛盾(T3 实测)。展示口径统一为
|
|
1696
|
+
* 计数百分比:它就是环、组头、图例共用的那个数,也是用户能数出来的数。
|
|
1697
|
+
*/
|
|
1698
|
+
h('span', null, `${t('vizOverall')} ${counts.percent === null ? '—' : `${counts.percent}%`}`), h('span', null, `${counts.active} ${t('stats.inProgress')} · ${counts.pending} ${t('stats.pending')}`), counts.blocked > 0 ? h('span', null, `${counts.blocked} ${t('stats.blocked')}`) : null), rows.length
|
|
1670
1699
|
? h('div', { className: 'dsh-wp-planrows' }, rows.map((row) => {
|
|
1671
1700
|
const width = row.total > 0 ? (row.done / row.total) * 100 : 0;
|
|
1672
1701
|
return h('div', {
|
|
@@ -1693,7 +1722,7 @@ window.__ModuleLoader__.load({
|
|
|
1693
1722
|
* 胶囊就必须是「已完成」,视觉档位也必须是 done。截图里那张卡之所以
|
|
1694
1723
|
* 「100% + 正在收尾 + 留在进行中组」,就是因为这三个读者各读各的字段。
|
|
1695
1724
|
*/
|
|
1696
|
-
const phase =
|
|
1725
|
+
const phase = sessionPhaseOf(session, counts);
|
|
1697
1726
|
const tone = phaseTone(phase);
|
|
1698
1727
|
const departments = Array.isArray(session.departments) ? session.departments : [];
|
|
1699
1728
|
const statuses = Array.isArray(session.statuses) ? session.statuses : [];
|
|
@@ -2104,7 +2133,7 @@ window.__ModuleLoader__.load({
|
|
|
2104
2133
|
const counts = planCounts(stats);
|
|
2105
2134
|
// 同一套计数与对账:柱状图的百分比、文案、色调都不得自成一套。
|
|
2106
2135
|
const percent = counts.percent ?? 0;
|
|
2107
|
-
const phase =
|
|
2136
|
+
const phase = sessionPhaseOf(session, counts);
|
|
2108
2137
|
const tone = phaseTone(phase);
|
|
2109
2138
|
return h('button', {
|
|
2110
2139
|
key: session.sessionId,
|
|
@@ -2179,7 +2208,7 @@ window.__ModuleLoader__.load({
|
|
|
2179
2208
|
* 这正是本次事故的现象:会话结束 4 小时后仍显示「进行中」。
|
|
2180
2209
|
*/
|
|
2181
2210
|
for (const session of activeSessions) {
|
|
2182
|
-
const phase =
|
|
2211
|
+
const phase = sessionPhaseOf(session);
|
|
2183
2212
|
if (phase === 'done')
|
|
2184
2213
|
finished.push(session);
|
|
2185
2214
|
else if (phase === 'ended')
|
|
@@ -2203,7 +2232,7 @@ window.__ModuleLoader__.load({
|
|
|
2203
2232
|
pending: 5,
|
|
2204
2233
|
ended: 6,
|
|
2205
2234
|
};
|
|
2206
|
-
const rank = (session) => phaseRank[
|
|
2235
|
+
const rank = (session) => phaseRank[sessionPhaseOf(session)] ?? 5;
|
|
2207
2236
|
live.sort((a, b) => (rank(a) - rank(b))
|
|
2208
2237
|
|| ((Number(b.createdAt) || 0) - (Number(a.createdAt) || 0))
|
|
2209
2238
|
|| String(a.sessionId).localeCompare(String(b.sessionId)));
|
|
@@ -2353,7 +2382,7 @@ window.__ModuleLoader__.load({
|
|
|
2353
2382
|
* 「侧栏已完成 / 对话里正在收尾」之间再次自相矛盾。
|
|
2354
2383
|
*/
|
|
2355
2384
|
const stats = session.stats || {};
|
|
2356
|
-
const phase =
|
|
2385
|
+
const phase = sessionPhaseOf(session);
|
|
2357
2386
|
const tone = phaseTone(phase);
|
|
2358
2387
|
return h('div', { className: `dsh-wp-turn dsh-wp-tone-${tone}` }, h('div', { className: 'dsh-wp-turn-title' }, h('span', null, session.title || t('panel')), h(Pill, { tone }, phaseLabel(phase, session, t))), h('div', { className: 'dsh-wp-muted', style: { marginTop: '6px' } }, `${t('helpWho')}:${workerText(session, t)}`), h('div', { className: 'dsh-wp-muted', style: { marginTop: '2px' } }, `${t('helpNext')}:${nextText(session, t)}`), h('div', { className: 'dsh-wp-progress-meta' }, h('span', null, `${stats.done ?? 0}/${stats.total ?? 0} ${t('stats.done')} · ${stats.blocked ?? 0} ${t('stats.blocked')}`), h('span', { className: 'dsh-wp-muted' }, t('viewHint'))));
|
|
2359
2388
|
}
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
# v1.8.4 — 「已结束」不再和「正在做」同屏
|
|
2
|
+
|
|
3
|
+
## 一句话
|
|
4
|
+
|
|
5
|
+
左侧栏「任务进度」曾把同一张卡片同时写成「已结束,可续跑 · 正在做」,而同一次运行还在真实推进脚本。
|
|
6
|
+
这一版让「结束」只按**真实的存活事实**判定:只要派发还在跑,卡片就不会宣布结束。
|
|
7
|
+
|
|
8
|
+
## 你会看到什么变化
|
|
9
|
+
|
|
10
|
+
| 之前 | 现在 |
|
|
11
|
+
|---|---|
|
|
12
|
+
| 徽标「已结束,可续跑 · 正在做」 | 派发在跑时显示真实阶段(如「正在做」);真的结束才显示「已结束」 |
|
|
13
|
+
| 「任务进度」卡一边宣告结束,展开后第 4 步仍写「正在做」 | 结束时会写明「本轮结束时这一步仍未完成,可以续跑」,不再残留「正在做」 |
|
|
14
|
+
| 同一张卡两个完成度:计数 73% / 加权 80% | 只有一个完成度,分组、环、展开页取同一个数 |
|
|
15
|
+
| 徽标承诺「可续跑」,卡片却不给方法 | 凡是说「可续跑」的地方,都给出「对主 Agent 说『续跑这个计划』…」以及剩余次数 |
|
|
16
|
+
|
|
17
|
+
## 根因(给需要复核的人)
|
|
18
|
+
|
|
19
|
+
计划结果由异步派发结算,而**派发可以跨过宿主回合结束**:事故会话里 `turn/end` 发生在
|
|
20
|
+
19:58:39,派发继续运行到 20:22:50 才写入结果。`serialisePlan` 只读取最后一个
|
|
21
|
+
`turn/start|turn/end` 事件判断「本轮是否结束」,从不读插件自己的存活信号
|
|
22
|
+
`record.dispatchPromise`,于是把「回合结束」误当成「没有东西在跑」,把阶段改写成
|
|
23
|
+
`ended`,而子任务状态仍是 `in_progress`——同屏的两句话从此互相打脸。
|
|
24
|
+
|
|
25
|
+
客户端还有三处加剧了矛盾:`planPhaseOf` 会用计数覆盖服务端阶段;`resumeHint` 只在
|
|
26
|
+
`phase === 'blocked'` 时给续跑指令,而徽标对 `ended` 也承诺「可续跑」;展开页用加权
|
|
27
|
+
百分比、分组与环用计数百分比。
|
|
28
|
+
|
|
29
|
+
## 修复内容
|
|
30
|
+
|
|
31
|
+
- `src/runtime.ts`:`serialisePlan` 先读 `record.dispatchPromise`;有活派发时不进入
|
|
32
|
+
`ended`,并把 `running` 随载荷下发。
|
|
33
|
+
- `src/runtime.ts`:回合真的结束且无活派发时,用 `settleStaleInflight` 把残留的
|
|
34
|
+
`in_progress` 改判 `blocked` 并附说明;**只改下发的副本**,内存记录不动,续跑仍从原地继续。
|
|
35
|
+
- `src/client.ts`:新增 `sessionPhaseOf`,`running === true` 时回退到原阶段,展示层不再
|
|
36
|
+
仅凭 `phase` 说「已结束」。
|
|
37
|
+
- `src/client.ts`:`resumeHint` 覆盖 `blocked` / `paused` / 可续跑的 `ended`;展开页与
|
|
38
|
+
分组统一使用计数百分比(删除 `planWeightedPercent`)。
|
|
39
|
+
- `src/plan.ts`:新增不变量 I11 —— `phase=ended` 且仍有 `in_progress` 时自检判红。
|
|
40
|
+
- 测试:新增 `tests/ended-live-dispatch.test.ts`(6 例,含回放路径、只改副本),
|
|
41
|
+
`tests/client-resume-hint.test.ts` 增 2 例(徽标与续跑说明必须同时成立;载荷说「还在跑」
|
|
42
|
+
时界面不得出现「已结束」)。全部 **196 项测试通过**。
|
|
43
|
+
|
|
44
|
+
## 升级
|
|
45
|
+
|
|
46
|
+
```bash
|
|
47
|
+
dsh plugin --profile web add dsh-workplan@1.8.4
|
|
48
|
+
```
|
|
49
|
+
|
|
50
|
+
插件在 `dsh web` 启动时加载,**升级后需重启一次 `dsh web` 才生效**(重启会中断正在运行的会话)。
|
|
51
|
+
历史计划不需要数据订正:面板按新规则重算,旧记录里「已结束 + 正在做」的组合不会再被渲染。
|
|
52
|
+
|
|
53
|
+
## 已知限制
|
|
54
|
+
|
|
55
|
+
- 「已结束」只代表**没有活派发**,不代表计划完成。没做完的计划仍会进入「已结束」分组并
|
|
56
|
+
标出受阻数——这是刻意的,用户需要看到「这一轮结束了,但事情没做完」。
|
|
57
|
+
- 存活信号只在同一进程内有效。若进程在派发中途被杀,记录里不会留下 `dispatchPromise`,
|
|
58
|
+
此时按「回合结束 + 残留 `in_progress`」收敛为受阻。
|
|
59
|
+
|
|
60
|
+
## 复核
|
|
61
|
+
|
|
62
|
+
```bash
|
|
63
|
+
npm run check && npm test # 196 项测试
|
|
64
|
+
npm run build && git diff --exit-code -- lib client.js # 生成物可复现
|
|
65
|
+
```
|
package/lib/host.js
CHANGED
package/lib/plan.js
CHANGED
|
@@ -1740,6 +1740,18 @@ export function aggregateInvariantViolations(snapshot, phase) {
|
|
|
1740
1740
|
violations.push(`I10 子任务 ${String(item?.subtaskId)} 状态为 in_progress 但 progress=${item?.progress}`);
|
|
1741
1741
|
}
|
|
1742
1742
|
}
|
|
1743
|
+
/*
|
|
1744
|
+
* [1.8.4] I11:「已结束」与「正在做」不能同屏。
|
|
1745
|
+
*
|
|
1746
|
+
* 本次事故截图(session-b83e4a75…,2026-10-30 20:06:33)里,同一张卡片既在
|
|
1747
|
+
* 「已结束」组、又在第 4 步写着「正在做」。根因是 `turn/end` 早于异步派发
|
|
1748
|
+
* 结束(派发又跑了近 4 分钟)。修复后 `ended` 只在「没有任何活派发」时才会
|
|
1749
|
+
* 出现,那时不可能还有子任务在跑;一旦这条关系被未来的改动破坏,
|
|
1750
|
+
* 这个断言会把具体计数带出来,而不是等用户截图发现。
|
|
1751
|
+
*/
|
|
1752
|
+
if (phase === 'ended' && stats.inProgress > 0) {
|
|
1753
|
+
violations.push(`I11 phase=ended 但仍有 ${stats.inProgress} 个子任务 in_progress(已结束与正在做同屏)`);
|
|
1754
|
+
}
|
|
1743
1755
|
return violations;
|
|
1744
1756
|
}
|
|
1745
1757
|
/**
|
package/lib/runtime.js
CHANGED
|
@@ -1048,8 +1048,47 @@ export function sessionTurnState(session) {
|
|
|
1048
1048
|
}
|
|
1049
1049
|
return { state: 'unknown', reason: null, reasonDetail: null, at: null };
|
|
1050
1050
|
}
|
|
1051
|
+
/*
|
|
1052
|
+
* [1.8.4] 回合已经结束 ⇒ 没有任何子任务还可能在跑。
|
|
1053
|
+
*
|
|
1054
|
+
* `turn/end` 之后仍残留 `in_progress` 只有两种来源:派发被进程退出/崩溃打断,
|
|
1055
|
+
* 或者某次状态写入没有配对收尾。无论哪种,把「正在做」原样留在载荷里都会让同一张
|
|
1056
|
+
* 卡片同时说出「已结束」和「正在做」(本次事故截图的第二处矛盾:卡片已经在
|
|
1057
|
+
* 「已结束」组里,第 4 步却写着「正在做」)。这里把这些条目改判为 `blocked`
|
|
1058
|
+
* (=需要人来续跑),保留原进度与已有错误说明,只在没有说明时补一句人话。
|
|
1059
|
+
*
|
|
1060
|
+
* 不引入 `Date.now()`:回放路径必须与实时路径给出同一结论,所以这份载荷
|
|
1061
|
+
* 只依赖输入数组,不依赖当前时间。
|
|
1062
|
+
*/
|
|
1063
|
+
const STALE_INFLIGHT_NOTE = '本轮结束时这一步仍未完成,没有拿到结果;可以续跑。';
|
|
1064
|
+
function settleStaleInflight(raw) {
|
|
1065
|
+
const list = Array.isArray(raw) ? raw : [];
|
|
1066
|
+
if (!list.some((item) => item?.status === 'in_progress'))
|
|
1067
|
+
return raw;
|
|
1068
|
+
return list.map((item) => item?.status === 'in_progress'
|
|
1069
|
+
? {
|
|
1070
|
+
...item,
|
|
1071
|
+
status: 'blocked',
|
|
1072
|
+
error: typeof item.error === 'string' && item.error.trim() !== '' ? item.error : STALE_INFLIGHT_NOTE,
|
|
1073
|
+
}
|
|
1074
|
+
: item);
|
|
1075
|
+
}
|
|
1051
1076
|
function serialisePlan(record, session) {
|
|
1052
1077
|
const plan = record.plan ?? null;
|
|
1078
|
+
/*
|
|
1079
|
+
* [1.8.4] 先问「此刻还有没有东西在跑」,再决定这份载荷允不允许宣告结束。
|
|
1080
|
+
*
|
|
1081
|
+
* `record.dispatchPromise` 是插件内部唯一的权威存活信号:派发时赋值,
|
|
1082
|
+
* `.finally()` 里置空(见 dispatchTool)。1.7.0 引入 async 派发后,宿主会在
|
|
1083
|
+
* 派发真正结束**之前**就写下 `turn/end`:事故截图里 20:06:33 卡片已经
|
|
1084
|
+
* 「已结束」,而同一计划的派发一直跑到 20:22:50 才写入结果消息。也就是说
|
|
1085
|
+
* 「回合结束」不等于「没有东西在跑」——把前者当成结束证据,就是本次
|
|
1086
|
+
* 「已结束 ∧ 正在做」的根因。存活信号在这里读一次,下面所有「收敛为 ended」
|
|
1087
|
+
* 的判断都必须经过它。
|
|
1088
|
+
*/
|
|
1089
|
+
const liveDispatch = Boolean(record.dispatchPromise);
|
|
1090
|
+
const turn = liveDispatch ? null : sessionTurnState(session);
|
|
1091
|
+
const turnEnded = turn?.state === 'ended';
|
|
1053
1092
|
/*
|
|
1054
1093
|
* Counts are derived here, once, from the very array that is shipped.
|
|
1055
1094
|
*
|
|
@@ -1059,11 +1098,12 @@ function serialisePlan(record, session) {
|
|
|
1059
1098
|
* built from `statuses` said otherwise. Deriving both from one normalised
|
|
1060
1099
|
* snapshot makes that contradiction structurally impossible.
|
|
1061
1100
|
*/
|
|
1062
|
-
const
|
|
1101
|
+
const rawStatuses = Array.isArray(record.statuses) && record.statuses.length > 0
|
|
1063
1102
|
? record.statuses
|
|
1064
1103
|
: plan
|
|
1065
1104
|
? createStatuses(plan)
|
|
1066
|
-
: []
|
|
1105
|
+
: [];
|
|
1106
|
+
const snapshot = derivePlanSnapshot(turnEnded ? settleStaleInflight(rawStatuses) : rawStatuses);
|
|
1067
1107
|
const statuses = snapshot.statuses;
|
|
1068
1108
|
const stats = snapshot.stats;
|
|
1069
1109
|
/*
|
|
@@ -1093,23 +1133,24 @@ function serialisePlan(record, session) {
|
|
|
1093
1133
|
* 重新开始(日志里出现新的 turn/start),下一份 payload 自然回到原来的
|
|
1094
1134
|
* 派发状态,不需要任何反向迁移逻辑;
|
|
1095
1135
|
* - 实时路径与回放路径都经过本函数,因此刷新前后结论必然一致(T4 硬约束)。
|
|
1136
|
+
*
|
|
1137
|
+
* [1.8.4] 前置门:只有 `turnEnded && !liveDispatch` 才准许收敛。存活信号为真时
|
|
1138
|
+
* 「回合已结束」仅仅说明宿主本轮不再收新消息,派发仍在跑,卡片必须继续显示
|
|
1139
|
+
* 真实阶段(正在做 / 预算用完),不许降级成 ended。
|
|
1096
1140
|
*/
|
|
1097
1141
|
let suspendedPhase = null;
|
|
1098
1142
|
let endReason = null;
|
|
1099
1143
|
let endReasonDetail = null;
|
|
1100
1144
|
let endedAt = null;
|
|
1101
|
-
if (phase !== 'done' && phase !== 'cancelled') {
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
1107
|
-
endedAt = turn.at;
|
|
1108
|
-
phase = 'ended';
|
|
1109
|
-
}
|
|
1145
|
+
if (turnEnded && phase !== 'done' && phase !== 'cancelled') {
|
|
1146
|
+
suspendedPhase = phase;
|
|
1147
|
+
endReason = turn.reason;
|
|
1148
|
+
endReasonDetail = turn.reasonDetail;
|
|
1149
|
+
endedAt = turn.at;
|
|
1150
|
+
phase = 'ended';
|
|
1110
1151
|
}
|
|
1111
1152
|
/*
|
|
1112
|
-
* 每次真正下发前跑一遍跨字段不变量(I1–
|
|
1153
|
+
* 每次真正下发前跑一遍跨字段不变量(I1–I11)。正常情况下恒为空;一旦某个
|
|
1113
1154
|
* 未来改动重新引入「进度与状态打架」,这里会把它连同具体字段值一起带出去,
|
|
1114
1155
|
* 而不是等用户截图发现。附在 payload 上而不是抛错:展示层不应因自检而白屏。
|
|
1115
1156
|
*/
|
|
@@ -1136,6 +1177,15 @@ function serialisePlan(record, session) {
|
|
|
1136
1177
|
* tell whether dispatch would actually run anything.
|
|
1137
1178
|
*/
|
|
1138
1179
|
heartbeatAt: record.heartbeatAt ?? null,
|
|
1180
|
+
/*
|
|
1181
|
+
* [1.8.4] 存活事实跟着载荷一起下发。
|
|
1182
|
+
*
|
|
1183
|
+
* 之前只有模型侧 tool 结果带 `running`,面板拿不到,只能靠 `phase` 猜
|
|
1184
|
+
* 「有没有东西在跑」;而 phase 既可能滞后(派发已结束、状态没回写),
|
|
1185
|
+
* 也可能过早(回合结束、派发还在跑)。把存活信号原样交给展示层,
|
|
1186
|
+
* 「已结束」与「正在做」就不可能再从两条互不知情的数据里各说各话。
|
|
1187
|
+
*/
|
|
1188
|
+
running: liveDispatch,
|
|
1139
1189
|
resumeCount: Number(record.resumeCount ?? 0),
|
|
1140
1190
|
resumeLimit: Number(record.resumeLimit ?? MAX_PLAN_RESUMES),
|
|
1141
1191
|
resumeAvailable: record.plan
|
package/package.json
CHANGED
package/src/client.ts
CHANGED
|
@@ -185,7 +185,7 @@ window.__ModuleLoader__.load({
|
|
|
185
185
|
"scopeAll": "当前各会话最新计划汇总",
|
|
186
186
|
"scopeThis": "本计划",
|
|
187
187
|
"vizStageTitle": "分步进度",
|
|
188
|
-
"
|
|
188
|
+
"vizOverall": "总体进度",
|
|
189
189
|
"allPlansHint": "上面是当前各会话最新计划的合计;历史计划不在此汇总,下面每张卡片只统计本计划。",
|
|
190
190
|
"openHint": "打开左侧「任务进度」看完整安排。"
|
|
191
191
|
},
|
|
@@ -356,7 +356,7 @@ window.__ModuleLoader__.load({
|
|
|
356
356
|
"scopeAll": "Latest plan per live session",
|
|
357
357
|
"scopeThis": "This plan",
|
|
358
358
|
"vizStageTitle": "Step progress",
|
|
359
|
-
"
|
|
359
|
+
"vizOverall": "Overall progress",
|
|
360
360
|
"allPlansHint": "These totals cover the latest plan in each live session; older plans are not included. Each card below counts only its own plan.",
|
|
361
361
|
"openHint": "Open “Task progress” on the left for the full plan."
|
|
362
362
|
}
|
|
@@ -1128,7 +1128,20 @@ window.__ModuleLoader__.load({
|
|
|
1128
1128
|
* build a fresh plan. Say out loud how to resume instead.
|
|
1129
1129
|
*/
|
|
1130
1130
|
function resumeHint(session: any, t: any) {
|
|
1131
|
-
|
|
1131
|
+
/*
|
|
1132
|
+
* [1.8.4] 谁承诺「可续跑」,谁就必须给出续跑方法。
|
|
1133
|
+
*
|
|
1134
|
+
* 旧实现只在 `phase === 'blocked'` 时给指令,而徽标在 ended 状态下拼的是
|
|
1135
|
+
* 「已结束,可续跑 · 卡住了」——同一张卡一边承诺能续跑,一边返回空字符串
|
|
1136
|
+
* 不给任何操作,这是事故截图里的第三处自相矛盾(T3 的互斥证据)。
|
|
1137
|
+
* 现在凡是徽标会说出「可续跑」的阶段(blocked / paused / ended 且原阶段
|
|
1138
|
+
* 是这类可续跑状态),一律给出同样的续跑指令。
|
|
1139
|
+
*/
|
|
1140
|
+
if (!session) return ''
|
|
1141
|
+
const phase = String(session.phase ?? '')
|
|
1142
|
+
const suspended = String(session.suspendedPhase ?? '')
|
|
1143
|
+
const resumable = phase === 'blocked' || phase === 'paused' || (phase === 'ended' && (suspended === '' || suspended === 'blocked' || suspended === 'paused' || suspended === 'executing' || suspended === 'planning'))
|
|
1144
|
+
if (!resumable) return ''
|
|
1132
1145
|
if (session.resumeAvailable) {
|
|
1133
1146
|
const limit = Number(session.resumeLimit ?? 0)
|
|
1134
1147
|
const used = Number(session.resumeCount ?? 0)
|
|
@@ -1609,15 +1622,22 @@ window.__ModuleLoader__.load({
|
|
|
1609
1622
|
}
|
|
1610
1623
|
|
|
1611
1624
|
/*
|
|
1612
|
-
* [1.
|
|
1625
|
+
* [1.8.4] 一张卡片的阶段只能有一个结论,且必须让「存活事实」拥有否决权。
|
|
1613
1626
|
*
|
|
1614
|
-
*
|
|
1615
|
-
*
|
|
1627
|
+
* 事故截图(2026-10-30 20:06:33)里同一张卡在「已结束」组,第 4 步却写着
|
|
1628
|
+
* 「正在做」。根因在后端(`turn/end` 早于异步派发结束),但展示层同样要能
|
|
1629
|
+
* 自保:服务端现在把 `running` 一起下发,这里据此兜一层——载荷同时说
|
|
1630
|
+
* 「已结束」和「派发仍在跑」时,以存活事实为准,绝不渲染「已结束」。
|
|
1631
|
+
* 老载荷没有 `running` 字段(undefined),行为保持原样。
|
|
1616
1632
|
*/
|
|
1617
|
-
function
|
|
1618
|
-
const
|
|
1619
|
-
|
|
1620
|
-
|
|
1633
|
+
function sessionPhaseOf(session: any, counts?: PlanCounts): string {
|
|
1634
|
+
const resolved = counts ?? planCounts(session?.stats || {})
|
|
1635
|
+
const phase = planPhaseOf(session?.phase || 'pending', resolved)
|
|
1636
|
+
if (phase === 'ended' && session?.running === true) {
|
|
1637
|
+
const suspended = String(session?.suspendedPhase ?? '')
|
|
1638
|
+
return suspended !== '' && suspended !== 'ended' ? suspended : 'executing'
|
|
1639
|
+
}
|
|
1640
|
+
return phase
|
|
1621
1641
|
}
|
|
1622
1642
|
|
|
1623
1643
|
function planStatusMap(statuses: any): Map<string, any> {
|
|
@@ -1858,7 +1878,7 @@ window.__ModuleLoader__.load({
|
|
|
1858
1878
|
)
|
|
1859
1879
|
}
|
|
1860
1880
|
|
|
1861
|
-
// 展开后的「分步进度」:逐阶段行 +
|
|
1881
|
+
// 展开后的「分步进度」:逐阶段行 + 总体进度(与环/组头同一个计数口径)。
|
|
1862
1882
|
function PlanOverview({ t, stats, counts, rows }: { t: (key: string) => string; stats: any; counts: PlanCounts; rows: PlanStageRow[] }) {
|
|
1863
1883
|
const stateOf = (tone: PlanTone): string => (tone === 'done'
|
|
1864
1884
|
? t('stats.done')
|
|
@@ -1873,7 +1893,15 @@ window.__ModuleLoader__.load({
|
|
|
1873
1893
|
h('span', null, `${counts.done}/${counts.total} ${t('stats.done')}`),
|
|
1874
1894
|
),
|
|
1875
1895
|
h('div', { className: 'dsh-wp-planoverview-stats' },
|
|
1876
|
-
|
|
1896
|
+
/*
|
|
1897
|
+
* [1.8.4] 一张卡只允许一个百分比口径。
|
|
1898
|
+
*
|
|
1899
|
+
* 这里以前显示加权进度,卡片其余位置显示计数百分比,于是同一张卡同时
|
|
1900
|
+
* 出现「73%」(环、组头、本计划 11/15)和「总体进度(加权)80%」——
|
|
1901
|
+
* 两者都算得对,但用户看到的是自相矛盾(T3 实测)。展示口径统一为
|
|
1902
|
+
* 计数百分比:它就是环、组头、图例共用的那个数,也是用户能数出来的数。
|
|
1903
|
+
*/
|
|
1904
|
+
h('span', null, `${t('vizOverall')} ${counts.percent === null ? '—' : `${counts.percent}%`}`),
|
|
1877
1905
|
h('span', null, `${counts.active} ${t('stats.inProgress')} · ${counts.pending} ${t('stats.pending')}`),
|
|
1878
1906
|
counts.blocked > 0 ? h('span', null, `${counts.blocked} ${t('stats.blocked')}`) : null,
|
|
1879
1907
|
),
|
|
@@ -1916,7 +1944,7 @@ window.__ModuleLoader__.load({
|
|
|
1916
1944
|
* 胶囊就必须是「已完成」,视觉档位也必须是 done。截图里那张卡之所以
|
|
1917
1945
|
* 「100% + 正在收尾 + 留在进行中组」,就是因为这三个读者各读各的字段。
|
|
1918
1946
|
*/
|
|
1919
|
-
const phase =
|
|
1947
|
+
const phase = sessionPhaseOf(session, counts)
|
|
1920
1948
|
const tone = phaseTone(phase)
|
|
1921
1949
|
const departments = Array.isArray(session.departments) ? session.departments : []
|
|
1922
1950
|
const statuses = Array.isArray(session.statuses) ? session.statuses : []
|
|
@@ -2389,7 +2417,7 @@ window.__ModuleLoader__.load({
|
|
|
2389
2417
|
const counts = planCounts(stats)
|
|
2390
2418
|
// 同一套计数与对账:柱状图的百分比、文案、色调都不得自成一套。
|
|
2391
2419
|
const percent = counts.percent ?? 0
|
|
2392
|
-
const phase =
|
|
2420
|
+
const phase = sessionPhaseOf(session, counts)
|
|
2393
2421
|
const tone = phaseTone(phase)
|
|
2394
2422
|
return h('button', {
|
|
2395
2423
|
key: session.sessionId,
|
|
@@ -2477,7 +2505,7 @@ window.__ModuleLoader__.load({
|
|
|
2477
2505
|
* 这正是本次事故的现象:会话结束 4 小时后仍显示「进行中」。
|
|
2478
2506
|
*/
|
|
2479
2507
|
for (const session of activeSessions) {
|
|
2480
|
-
const phase =
|
|
2508
|
+
const phase = sessionPhaseOf(session)
|
|
2481
2509
|
if (phase === 'done') finished.push(session)
|
|
2482
2510
|
else if (phase === 'ended') ended.push(session)
|
|
2483
2511
|
else live.push(session)
|
|
@@ -2498,7 +2526,7 @@ window.__ModuleLoader__.load({
|
|
|
2498
2526
|
pending: 5,
|
|
2499
2527
|
ended: 6,
|
|
2500
2528
|
}
|
|
2501
|
-
const rank = (session: any) => phaseRank[
|
|
2529
|
+
const rank = (session: any) => phaseRank[sessionPhaseOf(session)] ?? 5
|
|
2502
2530
|
live.sort((a: any, b: any) => (rank(a) - rank(b))
|
|
2503
2531
|
|| ((Number(b.createdAt) || 0) - (Number(a.createdAt) || 0))
|
|
2504
2532
|
|| String(a.sessionId).localeCompare(String(b.sessionId)))
|
|
@@ -2667,7 +2695,7 @@ window.__ModuleLoader__.load({
|
|
|
2667
2695
|
* 「侧栏已完成 / 对话里正在收尾」之间再次自相矛盾。
|
|
2668
2696
|
*/
|
|
2669
2697
|
const stats = session.stats || {}
|
|
2670
|
-
const phase =
|
|
2698
|
+
const phase = sessionPhaseOf(session)
|
|
2671
2699
|
const tone = phaseTone(phase)
|
|
2672
2700
|
return h('div', { className: `dsh-wp-turn dsh-wp-tone-${tone}` },
|
|
2673
2701
|
h('div', { className: 'dsh-wp-turn-title' },
|
package/src/host.ts
CHANGED
|
@@ -408,7 +408,7 @@ export function apply(ctx: any, config: WorkplanConfig = {}) {
|
|
|
408
408
|
|
|
409
409
|
export const meta = {
|
|
410
410
|
name,
|
|
411
|
-
version: '1.8.
|
|
411
|
+
version: '1.8.4',
|
|
412
412
|
promptOrder: PROMPT_ORDER,
|
|
413
413
|
routes: ['/dsh-workplan/plans', '/dsh-workplan/vendor/chart.umd.js'],
|
|
414
414
|
}
|
package/src/plan.ts
CHANGED
|
@@ -1832,6 +1832,18 @@ export function aggregateInvariantViolations(snapshot: PlanSnapshot, phase?: any
|
|
|
1832
1832
|
violations.push(`I10 子任务 ${String(item?.subtaskId)} 状态为 in_progress 但 progress=${item?.progress}`)
|
|
1833
1833
|
}
|
|
1834
1834
|
}
|
|
1835
|
+
/*
|
|
1836
|
+
* [1.8.4] I11:「已结束」与「正在做」不能同屏。
|
|
1837
|
+
*
|
|
1838
|
+
* 本次事故截图(session-b83e4a75…,2026-10-30 20:06:33)里,同一张卡片既在
|
|
1839
|
+
* 「已结束」组、又在第 4 步写着「正在做」。根因是 `turn/end` 早于异步派发
|
|
1840
|
+
* 结束(派发又跑了近 4 分钟)。修复后 `ended` 只在「没有任何活派发」时才会
|
|
1841
|
+
* 出现,那时不可能还有子任务在跑;一旦这条关系被未来的改动破坏,
|
|
1842
|
+
* 这个断言会把具体计数带出来,而不是等用户截图发现。
|
|
1843
|
+
*/
|
|
1844
|
+
if (phase === 'ended' && stats.inProgress > 0) {
|
|
1845
|
+
violations.push(`I11 phase=ended 但仍有 ${stats.inProgress} 个子任务 in_progress(已结束与正在做同屏)`)
|
|
1846
|
+
}
|
|
1835
1847
|
|
|
1836
1848
|
return violations
|
|
1837
1849
|
}
|
package/src/runtime.ts
CHANGED
|
@@ -1060,8 +1060,49 @@ export function sessionTurnState(session: any) {
|
|
|
1060
1060
|
return { state: 'unknown', reason: null, reasonDetail: null, at: null }
|
|
1061
1061
|
}
|
|
1062
1062
|
|
|
1063
|
+
/*
|
|
1064
|
+
* [1.8.4] 回合已经结束 ⇒ 没有任何子任务还可能在跑。
|
|
1065
|
+
*
|
|
1066
|
+
* `turn/end` 之后仍残留 `in_progress` 只有两种来源:派发被进程退出/崩溃打断,
|
|
1067
|
+
* 或者某次状态写入没有配对收尾。无论哪种,把「正在做」原样留在载荷里都会让同一张
|
|
1068
|
+
* 卡片同时说出「已结束」和「正在做」(本次事故截图的第二处矛盾:卡片已经在
|
|
1069
|
+
* 「已结束」组里,第 4 步却写着「正在做」)。这里把这些条目改判为 `blocked`
|
|
1070
|
+
* (=需要人来续跑),保留原进度与已有错误说明,只在没有说明时补一句人话。
|
|
1071
|
+
*
|
|
1072
|
+
* 不引入 `Date.now()`:回放路径必须与实时路径给出同一结论,所以这份载荷
|
|
1073
|
+
* 只依赖输入数组,不依赖当前时间。
|
|
1074
|
+
*/
|
|
1075
|
+
const STALE_INFLIGHT_NOTE = '本轮结束时这一步仍未完成,没有拿到结果;可以续跑。'
|
|
1076
|
+
function settleStaleInflight(raw: any): any {
|
|
1077
|
+
const list = Array.isArray(raw) ? raw : []
|
|
1078
|
+
if (!list.some((item: any) => item?.status === 'in_progress')) return raw
|
|
1079
|
+
return list.map((item: any) =>
|
|
1080
|
+
item?.status === 'in_progress'
|
|
1081
|
+
? {
|
|
1082
|
+
...item,
|
|
1083
|
+
status: 'blocked',
|
|
1084
|
+
error: typeof item.error === 'string' && item.error.trim() !== '' ? item.error : STALE_INFLIGHT_NOTE,
|
|
1085
|
+
}
|
|
1086
|
+
: item
|
|
1087
|
+
)
|
|
1088
|
+
}
|
|
1089
|
+
|
|
1063
1090
|
function serialisePlan(record: any, session: any) {
|
|
1064
1091
|
const plan = record.plan ?? null
|
|
1092
|
+
/*
|
|
1093
|
+
* [1.8.4] 先问「此刻还有没有东西在跑」,再决定这份载荷允不允许宣告结束。
|
|
1094
|
+
*
|
|
1095
|
+
* `record.dispatchPromise` 是插件内部唯一的权威存活信号:派发时赋值,
|
|
1096
|
+
* `.finally()` 里置空(见 dispatchTool)。1.7.0 引入 async 派发后,宿主会在
|
|
1097
|
+
* 派发真正结束**之前**就写下 `turn/end`:事故截图里 20:06:33 卡片已经
|
|
1098
|
+
* 「已结束」,而同一计划的派发一直跑到 20:22:50 才写入结果消息。也就是说
|
|
1099
|
+
* 「回合结束」不等于「没有东西在跑」——把前者当成结束证据,就是本次
|
|
1100
|
+
* 「已结束 ∧ 正在做」的根因。存活信号在这里读一次,下面所有「收敛为 ended」
|
|
1101
|
+
* 的判断都必须经过它。
|
|
1102
|
+
*/
|
|
1103
|
+
const liveDispatch = Boolean(record.dispatchPromise)
|
|
1104
|
+
const turn = liveDispatch ? null : sessionTurnState(session)
|
|
1105
|
+
const turnEnded = turn?.state === 'ended'
|
|
1065
1106
|
/*
|
|
1066
1107
|
* Counts are derived here, once, from the very array that is shipped.
|
|
1067
1108
|
*
|
|
@@ -1071,13 +1112,13 @@ function serialisePlan(record: any, session: any) {
|
|
|
1071
1112
|
* built from `statuses` said otherwise. Deriving both from one normalised
|
|
1072
1113
|
* snapshot makes that contradiction structurally impossible.
|
|
1073
1114
|
*/
|
|
1074
|
-
const
|
|
1115
|
+
const rawStatuses =
|
|
1075
1116
|
Array.isArray(record.statuses) && record.statuses.length > 0
|
|
1076
1117
|
? record.statuses
|
|
1077
1118
|
: plan
|
|
1078
1119
|
? createStatuses(plan)
|
|
1079
1120
|
: []
|
|
1080
|
-
)
|
|
1121
|
+
const snapshot = derivePlanSnapshot(turnEnded ? settleStaleInflight(rawStatuses) : rawStatuses)
|
|
1081
1122
|
const statuses = snapshot.statuses
|
|
1082
1123
|
const stats = snapshot.stats
|
|
1083
1124
|
/*
|
|
@@ -1107,23 +1148,24 @@ function serialisePlan(record: any, session: any) {
|
|
|
1107
1148
|
* 重新开始(日志里出现新的 turn/start),下一份 payload 自然回到原来的
|
|
1108
1149
|
* 派发状态,不需要任何反向迁移逻辑;
|
|
1109
1150
|
* - 实时路径与回放路径都经过本函数,因此刷新前后结论必然一致(T4 硬约束)。
|
|
1151
|
+
*
|
|
1152
|
+
* [1.8.4] 前置门:只有 `turnEnded && !liveDispatch` 才准许收敛。存活信号为真时
|
|
1153
|
+
* 「回合已结束」仅仅说明宿主本轮不再收新消息,派发仍在跑,卡片必须继续显示
|
|
1154
|
+
* 真实阶段(正在做 / 预算用完),不许降级成 ended。
|
|
1110
1155
|
*/
|
|
1111
1156
|
let suspendedPhase: any = null
|
|
1112
1157
|
let endReason: any = null
|
|
1113
1158
|
let endReasonDetail: any = null
|
|
1114
1159
|
let endedAt: any = null
|
|
1115
|
-
if (phase !== 'done' && phase !== 'cancelled') {
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
endedAt = turn.at
|
|
1122
|
-
phase = 'ended'
|
|
1123
|
-
}
|
|
1160
|
+
if (turnEnded && phase !== 'done' && phase !== 'cancelled') {
|
|
1161
|
+
suspendedPhase = phase
|
|
1162
|
+
endReason = turn.reason
|
|
1163
|
+
endReasonDetail = turn.reasonDetail
|
|
1164
|
+
endedAt = turn.at
|
|
1165
|
+
phase = 'ended'
|
|
1124
1166
|
}
|
|
1125
1167
|
/*
|
|
1126
|
-
* 每次真正下发前跑一遍跨字段不变量(I1–
|
|
1168
|
+
* 每次真正下发前跑一遍跨字段不变量(I1–I11)。正常情况下恒为空;一旦某个
|
|
1127
1169
|
* 未来改动重新引入「进度与状态打架」,这里会把它连同具体字段值一起带出去,
|
|
1128
1170
|
* 而不是等用户截图发现。附在 payload 上而不是抛错:展示层不应因自检而白屏。
|
|
1129
1171
|
*/
|
|
@@ -1150,6 +1192,15 @@ function serialisePlan(record: any, session: any) {
|
|
|
1150
1192
|
* tell whether dispatch would actually run anything.
|
|
1151
1193
|
*/
|
|
1152
1194
|
heartbeatAt: record.heartbeatAt ?? null,
|
|
1195
|
+
/*
|
|
1196
|
+
* [1.8.4] 存活事实跟着载荷一起下发。
|
|
1197
|
+
*
|
|
1198
|
+
* 之前只有模型侧 tool 结果带 `running`,面板拿不到,只能靠 `phase` 猜
|
|
1199
|
+
* 「有没有东西在跑」;而 phase 既可能滞后(派发已结束、状态没回写),
|
|
1200
|
+
* 也可能过早(回合结束、派发还在跑)。把存活信号原样交给展示层,
|
|
1201
|
+
* 「已结束」与「正在做」就不可能再从两条互不知情的数据里各说各话。
|
|
1202
|
+
*/
|
|
1203
|
+
running: liveDispatch,
|
|
1153
1204
|
resumeCount: Number(record.resumeCount ?? 0),
|
|
1154
1205
|
resumeLimit: Number(record.resumeLimit ?? MAX_PLAN_RESUMES),
|
|
1155
1206
|
resumeAvailable: record.plan
|