dsh-autorestart 0.5.0 → 0.6.1

package/README.md

@@ -29,10 +29,14 @@ round starts, so the session goes idle and the restart can proceed. The goal is
 restart and continues.
 
 The browser shows the state: a compact "pending restart" pill on the left side of the input toolbar
-and a small dot next to the session title in the sidebar. The pill's text reports how many
-conversations are still in the way (counted once per conversation, and the tooltip explains that a
-conversation with queued-but-not-started work counts too); it does not open a details panel. The dot
-breathes when the restart is about to fire.
+and a small dot next to the session title in the sidebar. The pill's text reports how many **tasks**
+are still in the way — a conversation, a subagent or a teammate counts as one task each, and the
+tooltip explains that queued-but-not-started work counts too; it does not open a details panel. The
+dot breathes when the restart is about to fire.
+
+Every blocker says **what it is**: a conversation is named by its own title, and a **subagent** is
+named after the conversation that created it ("Subagent of *that* conversation"). A raw session id is
+never shown to the user.
 
 Before every restart the plugin snapshots the profile, so a restart that leaves the host unable to
 boot is rolled back automatically — see
@@ -72,7 +76,7 @@ what it adds before you install it.
 
 ## Install
 
-Current version: **0.5.0**.
+Current version: **0.6.1**.
 
 From npm — the package is published under the name `dsh-autorestart`:
 
@@ -140,6 +144,7 @@ show up in the Plugin Manager and in the config editor.
 | `restartCommand` | `''` | Custom restart command. Supports the `{pid}`, `{ppid}` and `{app}` placeholders. |
 | `relaunchDelaySeconds` | `2` | How long the detached helper waits before it kills the app (`ping -n 3`, roughly 2 seconds). |
 | `settleMs` | `2000` | Quiet window in milliseconds: the host must stay silent this long after the last conversation activity before a restart may start. |
+| `restartGraceMs` | `10000` | Grace window in milliseconds: how long the host waits after the last conversation finished before it is really restarted or switched off — a dropdown: `0` / `3` / `5` / `10` / `20` / `30` seconds. `0` means "no extra wait". |
 | `autoReloadPage` | `true` | `dsh web`: reload the page automatically when the host boot token changes. |
 | `blockManualRestart` | `true` | Hard-block an agent that tries to kill or restart DSH with a shell command, and point it at `continuum_restart` instead. |
 | `healthPath` | `/__dsh_autorestart/health` | Health check route. Returns the boot id, the pid, the phase and the self-check flags. |
@@ -161,6 +166,30 @@ The two waits are independent of each other, and both default to two seconds:
 Both can be overridden separately in the profile config. A larger `settleMs` is the more
 conservative choice, because it is less likely to cut a session short that has just started.
 
+### Why the host waits a few more seconds after the work is done
+
+**The blind spot.** This plugin can only see the **DSH agents**: it knows whether a conversation is
+running, whether it has queued inbox work, and when the last of them went idle. It cannot see the
+work other plugins queue with a timer of their own — a memory plugin that writes its notes a few
+seconds after the conversation ended, a summary, an MCP callback, a log flush. That work is
+invisible here, so "every agent is idle" does not mean "nothing is happening any more".
+
+**The grace window.** `restartGraceMs` (default **10 seconds**) is the extra wait for exactly
+that: after the LAST conversation finished, the host waits this long before it is really restarted
+or switched off. It is a plain, configurable insurance — not a special case for any particular
+plugin.
+
+- **Both paths use it.** The restart gate waits `max(settleMs, restartGraceMs)` of quiet, and the
+  graceful shutdown waits the same grace **before** its countdown starts (so the grace never pushes
+  a countdown that is already running back by a round).
+- **New activity restarts the timer.** If a conversation starts working again while the host is
+  waiting, the grace starts over — the wait always follows the last activity.
+- **`0` means "as before".** With `restartGraceMs: 0` the behaviour is exactly the one of 0.4.0.
+- **Where to change it.** Settings → Auto-restart & shut down → *Wait a few more seconds after the
+  work is done*. The status interfaces report it too: `GET /health?state=1`, `GET /health?gate=1`,
+  `continuum_status` and `GET /sleep` all carry `graceMs` (the configured window) and `quietForMs`
+  (how long the host has actually been quiet).
+
 ### Platform note
 
 `restartMode: app` only applies to the DeepSeek Harness desktop app. A hosted `dsh web`
@@ -255,9 +284,25 @@ once, in the same composer dock, as a small card:
   already shown (`seenFeatureVersions` in the checkpoint file). A fresh installation never sees the
   card: the install question already explains the features, and answering it marks the announcement
   as seen.
-- **Once per version, for ever.** "Got it" records the version, the card disappears at once, and it
-  never comes back — not with the next restart of the host, and not with the next version of the
-  plugin (a *new* version of a feature is announced again, of course).
+- **"Seen" means "not older", not "equal".** The card counts as answered as soon as the recorded
+  version is **not older** than the current feature version — a record of `0.6.0` counts as seen
+  while the feature itself stands at `0.5.0`. Why not equality? Because the record does not say
+  *which* release the user answered on (until 0.6.0 the card carried the version of the package),
+  so an equality check would tell a user who already dismissed the card that they never saw it. A
+  record that is not a version at all counts as seen as well: a broken record must not make the
+  card come back for ever.
+- **Once per feature version, for ever.** "Got it" records the version, the card disappears at once,
+  and it never comes back — not with the next restart of the host, and not with the next release of
+  the plugin (a *newer version of the feature* is announced again, of course).
+- **The announcement follows the FEATURE, not the release.** The version it carries is a constant in
+  the source (`SLEEP_FEATURE_VERSION` in `index.js`), **not** the version of the package: a release
+  never brings the card back. Until 0.6.0 the card carried the package version, and every release
+  (0.5.0 → 0.6.0) brought "graceful shutdown" back to the users who had already answered it.
+- **How to announce it again on purpose.** Raise `SLEEP_FEATURE_VERSION` to a version **newer** than
+  the one that was recorded last: the card is then shown exactly once more. Do that **only** when
+  the feature itself changed so much that the user has to hear about it again (the shutdown became a
+  completely different thing, the button moved somewhere else, …). A release, a bug fix or a small
+  addition must **not** touch it — that is exactly the bug this constant exists to prevent.
 - **An unanswered card is not swallowed.** The card stays until it is answered, and it comes back with
   the next start of DSH.
 - **The countdown is read, not written.** The seconds in the card are the ones that are really in
@@ -265,7 +310,8 @@ once, in the same composer dock, as a small card:
   ("The button is currently switched off; you can turn it on in the settings").
 - **Where the state lives.** `<DSH_HOME>/storages/dsh-autorestart/state.json`, next to the checkpoint
   of the plugin. The host serves it on `GET /announcements` (`{ ok, pending: [{ feature, version }] }`)
-  and records it on `POST /announcements` (`{ feature }`).
+  and records it on `POST /announcements` (`{ feature }`). The `version` in that answer is the feature
+  version — the same number that `SLEEP_FEATURE_VERSION` holds.
 
 ## Graceful shutdown (收工关机)
 
@@ -276,6 +322,80 @@ be cancelled — the card has a button, and the moon button itself becomes a tog
 is armed. If a conversation starts working again during the countdown, the countdown goes back to
 "waiting" and nothing is switched off.
 
+### Shutdown and restart: who goes first
+
+**The short version.** Pressing the moon button means "switch the machine off when the work is
+done" — **not** "switch it off right now, whatever else is running". So:
+
+1. **A pending restart wins.** If a restart is still on the list, the shutdown does **not** happen.
+   The card says *"Waiting for the pending restart to finish before shutting down"*. The restart
+   goes first, the sessions come back with it and keep working, and only then does the machine
+   go off.
+2. **The work keeps running after the restart.** The sessions that resume with the restart are
+   running work: while any of them is busy, the shutdown waits. The machine only goes off when
+   **every** session is idle again.
+3. **The shutdown intent survives the restart.** You pressed the button **once**. The restart does
+   not swallow that request: it is written into the checkpoint file, and the new boot picks it up
+   and keeps waiting for the work. You do **not** have to press the button a second time.
+4. **You can cancel at any time.** The waiting card has a *"Keep it on"* button; pressing it (or the
+   moon button again) forgets the intent for good.
+
+**Where the intent lives.** In the checkpoint file
+(`<DSH_HOME>/storages/dsh-autorestart/state.json`) as `sleep: { armed, armedAt, countdownSeconds }`.
+It is cleared as soon as the machine went off, when the shutdown failed, and when you cancel. A
+record that cannot be read is dropped — asking once more is much better than a machine that switches
+itself off for ever because of a half-written file.
+
+**For the troubleshooting.** `GET /sleep` reports `armedAt` (when the shutdown was armed) next to
+`phase`, `blockers` and `graceMs`.
+
+### Troubleshooting: the machine did not switch off
+
+**These are the real answers of a running host** (the copy of the host is Chinese, the fields are
+not):
+
+```
+POST /__dsh_autorestart/sleep {"action":"arm"}   # three conversations are working
+→ phase=waiting  armed=true  remainingMs=20000   (the full value: the countdown has NOT started)
+  message: 等 3 个任务收工，收工后开始倒数。
+
+# after a restart was requested:
+GET /__dsh_autorestart/sleep
+→ phase=waiting  armed=true  remainingMs=20000
+  message: 等这次重启完成后再关机……
+  blockers: [{"sessionId":"restart-pending","kind":"restart-pending",
+              "label":"待执行的重启","name":"待执行的重启"}]
+```
+
+`remainingMs` at its full value is the tell: **the countdown has not started**, so the machine is
+waiting for something. Here is what it can be, and what to do about it:
+
+1. **Some tasks are still working.** `blockers[]` lists them; look at `kind`:
+   `session` is a conversation, `subagent` is a child agent of one. A subagent counts as work on
+   purpose — otherwise a restart would cut it off. **What to do:** let it finish, or stop that
+   conversation. The list shrinks on its own.
+2. **A restart is still pending.** `kind` is `restart-pending` (`label`/`name` are
+   `待执行的重启`). That is normal queueing, not a fault: the restart runs first, the sessions
+   come back with it, and the countdown continues afterwards. **What to do:** nothing — wait for
+   the restart. (You can also cancel the restart with `continuum_cancel_restart`.)
+3. **The work just ended and the grace window is still running** (default 10 seconds, so that a
+   memory or summary plugin can still write its notes). **What you see:** `graceMs` is the
+   configured window, `quietForMs` is how long the host has actually been quiet. **What to do:**
+   wait; if another conversation starts working during the wait, the timer starts over (that is
+   the point of the window). Set it to `0` in the settings if you do not want the extra wait.
+4. **Somebody started working during the countdown.** The countdown goes back to "waiting" and
+   `remainingMs` returns to its full value. **What you see:** the message says that somebody
+   started working again, and `blockers[]` lists who. **What to do:** let them finish.
+5. **You want to know who it is waiting for.** `continuum_status` → `blockedBy[]` and
+   `GET /sleep` → `blockers[]` are the **same data**: the first is for agents, the second for
+   scripts. Each entry has `kind` (what it is), `label` (the title of the session) and `name`
+   (the whole name, e.g. "the subagent of the coding session"). A session whose title could not
+   be resolved reports `label: null` and an empty `name` — that is why the waiting line then
+   only says "等 3 个任务收工" without a list of names.
+6. **You do not want it at all.** The cancel button on the waiting card (or the moon button
+   again, or `POST /sleep {"action":"cancel"}`) clears the intent for good: `armed` becomes
+   `false` and `armedAt` becomes `null`.
+
 **Where the button is.** The moon button sits at the **very bottom of the left sidebar, right next
 to the Settings row** (`sidebar.footer.action`). That seat is a **root** slot, so the button is
 there even when no conversation is open — on any page. When the sidebar is collapsed into its narrow

package/client.js

@@ -114,20 +114,33 @@ const SLEEP_DEFAULT_COUNTDOWN_SECONDS = 20
 /** How long the note of a finished rehearsal stays on screen (ms). */
 const SLEEP_DRY_RUN_NOTICE_MS = 8_000
 
+/**
+ * The grace window 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.
+ */
+const GRACE_CHOICES_SECONDS = Object.freeze([0, 3, 5, 10, 20, 30])
+
+/** The grace window used when the Host did not report one (ms / seconds). */
+const GRACE_DEFAULT_MS = 10_000
+const GRACE_DEFAULT_SECONDS = 10
+
 const ZH = {
   label: '待重启',
-  busyPrefix: ' · 被 ',
-  busySuffix: ' 个会话占用',
+  busyPrefix: ' · 等待 ',
+  busySuffix: ' 个任务结束',
   idle: ' · 空闲后自动重启',
-  goalActive: ' · 被某个会话自动续跑的 goal 占着',
-  goalExhausted: ' · 某个会话的 goal 轮次额度已用完，无法续跑',
+  goalActive: ' · 被某个自动续跑的 goal 占着',
+  goalExhausted: ' · 某个任务的 goal 轮次额度已用完，无法续跑',
   parkedGoals: ' · 已停泊 {n} 个 goal，重启后自动继续',
   parkButton: '停泊并重启',
   parkButtonAria: '停泊该会话的 goal，并立即请求重启',
   parkBusy: '停泊中…',
   parkError: '停泊失败：{message}',
   tooltip: '等待其他会话空闲后自动重启；重启后会自动继续本会话进度',
-  tooltipBusy: '等待其他会话空闲后自动重启（计数含“排队但还没开始”的任务）；重启后本会话会自动继续进度',
+  tooltipBusy: '等待其他任务结束（计数含“排队但还没开始”的任务）后自动重启；重启后本会话会自动继续进度',
   tooltipWithError: '等待其他会话空闲后自动重启；重启后本会话会自动继续进度。{message}',
   dotAria: '待重启',
   panelHeading: '待重启',
@@ -136,7 +149,13 @@ const ZH = {
   panelStateGoalActive: '等待其他会话停泊它自动续跑的 goal',
   panelStateGoalExhausted: '等待其他会话的 goal（轮次额度已用完）',
   panelBlockedTitle: '占用会话：{title}',
-  panelBlockedGeneric: '有一个会话正在运行',
+  panelBlockedGeneric: '有一个任务正在运行',
+  // One line per blocker: a session and a subagent are told apart, and
+  // neither of them is ever shown as a raw session id.
+  panelBlockedSession: '会话「{label}」正在运行',
+  panelBlockedSubagent: '{name}正在运行',
+  panelBlockedSubagentGeneric: '有一个子智能体正在运行',
+  panelBlockedRestartPending: '等这次重启完成后再关机',
   panelGoalActiveLine: '占用会话「{title}」：goal 正在自动续跑（goal-active）',
   panelGoalExhaustedLine: '占用会话「{title}」：goal 轮次额度已用完，无法继续（goal-exhausted）',
   panelParkedTitle: '已停泊的 goal（重启后自动继续）：',
@@ -177,6 +196,10 @@ const ZH = {
   '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.backup.label': '重启前备份',
   'settings.backup.hint': '每次重启前先快照一次当前配置；万一重启后起不来，能自动回退。',
   'settings.backupPlugins.label': '备份包含已安装插件',
@@ -212,7 +235,8 @@ const ZH = {
   'sleep.countdown.hint': '再过 {n} 秒就关机，点「算了，别关」可以留下。',
   'sleep.waiting.title': '还在等大家收工',
   'sleep.waiting.body': '等这些会话忙完，就轮到关机啦：',
-  'sleep.waiting.count': '还有 {n} 个会话在干活',
+  'sleep.waiting.count': '还有 {n} 个任务在干活',
+  'sleep.waiting.subagents': '其中 {k} 个是子智能体',
   'sleep.waiting.blocker': '· {title}',
   'sleep.waiting.none': '（正在确认还有谁在忙）',
   'sleep.waiting.cancel': '不关了',
@@ -246,8 +270,8 @@ const ZH = {
 
 const EN = {
   label: 'Pending restart',
-  busyPrefix: ' · blocked by ',
-  busySuffix: ' session(s)',
+  busyPrefix: ' · waiting for ',
+  busySuffix: ' task(s) to finish',
   idle: ' · restarts once idle',
   goalActive: ' · held by a self-continuing goal',
   goalExhausted: ' · a goal ran out of rounds',
@@ -259,7 +283,7 @@ const EN = {
   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 sessions to become idle, then restarts automatically (the count includes work that is queued but not started yet); this session resumes its progress after the restart.',
+    '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.',
   tooltipWithError:
     'Waits for the other sessions to become idle, then restarts automatically; this session resumes its progress after the restart. {message}',
   dotAria: 'Pending restart',
@@ -269,7 +293,13 @@ const EN = {
   panelStateGoalActive: 'Waiting for the other sessions to park their self-continuing goal',
   panelStateGoalExhausted: 'Waiting for the other sessions\' goal (its round budget is used up)',
   panelBlockedTitle: 'Blocking session: {title}',
-  panelBlockedGeneric: 'One session is running',
+  panelBlockedGeneric: 'One task is running',
+  // One line per blocker: a session and a subagent are told apart, and
+  // neither of them is ever shown as a raw session id.
+  panelBlockedSession: 'Session "{label}" is running',
+  panelBlockedSubagent: '{name} is running',
+  panelBlockedSubagentGeneric: 'One subagent is 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)',
   panelParkedTitle: 'Parked goals (they continue after the restart):',
@@ -310,6 +340,10 @@ const EN = {
   '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.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',
@@ -345,7 +379,8 @@ const EN = {
   'sleep.countdown.hint': 'Powering off in {n} seconds — pick "Never mind, keep it on" to stay.',
   'sleep.waiting.title': 'Waiting for everyone to finish',
   'sleep.waiting.body': 'Once these sessions are done, the machine powers off:',
-  'sleep.waiting.count': '{n} session(s) still working',
+  'sleep.waiting.count': '{n} task(s) still working',
+  'sleep.waiting.subagents': '{k} of them are subagents',
   'sleep.waiting.blocker': '· {title}',
   'sleep.waiting.none': '(checking who is still busy)',
   'sleep.waiting.cancel': 'Keep it on',
@@ -731,6 +766,53 @@ if (moduleLoader) moduleLoader.load({
       ))
     }
 
+    /**
+     * The line of one blocker: a session and a subagent are told apart, and
+     * neither of them is ever shown as a raw session id.
+     *
+     * The Host says WHAT the blocker is (`kind`) and HOW it is called: a
+     * session by its own title (`label`), a subagent by the whole phrase
+     * (`name`: "写代码的会话的子智能体"). The phrase is used as it is — it
+     * reads as a sentence, while a bracketed label would read like an
+     * annotation. A subagent whose parent title is unknown has no name of its
+     * own, so it gets the generic line instead of an empty bracket.
+     *
+     * @param {any} entry the blocker the Host reported
+     * @returns {string}
+     */
+    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() : ''
+      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() : ''
+        if (name === '' || label === '') return t('panelBlockedSubagentGeneric')
+        return fill(t('panelBlockedSubagent'), { name })
+      }
+      return label === ''
+        ? t('panelBlockedGeneric')
+        : fill(t('panelBlockedSession'), { label })
+    }
+
+    /**
+     * Whether a blocker is a pending RESTART (and not a task that is running).
+     *
+     * The restart is not a task: it is the thing the shutdown waits for, so it
+     * is never counted as one.
+     *
+     * @param {any} entry
+     * @returns {boolean}
+     */
+    function isRestartPending(entry) {
+      return Boolean(entry) && entry.kind === 'restart-pending'
+    }
+
     /** 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))
@@ -2296,6 +2378,15 @@ 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
+        : GRACE_DEFAULT_MS
+      const graceSeconds = GRACE_CHOICES_SECONDS.indexOf(Math.round(reportedGraceMs / 1000)) === -1
+        ? GRACE_DEFAULT_SECONDS
+        : Math.round(reportedGraceMs / 1000)
 
       /**
        * Write one change into the profile configuration.
@@ -2363,6 +2454,33 @@ if (moduleLoader) moduleLoader.load({
           ),
           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 })
+              },
+            },
+            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.grace.hint')),
+        ),
         h(
           'label',
           { className: 'dsh-autorestart-settings__field' },
@@ -2873,6 +2991,14 @@ if (moduleLoader) moduleLoader.load({
       if (phase === 'waiting') {
         ensureSleepStyle()
         const blockers = status && Array.isArray(status.blockers) ? status.blockers : []
+        // A pending restart is not a task: it is what the shutdown waits for,
+        // so it is never counted as one.
+        const tasks = blockers.filter((entry) => !isRestartPending(entry))
+        // How many of the blockers are subagents: the card says so, so the
+        // count is not read as "that many conversations".
+        const subagentCount = tasks.filter(
+          (entry) => entry && entry.kind === 'subagent',
+        ).length
         return h(
           'div',
           {
@@ -2886,23 +3012,35 @@ if (moduleLoader) moduleLoader.load({
           h('p', { className: 'dsh-autorestart-sleep-waiting__title' }, t('sleep.waiting.title')),
           h('p', { className: 'dsh-autorestart-sleep-waiting__body' }, t('sleep.waiting.body')),
           blockers.length === 0
-            ? h('p', { className: 'dsh-autorestart-sleep-waiting__none' }, t('sleep.waiting.none'))
+            ? h(
+              'p',
+              { className: 'dsh-autorestart-sleep-waiting__none' },
+              // The Host's own message explains WHY the machine waits (the
+              // grace window for work this plugin cannot see); the generic
+              // line is only the fallback.
+              typeof status.message === 'string' && status.message !== ''
+                ? status.message
+                : t('sleep.waiting.none'),
+            )
             : h(
               'ul',
               { className: 'dsh-autorestart-sleep-waiting__list' },
               blockers.map((entry, index) => h(
                 'li',
                 { key: 'blocker-' + index },
-                fill(t('sleep.waiting.blocker'), {
-                  title: entry && typeof entry.title === 'string' && entry.title !== ''
-                    ? entry.title
-                    : t('panelBlockedGeneric'),
-                }),
+                blockerLine(entry),
               )),
             ),
-          h('p', { className: 'dsh-autorestart-sleep-waiting__count' }, blockers.length === 0
+          h('p', { className: 'dsh-autorestart-sleep-waiting__count' }, tasks.length === 0
+            ? null
+            : fill(t('sleep.waiting.count'), { n: tasks.length })),
+          subagentCount === 0
             ? null
-            : fill(t('sleep.waiting.count'), { n: blockers.length })),
+            : h(
+              'p',
+              { className: 'dsh-autorestart-sleep-waiting__subagents' },
+              fill(t('sleep.waiting.subagents'), { k: subagentCount }),
+            ),
           errorLine(),
           h(
             'button',

package/cordis.patch.yml

@@ -25,6 +25,14 @@
         relaunchDelaySeconds: 2
         # quiet window (ms) after the last conversation activity before a restart may fire
         settleMs: 2000
+        # Grace window (ms): the extra wait after the LAST conversation finished,
+        # before the host is really restarted or switched off. This plugin can
+        # only see the DSH agents — other plugins (a memory plugin that writes
+        # its notes a few seconds later, a summary, an MCP callback) queue
+        # their work with a timer of their own, and that work is invisible
+        # here. A DROPDOWN in the settings page: 0 / 3 / 5 / 10 / 20 / 30
+        # seconds. `0` means "no extra wait" (the behaviour of 0.4.0).
+        restartGraceMs: 10000
         # dsh web: reload the page when the host boot token changes
         autoReloadPage: true
         # hard-block shell commands that would kill/relaunch DSH by hand