dsh-autorestart 0.8.2 → 0.8.3

package/docs/README.zh.md

@@ -20,7 +20,7 @@
 - 多个会话同时要求重启时合并成一次，且每个请求者都会被唤醒；
 - 带 goal 的会话不会把重启卡死：重启前自动**解除（disarm）**它的 goal（当前那一轮照常跑完，什么都不丢），重启之后自动重新上链；
 - 重启前有两道检查：宿主侧查一次，独立 helper 在杀进程前再查一次；
-- 界面上能看到状态：输入框工具行左侧的"待重启 · 等待 N 个任务结束"小胶囊、左侧栏会话标题旁的圆点；快重启时圆点呼吸，点胶囊看详情；
+- 界面上能看到状态：输入框工具行左侧的"待重启 · 等待 N 个会话"小胶囊、左侧栏会话标题旁的圆点；快重启时圆点呼吸，点胶囊看详情；
 - 可配置：静默窗口（默认 2 秒）、杀进程前等待（默认 2 秒）、忙碌时是否允许强制重启等。
 - 同一套"等到大家都安静"的想法还做成了**收工关机**：左侧栏最底部（设置按钮旁边）一个月亮按钮 → 等所有会话收工 → 屏幕上倒数（一张浮动卡片：大字 + 鲸鱼娘）→ **关掉整台电脑**（见「收工关机」）。
 
@@ -330,7 +330,7 @@ agent/status(running) ──► 写 checkpoint（<DSH_HOME>\storages\dsh-autores
 
 ## 安装
 
-当前版本：**0.8.2**。
+当前版本：**0.8.3**。
 
 ```powershell
 # 在 dsh 里（或对 Agent 说）：把工作区里的这个包安装为 profile bundle
@@ -533,7 +533,7 @@ restart gate: action=wait reason=agents-busy-within-soft-window busyCount=1 quie
 不放名字，也不放任何"双击可以取消"之类的提示（没地方放）。**单击**它（或聚焦后按 Enter / 空格）会在上方
 弹出一个小面板：
 
-- 这次重启还在等几个任务结束；
+- 这次重启还在等几个会话；
 - 还有几个**别的**会话也在等同一次重启；
 - 一个按钮：「取消我的这次重启」。
 
@@ -933,8 +933,8 @@ or by requesting the health path with ?gate=1.
 
 - 胶囊渲染在**输入框工具行左侧**（`conversation.input.left` 槽位），是一个高度约 22px 的小胶囊，**不额外占一行**（不再是输入框上方的一整行）。
 - 只有当健康路由 `/__dsh_autorestart/health?state=1` 返回 `pendingRestart: true` **且**本会话 id 出现在 `waiters` 列表里时才会出现；别的会话等待重启时你看不到它。
-- 文案有多种状态：还有别的**任务**占着时显示「待重启 · 等待 N 个任务结束」；都空闲时显示「待重启 · 空闲后自动重启」；被某个**自动续跑的 goal** 占着时显示「待重启 · 被某个自动续跑的 goal 占着」（见下面的升级 3）。
-- 悬停提示（原生 `title`）：「等待其他任务结束（计数含"排队但还没开始"的任务）后自动重启；重启后会自动继续本会话进度」。
+- 文案有多种状态：还有别的**会话**占着时显示「待重启 · 等待 N 个会话」；都空闲时显示「待重启 · 空闲后自动重启」；被某个**自动续跑的 goal** 占着时显示「待重启 · 被某个自动续跑的 goal 占着」（见下面的升级 3）。
+- 悬停提示（原生 `title`）：「等待其他会话结束（计数含"排队但还没开始"的会话）后自动重启；重启后会自动继续本会话进度」。
 - **每个占用者都说清自己是什么**：普通会话用它自己的标题；**子智能体**用"创建它的那个会话"的标题来称呼（显示成「子智能体（那个会话）」）。**原始的 `session-xxxx` 永远不会推给界面** —— 取不到标题时用一个通用说法。
 - 颜色走**品牌色（蓝紫）** `var(--dsw-alias-brand-primary, #5b8def)`，**不再用告警黄（warning）色**：胶囊里的小圆点和侧边栏圆点都是品牌色，胶囊边框保持中性（`--dsw-alias-border-l1`），文字保持中性。
 - 左侧边栏会话行的**行首 16px 状态格**里也会出现一个同款 8px 圆点（`sidebar.session.row.leading` 槽位，id `autorestart-restart-dot`，order 20）：纯图标，完整说明放在悬停 `title` 里，aria-label 为「待重启」/「Pending restart」。

package/index.js

@@ -387,7 +387,7 @@ function snapGraceChoice(value, fallback = DEFAULT_RESTART_GRACE_MS) {
  * `pluginVersion()`), but a bundled installation may not ship that file — so
  * the constant below is the last resort. A test keeps the two in sync.
  */
-const PLUGIN_VERSION_FALLBACK = '0.8.2'
+const PLUGIN_VERSION_FALLBACK = '0.8.3'
 
 /**
  * The version of the graceful-shutdown FEATURE, not the version of the package.
@@ -2714,6 +2714,9 @@ const titleOfSummary = (item) => {
       at: record && typeof record === 'object' ? record.at : null,
       progress: record && typeof record === 'object' ? record.progress : null,
       blocking: record && typeof record === 'object' && Number.isFinite(record.blocked) ? record.blocked : blocked,
+      // The measured size of the pre-restart snapshot: it survives the stage
+      // change, so a page that missed the copy can still report it.
+      snapshotBytes: record && typeof record === 'object' ? record.snapshotBytes : null,
       now: Date.now(),
     })
   }
@@ -4373,7 +4376,7 @@ const titleOfSummary = (item) => {
     /**
      * The stage of a restart, cut down for the health route (no long texts).
      *
-     * @returns {object} `{ phase, at, progress, slow, cancellable }`
+     * @returns {object} `{ phase, at, blocking, progress, slow, cancellable }`
      */
     restartStageBrief() {
       const info = restartStageInfo()
@@ -4381,6 +4384,11 @@ const titleOfSummary = (item) => {
         phase: info.phase,
         at: info.at,
         elapsedMs: info.elapsedMs,
+        // How many tasks still hold the gate: the centred overlay prints the
+        // number, so it travels as a number and not only inside `text`.
+        blocking: info.blocking,
+        // The size of the pre-restart snapshot, on every stage (bytes).
+        snapshotBytes: info.snapshotBytes,
         progress: info.progress === null
           ? null
           : { files: info.progress.files, bytes: info.progress.bytes, total: info.progress.total, percent: info.progress.percent, ageMs: info.progress.ageMs },
@@ -7879,11 +7887,16 @@ function registerHealthRoute(ctx, runtime, config, sleep) {
           // without one is sent exactly as the gate produced it. The goal
           // reason (`goal-active` / `goal-exhausted`) is attached as well, so
           // the client can tell a goal-driven blocker from a busy session.
-          const blockedBy = goalAwareBlockingDetails(runtime, verdict.blockedBy).map((entry) => {
-            if (!entry || typeof entry !== 'object') return entry
-            const title = runtime.sessionTitle(entry.sessionId)
-            return title ? { ...entry, title } : entry
-          })
+          // A blocker that is not an object (an empty string still reported by
+          // an older route, a null) is not a blocker: it has no session and no
+          // name, and rendering one produced the bare ",," the user saw. It is
+          // dropped HERE, so the interface never receives one.
+          const blockedBy = goalAwareBlockingDetails(runtime, verdict.blockedBy)
+            .filter((entry) => entry && typeof entry === 'object')
+            .map((entry) => {
+              const title = runtime.sessionTitle(entry.sessionId)
+              return title ? { ...entry, title } : entry
+            })
           stateBody = JSON.stringify({
             ok: true,
             pendingRestart,
@@ -7891,6 +7904,12 @@ function registerHealthRoute(ctx, runtime, config, sleep) {
             generation: live.generation,
             waiters,
             blockedBy,
+            // THE ONE NUMBER both client surfaces read: the capsule and the
+            // panel it opens. Counting the blockers in the browser is what made
+            // "1 个会话在忙" sit next to "还在等 0 个任务" — the two surfaces
+            // counted different filtered copies of the same list (user report,
+            // 2026-10-29). A blocker without a readable name is still a task.
+            busyCount: countBlockerTasks(verdict.blockedBy),
             allowRestart: verdict.allow === true,
             // WHY the gate says what it says. Without this, "allowRestart is
             // false and blockedBy is empty" looks like a contradiction: the

package/lib/checkpoint.js

@@ -223,6 +223,11 @@ function normalizeRestartPhase(raw, now) {
     startedAt,
     at,
     progress,
+    // HOW BIG THE PRE-RESTART BACKUP WAS. It is kept across the stage change on
+    // purpose: a hosted profile can be 92 KB and the copy takes ~5 ms, so a page
+    // that polls every 2 s would otherwise never learn that a backup happened
+    // (user report, 2026-10-29). null = nothing was measured.
+    snapshotBytes: isFiniteNumber(raw.snapshotBytes) ? Math.max(0, Math.trunc(raw.snapshotBytes)) : null,
     blocked: isFiniteNumber(raw.blocked) ? Math.max(0, Math.trunc(raw.blocked)) : 0,
   };
   return { record, changed };
@@ -246,10 +251,18 @@ export function setRestartPhase(state, { phase, now = Date.now(), blocked = 0, r
   const previous = isObject(state.restartPhase) ? state.restartPhase : null;
   // A new restart starts its own clock; a stage change inside the same restart
   // keeps the start time, so "elapsed" is the whole restart and not one stage.
-  const startedAt = restartStage && previous !== null && RESTART_PHASES.includes(previous.phase)
-    && !(phase === 'waiting' && previous.phase !== 'waiting')
-    ? previous.startedAt
-    : moment;
+  const sameRestart = restartStage && previous !== null && RESTART_PHASES.includes(previous.phase)
+    && !(phase === 'waiting' && previous.phase !== 'waiting');
+  const startedAt = sameRestart ? previous.startedAt : moment;
+  // THE SIZE OF THE SNAPSHOT, measured once and then CARRIED: the live byte
+  // counter while the copy runs, the final size afterwards. A 92 KB profile is
+  // copied in ~5 ms, so this number is the only thing a polling interface can
+  // still say about a backup that really happened (user report, 2026-10-29).
+  const measuredBytes = previous !== null && isFiniteNumber(previous.snapshotBytes)
+    ? Math.max(0, Math.trunc(previous.snapshotBytes))
+    : (previous !== null && isObject(previous.progress) && isFiniteNumber(previous.progress.bytes)
+      ? Math.max(0, Math.trunc(previous.progress.bytes))
+      : null);
   const record = {
     phase,
     startedAt,
@@ -259,6 +272,9 @@ export function setRestartPhase(state, { phase, now = Date.now(), blocked = 0, r
     progress: phase === 'snapshotting' && previous !== null && previous.phase === 'snapshotting'
       ? previous.progress
       : null,
+    // A NEW restart starts with nothing measured; a stage change inside one
+    // restart keeps the size it already has.
+    snapshotBytes: sameRestart ? measuredBytes : null,
     blocked: isFiniteNumber(blocked) ? Math.max(0, Math.trunc(blocked)) : 0,
   };
   state.restartPhase = record;
@@ -289,6 +305,9 @@ export function setRestartProgress(state, { files = 0, bytes = 0, total = 0, fil
       filesTotal: number(filesTotal),
       at: moment,
     },
+    // The live byte counter IS the size of the snapshot so far: keeping it here
+    // means the number survives the moment the copy ends.
+    snapshotBytes: number(bytes),
     blocked: previous !== null && isFiniteNumber(previous.blocked) ? previous.blocked : 0,
   };
   state.updatedAt = moment;

package/lib/restart-phase.js

@@ -152,6 +152,7 @@ export function estimateRemainingSeconds({ bytes = null, total = null, elapsedMs
  *   cancellable: boolean,
  *   cancelReason: string|null,
  *   estimateSeconds: number|null,
+ *   blocking: number|null,
  *   text: { zh: string, en: string },
  * }}
  */
@@ -161,6 +162,7 @@ export function describeRestartPhase({
   at = null,
   progress = null,
   blocking = null,
+  snapshotBytes = null,
   now = Date.now(),
 } = {}) {
   const stage = isRestartPhase(phase) ? phase : 'idle';
@@ -206,10 +208,21 @@ export function describeRestartPhase({
 
   const estimateSeconds = stage === 'snapshotting' ? seconds : null;
   const done = measured === null ? null : formatBytes(measured.bytes);
+  // HOW MANY TASKS STILL HOLD THE GATE. The centred overlay says
+  // "还有 N 个会话" as a number of its own, so the count travels as a NUMBER
+  // and not only inside the sentence: a surface that has room for two words
+  // must not have to parse the long text.
+  //
+  // NULL means "the caller did not say", which is not the same as zero:
+  // Number(null) is 0, and a stage that was never given a count must not
+  // pretend the gate is free.
+  const blockingCount = blocking === null || blocking === undefined || blocking === ''
+    ? null
+    : nonNegative(blocking);
 
   let text;
   if (stage === 'waiting') {
-    const count = nonNegative(blocking);
+    const count = blockingCount;
     const suffixZh = count && count > 0 ? '（还有 ' + count + ' 个会话在忙）' : '';
     const suffixEn = count && count > 0 ? ' (' + count + (count === 1 ? ' conversation' : ' conversations') + ' busy)' : '';
     text = {
@@ -217,20 +230,36 @@ export function describeRestartPhase({
       en: 'Waiting for every conversation to be idle…' + suffixEn,
     };
   } else if (stage === 'snapshotting') {
-    // The number appears ONLY when it was measured. "预计 X 秒" needs a real
-    // speed behind it, otherwise the text says what it knows and nothing more.
-    const etaZh = estimateSeconds === null ? '' : '，预计 ' + estimateSeconds + ' 秒';
-    const etaEn = estimateSeconds === null ? '' : ', about ' + estimateSeconds + 's left';
-    const doneZh = done === null ? '' : '，已完成 ' + done;
-    const doneEn = done === null ? '' : ', ' + done + ' done';
+    // ONE VOICE (user report, 2026-10-29): "正在备份" did not say WHAT was being
+    // backed up — the card says "DSH 重启前备份中", and this sentence (the
+    // settings page and the tooltip) says the same words, so no surface can
+    // disagree about what is running.
+    //
+    // The numbers appear ONLY when they were measured: "预计 X 秒" needs a real
+    // speed behind it, and "已完成 Y MB" a real byte count. With nothing
+    // measured yet the sentence claims nothing at all.
+    const measuredZh = [];
+    const measuredEn = [];
+    if (estimateSeconds !== null) {
+      measuredZh.push('预计 ' + estimateSeconds + ' 秒');
+      measuredEn.push('about ' + estimateSeconds + 's');
+    }
+    if (done !== null) {
+      measuredZh.push('已完成 ' + done);
+      measuredEn.push(done + ' done');
+    }
+    const detailZh = measuredZh.length === 0 ? '' : '（' + measuredZh.join('，') + '）';
+    const detailEn = measuredEn.length === 0 ? '' : ' (' + measuredEn.join(', ') + ')';
     text = {
-      zh: '正在备份配置和插件' + etaZh + doneZh + '…',
-      en: 'Backing up the configuration and the plugins' + etaEn + doneEn + '…',
+      zh: 'DSH 重启前备份中' + detailZh + '…',
+      en: 'Backing up before DSH restart' + detailEn + '…',
     };
     if (slow !== null) {
+      // Still the same subject when it is slow: the user must know WHICH backup
+      // is slow, not only that "the backup" is.
       text = {
-        zh: '备份比预期慢（可能磁盘很忙），还在继续…' + (done === null ? '' : '（已完成 ' + done + '）'),
-        en: 'The backup is slower than expected (the disk may be busy); it is still running…'
+        zh: 'DSH 重启前备份比预期慢（可能磁盘很忙），还在继续…' + (done === null ? '' : '（已完成 ' + done + '）'),
+        en: 'The DSH pre-restart backup is slower than expected (the disk may be busy); it is still running…'
           + (done === null ? '' : ' (' + done + ' done)'),
       };
     }
@@ -258,6 +287,18 @@ export function describeRestartPhase({
     cancellable: isCancellable(stage),
     cancelReason: cancelRefusalReason(stage),
     estimateSeconds,
+    // The number of tasks the gate still waits for, on its own: the centred
+    // overlay prints it, and a surface with room for two words must not have
+    // to parse the long sentence of `text`.
+    blocking: blockingCount,
+    // HOW BIG THE PRE-RESTART BACKUP IS (bytes). It is reported on EVERY stage
+    // of the restart, not only while the copy runs, so a card that appears a
+    // moment late can still say "backup done (92 KB)" instead of nothing.
+    // null means "nothing was measured", which is NOT the same as zero bytes:
+    // Number(null) is 0, and a receipt for a 0-byte backup would be a lie.
+    snapshotBytes: snapshotBytes === null || snapshotBytes === undefined || snapshotBytes === ''
+      ? null
+      : nonNegative(snapshotBytes),
     text,
   };
 }

package/locale/en.json

@@ -1,7 +1,7 @@
 {
   "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",
@@ -12,7 +12,7 @@
   "parkBusy": "Parking…",
   "parkError": "Park failed: {message}",
   "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.",
+  "tooltipBusy": "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",
   "panelHeading": "Pending restart",
@@ -48,7 +48,7 @@
   "durationMinutesShort": "{n} min",
   "durationHoursShort": "{n}h",
   "durationHoursMinutesShort": "{n}h {m}m",
-  "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",
@@ -201,8 +201,10 @@
       "copyPath": "Copy the path",
       "copied": "The path is on the clipboard",
       "copyFailed": "The copy failed — please select the path above by hand",
-      "withPlugins": "includes the installed plugins",
-      "withoutPlugins": "configuration only"
+      "time": "Backup time",
+      "size": "Backup size",
+      "withPlugins": "(plugins included)",
+      "withoutPlugins": "(plugins excluded)"
     },
     "backupPlugins": {
       "label": "Include the installed plugins in the backup",
@@ -299,6 +301,11 @@
       "tierNone": "(this machine has no way to run it)"
     },
     "error": "Could not save the settings: {message}",
+    "saveNotice": {
+      "saved": "Saved",
+      "failed": "Not saved",
+      "dismiss": "Dismiss"
+    },
     "autostartKind": {
       "other": "something else",
       "windows-task": "Windows scheduled task",
@@ -321,6 +328,20 @@
       "self-supervised": "the supervisor of this plugin started it"
     }
   },
+  "restart": {
+    "stage": {
+      "snapshotting": "Backing up…",
+      "restarting": "Restarting…",
+      "back": "Back"
+    },
+    "overlay": {
+      "snapshotting": "Backing up before DSH restart",
+      "size": "{done} / {total}",
+      "sizeDone": "{done}",
+      "restarting": "Restarting…",
+      "back": "Back again"
+    }
+  },
   "meta": {
     "title": "dsh-autorestart — restart continuation",
     "description": "Keeps agent work alive across a DeepSeek Harness restart: a durable checkpoint, goal re-arm or a continuation message on boot, and an idle-aware graceful restart the agent can request itself."

package/locale/zh.json

@@ -1,7 +1,7 @@
 {
   "label": "待重启",
   "busyPrefix": " · 等待 ",
-  "busySuffix": " 个任务结束",
+  "busySuffix": " 个会话",
   "idle": " · 空闲后自动重启",
   "goalActive": " · 被某个自动续跑的 goal 占着",
   "goalExhausted": " · 某个任务的 goal 轮次额度已用完，无法续跑",
@@ -12,7 +12,7 @@
   "parkBusy": "停泊中…",
   "parkError": "停泊失败：{message}",
   "tooltip": "等待其他会话空闲后自动重启；重启后会自动继续本会话进度",
-  "tooltipBusy": "等待其他任务结束（计数含“排队但还没开始”的任务）后自动重启；重启后本会话会自动继续进度",
+  "tooltipBusy": "等待其他会话结束（计数含“排队但还没开始”的会话）后自动重启；重启后本会话会自动继续进度",
   "tooltipWithError": "等待其他会话空闲后自动重启；重启后本会话会自动继续进度。{message}",
   "dotAria": "待重启",
   "panelHeading": "待重启",
@@ -48,7 +48,7 @@
   "durationMinutesShort": "{n} 分钟",
   "durationHoursShort": "{n} 小时",
   "durationHoursMinutesShort": "{n} 小时 {m} 分",
-  "cancelPanelTasks": "这次重启还在等 {n} 个任务结束",
+  "cancelPanelTasks": "还在等 {n} 个会话",
   "cancelPanelOthers": "还有 {n} 个会话也在等这次重启",
   "cancelPanelOthersAfter": "还剩 {n} 个会话在等",
   "cancelPanelAria": "待重启详情",
@@ -201,8 +201,10 @@
       "copyPath": "复制路径",
       "copied": "路径已复制",
       "copyFailed": "复制失败，请手动选中上面的路径",
-      "withPlugins": "含已装插件",
-      "withoutPlugins": "只有配置"
+      "time": "备份时间",
+      "size": "备份大小",
+      "withPlugins": "（含已装插件）",
+      "withoutPlugins": "（不含已装插件）"
     },
     "backupPlugins": {
       "label": "备份包含已安装插件",
@@ -299,6 +301,11 @@
       "tierNone": "（这台机器没有可用机制）"
     },
     "error": "没能保存设置：{message}",
+    "saveNotice": {
+      "saved": "已生效",
+      "failed": "没保存成功",
+      "dismiss": "关闭"
+    },
     "autostartKind": {
       "other": "其他方式",
       "windows-task": "Windows 计划任务",
@@ -321,6 +328,20 @@
       "self-supervised": "它由本插件自己的守护在管"
     }
   },
+  "restart": {
+    "stage": {
+      "snapshotting": "重启前备份中",
+      "restarting": "正在重启…",
+      "back": "已回来"
+    },
+    "overlay": {
+      "snapshotting": "DSH 重启前备份中",
+      "size": "{done} / {total}",
+      "sizeDone": "{done}",
+      "restarting": "正在重启…",
+      "back": "已回来"
+    }
+  },
   "meta": {
     "title": "dsh-autorestart — 重启不断线",
     "description": "让 DeepSeek Harness 重启后接着干活：落盘的检查点、启动时重新武装 goal 或给一条续接提示，以及一次等人闲下来的优雅重启。"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-autorestart",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "type": "module",
   "description": "DeepSeek Harness plugin: restart without losing work. Waits until every conversation is idle, restarts the host, then automatically resumes the interrupted sessions. AI-generated, not human-reviewed: use with caution.",
   "license": "MIT",