dsh-autorestart 0.6.0 → 0.6.2

package/client.js

@@ -75,13 +75,15 @@
  *
  * This file is a CLASSIC script: the client module loader evaluates a
  * plugin bundle as a same-origin external classic script, so the ESM
- * `export` keyword is NOT available here. The four pure helpers are
+ * `export` keyword is NOT available here. The pure helpers are
  * therefore published in the two places a test can reach them:
  *
  *   1. as NAMED properties of this module's exports — the client module
  *      system materializes `factory(require) -> exports`, so the exports
  *      object carries `pickSleepCaption`, `shouldShowSleepButton`,
- *      `buildChoiceBody` and `formatRemainingMs`;
+ *      `buildChoiceBody`, `formatRemainingMs`, `formatLongWaitNote`,
+ *      `formatLongWaitNoteParts`, `groupBlockers`, `summarizeBlockers`
+ *      and `truncateBlockerName`;
  *   2. on the global namespace `globalThis.__dshAutorestartClient`, which
  *      exists as soon as this file is evaluated (no factory call needed).
  *
@@ -115,17 +117,18 @@ const SLEEP_DEFAULT_COUNTDOWN_SECONDS = 20
 const SLEEP_DRY_RUN_NOTICE_MS = 8_000
 
 /**
- * The grace window the settings page offers (a dropdown, in seconds).
+ * The RESTART reserve the settings page offers (a dropdown, in seconds).
  *
- * It is the extra wait after the last conversation finished, so that work
- * other plugins queue with a timer (a memory plugin writing its notes, a
- * summary) still gets its chance — this plugin cannot see that work.
+ * It belongs to the restart only: a restart is a daily operation, so it
+ * should happen as soon as the conversations are done. The graceful shutdown
+ * has no reserve of its own — its VISIBLE countdown is the wait before the
+ * machine goes off.
  */
-const GRACE_CHOICES_SECONDS = Object.freeze([0, 3, 5, 10, 20, 30])
+const GRACE_CHOICES_SECONDS = Object.freeze([0, 5, 10, 20, 30, 60])
 
-/** The grace window used when the Host did not report one (ms / seconds). */
-const GRACE_DEFAULT_MS = 10_000
-const GRACE_DEFAULT_SECONDS = 10
+/** The RESTART reserve used when the Host did not report one (ms / seconds). */
+const GRACE_DEFAULT_MS = 0
+const GRACE_DEFAULT_SECONDS = 0
 
 const ZH = {
   label: '待重启',
@@ -134,6 +137,7 @@ const ZH = {
   idle: ' · 空闲后自动重启',
   goalActive: ' · 被某个自动续跑的 goal 占着',
   goalExhausted: ' · 某个任务的 goal 轮次额度已用完，无法续跑',
+  settling: ' · 还在等这段安静期',
   parkedGoals: ' · 已停泊 {n} 个 goal，重启后自动继续',
   parkButton: '停泊并重启',
   parkButtonAria: '停泊该会话的 goal，并立即请求重启',
@@ -155,6 +159,10 @@ const ZH = {
   panelBlockedSession: '会话「{label}」正在运行',
   panelBlockedSubagent: '{name}正在运行',
   panelBlockedSubagentGeneric: '有一个子智能体正在运行',
+  // The N subagents of ONE session are one line: the session is named once
+  // and the number of its subagents says how many there are.
+  panelBlockedSubagentGroup: '会话「{label}」的 {n} 个子智能体正在运行',
+  panelBlockedSubagentGroupGeneric: '有 {n} 个子智能体正在运行',
   panelBlockedRestartPending: '等这次重启完成后再关机',
   panelGoalActiveLine: '占用会话「{title}」：goal 正在自动续跑（goal-active）',
   panelGoalExhaustedLine: '占用会话「{title}」：goal 轮次额度已用完，无法继续（goal-exhausted）',
@@ -162,9 +170,30 @@ const ZH = {
   panelParkedGoal: '会话 {session} · {goal}',
   panelWaiting: '已等待 {duration}',
   panelResume: '重启后本会话会自动继续进度',
+  // The long wait: the restart passed the hard deadline while a conversation
+  // was still running. The capsule is ONE clipped line of 22px: it holds a
+  // number and a duration, NEVER a name. Every name goes into the tooltip,
+  // where there is room for all of them.
+  longWaitPill: ' · 已等 {duration} · {n} 项任务在跑',
+  longWaitTooltip: '已等 {duration}。在跑：{blockers}',
+  // The blockers of one list. They are grouped by the session that created
+  // them (N subagents of one session are ONE item), the tooltip names them
+  // ALL and the shutdown card lists them. One rule, two surfaces: the
+  // tooltip of the capsule and the list of the shutdown card.
+  blockerGeneric: '有会话',
+  blockerJoin: '、',
+  blockerGroupSubagents: '{label}（{n} 个子智能体）',
+  blockerGroupSubagentsGeneric: '{n} 个子智能体',
+  blockerMore: '…等 {n} 项',
+  blockersTitleLine: '占用会话：{blockers}',
   durationSeconds: '{n} 秒',
   durationMinutes: '{n} 分 {m} 秒',
   durationHours: '{n} 小时 {m} 分',
+  // The COMPACT duration of the capsule: it can afford "16 分钟", not
+  // "16 分 37 秒" — the capsule is one clipped line.
+  durationMinutesShort: '{n} 分钟',
+  durationHoursShort: '{n} 小时',
+  durationHoursMinutesShort: '{n} 小时 {m} 分',
   // The one-time install prompt (the choice is asked exactly once).
   // "Backup" is the verb and BOTH options share the "configuration" base:
   // the plugins are an ADDITION to the configuration, never a rival of it.
@@ -192,14 +221,16 @@ const ZH = {
   'sleep.error': '没能联系上关机服务：{message}',
   // The settings section: the entry in the settings sidebar.
   'nav': '自动重启与关机',
-  'settings.seconds.label': '倒计时秒数',
+  'settings.groups.restart': '重启相关设置',
+  'settings.groups.shutdown': '关机相关设置',
+  'settings.seconds.label': '关机倒数秒数',
   'settings.seconds.immediate': '不倒数（立即关机）',
   'settings.seconds.value': '{n} 秒',
-  'settings.seconds.hint': '按下按钮后，等所有会话收工，再倒数这么多秒才关机；「不倒数」表示会话一收工就关机。',
-  'settings.grace.label': '收工后再等几秒（给记忆/总结类插件留时间）',
-  'settings.grace.hint': '最后一个会话收工后，再等这么久才真正重启或关机——我们只看得见 DSH 的会话，看不见别的插件用定时器排队的活。等待期间如果又有会话开始干活，会重新计时。',
-  'settings.grace.value': '{n} 秒',
-  'settings.grace.immediate': '不等（立即重启/关机）',
+  'settings.seconds.hint': '所有会话收工后，屏幕上会显示这段倒数（可点「不关了」取消），数完才关机；想要更多落盘时间就把倒数调大。',
+  'settings.restartGrace.label': '重启前等待',
+  'settings.restartGrace.hint': '重启没有倒数环节，会话一收工就会立刻重启；如果你装了“会话结束后才写”的记忆/总结类插件，把这里调大（默认 0 秒）。',
+  'settings.restartGrace.value': '{n} 秒',
+  'settings.restartGrace.immediate': '不等（立即重启）',
   'settings.backup.label': '重启前备份',
   'settings.backup.hint': '每次重启前先快照一次当前配置；万一重启后起不来，能自动回退。',
   'settings.backupPlugins.label': '备份包含已安装插件',
@@ -275,6 +306,7 @@ const EN = {
   idle: ' · restarts once idle',
   goalActive: ' · held by a self-continuing goal',
   goalExhausted: ' · a goal ran out of rounds',
+  settling: ' · still waiting for the quiet window',
   parkedGoals: ' · {n} goal(s) parked, they continue after the restart',
   parkButton: 'Park & restart',
   parkButtonAria: 'Park that session goal and request the restart now',
@@ -299,6 +331,9 @@ const EN = {
   panelBlockedSession: 'Session "{label}" is running',
   panelBlockedSubagent: '{name} is running',
   panelBlockedSubagentGeneric: 'One subagent is running',
+  // The N subagents of ONE session are one line.
+  panelBlockedSubagentGroup: 'The {n} subagents of session "{label}" are running',
+  panelBlockedSubagentGroupGeneric: '{n} subagents are running',
   panelBlockedRestartPending: 'Waiting for the pending restart to finish before shutting down',
   panelGoalActiveLine: 'Blocking session "{title}": the goal keeps driving rounds by itself (goal-active)',
   panelGoalExhaustedLine: 'Blocking session "{title}": the goal ran out of rounds and cannot continue (goal-exhausted)',
@@ -306,9 +341,29 @@ const EN = {
   panelParkedGoal: 'session {session} · {goal}',
   panelWaiting: 'Waiting for {duration}',
   panelResume: 'This session resumes its progress automatically after the restart.',
+  // The long wait: the restart passed the hard deadline while a conversation
+  // was still running. The capsule is ONE clipped line of 22px: it holds a
+  // number and a duration, NEVER a name. Every name goes into the tooltip,
+  // where there is room for all of them.
+  longWaitPill: ' · waiting for {duration} · {n} task(s) running',
+  longWaitTooltip: 'Waiting for {duration}. Running: {blockers}',
+  // The blockers of one list: they are grouped by the session that created
+  // them (N subagents of one session are ONE item), the tooltip names them
+  // ALL and the shutdown card lists them. One rule, two surfaces.
+  blockerGeneric: 'another session',
+  blockerJoin: ', ',
+  blockerGroupSubagents: '{label} ({n} subagents)',
+  blockerGroupSubagentsGeneric: '{n} subagents',
+  blockerMore: '… and {n} more',
+  blockersTitleLine: 'Blocking sessions: {blockers}',
   durationSeconds: '{n}s',
   durationMinutes: '{n}m {m}s',
   durationHours: '{n}h {m}m',
+  // The COMPACT duration of the capsule: it can afford "16 min", not
+  // "16m 37s" — the capsule is one clipped line.
+  durationMinutesShort: '{n} min',
+  durationHoursShort: '{n}h',
+  durationHoursMinutesShort: '{n}h {m}m',
   // The one-time install prompt (the choice is asked exactly once).
   // "Backup" is the verb and BOTH options share the "configuration" base:
   // the plugins are an ADDITION to the configuration, never a rival of it.
@@ -336,14 +391,16 @@ const EN = {
   'sleep.error': 'Could not reach the sleep service: {message}',
   // The settings section: the entry in the settings sidebar.
   'nav': 'Auto-restart & shut down',
-  'settings.seconds.label': 'Countdown seconds',
+  'settings.groups.restart': 'Restart settings',
+  'settings.groups.shutdown': 'Shutdown settings',
+  'settings.seconds.label': 'Shutdown countdown seconds',
   'settings.seconds.immediate': 'No countdown (switch off right away)',
   'settings.seconds.value': '{n} seconds',
-  'settings.seconds.hint': 'After the button: wait for every conversation to be done, count down this many seconds and switch off. "No countdown" switches off as soon as the conversations are done.',
-  'settings.grace.label': 'Wait a few more seconds after the work is done',
-  'settings.grace.hint': 'After the last conversation finished, wait this long before the host is really restarted or switched off — this plugin only sees the DSH conversations, not the work other plugins queue with a timer. If a conversation starts working again while waiting, the timer starts over.',
-  'settings.grace.value': '{n} seconds',
-  'settings.grace.immediate': 'Do not wait (restart/switch off right away)',
+  'settings.seconds.hint': 'Once every conversation is done, this countdown is shown on screen (pick "Never mind, keep it on" to cancel); the machine goes off when it reaches zero. Raise it when you want more time to write.',
+  'settings.restartGrace.label': 'Wait before the restart',
+  'settings.restartGrace.hint': 'A restart has no countdown: the host restarts as soon as the conversations are done. Raise this if you rely on a memory or summary plugin that writes its notes after the conversation ended (default 0 seconds).',
+  'settings.restartGrace.value': '{n} seconds',
+  'settings.restartGrace.immediate': 'Do not wait (restart right away)',
   'settings.backup.label': 'Backup before a restart',
   'settings.backup.hint': 'Take a snapshot of the current configuration before every restart, so a host that cannot boot again is rolled back automatically.',
   'settings.backupPlugins.label': 'Include the installed plugins in the backup',
@@ -535,11 +592,454 @@ function formatRemainingMs(ms) {
   return Math.ceil(raw / 1000)
 }
 
+/**
+ * Fill `{name}` placeholders in a locale template.
+ *
+ * The locale API is not assumed to interpolate, so the helpers below do it
+ * themselves. This is the module-level twin of the panel's own `fill`.
+ *
+ * @param {string} template
+ * @param {Record<string, unknown>} vars
+ * @returns {string}
+ */
+function fillTemplate(template, vars) {
+  if (typeof template !== 'string') return ''
+  return template.replace(/\{(\w+)\}/g, (match, name) => (
+    vars && Object.prototype.hasOwnProperty.call(vars, name) ? String(vars[name]) : match
+  ))
+}
+
+/**
+ * A duration as a locale string: "45 秒" / "3 分 12 秒" / "2 小时 5 分".
+ *
+ * @param {number} ms
+ * @param {(name: string) => string} [t] the translator
+ * @returns {string}
+ */
+function formatDurationMs(ms, t) {
+  const translate = typeof t === 'function' ? t : (name) => name
+  const totalSeconds = Math.max(0, Math.floor((Number(ms) || 0) / 1000))
+  if (totalSeconds < 60) return fillTemplate(translate('durationSeconds'), { n: totalSeconds })
+  const minutes = Math.floor(totalSeconds / 60)
+  if (minutes < 60) return fillTemplate(translate('durationMinutes'), { n: minutes, m: totalSeconds % 60 })
+  const hours = Math.floor(minutes / 60)
+  return fillTemplate(translate('durationHours'), { n: hours, m: minutes % 60 })
+}
+
+/**
+ * A duration as a COMPACT locale string: "45 秒" / "3 分钟" / "2 小时 5 分".
+ *
+ * The capsule of the pending restart is ONE clipped line of 22px: it can
+ * afford "16 分钟", not "16 分 37 秒". The precise duration belongs into the
+ * tooltip, where there is room for it.
+ *
+ * @param {number} ms
+ * @param {(name: string) => string} [t] the translator
+ * @returns {string}
+ */
+function formatCompactDurationMs(ms, t) {
+  const translate = typeof t === 'function' ? t : (name) => name
+  const totalSeconds = Math.max(0, Math.floor((Number(ms) || 0) / 1000))
+  if (totalSeconds < 60) return fillTemplate(translate('durationSeconds'), { n: totalSeconds })
+  const minutes = Math.floor(totalSeconds / 60)
+  if (minutes < 60) return fillTemplate(translate('durationMinutesShort'), { n: minutes })
+  const hours = Math.floor(minutes / 60)
+  const rest = minutes % 60
+  return rest === 0
+    ? fillTemplate(translate('durationHoursShort'), { n: hours })
+    : fillTemplate(translate('durationHoursMinutesShort'), { n: hours, m: rest })
+}
+
+/* ------------------------------------------------------------------ *
+ * The blocker lists: ONE rule for every surface that names them.
+ *
+ * The defect the real machine showed: the pending-restart bubble grew a
+ * line that named EVERY blocker — and every AgentTeams member is a
+ * subagent, so the names of one team turned into a string of a dozen
+ * "…的子智能体" phrases that did not fit into a 22px pill any more and
+ * were clipped away.
+ *
+ * The rule, in one place:
+ *
+ *   1. the subagents of ONE session are ONE item ("<that session>
+ *      (N subagents)"); a plain session is an item of its own;
+ *   2. a list names at most `BLOCKER_SUMMARY_LIMIT` items and says
+ *      "… and N more" about the rest — never an endless list;
+ *   3. the SHORT list shortens a name that is too long;
+ *   4. the COMPLETE list goes into the tooltip (`title`).
+ *
+ * WHERE THE NAMES LIVE. The capsule of the pending restart is 22px high
+ * and ONE line wide: a name in it is a name that gets clipped away. So
+ * the capsule says NUMBERS ONLY ("已等 16 分钟 · 3 项任务在跑") and every
+ * name goes into the tooltip (`title`) — where the COMPLETE list lives.
+ * The shutdown card has room, so it keeps the readable list.
+ *
+ * THE TWO REAL SHAPES. The Host does not report the blockers in one shape,
+ * so the rule has to read every field the Host actually sends:
+ *
+ *   A. the gate / the long wait / the state route (`index.js`,
+ *      `describeBlocker` + `busyAgents`):
+ *
+ *        { sessionId, reason, busyReason?, kind, label, name,
+ *          parentTitle, parentSessionId }
+ *
+ *      `label` is the title of the session — for a SUBAGENT it is the title
+ *      of the session that created it, and `name` is the composed phrase
+ *      ("<that session>'s subagent"). `parentSessionId` says which session
+ *      it belongs to.
+ *
+ *   B. the shutdown card (`lib/sleep.js`, `blockerEntry`):
+ *
+ *        { sessionId, kind, label, name, parentTitle, title }
+ *
+ *      The SAME information, but WITHOUT `parentSessionId` — so the
+ *      grouping falls back to the parent's title (`parentTitle`).
+ *
+ * A rule that only knows `parentSessionId` therefore groups the card
+ * wrongly: every member of a team becomes an item of its own, which is
+ * exactly the endless list the rule is there to prevent.
+ * ------------------------------------------------------------------ */
+
+/**
+ * How many blockers a bubble names at once.
+ *
+ * The bubble is a 22px high pill: a long list is clipped away, so the list
+ * is capped and the complete list goes into the tooltip.
+ */
+const BLOCKER_SUMMARY_LIMIT = 2
+
+/**
+ * How many characters one name may have in the bubble.
+ *
+ * The bubble is small, so a long session title is shortened instead of
+ * pushing the rest of the line out of the pill. The "…" is part of the
+ * budget: the bubble never shows MORE than this many characters of one
+ * name.
+ */
+const BLOCKER_NAME_MAX_LENGTH = 12
+
+/** The character a shortened name ends with. */
+const BLOCKER_ELLIPSIS = '…'
+
+/**
+ * A name that is at most `maxLength` characters long.
+ *
+ * The characters are counted, not the code units, so a name of Chinese
+ * characters is cut after the requested number of characters. The ellipsis
+ * counts towards the limit: a name of 12 characters is shown as 11
+ * characters plus "…", never as 13.
+ *
+ * @param {string} name
+ * @param {number} [maxLength]
+ * @returns {string}
+ */
+function truncateBlockerName(name, maxLength) {
+  const text = typeof name === 'string' ? name.trim() : ''
+  if (text === '') return ''
+  const limit = Number.isFinite(maxLength) && maxLength > 0
+    ? Math.floor(maxLength)
+    : BLOCKER_NAME_MAX_LENGTH
+  const characters = Array.from(text)
+  if (characters.length <= limit) return text
+  if (limit === 1) return BLOCKER_ELLIPSIS
+  return characters.slice(0, limit - 1).join('') + BLOCKER_ELLIPSIS
+}
+
+/**
+ * One trimmed string field of a blocker, or '' when the field is missing.
+ *
+ * @param {any} entry
+ * @param {string} key
+ * @returns {string}
+ */
+function blockerField(entry, key) {
+  if (!entry || typeof entry !== 'object') return ''
+  const value = entry[key]
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+/**
+ * WHAT a blocker is: a session, a subagent or a pending restart.
+ *
+ * The Host says it (`kind`), but the kind is NOT the only evidence: an
+ * entry that names a parent session (`parentSessionId` / `parentTitle`) IS
+ * a subagent, whatever the Host called it. A Host that does not label the
+ * kind must not turn a team of subagents into a list of single items.
+ *
+ * @param {any} entry
+ * @returns {'session'|'subagent'|'restart-pending'}
+ */
+function blockerEntryKind(entry) {
+  if (!entry || typeof entry !== 'object') return 'session'
+  if (entry.kind === 'restart-pending') return 'restart-pending'
+  if (entry.kind === 'subagent') return 'subagent'
+  if (entry.kind === 'session') return 'session'
+  if (blockerField(entry, 'parentSessionId') !== '' || blockerField(entry, 'parentTitle') !== '') {
+    return 'subagent'
+  }
+  return 'session'
+}
+
+/**
+ * The title of the session a subagent belongs to.
+ *
+ * For a subagent the Host's `label` IS the title of the session that
+ * created it (that is what the "…的子智能体" name is built from);
+ * `parentTitle` is the same title under its own name, and `title` is the
+ * old alias of `label`.
+ *
+ * @param {any} entry
+ * @returns {string}
+ */
+function blockerParentTitle(entry) {
+  return blockerField(entry, 'label')
+    || blockerField(entry, 'parentTitle')
+    || blockerField(entry, 'title')
+}
+
+/**
+ * The identity of the session that created a subagent — the key its
+ * subagents are grouped by.
+ *
+ * The parent session id is the exact identity. The parent's title is the
+ * fallback for the surfaces that do not carry the id: the shutdown card
+ * reports `parentTitle` but NO `parentSessionId`, so without this
+ * fallback every member of a team would become an item of its own.
+ *
+ * @param {any} entry
+ * @returns {string|null}
+ */
+function blockerParentKey(entry) {
+  const id = blockerField(entry, 'parentSessionId')
+  if (id !== '') return 'id:' + id
+  const title = blockerField(entry, 'parentTitle')
+  if (title !== '') return 'title:' + title
+  const label = blockerField(entry, 'label')
+  if (label !== '') return 'label:' + label
+  return null
+}
+
+/**
+ * The readable name of one blocker.
+ *
+ * The Host names a session by its title (`label`, also carried as `name`)
+ * and a subagent by the whole phrase ("<that session>'s subagent"). A
+ * surface that carries the title under the old name (`title`) still gets a
+ * name; an entry without any of them has nothing to show.
+ *
+ * @param {any} entry
+ * @returns {string}
+ */
+function blockerEntryName(entry) {
+  if (!entry || typeof entry !== 'object') return ''
+  return blockerField(entry, 'name')
+    || blockerField(entry, 'label')
+    || blockerField(entry, 'title')
+    || blockerField(entry, 'parentTitle')
+}
+
+/**
+ * The blockers of one list, grouped by the session that created them.
+ *
+ * A subagent belongs to the session that spawned it, so N subagents of one
+ * session are ONE item. A plain session is an item of its own: it is a
+ * conversation in its own right, even when its own subagents are busy too.
+ *
+ * The group key is the parent session id when the surface reports it, and
+ * the parent's TITLE when it does not (the shutdown card reports
+ * `parentTitle` but no id).
+ *
+ * @param {any[]} entries the blockers the Host reported
+ * @returns {Array<{ key: string, kind: string, label: string, name: string, count: number, entry: any, sessionIds: string[] }>}
+ */
+function groupBlockers(entries) {
+  const list = Array.isArray(entries) ? entries : []
+  const groups = []
+  const byKey = new Map()
+  for (const entry of list) {
+    if (!entry || typeof entry !== 'object') continue
+    const kind = blockerEntryKind(entry)
+    // A subagent of a KNOWN session joins that session's group. A subagent
+    // whose parent is unknown joins the one generic group of parentless
+    // subagents — they are counted ("N subagents"), not listed one by one.
+    const parent = kind === 'subagent' ? (blockerParentKey(entry) || 'unknown') : null
+    const sessionId = entry.sessionId == null ? '' : String(entry.sessionId)
+    const key = parent !== null ? 'parent:' + parent : 'own:' + kind + ':' + sessionId
+    let group = byKey.get(key)
+    if (!group) {
+      group = {
+        key,
+        kind,
+        parentSessionId: blockerField(entry, 'parentSessionId') || null,
+        // The label of a subagent group is the title of the session that
+        // created it; the label of a session is its own title.
+        label: kind === 'subagent'
+          ? blockerParentTitle(entry)
+          : (blockerField(entry, 'label') || blockerField(entry, 'title')),
+        name: blockerEntryName(entry),
+        count: 0,
+        entry,
+        sessionIds: [],
+      }
+      byKey.set(key, group)
+      groups.push(group)
+    }
+    group.count += 1
+    group.sessionIds.push(sessionId)
+    if (group.label === '') {
+      group.label = kind === 'subagent'
+        ? blockerParentTitle(entry)
+        : (blockerField(entry, 'label') || blockerField(entry, 'title'))
+    }
+    if (group.name === '') group.name = blockerEntryName(entry)
+  }
+  return groups
+}
+
+/**
+ * The name of one group, as it is shown.
+ *
+ * A group of more than one subagent is named after the session that
+ * created them ("<that session> (N subagents)"); a lone subagent keeps its
+ * own name ("<that session>'s subagent").
+ *
+ * @param {any} group one group of `groupBlockers`
+ * @param {(name: string) => string} t the translator
+ * @param {number} maxLength how many characters the name may have
+ * @param {boolean} shorten whether the name may be shortened
+ * @returns {string}
+ */
+function blockerGroupName(group, t, maxLength, shorten) {
+  if (!group) return ''
+  const translate = typeof t === 'function' ? t : (name) => name
+  if (group.kind === 'subagent') {
+    // A group of MORE THAN ONE subagent is named after the session that
+    // created them ("<that session> (N subagents)"); a lone subagent keeps
+    // its own name ("<that session>'s subagent").
+    if (group.count > 1) {
+      const label = shorten ? truncateBlockerName(group.label, maxLength) : group.label
+      return label === ''
+        ? fillTemplate(translate('blockerGroupSubagentsGeneric'), { n: group.count })
+        : fillTemplate(translate('blockerGroupSubagents'), { label, n: group.count })
+    }
+    const own = group.name || group.label
+    if (own !== '') return shorten ? truncateBlockerName(own, maxLength) : own
+    // A lone subagent without any name at all: the generic line still says
+    // something — an empty name never reaches the interface.
+    return fillTemplate(translate('blockerGroupSubagentsGeneric'), { n: group.count })
+  }
+  const name = group.name || group.label
+  return shorten ? truncateBlockerName(name, maxLength) : name
+}
+
+/**
+ * The names of the blockers: a SHORT summary for the bubble and the
+ * COMPLETE list for the tooltip.
+ *
+ * The summary never grows without a bound: at most `limit` items, every
+ * name shortened to `maxNameLength` characters, and a "… and N more" for
+ * the rest. The complete list names every group with its full name — it is
+ * only ever shown in a tooltip, where there is room for it.
+ *
+ * @param {any[]} entries the blockers the Host reported
+ * @param {{ t?: Function, limit?: number, maxNameLength?: number, joiner?: string }} [options]
+ * @returns {{ groups: any[], summary: string, full: string, total: number }}
+ */
+function summarizeBlockers(entries, options) {
+  const opts = options && typeof options === 'object' ? options : {}
+  const translate = typeof opts.t === 'function' ? opts.t : (name) => name
+  const limit = Number.isFinite(opts.limit) && opts.limit > 0
+    ? Math.floor(opts.limit)
+    : BLOCKER_SUMMARY_LIMIT
+  const maxNameLength = Number.isFinite(opts.maxNameLength) && opts.maxNameLength > 0
+    ? Math.floor(opts.maxNameLength)
+    : BLOCKER_NAME_MAX_LENGTH
+  const joiner = typeof opts.joiner === 'string' ? opts.joiner : translate('blockerJoin')
+  const groups = groupBlockers(entries)
+
+  const full = groups
+    .map((group) => blockerGroupName(group, translate, maxNameLength, false))
+    .filter((name) => name !== '')
+    .join(joiner)
+
+  const shown = groups.slice(0, limit)
+  const names = shown
+    .map((group) => blockerGroupName(group, translate, maxNameLength, true))
+    .filter((name) => name !== '')
+  const rest = groups.length - shown.length
+  const more = rest > 0 ? fillTemplate(translate('blockerMore'), { n: rest }) : ''
+
+  return {
+    groups,
+    total: groups.length,
+    // How many of the groups carry a name at all: a list of unnamed blockers
+    // has nothing to show, so a caller can leave its clause out.
+    named: groups.filter((group) => blockerGroupName(group, translate, maxNameLength, false) !== '').length,
+    summary: names.length === 0 ? translate('blockerGeneric') : (names.join(joiner) + more),
+    full: full === '' ? translate('blockerGeneric') : full,
+  }
+}
+
+/**
+ * The note of a LONG wait.
+ *
+ * The Host says that the pending restart passed the hard deadline while a
+ * conversation was still running. That is not "a little longer" any more, so
+ * the bubble says it out loud: how long the restart has been waiting and who
+ * holds it. The note is empty when there is no long wait.
+ *
+ * @param {any} info the state payload of the Host
+ * @param {(name: string) => string} [t] the translator
+ * @returns {string}
+ */
+function formatLongWaitNote(info, t) {
+  return formatLongWaitNoteParts(info, t).note
+}
+
+/**
+ * The note of a LONG wait, in both shapes: the CAPSULE shows the numbers
+ * only, the tooltip the COMPLETE list.
+ *
+ * The capsule of the pending restart is 22px high and ONE line wide: a name
+ * in it is a name that gets clipped away. So the capsule says HOW LONG the
+ * restart has been waiting and HOW MANY tasks are running — never WHO they
+ * are — and every name goes into the tooltip.
+ *
+ * @param {any} info the state payload of the Host
+ * @param {(name: string) => string} [t] the translator
+ * @returns {{ note: string, full: string, pill: string, summary: string, count: number, hasLongWait: boolean }}
+ */
+function formatLongWaitNoteParts(info, t) {
+  const translate = typeof t === 'function' ? t : (name) => name
+  const longWait = info && typeof info === 'object' ? info.longWait : null
+  if (!longWait || typeof longWait !== 'object') {
+    return { note: '', full: '', pill: '', summary: '', count: 0, hasLongWait: false }
+  }
+  const blockedBy = Array.isArray(longWait.blockedBy) ? longWait.blockedBy : []
+  const summary = summarizeBlockers(blockedBy, { t: translate })
+  // The precise duration belongs into the tooltip, the COMPACT one into the
+  // capsule: the capsule cannot afford "16 分 37 秒".
+  const duration = formatDurationMs(longWait.waitedMs, translate)
+  const compact = formatCompactDurationMs(longWait.waitedMs, translate)
+  const count = blockedBy.length
+  // The tooltip: the whole story, every name, nothing cut.
+  const sentence = fillTemplate(translate('longWaitTooltip'), { duration, blockers: summary.full })
+  return {
+    // The CAPSULE: numbers only, no name at all.
+    pill: fillTemplate(translate('longWaitPill'), { duration: compact, n: count }),
+    note: sentence,
+    full: sentence,
+    summary: summary.summary,
+    count,
+    hasLongWait: true,
+  }
+}
+
 /**
  * The named exports of this module.
  *
  * The client module system materializes `factory(require) -> exports`, so
- * these four helpers ARE the module's exports; they are mirrored on
+ * these helpers ARE the module's exports; they are mirrored on
  * `globalThis.__dshAutorestartClient` for the tests that evaluate the file
  * without a loader.
  */
@@ -548,6 +1048,14 @@ const SLEEP_EXPORTS = {
   shouldShowSleepButton,
   buildChoiceBody,
   formatRemainingMs,
+  formatLongWaitNote,
+  formatLongWaitNoteParts,
+  formatCompactDurationMs,
+  groupBlockers,
+  summarizeBlockers,
+  truncateBlockerName,
+  // The two dictionaries, so a test can build a translator without a Host.
+  dictionaries: { zh: ZH, en: EN },
 }
 
 if (typeof globalThis !== 'undefined' && globalThis !== null) {
@@ -782,16 +1290,18 @@ if (moduleLoader) moduleLoader.load({
      */
     function blockerLine(entry) {
       const t = translate ?? ((name) => name)
-      const kind = entry && entry.kind === 'subagent'
-        ? 'subagent'
-        : (entry && entry.kind === 'restart-pending' ? 'restart-pending' : 'session')
-      const label = entry && typeof entry.label === 'string' ? entry.label.trim() : ''
+      // The SAME rule as the grouping: an entry that names a parent is a
+      // subagent, whatever the Host called it.
+      const kind = blockerEntryKind(entry)
+      const label = kind === 'subagent'
+        ? blockerParentTitle(entry)
+        : (blockerField(entry, 'label') || blockerField(entry, 'title'))
       if (kind === 'restart-pending') {
         // A pending restart goes first: the shutdown waits for it.
         return t('panelBlockedRestartPending')
       }
       if (kind === 'subagent') {
-        const name = entry && typeof entry.name === 'string' ? entry.name.trim() : ''
+        const name = blockerField(entry, 'name')
         if (name === '' || label === '') return t('panelBlockedSubagentGeneric')
         return fill(t('panelBlockedSubagent'), { name })
       }
@@ -813,6 +1323,27 @@ if (moduleLoader) moduleLoader.load({
       return Boolean(entry) && entry.kind === 'restart-pending'
     }
 
+    /**
+     * The line of one GROUP of blockers.
+     *
+     * The N subagents of ONE session are one line: the session is named once
+     * and the number of its subagents says how many there are. A group of one
+     * keeps the ordinary line (a session, or a lone subagent).
+     *
+     * @param {any} group one group of `groupBlockers`
+     * @returns {string}
+     */
+    function blockerGroupLine(group) {
+      const t = translate ?? ((name) => name)
+      if (!group) return ''
+      if (group.kind === 'subagent' && group.count > 1) {
+        return group.label === ''
+          ? fill(t('panelBlockedSubagentGroupGeneric'), { n: group.count })
+          : fill(t('panelBlockedSubagentGroup'), { label: group.label, n: group.count })
+      }
+      return blockerLine(group.entry)
+    }
+
     /** How long the pending restart has been waiting, as a locale string. */
     function formatWaiting(ms, t) {
       const totalSeconds = Math.max(0, Math.floor((ms || 0) / 1000))
@@ -952,6 +1483,18 @@ if (moduleLoader) moduleLoader.load({
       whiteSpace: 'nowrap',
     }
 
+    // The extra line of a LONG wait: how long the restart has been waiting and
+    // who holds it. It is a separate element (not more text in the same span)
+    // so the bubble can tell "the ordinary status" from "the long wait", and
+    // it stays inside the clipped pill — the composer row never grows.
+    const LONG_WAIT_STYLE = {
+      minWidth: 0,
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+      opacity: 0.85,
+    }
+
     // The details panel: anchored to the wrapper, above the pill, left
     // aligned. It uses the host theme tokens (background / border / label
     // color) so it follows the app theme.
@@ -1260,14 +1803,52 @@ if (moduleLoader) moduleLoader.load({
       const goalActive = others.filter((entry) => String(entry.reason) === 'goal-active')
       const goalExhausted = others.filter((entry) => String(entry.reason) === 'goal-exhausted')
       const otherBusy = others.length - goalActive.length - goalExhausted.length
+      // The tasks that are NOT a goal: the count and the names of the waiting
+      // sentence talk about the same set.
+      const busyBlockers = others.filter(
+        (entry) => String(entry.reason) !== 'goal-active' && String(entry.reason) !== 'goal-exhausted',
+      )
 
-      const status = goalActive.length > 0
-        ? t('goalActive')
-        : goalExhausted.length > 0
-          ? t('goalExhausted')
-          : otherBusy > 0
-            ? `${t('busyPrefix')}${otherBusy}${t('busySuffix')}`
-            : t('idle')
+      // WHY the gate is closed: the Host reports the reason next to the
+      // blockers. With no blocker but the reason "settling" the restart is
+      // waiting for the quiet window — not for a conversation.
+      const gateReason = info && typeof info.reason === 'string' ? info.reason : ''
+
+      // The long wait: the Host says that the restart passed the hard
+      // deadline while a conversation was still running. The capsule shows one
+      // more line about it — how long it has been waiting and how many tasks
+      // are running.
+      const longWait = formatLongWaitNoteParts(info, t)
+      // The blockers of the ordinary list: the SAME rule as the long wait
+      // (grouped by the session that created them).
+      const blockers = summarizeBlockers(busyBlockers, { t })
+
+      // The capsule is ONE clipped line of 22px: it holds a NUMBER and a
+      // duration, never a NAME. Every name goes into the tooltip, where
+      // there is room for all of them.
+      //
+      // A long wait says it ONCE: its own line carries the duration and the
+      // count, so the ordinary "waiting for N tasks" sentence is left out —
+      // it would say the same thing twice and take twice the width.
+      const status = longWait.hasLongWait
+        ? ''
+        : goalActive.length > 0
+          ? t('goalActive')
+          : goalExhausted.length > 0
+            ? t('goalExhausted')
+            : otherBusy > 0
+              ? `${t('busyPrefix')}${otherBusy}${t('busySuffix')}`
+              : (gateReason === 'settling' ? t('settling') : t('idle'))
+
+      const tooltipText = otherBusy > 0 ? t('tooltipBusy') : t('tooltip')
+      // The tooltip carries the COMPLETE list of the blockers: the capsule
+      // shows numbers only, the tooltip every name.
+      const detail = longWait.hasLongWait
+        ? longWait.full
+        : (blockers.total === 0 ? '' : fill(t('blockersTitleLine'), { blockers: blockers.full }))
+      const titleText = parkError
+        ? fill(t('tooltipWithError'), { message: parkError })
+        : (detail === '' ? tooltipText : `${tooltipText} ${detail}`)
 
       if (pulsing) ensurePulseStyle()
 
@@ -1330,12 +1911,25 @@ if (moduleLoader) moduleLoader.load({
           'div',
           {
             style: PILL_STYLE,
-            title: parkError
-              ? fill(t('tooltipWithError'), { message: parkError })
-              : (otherBusy > 0 ? t('tooltipBusy') : t('tooltip')),
+            title: titleText,
           },
           h('span', { style: dotStyle(DOT_STYLE, pulsing), 'aria-hidden': 'true' }),
           h('span', { style: TEXT_STYLE }, h('b', null, t('label')), status),
+          // One more line for the long wait: how long the restart has been
+          // waiting and how many tasks are running. It is only there when the
+          // Host says so. The line carries NO name at all — it is one
+          // clipped line — and its own tooltip carries the COMPLETE list.
+          longWait.pill === ''
+            ? null
+            : h(
+              'span',
+              {
+                style: LONG_WAIT_STYLE,
+                'data-dsh-autorestart-long-wait': 'true',
+                title: longWait.full,
+              },
+              longWait.pill,
+            ),
           // One park button per goal-driven blocker that can be parked. It
           // lives inside the pill, so the slot still has a single root.
           goalActive.map((entry, index) => {
@@ -1393,9 +1987,14 @@ if (moduleLoader) moduleLoader.load({
       const pulsing = info.allowRestart === true && !prefersReducedMotion()
       if (pulsing) ensurePulseStyle()
 
+      // The long wait is worth a word in the tooltip too: the dot is
+      // icon-only, so the text is the only place where it can be read.
+      // The tooltip carries the COMPLETE list of the blockers.
+      const longWait = formatLongWaitNoteParts(info, t)
+
       return h('span', {
         style: dotStyle(SIDEBAR_DOT_STYLE, pulsing),
-        title: t('tooltip'),
+        title: longWait.hasLongWait ? `${t('tooltip')} ${longWait.full}` : t('tooltip'),
         role: 'status',
         'aria-live': 'polite',
         'aria-label': t('dotAria'),
@@ -2146,6 +2745,9 @@ if (moduleLoader) moduleLoader.load({
       '.dsh-autorestart-sleep-waiting__body{margin:0 0 6px;}',
       '.dsh-autorestart-sleep-waiting__list{margin:0 0 6px;padding-left:2px;list-style:none;}',
       '.dsh-autorestart-sleep-waiting__list li{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}',
+      // The line that says how many blockers are NOT shown: it is a note,
+      // not a blocker of its own.
+      '.dsh-autorestart-sleep-waiting__more{opacity:.7;}',
       '.dsh-autorestart-sleep-waiting__none{margin:0 0 6px;opacity:.8;}',
       // The command a rehearsal WOULD have run: it has to stay readable,
       // whatever the shell command looks like.
@@ -2182,6 +2784,21 @@ if (moduleLoader) moduleLoader.load({
       '}',
       // The configuration page of the plugin row.
       '.dsh-autorestart-settings{display:flex;flex-direction:column;gap:14px;}',
+      // The two titled groups (restart first, shutdown after it).
+      '.dsh-autorestart-settings__group{',
+      '  display:flex;',
+      '  flex-direction:column;',
+      '  gap:12px;',
+      '  padding:12px 14px;',
+      '  border:1px solid var(--dsw-alias-border-l1);',
+      '  border-radius:10px;',
+      '}',
+      '.dsh-autorestart-settings__group-title{',
+      '  font-size:12px;',
+      '  font-weight:700;',
+      '  line-height:18px;',
+      '  color:var(--dsw-alias-label-secondary);',
+      '}',
       '.dsh-autorestart-settings__field{display:flex;flex-direction:column;gap:4px;}',
       '.dsh-autorestart-settings__label{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);}',
       '.dsh-autorestart-settings__select{',
@@ -2340,12 +2957,17 @@ if (moduleLoader) moduleLoader.load({
      * in the settings sidebar).
      *
      * The Host renders this section for the slot `settings.section` with the
-     * id `dsh-autorestart`. It carries exactly the three settings that
-     * matter:
+     * id `dsh-autorestart`. The settings are split into two titled groups:
+     *
+     *   - "Restart settings": how long the host waits before a restart (a
+     *     dropdown), whether the pre-restart backup is taken at all (a
+     *     switch) and whether that backup also snapshots the installed
+     *     plugins (a switch);
+     *   - "Shutdown settings": how long the visible countdown of the
+     *     graceful shutdown runs (a dropdown).
      *
-     *   - how long the countdown runs (a dropdown),
-     *   - whether the pre-restart backup is taken at all (a switch),
-     *   - whether that backup also snapshots the installed plugins (a switch).
+     * The restart group comes first. The shutdown has no invisible reserve:
+     * its countdown on screen IS the wait before the machine goes off.
      *
      * A change is written to the profile configuration at once (through the
      * plugin's own choice route, which uses the official `configEditor`
@@ -2378,15 +3000,14 @@ if (moduleLoader) moduleLoader.load({
       const backupIncludePlugins = status && typeof status === 'object' && typeof status.backupIncludePlugins === 'boolean'
         ? status.backupIncludePlugins
         : true
-      // The grace window: how long the host waits after the last conversation
-      // finished. The Host reports it in milliseconds; the dropdown works in
-      // seconds.
-      const reportedGraceMs = status && typeof status === 'object' && typeof status.graceMs === 'number'
-        ? status.graceMs
+      // The RESTART reserve: the Host reports it in milliseconds, the
+      // dropdown works in seconds.
+      const reportedRestartGraceMs = status && typeof status === 'object' && typeof status.restartGraceMs === 'number'
+        ? status.restartGraceMs
         : GRACE_DEFAULT_MS
-      const graceSeconds = GRACE_CHOICES_SECONDS.indexOf(Math.round(reportedGraceMs / 1000)) === -1
+      const restartGraceSeconds = GRACE_CHOICES_SECONDS.indexOf(Math.round(reportedRestartGraceMs / 1000)) === -1
         ? GRACE_DEFAULT_SECONDS
-        : Math.round(reportedGraceMs / 1000)
+        : Math.round(reportedRestartGraceMs / 1000)
 
       /**
        * Write one change into the profile configuration.
@@ -2429,101 +3050,128 @@ if (moduleLoader) moduleLoader.load({
       return h(
         'div',
         { className: 'dsh-autorestart-settings' },
+        // The panel is split into two titled groups: the RESTART settings
+        // come first, the SHUTDOWN settings after them. The two situations
+        // are different, so they do not share one flat list.
         h(
-          'label',
-          { className: 'dsh-autorestart-settings__field' },
-          h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.seconds.label')),
+          'div',
+          {
+            className: 'dsh-autorestart-settings__group',
+            'data-dsh-autorestart-group': 'restart',
+          },
           h(
-            'select',
-            {
-              className: 'dsh-autorestart-settings__select',
-              value: String(seconds),
-              disabled: busy,
-              'data-dsh-autorestart-setting': 'sleepCountdownSeconds',
-              onChange: (event) => {
-                const value = Number(event && event.target ? event.target.value : NaN)
-                if (!Number.isFinite(value) || value === seconds) return
-                void save({ sleepCountdownSeconds: value })
+            'div',
+            { className: 'dsh-autorestart-settings__group-title' },
+            t('settings.groups.restart'),
+          ),
+          h(
+            'label',
+            { className: 'dsh-autorestart-settings__field' },
+            h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.restartGrace.label')),
+            h(
+              'select',
+              {
+                className: 'dsh-autorestart-settings__select',
+                value: String(restartGraceSeconds),
+                disabled: busy,
+                'data-dsh-autorestart-setting': 'restartGraceMs',
+                onChange: (event) => {
+                  const value = Number(event && event.target ? event.target.value : NaN)
+                  if (!Number.isFinite(value) || value === restartGraceSeconds) return
+                  void save({ restartGraceMs: value * 1000 })
+                },
               },
-            },
-            SLEEP_COUNTDOWN_CHOICES.map((choice) => h(
-              'option',
-              { key: String(choice), value: String(choice) },
-              choice === 0 ? t('settings.seconds.immediate') : fill(t('settings.seconds.value'), { n: choice }),
-            )),
+              GRACE_CHOICES_SECONDS.map((choice) => h(
+                'option',
+                { key: String(choice), value: String(choice) },
+                choice === 0
+                  ? t('settings.restartGrace.immediate')
+                  : fill(t('settings.restartGrace.value'), { n: choice }),
+              )),
+            ),
+            h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.restartGrace.hint')),
           ),
-          h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.seconds.hint')),
-        ),
-        h(
-          'label',
-          { className: 'dsh-autorestart-settings__field' },
-          h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.grace.label')),
           h(
-            'select',
-            {
-              className: 'dsh-autorestart-settings__select',
-              value: String(graceSeconds),
-              disabled: busy,
-              'data-dsh-autorestart-setting': 'restartGraceMs',
-              onChange: (event) => {
-                const value = Number(event && event.target ? event.target.value : NaN)
-                if (!Number.isFinite(value) || value === graceSeconds) return
-                void save({ restartGraceMs: value * 1000 })
+            'label',
+            { className: 'dsh-autorestart-settings__field' },
+            h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.backup.label')),
+            h(
+              'input',
+              {
+                type: 'checkbox',
+                className: 'dsh-autorestart-settings__switch',
+                checked: backupOnRestart,
+                disabled: busy,
+                'data-dsh-autorestart-setting': 'backupOnRestart',
+                onChange: (event) => {
+                  const value = Boolean(event && event.target ? event.target.checked : false)
+                  if (value === backupOnRestart) return
+                  void save({ backupOnRestart: value })
+                },
               },
-            },
-            GRACE_CHOICES_SECONDS.map((choice) => h(
-              'option',
-              { key: String(choice), value: String(choice) },
-              choice === 0
-                ? t('settings.grace.immediate')
-                : fill(t('settings.grace.value'), { n: choice }),
-            )),
+            ),
+            h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.backup.hint')),
           ),
-          h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.grace.hint')),
-        ),
-        h(
-          'label',
-          { className: 'dsh-autorestart-settings__field' },
-          h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.backup.label')),
           h(
-            'input',
-            {
-              type: 'checkbox',
-              className: 'dsh-autorestart-settings__switch',
-              checked: backupOnRestart,
-              disabled: busy,
-              'data-dsh-autorestart-setting': 'backupOnRestart',
-              onChange: (event) => {
-                const value = Boolean(event && event.target ? event.target.checked : false)
-                if (value === backupOnRestart) return
-                void save({ backupOnRestart: value })
+            'label',
+            { className: 'dsh-autorestart-settings__field' },
+            h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.backupPlugins.label')),
+            h(
+              'input',
+              {
+                type: 'checkbox',
+                className: 'dsh-autorestart-settings__switch',
+                checked: backupIncludePlugins,
+                // Without a pre-restart backup there is nothing to extend: the
+                // switch is greyed out (and the Host never reads it).
+                disabled: busy || !backupOnRestart,
+                'data-dsh-autorestart-setting': 'backupIncludePlugins',
+                onChange: (event) => {
+                  const value = Boolean(event && event.target ? event.target.checked : false)
+                  if (value === backupIncludePlugins) return
+                  void save({ backupIncludePlugins: value })
+                },
               },
-            },
+            ),
+            h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.backupPlugins.hint')),
           ),
-          h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.backup.hint')),
         ),
         h(
-          'label',
-          { className: 'dsh-autorestart-settings__field' },
-          h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.backupPlugins.label')),
+          'div',
+          {
+            className: 'dsh-autorestart-settings__group',
+            'data-dsh-autorestart-group': 'shutdown',
+          },
           h(
-            'input',
-            {
-              type: 'checkbox',
-              className: 'dsh-autorestart-settings__switch',
-              checked: backupIncludePlugins,
-              // Without a pre-restart backup there is nothing to extend: the
-              // switch is greyed out (and the Host never reads it).
-              disabled: busy || !backupOnRestart,
-              'data-dsh-autorestart-setting': 'backupIncludePlugins',
-              onChange: (event) => {
-                const value = Boolean(event && event.target ? event.target.checked : false)
-                if (value === backupIncludePlugins) return
-                void save({ backupIncludePlugins: value })
+            'div',
+            { className: 'dsh-autorestart-settings__group-title' },
+            t('settings.groups.shutdown'),
+          ),
+          h(
+            'label',
+            { className: 'dsh-autorestart-settings__field' },
+            h('span', { className: 'dsh-autorestart-settings__label' }, t('settings.seconds.label')),
+            h(
+              'select',
+              {
+                className: 'dsh-autorestart-settings__select',
+                value: String(seconds),
+                disabled: busy,
+                'data-dsh-autorestart-setting': 'sleepCountdownSeconds',
+                onChange: (event) => {
+                  const value = Number(event && event.target ? event.target.value : NaN)
+                  if (!Number.isFinite(value) || value === seconds) return
+                  void save({ sleepCountdownSeconds: value })
+                },
               },
-            },
+              SLEEP_COUNTDOWN_CHOICES.map((choice) => h(
+                'option',
+                { key: String(choice), value: String(choice) },
+                choice === 0 ? t('settings.seconds.immediate') : fill(t('settings.seconds.value'), { n: choice }),
+              )),
+            ),
+            h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.seconds.hint')),
           ),
-          h('span', { className: 'dsh-autorestart-settings__hint' }, t('settings.backupPlugins.hint')),
         ),
         error === ''
           ? null
@@ -2999,6 +3647,11 @@ if (moduleLoader) moduleLoader.load({
         const subagentCount = tasks.filter(
           (entry) => entry && entry.kind === 'subagent',
         ).length
+        // The list of the card: the SAME rule as the bubble (the subagents of
+        // one session are one item, the list is capped), so a team of a dozen
+        // members does not become a dozen lines.
+        const pending = blockers.filter((entry) => isRestartPending(entry))
+        const grouped = summarizeBlockers(tasks, { t })
         return h(
           'div',
           {
@@ -3024,10 +3677,29 @@ if (moduleLoader) moduleLoader.load({
             )
             : h(
               'ul',
-              { className: 'dsh-autorestart-sleep-waiting__list' },
-              blockers.map((entry, index) => h(
+              {
+                className: 'dsh-autorestart-sleep-waiting__list',
+                // The tooltip carries the COMPLETE list: the card itself
+                // shows a short one (the same rule as the bubble).
+                title: grouped.full,
+              },
+              grouped.groups.slice(0, BLOCKER_SUMMARY_LIMIT).map((group, index) => h(
                 'li',
                 { key: 'blocker-' + index },
+                blockerGroupLine(group),
+              )),
+              grouped.groups.length > BLOCKER_SUMMARY_LIMIT
+                ? h(
+                  'li',
+                  { key: 'blocker-more', className: 'dsh-autorestart-sleep-waiting__more' },
+                  fill(t('blockerMore'), { n: grouped.groups.length - BLOCKER_SUMMARY_LIMIT }),
+                )
+                : null,
+              // A pending restart is not a task: it is what the shutdown waits
+              // for, so it is never part of the grouped list.
+              pending.map((entry, index) => h(
+                'li',
+                { key: 'pending-' + index },
                 blockerLine(entry),
               )),
             ),