dsh-autorestart 0.8.1 → 0.8.3

package/client.js

@@ -155,7 +155,7 @@
   const ZH = {
     label: '待重启',
     busyPrefix: ' · 等待 ',
-    busySuffix: ' 个任务结束',
+    busySuffix: ' 个会话',
     idle: ' · 空闲后自动重启',
     goalActive: ' · 被某个自动续跑的 goal 占着',
     goalExhausted: ' · 某个任务的 goal 轮次额度已用完，无法续跑',
@@ -166,7 +166,7 @@
     parkBusy: '停泊中…',
     parkError: '停泊失败：{message}',
     tooltip: '等待其他会话空闲后自动重启；重启后会自动继续本会话进度',
-    tooltipBusy: '等待其他任务结束（计数含“排队但还没开始”的任务）后自动重启；重启后本会话会自动继续进度',
+    tooltipBusy: '等待其他会话结束（计数含“排队但还没开始”的会话）后自动重启；重启后本会话会自动继续进度',
     tooltipWithError: '等待其他会话空闲后自动重启；重启后本会话会自动继续进度。{message}',
     dotAria: '待重启',
     panelHeading: '待重启',
@@ -219,12 +219,13 @@
     // The manual cancel of the capsule: the panel, the confirmation and the
     // readable reasons. The capsule's own text stays free of hints — the panel
     // is the discoverability.
-    cancelPanelTasks: '这次重启还在等 {n} 个任务结束',
+    cancelPanelTasks: '还在等 {n} 个会话',
     cancelPanelOthers: '还有 {n} 个会话也在等这次重启',
     cancelPanelOthersAfter: '还剩 {n} 个会话在等',
     cancelPanelAria: '待重启详情',
     cancelButton: '取消我的这次重启',
     cancelButtonAria: '取消我的这次重启',
+    cancelLocked: '正在重启，已经不能取消了',
     cancelConfirmTitle: '取消你的这次重启？',
     cancelConfirmOnlyMe: '取消后这次重启就不会发生了。',
     cancelConfirmOthers: '还有 {n} 个会话也在等这次重启——取消只影响你自己，他们仍会重启。',
@@ -374,8 +375,10 @@
     'settings.backup.copyPath': '复制路径',
     'settings.backup.copied': '路径已复制',
     'settings.backup.copyFailed': '复制失败，请手动选中上面的路径',
-    'settings.backup.withPlugins': '含已装插件',
-    'settings.backup.withoutPlugins': '只有配置',
+    'settings.backup.time': '备份时间',
+    'settings.backup.size': '备份大小',
+    'settings.backup.withPlugins': '（含已装插件）',
+    'settings.backup.withoutPlugins': '（不含已装插件）',
     'settings.groups.report': '报告问题',
     'settings.groups.rescue': '出事了怎么办',
     'settings.rescue.hint': 'DSH 打不开的时候，用下面这两个脚本救自己（都不用 DSH 跑起来）。',
@@ -411,6 +414,9 @@
     'settings.report.issueTitle': '重启 / 开机自启相关的问题',
     'settings.report.issueBody': '请把刚才复制的诊断信息粘贴到下面。\n\n## 发生了什么\n\n\n## 期望什么\n\n\n## 怎么复现\n',
     'settings.error': '没能保存设置：{message}',
+    'settings.saveNotice.saved': '已生效',
+    'settings.saveNotice.failed': '没保存成功',
+    'settings.saveNotice.dismiss': '关闭',
     'sleep.dryRun.title': '试运行：不会真的关机',
     'sleep.dryRun.body': '彩排结束，本来会执行这条命令（真的什么都没执行）：',
     'sleep.dryRun.close': '知道了',
@@ -472,12 +478,32 @@
     'announcement.disabled': '按钮目前关闭，可在设置里打开。',
     'announcement.button': '知道了',
     'announcement.error': '没能记下来：{message}',
+    // THE COPY OF THE COMPOSER ROW. It is one SHORT line and never a sentence:
+    // the long stage sentence was clipped away there (user report,
+    // 2026-10-29). While the gate waits the pill keeps its own composed line
+    // ("待重启 · 空闲后自动重启" / "待重启 · 等待 N 个会话"); the three
+    // other stages REPLACE that line with one of these.
+    'restart.stage.snapshotting': '重启前备份中',
+    'restart.stage.restarting': '正在重启…',
+    'restart.stage.back': '已回来',
+    // The centred overlay of a restart that is REALLY RUNNING (the backup, the
+    // shutdown, the return): one short line per stage, never wrapped, never cut
+    // with an ellipsis (the card shrinks its font instead). The numbers come
+    // from the Host's real measurements. There is no copy for `waiting`: no
+    // card is drawn while the gate merely waits.
+    'restart.overlay.snapshotting': 'DSH 重启前备份中',
+    // The unit travels WITH the number (KB or MB, chosen by the size): a 92 KB
+    // profile must never be rounded down to "0 MB".
+    'restart.overlay.size': '{done} / {total}',
+    'restart.overlay.sizeDone': '{done}',
+    'restart.overlay.restarting': '正在重启…',
+    'restart.overlay.back': '已回来',
   }
 
   const EN = {
     label: 'Pending restart',
     busyPrefix: ' · waiting for ',
-    busySuffix: ' task(s) to finish',
+    busySuffix: ' session(s)',
     idle: ' · restarts once idle',
     goalActive: ' · held by a self-continuing goal',
     goalExhausted: ' · a goal ran out of rounds',
@@ -490,7 +516,7 @@
     tooltip:
       'Waits for the other sessions to become idle, then restarts automatically; this session resumes its progress after the restart.',
     tooltipBusy:
-      'Waits for the other tasks to finish (the count includes work that is queued but not started yet), then restarts automatically; this session resumes its progress after the restart.',
+      'Waits for the other sessions to finish (the count includes work that is queued but not started yet), then restarts automatically; this session resumes its progress after the restart.',
     tooltipWithError:
       'Waits for the other sessions to become idle, then restarts automatically; this session resumes its progress after the restart. {message}',
     dotAria: 'Pending restart',
@@ -542,12 +568,13 @@
     // The manual cancel of the capsule: the panel, the confirmation and the
     // readable reasons. The capsule's own text stays free of hints — the panel
     // is the discoverability.
-    cancelPanelTasks: 'This restart is still waiting for {n} task(s) to finish',
+    cancelPanelTasks: 'Still waiting for {n} session(s)',
     cancelPanelOthers: '{n} other session(s) are waiting for this restart too',
     cancelPanelOthersAfter: '{n} session(s) are still waiting',
     cancelPanelAria: 'Pending restart details',
     cancelButton: 'Cancel my restart',
     cancelButtonAria: 'Cancel my restart',
+    cancelLocked: 'Restarting — this can no longer be cancelled',
     cancelConfirmTitle: 'Cancel your restart?',
     cancelConfirmOnlyMe: 'After this, the restart will not happen.',
     cancelConfirmOthers: '{n} other session(s) are waiting for this restart too — cancelling only affects you; they will still restart.',
@@ -697,8 +724,10 @@
     'settings.backup.copyPath': 'Copy the path',
     'settings.backup.copied': 'The path is on the clipboard',
     'settings.backup.copyFailed': 'The copy failed — please select the path above by hand',
-    'settings.backup.withPlugins': 'includes the installed plugins',
-    'settings.backup.withoutPlugins': 'configuration only',
+    'settings.backup.time': 'Backup time',
+    'settings.backup.size': 'Backup size',
+    'settings.backup.withPlugins': '(plugins included)',
+    'settings.backup.withoutPlugins': '(plugins excluded)',
     'settings.groups.report': 'Report a problem',
     'settings.groups.rescue': 'If DSH will not start',
     'settings.rescue.hint': 'When DSH does not come up, these two scripts rescue it for you (neither of them needs DSH running).',
@@ -734,6 +763,9 @@
     'settings.report.issueTitle': 'A problem with the restart / start at login',
     'settings.report.issueBody': 'Please paste the diagnostics you just copied below.\n\n## What happened\n\n\n## What you expected\n\n\n## How to reproduce\n',
     'settings.error': 'Could not save the settings: {message}',
+    'settings.saveNotice.saved': 'Saved',
+    'settings.saveNotice.failed': 'Not saved',
+    'settings.saveNotice.dismiss': 'Dismiss',
     'sleep.dryRun.title': 'Dry run: the machine stays on',
     'sleep.dryRun.body': 'The rehearsal is over. This is the command it WOULD have run (nothing was executed):',
     'sleep.dryRun.close': 'Got it',
@@ -795,6 +827,17 @@
     'announcement.disabled': 'The button is currently switched off; you can turn it on in the settings.',
     'announcement.button': 'Got it',
     'announcement.error': 'Could not record it: {message}',
+    // THE COPY OF THE COMPOSER ROW (see the Chinese block): one short line,
+    // never a sentence.
+    'restart.stage.snapshotting': 'Backing up…',
+    'restart.stage.restarting': 'Restarting…',
+    'restart.stage.back': 'Back',
+    // The centred overlay of a running restart.
+    'restart.overlay.snapshotting': 'Backing up before DSH restart',
+    'restart.overlay.size': '{done} / {total}',
+    'restart.overlay.sizeDone': '{done}',
+    'restart.overlay.restarting': 'Restarting…',
+    'restart.overlay.back': 'Back again',
   }
 
   /**
@@ -1382,6 +1425,40 @@
     return families.size
   }
 
+  /**
+   * THE number of tasks the pending restart waits for — ONE source for every
+   * surface of the interface.
+   *
+   * THE DEFECT THIS FIXES (user report, 2026-10-29)
+   *
+   * The capsule said "还有 1 个会话在忙" while the panel it opens said
+   * "这次重启还在等 0 个会话". Two numbers, ONE fact: the capsule counted
+   * the blockers itself, the panel re-counted a FILTERED copy of them (the own
+   * session dropped out, the goal blockers dropped out) — so the same pending
+   * restart was "1" on one line and "0" on the next.
+   *
+   * THE RULE
+   *
+   * The Host counts the TASKS that hold the gate and publishes the number as
+   * `busyCount` on its state route. Everything reads THAT number — the
+   * capsule, its panel and the long-wait line — so the two can never disagree
+   * again. Only a payload without the number (an older Host, a test fixture)
+   * falls back to counting the blockers, and then both surfaces count the SAME
+   * list.
+   *
+   * A blocker WITHOUT a readable name is still a task: the count never drops
+   * to 0 just because the name is missing.
+   *
+   * @param {any} info the state payload of the Host
+   * @param {any[]} [entries] the list to count when the Host sent no number
+   * @returns {number}
+   */
+  function waitingTaskCount(info, entries) {
+    const host = info && typeof info === 'object' ? info.busyCount : undefined
+    if (typeof host === 'number' && Number.isFinite(host) && host >= 0) return Math.floor(host)
+    return countBlockerTasks(Array.isArray(entries) ? entries : [])
+  }
+
   /**
    * How many of those tasks are carried by SUBAGENTS ONLY.
    *
@@ -1614,9 +1691,9 @@
     // capsule: the capsule cannot afford "16 分 37 秒".
     const duration = formatDurationMs(longWait.waitedMs, translate)
     const compact = formatCompactDurationMs(longWait.waitedMs, translate)
-    // The count is about TASKS, not blockers: a session and its own subagents
-    // are ONE task, exactly as the left sidebar counts them.
-    const count = countBlockerTasks(blockedBy)
+    // THE same number the capsule and its panel show (the Host's `busyCount`
+    // when it sends one): a session and its own subagents are ONE task.
+    const count = waitingTaskCount(info, blockedBy)
     // The tooltip: the whole story, every name, nothing cut.
     const sentence = fillTemplate(translate('longWaitTooltip'), { duration, blockers: summary.full })
     return {
@@ -1987,7 +2064,11 @@
   }
 
   /**
-   * The size of one backup, in MB (the manifest carries the byte count).
+   * The size of one backup, with the unit that fits it (the manifest carries
+   * the byte count).
+   *
+   * 92 KB stays 92 KB and 156 MB stays 156 MB: the tenth is kept only when it
+   * says something ("117.7 MB"), never as a pointless "156.0 MB".
    *
    * @param {number|null|undefined} bytes
    * @returns {string}
@@ -1995,21 +2076,150 @@
   function formatBackupSize(bytes) {
     const value = Number(bytes)
     if (!Number.isFinite(value) || value < 0) return ''
-    return (value / (1024 * 1024)).toFixed(1) + ' MB'
+    const units = [
+      { size: 1024 * 1024 * 1024, suffix: 'GB' },
+      { size: 1024 * 1024, suffix: 'MB' },
+      { size: 1024, suffix: 'KB' },
+    ]
+    for (const unit of units) {
+      if (value < unit.size) continue
+      const scaled = Math.round((value / unit.size) * 10) / 10
+      // 156.0 → 156, 117.7 → 117.7: the tenth only when it says something.
+      return (Number.isInteger(scaled) ? String(scaled) : scaled.toFixed(1)) + ' ' + unit.suffix
+    }
+    return Math.round(value) + ' B'
   }
 
   /**
-   * The local time of one backup.
+   * The local time of one backup, to the minute.
    *
    * The directory name is UTC on purpose, so the panel shows the LOCAL time
    * the manifest carries: a fresh snapshot can never look like an old one.
    *
+   * The OFFSET is dropped on purpose (user report, 2026-10-29): the string is
+   * already the local time of the machine that took the copy, so "+08:00" is
+   * noise to whoever reads it — and the seconds never say anything either.
+   *
    * @param {string|null|undefined} atLocal
    * @returns {string}
    */
   function formatBackupTime(atLocal) {
-    if (typeof atLocal !== 'string' || atLocal === '') return ''
-    return atLocal.replace('T', ' ')
+    if (typeof atLocal !== 'string' || atLocal.trim() === '') return ''
+    const text = atLocal.trim().replace('T', ' ')
+    // "2026-10-29 22:08:46+08:00" → "2026-10-29 22:08" (date and minute only).
+    const matched = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}/.exec(text)
+    if (matched) return matched[0]
+    // Anything else: at least never show an offset.
+    return text.replace(/ ?([+-]\d{2}:?\d{2}|Z)$/, '')
+  }
+
+  /**
+   * THE COPY OF THE COMPOSER ROW: one SHORT line, never a sentence.
+   *
+   * WHY (user report, 2026-10-29): the pill sits in the composer tool row — a
+   * single clipped line inside a 22px toolbar. The long stage sentence
+   * ("正在等待所有会话空闲…（还有 1 个会话在忙）") was cut off on a narrow
+   * window and the ellipsis ate exactly the part that mattered.
+   *
+   * SO the pill now shows ONE of these, and nothing else:
+   *
+   *   while the gate waits      待重启 · 空闲后自动重启   (the composed line of
+   *                             the pill itself — it already carries the short
+   *                             count of the tasks that hold the gate)
+   *   while the snapshot runs   重启前备份中
+   *   while the host goes down  正在重启…
+   *   after the new host is up  已回来           (1.5s, then the pill is plain)
+   *
+   * The detail — the number of busy conversations, the megabytes of the copy,
+   * the progress bar — lives in the CENTRED OVERLAY (`restart.overlay.*`),
+   * where there is room for it. The words come from the same dictionaries as
+   * everything else, so no surface has a second source of truth.
+   */
+  const RESTART_PILL_STAGE_KEYS = Object.freeze({
+    // `waiting` is deliberately MISSING: while the gate waits the pill already
+    // says "待重启 · 等待 N 个…" / "待重启 · 空闲后自动重启", and saying
+    // the stage as well would put two lines into a one-line row.
+    snapshotting: 'restart.stage.snapshotting',
+    restarting: 'restart.stage.restarting',
+    back: 'restart.stage.back',
+  })
+
+  /**
+   * The locale keys of the centred overlay.
+   *
+   * `waiting` is deliberately MISSING: while the gate waits for the other
+   * conversations there is NOTHING in progress yet, so no card is drawn at all
+   * (user report, 2026-10-29: "不是应该触发备份才触发吗？备份完就消失" — a card
+   * that said "等待会话空闲" hung on screen for ten minutes while the request
+   * merely queued). The waiting count belongs to the pill, which is where it
+   * always was: "待重启 · 等待 N 个会话".
+   */
+  const RESTART_OVERLAY_KEYS = Object.freeze({
+    snapshotting: 'restart.overlay.snapshotting',
+    restarting: 'restart.overlay.restarting',
+    back: 'restart.overlay.back',
+  })
+
+  /**
+   * Is this a stage the centred overlay draws at all?
+   *
+   * @param {unknown} phase
+   * @returns {boolean}
+   */
+  function isRestartOverlayPhase(phase) {
+    return typeof phase === 'string' && Object.prototype.hasOwnProperty.call(RESTART_OVERLAY_KEYS, phase)
+  }
+
+  /**
+   * THE COPY OF THE COMPOSER ROW for a stage ('' = the pill keeps its own
+   * composed line, "待重启 · …").
+   *
+   * @param {{ phase?: string }|null|undefined} stage the `restartPhase` payload
+   * @param {Function} [translator] the translator (the built-in one otherwise)
+   * @returns {string}
+   */
+  function restartPillStageText(stage, translator) {
+    const phase = stage && typeof stage === 'object' && typeof stage.phase === 'string' ? stage.phase : ''
+    if (!Object.prototype.hasOwnProperty.call(RESTART_PILL_STAGE_KEYS, phase)) return ''
+    const t = typeof translator === 'function' ? translator : makeTranslate(null)
+    return t(RESTART_PILL_STAGE_KEYS[phase])
+  }
+
+  /**
+   * The short line of the centred overlay for a stage ('' when there is none).
+   *
+   * @param {{ phase?: string }|null|undefined} stage
+   * @param {Function} [translator]
+   * @returns {string}
+   */
+  function restartOverlayTitle(stage, translator) {
+    const phase = stage && typeof stage === 'object' && typeof stage.phase === 'string' ? stage.phase : ''
+    if (!isRestartOverlayPhase(phase)) return ''
+    const t = typeof translator === 'function' ? translator : makeTranslate(null)
+    return t(RESTART_OVERLAY_KEYS[phase])
+  }
+
+  /**
+   * A SIZE, WITH THE UNIT THAT FITS IT: "92 KB", "156 MB", "12.3 MB", "0 B".
+   *
+   * WHY the unit is chosen here (user report, 2026-10-29): a hosted profile is
+   * only 92 KB. Printed in megabytes that is "0.1 MB" at best and "0 MB" after
+   * rounding — the size of a real backup would have looked like nothing at all.
+   * So: below 1 MB the number is KB, below 1 KB it is B, and a whole number of
+   * megabytes keeps no ".0".
+   *
+   * @param {number|null|undefined} bytes
+   * @returns {string} '' when the Host did not measure anything
+   */
+  function formatOverlaySize(bytes) {
+    // No measurement is NOT a measurement of zero: a missing byte count must
+    // never be printed as "0" (Number(null) is 0, which is exactly the trap).
+    if (bytes === null || bytes === undefined || bytes === '') return ''
+    const value = Number(bytes)
+    if (!Number.isFinite(value) || value < 0) return ''
+    if (value < 1024) return Math.round(value) + ' B'
+    if (value < 1024 * 1024) return Math.round(value / 1024) + ' KB'
+    return String(Math.round((value / (1024 * 1024)) * 10) / 10) + ' MB'
   }
 
   /**
@@ -2033,8 +2243,10 @@
     summarizeBlockers,
     truncateBlockerName,
     // The task count: one rule, four surfaces (mirrored from lib/blockers.js).
+    // `waitingTaskCount` is THE number the capsule and its panel both show.
     blockerTaskKeys,
     countBlockerTasks,
+    waitingTaskCount,
     countSubagentTasks,
     resolveAccessRedirect,
     supervisorModeLabel,
@@ -2060,6 +2272,14 @@
     startupStatusLine,
     formatBackupSize,
     formatBackupTime,
+    // The stage of a restart on the two surfaces that have room for it: the
+    // composer row (one short line) and the centred overlay (the detail).
+    isRestartOverlayPhase,
+    restartPillStageText,
+    restartOverlayTitle,
+    // The size with the unit that fits it ("92 KB", "156 MB"): a hosted profile
+    // is small enough that megabytes would round it to "0 MB".
+    formatOverlaySize,
     // The TRANSLATOR: the Host's one when it answers, the built-in dictionary
     // when it does not (a key name is never shown).
     makeTranslate,
@@ -2134,6 +2354,44 @@
       // factory-scoped handle instead of a standard `t` prop.
       let translate = null
 
+      /**
+       * THE STAGE LINE of a running restart, in the reader's language.
+       *
+       * The Host sends BOTH languages (`text: { zh, en }`) with every stage, so
+       * the pill and the settings page need no locale key that an older Host
+       * might not ship — and there is exactly ONE sentence per stage instead of
+       * two that could drift apart.
+       *
+       * @param {object|null} stage the `restartPhase` of the state payload
+       * @returns {string} the sentence, or '' when there is no restart
+       */
+      function restartStageText(stage) {
+        if (!stage || typeof stage !== 'object') return ''
+        const text = stage.text && typeof stage.text === 'object' ? stage.text : null
+        if (!text) return ''
+        const lang = typeof document !== 'undefined' && document.documentElement && document.documentElement.lang
+          ? String(document.documentElement.lang)
+          : (typeof navigator !== 'undefined' && navigator.language ? String(navigator.language) : 'en')
+        const zh = lang.toLowerCase().indexOf('zh') === 0
+        const picked = zh ? (text.zh || text.en) : (text.en || text.zh)
+        return typeof picked === 'string' ? picked : ''
+      }
+
+      /**
+       * May this restart still be called off?
+       *
+       * It is the HOST that decides (`cancellable`): once the host is on its
+       * way out, a cancel button would be a promise the plugin cannot keep, so
+       * it is shown disabled together with the reason.
+       *
+       * @param {object|null} stage
+       * @returns {boolean}
+       */
+      function restartStageLocked(stage) {
+        if (!stage || typeof stage !== 'object') return false
+        return stage.cancellable === false
+      }
+
       /**
        * ONE shared poller, shared by every surface that shows the pending
        * restart state (the composer pill and the sidebar session-row dot).
@@ -2551,6 +2809,87 @@
         opacity: 0.85,
       }
 
+      // HOW LONG THE "已回来" CARD STAYS after the new host is up (ms).
+      const RESTART_OVERLAY_BACK_MS = 1500
+      // The id of the injected stylesheet, so a second mount never duplicates it.
+      const RESTART_OVERLAY_STYLE_ID = 'dsh-autorestart-restart-overlay'
+
+      // THE CENTRED OVERLAY of a running restart.
+      //
+      // WHY IT EXISTS (user report, 2026-10-29): the stage line lived in the
+      // composer row, a single clipped line inside a 22px toolbar — on a narrow
+      // window "正在等待所有会话空闲…（还有 1 个会话在忙）" was cut off, and an
+      // ellipsis ate exactly the part that mattered. The detail therefore moved
+      // OUT of the composer row onto the middle of the interface: a fixed 320px
+      // card, one short line per stage, a real progress bar for the backup.
+      //
+      // TWO RULES:
+      //   1. IT NEVER COVERS THE INPUT. `pointer-events: none` and a translation
+      //      only — every click goes through to the interface below, and the
+      //      card sits in the middle of the conversation, not over the composer;
+      //   2. NO TEXT IS EVER CUT. The card keeps its line unwrapped, has no
+      //      `text-overflow` at all, and shrinks its font on a narrow window
+      //      (`clamp`), so the number of the backup is never replaced by "…".
+      const RESTART_OVERLAY_CSS = [
+        '.dsh-autorestart-restart-overlay{',
+        '  position:fixed;',
+        '  top:44%;',
+        '  left:50%;',
+        '  transform:translate(-50%,-50%);',
+        '  z-index:9997;',
+        '  box-sizing:border-box;',
+        '  width:min(320px,calc(100vw - 32px));',
+        '  padding:14px 16px;',
+        '  border:1px solid var(--dsw-alias-border-l1);',
+        '  border-radius:14px;',
+        '  background:color-mix(in srgb, var(--dsw-alias-bg-layer-1) 88%, transparent);',
+        '  box-shadow:0 10px 30px color-mix(in srgb, var(--dsw-alias-bg-mask-3) 20%, transparent);',
+        '  color:var(--dsw-alias-label-primary);',
+        '  text-align:center;',
+        '  pointer-events:none;',
+        '}',
+        '.dsh-autorestart-restart-overlay__title{',
+        '  margin:0;',
+        '  font-size:clamp(11px,2.6vw,14px);',
+        '  font-weight:600;',
+        '  line-height:1.4;',
+        '  white-space:nowrap;',
+        '  overflow:visible;',
+        '}',
+        '.dsh-autorestart-restart-overlay__detail{',
+        '  margin:4px 0 0;',
+        '  font-size:clamp(10px,2.2vw,12.5px);',
+        '  line-height:1.5;',
+        '  color:var(--dsw-alias-label-secondary);',
+        '  white-space:nowrap;',
+        '  overflow:visible;',
+        '}',
+        '.dsh-autorestart-restart-overlay__bar{',
+        '  margin:9px 0 0;',
+        '  height:6px;',
+        '  border-radius:999px;',
+        '  background:color-mix(in srgb, var(--dsw-alias-label-primary) 14%, transparent);',
+        '  overflow:hidden;',
+        '}',
+        '.dsh-autorestart-restart-overlay__bar-fill{',
+        '  height:100%;',
+        '  border-radius:999px;',
+        '  background:var(--dsw-alias-state-business-primary,var(--dsw-alias-brand-primary,#5b8def));',
+        '  transition:width .3s ease-out;',
+        '}',
+        '.dsh-autorestart-restart-overlay__size{',
+        '  display:flex;',
+        '  align-items:baseline;',
+        '  justify-content:space-between;',
+        '  gap:8px;',
+        '  margin:6px 0 0;',
+        '  font-size:clamp(10px,2.2vw,12px);',
+        '  line-height:1.5;',
+        '  color:var(--dsw-alias-label-secondary);',
+        '  white-space:nowrap;',
+        '}',
+      ].join('\n')
+
       // 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.
@@ -2613,10 +2952,14 @@
         cursor: 'pointer',
       }
 
-      // The park button lives inside the pill and reuses the pill's own button
-      // look (same tokens, same border, same radius), only smaller so the pill
-      // stays a one-line chip. It is inline (no absolute/fixed positioning, no
-      // negative margins) and never becomes a second element in the slot.
+      // The same button, greyed out: used while the host is already restarting,
+      // when a cancel can no longer be honoured.
+      const PANEL_BUTTON_DISABLED_STYLE = {
+        ...PANEL_BUTTON_STYLE,
+        cursor: 'not-allowed',
+        opacity: 0.55,
+      }
+
       const PARK_BUTTON_STYLE = {
         ...PILL_STYLE,
         height: 18,
@@ -2916,6 +3259,22 @@
         if (!waiting && !withdrawn) return null
 
         const blockedBy = Array.isArray(info.blockedBy) ? info.blockedBy : []
+        // WHICH STAGE THE RESTART IS IN (waiting / backing up / restarting) and
+        // whether a cancel is still honest. Both come from the Host: the pill
+        // never guesses the stage and never invents progress.
+        const stage = info && info.restartPhase && typeof info.restartPhase === 'object' ? info.restartPhase : null
+        // THE COPY OF THE COMPOSER ROW: ONE short line, never a sentence.
+        //   waiting (or no stage at all): the pill keeps its own composed line —
+        //     "待重启 · 空闲后自动重启" / "待重启 · 等待 N 个…"
+        //     (the noun of that count belongs to the capsule's own copy);
+        //   snapshotting / restarting / back: the stage REPLACES that line —
+        //     "重启前备份中" / "正在重启…" / "已回来", and nothing else.
+        // The sentence that used to sit here ("正在等待所有会话空闲…（还有 1 个
+        // 会话在忙）") was clipped away by the composer row (user report,
+        // 2026-10-29). The detail — the count of busy conversations, the
+        // megabytes, the progress bar — is the CENTRED OVERLAY.
+        const pillStageText = restartPillStageText(stage, t)
+        const cancelLocked = restartStageLocked(stage)
         // The TASK of every blocker: a session and its own subagents are ONE
         // task (the sidebar counts them once). The keys are aligned with the
         // list, so the filter below can ask "is this MY task?".
@@ -2949,9 +3308,6 @@
         const busyBlockers = others.filter(
           (entry) => String(entry.reason) !== 'goal-active' && String(entry.reason) !== 'goal-exhausted',
         )
-        // The count is about TASKS, not blockers: a parent session and its own
-        // subagents are ONE task, exactly as the left sidebar counts them.
-        const otherBusy = countBlockerTasks(busyBlockers)
 
         // WHY the gate is closed: the Host reports the reason next to the
         // blockers. With no blocker but the reason "settling" the restart is
@@ -2963,6 +3319,18 @@
         // more line about it — how long it has been waiting and how many tasks
         // are running.
         const longWait = formatLongWaitNoteParts(info, t)
+        // THE ONE NUMBER both surfaces show (user report, 2026-10-29: the
+        // capsule said "还有 1 个会话在忙" while the panel it opens said
+        // "这次重启还在等 0 个会话"). The Host counts the tasks that hold
+        // the gate and publishes `busyCount`; the capsule AND its panel read
+        // that very value, so the two can never disagree again. A blocker
+        // WITHOUT a readable name is still counted.
+        const longWaitBlockers = info && info.longWait && Array.isArray(info.longWait.blockedBy)
+          ? info.longWait.blockedBy
+          : []
+        const countingBlockers = others.length > 0 || !longWait.hasLongWait ? others : longWaitBlockers
+        const waitingCount = waitingTaskCount(info, countingBlockers)
+        const otherBusy = waitingCount
         // 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 })
@@ -2997,7 +3365,9 @@
         // The panel: how many tasks the restart waits for, and how many OTHER
         // sessions wait for the same restart. The count is about TASKS (a
         // session and its own subagents are one), like everywhere else.
-        const taskCount = longWait.hasLongWait ? longWait.count : countBlockerTasks(others)
+        // The SAME variable the capsule used: the panel can never claim a
+        // different count than the line it was opened from.
+        const taskCount = waitingCount
         const otherWaiters = waiters.filter((waiter) => String(waiter) !== key).length
         const sessionsWaiting = sessionsLeft === null ? otherWaiters : sessionsLeft
         // The session that asks for the cancel: without it the own request
@@ -3163,7 +3533,14 @@
                 if (event && typeof event.stopPropagation === 'function') event.stopPropagation()
               },
             },
-            h('p', { style: { margin: 0 } }, fill(t('cancelPanelTasks'), { n: taskCount })),
+            // THE SAME number the capsule shows (one variable, one number).
+            // A restart that waits for nobody says so in words — "还在等 0 个
+            // 会话" is not a sentence anybody writes.
+            h(
+              'p',
+              { style: { margin: 0 } },
+              taskCount > 0 ? fill(t('cancelPanelTasks'), { n: taskCount }) : t('panelStateIdle'),
+            ),
             sessionsWaiting > 0
               ? h(
                 'p',
@@ -3233,16 +3610,22 @@
                 'button',
                 {
                   type: 'button',
-                  style: PANEL_BUTTON_STYLE,
-                  title: t('cancelButtonAria'),
-                  'aria-label': t('cancelButtonAria'),
-                  disabled: cancelling,
+                  style: cancelLocked ? PANEL_BUTTON_DISABLED_STYLE : PANEL_BUTTON_STYLE,
+                  // A cancel once the host is restarting would be a promise the
+                  // plugin cannot keep: the button is greyed out and the reason
+                  // is in its tooltip.
+                  title: cancelLocked
+                    ? t('cancelLocked') + (stage && stage.cancelReason ? ' · ' + stage.cancelReason : '')
+                    : t('cancelButtonAria'),
+                  'aria-label': cancelLocked ? t('cancelLocked') : t('cancelButtonAria'),
+                  'aria-disabled': cancelLocked ? 'true' : 'false',
+                  disabled: cancelling || cancelLocked,
                   onClick: (event) => {
                     if (event && typeof event.stopPropagation === 'function') event.stopPropagation()
                     setConfirmOpen(true)
                   },
                 },
-                t('cancelButton'),
+                cancelLocked ? t('cancelLocked') : t('cancelButton'),
               ),
           )
           : null
@@ -3270,7 +3653,27 @@
               onKeyDown: onPillKeyDown,
             },
             h('span', { style: dotStyle(DOT_STYLE, pulsing), 'aria-hidden': 'true' }),
-            h('span', { style: TEXT_STYLE }, h('b', null, t('label')), status),
+            // THE ONE VISIBLE LINE OF THE COMPOSER ROW — short, never a
+            // sentence:
+            //   waiting (or no stage at all): the composed line of the pill —
+            //     "待重启 · 空闲后自动重启" / "待重启 · 等待 N 个…";
+            //   snapshotting / restarting / back: the stage REPLACES it —
+            //     "重启前备份中" / "正在重启…" / "已回来".
+            // The long sentence that used to live here was clipped away by the
+            // composer row (user report, 2026-10-29): the detail is the CENTRED
+            // OVERLAY, and the pill is one clipped line again.
+            h(
+              'span',
+              {
+                style: TEXT_STYLE,
+                'data-dsh-autorestart-copy': 'true',
+                'data-dsh-autorestart-stage': String(stage && stage.phase ? stage.phase : ''),
+              },
+              pillStageText === ''
+                ? h('b', { key: 'label' }, t('label'))
+                : h('b', { key: 'stage' }, pillStageText),
+              pillStageText === '' ? status : null,
+            ),
             // 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
@@ -3358,6 +3761,150 @@
         })
       }
 
+      /**
+       * Inject the overlay stylesheet exactly once. The id keeps a second
+       * injection from duplicating the rule.
+       */
+      function ensureRestartOverlayStyle() {
+        if (typeof document === 'undefined' || !document.head) return
+        try {
+          if (document.getElementById(RESTART_OVERLAY_STYLE_ID)) return
+          const style = document.createElement('style')
+          style.id = RESTART_OVERLAY_STYLE_ID
+          style.textContent = RESTART_OVERLAY_CSS
+          document.head.appendChild(style)
+        } catch {
+          // Without the stylesheet the card is still readable, just plainer.
+        }
+      }
+
+      /**
+       * THE CENTRED OVERLAY OF A RESTART — the stage, on the interface itself.
+       *
+       * WHY (first report): the stage lived in the composer row, one clipped line
+       * inside a 22px toolbar, where the sentence was cut off by an ellipsis. The
+       * detail therefore moved onto the middle of the conversation.
+       *
+       * WHAT IS DRAWN, AND WHEN — the card follows the Host EXACTLY, with no time
+       * floor of its own (the owner's decision, 2026-10-29: "浮层不用保底时间,
+       * 短就算了,不用硬加长"): a 92 KB backup is copied in ~5 ms and the card is
+       * gone just as fast; a slow backup keeps it on screen for as long as it
+       * takes. Nothing here invents a duration.
+       *   snapshotting  "DSH 重启前备份中" + the real bar + "12.3 MB / 40 MB" + %
+       *   restarting    "正在重启…" (the host is on its way out)
+       *   back          "已回来", for 1.5s, and only for a restart THIS page saw
+       *   waiting/idle  NOTHING: the gate merely waits, nothing is in progress
+       *
+       * A running stage counts only while the restart is really PENDING
+       * (pendingRestart): the stage a previous restart left in the state file is
+       * not an action, and a card for it would be a lie.
+       *
+       * IT LIVES ON THIS PAGE ONLY (no localStorage, no global marker), it never
+       * covers the input (pointer-events: none), and it never cuts a word.
+       */
+      function RestartOverlay() {
+        const info = useSharedInfo(true)
+        const t = makeTranslate(translate)
+        // The stage said goodbye: the card folds away once, and only once.
+        const [backGone, setBackGone] = useState(false)
+        // DID THIS PAGE WATCH A RESTART IN PROGRESS? A page opened afterwards
+        // reads a LEFTOVER stage from the state file and must draw nothing.
+        const [sawRunning, setSawRunning] = useState(false)
+
+        const stage = info && info.restartPhase && typeof info.restartPhase === 'object' ? info.restartPhase : null
+        const phase = stage && typeof stage.phase === 'string' ? stage.phase : ''
+        // A RESTART THAT IS REALLY PENDING: the request says "something is going
+        // on right now", the state file alone does not.
+        const pending = Boolean(info && info.pendingRestart === true)
+        // THE ONLY TWO STAGES THAT ARE "SOMETHING IS REALLY HAPPENING": the
+        // snapshot is being written, or the host is on its way out.
+        const running = pending && (phase === 'snapshotting' || phase === 'restarting')
+
+        useEffect(() => {
+          if (running) setSawRunning(true)
+        }, [running])
+
+        // "已回来" is a MOMENT, not a state: 1.5s and then the card is gone.
+        useEffect(() => {
+          if (phase !== 'back') {
+            setBackGone(false)
+            return undefined
+          }
+          const timer = setTimeout(() => setBackGone(true), RESTART_OVERLAY_BACK_MS)
+          return () => clearTimeout(timer)
+        }, [phase])
+
+        // THE CARD IS ONLY DRAWN WHILE SOMETHING IS REALLY IN PROGRESS.
+        const visible = running || (phase === 'back' && sawRunning && !backGone)
+        if (!visible) return null
+
+        const progress = stage.progress && typeof stage.progress === 'object' ? stage.progress : null
+        const bytes = progress !== null && Number.isFinite(Number(progress.bytes)) ? Number(progress.bytes) : null
+        const total = progress !== null && Number.isFinite(Number(progress.total)) ? Number(progress.total) : null
+        const percent = progress !== null && Number.isFinite(Number(progress.percent))
+          ? Math.max(0, Math.min(100, Math.round(Number(progress.percent))))
+          : null
+
+        const title = restartOverlayTitle(stage, t)
+
+        let bar = null
+        let detail = null
+        if (phase === 'snapshotting') {
+          // The numbers are the ones the copy loop really measured; when there is
+          // no measurement yet, the card shows no number at all (an invented
+          // progress bar is worse than none). The unit fits the size, so a 92 KB
+          // profile is "92 KB" and never "0 MB".
+          const done = bytes === null ? '' : formatOverlaySize(bytes)
+          const all = total === null ? '' : formatOverlaySize(total)
+          const sizeText = done === ''
+            ? ''
+            : (all === '' ? fill(t('restart.overlay.sizeDone'), { done }) : fill(t('restart.overlay.size'), { done, total: all }))
+          bar = h(
+            'div',
+            {
+              className: 'dsh-autorestart-restart-overlay__bar',
+              role: 'progressbar',
+              'aria-valuemin': 0,
+              'aria-valuemax': 100,
+              'aria-valuenow': percent === null ? 0 : percent,
+            },
+            h('div', {
+              className: 'dsh-autorestart-restart-overlay__bar-fill',
+              'data-dsh-autorestart-restart-overlay-bar': 'true',
+              style: { width: (percent === null ? 0 : percent) + '%' },
+            }),
+          )
+          detail = sizeText === ''
+            ? null
+            : h(
+              'p',
+              { className: 'dsh-autorestart-restart-overlay__size' },
+              h('span', { 'data-dsh-autorestart-restart-overlay-size': 'true' }, sizeText),
+              h('span', { 'data-dsh-autorestart-restart-overlay-percent': 'true' }, percent === null ? '' : percent + '%'),
+            )
+        }
+
+        ensureRestartOverlayStyle()
+
+        return h(
+          'div',
+          {
+            className: 'dsh-autorestart-restart-overlay',
+            role: 'status',
+            'aria-live': 'polite',
+            'data-dsh-autorestart-restart-overlay': 'true',
+            'data-dsh-autorestart-restart-overlay-phase': phase,
+          },
+          h(
+            'p',
+            { className: 'dsh-autorestart-restart-overlay__title', 'data-dsh-autorestart-restart-overlay-title': 'true' },
+            title,
+          ),
+          bar,
+          detail,
+        )
+      }
+
       /**
        * Inject the prompt styles exactly once. The id keeps a second injection
        * from duplicating the rule.
@@ -4328,6 +4875,37 @@
         '  font-size:13px;',
         '}',
         '.dsh-autorestart-settings__hint{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary);}',
+        // THE BACKUP LIST (user report, 2026-10-29: the old one-liner
+        // "2026-10-29 22:08:46+08:00 156.0 MB 含已装插件" was unreadable).
+        // One GROUP per backup, a labelled row for the time and one for the
+        // size, and enough air between two groups that two copies never read
+        // as one block.
+        '.dsh-autorestart-settings__backup{',
+        '  display:flex;',
+        '  flex-direction:column;',
+        '  gap:3px;',
+        '  padding-top:8px;',
+        '  border-top:1px solid var(--dsw-alias-border-l1);',
+        '}',
+        '.dsh-autorestart-settings__backup + .dsh-autorestart-settings__backup{margin-top:12px;}',
+        '.dsh-autorestart-settings__backup-row{display:flex;flex-wrap:wrap;gap:8px;align-items:baseline;}',
+        '.dsh-autorestart-settings__backup-label{',
+        '  flex:none;',
+        '  font-size:12.5px;',
+        '  line-height:18px;',
+        '  color:var(--dsw-alias-label-secondary);',
+        '}',
+        '.dsh-autorestart-settings__backup-value{',
+        '  font-size:13px;',
+        '  line-height:18px;',
+        '  color:var(--dsw-alias-label-primary);',
+        '  font-variant-numeric:tabular-nums;',
+        '}',
+        '.dsh-autorestart-settings__backup-note{',
+        '  font-size:12px;',
+        '  line-height:18px;',
+        '  color:var(--dsw-alias-label-secondary);',
+        '}',
         // The folded "technical details": the command itself stays out of the
         // way until somebody asks for it.
         '.dsh-autorestart-settings__details{',
@@ -4506,6 +5084,321 @@
        * @param {object} props the Host's props: `t` (the translator of the
        *   registered locale, injected by the section registration)
        */
+      /* ---------------------------------------------------------------- *
+       * THE RECEIPT OF A SETTINGS CHANGE
+       *
+       * A setting is written the moment the user picks it ("change it and it
+       * is in effect"), which left the user unable to tell whether it was
+       * really stored. This is the missing half: ONE `sticky` line at the TOP
+       * OF THE SETTINGS PANEL that says "Saved 21:40:12" once the HOST
+       * answered `ok: true`, or "Not saved — <the reason>" in red when it
+       * refused.
+       *
+       * It is drawn INSIDE the panel (a child of the panel's own tree), never
+       * on the window: a window overlay put it on top of the conversation
+       * area, outside the dialog it belongs to.
+       *
+       * The rules it keeps:
+       *
+       *   - NOTHING is announced before the Host's receipt: rendering the
+       *     page, polling it and clicking a control all stay silent;
+       *   - a failure is never swallowed and never fades: it stays until the
+       *     next change succeeds or the user closes it;
+       *   - a success fades out on its own after a moment, and three changes
+       *     in a row update the SAME line instead of stacking new ones;
+       *   - the line lives exactly as long as the panel does (closing the
+       *     settings throws it away).
+       * ---------------------------------------------------------------- */
+
+      /** The id of the one stylesheet of the receipt line. */
+      const SAVE_NOTICE_STYLE_ID = 'dsh-autorestart-save-notice'
+      /** How long the green line stays; the red one stays for ever. */
+      const SAVE_NOTICE_HIDE_MS = 3000
+
+      /**
+       * The receipt on screen right now (one for the whole panel: two changes
+       * never produce two lines).
+       *
+       * `notice` is `null` until a save came back from the Host, and it is
+       * `{ kind: 'ok' | 'failed', at, atText, reason }` afterwards.
+       */
+      const saveNoticeStore = {
+        notice: null,
+        listeners: new Set(),
+        timer: null,
+      }
+
+      /** Tell every mounted receipt about the current one. */
+      function notifySaveNotice() {
+        saveNoticeStore.listeners.forEach((listener) => {
+          try {
+            listener(saveNoticeStore.notice)
+          } catch {
+            // One broken listener must not stop the others.
+          }
+        })
+      }
+
+      /** The local clock time of a receipt, as HH:MM:SS. */
+      function formatSaveNoticeClock(at) {
+        const moment = new Date(at)
+        const pad = (value) => (value < 10 ? '0' + value : String(value))
+        return pad(moment.getHours()) + ':' + pad(moment.getMinutes()) + ':' + pad(moment.getSeconds())
+      }
+
+      /**
+       * Publish one receipt.
+       *
+       * A pending fade-out of the previous receipt is dropped first, so a
+       * second change restarts the clock on the SAME line (test: "two saves,
+       * one line").
+       */
+      function publishSaveNotice(notice) {
+        if (saveNoticeStore.timer !== null) {
+          clearTimeout(saveNoticeStore.timer)
+          saveNoticeStore.timer = null
+        }
+        saveNoticeStore.notice = notice
+        notifySaveNotice()
+        // A failure stays: only the user closes it (or a save that works).
+        if (notice.kind !== 'ok') return
+        const timer = setTimeout(() => {
+          saveNoticeStore.timer = null
+          // A newer receipt replaced this one while the timer ran.
+          if (saveNoticeStore.notice !== notice) return
+          saveNoticeStore.notice = null
+          notifySaveNotice()
+        }, SAVE_NOTICE_HIDE_MS)
+        // In a browser this is a number; under Node it is a Timeout that must
+        // not hold the process open (the tests run in one).
+        if (timer && typeof timer.unref === 'function') timer.unref()
+        saveNoticeStore.timer = timer
+      }
+
+      /**
+       * The Host took the change (`ok: true`): this is the ONE moment the
+       * page may say "Saved".
+       */
+      function publishSaveSaved() {
+        const at = Date.now()
+        publishSaveNotice({ kind: 'ok', at, atText: formatSaveNoticeClock(at), reason: '' })
+      }
+
+      /**
+       * The Host refused the change: say so, with the reason it gave, and
+       * keep saying it.
+       *
+       * @param {string} reason the error of the Host answer (or of the request)
+       */
+      function publishSaveFailure(reason) {
+        const at = Date.now()
+        publishSaveNotice({
+          kind: 'failed',
+          at,
+          atText: formatSaveNoticeClock(at),
+          reason: typeof reason === 'string' ? reason : '',
+        })
+      }
+
+      /** Close the receipt: only the user does that, with the close button. */
+      function clearSaveNotice() {
+        if (saveNoticeStore.timer !== null) {
+          clearTimeout(saveNoticeStore.timer)
+          saveNoticeStore.timer = null
+        }
+        if (saveNoticeStore.notice === null) return
+        saveNoticeStore.notice = null
+        notifySaveNotice()
+      }
+
+      /** The receipt on screen, re-rendered whenever it changes. */
+      function useSaveNotice() {
+        const [notice, setNotice] = useState(saveNoticeStore.notice)
+        useEffect(() => {
+          setNotice(saveNoticeStore.notice)
+          saveNoticeStore.listeners.add(setNotice)
+          return () => { saveNoticeStore.listeners.delete(setNotice) }
+        }, [])
+        return notice
+      }
+
+      // THE RECEIPT OF A SETTINGS CHANGE IS A STRIP OF THE SETTINGS PANEL.
+      //
+      // It used to be a WINDOW overlay (`shell.overlay`), and that was wrong:
+      // the user saw it floating over the conversation area — outside the
+      // dialog it belonged to. It is a child of the panel itself now: a
+      // `sticky` strip at the top of the panel, so it stays visible while the
+      // settings are scrolled and it can never leave the dialog.
+      //
+      // The strip COVERS the first line of the panel for its 30px (the wrapper
+      // is sticky with height 0) instead of pushing the form down, so nothing
+      // jumps when it appears or fades.
+      const SAVE_NOTICE_CSS = [
+        '.dsh-autorestart-save-notice{',
+        '  position:sticky;',
+        '  top:0;',
+        '  z-index:5;',
+        '  height:0;',
+        '  pointer-events:none;',
+        '}',
+        '.dsh-autorestart-save-notice__bar{',
+        '  display:flex;',
+        '  align-items:center;',
+        '  gap:8px;',
+        '  box-sizing:border-box;',
+        '  height:30px;',
+        '  max-width:100%;',
+        '  padding:0 4px 0 10px;',
+        '  border:1px solid transparent;',
+        '  border-radius:8px;',
+        '  font-size:13px;',
+        '  line-height:18px;',
+        '  white-space:nowrap;',
+        '  pointer-events:auto;',
+        '  box-shadow:0 2px 8px color-mix(in srgb, var(--dsw-alias-bg-mask-3) 14%, transparent);',
+        '}',
+        // The green strip: a light green ground with green text.
+        '.dsh-autorestart-save-notice--ok .dsh-autorestart-save-notice__bar{',
+        '  border-color:color-mix(in srgb, var(--dsw-alias-state-success,#1a7f37) 38%, transparent);',
+        '  background:color-mix(in srgb, var(--dsw-alias-state-success,#1a7f37) 12%, var(--dsw-alias-bg-layer-1));',
+        '  color:var(--dsw-alias-state-success-fg,var(--dsw-alias-state-success,#1a7f37));',
+        '}',
+        // The red one: a light red ground with red text. It does not fade.
+        '.dsh-autorestart-save-notice--failed .dsh-autorestart-save-notice__bar{',
+        '  border-color:color-mix(in srgb, var(--dsw-alias-danger,#d14343) 38%, transparent);',
+        '  background:color-mix(in srgb, var(--dsw-alias-danger,#d14343) 12%, var(--dsw-alias-bg-layer-1));',
+        '  color:var(--dsw-alias-danger,#d14343);',
+        '}',
+        '.dsh-autorestart-save-notice__title{flex:none;font-weight:600;}',
+        // The clock time sits at the RIGHT of the strip, in small type.
+        '.dsh-autorestart-save-notice__time{',
+        '  flex:none;',
+        '  margin-left:auto;',
+        '  font-size:11.5px;',
+        '  opacity:.75;',
+        '  font-variant-numeric:tabular-nums;',
+        '}',
+        // The reason is the only text that may be cut, and even then the whole
+        // text is in the tooltip: the short copy itself is never cut.
+        '.dsh-autorestart-save-notice__reason{',
+        '  flex:0 1 auto;',
+        '  min-width:0;',
+        '  overflow:hidden;',
+        '  text-overflow:ellipsis;',
+        '}',
+        '.dsh-autorestart-save-notice__close{',
+        '  flex:none;',
+        '  width:20px;',
+        '  height:20px;',
+        '  padding:0;',
+        '  border:none;',
+        '  border-radius:6px;',
+        '  background:transparent;',
+        '  color:inherit;',
+        '  font:inherit;',
+        '  font-size:14px;',
+        '  line-height:18px;',
+        '  cursor:pointer;',
+        '}',
+        '.dsh-autorestart-save-notice__close:hover{background:color-mix(in srgb, currentColor 14%, transparent);}',
+        '.dsh-autorestart-save-notice__close:focus-visible{',
+        '  outline:2px solid var(--dsw-alias-state-business-primary,var(--dsw-alias-brand-primary,#4d6bfe));',
+        '  outline-offset:2px;',
+        '}',
+        // The fade is decoration: a system that asks for less motion gets none.
+        '@media (prefers-reduced-motion: no-preference){',
+        '  .dsh-autorestart-save-notice__bar{animation:dsh-autorestart-save-notice-in .16s ease-out;}',
+        '}',
+        '@keyframes dsh-autorestart-save-notice-in{',
+        '  from{opacity:0;transform:translateY(-3px);}',
+        '  to{opacity:1;transform:translateY(0);}',
+        '}',
+      ].join('\n')
+
+      /** Inject the stylesheet of the receipt exactly once. */
+      function ensureSaveNoticeStyle() {
+        if (typeof document === 'undefined' || !document.head) return
+        try {
+          if (document.getElementById(SAVE_NOTICE_STYLE_ID)) return
+          const style = document.createElement('style')
+          style.id = SAVE_NOTICE_STYLE_ID
+          style.textContent = SAVE_NOTICE_CSS
+          document.head.appendChild(style)
+        } catch {
+          // Without the stylesheet the line is still readable, just plainer.
+        }
+      }
+
+      /**
+       * THE RECEIPT OF A SETTINGS CHANGE, drawn INSIDE the settings panel.
+       *
+       * It is a child of the panel itself (never a window overlay): the DOM
+       * ancestor of this strip IS the settings section, so it can not float
+       * over the conversation area. `SAVE_NOTICE_CSS` makes it a `sticky`
+       * strip at the top of the panel, so it stays visible while the settings
+       * are scrolled, and it covers the first line instead of pushing the
+       * form down.
+       *
+       * It renders NOTHING until a save came back from the Host — the first
+       * render and every poll are silent.
+       *
+       * @param {(key: string) => string} t the translator of the panel
+       * @param {object|null} notice the receipt on screen (`null` = none)
+       */
+      function saveNoticeBar(t, notice) {
+        if (!notice) return null
+        ensureSaveNoticeStyle()
+        const saved = notice.kind === 'ok'
+        return h(
+          'div',
+          {
+            className: 'dsh-autorestart-save-notice'
+              + (saved ? ' dsh-autorestart-save-notice--ok' : ' dsh-autorestart-save-notice--failed'),
+            role: saved ? 'status' : 'alert',
+            'aria-live': saved ? 'polite' : 'assertive',
+            'data-dsh-autorestart-save-notice': saved ? 'ok' : 'failed',
+            'data-dsh-autorestart-save-notice-at': notice.atText,
+          },
+          h(
+            'div',
+            { className: 'dsh-autorestart-save-notice__bar' },
+            // LEFT: the short copy ("已生效" / "Saved").
+            h(
+              'span',
+              { className: 'dsh-autorestart-save-notice__title' },
+              saved ? t('settings.saveNotice.saved') : t('settings.saveNotice.failed'),
+            ),
+            // The reason of a failure (the only text that may be cut, and the
+            // tooltip carries all of it).
+            saved || notice.reason === ''
+              ? null
+              : h(
+                'span',
+                {
+                  className: 'dsh-autorestart-save-notice__reason',
+                  'data-dsh-autorestart-save-notice-reason': 'true',
+                  title: notice.reason,
+                },
+                notice.reason,
+              ),
+            // RIGHT: the small clock time, then the close button.
+            h('span', { className: 'dsh-autorestart-save-notice__time' }, notice.atText),
+            h(
+              'button',
+              {
+                type: 'button',
+                className: 'dsh-autorestart-save-notice__close',
+                'data-dsh-autorestart-save-notice-close': 'true',
+                onClick: clearSaveNotice,
+                title: t('settings.saveNotice.dismiss'),
+                'aria-label': t('settings.saveNotice.dismiss'),
+              },
+              '×',
+            ),
+          ),
+        )
+      }
+
       function AutorestartSection(props) {
         const status = useSleepStatus()
         const info = useSharedInfo(true)
@@ -4525,6 +5418,19 @@
         // accident.
         const [detailsOpen, setDetailsOpen] = useState(false)
         const t = makeTranslate(props && typeof props.t === 'function' ? props.t : translate)
+        // THE RECEIPT OF A SETTINGS CHANGE, on screen right now. It belongs to
+        // THIS panel (it is not a window overlay), so it is read here and
+        // drawn here.
+        const saveNotice = useSaveNotice()
+
+        // The receipt lives exactly as long as this panel is on screen: a page
+        // that is closed (or reopened) never shows a "Saved" of an earlier
+        // visit. The mount clearing also covers a Host that keeps the section
+        // mounted while it is hidden.
+        useEffect(() => {
+          clearSaveNotice()
+          return () => { clearSaveNotice() }
+        }, [])
 
         // The current values come from the Host, so the panel always shows what
         // is really in effect.
@@ -4734,6 +5640,9 @@
          * back with a fresh poll — so the controls never show a value the
          * Host did not take.
          *
+         * ONLY the Host's answer (`ok: true`) makes the window say "Saved":
+         * picking a value, rendering the page and polling it stay silent.
+         *
          * @param {object} changes the keys to write
          */
         const save = async (changes) => {
@@ -4752,12 +5661,31 @@
                 ? (body.message || body.error || String(response.status))
                 : String(response.status)
               setError(fill(t('settings.error'), { message }))
+              // The Host refused the write: the red line keeps the reason
+              // until the next change works (or the user closes it).
+              publishSaveFailure(message)
+              return
+            }
+            if (!body || typeof body !== 'object' || body.ok !== true) {
+              // The request came back, but the Host did not confirm it: a
+              // "saved" line here would be a lie.
+              const reason = body && typeof body === 'object'
+                ? String(body.message || body.error || '')
+                : ''
+              setError(fill(t('settings.error'), {
+                message: reason === '' ? String(response.status) : reason,
+              }))
+              publishSaveFailure(reason)
               return
             }
+            // The receipt is there: now the window may say "Saved".
+            publishSaveSaved()
             // Read the new values back from the Host.
             await pollSleepOnce()
           } catch (failure) {
-            setError(fill(t('settings.error'), { message: describeError(failure) }))
+            const message = describeError(failure)
+            setError(fill(t('settings.error'), { message }))
+            publishSaveFailure(message)
           } finally {
             setBusy(false)
           }
@@ -4883,6 +5811,11 @@
         return h(
           'div',
           { className: 'dsh-autorestart-settings' },
+          // THE RECEIPT: a `sticky` strip at the TOP of this panel. It is a
+          // child of the panel (the DOM ancestor of the message IS the
+          // settings section), so it can not float over the conversation area
+          // again — and it stays visible while the settings are scrolled.
+          saveNoticeBar(t, saveNotice),
           // 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.
@@ -4897,6 +5830,28 @@
               { className: 'dsh-autorestart-settings__group-title' },
               t('settings.groups.restart'),
             ),
+            // THE STATUS LINE: what the restart is doing right now, next to the
+            // settings that control it. It lives here (the pill only exists
+            // while a restart is pending), so a slow backup, "restarting" and
+            // "back — carrying on" are visible where the user went looking.
+            restartStageText(info && info.restartPhase) === ''
+              ? null
+              : h(
+                'div',
+                {
+                  className: 'dsh-autorestart-settings__status',
+                  'data-dsh-autorestart-stage': String(
+                    info && info.restartPhase && info.restartPhase.phase ? info.restartPhase.phase : '',
+                  ),
+                  style: {
+                    margin: '2px 0 8px',
+                    fontSize: 12,
+                    lineHeight: '16px',
+                    color: 'var(--dsw-alias-label-secondary, inherit)',
+                  },
+                },
+                restartStageText(info && info.restartPhase),
+              ),
             h(
               'label',
               { className: 'dsh-autorestart-settings__field' },
@@ -4999,25 +5954,50 @@
                 : null,
               backupItems.map((item, index) => h(
                 'div',
-                { className: 'dsh-autorestart-settings__value', 'data-dsh-autorestart-backup': 'item' },
-                h(
-                  'span',
-                  { 'data-dsh-autorestart-backup': 'time' },
-                  formatBackupTime(item && item.atLocal),
-                ),
+                {
+                  className: 'dsh-autorestart-settings__backup',
+                  'data-dsh-autorestart-backup': 'item',
+                  key: 'backup-' + index,
+                },
+                // WHEN it was taken. No timezone offset: what is shown is
+                // already the local clock of the machine that took the copy.
                 h(
-                  'span',
-                  { 'data-dsh-autorestart-backup': 'size' },
-                  formatBackupSize(item && item.bytes),
+                  'div',
+                  { className: 'dsh-autorestart-settings__backup-row' },
+                  h(
+                    'span',
+                    { className: 'dsh-autorestart-settings__backup-label' },
+                    t('settings.backup.time'),
+                  ),
+                  h(
+                    'span',
+                    { className: 'dsh-autorestart-settings__backup-value', 'data-dsh-autorestart-backup': 'time' },
+                    formatBackupTime(item && item.atLocal),
+                  ),
                 ),
+                // HOW BIG it is — and whether the plugins are in it, because
+                // that is WHY it is that big: the note belongs to the size.
                 h(
-                  'span',
-                  { 'data-dsh-autorestart-backup': 'plugins' },
-                  item && item.includePlugins === true
-                    ? t('settings.backup.withPlugins')
-                    : t('settings.backup.withoutPlugins'),
+                  'div',
+                  { className: 'dsh-autorestart-settings__backup-row' },
+                  h(
+                    'span',
+                    { className: 'dsh-autorestart-settings__backup-label' },
+                    t('settings.backup.size'),
+                  ),
+                  h(
+                    'span',
+                    { className: 'dsh-autorestart-settings__backup-value', 'data-dsh-autorestart-backup': 'size' },
+                    formatBackupSize(item && item.bytes),
+                  ),
+                  h(
+                    'span',
+                    { className: 'dsh-autorestart-settings__backup-note', 'data-dsh-autorestart-backup': 'plugins' },
+                    item && item.includePlugins === true
+                      ? t('settings.backup.withPlugins')
+                      : t('settings.backup.withoutPlugins'),
+                  ),
                 ),
-                index === 0 ? null : null,
               )),
               backupsInfo.dir === ''
                 ? null
@@ -6642,6 +7622,15 @@
           // The countdown overlay: a frame-wide floating layer above every
           // column.
           ctx.slots.inject('shell.overlay', () => ctx.slots.register({ name: 'shell.overlay', id: 'autorestart-sleep-overlay', order: 60 }, SleepOverlay))
+          // THE CENTRED OVERLAY of a running restart: the stage (waiting / the
+          // backup with its real megabytes and its progress bar / restarting /
+          // back) in the middle of the interface, so the composer row can stay
+          // one short clipped line. It draws NOTHING when no restart is staged.
+          ctx.slots.inject('shell.overlay', () => ctx.slots.register({ name: 'shell.overlay', id: 'autorestart-restart-overlay', order: 55, locale: NS }, RestartOverlay))
+          // NOTE: the receipt of a settings change is NOT registered here. It
+          // is a `sticky` strip INSIDE the settings panel (see
+          // `saveNoticeBar`), because a window overlay put it on top of the
+          // conversation area instead of inside the dialog it belongs to.
         },
         // The named exports of this module (the client module system hands
         // `factory(require) -> exports` to every importer).