sintbot 1.4.2 → 1.4.4

package/CHANGELOG.en.json

@@ -1,4 +1,54 @@
 [
+  {
+    "version": "1.4.4",
+    "date": "2026-11-09",
+    "name": "Upgrade progress in the console",
+    "items": [
+      {
+        "t": "Confirm the upgrade in the page",
+        "d": "Upgrade now asks for confirmation in the page, stating the versions and that new messages wait about a minute during the switch."
+      },
+      {
+        "t": "The upgrade window shows each step",
+        "d": "Waiting for idle groups, download and install, stopping the current service, checking records and backing up, preflight, switching and starting, and waiting for every group to connect are ticked off one by one with the elapsed time; while waiting it names the groups still working."
+      },
+      {
+        "t": "Reconnects while the service restarts",
+        "d": "During the switch the page says the service is restarting and reconnects by itself; once the new version connects every group it reloads into the new console and shows the result once. A failed step and the restored version are marked."
+      },
+      {
+        "t": "Can run in the background",
+        "d": "Continue in background keeps a spinner on the top-bar icon, which reopens the progress; a notice appears when the upgrade ends."
+      },
+      {
+        "t": "Takes effect from 1.4.4",
+        "d": "The upgrade window comes from the running version: upgrading from 1.4.3 to 1.4.4 still shows the previous screen, and later upgrades show the window."
+      }
+    ]
+  },
+  {
+    "version": "1.4.3",
+    "date": "2026-11-09",
+    "name": "Progress on the reply card",
+    "items": [
+      {
+        "t": "A card appears even before any output",
+        "d": "If nothing has been produced after 25 seconds, a \"Received, working on it\" card appears and the answer later replaces it in place. A turn that ends without a reply recalls that card."
+      },
+      {
+        "t": "The card shows how far the task has got",
+        "d": "While running, one line updates every 15 seconds: how long it has run and what it is doing (reading, editing or writing which file, running a command, searching the web; file names only). After 10 minutes it updates once a minute, and notes when nothing has happened for more than 2 minutes. Delivered steps such as writing files, committing or pushing, and sending files to the group are listed with ▶ at the top of the card and fold into a \"Process\" section when the turn ends."
+      },
+      {
+        "t": "/status shows progress",
+        "d": "While running it shows how many steps have run, how long ago the last activity was, and what it is doing."
+      },
+      {
+        "t": "Fix: a streamed reply could fail the whole turn",
+        "d": "Text that arrived while the previous update was still being sent used to fail the turn; it now queues behind it and keeps updating the card."
+      }
+    ]
+  },
   {
     "version": "1.4.2",
     "date": "2026-11-09",

package/CHANGELOG.json

@@ -1,4 +1,54 @@
 [
+  {
+    "version": "1.4.4",
+    "date": "2026-11-09",
+    "name": "控制台升级显示进度",
+    "items": [
+      {
+        "t": "升级前在页面里确认",
+        "d": "点「现在升级」后在页面里确认，写明从哪个版本升到哪个版本，以及切换期间约一分钟不处理新消息。"
+      },
+      {
+        "t": "升级窗口显示每一步",
+        "d": "等待所有群空闲、下载安装、停止旧服务、核对记录并备份、新版本预检、切换并启动、等全部群连上，逐步打勾并显示已用时间；等群空闲时列出还在运行的群。"
+      },
+      {
+        "t": "服务重启时自动重连",
+        "d": "切换那几秒页面显示「服务正在重启」并自动重连；新版本连上全部群后自动刷新到新版控制台，再显示一次结果。失败时标出出错的那一步和已换回的版本。"
+      },
+      {
+        "t": "可以放到后台",
+        "d": "点「在后台继续」后顶栏图标转圈，点它可以再打开进度；升级结束时给一条提示。"
+      },
+      {
+        "t": "从 1.4.4 起生效",
+        "d": "升级窗口由正在运行的版本提供：从 1.4.3 升到 1.4.4 时仍是原来的界面，之后的升级才会显示。"
+      }
+    ]
+  },
+  {
+    "version": "1.4.3",
+    "date": "2026-11-09",
+    "name": "回复卡片显示进度",
+    "items": [
+      {
+        "t": "一时没有输出也先回一张卡",
+        "d": "25 秒还没有任何输出时，先出一张「已收到，正在处理」卡片；回答出来后在同一张卡里替换。这一轮最后决定不回复时，撤回这张卡。"
+      },
+      {
+        "t": "卡片显示做到哪了",
+        "d": "运行中每 15 秒更新一行：已跑多久、最近在做什么（看、改、写哪个文件，跑命令，查网页等，只给文件名）；跑满 10 分钟后改为每分钟一次，超过 2 分钟没有新动静会注明。写改文件、提交推送、发文件到群这类交付动作以 ▶ 列在卡片上方，结束后收进「过程」折叠区。"
+      },
+      {
+        "t": "/status 显示进度",
+        "d": "运行中会显示已执行几步、最近一次动静在多久前，以及最近在做什么。"
+      },
+      {
+        "t": "修复：流式回复偶发整轮失败",
+        "d": "上一段内容还在发送时又来一段文字，原来会让这一轮失败；现在排在后面继续更新卡片。"
+      }
+    ]
+  },
   {
     "version": "1.4.2",
     "date": "2026-11-09",

package/docs/AI-ASSISTED-INSTALL.md

@@ -1,4 +1,4 @@
-# Install SintBot 1.4.2 with an AI assistant
+# Install SintBot 1.4.4 with an AI assistant
 
 English · [简体中文](./zh-CN/AI-ASSISTED-INSTALL.md)
 
@@ -15,5 +15,5 @@ Use the terminal on the Mac that will run SintBot. A cloud shell cannot install
 ## Copyable request
 
 ```text
-Install SintBot 1.4.2 on this Mac using the one-line installation guide. Preserve existing services, configuration, state and Codex or Claude Code account data. Do not expose credentials. Verify the actual installed executable and binary core, configure the Feishu groups with their runners, and initialize only clean new state. Run the foreground preflight and an authorized read-only group test, check the result, then verify clean stop/restart. Stop temporary processes when finished, and distinguish package installation from successful group acceptance.
+Install SintBot 1.4.4 on this Mac using the one-line installation guide. Preserve existing services, configuration, state and Codex or Claude Code account data. Do not expose credentials. Verify the actual installed executable and binary core, configure the Feishu groups with their runners, and initialize only clean new state. Run the foreground preflight and an authorized read-only group test, check the result, then verify clean stop/restart. Stop temporary processes when finished, and distinguish package installation from successful group acceptance.
 ```

package/docs/install.md

@@ -1,4 +1,4 @@
-# Install SintBot 1.4.2
+# Install SintBot 1.4.4
 
 English · [简体中文](./zh-CN/install.md)
 
@@ -10,7 +10,7 @@ You need a Mac, Node.js 22 or newer, and projects stored on that Mac. Install an
 curl -fsSL https://sintbot.com/install.sh | bash
 ```
 
-The installer checks the environment, installs `sintbot@1.4.2` into `~/.local/share/sintbot`, and verifies the entry, built-in core and Feishu module. Continue when you see `Installed and verified SintBot 1.4.2`. No sudo is needed.
+The installer checks the environment, installs `sintbot@1.4.4` into `~/.local/share/sintbot`, and verifies the entry, built-in core and Feishu module. Continue when you see `Installed and verified SintBot 1.4.4`. No sudo is needed.
 
 To preview, append `-s -- --dry-run`. To choose another location, set `SINTBOT_INSTALL_DIR` and adjust the executable paths below.
 
@@ -86,12 +86,12 @@ In a group, send "Read the first line of the project README and reply with only
 
 ## 5. Use it in a group
 
-Any text message is a task. Replies arrive in a card that appears once the model starts answering and refreshes as it works.
+Any text message is a task. Replies arrive in a card that appears once the model starts answering, or after 25 seconds if it is still working without output. While the task runs, the card shows how long it has run, what it is doing and the steps already delivered; at the end those steps fold into a Process section.
 
 | Command | Effect |
 | --- | --- |
 | `/help` | List commands |
-| `/status` | Group status: model, project, busy or idle, queue |
+| `/status` | Group status: model, project, busy or idle (steps and current work while busy), queue |
 | `/model` | List models; `/model name` switches (only while the group is idle; starts a new conversation) |
 | `/new` | Start a new conversation (only while the group is idle) |
 | `/stop` | Stop the current task and cancel queued ones |
@@ -104,7 +104,7 @@ Messages sent while a task runs are added to that task in Codex groups (`codexSt
 
 With `--ui`, open `http://127.0.0.1:4600` on this Mac. The console shows each group (a paused group shows Needs attention), stops tasks, binds new groups, and switches the model or project folder of an idle group. For LAN access, set a console password in its settings first, then enable LAN access.
 
-Settings → Software updates checks for new releases. In the foreground setup above it shows the upgrade steps: press Ctrl-C and wait for exit, rerun the one-line installer, then start again with the same command. If your own launchd agent starts SintBot, Upgrade now waits until every group is idle and settled, installs the new version into `~/.local/share/sintbot/releases/<version>` and switches the agent to it; if the new version does not connect every group within 90 seconds, the previous one is restored. Upgrades are not announced in groups.
+Settings → Software updates checks for new releases. In the foreground setup above it shows the upgrade steps: press Ctrl-C and wait for exit, rerun the one-line installer, then start again with the same command. If your own launchd agent starts SintBot, Upgrade now waits until every group is idle and settled, installs the new version into `~/.local/share/sintbot/releases/<version>` and switches the agent to it; if the new version does not connect every group within 90 seconds, the previous one is restored. A window shows each step, reconnects by itself while the service restarts and can be left running in the background. Upgrades are not announced in groups.
 
 You can also add a group without the console: add it to the configuration, stop the service and run `start` again; the new group is registered automatically. Bound groups cannot be removed or renamed by editing the configuration.
 

package/docs/zh-CN/AI-ASSISTED-INSTALL.md

@@ -1,4 +1,4 @@
-# 用 AI 助手安装 SintBot 1.4.2
+# 用 AI 助手安装 SintBot 1.4.4
 
 [English](../AI-ASSISTED-INSTALL.md) · 简体中文
 
@@ -15,5 +15,5 @@
 ## 可复制的请求
 
 ```text
-按一行安装指南，在这台 Mac 安装 SintBot 1.4.2。保留已有服务、配置、状态和 Codex 或 Claude Code 账号数据，不输出凭据。验证实际入口与二进制核心，配置飞书群及各群的执行器，只对全新状态初始化。运行前台预检和已授权的只读群测试，对照结果，再验证正常停止与重启。完成后停止临时进程，并区分程序包安装与群验收结果。
+按一行安装指南，在这台 Mac 安装 SintBot 1.4.4。保留已有服务、配置、状态和 Codex 或 Claude Code 账号数据，不输出凭据。验证实际入口与二进制核心，配置飞书群及各群的执行器，只对全新状态初始化。运行前台预检和已授权的只读群测试，对照结果，再验证正常停止与重启。完成后停止临时进程，并区分程序包安装与群验收结果。
 ```

package/docs/zh-CN/install.md

@@ -1,4 +1,4 @@
-# 安装 SintBot 1.4.2
+# 安装 SintBot 1.4.4
 
 [English](../install.md) · 简体中文
 
@@ -10,7 +10,7 @@
 curl -fsSL https://sintbot.com/install.sh | bash
 ```
 
-安装器会自动检查环境，把 `sintbot@1.4.2` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.2` 就可以继续。不需要 sudo。
+安装器会自动检查环境，把 `sintbot@1.4.4` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.4` 就可以继续。不需要 sudo。
 
 可选预览：在命令末尾加 `-s -- --dry-run`。要自定义安装位置，设置 `SINTBOT_INSTALL_DIR` 环境变量，并同步修改后面的可执行文件路径。
 
@@ -86,12 +86,12 @@ SINTBOT="$HOME/.local/share/sintbot/bin/sintbot"
 
 ## 5. 在群里使用
 
-直接发文字就是给它派任务。回复以卡片呈现，模型开始输出后就会出现并随进度刷新。
+直接发文字就是给它派任务。回复以卡片呈现：模型开始输出时出现；25 秒还没有输出也会先出现。运行中卡片显示已跑多久、正在做什么和已完成的步骤，结束后这些步骤收进「过程」折叠区。
 
 | 命令 | 作用 |
 | --- | --- |
 | `/help` | 查看可用命令 |
-| `/status` | 本群状态：模型、项目、是否在忙、排队数 |
+| `/status` | 本群状态：模型、项目、是否在忙（在忙时含步数和正在做什么）、排队数 |
 | `/model` | 查看可选模型；`/model 名字` 切换（只在本群空闲时生效，切换后开始新的一段对话） |
 | `/new` | 开始新的一段对话（只在本群空闲时生效） |
 | `/stop` | 停止当前任务，连同排队的一起取消 |
@@ -104,7 +104,7 @@ SINTBOT="$HOME/.local/share/sintbot/bin/sintbot"
 
 带 `--ui` 启动后，在本机浏览器打开 `http://127.0.0.1:4600`。控制台可以查看各群状态（暂停的群显示「需要处理」）、停止任务、绑定新群、给空闲的群切换模型或项目目录。要从局域网访问，先在控制台的设置里设访问密码，再开启局域网访问。
 
-「设置 → 软件更新」会检查新版本。按上面前台方式运行时，卡片给出升级步骤：按 Ctrl-C 等待退出，重新运行一行安装命令，再用原来的命令启动。如果用你自己的 launchd 后台任务启动 SintBot，「现在升级」会等所有群空闲、记录结清后，把新版本装到 `~/.local/share/sintbot/releases/<版本>` 并切换过去；新版本 90 秒内没连上全部群会自动换回旧版。升级不在群里播报。
+「设置 → 软件更新」会检查新版本。按上面前台方式运行时，卡片给出升级步骤：按 Ctrl-C 等待退出，重新运行一行安装命令，再用原来的命令启动。如果用你自己的 launchd 后台任务启动 SintBot，「现在升级」会等所有群空闲、记录结清后，把新版本装到 `~/.local/share/sintbot/releases/<版本>` 并切换过去；新版本 90 秒内没连上全部群会自动换回旧版。升级时窗口逐步显示进度，服务重启时页面自动重连，也可以放到后台继续。升级不在群里播报。
 
 不用控制台也能加群：在配置里加上新群，停止后重新 `start` 即可，新群会自动登记。已绑定的群不能通过改配置删除或改名。
 

package/install.sh

@@ -2,7 +2,7 @@
 # The function is parsed in full before installation starts, including when piped.
 sintbot_install() (
   set -eu
-  version=1.4.2
+  version=1.4.4
   prefix="${SINTBOT_INSTALL_DIR:-$HOME/.local/share/sintbot}"
   fail() { printf 'SintBot: %s\n' "$*" >&2; exit 1; }
   case "${1:-}" in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sintbot",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "private": false,
   "description": "Drive your Mac projects from Feishu groups with Codex or Claude Code, using a built-in agent core.",
   "bin": {
@@ -103,6 +103,7 @@
     "src/core/redact.js",
     "src/core/store.js",
     "src/core/time.js",
+    "src/core/turnprogress.js",
     "src/core/v2engine.js",
     "src/core/verify.js",
     "src/design.js",

package/src/c2console.js

@@ -10,7 +10,7 @@ const READ_PATHS = ['/api/state', '/api/events', '/api/inbox', '/api/activity',
   '/api/changelog', '/api/changelog-en', '/api/codex/models', '/api/usage',
   '/api/plugins', '/api/design/styles', '/api/design/icons', '/api/fs/listdir',
   '/api/feishu/admin-candidates', '/api/feishu/org-users', '/api/feishu/resolve-contact',
-  '/api/feishu/chats', '/api/feishu/chat-members', START_PATH, CALLBACK_PATH]
+  '/api/feishu/chats', '/api/feishu/chat-members', '/api/update', START_PATH, CALLBACK_PATH]
 const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   '/api/ui/network', '/api/ui/public-url', '/api/ui/update-settings', '/api/feishu/admins',
   '/api/groups', '/api/groups/provider', '/api/fs/mkdir',

package/src/core/c2cardterminalpath.js

@@ -6,6 +6,7 @@
 // outbound executor a second time.
 const { createC2CardEffectBoundary, confirmCardOperation } = require('./c2cardeffectbridge')
 const { prepareTerminalEffectBridge, terminalReplyText } = require('./c2terminaleffectbridge')
+const { stripMilestones } = require('./turnprogress')
 
 function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
   receiptId, chatId, turnToken, generation, verifyGeneration,
@@ -130,7 +131,7 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
         return true
       } catch (error) { return fail(error) }
     },
-    async complete({ payload, replyText, paused = false, footer = '' } = {}) {
+    async complete({ payload, replyText, paused = false, footer = '', milestones = [] } = {}) {
       if (phase !== 'open' && phase !== 'plain') {
         throw new Error('C2 card terminal path is not open')
       }
@@ -143,7 +144,8 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
             typeof terminalPayload.quiet !== 'boolean' || terminalPayload.quiet !== receipt.quiet ||
             typeof terminalPayload.resultText !== 'string' ||
             typeof terminalPayload.bufferText !== 'string' ||
-            typeof footer !== 'string') {
+            typeof footer !== 'string' || !Array.isArray(milestones) ||
+            !milestones.every(item => typeof item === 'string' && item.trim())) {
           throw new TypeError('C2 card terminal payload differs from running turn')
         }
         if (card && await card.flush() !== true) {
@@ -184,8 +186,20 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
                 // is therefore not suitable for a durable final effect.
                 return sendPlainReply(target, visibleText)
               }
+              // Display only: milestone lines leave the answer and go into the
+              // card's "process" fold; an answer that was only milestones shows
+              // them as its body. The durable reply text stays exact.
+              let shownText = visibleText
+              const finishOpts = { footer }
+              if (milestones.length) {
+                const stripped = stripMilestones(visibleText)
+                if (stripped.trim()) {
+                  shownText = stripped
+                  finishOpts.milestones = [...milestones]
+                } else shownText = milestones.map(item => '▶ ' + item).join('\n')
+              }
               let calls = 0
-              const finished = await card.finish(visibleText, { footer,
+              const finished = await card.finish(shownText, { ...finishOpts,
                 terminalOperationBoundary: async operation => {
                   if (!operation || operation.kind !== 'card.update' ||
                       operation.cardId == null || typeof operation.invoke !== 'function' ||

package/src/core/c2durableruntime.js

@@ -205,6 +205,12 @@ class C2DurableRuntime {
   get blocked() { return this.#closed || this.#opening || this.#externalEffectInFlight || !this.#ingress ||
     this.#ingress.blocked || this.#journal.blocked }
 
+  // Closed or sealed for good. Unlike `blocked`, an outbound effect that is
+  // still awaiting its platform response does not count: a streaming card's
+  // next frame queues behind it instead of failing the turn.
+  get closed() { return this.#closed || !this.#ingress || this.#ingress.blocked ||
+    this.#journal.blocked }
+
   hasRecoveryPolicy({ assertWriterLock, singleNoticePerGroup } = {}) {
     return typeof assertWriterLock === 'function' &&
       this.#assertWriterLock === assertWriterLock &&

package/src/core/turnprogress.js

@@ -0,0 +1,135 @@
+'use strict'
+
+// 卡片进度:里程碑 · 「最近在做」· 脉搏文案(纯函数)。
+// 发行宿主(v2engine)与卡片收尾共用一份。只做展示,不参与任何收据或效果判定。
+// 卡片文案与旧引擎逐字一致,便于逐字对照。
+
+// 长任务的「活着」信号与「做到哪了」。⚠ 只在卡里滚动,不另发消息 —— 群里多一条就是一次刷屏。
+const T = {
+  // 迟迟没动静时先回一声:填进本来就要建的那张流式卡,答案到了原地替换 —— 不多发消息。
+  // 文案过零工具名,且不说「马上/很快」这类无法兑现的承诺。
+  ackWorking: '⏳ 已收到,正在处理…',
+  // 「最近动静」只在**停滞**时才有信息量 ⇒ 超过 cardPulseStaleMs(默认 2 分钟)没动静才追加。
+  // 还没调过任何工具时退回「处理中 · 已跑」。
+  pulse: (ran, doing, stale) => (doing && doing.length ? `⏳ 已跑 ${ran} · ${T.pulseDoing(doing)}` : `⏳ 处理中 · 已跑 ${ran}`) + (stale ? ` · 最近动静 ${stale}前` : ''),
+  // 由工具调用**确定性**推出(describeTool),模型一个字不说也有东西看。脉搏与 /status 共用。
+  // 只给文件名不给路径、不给命令内容 —— 群面零机器路径。
+  pulseDoing: (list) => `最近在做:${list.join(' · ')}`,
+}
+
+// 脉搏「已跑多久」:分钟粒度够用(卡片底部那行的耗时另算到秒)。
+function humanDur(ms) {
+  const s = Math.max(0, Math.round(ms / 1000))
+  if (s < 60) return `${s} 秒`
+  const m = Math.floor(s / 60)
+  if (m < 60) return `${m} 分钟`
+  const h = Math.floor(m / 60)
+  return m % 60 ? `${h} 小时 ${m % 60} 分钟` : `${h} 小时`
+}
+
+// ── 里程碑与「最近在做」─────────────────────────────────────────────────────
+// 模型每完成一个阶段输出一行 `>> …`,引擎认它 —— 跑的时候随打字机进卡(显示成 ▶),收尾收进卡片
+// 折叠区,不再被「只留最后一段」丢掉。判据收在这里,不散在三处(打字机 / 脉搏 / 收尾)。
+const MILESTONE_MAX = 12
+const MILESTONE_RE = /^>>\s*(.*\S)\s*$/
+// 逐行扫、跳过代码围栏 —— shell 的 `>> file` 与 Python 的 `>>>` 都可能出现在代码块里。
+function scanMilestoneLines(text, onLine) {
+  let fence = false
+  for (const line of String(text || '').split('\n')) {
+    if (/^\s*```/.test(line)) { fence = !fence; onLine(line, null); continue }
+    const m = fence ? null : MILESTONE_RE.exec(line)
+    onLine(line, m ? m[1] : null)
+  }
+}
+// 本轮全部里程碑(去重、封顶),从流式全量文本里取 —— 中途说的与收尾说的都算。
+function milestonesOf(text) {
+  const out = []
+  scanMilestoneLines(text, (_l, m) => { if (m && !out.includes(m) && out.length < MILESTONE_MAX) out.push(m) })
+  return out
+}
+// 打字机 / 脉搏用:`>> ` 原地换成 ▶(不换的话 markdown 会把 `>>` 渲染成嵌套引用)。
+function renderMilestones(text) {
+  const lines = []
+  scanMilestoneLines(text, (l, m) => lines.push(m == null ? l : '▶ ' + m))
+  return lines.join('\n')
+}
+// 收尾用:正文里的里程碑行剔掉(它们进折叠区),只剩答案。
+function stripMilestones(text) {
+  const lines = []
+  scanMilestoneLines(text, (l, m) => { if (m == null) lines.push(l) })
+  return lines.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+}
+// 「最近在做」:一次工具调用 → 一句人话。只给文件名不给路径(群面零机器路径);命令内容不给
+// (那是 agent 写的,可能带机器路径);插件按名字;认不出的返回 null,不拿框架里的工具名去凑数。
+// codex 的工具名经 codexcode 映射后与 claude 同形(Bash / Write / MCP)。
+const baseName = (p) => String(p || '').split(/[\\/]/).filter(Boolean).pop() || ''
+function describeTool(name, input = {}) {
+  const n = String(name || '')
+  const inp = input && typeof input === 'object' ? input : {}
+  const file = baseName(inp.file_path || inp.path || inp.notebook_path)
+  const withFile = (verb) => (file ? `${verb} ${file}` : `${verb}文件`)
+  const mcp = /^mcp__(.+?)__/.exec(n)
+  if (mcp) return `用插件 ${mcp[1]}`
+  switch (n) {
+    case 'Read': return withFile('看')
+    case 'Edit': case 'MultiEdit': case 'NotebookEdit': return withFile('改')
+    case 'Write': return withFile('写')
+    case 'Delete': return withFile('删')
+    case 'Bash': return '跑命令'
+    case 'Glob': case 'Grep': case 'FileSearch': return '搜代码'
+    case 'WebFetch': case 'WebSearch': return '查网页'
+    case 'Task': case 'Agent': return '派子任务'
+    case 'MCP': return `用插件${inp.server ? ' ' + baseName(inp.server) : ''}`
+    default: return null
+  }
+}
+// ── 确定性里程碑 ──────────────────────────────────────────────────────────────
+// 「最近在做」只滚最近 3 条,回答的是「还活着吗」;这里回答「做到哪了」:从工具调用里只认**交付类**
+// 动作(写 / 改文件 · 发到群 · 上画布 / 生图 / 预览 · git 提交推送 · 出 PDF),累积、去重、封顶,
+// 与模型自己的 `>> ` 行并排进卡、收尾同进折叠区。只给文件名不给路径,临时目录里的脚本不算
+// (那是它写给自己用的),命令内容不给 —— 群面零机器路径。一次 Bash 只记最重的一条。
+const TMP_PATH_RE = /^(?:\/private)?\/tmp\/|^\/var\/folders\/|^\$TMPDIR|^%TEMP%|\\Temp\\/i
+const unquote = (s) => String(s || '').trim().replace(/^(["'])(.*)\1$/, '$2')
+const SH_ARG = '("[^"]+"|\'[^\']+\'|[^\\s;|&<>]+)'
+function autoMilestone(name, input = {}) {
+  const n = String(name || '')
+  const inp = input && typeof input === 'object' ? input : {}
+  // 路径里带 shell 变量(`$OUT`)或命令替换 ⇒ 名字解不出来,只报动作不报名
+  const fileMs = (verb, raw) => { const p = unquote(raw); const f = baseName(p); return f && !TMP_PATH_RE.test(p) && !/[$`]/.test(p) ? `${verb} ${f}` : null }
+  const target = inp.file_path || inp.path || inp.notebook_path
+  switch (n) {
+    case 'Write': return fileMs('写了', target)
+    case 'Edit': case 'MultiEdit': case 'NotebookEdit': return fileMs('改了', target)
+    case 'Bash': break
+    default: return null
+  }
+  const cmd = String(inp.command || '')
+  const grab = (re) => { const m = re.exec(cmd); return m ? m[1] : '' }
+  let a
+  // 平台基础技能的命令名不写死(sbot feishu / sbot wecom …):里程碑只认动作名
+  if ((a = grab(new RegExp('\\bsbot\\s+[a-z]+\\s+send-file\\s+' + SH_ARG)))) return fileMs('已发文件', a) || '已发文件到群'
+  if ((a = grab(new RegExp('\\bsbot\\s+[a-z]+\\s+send-image\\s+' + SH_ARG)))) return fileMs('已发图片', a) || '已发图片到群'
+  if (/\bsbot\s+[a-z]+\s+send-notice\b/.test(cmd)) return '已发通知到群'
+  if (/\bsbot\s+[a-z]+\s+send-msg\b/.test(cmd)) return '已发消息到群'
+  if (/\bsbot\s+feishu\s+board-add-(?:image|diagram|nodes)\b/.test(cmd)) return '已上画布'
+  if (/\bsbot\s+imagen\s/.test(cmd) && /--out\b/.test(cmd)) return '已提交生图'
+  if (/\bsbot\s+preview\s+start\b/.test(cmd)) return '已开预览'
+  if (/\bgit\s+(?:-C\s+\S+\s+)?push\b/.test(cmd)) return '已推送远端'
+  if (/\bgit\s+(?:-C\s+\S+\s+)?commit\b/.test(cmd)) return '已提交代码'
+  if ((a = grab(new RegExp('--print-to-pdf=' + SH_ARG)))) return fileMs('已出 PDF', a) || '已出 PDF'
+  if (/--print-to-pdf\b/.test(cmd)) return '已出 PDF'
+  if ((a = grab(new RegExp('(?:^|[\\s;&|(])cat\\s*>{1,2}\\s*' + SH_ARG)))) return fileMs('写了', a)
+  return null
+}
+// 最多留 3 条、去重、最新在最后(脉搏与 /status 共用同一个列表)。
+function pushDoing(list, d) {
+  if (!d) return list
+  const i = list.indexOf(d)
+  if (i >= 0) list.splice(i, 1)
+  list.push(d)
+  while (list.length > 3) list.shift()
+  return list
+}
+
+module.exports = { T, humanDur, MILESTONE_MAX, milestonesOf, renderMilestones,
+  stripMilestones, describeTool, autoMilestone, pushDoing }

package/src/core/v2engine.js

@@ -15,6 +15,7 @@ const { createC2TurnProjection } = require('./c2turnprojection')
 const { prepareC2RunnerInput } = require('./c2runnerinput')
 const { continueC2Successor } = require('./c2successorbridge')
 const { rejectC2Input } = require('./c2inputrejection')
+const progress = require('./turnprogress')
 const NO_REPLY = 'NO_REPLY'
 const SYSTEM_APPENDIX = systemAppendix(NO_REPLY)
 const V2_NORMAL_ROUTE_MISSING = Object.freeze(['complete durable v2 authority'])
@@ -47,8 +48,10 @@ const T = {
     '/issue 一句话 记下问题反馈',
     steer ? '直接发文字就是派任务；任务进行中再发的消息会补充进当前任务。'
       : '直接发文字就是派任务；任务进行中再发的消息会排队，等这一轮结束再处理。'].join('\n'),
-  status: ({ model, project, state, queue, session }) => ['【本群状态】', `· 模型：${model}`,
-    `· 项目：${project}`, `· 状态：${state}`, `· 排队：${queue}`, `· 对话：${session}`].join('\n'),
+  status: ({ model, project, state, doing = [], queue, session }) => ['【本群状态】', `· 模型：${model}`,
+    `· 项目：${project}`, `· 状态：${state}`,
+    ...(doing.length ? [`· 最近在做：${doing.join(' · ')}`] : []),
+    `· 排队：${queue}`, `· 对话：${session}`].join('\n'),
   freshSession: '✅ 已开始新的一段对话，之前聊的内容不再带着',
   newBusy: '⚠ 手头还有任务在跑 —— 等它跑完，或先发 /stop 再发 /new',
   quotaShow: (name, value) => `${name} 额度：${value}`,
@@ -68,6 +71,7 @@ const T = {
   stopPending: '正在停止当前任务，这条消息没有处理，请稍后重发。',
   stopUnavailable: '当前任务正在收尾，暂时无法停止。',
   stoppedWithQueue: n => `已停止 — 连同排队的 ${n} 条一并取消`,
+  quotaFailure: 'Codex 订阅额度已用完，本次任务未完成。请恢复额度后重新发送；本次请求不会自动重试。',
   cardFooter: ({ ms, tokens }) => {
     const parts = [`耗时 ${Math.max(0, Math.round(ms / 1000))} 秒`]
     const tokenLabel = n => n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n)
@@ -351,11 +355,14 @@ async _durableV2Command(msg, cmd, rest) {
     if (cmd === '/status') {
       const rt = this.rts.get(msg.chatId)
       const queued = this.durableV2Runtime.snapshot().state?.lanes?.queue?.[msg.chatId]?.queue?.length || 0
-      const state = rt?.v2NormalRouteActive
-        ? `运行中（已跑 ${humanDuration(Date.now() - (rt.v2StartedAt || Date.now()))}）`
+      // "Running for long" is not "stuck": steps and the last activity tell them apart.
+      const busy = !!rt?.v2NormalRouteActive
+      const state = busy
+        ? `运行中（已跑 ${humanDuration(Date.now() - (rt.v2StartedAt || Date.now()))}${rt.v2Steps ? ` · 已执行 ${rt.v2Steps} 步` : ''}${rt.v2AliveAt ? ` · 最近动静 ${humanDuration(Date.now() - rt.v2AliveAt)}前` : ''}）`
         : rt?.v2AdmissionPending ? '消息已登记，等待并发名额' : '空闲'
       const project = String(group.workdir || '').split(/[\\/]/).filter(Boolean).pop() || '（未设）'
-      return reject('status', T.status({ model: label(name, provider), project, state, queue: queued,
+      return reject('status', T.status({ model: label(name, provider), project, state,
+        doing: busy && Array.isArray(rt.v2Doing) ? rt.v2Doing : [], queue: queued,
         session: this.store.getSession(msg.chatId) ? '进行中（记着上下文）' : '未开始' }))
     }
     if (cmd === '/new') {
@@ -1258,6 +1265,13 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
     const generation = randomBytes(16).toString('hex')
     rt.v2RunnerGeneration = generation
     rt.v2StartedAt = Date.now()
+    // Evidence that the turn is still moving, for /status and the card pulse;
+    // every turn starts from zero.
+    rt.v2Steps = 0
+    rt.v2AliveAt = 0
+    rt.v2Doing = []
+    rt.v2AutoMilestones = []
+    rt.v2CardQuotaFailure = false
     rt.v2CardBinding = null
     rt.v2StreamRequested = false
     rt.v2StreamQuiescing = false
@@ -1271,6 +1285,13 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
     let accepted = false
     let controller = null
     let capTimer = null
+    let ackTimer = null
+    let ackDue = false
+    let pulseTimer = null
+    const stopProgressTimers = () => {
+      if (ackTimer) { clearTimeout(ackTimer); ackTimer = null }
+      if (pulseTimer) { clearInterval(pulseTimer); pulseTimer = null }
+    }
     try {
       capability = authority.beginRunnerStart({ receiptId, chatId, turnToken,
         generation, verifyGeneration })
@@ -1346,19 +1367,28 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
       rt.v2RunnerNotStarted = false
       let streamChain = Promise.resolve()
       let streamFailure = null
-      const enqueueFrame = event => {
-        if (!this.durableV2StreamFrames || event.type !== 'assistant') return
-        if (!event.text || controller.signal.aborted || rt.v2CancelControl ||
-            rt.v2StreamQuiescing ||
-            authority.scopeState('stopIntent', chatId)) return
-        const buffer = projection.streamSnapshot().bufferText
-        const trimmed = buffer.trim()
-        if (!trimmed || NO_REPLY.startsWith(trimmed)) return
-        const text = buffer
+      // Card progress (same mechanism and wording as the legacy engine): deterministic
+      // milestones and "recently doing" from tool calls, an early "received" card
+      // and a pulse line. All of it is process-local card text; the card itself is
+      // still opened through the durable terminal path below.
+      const autoMs = []
+      rt.v2AutoMilestones = autoMs
+      const pushAuto = m => {
+        if (m && !autoMs.includes(m) && autoMs.length < progress.MILESTONE_MAX) autoMs.push(m)
+      }
+      const autoBlock = () => (autoMs.length ? autoMs.map(m => '▶ ' + m).join('\n') + '\n\n' : '')
+      const pulseFrom = Date.now()
+      let cardTouchedAt = 0
+      const progressClosed = () => rt.v2RunnerGeneration !== generation ||
+        rt.v2TerminalStarted || controller.signal.aborted || rt.v2CancelControl ||
+        rt.v2StreamQuiescing || !!authority.scopeState('stopIntent', chatId)
+      const enqueueCardText = text => {
         rt.v2StreamRequested = true
         streamChain = streamChain.then(async () => {
           if (rt.v2QueueNoticePromise) await rt.v2QueueNoticePromise
-          if (authority.blocked) throw new Error('C2 v2 stream authority closed')
+          // An earlier frame or pulse may still await its platform response;
+          // only a closed authority ends the stream.
+          if (authority.closed) throw new Error('C2 v2 stream authority closed')
           if (controller.signal.aborted || rt.v2CancelControl ||
               authority.scopeState('stopIntent', chatId)) return
           if (!rt.v2CardBinding) {
@@ -1368,8 +1398,10 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
               generation, verifyGeneration,
               applyLocalEffect: this.durableV2ApplyLocalEffect,
               assertWriterLock: this.durableV2AssertWriterLock,
-              redactText: value => redact(value,
-                { pii: job.group?.redactPii !== false }),
+              // An early card may end as the supported quota failure; its final
+              // text then uses the same fixed notice as an unopened card.
+              redactText: value => redact(rt.v2CardQuotaFailure === true
+                ? T.quotaFailure : value, { pii: job.group?.redactPii !== false }),
               sendPlainReply: typeof job.platform.replyOnce === 'function'
                 ? (target, value) => job.platform.replyOnce(target.replyCtx, value)
                 : null })
@@ -1385,6 +1417,82 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
           try { controller.abort() } catch {}
         })
       }
+      const enqueueFrame = event => {
+        if (event.type !== 'assistant') return
+        // /status and the pulse read these; a late event from an older
+        // generation must not write progress into this turn.
+        if (rt.v2RunnerGeneration === generation) {
+          rt.v2AliveAt = Date.now()
+          if (event.tools && event.tools.length) {
+            rt.v2Steps = (rt.v2Steps || 0) + event.tools.length
+            for (const tool of event.tools) {
+              progress.pushDoing(rt.v2Doing, progress.describeTool(tool.name, tool.input))
+              pushAuto(progress.autoMilestone(tool.name, tool.input))
+            }
+          }
+        }
+        if (!this.durableV2StreamFrames) return
+        if (!event.text || controller.signal.aborted || rt.v2CancelControl ||
+            rt.v2StreamQuiescing ||
+            authority.scopeState('stopIntent', chatId)) return
+        const buffer = projection.streamSnapshot().bufferText
+        const trimmed = buffer.trim()
+        if (!trimmed || NO_REPLY.startsWith(trimmed)) return
+        cardTouchedAt = Date.now()
+        enqueueCardText(autoBlock() + progress.renderMilestones(buffer))
+      }
+      const cardsVisible = this.durableV2StreamFrames && !receipt.quiet &&
+        typeof job.platform?.createStreamingCard === 'function'
+      // No visible output after ackDelayMs: open the card that would be opened
+      // anyway and fill it with "received"; the answer replaces it in place and
+      // a turn that ends silent recalls it at the terminal.
+      const ackMs = this.cfg.agent?.ackDelayMs == null ? 25_000 : Number(this.cfg.agent.ackDelayMs)
+      // No card before the runner is accepted. A runner accepted after the
+      // delay (Codex holds its events until its turn start returns) gets the
+      // card as soon as it is accepted.
+      const tryAck = () => {
+        if (!accepted) { ackDue = true; return }
+        if (progressClosed() || rt.v2CardBinding || rt.v2StreamRequested ||
+            projection.streamSnapshot().bufferText.trim()) return
+        cardTouchedAt = Date.now()
+        enqueueCardText(progress.T.ackWorking)
+      }
+      const armAck = delayMs => {
+        ackTimer = setTimeout(() => { ackTimer = null; tryAck() }, delayMs)
+        if (ackTimer.unref) ackTimer.unref()
+      }
+      if (cardsVisible && ackMs > 0) armAck(ackMs)
+      // Pulse: only rewrites the open card. Every PULSE_MS for the first
+      // PULSE_SLOW_AFTER_MS, then every PULSE_SLOW_MS; "recent activity" is only
+      // added after PULSE_STALE_MS without an assistant event.
+      const agentCfg = this.cfg.agent || {}
+      const PULSE_MS = agentCfg.cardPulseMs == null ? 15_000 : Number(agentCfg.cardPulseMs)
+      const PULSE_SLOW_MS = agentCfg.cardPulseSlowMs == null ? 60_000 : Number(agentCfg.cardPulseSlowMs)
+      const PULSE_SLOW_AFTER_MS = agentCfg.cardPulseSlowAfterMs == null ? 10 * 60 * 1000 : Number(agentCfg.cardPulseSlowAfterMs)
+      const PULSE_STALE_MS = agentCfg.cardPulseStaleMs == null ? 2 * 60 * 1000 : Number(agentCfg.cardPulseStaleMs)
+      if (cardsVisible && PULSE_MS > 0) {
+        const pulseEvery = () => (Date.now() - pulseFrom >= PULSE_SLOW_AFTER_MS
+          ? Math.max(PULSE_MS, PULSE_SLOW_MS) : PULSE_MS)
+        pulseTimer = setInterval(() => {
+          const binding = rt.v2CardBinding
+          if (progressClosed() || !binding?.opened || binding.generation !== generation) return
+          if (Date.now() - cardTouchedAt < pulseEvery()) return
+          cardTouchedAt = Date.now()
+          const sinceAlive = Date.now() - (rt.v2AliveAt || pulseFrom)
+          const stale = sinceAlive >= PULSE_STALE_MS ? progress.humanDur(sinceAlive) : ''
+          // Same gate as the stream frame: text that may still become NO_REPLY
+          // never reaches the card.
+          const buffer = projection.streamSnapshot().bufferText
+          const sofar = buffer.trim()
+          const body = autoBlock() + (sofar && !NO_REPLY.startsWith(sofar)
+            ? progress.renderMilestones(buffer) + '\n\n' : '')
+          try {
+            binding.path.update(body + progress.T.pulse(
+              progress.humanDur(Date.now() - pulseFrom), rt.v2Doing, stale))
+          } catch { /* a closed card never affects the turn */ }
+        }, PULSE_MS)
+        if (pulseTimer.unref) pulseTimer.unref()
+      }
       const maxMins = Number(this.cfg.agent.maxTurnTimeMins) || 0
       const timeoutMs = maxMins > 0 ? maxMins * 60_000 : 0
       const timeoutDeadlineAt = timeoutMs > 0 ? Date.now() + timeoutMs : null
@@ -1416,6 +1524,7 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
         onTurnAccepted: value => {
           const ack = capability.onTurnAccepted(value)
           accepted = true
+          if (ackDue) { ackDue = false; armAck(0) }
           return ack
         },
         onSpawnFailed: value => capability.onSpawnFailed(value),
@@ -1440,6 +1549,7 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
       let result
       try {
         result = await running
+        stopProgressTimers()
         rt.v2SteerClosing = true
         rt.v2SteerControl = null
         if (rt.v2SteerDrain) await rt.v2SteerDrain
@@ -1462,6 +1572,7 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
       }
       finally {
         if (capTimer) clearTimeout(capTimer)
+        stopProgressTimers()
         if (rt.v2Controller === controller) rt.v2Controller = null
       }
       if (authority.blocked && rt.v2RunnerStopVerified !== true) {
@@ -1512,6 +1623,7 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
       return { effectId, accepted: true, outputHeld: true }
     } catch (error) {
       if (capTimer) clearTimeout(capTimer)
+      stopProgressTimers()
       if (controller && rt.v2Controller === controller) rt.v2Controller = null
       const proofId = `sbot-c2-runner-not-started-v1:${receiptId}:${generation}`
       const eventId = `sbot-c2-runner-not-started-commit-v1:${receiptId}:${turnToken}:${generation}`
@@ -1620,7 +1732,7 @@ async completeDurableV2CardTurn({ chatId, receiptId, turnToken, effectId,
         verifyGeneration, applyLocalEffect: this.durableV2ApplyLocalEffect,
         assertWriterLock: this.durableV2AssertWriterLock,
         redactText: text => redact(quotaFailure
-          ? 'Codex 订阅额度已用完，本次任务未完成。请恢复额度后重新发送；本次请求不会自动重试。'
+          ? T.quotaFailure
           : text, { pii: job.group?.redactPii !== false }),
         sendPlainReply: typeof job.platform.replyOnce === 'function'
           ? (target, text) => job.platform.replyOnce(target.replyCtx, text)
@@ -1631,7 +1743,15 @@ async completeDurableV2CardTurn({ chatId, receiptId, turnToken, effectId,
       for (const text of updates) path.update(text)
       const footer = T.cardFooter({ ms: Math.max(0, Date.now() - rt.v2StartedAt),
         tokens: rt.v2UsageDecision?.tokens || null })
-      const completed = await path.complete({ payload, replyText, paused, footer })
+      // Milestones from tool calls first, then the model's own `>> ` lines;
+      // the card shows them in its "process" fold (display only).
+      rt.v2CardQuotaFailure = !!quotaFailure
+      const redactMilestone = value => redact(value, { pii: job.group?.redactPii !== false })
+      const milestones = [...(rt.v2AutoMilestones || []),
+        ...progress.milestonesOf(payload.bufferText)]
+        .filter((m, i, a) => a.indexOf(m) === i).map(redactMilestone)
+        .filter(m => typeof m === 'string' && m.trim())
+      const completed = await path.complete({ payload, replyText, paused, footer, milestones })
       const after = authority.snapshot()
       const queue = after.state?.lanes?.queue?.[chatId]?.queue
       let successor = null
@@ -1668,6 +1788,8 @@ async completeDurableV2CardTurn({ chatId, receiptId, turnToken, effectId,
       rt.v2TerminalProjection = null
       rt.v2UsageDecision = null
       rt.v2StartedAt = null
+      rt.v2AutoMilestones = []
+      rt.v2CardQuotaFailure = false
       rt.v2CardBinding = null
       rt.v2StreamRequested = false
       rt.v2TimeoutProof = null

package/src/ui/console.html

@@ -743,6 +743,32 @@ h2.sec{font-family:var(--sans);font-size:14px;letter-spacing:.2px;color:var(--in
 .modal-bg.show{display:flex}
 .modal{width:min(520px,92vw);background:var(--modal-bg);border:1px solid var(--line-hi);border-radius:16px;padding:26px;max-height:82vh;overflow:auto}
 .modal h3{font-family:var(--sans);font-size:15px;font-weight:600;margin:0 0 18px;letter-spacing:.4px}
+/* ── 控制台升级:确认 + 进度弹窗 ── 每一步的状态只从升级任务记录推出来,重载、断线重连后画出同一张 */
+.modal.upg h3{display:flex;align-items:center;gap:10px;margin-bottom:6px}
+.upg-sub{font-size:12px;color:var(--dim);margin:0 0 16px;display:flex;gap:10px;flex-wrap:wrap}
+.upg-bar{height:4px;border-radius:4px;background:var(--line);overflow:hidden;margin:0 0 14px;position:relative}
+.upg-bar>i{position:absolute;inset:0 auto 0 0;border-radius:4px;background:var(--ember);transition:width .5s var(--ease,ease)}
+.upg-bar.run>i::after{content:"";position:absolute;inset:0;background:linear-gradient(90deg,transparent,rgba(255,255,255,.45),transparent);animation:upg-sheen 1.3s linear infinite}
+.upg-bar.ok>i{background:var(--ok)}.upg-bar.fail>i{background:var(--fail)}
+@keyframes upg-sheen{from{transform:translateX(-100%)}to{transform:translateX(100%)}}
+.upg-steps{list-style:none;margin:0 0 12px;padding:0;display:grid;gap:2px}
+.upg-steps li{display:flex;align-items:center;gap:10px;padding:7px 10px;border-radius:9px;font-size:13px;color:var(--faint)}
+.upg-steps li.done{color:var(--ink)}
+.upg-steps li.active{color:var(--ink);background:rgba(var(--ember-rgb),.08);font-weight:600}
+.upg-steps li.fail{color:var(--fail);background:rgba(var(--fail-rgb),.08);font-weight:600}
+.upg-steps .dot{width:16px;height:16px;flex:none;display:inline-flex;align-items:center;justify-content:center;border-radius:50%;
+  border:1.5px solid var(--line-hi);font-size:10px;line-height:1;box-sizing:border-box}
+.upg-steps li.done .dot{border-color:var(--ok);background:var(--ok);color:var(--modal-bg)}
+.upg-steps li.fail .dot{border-color:var(--fail);background:var(--fail);color:var(--modal-bg)}
+.upg-steps li.active .dot{border-color:transparent}
+.upg-steps li.active .dot .spin{width:12px;height:12px}
+.upg-mark{width:22px;height:22px;flex:none;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;font-size:12px;color:var(--modal-bg)}
+.upg-mark.ok{background:var(--ok)}.upg-mark.fail{background:var(--fail)}
+.upg-note{font-size:12.5px;line-height:1.6;color:var(--dim);padding:10px 12px;border-radius:10px;background:var(--inset-bg);margin:0 0 16px}
+.upg-note.warn{color:var(--warn)}.upg-note.fail{color:var(--fail)}
+.upg-btns{display:flex;justify-content:flex-end;gap:8px;flex-wrap:wrap}
+.mark .ver-update.upgrading .update-dot{width:8px;height:8px;background:transparent;box-shadow:none;border:1.5px solid var(--spin-track);
+  border-top-color:var(--ember);animation:sp .8s linear infinite}
 /* ── 新建/编辑自定义风格(左表单 · 右实时预览)────────────────────────────────
    预览必须**一直在视野里** —— 这张表单的每一项都对应预览图的一条通道,改哪儿图上立刻变哪儿
    才是它区别于「填一份 YAML」的全部价值;所以右列 sticky,滚表单时图不走。 */
@@ -3370,7 +3396,8 @@ function openSay(chatId){
     }catch(e){ toast(e.message,'err'); go.disabled=false; const t2=$('#sayGoTxt'); if(t2) t2.textContent=old }
   };
 }
-function closeModal(){clearTimeout(nsTimer);nsTimer=null;nsSeq++;sayRefresh=null;$('#modalBg').classList.remove('show');$('#modal').className='modal';}
+function closeModal(){clearTimeout(nsTimer);nsTimer=null;nsSeq++;sayRefresh=null;$('#modalBg').classList.remove('show');$('#modal').className='modal';
+  try{upgOnClose();}catch{}} // 升级弹窗:升级照常进行,只收起
 $('#modalBg').onclick=e=>{if(e.target.id==='modalBg')closeModal();};
 
 /* ── playground ── */
@@ -3494,7 +3521,7 @@ function renderSettings(){
     :updMode==='foreground'?'前台运行不能在控制台升级：在运行 SintBot 的终端按 Ctrl-C 等待退出，重新运行一行安装命令 curl -fsSL https://sintbot.com/install.sh | bash，再用原来的启动命令启动。'
     :updMode==='dev'?'开发版不在控制台升级，请用部署脚本。':'只安装检测到的稳定版本;所有群任务与队列清空后才会安装。需要可写的全局安装目录,不会提权;后台服务会自动重启,前台运行需手动重启。';
   const updateCard=`<div class="card" style="grid-column:1/-1" id="updateCard"><div class="lbl">软件更新</div>
-    <div id="updateStatus" class="hint" style="margin:0 0 12px;color:var(--ink)">${updateText}</div>
+    <div id="updateStatus" class="hint" style="margin:0 0 12px;color:var(--ink);display:flex;align-items:center;gap:8px">${updMode==='managed'&&updateBusy?'<span class="spin"></span>':''}<span>${updateText}</span></div>
     ${upd&&upd.available?`<div class="hint" style="margin:-4px 0 12px">版本差异与发布说明：<a href="https://github.com/sintlab/sintbot/releases/tag/v${encodeURIComponent(upd.latestVersion)}" target="_blank" rel="noopener" style="color:var(--ember-soft)">查看 v${esc(upd.latestVersion)} 发布说明</a></div>`:''}
     <div class="inline" style="gap:14px;flex-wrap:wrap;margin-bottom:12px">
       <span class="dim">自动检查稳定版(启动时及每天)</span>
@@ -3503,6 +3530,8 @@ function renderSettings(){
     <div class="inline" style="gap:8px;flex-wrap:wrap">
       <button class="btn" id="updCheck" ${!upd?'disabled':''}>检查新版</button>
       ${updCanInstall?`<button class="btn primary" id="updInstall" ${!upd||!upd.available||updateBusy?'disabled':''}>现在升级</button>`:''}
+      ${updMode==='managed'&&updateJob&&(updateBusy||['failed','rolled-back'].includes(updateJob.state)||upgWatchId()===updateJob.id)
+        ?`<button class="btn" id="updProgress">${updateBusy?'查看进度':'查看上次升级'}</button>`:''}
       <button class="btn" id="updIgnore" ${!upd||!upd.available?'disabled':''}>忽略此版本</button>
     </div>
     <div class="hint" style="margin-top:10px">${updHint}</div>
@@ -3557,8 +3586,11 @@ function renderSettings(){
   $('#updCheck').onclick=async()=>{const b=$('#updCheck');b.disabled=true;b.textContent='检查中…';
     try{await api('/api/update/check','POST',{});S=await api('/api/state');await refreshInbox();renderSettings();renderOverview();toast('版本检查完成','ok');}
     catch(e){toast(e.message,'err');b.disabled=false;b.textContent='检查新版';}};
+  if($('#updProgress'))$('#updProgress').onclick=()=>upgOpen(true);
   if($('#updInstall'))$('#updInstall').onclick=async()=>{const u=S.update||{},version=u.latestVersion;if(!version)return;
     const announce=$('#updAnnounce')?$('#updAnnounce').checked:false;
+    // 后台托管:页内确认 → 进度弹窗(每一步、断线重连、完成后刷新到新版控制台)。前台 / 旧式更新器仍走下面的原生确认
+    if(u.mode==='managed'){upgConfirm(announce);return;}
     const what=u.mode==='managed'?'等所有群空闲、记录结清后装到单独的目录，再切换后台服务；切换期间约一分钟不处理新消息，新版本没连上全部群会自动换回。':`${announce?'安装完成后会向未暂停的群播报；':'本次不向群播报。'}所有群任务结束后才开始安装，后台服务会重启。`;
     if(!confirm(`将从 v${u.currentVersion} 升级到 v${version}。${what}继续?`))return;
     const b=$('#updInstall');b.disabled=true;
@@ -3927,9 +3959,209 @@ document.addEventListener('click',(e)=>{const b=e.target.closest&&e.target.close
 function renderAll(){renderOverview();renderProviders();renderGroups();renderPlayground();renderSettings();updateDaemon();updateTopFxApp();applyRuntimeCapabilities();}
 function updateTopUpdateBadge(){
   const badge=$('#topUpdateBadge');if(!badge)return;
-  badge.hidden=!(S&&S.update&&S.update.available);
+  const busy=upgManaged()&&upgIsActive(upgJob());
+  badge.hidden=!(S&&S.update&&(S.update.available||busy));
+  badge.classList.toggle('upgrading',busy);
+  const tip=busy?'正在升级，查看进度':'发现新版本，打开软件更新';
+  if(badge.title!==tip){badge.title=tip;badge.setAttribute('aria-label',tip);}
+  upgEnsureWatch();
 }
+
+/* UPGRADE_PROGRESS_BEGIN ── 控制台升级的进度弹窗 ──────────────────────────────────────────
+   点「现在升级」→ 页内确认 → 进度弹窗。升级期间每 1.5 秒读一次 GET /api/update;服务切换那几秒
+   连不上(或反代回 502)就显示「服务正在重启，页面会自动重连」,不当成错误;重启后旧令牌作废(环回
+   免密模式)则交给 checkStaleAuth 整页重载。新版本连上全部群、任务记为 done 后,这一页还是旧版前端
+   ⇒ 倒数 3 秒整页刷新,刷新后按 sessionStorage 记下的任务 id 再把结果弹出来一次。
+   每一步的状态只从任务记录(state / prefix / installed / steps)推出来,不靠页面记忆。 */
+const UPG_PHASES=[
+  ['wait','等待所有群空闲'],
+  ['install','下载并安装新版本'],
+  ['stop','停止旧服务'],
+  ['backup','核对群记录并备份数据'],
+  ['preflight','新版本预检'],
+  ['start','切换并启动新版本'],
+  ['connect','等待全部群连上'],
+];
+function upgIsActive(j){return !!(j&&['queued','installing','switching'].includes(j.state));}
+function upgVer(v){return String(v||'').trim().replace(/^v/i,'');}
+function upgStep(j,name){const s=((j&&j.steps)||[]).find(x=>x&&x.step===name);return s?(s.ok?'ok':'bad'):'';}
+// → [{key,label,state:'done'|'active'|'fail'|'todo'}]:最后一个已到达的步骤之前全算完成,下一步是
+//   进行中(任务还在跑)或失败(任务已失败 / 已换回);换回旧版本时多一行「换回 vX」。
+function upgPhases(j){
+  if(!j)return [];
+  const st=j.state, ok=n=>upgStep(j,n)==='ok';
+  const reached={
+    wait:!!(j.prefix||j.installed)||st==='installing'||st==='switching',
+    install:!!j.installed,
+    stop:ok('stop service'),
+    backup:ok('journals unchanged')&&ok('data backed up'),
+    preflight:ok('new version preflight'),
+    start:ok('service entry replaced')&&ok('start new version'),
+    connect:st==='done',
+  };
+  let last=-1;UPG_PHASES.forEach(([k],i)=>{if(reached[k])last=i;});
+  if(st==='done')last=UPG_PHASES.length-1;
+  const active=upgIsActive(j), failed=st==='failed'||st==='rolled-back';
+  const out=UPG_PHASES.map(([key,label],i)=>({key,label,
+    state:i<=last?'done':i===last+1?(active?'active':failed?'fail':'todo'):'todo'}));
+  if(upgStep(j,'rollback')){
+    const back=upgStep(j,'previous version started');
+    out.push({key:'rollback',label:`换回 v${upgVer(j.from)}`,state:back==='ok'||st==='rolled-back'?'done':back==='bad'||st==='failed'?'fail':'active'});
+  }
+  return out;
+}
+// 连不上时是不是在切换:已进入安装 / 已装好 / 已在切换(排队等空闲时服务不会自己重启)
+function upgRestarting(j){return !!(j&&(j.state==='switching'||j.state==='installing'||j.installed));}
+function upgDur(ms){const s=Math.max(0,Math.round(ms/1000));return s<60?`${s} 秒`:`${Math.floor(s/60)} 分 ${String(s%60).padStart(2,'0')} 秒`;}
+/* UPGRADE_PROGRESS_LOGIC_END */
+const upg={timer:0,tick:0,polling:false,open:false,view:'',offlineSince:0,waiting:[],reloadAt:0,toasted:''};
+const UPG_PAGE_VERSION=upgVer((document.querySelector('.mark .ver')||{}).textContent);
+function upgWatchId(){try{return sessionStorage.getItem('sbot-upgrade-watch')||'';}catch{return '';}}
+function upgSetWatch(id){try{if(id)sessionStorage.setItem('sbot-upgrade-watch',id);else sessionStorage.removeItem('sbot-upgrade-watch');}catch{}}
+// 「在后台继续」收起的任务 id:服务重启后页面会整页重载(环回免密模式换令牌),收起的弹窗不能因此又弹出来
+function upgHiddenId(){try{return sessionStorage.getItem('sbot-upgrade-hidden')||'';}catch{return '';}}
+function upgSetHidden(id){try{if(id)sessionStorage.setItem('sbot-upgrade-hidden',id);else sessionStorage.removeItem('sbot-upgrade-hidden');}catch{}}
+function upgJob(){return (S&&S.update&&S.update.job)||null;}
+function upgManaged(){return !!(S&&S.update&&S.update.mode==='managed');}
+function upgModalShown(){return !!(upg.open&&upg.view==='progress'&&$('#modalBg').classList.contains('show')&&$('#modal').classList.contains('upg'));}
+function upgSchedule(ms=1500){clearTimeout(upg.timer);upg.timer=setTimeout(upgPoll,ms);}
+// 由 updateTopUpdateBadge 在每次状态更新时调用:任务在跑就保证轮询在走;这一页发起(或看过)的任务
+// 刚结束、页面刚刷新过来 ⇒ 把结果弹出来一次。
+function upgEnsureWatch(){
+  if(!upgManaged())return;
+  const j=upgJob();if(!j)return;
+  if(upgIsActive(j)&&!upg.timer&&!upg.polling)upgSchedule(1500);
+  if(upg.open||upgWatchId()!==j.id||$('#modalBg').classList.contains('show'))return;
+  if(upgHiddenId()!==j.id)upgOpen(false);
+  else if(!upgIsActive(j))upgNotifyDone(j);   // 收起过:结束时只发一条提示
+}
+function upgNotifyDone(j){
+  if(!j||upg.toasted===j.id)return;
+  upg.toasted=j.id;upgSetWatch('');upgSetHidden('');
+  toast(j.message||(j.state==='done'?`已升级到 v${upgVer(j.to)}`:'升级没有完成'),j.state==='done'?'ok':'err');
+}
+async function upgPoll(){
+  upg.timer=0;if(upg.polling)return;upg.polling=true;
+  let r=null,data=null;
+  try{
+    try{r=await fetch('/api/update',{headers:{'X-Sbot-Token':TOKEN},cache:'no-store'});}catch{}
+    if(r&&r.status===401){upgRender();checkStaleAuth();return;}  // 重启后令牌作废:整页重载或落到登录框
+    if(r&&r.ok){try{data=await r.json();}catch{}}
+    if(!data||!data.currentVersion){                            // 断线 / 反代 502 / 服务重启中
+      if(!upg.offlineSince)upg.offlineSince=Date.now();
+      upgRender();upgSchedule(2000);return;
+    }
+    const wasOffline=!!upg.offlineSince;upg.offlineSince=0;
+    upg.waiting=Array.isArray(data.waitingGroups)?data.waitingGroups:[];
+    const {waitingGroups,...update}=data;
+    S.update={...(S.update||{}),...update};
+    const j=update.job;
+    if(upgIsActive(j)){upgRender();updateTopUpdateBadge();upgSchedule(1500);return;}
+    upgFinished(j,update,wasOffline);
+  }finally{upg.polling=false;}
+}
+// 任务结束(done / failed / rolled-back):这一页是旧版前端就倒数刷新;弹窗被收起了就只发一条提示。
+async function upgFinished(j,update,wasOffline){
+  const mine=!!(j&&upgWatchId()===j.id);
+  const stale=!!(j&&j.state==='done'&&UPG_PAGE_VERSION&&upgVer(update.currentVersion)!==UPG_PAGE_VERSION);
+  if(j&&mine&&stale&&upgModalShown()&&!upg.reloadAt){
+    upg.reloadAt=Date.now()+3000;upgRender();updateTopUpdateBadge();setTimeout(()=>location.reload(),3000);return;
+  }
+  if(j&&mine&&!upgModalShown())upgNotifyDone(j);
+  upgRender();
+  try{S=await api('/api/state');}catch{}
+  updateTopUpdateBadge();
+  if(!busyInteracting()){renderSettings();renderOverview();}
+  else if(wasOffline&&!upgModalShown())renderOverview();
+}
+function upgConfirm(announce){
+  const u=S.update||{};
+  $('#modal').className='modal upg';
+  $('#modal').innerHTML=`<h3>升级到 v${esc(upgVer(u.latestVersion))}</h3>
+    <div class="upg-sub"><span class="mono">v${esc(upgVer(u.currentVersion))} → v${esc(upgVer(u.latestVersion))}</span></div>
+    <div class="upg-note">等所有群空闲、记录结清后装到单独的目录，再切换后台服务；切换期间约一分钟不处理新消息，新版本没连上全部群会自动换回。</div>
+    <div class="hint" style="margin:-6px 0 18px">开始后这里会显示每一步的进度；服务重启时页面会自动重连。</div>
+    <div class="upg-btns"><button class="btn" id="upgCancel">取消</button><button class="btn primary" id="upgGo">开始升级</button></div>`;
+  upg.open=true;upg.view='confirm';
+  $('#modalBg').classList.add('show');
+  $('#upgCancel').onclick=()=>closeModal();
+  $('#upgGo').onclick=async()=>{
+    const b=$('#upgGo');b.disabled=true;b.innerHTML='<span class="spin"></span> 正在提交…';
+    try{
+      const r=await api('/api/update/start','POST',{version:u.latestVersion,announce:!!announce});
+      S.update={...(S.update||{}),...r};
+      upgSetWatch(r.job&&r.job.id);upg.reloadAt=0;
+      upgOpen(true);updateTopUpdateBadge();upgSchedule(600);
+    }catch(e){
+      if(e.payload&&e.payload.update)S.update={...(S.update||{}),...e.payload.update};
+      toast(e.message,'err');b.disabled=false;b.textContent='开始升级';
+    }
+  };
+}
+// 打开进度 / 结果弹窗。user=true:用户点的(「查看进度」、顶栏图标、刚确认),记下任务 id 以便刷新后接着看。
+function upgOpen(user){
+  const j=upgJob();if(!j)return;
+  if(user){upgSetWatch(j.id);upgSetHidden('');}
+  $('#modal').className='modal upg';
+  upg.open=true;upg.view='progress';
+  $('#modalBg').classList.add('show');
+  upgRender();
+  clearInterval(upg.tick);upg.tick=setInterval(()=>{if(!upgModalShown()){clearInterval(upg.tick);upg.tick=0;return;}upgRender();},1000);
+  if(upgIsActive(j)&&!upg.timer&&!upg.polling)upgSchedule(300);
+}
+// 弹窗被关掉(按钮、点遮罩、别的弹窗):升级照常进行,顶栏图标保持转圈,结束时只发提示
+function upgOnClose(){
+  if(!upg.open)return;
+  const wasProgress=upg.view==='progress';
+  upg.open=false;upg.view='';clearInterval(upg.tick);upg.tick=0;
+  const j=upgJob();
+  if(wasProgress&&upgIsActive(j))upgSetHidden(j.id);
+  else if(wasProgress&&j&&upgWatchId()===j.id){upgSetWatch('');upgSetHidden('');}
+  // 结果看完了:设置页那张卡在弹窗开着时没重画,这里补一次
+  if(wasProgress&&!upgIsActive(j))setTimeout(()=>{if(!busyInteracting()){renderSettings();renderOverview();}},0);
+}
+function upgRender(){
+  const j=upgJob(), statusBox=$('#updateStatus');
+  if(statusBox&&j&&upgManaged()&&upgIsActive(j)){
+    const text=upg.offlineSince?(upgRestarting(j)?'服务正在重启，页面会自动重连…':'暂时连不上服务，正在重试…')
+      :j.state==='switching'&&upgStep(j,'start new version')==='ok'?'新版本已启动，正在等全部群连上…':(j.message||j.state);
+    statusBox.innerHTML=`<span class="spin"></span><span>${esc(text)}</span>`;
+  }
+  if(!upgModalShown()||!j)return;
+  // 安装一结束,切换进程不到一秒就停掉旧服务:页面最后看到的多半还是「安装中」。这时连不上 = 正在切换
+  const view=upg.offlineSince&&upgRestarting(j)&&j.state!=='switching'?{...j,state:'switching',installed:true}:j;
+  const active=upgIsActive(view), st=view.state, phases=upgPhases(view);
+  const end=active?Date.now():(+j.finishedAt||+j.updatedAt||Date.now());
+  const took=upgDur(end-(+j.createdAt||end));
+  const doneN=phases.filter(p=>p.key!=='rollback'&&p.state==='done').length;
+  const pct=st==='done'?100:Math.max(4,Math.round(doneN/UPG_PHASES.length*100));
+  const to=esc(upgVer(j.to)), from=esc(upgVer(j.from));
+  const head=st==='done'?`<span class="upg-mark ok">✓</span><span>已升级到 v${to}</span>`
+    :active?`<span class="spin"></span><span>正在升级到 v${to}</span>`
+    :`<span class="upg-mark fail">!</span><span>升级没有完成</span>`;
+  let note,noteCls='';
+  if(active&&upg.offlineSince){note=st==='switching'?'服务正在重启，页面会自动重连…':'暂时连不上服务，正在重试…';noteCls='warn';}
+  else if(st==='switching'&&upgStep(view,'start new version')==='ok'){note='新版本已启动，正在等全部群连上…';}
+  else if(st==='queued'&&upg.waiting.length){note=`还在运行的群：${upg.waiting.map(g=>g.name).join('、')}`;}
+  else if(st==='done'&&upg.reloadAt){note=`页面将在 ${Math.max(0,Math.ceil((upg.reloadAt-Date.now())/1000))} 秒后刷新，载入新版控制台`;}
+  else{note=j.message||st;if(!active&&st!=='done')noteCls='fail';}
+  const icon=p=>p.state==='done'?'✓':p.state==='fail'?'!':p.state==='active'?'<span class="spin"></span>':'';
+  const btns=active?`<button class="btn" id="upgHide">在后台继续</button>`
+    :st==='done'&&upg.reloadAt?`<button class="btn primary" id="upgReload">现在刷新</button>`
+    :`<button class="btn${st==='done'?' primary':''}" id="upgDone">${st==='done'?'完成':'关闭'}</button>`;
+  $('#modal').innerHTML=`<h3>${head}</h3>
+    <div class="upg-sub"><span class="mono">v${from} → v${to}</span><span>${active?`已用 ${took}`:`用时 ${took}`}</span></div>
+    <div class="upg-bar ${active?'run':st==='done'?'ok':'fail'}"><i style="width:${pct}%"></i></div>
+    <ol class="upg-steps">${phases.map(p=>`<li class="${p.state}"><span class="dot">${icon(p)}</span><span>${esc(p.label)}</span></li>`).join('')}</ol>
+    <div class="upg-note ${noteCls}">${esc(note)}</div>
+    <div class="upg-btns">${btns}</div>`;
+  const hide=$('#upgHide');if(hide)hide.onclick=()=>closeModal();
+  const done=$('#upgDone');if(done)done.onclick=()=>closeModal();
+  const rl=$('#upgReload');if(rl)rl.onclick=()=>location.reload();
+}
+/* UPGRADE_PROGRESS_END */
 (()=>{const badge=$('#topUpdateBadge');if(!badge)return;badge.onclick=()=>{
+  if(upgManaged()&&upgIsActive(upgJob())){upgOpen(true);return;}
   const nav=$('nav [data-tab="settings"]');if(nav)nav.click();
   const card=$('#updateCard');if(!card)return;
   requestAnimationFrame(()=>{card.scrollIntoView({behavior:'smooth',block:'start'});
@@ -4777,6 +5009,27 @@ const I18N_EN=[
   ["只安装检测到的稳定版本：等所有群空闲、记录结清后装到单独的目录，再切换后台服务；新版本没在 90 秒内连上全部群会自动换回。旧版本保留用于回滚，不提权，不在群里播报。","Installs only the detected stable version: once every group is idle and settled, it goes into its own folder and the background service switches to it; if the new version does not connect every group within 90 seconds, the previous one is restored. The previous version is kept for rollback. No elevated privileges and no group announcements."],
   ["前台运行不能在控制台升级：在运行 SintBot 的终端按 Ctrl-C 等待退出，重新运行一行安装命令 curl -fsSL https://sintbot.com/install.sh | bash，再用原来的启动命令启动。","A foreground run cannot upgrade from the console: press Ctrl-C in the terminal running SintBot and wait for it to exit, rerun the one-line installer curl -fsSL https://sintbot.com/install.sh | bash, then start with your usual command."],
   ["开发版不在控制台升级，请用部署脚本。","Development builds are not upgraded from the console; use the deployment scripts."],
+  ["查看进度","View progress"],
+  ["查看上次升级","View last upgrade"],
+  ["正在升级，查看进度","Upgrading; view progress"],
+  ["等所有群空闲、记录结清后装到单独的目录，再切换后台服务；切换期间约一分钟不处理新消息，新版本没连上全部群会自动换回。","Once every group is idle and settled, it installs into its own folder and switches the background service; new messages wait about a minute during the switch, and the previous version is restored if the new one does not connect every group."],
+  ["开始后这里会显示每一步的进度；服务重启时页面会自动重连。","Once started, this window shows each step; the page reconnects by itself while the service restarts."],
+  ["开始升级","Start upgrade"],
+  ["正在提交…","Submitting…"],
+  ["等待所有群空闲","Waiting for every group to be idle"],
+  ["下载并安装新版本","Download and install the new version"],
+  ["停止旧服务","Stop the current service"],
+  ["核对群记录并备份数据","Check group records and back up data"],
+  ["新版本预检","Preflight the new version"],
+  ["切换并启动新版本","Switch to and start the new version"],
+  ["等待全部群连上","Wait for every group to connect"],
+  ["升级没有完成","The upgrade did not complete"],
+  ["服务正在重启，页面会自动重连…","The service is restarting; this page reconnects by itself…"],
+  ["暂时连不上服务，正在重试…","Cannot reach the service right now; retrying…"],
+  ["新版本已启动，正在等全部群连上…","The new version has started; waiting for every group to connect…"],
+  ["在后台继续","Continue in background"],
+  ["现在刷新","Reload now"],
+  ["关闭","Close"],
   ["访问地址正在切换;页面即将重载","Changing the access address; this page will reload"],
   ["访问设置已保存","Access settings saved"],
   ["开启局域网访问前要设置至少 6 位访问密码","Set an access password of at least 6 characters before enabling LAN access"],
@@ -5404,6 +5657,15 @@ const I18N_EN_RX=[
   [/^v([\d.]+) 已安装，等所有群空闲后切换$/,"v$1 is installed; switching when every group is idle"],
   [/^正在切换到 v([\d.]+)；期间的消息会提示稍后重发$/,"Switching to v$1; messages meanwhile are asked to be resent later"],
   [/^已升级到 v([\d.]+)$/,"Upgraded to v$1"],
+  [/^升级到 v([\d.]+)$/,"Upgrade to v$1"],
+  [/^正在升级到 v([\d.]+)$/,"Upgrading to v$1"],
+  [/^换回 v([\d.]+)$/,"Restore v$1"],
+  [/^已用 (\d+) 秒$/,"Elapsed $1 s"],
+  [/^已用 (\d+) 分 (\d+) 秒$/,"Elapsed $1 min $2 s"],
+  [/^用时 (\d+) 秒$/,"Took $1 s"],
+  [/^用时 (\d+) 分 (\d+) 秒$/,"Took $1 min $2 s"],
+  [/^还在运行的群：([\s\S]+)$/,"Groups still working: $1"],
+  [/^页面将在 (\d+) 秒后刷新，载入新版控制台$/,"Reloading in $1 s to load the new console"],
   [/^没有切换到 v([\d.]+)：([\s\S]*)；已换回 v([\d.]+)$/,"Did not switch to v$1 ($2); v$3 was restored"],
   [/^等待群空闲超时；可在空闲后重新发起$/,"Timed out waiting for idle groups; retry when they are idle"],
   [/^有暂停的群，升级已取消；先处理暂停的群$/,"A group is paused, so the upgrade was cancelled; handle the paused group first"],

package/src/ui/serverbase.js

@@ -344,6 +344,15 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
   } catch { /* 回填是锦上添花,读不了就空着 */ }
   const inboxDismiss = dashboard.createDismissStore({ file: inboxDismissPath || path.join(os.homedir(), '.sbot', 'inbox-dismissed.json'), log })
   let lastHealth = null // 最近一次 buildState 的健康检查,给只算收件箱的 /api/inbox 用(那里不重跑探针)
+  // 升级排队时还有任务、排队、未结或暂停的群(只给名字,升级弹窗据此说明在等谁)
+  const upgradeWaitingGroups = () => {
+    let live = null, groupsRaw = {}
+    try { live = getLiveState ? getLiveState() : null } catch { return [] }
+    try { groupsRaw = readRaw().groups || {} } catch {}
+    return Object.entries((live && live.groups) || {})
+      .filter(([, g]) => g && (g.busy || g.finalizing || g.waitingForCapacity || g.queue > 0 || g.pending > 0 || g.held))
+      .map(([chatId, g]) => ({ name: (groupsRaw[chatId] && groupsRaw[chatId].name) || chatId.slice(-8), held: !!g.held }))
+  }
   // 「需要你处理」:从 state 各区取数(反馈本 / 预览 / 残留进程 / 健康)+ 账本 + 接管票,不再各算一遍
   const buildInboxFor = ({ issues, previews, leftovers, health }, raw) => {
     try {
@@ -839,6 +848,12 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
       if (p === '/api/changelog' && req.method === 'GET') return sendJSON(res, 200, { changelog: readChangelog() })
       // 同一份版本历史的英文本(界面切英文时才拉;缺的版本前端按 version 回退中文)
       if (p === '/api/changelog-en' && req.method === 'GET') return sendJSON(res, 200, { changelog: readChangelogEn() })
+      // 升级进度:控制台的升级弹窗在升级期间每一两秒读一次。只读,只给升级状态和还有任务的群名,
+      // 不重算整份 state(那里有健康探针);服务重启的那几秒连不上,由页面当作「正在重启」处理。
+      if (p === '/api/update' && req.method === 'GET') {
+        if (!updater) return sendJSON(res, 503, { error: '版本检查暂不可用' })
+        return sendJSON(res, 200, { ...updater.status(), waitingGroups: upgradeWaitingGroups() })
+      }
       if (p === '/api/update/check' && req.method === 'POST') {
         if (!updater) return sendJSON(res, 503, { error: '版本检查暂不可用' })
         return sendJSON(res, 200, await updater.check())