sintbot 1.4.12 → 1.4.13

package/CHANGELOG.en.json

@@ -1,4 +1,43 @@
 [
+  {
+    "version": "1.4.13",
+    "date": "2026-11-10",
+    "name": "Reliability and task follow-up improvements",
+    "items": [
+      {
+        "t": "Restore Claude Code health information",
+        "d": "Visible Claude Code models show executor version and probe results. Hidden models do not trigger extra probes."
+      },
+      {
+        "t": "Retry failed upgrades safely",
+        "d": "Keep failed installations for inspection. Retry in a separate directory and verify before switching, without overwriting existing installations."
+      },
+      {
+        "t": "Align runtime version, model and capability information",
+        "d": "Each turn receives the running service version and its exact tool entry. Distinguish service, global installation and available updates; consistently resolve group model overrides and defaults."
+      },
+      {
+        "t": "Read locally retained group replies",
+        "d": "Look up this group’s recorded replies by source message or turn, with explicit provenance, status, truncation and retention limits. Unreadable Feishu cards are never reconstructed by guesswork."
+      },
+      {
+        "t": "Apply concurrency and maintenance checks to trials",
+        "d": "Allow one console trial within shared model capacity. Refuse starts during maintenance, abort and skip saving after writer loss, and retain capacity when process closure is unknown."
+      },
+      {
+        "t": "Handle early timeout callbacks",
+        "d": "If a timer callback arrives before the deadline, wait for the remaining interval. Abort only with elapsed-time evidence so a normal timeout is not misclassified as a fault."
+      },
+      {
+        "t": "Send console messages while a task is running",
+        "d": "Project messages use the same followup or queue path as group messages. The console distinguishes acceptance, waiting for the model to read, and confirmed joining; repeated submissions are deduplicated."
+      },
+      {
+        "t": "Continue output after moving a reply card",
+        "d": "Busy follow-ups preserve already displayed text on the relocated card, then stream subsequent output without replaying the old text. Updates arriving during the move and the final answer remain ordered."
+      }
+    ]
+  },
   {
     "version": "1.4.12",
     "date": "2026-11-10",

package/CHANGELOG.json

@@ -1,4 +1,43 @@
 [
+  {
+    "version": "1.4.13",
+    "date": "2026-11-10",
+    "name": "可靠性与任务跟进体验",
+    "items": [
+      {
+        "t": "恢复 Claude Code 健康信息",
+        "d": "可见的 Claude Code 模型显示执行器版本与探测结果；主动隐藏的模型不额外探测。"
+      },
+      {
+        "t": "升级失败可重新尝试",
+        "d": "失败安装保留供排查；重试使用独立目录，校验后才能切换，不覆盖已有安装。"
+      },
+      {
+        "t": "统一运行版本、模型与能力说明",
+        "d": "每轮注入当前服务版本和准确工具入口，区分服务、全局安装与可用更新；群模型覆盖和执行器默认值统一展示。"
+      },
+      {
+        "t": "读取本群已保存答复",
+        "d": "可按消息或轮次读取本机保存的答复，明确来源、状态、截断与保留范围，不补造不可读的飞书卡片。"
+      },
+      {
+        "t": "试运行纳入并发与维护准入",
+        "d": "最多一项控制台试运行，共享模型并发名额；维护时拒绝启动，失去写入权限后中止且不保存结果，进程关闭未知时保留名额。"
+      },
+      {
+        "t": "修正硬超时提前触发",
+        "d": "计时回调早于截止时间时继续等待；获得超时证明后才中止任务，避免正常超时被误判为异常收尾。"
+      },
+      {
+        "t": "任务进行中可从控制台插话",
+        "d": "群项目列表不再因任务忙碌禁用插话；沿用群内跟进或排队流程，区分已受理、等待模型读取与已加入，重复提交不重复处理。"
+      },
+      {
+        "t": "卡片移位后接续输出",
+        "d": "收到忙时补充后，新卡直接保留已显示内容，后续输出继续追加，避免旧内容从头打字；移位期间的新内容和最终结果保持顺序。"
+      }
+    ]
+  },
   {
     "version": "1.4.12",
     "date": "2026-11-10",

package/bin/sintbot-v2.js

@@ -254,6 +254,8 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
             },
             durableV2UsageProbe: usageProbe, durableV2Issues: issues,
             durableV2Version: require('../package.json').version,
+            durableV2DataDir: stateDir,
+            durableV2ConsoleEnabled: uiEnabled,
             durableV2NormalRoute: true, durableV2StreamFrames: streamFrames(cfg) })
           return { journal, gate, runtime, engine, handles }
         } catch (error) { gate.stop(); throw error }
@@ -292,6 +294,7 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
         configPath: cfg._path, stateDir, host: uiHost, activity, store,
         getConfig: () => cfg, getBindings: () => service.bindings,
         getHeld: () => service.held, getCapacity: () => capacity.snapshot(),
+        acquireCapacity: options => capacity.acquire(options),
         getConnHealth: () => liveTransport?.platform.connHealth?.() || {},
         // Console injection enters through the same ingress as a group
         // message, posted and answered with that group's own adapter.

package/docs/AI-ASSISTED-INSTALL.md

@@ -1,4 +1,4 @@
-# Install SintBot 1.4.12 with an AI assistant
+# Install SintBot 1.4.13 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.12 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.13 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.12
+# Install SintBot 1.4.13
 
 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.12` into `~/.local/share/sintbot`, and verifies the entry, built-in core and Feishu module. Continue when you see `Installed and verified SintBot 1.4.12`. No sudo is needed.
+The installer checks the environment, installs `sintbot@1.4.13` into `~/.local/share/sintbot`, and verifies the entry, built-in core and Feishu module. Continue when you see `Installed and verified SintBot 1.4.13`. No sudo is needed.
 
 To preview, append `-s -- --dry-run`. To choose another location, set `SINTBOT_INSTALL_DIR` and adjust the executable paths below.
 
@@ -103,13 +103,21 @@ Send a command as a message of its own; except for `/issue` and `/model`, do not
 
 Busy follow-ups default on for both Codex and Claude Code. Set `steer: false` to queue them instead; an explicit `steer` value overrides the legacy Codex setting. Claude Code must advertise the required input capabilities, otherwise messages stay queued. Reading can wait until a long-running tool finishes. The reply card follows confirmed reading, and continuation answers are combined into one final reply. If a turn returns a model error or no result, only that group is asked to resend; there is no automatic retry. If a group's last result cannot be confirmed, such as a reply whose delivery is unknown, only that group is paused and answers new messages with a short notice; other groups keep working. Nothing is replayed or retried.
 
+When the reply card moves below a confirmed follow-up, its existing text is shown immediately and subsequent output continues from that point. Moving the card does not restart the task.
+
 ## 6. Console
 
 The overview combines group projects and concurrency. Each row shows the runner, state and elapsed time, project folder, model and configured reasoning effort, and the latest reported context usage. Select a group to view its tasks, then expand a task for tools, reply and usage. Context is a session sample, not cumulative token consumption; unknown capacity and older samples are labeled. Row icons provide console messages, stop and new-session controls according to the current group state.
 
 With `--ui`, open `http://127.0.0.1:4600` on this Mac. The console shows each group, stops tasks, starts a new conversation for an idle group, binds new groups, switches the model or project folder of an idle group, and adds or configures models. 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. A window shows each step, reconnects by itself while the service restarts and can be left running in the background. On the first start after an upgrade, each serving group gets one card listing what changed; to turn this off, clear "Announce upgrades in groups" under Settings → Software updates.
+The Message action also works while a group is busy. It follows the group’s follow-up setting: the message waits for model reading or joins the queue. “Accepted” does not yet confirm that the model has read it. New sessions and model changes still require an idle group.
+
+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 an isolated release directory 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. On the first start after an upgrade, each serving group gets one card listing what changed; to turn this off, clear "Announce upgrades in groups" under The Message action also works while a group is busy. It follows the group’s follow-up setting: the message waits for model reading or joins the queue. “Accepted” does not yet confirm that the model has read it. New sessions and model changes still require an idle group.
+
+Settings → Software updates.
+
+If an installation fails, retry uses a fresh directory and preserves the failed attempt for diagnosis. It switches only after verification.
 
 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.12
+# 用 AI 助手安装 SintBot 1.4.13
 
 [English](../AI-ASSISTED-INSTALL.md) · 简体中文
 
@@ -15,5 +15,5 @@
 ## 可复制的请求
 
 ```text
-按一行安装指南，在这台 Mac 安装 SintBot 1.4.12。保留已有服务、配置、状态和 Codex 或 Claude Code 账号数据，不输出凭据。验证实际入口与二进制核心，配置飞书群及各群的执行器，只对全新状态初始化。运行前台预检和已授权的只读群测试，对照结果，再验证正常停止与重启。完成后停止临时进程，并区分程序包安装与群验收结果。
+按一行安装指南，在这台 Mac 安装 SintBot 1.4.13。保留已有服务、配置、状态和 Codex 或 Claude Code 账号数据，不输出凭据。验证实际入口与二进制核心，配置飞书群及各群的执行器，只对全新状态初始化。运行前台预检和已授权的只读群测试，对照结果，再验证正常停止与重启。完成后停止临时进程，并区分程序包安装与群验收结果。
 ```

package/docs/zh-CN/install.md

@@ -1,4 +1,4 @@
-# 安装 SintBot 1.4.12
+# 安装 SintBot 1.4.13
 
 [English](../install.md) · 简体中文
 
@@ -10,7 +10,7 @@
 curl -fsSL https://sintbot.com/install.sh | bash
 ```
 
-安装器会自动检查环境，把 `sintbot@1.4.12` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.12` 就可以继续。不需要 sudo。
+安装器会自动检查环境，把 `sintbot@1.4.13` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.13` 就可以继续。不需要 sudo。
 
 可选预览：在命令末尾加 `-s -- --dry-run`。要自定义安装位置，设置 `SINTBOT_INSTALL_DIR` 环境变量，并同步修改后面的可执行文件路径。
 
@@ -103,16 +103,22 @@ SINTBOT="$HOME/.local/share/sintbot/bin/sintbot"
 
 Codex 和 Claude Code 的忙时跟进默认开启；`steer:false` 改为排队，显式 `steer` 优先于旧 Codex 开关。Claude Code 未提供所需输入能力时保留排队。长工具调用可能延迟读取；确认读取后回复卡才跟随补话，续轮答案合并为一条最终回复。某一轮模型报错或没有结果时，只在本群提示重新发送，不会自动重试。某个群上一轮的结果无法确认时（例如回复是否送达不明），只暂停这个群，它收到新消息会回一句说明，其他群照常；不重放、不重试。
 
+回复卡移到已确认读取的补话下方时，会立即保留已有文字，后续输出继续更新；移动卡片不会重新启动任务。
+
 ## 6. 控制台
 
 概览合并群项目与并发信息，每行显示执行器、状态与耗时、项目目录、模型和配置的思考深度、最近上报的上下文用量。选择群后查看对应任务，展开任务查看工具、回复和用量。上下文是当前会话采样，不是累计消耗；容量未知或历史采样会明确标注。群行图标按当前状态提供插话、停止与新会话操作。
 
 带 `--ui` 启动后，在本机浏览器打开 `http://127.0.0.1:4600`。控制台可以查看各群状态、停止任务、给空闲的群开新会话、绑定新群、给空闲的群切换模型或项目目录、添加和设置模型。要从局域网访问，先在控制台的设置里设访问密码，再开启局域网访问。
 
-「设置 → 软件更新」会检查新版本。按上面前台方式运行时，卡片给出升级步骤：按 Ctrl-C 等待退出，重新运行一行安装命令，再用原来的命令启动。如果用你自己的 launchd 后台任务启动 SintBot，「现在升级」会等所有群空闲、记录结清后，把新版本装到 `~/.local/share/sintbot/releases/<版本>` 并切换过去；新版本 90 秒内没连上全部群会自动换回旧版。升级时窗口逐步显示进度，服务重启时页面自动重连，也可以放到后台继续。升级后首次启动会在每个在服务的群发一张版本公告卡，列出这一版的更新；不想播报就在「设置 → 软件更新」取消「升级后向群里播报」。
+群忙时也可以使用控制台「插话」：按本群跟进设置，等待模型读取或进入队列。「已受理」不代表模型已经读取。新会话与模型切换仍需等待群空闲。
+
+「设置 → 软件更新」会检查新版本。按上面前台方式运行时，卡片给出升级步骤：按 Ctrl-C 等待退出，重新运行一行安装命令，再用原来的命令启动。如果用你自己的 launchd 后台任务启动 SintBot，「现在升级」会等所有群空闲、记录结清后，把新版本装到独立的发行目录并切换过去；新版本 90 秒内没连上全部群会自动换回旧版。升级时窗口逐步显示进度，服务重启时页面自动重连，也可以放到后台继续。升级后首次启动会在每个在服务的群发一张版本公告卡，列出这一版的更新；不想播报就在「设置 → 软件更新」取消「升级后向群里播报」。
 
 不用控制台也能加群：在配置里加上新群，停止后重新 `start` 即可，新群会自动登记。已绑定的群不能通过改配置删除或改名。
 
+升级安装失败后可重新尝试：重试使用新目录，保留失败产物供排查，校验成功后才切换。
+
 ## 停止与重启
 
 按 Ctrl-C 并等待退出。确认飞书环境变量已设置，再执行：

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.12
+  version=1.4.13
   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.12",
+  "version": "1.4.13",
   "private": false,
   "description": "Drive your Mac projects from Feishu groups with Codex or Claude Code, using a built-in agent core.",
   "bin": {
@@ -69,6 +69,7 @@
     "src/cdp.js",
     "src/config.js",
     "src/consolesay.js",
+    "src/consoletrials.js",
     "src/core/c2cardeffectbridge.js",
     "src/core/c2cardterminalpath.js",
     "src/core/c2durableingress.js",
@@ -113,6 +114,7 @@
     "src/feishucli.js",
     "src/gitrepo.js",
     "src/leftover.js",
+    "src/modelcontext.js",
     "src/platform/board.js",
     "src/platform/feishu.js",
     "src/platform/multi.js",
@@ -128,6 +130,8 @@
     "src/preview.js",
     "src/projectmemory.js",
     "src/projectsroot.js",
+    "src/recordedanswers.js",
+    "src/runtimefacts.js",
     "src/setupmodels.js",
     "src/ui/auth.js",
     "src/ui/browser.html",

package/src/agent/claudecode.js

@@ -229,6 +229,8 @@ function runTurn({
       // The binary owns the permission, tool allow/deny and argument policy.
       // Node only resolves capability and writes the project-scoped MCP file.
       const args = claudeBuildArgs({ steer, model, providerModel: provider.model, sessionId,
+        runtimeCommand: extraEnv?.SBOT_RUNTIME_ENTRY
+          ? require('../runtimefacts').runtimeCommand(extraEnv.SBOT_RUNTIME_ENTRY) : '',
         permissionMode, autocompactTokens, autocompactSupported,
         mcpConfigPath, allowedTools, pluginAllows, disallowedTools,
         appendSystemPrompt, workdir })

package/src/agent/privatecore.js

@@ -3,7 +3,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { createHash } = require('node:crypto')
 
-const EXPECTED_SHA256 = '9c29c9123b38aa75b9c47066c809d844f938baca41779372b77c02fa7baa9989'
+const EXPECTED_SHA256 = 'a7ad2bd9210906ee6f5d7893ed3d9632769b6e2dbec285c1102492e3ba1257b5'
 let bytes
 try {
   bytes = fs.readFileSync(path.join(__dirname, 'privatecore.wasm'))

package/src/agent/runner.js

@@ -17,4 +17,6 @@ function runTurn(opts) {
   return claudeAgent.runTurn(opts)
 }
 
-module.exports = { runTurn, probeVersion: claudeAgent.probeVersion }
+const isClosedRunnerResult = value => [claudeAgent, codexAgent, codexApp].some(agent => agent.isClosedRunnerResult(value))
+const isClosedRunnerError = value => [claudeAgent, codexAgent, codexApp].some(agent => agent.isClosedRunnerError(value))
+module.exports = { runTurn, probeVersion: claudeAgent.probeVersion, isClosedRunnerResult, isClosedRunnerError }

package/src/c2console.js

@@ -30,7 +30,7 @@ const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   // one-off agent run); it does not take a group concurrency slot.
   '/api/test',
   '/api/inbox/dismiss', '/api/issues/status',
-  // Console injection, first version: an idle group only, the line shown in
+  // Console injection through the ordinary busy-followup ingress, the line shown in
   // the group and the reply delivered there. The posted line is the platform
   // message that drives the turn (see consolesay.createDurableConsoleSay).
   '/api/groups/say',
@@ -38,6 +38,8 @@ const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   // manages this exact entry (the updater refuses every other run mode).
   '/api/update/check', '/api/update/start', '/api/update/ignore']
 const SUPPORTED_RUNNERS = ['claude', 'codex']
+const { modelContext } = require('./modelcontext')
+const { GROUP_COMMANDS } = require('./runtimefacts')
 
 function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld = () => new Map(), activity = null, store = null,
   assertWriterLock, validateConfig, applyConfig, beforeWrite = () => true,
@@ -45,6 +47,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
   // Console injection reaches a group only through the service's own ingress
   // and that group's real platform adapter. Without them it is refused.
   getPlatform = null, routeMessage = null, isServing = () => false, isFrozen = () => false,
+  acquireCapacity = null,
   log = () => {} } = {}) {
   for (const callback of [getBindings, getCapacity, getConfig, getHeld, assertWriterLock,
     validateConfig, applyConfig, beforeWrite, appliedResets, now, isServing, isFrozen, log]) {
@@ -58,9 +61,12 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     throw new TypeError('C2 console configuration hooks must be synchronous')
   }
   const startedAt = now()
+  const trials = require('./consoletrials').createConsoleTrials({ getCapacity, acquireCapacity,
+    assertWriterLock, isServing, isFrozen })
   const capabilities = Object.freeze({ mode: 'durable-v2',
+    groupCommands: GROUP_COMMANDS,
     reason: '此操作尚未接入当前版本的持久处理流程，未执行。',
-    summary: '实时状态、认证管理、停止任务、空闲群开新会话、空闲群的控制台插话、绑定新群、空闲群的模型切换（Codex / Claude Code）和项目目录修改、模型的添加与设置，以及后台运行时的软件升级已接入；该群有任务或未结记录时不能修改，也不能开新会话或插话；改模型的型号、后端或端点时，用它的群须空闲，并会开始新的一段对话。插话会把这句话（标着「管理员」）和回复都发进群，群忙时不排队、也不加入当前任务；静默插话和不回复的插话暂不支持。解除绑定、移除模型、定时任务和画布暂不可用。',
+    summary: '实时状态、认证管理、停止任务、空闲群开新会话、支持忙时跟进的控制台插话、绑定新群、空闲群的模型切换（Codex / Claude Code）和项目目录修改、模型的添加与设置，以及后台运行时的软件升级已接入；该群有任务或未结记录时不能修改，也不能开新会话；改模型的型号、后端或端点时，用它的群须空闲，并会开始新的一段对话。插话会把这句话（标着「管理员」）和回复都发进群，群忙时按该群的忙时跟进设置尝试加入当前任务，关闭或暂不支持时排队；确认模型读取后才显示已加入；静默插话和不回复的插话暂不支持。解除绑定、移除模型、定时任务和画布暂不可用。',
     allowed: { GET: READ_PATHS, POST: WRITE_PATHS } })
   function held() {
     if (assertWriterLock() !== true) throw new Error('服务写入权限已失效，操作未执行')
@@ -97,7 +103,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     binding.engine.store.resetSessionAndStats(chatId)
     return true
   }
-  // Console injection, first version: an open, idle group only. Checked
+  // Console injection: an open group, idle or running. Checked
   // before the line is posted, so a refused group shows nothing, and again
   // right after; the service ingress remains the final authority.
   function sayGate(chatId) {
@@ -110,8 +116,13 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     const binding = bindings().get(chatId)
     if (!binding || binding.runtime?.closed === true) return 'not-serving'
     const rt = binding.engine?.rts?.get(chatId)
-    if (groupBusy(chatId, binding) || rt?.v2RunningJobs || rt?.v2StopControl || rt?.v2SkipWaiter ||
-        (binding.journal?.consoleSnapshot?.() || binding.journal?.snapshot())?.state?.lanes?.stopIntent?.[chatId]) return 'busy'
+    const snapshot = binding.journal?.consoleSnapshot?.() || binding.journal?.snapshot()
+    if (rt?.v2StopControl || rt?.v2SkipWaiter || snapshot?.state?.lanes?.stopIntent?.[chatId]) return 'busy'
+    // A normal active turn may accept ordinary messages. Unowned pending work
+    // still refuses; it must not become a new execution path or bypass recovery.
+    if (!rt?.v2NormalRouteActive && !rt?.v2AdmissionPending && (groupBusy(chatId, binding) || rt?.v2RunningJobs)) return 'busy'
+    const queued = snapshot?.state?.lanes?.queue?.[chatId]?.queue?.length || 0
+    if (queued >= (rt?.v2AdmissionPending ? 3 : 2)) return 'queue-full'
     return null
   }
   function receiptState(chatId, receiptId) {
@@ -120,9 +131,22 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     if (receipts?.completed?.some(item => item.id === receiptId)) return 'completed'
     return null
   }
+  function locateSay(chatId, receiptId) {
+    const binding = bindings().get(chatId)
+    const rt = binding?.engine?.rts?.get(chatId)
+    const state = receiptState(chatId, receiptId)
+    if (state === 'completed') return { state: 'done' }
+    const steer = rt?.v2SteerEntries?.get(receiptId)
+    if (steer) return { state: steer.accepted && steer.landed ? 'joined' : 'following' }
+    const queue = (binding?.journal?.consoleSnapshot?.() || binding?.journal?.snapshot())?.state?.lanes?.queue?.[chatId]?.queue || []
+    const index = queue.findIndex(item => item.id === `receipt:job:${receiptId}`)
+    if (index >= 0) return { state: 'queued', ahead: index, join: false }
+    if (rt?.v2RunningJobs?.some(job => job.msg?._c2ReceiptId === receiptId)) return { state: 'started' }
+    return { state: 'accepted' }
+  }
   const say = getPlatform ? createDurableConsoleSay({ getPlatform,
     getGroup: chatId => getConfig().groups?.[chatId] || null,
-    gate: sayGate, route: routeMessage, receiptState, log, now }) : null
+    gate: sayGate, route: routeMessage, receiptState, locate: locateSay, log, now }) : null
   function getLiveState() {
     const cfg = getConfig()
     const capacity = getCapacity()
@@ -198,7 +222,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
         ? { usedTokens: stats.ctx, windowTokens: null, measuredAt: null, quality: 'historical' } : null)
       return { chatId, name: group.name || chatId.slice(-8), project: path.basename(group.workdir || '') || '—',
         workdir: group.workdir || '', runner: provider.runner || 'claude',
-        model: group.model || provider.model || provider.env?.ANTHROPIC_MODEL || providerName,
+        ...modelContext(group, provider),
         reasoningEffort: (provider.runner === 'codex' ? provider.reasoningEffort : provider.env?.CLAUDE_CODE_EFFORT_LEVEL) || '',
         paused: !!group.paused, ...live.groups[chatId], context }
     })
@@ -209,6 +233,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
   }
   return {
     capabilities,
+    beginTrial: controller => trials.begin(controller),
     allows: (method, pathname) => (capabilities.allowed[method] || []).includes(pathname),
     // A provider without a runner field is Claude Code, as everywhere else.
     providerSupported: provider => SUPPORTED_RUNNERS.includes(provider?.runner || 'claude'),
@@ -221,6 +246,12 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     appliedResets: () => appliedResets(),
     decorateState(state) {
       state.runtimeCapabilities = capabilities
+      for (const group of state.groups || []) {
+        const cfg = getConfig(), source = cfg.groups?.[group.chatId] || {}
+        const provider = cfg.providers?.[group.effectiveProvider || source.provider || cfg.defaultProvider]
+        const model = modelContext(source, provider)
+        Object.assign(group, { configuredModel: model.model, modelSource: model.source, actualModel: model.actualModel })
+      }
       state.previews = (state.previews || []).filter(item => getConfig().groups?.[item.chatId])
       state.leftovers = { supported: false, rows: [], error: null }
     },

package/src/c2updater.js

@@ -289,16 +289,24 @@ function createC2Updater({ currentVersion, runMode, stateFile, dataDir, configPa
     const blocked = gate()
     if (blocked.includes('held')) return fail('有暂停的群，升级已取消；先处理暂停的群')
     if (blocked.length) { schedule(); return status() }
-    const prefix = path.join(releasesRoot, job.to)
+    let prefix = job.installed ? job.prefix : path.join(releasesRoot, job.to)
     if (!job.installed) {
       setJob({ state: 'installing', prefix }, `正在安装 v${job.to}`)
       try {
+        let reusable = false
         if (fs.existsSync(prefix)) {
-          // A directory left by an earlier attempt or a manual install is reused
-          // only when it verifies as exactly this version.
-          await verifyInstall({ version: job.to, prefix })
-        } else {
+          // Never repair an existing tree in place: another process may still
+          // use it. A failed check leaves it intact as evidence.
+          try { await verifyInstall({ version: job.to, prefix }); reusable = true }
+          catch { /* retry in an independent installation directory */ }
+        }
+        if (!reusable) {
           fs.mkdirSync(releasesRoot, { recursive: true, mode: 0o700 })
+          // The directory becomes eligible for switching only after validation.
+          // Keeping its unique path also avoids overwriting a concurrently
+          // installed or running release when a download is retried.
+          prefix = fs.mkdtempSync(path.join(releasesRoot, `${job.to}-`))
+          setJob({ prefix })
           await installVersion({ version: job.to, prefix, registry: job.registry })
           await verifyInstall({ version: job.to, prefix })
         }

package/src/consolesay.js

@@ -86,7 +86,7 @@ function createConsoleSay({ getPlatform, getGroup, handle, locate, log = () => {
   }
 }
 
-// ── 持久处理流程(sintbot-v2)的插话,第 1 版:只接「空闲群 · 这句话进群 · 回复进群」 ──
+// ── 持久处理流程(sintbot-v2)的插话,这句话与回复进群，忙时沿用普通群消息的跟进/排队流程 ──
 //
 // 群里那行「【管理员】…」就是驱动这一轮的那条平台消息:它的 om_ 消息 id 就是这笔任务的来源身份
 // (source 'message'),与群成员自己发的一条消息同形 —— 收据、回复锚点、/stop、重启后的中断告知
@@ -97,7 +97,6 @@ function createConsoleSay({ getPlatform, getGroup, handle, locate, log = () => {
 // 第 1 版不做的,都在发群消息**之前**就拒,群里不留痕:
 //   · 静默插话(这句不进群):没有平台消息可锚,需要另一种来源和重启告知路径;
 //   · 不回复的插话(quiet):持久路径还不接静默收据;
-//   · 群正忙:不排队、也不加入当前任务;
 //   · 斜杠命令:群命令不走插话(停止、开新会话在概览里有按钮)。
 //
 // requestId:控制台每次提交带的 32 位十六进制幂等键(经 syntheticSource 校验并折成键)。发出那行字
@@ -128,9 +127,10 @@ function refusalOf(value) {
 //   route(msg, platform)       服务的统一入口(routeMessage):暂停 / 待人工 / 收尾中 / 升级中都在那里把关
 //   receiptState(chatId, id)   该群日志里这笔收据:'pending' | 'completed' | null
 function createDurableConsoleSay({ getPlatform, getGroup, gate, route, receiptState,
+  locate = () => ({ state: 'accepted' }),
   log = () => {}, now = () => Date.now(), sendTimeoutMs = SEND_TIMEOUT_MS,
   confirmMs = CONFIRM_MS, pollMs = POLL_MS, maxRequests = MAX_REQUESTS } = {}) {
-  for (const hook of [getPlatform, getGroup, gate, route, receiptState, log, now]) {
+  for (const hook of [getPlatform, getGroup, gate, route, receiptState, locate, log, now]) {
     if (typeof hook !== 'function') throw new TypeError('durable console say needs explicit hooks')
   }
   const posted = new Map() // 请求键 → 群里那行字的消息 id(按插入顺序,超过上限丢最早的)
@@ -171,7 +171,7 @@ function createDurableConsoleSay({ getPlatform, getGroup, gate, route, receiptSt
         return { ok: false, reason: 'shown-failed' }
       }
       remember(key, shownId)
-      // 发这行字的这会儿群里可能刚开始了别的任务:此时不注入(第 1 版忙时不排队、不加入)
+      // 发送期间再次检查暂停、停止、维护及容量，正常忙时仍走统一入口
       const late = gate(chatId)
       if (late) return { ok: false, reason: late === 'busy' ? 'busy-after-post' : late }
     }
@@ -186,12 +186,12 @@ function createDurableConsoleSay({ getPlatform, getGroup, gate, route, receiptSt
     if (first.admitted || first.timeout) {
       // 这一轮在后台继续;它之后的成败由该群自己的持久路径收尾,这里只留日志
       settled.then(({ error }) => { if (error) log('say: ' + (error && error.message)) })
-      return first.admitted ? { ok: true, where: { state: 'started' } } : { ok: false, reason: 'unconfirmed' }
+      return first.admitted ? { ok: true, where: locate(chatId, receiptId) } : { ok: false, reason: 'unconfirmed' }
     }
     const { value, error } = first
     if (value && value.duplicate) return { ok: true, where: { state: 'duplicate' } }
     const state = receiptState(chatId, receiptId)
-    if (state) return { ok: true, where: { state: state === 'completed' ? 'done' : 'started' } }
+    if (state) return { ok: true, where: state === 'completed' ? { state: 'done' } : locate(chatId, receiptId) }
     if (error) {
       log('say: ' + (error && error.message))
       return { ok: false, reason: 'inject-failed' }

package/src/consoletrials.js

@@ -0,0 +1,43 @@
+'use strict'
+
+// One bounded console trial, sharing the real model capacity. A timeout or
+// lease loss asks the runner to stop; only its close proof releases capacity.
+function createConsoleTrials({ getCapacity, acquireCapacity, assertWriterLock, isServing, isFrozen }) {
+  let active = false
+  function assertWritable() {
+    if (assertWriterLock() !== true) throw new Error('服务写入权限已失效，试运行结果未保存')
+  }
+  function assertAdmission() {
+    assertWritable()
+    if (!isServing() || isFrozen()) throw new Error('服务未就绪或正在维护，暂不能试运行')
+  }
+  async function begin(controller) {
+    assertAdmission()
+    const capacity = getCapacity()
+    if (active || capacity.closed || capacity.active + capacity.waiting >= capacity.maxConcurrent) {
+      throw new Error('试运行或模型并发名额已满，请稍后重试')
+    }
+    if (typeof acquireCapacity !== 'function') throw new Error('当前服务未接入试运行并发准入')
+    active = true
+    let release
+    try {
+      release = await acquireCapacity({ signal: controller.signal })
+      assertAdmission()
+    } catch (error) { active = false; release?.(); throw error }
+    let finished = false
+    const monitor = setInterval(() => {
+      try { assertAdmission() } catch (error) { controller.abort(error) }
+    }, 100)
+    monitor.unref?.()
+    return { assertWritable,
+      finish(closed) {
+        if (finished) return
+        finished = true; clearInterval(monitor)
+        // Unknown closure keeps the shared slot occupied and blocks upgrades.
+        if (closed) { active = false; release() }
+      },
+    }
+  }
+  return { begin, active: () => active }
+}
+module.exports = { createConsoleTrials }

package/src/core/c2cardterminalpath.js

@@ -129,7 +129,7 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
       const nextCtx = landedAnchor(anchor)
       if (phase !== 'open' || !card) return false
       if (activeAnchorCtx.messageId === nextCtx.messageId) return true
-      if (!lastCardText) throw new Error('C2 card move has no visible text to replay')
+      if (!lastCardText) throw new Error('C2 card move has no visible text to preserve')
       phase = 'relocating'
       try {
         if (await card.flush() !== true) throw new Error('C2 old card flush unconfirmed')
@@ -138,6 +138,7 @@ function prepareCardTerminalPath({ runtime, payloadHandles, platform, replyCtx,
         const fresh = await platform.createStreamingCard(nextCtx, {
           operationKey: `${receiptId}:followup:${anchor.receiptId}`,
           operationBoundary,
+          initialText: lastCardText,
         })
         if (!fresh || typeof fresh.update !== 'function' ||
             typeof fresh.flush !== 'function' || typeof fresh.recall !== 'function') {

package/src/core/v2engine.js

@@ -18,6 +18,8 @@ const { prepareC2RunnerInput } = require('./c2runnerinput')
 const { continueC2Successor } = require('./c2successorbridge')
 const { rejectC2Input } = require('./c2inputrejection')
 const progress = require('./turnprogress')
+const { modelContext } = require('../modelcontext')
+const { GROUP_COMMANDS, RUNTIME_ENTRY, runtimeCommand } = require('../runtimefacts')
 const NO_REPLY = 'NO_REPLY'
 const SYSTEM_APPENDIX = systemAppendix(NO_REPLY)
 const V2_NORMAL_ROUTE_MISSING = Object.freeze(['complete durable v2 authority'])
@@ -25,7 +27,7 @@ const V2_NORMAL_ROUTE_MISSING = Object.freeze(['complete durable v2 authority'])
 // the Codex read-only sandbox, 3 the fail-closed default. 0 is full access
 // and 2 an allow-listed tool set, which may still change files.
 const READ_ONLY_TIERS = Object.freeze([1, 3])
-const DURABLE_V2_COMMANDS = new Set(['/help', '/status', '/model', '/new', '/hud', '/issue'])
+const DURABLE_V2_COMMANDS = new Set(GROUP_COMMANDS.filter(cmd => !['/skip', '/stop'].includes(cmd)))
 function fmtWan(n) {
   n = Number(n) || 0
   if (n >= 100_000_000) return `${(n / 100_000_000).toFixed(1).replace(/\.0$/, '')}亿`
@@ -51,8 +53,7 @@ function cardDuration(ms) {
 }
 function cardModelInfo(group, provider) {
   if (!provider) return { model: '', effort: '' }
-  const model = group?.model || provider.model ||
-    (provider.runner === 'codex' ? '' : provider.env?.ANTHROPIC_MODEL) || ''
+  const { model } = modelContext(group, provider)
   const effort = provider.runner === 'codex'
     ? provider.reasoningEffort : provider.env?.CLAUDE_CODE_EFFORT_LEVEL
   const clean = value => String(value || '').replace(/\s+/g, ' ').trim()
@@ -224,10 +225,11 @@ function v2QueueSelection(queue) {
 function releaseSkillLines(platform) {
   const features = manifestFeatures({ ...(platform?.features || {}),
     boards: false, imagen: false, takeoverCard: false })
-  const lines = manifestSkills({ features,
+  const lines = manifestSkills({ features: { ...features, localAnswers: true },
     platformName: String(platform?.chatLabel || '飞书群').replace(/群$/, '') })
   const cron = lines.findIndex(line => line.startsWith('【定时任务】'))
-  return cron < 0 ? lines : lines.slice(0, cron)
+  return (cron < 0 ? lines : lines.slice(0, cron))
+    .map(line => line.replace(/sbot feishu/g, `${runtimeCommand()} feishu`))
 }
 
 // The group skills call `sbot feishu`. A machine can carry another `sbot` on
@@ -256,7 +258,7 @@ class Engine {
       durableV2NormalRoute = true, durableV2StreamFrames = false,
       durableV2AcquireCapacity = null, durableV2SealCapacity = null,
       durableV2SwitchProvider = null, durableV2UsageProbe = null, durableV2Issues = null,
-      durableV2Version = '' } = options
+      durableV2Version = '', durableV2DataDir = '', durableV2ConsoleEnabled = false } = options
     const sync = f => typeof f === 'function' && f.constructor?.name !== 'AsyncFunction'
     if (!cfg || !cfg.agent || !cfg.groups || !cfg.providers ||
         options.receiptJournal || options.unifiedStepHost ||
@@ -289,7 +291,8 @@ class Engine {
       durableV2StartTurn, durableV2ApplyLocalEffect, durableV2VerifyRunnerClosed,
       durableV2AssertWriterLock, durableV2Journal, durableV2NormalRoute,
       durableV2StreamFrames, durableV2AcquireCapacity, durableV2SealCapacity,
-      durableV2SwitchProvider, durableV2UsageProbe, durableV2Issues, durableV2Version })
+      durableV2SwitchProvider, durableV2UsageProbe, durableV2Issues, durableV2Version,
+      durableV2DataDir, durableV2ConsoleEnabled })
     this.projectMemory = options.projectMemory || null
     this.repoInfo = options.repoInfo || null
     this.activity = options.activity || null
@@ -433,6 +436,8 @@ baseSkillEnv(chatId) {
     const g = (this.cfg.groups || {})[chatId]
     const bin = releaseBinDir()
     return { ...(bin ? { PATH: [bin, process.env.PATH].filter(Boolean).join(path.delimiter) } : {}),
+      SBOT_RUNTIME_ENTRY: RUNTIME_ENTRY, SBOT_RUNTIME_VERSION: this.durableV2Version || '',
+      ...(this.durableV2DataDir ? { SBOT_DATA_DIR: this.durableV2DataDir } : {}),
       SBOT_CHAT_ID: chatId, ...(g && g.platform ? { SBOT_PLATFORM: g.platform } : {}), TZ: this.tz, ...(this.cfg._path ? { SBOT_CONFIG: this.cfg._path } : {}), ...(this.uiLocalUrl ? { SBOT_UI_URL: this.uiLocalUrl } : {}) }
   }
 
@@ -463,7 +468,7 @@ async _durableV2Command(msg, cmd, rest) {
     if (!group || group.paused) return reject('unsupported-command', T.unsupportedCommandWithModel)
     const { name, provider } = this._resolveProvider(msg.chatId, group)
     // A group may pin its own model; the runner uses it before the provider default.
-    const label = (n, p) => (group.model || p?.model) ? `${n} · ${group.model || p.model}` : n
+    const label = (n, p) => { const { model } = modelContext(group, p); return model ? `${n} · ${model}` : n }
     if (cmd === '/model') return this._durableV2ModelCommand(msg, rest, group)
     if (cmd === '/help') {
       const isCodex = provider?.runner === 'codex'
@@ -532,12 +537,15 @@ async _durableV2Command(msg, cmd, rest) {
 _durableV2ModelCommand(msg, want, group) {
     const reject = (reason, notice) =>
       rejectC2Input('C2 v2 model command answered before receipt', { reason, notice })
-    const label = (name, provider) => provider?.model ? `${name} · ${provider.model}` : name
+    const label = (name, provider, scope = {}) => {
+      const { model } = modelContext(scope, provider)
+      return model ? `${name} · ${model}` : name
+    }
     const available = Object.entries(this.cfg.providers || {})
       .filter(([, provider]) => provider && !provider.hidden &&
-        ['claude', 'codex'].includes(provider.runner))
+        ['claude', 'codex'].includes(provider.runner || 'claude'))
     const { name: currentName, provider: currentProvider } = this._resolveProvider(msg.chatId, group)
-    const current = label(currentName, currentProvider)
+    const current = label(currentName, currentProvider, group)
     const list = available.map(([name, provider]) => label(name, provider)).join(' / ')
     if (!want) {
       const example = available.find(([name]) => name !== currentName)?.[0] || currentName
@@ -1377,6 +1385,7 @@ stageDurableV2Message(msg, platform) {
     if (!rt.v2QueueReceiptIds) rt.v2QueueReceiptIds = []
     rt.v2QueueReceiptIds.push(receipt.id)
     this._observeActivity('receive', { chatId: msg.chatId, receiptId: receipt.id,
+      sourceMessageId: msg.msgId,
       text: msg.text, sender: msg.senderName || '', acceptedAt })
     return { receiptId: receipt.id, cursor: result.cursor, staged: true,
       ingressClosed: !!authority.blocked }
@@ -1778,18 +1787,22 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
           (!Number.isSafeInteger(timeoutDeadlineAt) || timeoutDeadlineAt <= 0)) {
         throw new Error('C2 v2 hard timeout deadline invalid')
       }
-      capTimer = timeoutDeadlineAt !== null
-        ? setTimeout(() => {
+      const onHardDeadline = () => {
           const elapsedAt = Date.now()
           if (rt.v2RunnerGeneration !== generation ||
               rt.v2Controller !== controller || rt.v2CancelControl ||
               rt.v2StreamQuiescing) return
-          if (elapsedAt >= timeoutDeadlineAt) {
-            rt.v2TimeoutProof = { receiptId, turnToken, generation,
-              deadlineAt: timeoutDeadlineAt, elapsedAt }
+          // Timers and Date.now need not tick together. An early callback (or
+          // a backward wall-clock adjustment) is not proof of elapsed time.
+          if (elapsedAt < timeoutDeadlineAt) {
+            capTimer = setTimeout(onHardDeadline, timeoutDeadlineAt - elapsedAt)
+            return
           }
+          rt.v2TimeoutProof = { receiptId, turnToken, generation,
+            deadlineAt: timeoutDeadlineAt, elapsedAt }
           controller.abort()
-        }, timeoutMs) : null
+      }
+      capTimer = timeoutDeadlineAt !== null ? setTimeout(onHardDeadline, timeoutMs) : null
       const input = prepareC2RunnerInput({ prompt,
         appendSystemPrompt: SYSTEM_APPENDIX, msg: job.msg, group: job.group,
         provider, config: this.cfg,
@@ -2213,21 +2226,25 @@ classifyDurableV2UnresolvedTurn({ chatId, receiptId, turnToken, effectId,
     const policy = manifestPolicy(group.permissionMode, provider.runner === 'codex',
       group.allowedTools, group.disallowedTools)
     const brand = this.cfg.brand || 'SintBot'
+    const groupTools = group.platform === 'feishu' && manifestFeatures(platform.features || {}).skills
     const info = group.repo && this.repoInfo ? this.repoInfo(group.workdir, group.repo) : null
     const manifest = [
       ...manifestHeader({ restrictedV2: true, brand, chatLabel: platform.chatLabel || '项目群',
         chatId: msg.chatId, groupName: group.name || msg.chatId,
         workdir: group.workdir, repo: group.repo || '', repoState: info?.state || '',
         repoOrigin: info?.origin || '未知', pushDenied: policy.pushDenied,
-        providerName, model: group.model || provider.model || '',
+        providerName, model: modelContext(group, provider).model,
+        runtimeVersion: this.durableV2Version || '', runtimeCommand: runtimeCommand(),
         noVision: provider.vision === false, platformName: platform.chatLabel || '项目群',
         permissionTier: policy.tier, tz: this.tz, publicUrl: '', uiUrl: '', lanUrl: '' }),
       ...manifestContext({ restrictedV2: true, brand, isCodex: provider.runner === 'codex',
+        groupCommands: GROUP_COMMANDS, groupTools,
+        consoleEnabled: this.durableV2ConsoleEnabled === true,
         pmem: this.projectMemory ? this.projectMemory(group.workdir,
           { full: policy.full, isCodex: provider.runner === 'codex' }) : null,
         unredactedPii: group.redactPii === false,
         cardPinned: platform.features?.cardPinned === true, plainSend: false }),
-      ...releaseSkillLines(platform),
+      ...(groupTools ? releaseSkillLines(platform) : []),
     ].join('\n')
     // Reinject current supported context each turn. No legacy feature menu,
     // external-message commands or v1 manifest refresh scheduler is included.

package/src/feishucli.js

@@ -20,7 +20,7 @@ const { redact } = require('./core/redact')
 const { fmtStamp, normalizeTz } = require('./core/time')
 
 const FEISHU_MESSAGE_ACTIONS = Object.freeze(['send-msg', 'send-notice', 'send-file', 'send-image',
-  'history', 'reply', 'edit', 'recall', 'delete', 'download', 'react'])
+  'history', 'answers', 'reply', 'edit', 'recall', 'delete', 'download', 'react'])
 
 const dim = (s) => `\x1b[2m${s}\x1b[0m`
 const green = (s) => `\x1b[32m${s}\x1b[0m`
@@ -44,6 +44,8 @@ function parseFeishuArgs(action, rawArgs) {
     else if (a.startsWith('--chat=')) o.chat = a.slice(7)
     else if (a === '--config') o.config = rawArgs[++i]
     else if (a.startsWith('--config=')) o.config = a.slice(9)
+    else if (a === '--data-dir') o.dataDir = rawArgs[++i]
+    else if (a.startsWith('--data-dir=')) o.dataDir = a.slice(11)
     else if (action === 'send-notice' && a === '--sub') o.subtitle = rawArgs[++i]
     else if (action === 'send-notice' && a === '--tone') o.tone = rawArgs[++i]
     else if (action === 'send-notice' && a === '--warn') o.warnings.push(rawArgs[++i])
@@ -102,6 +104,15 @@ async function runFeishuAction(args, deps = {}) {
   const out = deps.stdout || ((s) => process.stdout.write(s))
   const err = deps.stderr || ((s) => process.stderr.write(s))
   const p = opts.positionals
+  if (action === 'answers') {
+    if (!cfg.groups?.[chatId]) refuse('目标群没有绑定，不能读取本机答复记录')
+    const { readRecordedAnswers } = require('./recordedanswers')
+    const result = readRecordedAnswers({ dataDir: opts.dataDir || (deps.env || process.env).SBOT_DATA_DIR,
+      chatId, id: p[0] || '' })
+    out(JSON.stringify(result, null, 2) + '\n')
+    if (!result.answers.length) err('未找到本群匹配记录；可能已过保留范围或尚未落盘，不能推断原卡正文。\n')
+    return result
+  }
   // Usage errors before any network call, worded as the legacy entry did.
   let notice
   if (action === 'send-msg' && !p.join(' ').trim()) refuse('缺少消息内容 — sbot feishu send-msg "<文本>"')
@@ -200,6 +211,7 @@ function feishuUsage(cmd = 'sintbot') {
     + '    send-notice "<标题>" "<正文>"              发群通知卡(可加 --sub / --tone / --warn / --from)\n'
     + '    send-file <路径> · send-image <路径>       发文件 / 图片\n'
     + '    history [n]                              拉最近 n 条(默认 20,最多 50):每条带 message_id,并标 →@某某·未@bot / →@bot\n'
+    + '    answers [消息或轮次ID]                    只读本群本机答复记录；默认最近 10 轮，不代表完整飞书历史\n'
     + '    reply <message_id> "<文本>"              回复某条\n'
     + '    edit <message_id> "<文本>"               改自己发过的消息\n'
     + '    recall <message_id>                      撤回自己发过的消息(别名 delete)\n'

package/src/modelcontext.js

@@ -0,0 +1,13 @@
+'use strict'
+
+// Configuration projection shared by chat, cards and the console. A configured
+// model is not proof of what an executor ultimately selected or fell back to.
+function modelContext(group = {}, provider = {}) {
+  group ||= {}; provider ||= {}
+  const environment = provider.runner === 'codex' ? '' : provider.env?.ANTHROPIC_MODEL
+  const model = group.model || provider.model || environment || ''
+  return { model, source: group.model ? 'group' : provider.model ? 'provider' : environment ? 'environment' : 'default',
+    actualModel: null }
+}
+
+module.exports = { modelContext }

package/src/platform/feishu.js

@@ -181,9 +181,10 @@ function createCardWriter({
   client, cardId, elementId = 'answer', log = () => {}, now = () => Date.now(),
   throttleMs = 0, streamWindowMs = STREAM_WINDOW_MS, setTimer = setTimeout, clearTimer = clearTimeout,
   operationBoundary = null, operationKey = null,
+  initialText = '', initialSequence = 1,
 } = {}) {
   const openedAt = now()
-  let seq = 1            // 流式与整卡更新共用的**唯一**序号分配器(混用同一张卡必须同源)
+  let seq = initialSequence // Includes any confirmed settings call before this writer opens.
   let streamOpen = true  // 飞书侧流式模式还开着吗
   // ⚠ 「已收尾」与「已冻结」是两件事,合成一个标记会吃掉一条兜底路径:撤回失败时调用方
   //   要退一句中性收尾(engine 的 dropAckCard),而 recall 若把 finish 一并封死,那张卡就
@@ -195,8 +196,9 @@ function createCardWriter({
   let pushes = 0         // 流式帧 cardElement.content
   let fulls = 0          // 整卡更新 card.update
   let closes = 0         // 关流式 card.settings
-  let lastSeen = ''      // 最近一次收到的累积文本(判重用)
-  let confirmedText = null // 只记录平台确认过的正文,不能把已派发当成已送达
+  const resumes = initialText ? 1 : 0 // Confirmed pre-writer streaming enable.
+  let lastSeen = initialText // Seed only after the snapshot's create/post have been confirmed.
+  let confirmedText = initialText || null // 只记录平台确认过的正文,不能把已派发当成已送达
   let chain = Promise.resolve()
   let finishResult = null
   let boundaryError = null
@@ -363,7 +365,7 @@ function createCardWriter({
           // ⚠ 这行必须打在**收尾之后**:收尾自己那一次调用(整卡更新 / 关流式)就发生在这个
           // 回调里。原先它打在回调外、且只报节流器的派发次数 ⇒ 降级后的整卡更新与收尾那次
           // 全在账外(实测漏计 ≈44 次/天)。注释写着「配额账可实测」,那就得真能对上账。
-          log(`card ops: ${pushes + fulls + closes} 次调用(流式 ${pushes} · 整卡 ${fulls} · 关流式 ${closes})`)
+          log(`card ops: ${pushes + fulls + closes + resumes} 次调用(流式 ${pushes} · 整卡 ${fulls} · 关流式 ${closes}${resumes ? ` · 恢复流式 ${resumes}` : ''})`)
         }
       }, { terminal: true })
       return finishResult
@@ -371,7 +373,7 @@ function createCardWriter({
     // recall:先断掉后续流式帧再去删消息。⚠ 只冻结不收尾 —— 撤不掉时调用方还要退一句中性收尾。
     markClosed() { frozen = true; flushedRevision = -1 },
     settle: () => chain.then((result) => { if (boundaryError) throw boundaryError; return result }),
-    stats: () => ({ pushes, fullUpdates: fulls, closes, calls: pushes + fulls + closes, streamOpen, seq }),
+    stats: () => ({ pushes, fullUpdates: fulls, closes, calls: pushes + fulls + closes + resumes, streamOpen, seq }),
   }
 }
 
@@ -858,9 +860,10 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
     // effect. `finish` flips streaming_mode off so the card settles.
     // All ops are serialized so the per-card `sequence` stays strictly increasing.
     async createStreamingCard(replyCtx, { title = 'sbot', operationBoundary = null,
-      operationKey = null } = {}) {
+      operationKey = null, initialText = '' } = {}) {
       const chatId = replyCtx && replyCtx.chatId
       if (!chatId) return null
+      if (typeof initialText !== 'string') throw new TypeError('card initial text must be a string')
       if (operationBoundary && (typeof operationBoundary !== 'function' ||
           typeof operationKey !== 'string' || !operationKey ||
           Buffer.byteLength(operationKey) > 256)) {
@@ -870,8 +873,8 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
       // No header — the reply card shows just the answer body (no "sbot" title line).
       const cardJson = {
         schema: '2.0',
-        config: { streaming_mode: true, summary: { content: '' }, streaming_config: { print_strategy: 'fast' } },
-        body: { elements: [{ tag: 'markdown', content: '', element_id: ELEM }] },
+        config: { streaming_mode: !initialText, summary: { content: '' }, streaming_config: { print_strategy: 'fast' } },
+        body: { elements: [{ tag: 'markdown', content: initialText, element_id: ELEM }] },
       }
 
       let cardId
@@ -900,6 +903,22 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
         const posted = await postCard(client, chatId, replyCtx && replyCtx.messageId, cardId,
           { operationBoundary, operationKey })
         msgId = posted
+        // A moved card is first delivered with its complete, static snapshot.
+        // Enable streaming only afterward: old text never enters the typewriter
+        // endpoint, and the next cumulative frame continues from this baseline.
+        if (initialText) {
+          const sequence = 1
+          const uuid = crypto.randomUUID()
+          await cardOperation(operationBoundary, operationKey, 'card.settings',
+            { cardId, sequence, uuid }, async () => {
+              const response = assertCardOk(await client.cardkit.v1.card.settings({
+                path: { card_id: cardId },
+                data: { settings: JSON.stringify({ config: { streaming_mode: true } }), sequence, uuid },
+              }), '恢复流式')
+              if (response?.code !== 0) throw new Error('恢复流式未确认:未返回 code=0')
+              return response
+            })
+        }
       } catch (e) {
         log('feishu card create error: ' + (e && e.message))
         if (operationBoundary) throw e
@@ -908,7 +927,8 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
 
       // 全部写操作交给写入器(流式窗口判断、序号分配、错误码检查都在它一处)。
       const writer = createCardWriter({ client, cardId, elementId: ELEM, log,
-        throttleMs: cardThrottleMs, operationBoundary, operationKey })
+        throttleMs: cardThrottleMs, operationBoundary, operationKey,
+        initialText, initialSequence: initialText ? 2 : 1 })
 
       return {
         durableTarget() {

package/src/recordedanswers.js

@@ -0,0 +1,27 @@
+'use strict'
+const fs = require('node:fs')
+const path = require('node:path')
+const { redact } = require('./core/redact')
+
+// Read only the bounded observation file. Never open/rewrite execution journals
+// or infer that a stored draft reached Feishu.
+function readRecordedAnswers({ dataDir, chatId, id = '' }) {
+  if (!path.isAbsolute(dataDir || '') || !chatId) throw new Error('缺少当前服务的数据目录或群信息，无法读取本机答复记录')
+  const file = path.join(dataDir, 'activity-v1.json')
+  let data
+  try {
+    if (fs.statSync(file).size > 12 * 1024 * 1024) throw new Error('size')
+    data = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (data.version !== 1 || !Array.isArray(data.rows) || data.rows.length > 256) throw new Error('format')
+  } catch { throw new Error('本机答复记录不存在或不可读；不能据此判断机器人没有回复') }
+  const rows = data.rows.filter(row => row && row.chatId === chatId && typeof row.id === 'string' &&
+    (!id || row.id === id || Array.isArray(row.receiptIds) && row.receiptIds.includes(id) ||
+      Array.isArray(row.messages) && row.messages.some(message => message?.sourceMessageId === id)))
+    .sort((a, b) => (b.ts || 0) - (a.ts || 0)).slice(0, id ? 1 : 10)
+  return { source: 'local-activity-v1', retention: '全服务最多保留最近 256 轮；每轮答复最多 16384 字符；旧记录可能没有消息 ID',
+    chatId, answers: rows.map(row => ({ id: row.id, ts: row.ts,
+      status: row.status, deliveryConfirmed: row.status === 'answered',
+      truncated: !!row.truncated, reply: redact(String(row.reply || ''), { pii: false }).slice(0, 16384),
+      sourceMessageIds: (Array.isArray(row.messages) ? row.messages : []).map(message => message?.sourceMessageId).filter(id => typeof id === 'string') })) }
+}
+module.exports = { readRecordedAnswers }

package/src/runtimefacts.js

@@ -0,0 +1,11 @@
+'use strict'
+
+// Supported surfaces of the release host. These are facts passed to the core
+// renderer, not an alternative implementation of core policy.
+const GROUP_COMMANDS = Object.freeze(['/help', '/status', '/model', '/new', '/hud', '/issue', '/skip', '/stop'])
+const RUNTIME_ENTRY = require('node:path').join(__dirname, '..', 'bin', 'sintbot-v2.js')
+const quoteShell = value => "'" + String(value).replace(/'/g, "'\\''") + "'"
+function runtimeCommand(entry = RUNTIME_ENTRY, node = process.execPath) {
+  return `${quoteShell(node)} ${quoteShell(entry)}`
+}
+module.exports = { GROUP_COMMANDS, RUNTIME_ENTRY, runtimeCommand }

package/src/ui/console.html

@@ -2621,7 +2621,7 @@ const RUNTIME_UI_TEXT={
   "paused": "已暂停：不接收本群新消息，配置与会话保留。",
   "resume": "恢复本群：重新接收本群消息，配置与会话保留。",
   "resumeLabel": "恢复",
-  "steer": "Codex 与 Claude Code 默认开启忙时跟进；长命令执行期间的补充会在工具步骤之间读取。只有确认模型已读取才显示已加入；不支持此能力时排队。控制台插话仅空闲时可用。",
+  "steer": "Codex 与 Claude Code 默认开启忙时跟进；长命令执行期间的补充会在工具步骤之间读取。只有确认模型已读取才显示已加入；不支持此能力时排队。控制台插话同样支持忙时跟进；关闭或暂不支持时排队。",
   "preview": "当前版本未接入预览服务。",
   "providers": "可添加模型，修改型号、端点、密钥、思考深度与推理强度，测试、隐藏或拖动排序；各群的模型在「群·项目」里切换。改型号、后端或端点时，用它的群须空闲，并会开始新的一段对话；默认模型和群正在用的模型不能隐藏。移除模型暂不可用。",
   "providersView": "当前可查看模型配置与登录状态；各群的模型在「群·项目」里切换。添加或修改模型暂不可用。",
@@ -3339,18 +3339,17 @@ function sayPlan(chatId,reply){
 function runsCodex(g){const pr=(S.providers||[]).find(pp=>pp.name===g.effectiveProvider);return !!pr&&pr.runner==='codex';}
 function sayAge(ms){const m=Math.floor((ms||0)/60e3);if(m<1)return '不到 1 分钟';if(m<60)return m+' 分钟';return Math.floor(m/60)+' 小时'+(m%60?' '+(m%60)+' 分钟':'');}
 let sayRefresh=null; // 浮层开着时,概览的实时刷新顺手重算一遍(打字的这会儿任务可能刚好跑完)
-/* 持久处理流程(当前版本)的插话只有一种形态:空闲群、这句话进群、回复进群。群忙 / 待人工 / 升级中等
-   直接说明白、按钮不可点 —— 不再说「加入当前任务 / 排队」,那是旧流程的行为。原因由服务端实时状态
-   (live.groups[chatId].sayBlocked,与插话接口同一个判据)给出;没有实时状态时以接口回报为准。 */
+/* 插话按服务端准入显示阻塞原因；正常忙时允许提交，是否已加入只以模型读取确认判断。 */
 const SAY_V1={
-  ok:'当前版本的插话:这句话(标着「管理员」)和它做完的回复都会发进群;静默插话、不回复的插话和群忙时的插话暂不支持。',
-  busy:'该群有任务进行中,当前版本的插话不排队也不加入当前任务,等它结束再插。',
+  ok:'这句话(标着「管理员」)和回复都会发进群。任务进行中也可以插话；确认模型读取后才算已加入。',
+  busy:'该群正在停止、跳过或处理未结记录,请稍后再插话。',
+  'queue-full':'该群等待处理的消息已满,请稍后再插话。',
   held:'该群上一个任务结果不明,已暂停处理、等待人工确认;现在不能插话。',
   upgrading:'正在升级,现在不能插话,请一分钟后再试。',
   paused:'这个群项目已暂停,先恢复再插话。',
   closed:'服务正在启动或停止,或该群当前未开放;现在不能插话。'
 };
-function sayV1Blocked(chatId){const lv=((S.live||{}).groups||{})[chatId]||{};return lv.sayBlocked||(lv.busy?'busy':null);}
+function sayV1Blocked(chatId){const lv=((S.live||{}).groups||{})[chatId]||{};return lv.sayBlocked||null;}
 /* 每次提交一个 32 位十六进制幂等键:同一段文字没成功前重点一次,沿用同一个键,服务端据此不重复处理 */
 function sayRequestId(){const a=new Uint8Array(16);crypto.getRandomValues(a);return Array.from(a,b=>b.toString(16).padStart(2,'0')).join('');}
 /* 「向群里插一句」浮层。入口在概览「群·项目」每一行的 ✎ —— 动作长在对象身上,
@@ -3380,12 +3379,13 @@ function openSay(chatId){
   const v1=!!S.runtimeCapabilities; let sending=false, req=null;
   // 当前版本两个开关固定勾上:只支持「这句话进群 + 回复进群」,开关留着,让人看见这句会以什么样子出现
   if(v1){ for(const c of [sw,rp]){ c.checked=true; c.disabled=true; c.parentElement.title='当前版本固定:这句话和回复都发进群'; } }
-  const preview=()=>{ const a=sw.checked,b=rp.checked, plan=v1?null:sayPlan(chatId,b);
+  const preview=()=>{ const a=sw.checked,b=rp.checked, plan=sayPlan(chatId,b);
     if(v1){
       const why=sayV1Blocked(chatId), lv=((S.live||{}).groups||{})[chatId]||{};
-      bz.innerHTML=why==='busy'?`<span class="dot"></span>${lv.busy?'正在处理任务 · 已 '+sayAge(lv.sinceMs):'正在收尾'}`:why==='held'?'<span class="dot"></span>待人工确认':'';
-      pv.textContent=why?(SAY_V1[why]||SAY_V1.closed):SAY_V1.ok;
-      if(!sending){ go.disabled=!!why; goTxt.textContent=why?'暂不能插':'插入'; }
+      bz.innerHTML=lv.busy?`<span class="dot"></span><span>${lv.finalizing?'正在收尾':'正在处理任务'}</span> · ${fmtDur(lv.sinceMs)}`:why==='held'?'<span class="dot"></span>待人工确认':'';
+      const detail=lv.busy?(lv.followups?'将尝试跟进当前任务；长命令执行期间需等待工具步骤结束，实际进度请查看实时活动。':'当前任务暂不接收跟进，这句话会排队处理。'):'';
+      pv.innerHTML=why?esc(SAY_V1[why]||SAY_V1.closed):`<span>${esc(detail)}</span> <span>${esc(SAY_V1.ok)}</span>`;
+      if(!sending){ go.disabled=!!why; goTxt.textContent=why?'暂不能插':lv.busy?(lv.followups?'发送补充':'排队'):'插入'; }
       return;
     }
     const vis = a&&b ? '群里会看到:你插的这句话(标着「管理员」)和它做完的回复。'
@@ -3422,7 +3422,10 @@ function openSay(chatId){
       // 回报照实说清两件事:这句**落在哪**(服务端按引擎实际落点回报),以及群里会/不会出现什么 —— 只说「已插入」等于没说
       const vis = inj&&inj.show ? (inj.reply?'群里能看到这句话和回复':'群里只看到这句话') : (inj&&inj.reply?'群里只会出现回复':'群里不会有任何动静');
       const w=(inj&&inj.where)||{};
-      const head = w.state==='joined' ? '已加入当前任务'+(inj&&inj.show?' · 回复卡片会跟到这句话下面':'')
+      const head = w.state==='following' ? '已受理 · 等待模型读取，尚未确认加入'
+        : w.state==='accepted' ? '已受理 · 处理状态请查看实时活动'
+        : w.state==='done' ? '已处理'
+        : w.state==='joined' ? '已加入当前任务'+(inj&&inj.show?' · 回复卡片会跟到这句话下面':'')
         : w.state==='queued' ? (w.join ? '已排队 · 当前任务一就绪就会加入' : '群正忙,已排队'+(w.ahead?`(前面还有 ${w.ahead} 条)`:'')+' · 当前任务结束后处理')
         : '已插入';
       toast(head+' · '+vis,'ok');
@@ -4302,6 +4305,10 @@ updateThemeBtn();
 /* I18N_DICT_BEGIN —— 合并翻译片段时整块替换这两个数组,不要改此标记之外的代码
    ⚠ 正则一律 ^…$ 整串、不加 g 标志;更具体的条目必须排在泛化条之前。 */
 const I18N_EN=[
+  ["正在处理任务", "Task in progress"],
+  ["已受理", "Accepted"],
+  ["等待模型读取，尚未确认加入", "Waiting for the model to read it; not yet confirmed joined"],
+  ["处理状态请查看实时活动", "Check live activity for processing status"],
   ["需要处理", "Needs attention"],
   ["可绑定新群，修改模型、项目目录、权限、数据输出和忙时跟进；该群须没有进行中的任务和未结记录。切模型或项目会开始新的一段对话。停止任务和开新会话在「概览」，开新会话须等该群空闲。群里发 /model 也能切换模型。", "Bind new groups and change the model, project folder, permissions, data display and busy-turn followups of a group with no running task or unsettled record. Changing the model or project starts a new conversation. Stop tasks and start new sessions in Overview; a new session needs the group to be idle. Members can also switch models with /model in the group."],
   ["当前支持飞书文字消息、忙时跟进、任务回复和停止。定时任务、生图、群消息管理、画布与预览暂未接入。", "Feishu text messages, busy-turn followups, task replies and stopping are supported. Schedules, image generation, group message management, canvas and previews are unavailable."],
@@ -4311,7 +4318,7 @@ const I18N_EN=[
   ["已暂停：不接收本群新消息，配置与会话保留。", "Paused: no new group messages are accepted; configuration and sessions are retained."],
   ["恢复本群：重新接收本群消息，配置与会话保留。", "Resume this group: its messages are accepted again; configuration and sessions are retained."],
   ["恢复", "Resume"],
-  ["Codex 与 Claude Code 默认开启忙时跟进；长命令执行期间的补充会在工具步骤之间读取。只有确认模型已读取才显示已加入；不支持此能力时排队。控制台插话仅空闲时可用。", "Busy-turn followups are on by default for Codex and Claude Code. Followups are read between tool steps; a long command must finish first. Joined means the model has read the message. Unsupported clients queue followups. Console messages require an idle group."],
+  ["Codex 与 Claude Code 默认开启忙时跟进；长命令执行期间的补充会在工具步骤之间读取。只有确认模型已读取才显示已加入；不支持此能力时排队。控制台插话同样支持忙时跟进；关闭或暂不支持时排队。", "Busy-turn followups are on by default for Codex and Claude Code. Followups are read between tool steps; a long command must finish first. Joined means the model has read the message. Unsupported clients queue followups. Console messages also support busy-turn followups, or queue when followups are disabled or unavailable."],
   ["当前版本未接入预览服务。", "Preview services are unavailable in this version."],
   ["当前可查看模型配置与登录状态；各群的模型在「群·项目」里切换。添加或修改模型暂不可用。", "Model configuration and login status are shown here. Switch each group's model under Groups. Adding or changing models is unavailable."],
   ["可添加模型，修改型号、端点、密钥、思考深度与推理强度，测试、隐藏或拖动排序；各群的模型在「群·项目」里切换。改型号、后端或端点时，用它的群须空闲，并会开始新的一段对话；默认模型和群正在用的模型不能隐藏。移除模型暂不可用。", "Add models; change their model id, endpoint, key, thinking depth and reasoning effort; test, hide or drag to reorder them. Switch each group's model under Groups. Changing a model id, backend or endpoint needs the groups using it to be idle and starts a new conversation for them. The default model and models in use by a group cannot be hidden. Removing models is unavailable."],
@@ -4388,6 +4395,12 @@ const I18N_EN=[
   ["此群当前未开放，未开新会话","This group is not open right now; no new session was started."],
   ["还没有群项目 · 去「群·项目」配置","No group projects yet · set one up on the Groups · Projects page"],
   ["健康","Health"],
+  ["模型已隐藏，不能试运行","This model is hidden and cannot be tested."],
+  ["服务写入权限已失效，试运行结果未保存","The service lost write access; the trial result was not saved."],
+  ["服务未就绪或正在维护，暂不能试运行","The service is not ready or is under maintenance; trials are unavailable."],
+  ["试运行或模型并发名额已满，请稍后重试","The trial or model concurrency limit is reached. Try again later."],
+  ["当前服务未接入试运行并发准入","This service has no trial admission control."],
+  ["试运行进程关闭状态未知，结果未保存，并发名额已保留","Trial process closure is unknown; the result was not saved and its capacity slot remains reserved."],
   ["并发","Concurrency"],
   ["活动","Active"],
   ["· 无上限","· No limit"],
@@ -4986,6 +4999,14 @@ const I18N_EN=[
   ["输入文件夹名","Enter a folder name"],
   ["要它做什么,像跟人说话那样写…","What should it do? Write it the way you would tell a person…"],
   ["群里可见","Visible in the group"],
+  ["发送补充", "Send followup"],
+  ["将尝试跟进当前任务；长命令执行期间需等待工具步骤结束，实际进度请查看实时活动。", "Will try to follow up on the current task. Long commands must finish first; check live activity for progress."],
+  ["当前任务暂不接收跟进，这句话会排队处理。", "The current task is not accepting followups; this message will queue."],
+  ["已受理 · 等待模型读取，尚未确认加入", "Accepted · waiting for the model to read it; not yet confirmed joined"],
+  ["已受理 · 处理状态请查看实时活动", "Accepted · check live activity for processing status"],
+  ["该群等待处理的消息已满,请稍后再插话。", "The message queue is full. Try again shortly."],
+  ["该群等待处理的消息已满,请稍后再插话", "The message queue is full. Try again shortly."],
+  ["该群正在停止、跳过或处理未结记录,请稍后再插话", "This group is stopping, skipping, or settling pending records. Try again shortly."],
   ["你插的这句话本身要不要发进群(会标着「管理员」)","Whether the line you interject is itself posted in the group (marked \"admin\")"],
   ["插话","Interject"],
   ["它做完之后的回复要不要发进群;取消后连报错也不会说","Whether its reply is posted in the group when it finishes; untick and even errors stay silent"],
@@ -5000,8 +5021,8 @@ const I18N_EN=[
   ["什么都不会出现","shows nothing at all"],
   [",连出错也不会说 —— 状态去「实时活动」看。",", not even errors — check the status under \"Live activity\"."],
   ["插入中…","Inserting…"],
-  ["当前版本的插话:这句话(标着「管理员」)和它做完的回复都会发进群;静默插话、不回复的插话和群忙时的插话暂不支持。","In this version a console message always posts the line (marked \"admin\") and its reply to the group; silent messages, messages without a reply and messages to a busy group are unavailable."],
-  ["该群有任务进行中,当前版本的插话不排队也不加入当前任务,等它结束再插。","This group has a task in progress. In this version a console message neither queues nor joins the current task; send it once the task ends."],
+  ["这句话(标着「管理员」)和回复都会发进群。任务进行中也可以插话；确认模型读取后才算已加入。","The line (marked \"admin\") and its reply are posted to the group. You can send while a task is running; joined means the model has read it."],
+  ["该群正在停止、跳过或处理未结记录,请稍后再插话。","This group is stopping, skipping, or settling pending records. Try again shortly."],
   ["该群上一个任务结果不明,已暂停处理、等待人工确认;现在不能插话。","The outcome of this group's last task is unknown; the group is paused for operator review, so console messages are unavailable."],
   ["正在升级,现在不能插话,请一分钟后再试。","An upgrade is in progress; try the console message again in a minute."],
   ["这个群项目已暂停,先恢复再插话。","This group project is paused; resume it before sending a console message."],
@@ -5967,7 +5988,7 @@ function disableRuntimeControl(el,reason){
 function applyRuntimeCapabilities(){
   if(!S||!S.runtimeCapabilities)return;
   document.querySelectorAll(RUNTIME_DISABLED_SELECTORS).forEach(el=>disableRuntimeControl(el,RUNTIME_UI_TEXT.unavailable));
-  // 插话照服务端白名单放行(第 1 版只接空闲群,忙不忙在浮层里按实时状态说)
+  // 插话照服务端白名单放行(忙时去向在浮层里按实时状态说明)
   if(!runtimeAllows('POST','/api/groups/say'))document.querySelectorAll('[data-osay]').forEach(el=>disableRuntimeControl(el,RUNTIME_UI_TEXT.unavailable));
   if(!runtimeAllows('POST','/api/providers/order'))document.querySelectorAll('#pgrid .drag').forEach(el=>{el.draggable=false;el.title=trText(RUNTIME_UI_TEXT.unavailable);});
 }

package/src/ui/liveactivity-client.js

@@ -121,14 +121,14 @@ const activityPanel = (() => {
     state.dataset.status = g.held || g.queueFaulted ? 'attention' : g.busy ? 'running' : 'idle'
     if (g.busy) text(state, state.textContent + ' ' + Math.floor((g.sinceMs || 0)/1000) + 's')
     if (g.queue) text(state, state.textContent + ' · ' + tr('排队 ','Queued ') + g.queue)
-    text(b.children[0], g.model)
+    text(b.children[0], g.model || tr('执行器默认（未回报实际型号）','Executor default (actual model unknown)'))
     text(b.children[1], tr('思考深度 · ','Reasoning · ') + (g.reasoningEffort || tr('默认','Default')))
     b.children[1].title = tr('当前模型配置；未指定时使用模型默认值','Current model configuration; unspecified uses the model default')
     const blocked = !S?.live?.running || g.paused || g.held || g.queueFaulted
     const busy = g.busy || g.pending > 0 || g.queue > 0 || g.waitingForCapacity || g.finalizing
     for (const [action,zh,eng] of [['say','插话','Message'],['stop','停止任务','Stop task'],['new','新会话','New session']]) {
       const button = n.querySelector('[data-action='+action+']')
-      button.disabled = actionPending.has(g.chatId + ':' + action) || blocked || (action === 'stop' ? !busy : !!busy || action === 'say' && !!g.sayBlocked)
+      button.disabled = actionPending.has(g.chatId + ':' + action) || blocked || (action === 'stop' ? !busy : action === 'new' ? !!busy : !!g.sayBlocked)
       button.setAttribute('aria-label',tr(zh,eng) + ' · ' + g.name)
       button.title = tr(zh,eng) + ' · ' + (button.disabled ? tr('当前状态不可操作','Unavailable in the current state') : action === 'say' ? tr('这句话和回复都会发进该群','Your message and reply will be sent to this group') : action === 'new' ? tr('开始新会话，清除当前会话上下文','Start a new session with fresh context') : tr('停止当前任务，保留会话','Stop the task and keep the session'))
     }

package/src/ui/liveactivity.js

@@ -34,11 +34,12 @@ function createLiveActivity({ file, now = Date.now, log = () => {}, canWrite = (
       for (const id of oldest.receiptIds) aliases.delete(key(oldest.chatId, id))
     }
   }
-  function receive({ chatId, receiptId, text, sender, acceptedAt }) {
+  function receive({ chatId, receiptId, sourceMessageId, text, sender, acceptedAt }) {
     if (locate(chatId, receiptId)) return
     const row = { id: receiptId, chatId, receiptIds: [receiptId], ts: acceptedAt || now(),
       status: 'queued', text: clean(text, 160), sender: clean(sender, 120),
-      messages: [{ id: receiptId, text: clean(text), sender: clean(sender, 120), state: 'accepted' }],
+      messages: [{ id: receiptId, sourceMessageId: typeof sourceMessageId === 'string' ? sourceMessageId : null,
+        text: clean(text), sender: clean(sender, 120), state: 'accepted' }],
       truncated: String(text || '').length > TEXT, reply: '', tools: [], milestones: [] }
     rows.set(key(chatId, receiptId), row); touch(row, true)
   }

package/src/ui/serverbase.js

@@ -18,7 +18,7 @@ const { createLedger } = require('../core/ledger')
 const { normalizeTz, isValidTz, tzOffsetMin, tzParts } = require('../core/time')
 // Runner dispatch (Claude vs Codex by provider.runner) — so 测试/试跑 run codex
 // providers on the Codex CLI, not Claude. Same module the daemon/CLI use.
-const { runTurn, probeVersion } = require('../agent/runner')
+const { runTurn, probeVersion, isClosedRunnerResult, isClosedRunnerError } = require('../agent/runner')
 const codexstatus = require('../agent/codexstatus') // codex 订阅登录态 + 用量(卡片「验证登录」)
 const claudestatus = require('../agent/claudestatus') // Claude 订阅登录态(卡片「检测登录」· doctor 同源)
 const claudemodels = require('../agent/claudemodels') // Claude 模型候选(仅登录后给)
@@ -405,9 +405,9 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
   // each click doesn't spawn a `claude --version` child.
   let probeCache = null // { val, ts }
   const probeCached = async (bin) => {
-    if (probeCache && Date.now() - probeCache.ts < 60_000) return probeCache.val
+    if (probeCache && probeCache.bin === bin && Date.now() - probeCache.ts < 60_000) return probeCache.val
     const val = await probeVersion(bin)
-    probeCache = { val, ts: Date.now() }
+    probeCache = { val, bin, ts: Date.now() }
     return val
   }
   // Same 60s cache for the codex CLI probe — only run when a codex provider exists.
@@ -522,7 +522,8 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
         icons: g.workdir ? design.projectIconCard(g.workdir) : null, crons: (Array.isArray(g.crons) ? g.crons : []).map((c) => ({ ...c, human: describeTask(c, nowTzStr), expired: cronExpired(c.at) })), exists: g.workdir ? fs.existsSync(g.workdir) : false }))
     // Console overview health — deliberately minimal: backend CLI 探针 + "有无可用模型/群"。
     // Codex CLI 行仅在配了 codex provider 时出现(与 doctor 一致);`sbot doctor` 保留全量。
-    const v = runtimePolicy ? null : await probeCached(cfg.agent.bin)
+    const hasClaude = providers.some((p) => !p.hidden && p.runner !== 'codex')
+    const v = !runtimePolicy || hasClaude ? await probeCached(cfg.agent.bin) : null
     const hasCodex = providers.some((p) => !p.hidden && p.runner === 'codex')
     const cv = hasCodex ? await probeCodexCached() : null
     // 「可用模型」= 能用的,不只是配了的(1.0.3;此前没登录的 Claude 订阅、试跑失败的 key 都算在内)。
@@ -684,14 +685,18 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
     const cfg = loadConfig(configPath); applyProxyEnv(cfg)
     const provider = cfg.providers[name]
     if (!provider) return { ok: false, error: `unknown provider '${name}'` }
+    if (provider.hidden) return { ok: false, error: '模型已隐藏，不能试运行' }
     if (provider.baseUrl && !provider.apiKey) return { ok: false, error: 'no apiKey' }
     const ac = new AbortController()
+    let lease, closed = false
+    try { lease = runtimePolicy ? await runtimePolicy.beginTrial(ac) : null }
+    catch (error) { return { ok: false, error: error.message } }
     // codex 跑整轮 GPT(冷启动 + reasoning)远慢于 Anthropic 的快问快答;给更长的测试超时。
     // 中止现在真生效(codexcode 强制收尾),超时到点能掐断,不会再干等到自然结束。
     const timer = setTimeout(() => ac.abort(), provider.runner === 'codex' ? 180000 : 60000)
     const t0 = Date.now()
     try {
-      const { result } = await runTurn({
+      const execution = await runTurn({
         bin: cfg.agent.bin,
         prompt: prompt || verify.TRIAL_PROMPT,
         provider,
@@ -699,13 +704,22 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
         permissionMode: cfg.agent.permissionMode,
         signal: ac.signal, // a one-line reply — needs no tools, so no allow list
       })
+      closed = isClosedRunnerResult(execution)
+      const { result } = execution
+      if (lease && !closed) throw new Error('试运行进程关闭状态未知，结果未保存，并发名额已保留')
+      lease?.assertWritable()
       const ok = !(result && result.isError)
       verify.recordTurn(provider, ok, (result && result.text) || '', vopts) // doctor / 概览据此报「能用」或「key 不对」
       return { ok, model: provider.model, reply: (result && result.text) || '(no text)', ms: Date.now() - t0 }
     } catch (e) {
-      verify.recordTurn(provider, false, (e && e.message) || String(e), vopts)
+      closed ||= isClosedRunnerError(e)
+      if (!lease) verify.recordTurn(provider, false, (e && e.message) || String(e), vopts)
+      else if (closed) {
+        try { lease.assertWritable(); verify.recordTurn(provider, false, e.message || String(e), vopts) }
+        catch { /* lease loss must never write verification evidence */ }
+      }
       return { ok: false, error: (e && e.message) || String(e), ms: Date.now() - t0 }
-    } finally { clearTimeout(timer) }
+    } finally { clearTimeout(timer); lease?.finish(closed) }
   }
 
   // ── request handling ──────────────────────────────────────────────────────
@@ -1119,7 +1133,8 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
           const why = { 'no-daemon': '守护进程没在跑(纯配置模式)—— 插话需要它在线', paused: '这个群项目已暂停,先恢复再插话', unbound: '没有这个群项目', 'inject-failed': '注入失败(守护进程侧报错,看日志)',
             // 持久处理流程(第 1 版插话)的拒绝原因。shown-failed 之前的几条在发群消息之前就拒,群里没有任何字;
             // 从 shown-failed 起,群里可能已经有那行「【管理员】…」
-            busy: '该群有任务进行中,当前版本的插话不排队也不加入当前任务,等它结束再插',
+            busy: '该群正在停止、跳过或处理未结记录,请稍后再插话',
+            'queue-full': '该群等待处理的消息已满,请稍后再插话',
             held: '该群上一个任务结果不明,已暂停处理、等待人工确认;插话未执行',
             recovering: '该群上一个任务出错,正在收尾;插话未执行,请稍后再试',
             upgrading: '正在升级,插话未执行,请一分钟后再试',
@@ -1130,7 +1145,7 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
             'request-id': '这次提交缺少有效的提交编号,请刷新控制台后再试',
             empty: '内容不能为空',
             'shown-failed': '群里那行「【管理员】…」没能确认发出(失败或超时),插话未执行;即使群里随后出现这行,它也不会被处理',
-            'busy-after-post': '这行字发进群时该群刚好开始了别的任务,这句没有处理;等它结束后原样再点一次插入,会沿用群里已有的那行',
+            'busy-after-post': '这行字发进群时该群正在停止或处理未结记录,这句没有处理;稍后原样再点一次插入,会沿用群里已有的那行',
             refused: '该群拒收了这句(原因已回复在群里那行下面);插话未执行',
             quarantined: '这句的来源已被隔离,未执行',
             unconfirmed: '这行字已发进群,但没在 5 秒内确认登记,结果以群里和「实时活动」为准;原样再点一次插入不会重复处理' }[r.reason] || '插话失败'