dsh-workplan 1.5.1 → 1.6.0

package/src/client.ts

@@ -20,21 +20,26 @@ window.__ModuleLoader__.load({
         "panel": "任务进度",
         "groupLive": "进行中",
         "groupDone": "已完成",
+        "groupEnded": "已结束",
         "groupLiveHint": "还没结束，正在或即将推进",
         "groupDoneHint": "已全部完成并收尾",
+        "groupEndedHint": "这一轮已经停了，没有东西在跑；说「续跑」可继续推进",
         "groupCollapse": "收起",
         "groupExpand": "展开",
         "groupNeeds": "需处理",
         "groupLiveEmpty": "没有进行中的任务",
         "groupDoneEmpty": "还没有完成的任务",
+        "groupEndedEmpty": "没有已结束但未完成的任务",
         "groupSummary": "未完成 {open} / 已完成 {done}（完成率 {pct}%）",
         "groupSummaryNoRate": "未完成 {open} / 已完成 {done}（完成率暂无数据）",
         "groupAria": "{title}组，{plans} 个计划，共 {total} 件具体工作，已完成 {done} 件，完成率 {pct}%。其中正在做 {active} 件、卡住 {blocked} 件、还没开始 {pending} 件。",
         "groupAriaEmpty": "{title}组，{plans} 个计划，暂无具体工作项。",
         "groupPlansLabel": "个计划",
-        "chartGroups": "两类计划数量占比",
-        "chartLive": "进行中计划完成度（按工作项）",
-        "chartMore": "另有 {n} 个进行中计划未画入图表",
+        "chartGroups": "计划数量与完成情况",
+        "chartOpen": "未结束",
+        "chartDone": "已完成",
+        "chartLive": "未完成计划的完成度（按工作项）",
+        "chartMore": "另有 {n} 个未完成计划未画入图表",
 
         "title": "任务进度：一眼看懂",
         "subtitle": "用大白话说明：现在要做什么、谁在做、做到哪一步、接下来做什么。",
@@ -45,6 +50,9 @@ window.__ModuleLoader__.load({
         "helpNobody": "还没开始",
         "helpDone": "都做完了",
         "helpNextDone": "没有下一步，这件事已完成",
+        "helpWaitActive": "等这一步做完，再继续下一项",
+        "helpNoPlan": "还没有安排任何工作",
+        "nowRemaining": "还剩 {n} 项",
         "helpHint": "负责团队 = 谁来做；具体工作 = 要完成的一件事；卡住了 = 需要人处理。",
         "handleBlocked": "先处理",
         "resumeReady": "对主 Agent 说「续跑这个计划」，会从受阻处继续（已完成的不重跑）",
@@ -66,7 +74,8 @@ window.__ModuleLoader__.load({
           "blocked": "卡住了",
           "paused": "预算用完，可续跑",
           "degraded": "安排失败",
-          "cancelled": "已取消"
+          "cancelled": "已取消",
+          "ended": "已结束，可续跑"
         },
         "status": {
           "pending": "还没开始",
@@ -182,6 +191,7 @@ window.__ModuleLoader__.load({
       "en": {
         "groupLive": "In progress",
         "groupDone": "Completed",
+        "groupEnded": "Ended",
         "groupLiveHint": "Not finished yet — running or about to run",
         "groupDoneHint": "All work finished and wrapped up",
         "groupCollapse": "Collapse",
@@ -189,14 +199,17 @@ window.__ModuleLoader__.load({
         "groupNeeds": "needs attention",
         "groupLiveEmpty": "No work in progress",
         "groupDoneEmpty": "Nothing completed yet",
+        "groupEndedEmpty": "No ended-but-unfinished plans",
         "groupSummary": "Open {open} / done {done} ({pct}% complete)",
         "groupSummaryNoRate": "Open {open} / done {done} (completion rate unavailable)",
         "groupAria": "{title} group: {plans} plan(s), {total} work item(s), {done} done, {pct}% complete. Right now {active} in progress, {blocked} blocked, {pending} not started.",
         "groupAriaEmpty": "{title} group: {plans} plan(s), no work items yet.",
         "groupPlansLabel": "plan(s)",
-        "chartGroups": "Plan count by group",
-        "chartLive": "In-progress plans by work item",
-        "chartMore": "{n} more in-progress plans not drawn",
+        "chartGroups": "Plan count and completion",
+        "chartOpen": "Open",
+        "chartDone": "Completed",
+        "chartLive": "Open plans by work item",
+        "chartMore": "{n} more open plans not drawn",
         "panel": "Task progress",
         "title": "Task progress at a glance",
         "subtitle": "Plain language: what this is, who is doing it, how far along it is, and what happens next.",
@@ -207,6 +220,9 @@ window.__ModuleLoader__.load({
         "helpNobody": "Not started yet",
         "helpDone": "Everything is done",
         "helpNextDone": "Nothing next; this task is complete",
+        "helpWaitActive": "Wait for this step to finish, then continue",
+        "helpNoPlan": "No work has been scheduled yet",
+        "nowRemaining": "{n} item(s) left",
         "helpHint": "Team = who does it; work item = one thing to finish; stuck = a person needs to help.",
         "handleBlocked": "Fix first",
         "resumeReady": "Tell the main agent to resume this plan; it continues from the blocked step without re-running finished work",
@@ -228,7 +244,8 @@ window.__ModuleLoader__.load({
           "blocked": "Stuck",
           "paused": "Paused (budget spent)",
           "degraded": "Planning failed",
-          "cancelled": "Cancelled"
+          "cancelled": "Cancelled",
+          "ended": "Ended (resumable)"
         },
         "status": {
           "pending": "Not started",
@@ -399,6 +416,7 @@ window.__ModuleLoader__.load({
 .dsh-wp-group::before { content: ''; position: absolute; inset: 0 auto 0 0; width: 4px; }
 .dsh-wp-group--live::before { background: linear-gradient(180deg, #fb923c, #f97316); }
 .dsh-wp-group--done::before { background: linear-gradient(180deg, #38bdf8, #0284c7); }
+.dsh-wp-group--ended::before { background: linear-gradient(180deg, #94a3b8, #64748b); }
 /* T6 — 组头多出一行完成度摘要，底部内边距 10px → 6px，两组仍在同一屏内读完。 */
 .dsh-wp-group-head { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; padding: 0 4px 6px; }
 .dsh-wp-group-head--btn { width: 100%; background: none; border: 0; color: inherit; font: inherit; text-align: left; cursor: pointer; border-radius: 8px; }
@@ -425,6 +443,8 @@ window.__ModuleLoader__.load({
 .dsh-wp-group-dot { width: 9px; height: 9px; border-radius: 50%; flex: none; }
 .dsh-wp-group--live .dsh-wp-group-dot { background: #f97316; box-shadow: 0 0 0 4px rgba(249,115,22,.16); animation: dsh-wp-pulse 1.8s ease-in-out infinite; }
 .dsh-wp-group--done .dsh-wp-group-dot { background: #0ea5e9; box-shadow: 0 0 0 4px rgba(14,165,233,.14); }
+/* [1.6.0] 已结束：灰点、不脉冲——"没有东西在跑"这件事不允许用动画表达。 */
+.dsh-wp-group--ended .dsh-wp-group-dot { background: #94a3b8; box-shadow: 0 0 0 4px rgba(148,163,184,.16); }
 .dsh-wp-group-title { font-size: 15px; font-weight: 700; letter-spacing: .2px; color: var(--dsw-alias-label-primary, #0f172a); }
 /* 设计稿 §6.1：橙 #f97316 / 白 ≈2.8:1、蓝 #0ea5e9 / 白 ≈2.77:1，均不足 4.5:1，
    15px 粗体也不算法定「大字号」，所以组头一律用主文本色；品牌色只做「面」——
@@ -433,6 +453,7 @@ window.__ModuleLoader__.load({
 .dsh-wp-group-count { min-width: 22px; padding: 0 7px; height: 20px; border-radius: 999px; font-size: 12px; font-weight: 700; display: inline-flex; align-items: center; justify-content: center; color: var(--dsw-alias-label-primary, #0f172a); font-variant-numeric: tabular-nums; }
 .dsh-wp-group--live .dsh-wp-group-count { background: rgba(249,115,22,.14); box-shadow: inset 0 0 0 1px rgba(249,115,22,.34); }
 .dsh-wp-group--done .dsh-wp-group-count { background: rgba(14,165,233,.14); box-shadow: inset 0 0 0 1px rgba(14,165,233,.34); }
+.dsh-wp-group--ended .dsh-wp-group-count { background: rgba(148,163,184,.16); box-shadow: inset 0 0 0 1px rgba(148,163,184,.36); }
 /* WCAG AA：错误色叠 12% 红底后，浅色 #ec1313 只有 3.70:1；与主文本色混合 20%
    让浅色变深、深色变浅，两套主题都 ≥4.5:1（实测 5.16:1 / 5.67:1）。 */
 .dsh-wp-group-alert { font-size: 12px; font-weight: 650; color: var(--dsw-alias-state-error-primary, #ef4444); color: color-mix(in srgb, var(--dsw-alias-state-error-primary, #ef4444) 80%, var(--dsw-alias-label-primary, #0f172a) 20%); background: rgba(239,68,68,.12); padding: 1px 8px; border-radius: 999px; }
@@ -745,6 +766,7 @@ window.__ModuleLoader__.load({
 .dsh-wp-group::before { content: ''; position: absolute; left: 0; top: 14px; bottom: 14px; width: 3px; border-radius: 0 3px 3px 0; opacity: .9; }
 .dsh-wp-group--live::before { background: linear-gradient(180deg, #fbbf24, #ea580c); }
 .dsh-wp-group--done::before { background: linear-gradient(180deg, #7dd3fc, #0369a1); }
+.dsh-wp-group--ended::before { background: linear-gradient(180deg, #cbd5e1, #94a3b8); }
 .dsh-wp-group--done { opacity: .97; }
 .dsh-wp-group-head--btn { transition: background-color .16s ease; }
 .dsh-wp-group-head--btn:hover { background: rgba(148,163,184,.10); }
@@ -976,12 +998,33 @@ window.__ModuleLoader__.load({
 
     function phaseTone(phase: any) {
       if (phase === 'blocked') return 'blocked'
+      /*
+       * [1.6.0] `ended` = 这一轮停了，但计划没做完。它既不是成功（done），也不能
+       * 冒充正在干活（active）；用中性 idle 色，卡在哪由二级徽标 suspendedPhase 说明。
+       */
+      if (phase === 'ended') return 'idle'
       if (phase === 'degraded' || phase === 'cancelled' || phase === 'paused') return 'warn'
       if (phase === 'integrating' || phase === 'done') return 'done'
       if (phase === 'executing' || phase === 'planning') return 'active'
       return 'idle'
     }
 
+    /*
+     * [1.6.0] 「已结束」徽标要把「停在哪儿」一起说出来。
+     *
+     * 只说「已结束，可续跑」，用户不知道是预算用完、卡住了、还是压根没开始；
+     * 只说原阶段（「正在做」），又会像事故截图那样暗示还在跑。两段式表达：
+     * 终态 + 原阶段，一次说清两个事实。
+     */
+    function phaseLabel(phase: any, session: any, t: any) {
+      const base = t(`phase.${phase}`)
+      if (phase !== 'ended') return base
+      const suspended = String(session?.suspendedPhase ?? '')
+      if (!suspended) return base
+      const detail = t(`phase.${suspended}`)
+      return detail && detail !== base ? `${base} · ${detail}` : base
+    }
+
     function allEntries(session: any) {
       const byId = new Map((Array.isArray(session?.statuses) ? session.statuses : []).map((item: any) => [item.subtaskId, item]))
       const entries: any[] = []
@@ -1028,14 +1071,21 @@ window.__ModuleLoader__.load({
     }
 
     function workerText(session: any, t: any) {
-      const active = findEntry(session, 'in_progress')
-      if (active) {
-        return `${deptName(t, active.subtask.department)} · ${active.subtask.title}`
-      }
+      /*
+       * [1.5.2] 与 `planNow` 同序：卡住优先。
+       *
+       * 旧顺序是「正在做」优先，而卡片右上角的「现在」是「卡住了」优先，
+       * 于是同一屏一边说「现在卡住了 T1」、一边说「正在做 T2」（T5 C12）。
+       * 卡住需要人介入，两个位置都应先报它。
+       */
       const blocked = findEntry(session, 'blocked')
       if (blocked) {
         return `${deptName(t, blocked.subtask.department)} · ${blocked.subtask.title}（${t('status.blocked')}）`
       }
+      const active = findEntry(session, 'in_progress')
+      if (active) {
+        return `${deptName(t, active.subtask.department)} · ${active.subtask.title}`
+      }
       const stats = session.stats || {}
       if ((stats.total ?? 0) > 0 && (stats.done ?? 0) >= (stats.total ?? 0)) return t('helpDone')
       return t('helpNobody')
@@ -1061,11 +1111,22 @@ window.__ModuleLoader__.load({
     function nextText(session: any, t: any) {
       const blocked = findEntry(session, 'blocked')
       if (blocked) return `${t('handleBlocked')}：${deptName(t, blocked.subtask.department)} · ${blocked.subtask.title}${resumeHint(session, t)}`
+      /*
+       * [1.5.2] 「没有下一步」只允许出现在真正全部完成之后。
+       *
+       * 旧实现找不到 pending 就直接 return「没有下一步，这件事已完成」，于是
+       *   · 单任务计划刚进入 in_progress（环 0%）→ 同一张卡宣布「已完成」（T5 C2）；
+       *   · 降级计划 0/0 → 一边「安排失败」一边「已完成」（T5 C11）。
+       * 现在先按计数判终态，再区分「等当前这一步」「根本没有计划」。
+       */
+      const counts = planCounts(session.stats || {})
+      if (counts.total > 0 && counts.done === counts.total) return t('helpDone')
+      if (counts.total === 0) return t('helpNoPlan')
       const next = findEntry(session, 'pending') || allEntries(session).find((entry: any) => !entry.item)
       if (next) return `${deptName(t, next.subtask.department)} · ${next.subtask.title}`
-      const stats = session.stats || {}
-      if ((stats.total ?? 0) > 0 && (stats.done ?? 0) >= (stats.total ?? 0)) return t('helpDone')
-      return t('helpNextDone')
+      const active = findEntry(session, 'in_progress')
+      if (active) return `${t('helpWaitActive')}：${deptName(t, active.subtask.department)} · ${active.subtask.title}`
+      return t('helpWaitActive')
     }
 
     function progressText(item: any, t: any) {
@@ -1339,15 +1400,19 @@ window.__ModuleLoader__.load({
       const done = items.filter(({ item }: any) => item?.status === 'done').length
       const blocked = items.filter(({ item }: any) => item?.status === 'blocked').length
       const inProgress = items.some(({ item }: any) => item?.status === 'in_progress')
-      const tone = blocked > 0 ? 'blocked' : done === items.length ? 'done' : inProgress ? 'active' : 'idle'
+      // [1.5.2] 与 `planStageRows` 同一条规则：有 done 就是 active，不再只在
+      // 有 in_progress 时才算「正在做」。旧规则让同一阶段在概览行显示「正在做」、
+      // 在阶段卡显示「还没开始」（T5 C9）。
+      const tone = blocked > 0 ? 'blocked' : items.length > 0 && done === items.length ? 'done' : inProgress || done > 0 ? 'active' : 'idle'
       // Same tone/counts as before; only the presentation moved into the
       // collapsed summary row (done/total + state pill), so the numbers keep one
       // source: this step's own items from `statuses`.
       const stateText = blocked > 0
         ? `${blocked} ${t('stats.blocked')}`
-        : done === items.length
+        : items.length > 0 && done === items.length
           ? t('helpDone')
-          : inProgress ? t('phase.executing') : t('phase.pending')
+          : inProgress ? t('phase.executing')
+            : done > 0 ? fill(t('nowRemaining'), { n: items.length - done }) : t('phase.pending')
       return h('section', { className: `dsh-wp-stage dsh-wp-tone-${tone}` },
         h(Collapse, {
           className: 'dsh-wp-stage-collapse',
@@ -1463,6 +1528,18 @@ window.__ModuleLoader__.load({
       return Math.max(0, Math.round(number))
     }
 
+    /*
+     * [1.5.2] 计划级百分比的唯一算式。
+     *
+     * 1.5.1 及以前，同一页面上至少有三处各自 `Math.round(done / total * 100)`：
+     * 卡片环（planCounts）、组头环（groupTotals）、按任务进度条（TaskBars / 总览柱状图）。
+     * 三份实现口径相同只是巧合，任何一处单独改动都会让「同一张卡两个百分比」重现。
+     * 现在只有这一个函数，其它地方一律调用它。
+     */
+    function planPercent(done: number, total: number): number | null {
+      return total > 0 ? Math.round((done / total) * 100) : null
+    }
+
     // 与 groupTotals 同一套口径：先夹到 [0,total]，再让「正在做/还没开始」
     // 吃掉剩余量，四段之和恒等于总数（构成条不会溢出或出现负宽度）。
     function planCounts(stats: any): PlanCounts {
@@ -1472,8 +1549,44 @@ window.__ModuleLoader__.load({
       const blocked = Math.min(planCount(source.blocked), total - done)
       const active = Math.min(planCount(source.inProgress), total - done - blocked)
       const pending = Math.max(0, total - done - blocked - active)
-      const percent = total > 0 ? Math.round((done / total) * 100) : null
-      return { total, done, active, blocked, pending, percent }
+      return { total, done, active, blocked, pending, percent: planPercent(done, total) }
+    }
+
+    /*
+     * [1.5.2] 完成语义的第二道保险：状态文案必须服从计数事实。
+     *
+     * 后端已保证「工作项全部 done ⇒ phase=done」（`reconcilePhase`）。这里再兜一层，
+     * 让任何历史载荷、旧缓存或第三方构造的 payload 都不可能渲染出「100% + 正在
+     * 收尾」：计数齐全且全部完成时一律按「已完成」呈现；反过来，phase 说 done
+     * 但计数里还有没做完的项时，按真实计数降级，避免「已完成下面挂着没做完的活」。
+     *
+     * 计数未知（total=0，例如已取消或尚未拆解）时不动原始 phase——此时没有事实
+     * 可以覆盖它，硬改会把「进行中/已完成」的分组依据一起抹掉。
+     * 「integrating」只在计数证明全部完成时升级为 done，否则保留原语义（回放旧会话）。
+     */
+    function planPhaseOf(rawPhase: any, counts: PlanCounts): string {
+      const phase = String(rawPhase ?? 'pending')
+      if (counts.total > 0) {
+        if (counts.done === counts.total) return 'done'
+        if (phase === 'done') {
+          if (counts.blocked > 0) return 'blocked'
+          if (counts.active > 0) return 'executing'
+          return 'pending'
+        }
+      }
+      return phase
+    }
+
+    /*
+     * [1.5.2] 加权总进度的展示口径：未全部完成时封顶 99。
+     *
+     * 服务端 `deriveAggregates` 已做同样封顶；这里再算一次是为了让旧载荷/手工
+     * fixture 也守同一条不变量——「总体进度 100%」绝不能与「还有 N 项没完成」同屏。
+     */
+    function planWeightedPercent(stats: any, counts: PlanCounts): number {
+      const weighted = clampPct(stats?.progress ?? 0)
+      if (counts.total > 0 && counts.done === counts.total) return 100
+      return Math.min(99, weighted)
     }
 
     function planStatusMap(statuses: any): Map<string, any> {
@@ -1555,6 +1668,16 @@ window.__ModuleLoader__.load({
         return { state: 'active', text: withTitle(t('stats.inProgress'), active?.title) }
       }
       if (counts.total > 0 && counts.done === counts.total) return { state: 'done', text: t('helpDone') }
+      /*
+       * [1.5.2] 部分完成不再落到「还没开始」。
+       *
+       * `done>0` 但没有 blocked、也没有 in_progress 时（预算把剩余项重置成
+       * pending，或剩余项还没轮到），旧代码直接返回 `stats.pending`「还没开始」，
+       * 与同一张卡上的「1/2 做好了」和 50% 直接冲突（T5 C5）。
+       */
+      if (counts.done > 0) {
+        return { state: 'active', text: fill(t('nowRemaining'), { n: counts.total - counts.done }) }
+      }
       return { state: 'pending', text: t('stats.pending') }
     }
 
@@ -1643,7 +1766,9 @@ window.__ModuleLoader__.load({
       if (rows.length < 1 || rows.length > 12) return null
       return h('div', { className: 'dsh-wp-stepper', 'aria-hidden': 'true', 'data-stages': String(rows.length) },
         rows.map((row) => {
-          const reach = row.total > 0 ? ((row.done + row.active + row.blocked) / row.total) * 100 : 0
+          // [1.5.2] 只按 done 计。旧式把 blocked/active 也算「触达」，于是环 50%
+          // 时阶段条已经全满（T5 C7）——同一张卡两个「完成度」。
+          const reach = row.total > 0 ? (row.done / row.total) * 100 : 0
           const width = row.tone === 'pending' ? 0 : reach
           return h('span', {
             key: row.id,
@@ -1664,11 +1789,20 @@ window.__ModuleLoader__.load({
     }
 
     function PlanViz({ t, counts, now, rows }: { t: (key: string) => string; counts: PlanCounts; now: PlanNow; rows: PlanStageRow[] }) {
+      /*
+       * [1.5.2] data-state 也是「完成语义」的一个读者。
+       *
+       * 旧实现只看 percent：0% 的 pending 卡拿到 data-state="active"，
+       * 而 100% 的卡即使 phase 说 integrating 也是 "done"（T5 C13/C1）。
+       * 现在与胶囊、分组、环共用计数：全 done 才 done，0 且有未完成才 idle。
+       */
       const state = counts.percent === null
         ? 'idle'
         : counts.blocked > 0
           ? 'blocked'
-          : counts.percent >= 100 ? 'done' : 'active'
+          : counts.total > 0 && counts.done === counts.total
+            ? 'done'
+            : counts.done > 0 || counts.active > 0 ? 'active' : 'idle'
       return h('div', {
         className: 'dsh-wp-planviz',
         'data-percent': counts.percent === null ? 'none' : String(counts.percent),
@@ -1708,7 +1842,7 @@ window.__ModuleLoader__.load({
           h('span', null, `${counts.done}/${counts.total} ${t('stats.done')}`),
         ),
         h('div', { className: 'dsh-wp-planoverview-stats' },
-          h('span', null, `${t('vizWeighted')} ${clampPct(stats?.progress ?? 0)}%`),
+          h('span', null, `${t('vizWeighted')} ${planWeightedPercent(stats, counts)}%`),
           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,
         ),
@@ -1742,13 +1876,18 @@ window.__ModuleLoader__.load({
 
     function SessionCard({ session, t, open, onToggle }: any) {
       const domId = `dsh-wp-session-${session.sessionId}`
-      const phase = session.phase || 'pending'
       const stats = session.stats || {}
-      const tone = phaseTone(phase)
-      const departments = Array.isArray(session.departments) ? session.departments : []
       // 1.5.0：折叠卡摘要＝图表（环 + 百分比 + 四段构成条 + 图例 + 阶段步进条）；
       // 数字仍只来自 session.stats，与旧头部的口径完全一致，不引入第二套统计。
       const counts = planCounts(stats)
+      /*
+       * [1.5.2] 卡片的色调与胶囊文案也走统一对账：只要计数显示全部完成，
+       * 胶囊就必须是「已完成」，视觉档位也必须是 done。截图里那张卡之所以
+       * 「100% + 正在收尾 + 留在进行中组」，就是因为这三个读者各读各的字段。
+       */
+      const phase = planPhaseOf(session.phase || 'pending', counts)
+      const tone = phaseTone(phase)
+      const departments = Array.isArray(session.departments) ? session.departments : []
       const statuses = Array.isArray(session.statuses) ? session.statuses : []
       const stageRows = planStageRows(session.stages, statuses)
       const now = planNow(t, counts, planTaskEntries(session.stages, statuses))
@@ -1761,7 +1900,7 @@ window.__ModuleLoader__.load({
           panelClassName: 'dsh-wp-session-body',
           title: session.title || t('panel'),
           meta: h(PlanViz, { t, counts, now, rows: stageRows }),
-          badge: h(Pill, { tone }, t(`phase.${phase}`)),
+          badge: h(Pill, { tone }, phaseLabel(phase, session, t)),
         },
           session.updatedAt
             ? h('div', { className: 'dsh-wp-meta dsh-wp-session-updated' }, `${t('updatedAt')} ${formatTime(session.updatedAt)}`)
@@ -1865,7 +2004,7 @@ window.__ModuleLoader__.load({
               charts.push(new lib(canvasA, {
                 type: 'doughnut',
                 data: {
-                  labels: [t('groupLive'), t('groupDone')],
+                  labels: [t('chartOpen'), t('chartDone')],
                   datasets: [{ data: [liveCount, doneCount], backgroundColor: [liveFill, doneFill], borderWidth: 0, hoverOffset: 5 }],
                 },
                 options: {
@@ -1920,16 +2059,16 @@ window.__ModuleLoader__.load({
           // 「无 canvas → 不建图 → 不 ready → 无 canvas」的死循环（T3 实测
           // 探针输出 canvasNodes:0 / fallbackBars:1）。改为并存：
           // fallback 在 ready 前可见，ready 后由 CSS 隐藏，canvas 反向隐藏。
-          h('div', { className: 'dsh-wp-chart-canvas' }, h('canvas', { 'data-chart': 'groups', role: 'img', 'aria-label': `${t('groupLive')} ${liveCount} / ${t('groupDone')} ${doneCount}` })),
+          h('div', { className: 'dsh-wp-chart-canvas' }, h('canvas', { 'data-chart': 'groups', role: 'img', 'aria-label': `${t('chartOpen')} ${liveCount} / ${t('chartDone')} ${doneCount}` })),
           chartState !== 'ready'
             ? h('div', { className: 'dsh-wp-fallback' },
-              h('div', { className: 'dsh-wp-fallback-bar', role: 'img', 'aria-label': `${t('groupLive')} ${liveCount} / ${t('groupDone')} ${doneCount}` },
+              h('div', { className: 'dsh-wp-fallback-bar', role: 'img', 'aria-label': `${t('chartOpen')} ${liveCount} / ${t('chartDone')} ${doneCount}` },
                 h('span', { className: 'dsh-wp-fallback-live', style: { width: `${livePct}%` } }),
                 h('span', { className: 'dsh-wp-fallback-done', style: { width: `${donePct}%` } }),
               ),
               h('div', { className: 'dsh-wp-fallback-legend' },
-                h('span', null, h('i', { className: 'dsh-wp-fallback-key dsh-wp-fallback-key--live' }), `${t('groupLive')} ${liveCount}`),
-                h('span', null, h('i', { className: 'dsh-wp-fallback-key dsh-wp-fallback-key--done' }), `${t('groupDone')} ${doneCount}`),
+                h('span', null, h('i', { className: 'dsh-wp-fallback-key dsh-wp-fallback-key--live' }), `${t('chartOpen')} ${liveCount}`),
+                h('span', null, h('i', { className: 'dsh-wp-fallback-key dsh-wp-fallback-key--done' }), `${t('chartDone')} ${doneCount}`),
               ),
             )
             : null,
@@ -1989,7 +2128,7 @@ window.__ModuleLoader__.load({
         total,
         done,
         open: total - done,
-        percent: total > 0 ? Math.round((done / total) * 100) : null,
+        percent: planPercent(done, total),
         active: Math.max(0, active),
         pending: Math.max(0, pending),
         blocked: Math.max(0, blocked),
@@ -2046,18 +2185,25 @@ window.__ModuleLoader__.load({
     }
 
     function SessionGroup({ group, list, hasLive, urgent, t, openSessionId, setOpenSessionId }: any) {
+      /*
+       * [1.6.0] 三个分组共用一套组件：live（真的在跑）、ended（这一轮停了但没做完）、
+       * done（全部完成）。`ended` 是本次事故的修复核心——它必须是一个**独立分组**，
+       * 而不是被塞回「进行中」：会话已经结束的事实不允许用「进行中」这三个字表达。
+       */
       const isDone = group === 'done'
+      const isEnded = group === 'ended'
+      const keySuffix = isDone ? 'Done' : isEnded ? 'Ended' : 'Live'
       // 设计稿 §6.4 #1/#6：已完成组在有进行中任务时默认折叠，避免历史任务抢走
       // 「进行中」的视觉权重；没有进行中任务时默认展开，空的进度栏仍是空的。
-      // 折叠态由本组件自己持有（不给 users 存偏好），刷新后回到默认，符合 §7.3「不打扰」。
-      const [open, setOpen] = useState(!(isDone && hasLive))
+      // [1.6.0] 「已结束」组同理：还有东西在跑时收起来，只留组头一行结论。
+      const [open, setOpen] = useState(!((isDone || isEnded) && hasLive))
       // §7.3「不打扰」的自动展开：只在这两种情形打开一次，不做反复弹开——
       // ① 进行中清零（最后一个任务完成）；② 用户正展开着的卡片被移进本组。
       // 依赖都是布尔值，轮询刷新不会重复触发。
       const holdsOpenCard = list.some((session: any) => session.sessionId === openSessionId)
       useEffect(() => { if (!hasLive) setOpen(true) }, [hasLive])
       useEffect(() => { if (holdsOpenCard) setOpen(true) }, [holdsOpenCard])
-      const collapsible = isDone && list.length > 0
+      const collapsible = (isDone || isEnded) && list.length > 0
       // 折叠只隐藏、不卸载：`hidden` 必须是布尔 true，不能传空字符串——
       // React 对 `hidden` 走 DOM 布尔属性赋值，`el.hidden = ''` 会得到 false，
       // 只剩 CSS 类在遮挡；那样「折叠态 DOM 保留 + 无障碍语义」就不成立。
@@ -2068,8 +2214,8 @@ window.__ModuleLoader__.load({
       // T6：组头完成度摘要 + 零依赖进度环。数值只来自 groupTotals(list)，
       // 先用纯文本给出「进行中 N / 已完成 M（完成率 x%）」，不点开、不看颜色也能读出进度。
       const totals = useMemo(() => groupTotals(list), [list])
-      const groupTitle = t(isDone ? 'groupDone' : 'groupLive')
-      const hintText = t(isDone ? 'groupDoneHint' : 'groupLiveHint')
+      const groupTitle = t(`group${keySuffix}`)
+      const hintText = t(`group${keySuffix}Hint`)
       // 用户 Q3：0/0 时不再显示「未完成 0 / 已完成 0（完成率暂无数据）」——
       // 环上已经是「—」，组内空态也已说明没有工作项；再重复一遍 0/0 只是噪声。
       // 全部做完（100%）仍保留整句，因为那时「未完成 0」正是用户要找的结论。
@@ -2136,7 +2282,7 @@ window.__ModuleLoader__.load({
             open: openSessionId === session.sessionId,
             onToggle: (next: boolean) => setOpenSessionId(next ? session.sessionId : null),
           })))
-          : h('div', { className: 'dsh-wp-group-empty' }, t(isDone ? 'groupDoneEmpty' : 'groupLiveEmpty')),
+          : h('div', { className: 'dsh-wp-group-empty' }, t(`group${keySuffix}Empty`)),
       )
     }
 
@@ -2209,10 +2355,11 @@ window.__ModuleLoader__.load({
         h('div', { className: 'dsh-wp-section-title' }, t('taskChart')),
         (Array.isArray(sessions) ? sessions : []).map((session: any) => {
           const stats = session.stats || {}
-          const total = Math.max(0, Number(stats.total) || 0)
-          const done = Math.max(0, Number(stats.done) || 0)
-          const percent = total > 0 ? Math.round((done / total) * 100) : 0
-          const tone = phaseTone(session.phase || 'pending')
+          const counts = planCounts(stats)
+          // 同一套计数与对账：柱状图的百分比、文案、色调都不得自成一套。
+          const percent = counts.percent ?? 0
+          const phase = planPhaseOf(session.phase || 'pending', counts)
+          const tone = phaseTone(phase)
           return h('button', {
             key: session.sessionId,
             type: 'button',
@@ -2222,13 +2369,13 @@ window.__ModuleLoader__.load({
           },
             h('div', { className: 'dsh-wp-bar-head' },
               h('span', { className: 'dsh-wp-bar-title' }, session.title || t('panel')),
-              h('span', { className: 'dsh-wp-bar-value' }, `${done}/${total}`),
+              h('span', { className: 'dsh-wp-bar-value' }, `${counts.done}/${counts.total}`),
             ),
             h('div', { className: 'dsh-wp-bar-track' },
               h('div', { className: `dsh-wp-bar-fill dsh-wp-bar-fill--${tone}`, style: { width: `${percent}%` } }),
             ),
             h('div', { className: 'dsh-wp-bar-meta' },
-              h('span', null, t(`phase.${session.phase || 'pending'}`)),
+              h('span', null, phaseLabel(phase, session, t)),
               h('span', null, `${percent}%`),
             ),
           )
@@ -2280,10 +2427,25 @@ window.__ModuleLoader__.load({
       }, [activeSessions])
       const groups = useMemo(() => {
         const live: any[] = []
+        const ended: any[] = []
         const finished: any[] = []
         const urgentPhases = ['blocked', 'degraded', 'paused']
+        /*
+         * [1.5.2] 分组也按对账后的 phase，而不是 payload 里的原始 phase。
+         *
+         * 截图那张卡之所以停在「进行中」组，就是因为这里只读 `session.phase`：
+         * 14/14、100% 的计划带着 integrating 被塞进 live 组，组头于是出现
+         * 「未完成 0 / 已完成 14（完成率 100%）」却仍标着「进行中」。
+         * `planPhaseOf` 让分组、组头计数、卡片胶囊共用同一个结论。
+         *
+         * [1.6.0] 新增 ended 分组：宿主已经 `turn/end`（会话这一轮结束、没有任何
+         * 东西在跑），而计划还没做完的，一律进「已结束」，绝不进「进行中」。
+         * 这正是本次事故的现象：会话结束 4 小时后仍显示「进行中」。
+         */
         for (const session of activeSessions) {
-          if (session.phase === 'done') finished.push(session)
+          const phase = planPhaseOf(session.phase, planCounts(session.stats))
+          if (phase === 'done') finished.push(session)
+          else if (phase === 'ended') ended.push(session)
           else live.push(session)
         }
         /*
@@ -2300,11 +2462,19 @@ window.__ModuleLoader__.load({
           integrating: 3,
           planning: 4,
           pending: 5,
+          ended: 6,
         }
-        const rank = (session: any) => phaseRank[session.phase] ?? 5
+        const rank = (session: any) => phaseRank[planPhaseOf(session.phase, planCounts(session.stats))] ?? 5
         live.sort((a: any, b: any) => (rank(a) - rank(b))
           || ((Number(b.createdAt) || 0) - (Number(a.createdAt) || 0))
           || String(a.sessionId).localeCompare(String(b.sessionId)))
+        /*
+         * [1.6.0] 已结束组按「最近结束在前」：`endedAt` 是宿主 turn/end 的时间戳
+         * （后端下发），比 updatedAt 更准确地表达「什么时候停的」。
+         */
+        const endedAt = (session: any) => Number(session.endedAt) || Number(session.updatedAt) || Number(session.createdAt) || 0
+        ended.sort((a: any, b: any) => (endedAt(b) - endedAt(a))
+          || ((Number(b.createdAt) || 0) - (Number(a.createdAt) || 0)))
         /*
          * 已完成组按「最近完成在前」（§3.3 / C8）：优先取子任务
          * statuses[].finishedAt 的最大值（忽略 null / 非数字），缺失则退回
@@ -2327,15 +2497,25 @@ window.__ModuleLoader__.load({
         }
         finished.sort((a: any, b: any) => (finishedAt(b) - finishedAt(a))
           || ((Number(b.createdAt) || 0) - (Number(a.createdAt) || 0)))
-        return { live, finished, urgent: live.filter((session: any) => urgentPhases.includes(session.phase)).length }
+        return {
+          live,
+          ended,
+          finished,
+          urgent: live.filter((session: any) => urgentPhases.includes(session.phase)).length,
+          /*
+           * [1.6.0] 「已结束」组也需要「需处理」角标：卡住的计划停了仍然是卡住的，
+           * 判定用后端下发的 suspendedPhase（原派发阶段），而不是被收敛后的 ended。
+           */
+          urgentEnded: ended.filter((session: any) => urgentPhases.includes(String(session.suspendedPhase ?? ''))).length,
+        }
       }, [activeSessions])
-      const liveBars = useMemo(() => groups.live.slice(0, 6).map((session: any) => {
-        const doneCount = session.stats?.done ?? 0
-        const totalCount = session.stats?.total ?? 0
+      // [1.6.0] 图表口径 = 未结束计划（进行中 + 已结束未完成），与环图标签一致。
+      const liveBars = useMemo(() => [...groups.live, ...groups.ended].slice(0, 6).map((session: any) => {
         const raw = String(session.title || t('panel'))
         return {
           label: raw.length > 14 ? `${raw.slice(0, 14)}…` : raw,
-          value: totalCount > 0 ? Math.round((doneCount / totalCount) * 100) : 0,
+          // [1.5.2] 与卡片/组头同一个百分比函数，杜绝第二套口径。
+          value: planPercent(planCount(session.stats?.done), planCount(session.stats?.total)) ?? 0,
         }
       }), [groups, t])
       return h('div', { className: 'dsh-wp' },
@@ -2362,8 +2542,16 @@ window.__ModuleLoader__.load({
         activeSessions.length === 0
           ? h('div', { className: 'dsh-wp-empty' }, h('div', { style: { fontWeight: 650, marginBottom: '4px' } }, t('empty')), h('div', null, t('emptyHint')))
           : h('div', { className: 'dsh-wp-groups' },
-            h(SessionGroup, { group: 'live', list: groups.live, urgent: groups.urgent, t, openSessionId, setOpenSessionId }),
-            h(SessionGroup, { group: 'done', list: groups.finished, hasLive: groups.live.length > 0, urgent: 0, t, openSessionId, setOpenSessionId }),
+            /*
+             * [1.6.0] 三组顺序：真的在跑 → 已结束（停在半路） → 已完成。
+             * 「已结束」夹在中间是有意为之：它是用户最需要立刻知道的那一档
+             * （刚停、还没做完），不能滑到历史组的下面去。
+             */
+            h(SessionGroup, { key: 'live', group: 'live', list: groups.live, urgent: groups.urgent, t, openSessionId, setOpenSessionId }),
+            groups.ended.length > 0
+              ? h(SessionGroup, { key: 'ended', group: 'ended', list: groups.ended, hasLive: groups.live.length > 0, urgent: groups.urgentEnded, t, openSessionId, setOpenSessionId })
+              : null,
+            h(SessionGroup, { key: 'done', group: 'done', list: groups.finished, hasLive: groups.live.length > 0 || groups.ended.length > 0, urgent: 0, t, openSessionId, setOpenSessionId }),
             // 用户选择 B：总览块（完成率环 + 每个计划的进度条）同样下移到两组之后，
             // 让开屏第一屏直接是「进行中」组的任务卡（此前统计条 → 总览 → 说明行 →
             // 任务卡，第一张卡要下滑约一屏）。顶部只保留 5 格数字统计条与一行口径说明。
@@ -2373,7 +2561,8 @@ window.__ModuleLoader__.load({
             ) : null,
             // 图表放两组之后：两张卡各 ≈246px，排在组前会让首屏看不到任何一张任务卡
             // （设计稿 §8 第 12 条，T8 复核时复现在 1.4.2 源码里）。
-            h(GroupCharts, { liveCount: groups.live.length, doneCount: groups.finished.length, liveBars, hiddenBars: Math.max(0, groups.live.length - 6), t }),
+            // [1.6.0] 「未结束」= 进行中 + 已结束但未完成：两者都还没做完，都是用户要盯的对象。
+            h(GroupCharts, { liveCount: groups.live.length + groups.ended.length, doneCount: groups.finished.length, liveBars, hiddenBars: Math.max(0, groups.live.length + groups.ended.length - 6), t }),
           ),
       )
     }
@@ -2389,12 +2578,19 @@ window.__ModuleLoader__.load({
         const active = ['planning', 'executing', 'blocked'].includes(session.phase)
         if (currentTurn > createdTurn && !active) return null
       }
+      /*
+       * [1.5.2] 会话内联卡（TurnCard）也走同一套对账。
+       *
+       * 面板卡片修好了、内联卡却仍按原始 phase 渲染的话，同一张计划会在
+       * 「侧栏已完成 / 对话里正在收尾」之间再次自相矛盾。
+       */
       const stats = session.stats || {}
-      const tone = phaseTone(session.phase || 'pending')
+      const phase = planPhaseOf(session.phase || 'pending', planCounts(stats))
+      const tone = phaseTone(phase)
       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 }, t(`phase.${session.phase || 'pending'}`)),
+          h(Pill, { tone }, phaseLabel(phase, session, t)),
         ),
         h('div', { className: 'dsh-wp-muted', style: { marginTop: '6px' } },
           `${t('helpWho')}：${workerText(session, t)}`),