sintbot 1.4.10 → 1.4.12

package/CHANGELOG.en.json

@@ -1,4 +1,30 @@
 [
+  {
+    "version": "1.4.12",
+    "date": "2026-11-10",
+    "name": "Projects and live activity",
+    "items": [
+      {
+        "t": "Projects, concurrency and context in one panel",
+        "d": "Show project paths, runtime, configured reasoning and context together; restore row icon actions and display task tools, reply and compact metrics after selecting a group. Remove the top available-controls notice."
+      },
+      {
+        "t": "Actual task details and reported context",
+        "d": "Shows requests, follow-ups, progress, replies and the latest reported context. Reuses existing events without extra model calls; details load on demand and restored samples are labeled historical."
+      }
+    ]
+  },
+  {
+    "version": "1.4.11",
+    "date": "2026-11-10",
+    "name": "Unified busy follow-ups",
+    "items": [
+      {
+        "t": "Busy follow-ups default on for Codex and Claude Code",
+        "d": "One per-group switch preserves explicit disabling. Claude follow-ups join after confirmed reading, and continuation answers form one final reply. Recalling handed-over input cancels the whole task; uncertain delivery is never replayed."
+      }
+    ]
+  },
   {
     "version": "1.4.10",
     "date": "2026-11-10",

package/CHANGELOG.json

@@ -1,4 +1,30 @@
 [
+  {
+    "version": "1.4.12",
+    "date": "2026-11-10",
+    "name": "群项目与实时活动",
+    "items": [
+      {
+        "t": "群项目、并发与上下文集中展示",
+        "d": "群项目、运行耗时、项目路径、模型思考深度与上下文集中展示；恢复群行图标操作，选择群后查看任务，详情采用工具标签、回复正文和紧凑统计。 移除顶部当前可用操作说明卡片。"
+      },
+      {
+        "t": "真实任务详情与可信上下文",
+        "d": "展示请求、补话、进度、回复及最近上报的上下文。使用既有事件，不额外请求模型；详情按需加载，重启后历史采样明确标注。"
+      }
+    ]
+  },
+  {
+    "version": "1.4.11",
+    "date": "2026-11-10",
+    "name": "统一忙时跟进",
+    "items": [
+      {
+        "t": "Codex 与 Claude Code 默认开启忙时跟进",
+        "d": "统一按群开关并持久保存关闭；Claude 确认读取后加入任务，续轮答案合并为一条最终回复。撤回已交给执行器的补话取消整轮，未知送达不重放。"
+      }
+    ]
+  },
   {
     "version": "1.4.10",
     "date": "2026-11-10",

package/bin/sintbot-v2.js

@@ -114,6 +114,7 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
   let configControl
   let updater
   let liveTransport
+  let activity
   let onSigint, onSigterm
   try {
     const migrationFence = require('../src/c2migration').loadC2MigrationFence({ stateDir, routes })
@@ -139,6 +140,9 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
     // All group Engines must share this exact object: separate Store caches
     // would overwrite sibling sessions when they save the same state file.
     const store = new StateStore(path.join(stateDir, 'state.json'))
+    activity = require('../src/ui/liveactivity').createLiveActivity({
+      file: path.join(stateDir, 'activity-v1.json'), canWrite: assertWriterLock,
+      log: message => process.stderr.write(`Console · ${message}\n`) })
     const closeChecks = {
       claude: require('../src/agent/claudecode').isClosedRunnerResult,
       'codex-exec': require('../src/agent/codexcode').isClosedRunnerResult,
@@ -154,11 +158,12 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
     const limits = { maxEventCount: 100_000, maxJournalBytes: 64 * 1024 * 1024,
       maxCompletionEvents: 1_000, maxCompletionBytes: 8 * 1024 * 1024 }
     let finishing = false
-    const finish = result => {
+    const finish = async result => {
       if (finishing) return
       finishing = true
       ui?.close()
       updater?.close()
+      await activity?.close()
       lock.release()
       process.stderr.write(`C2 multi-group · ${result.reason}; platform stopped=${result.platformStopped}; runner drained=${result.drained}\n`,
         () => process.exit(result.code))
@@ -230,7 +235,7 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
             return result
           }
           engine = new Engine({ ...cfg, groups: { [route.chatId]: route.group } }, {
-            store, log: message => process.stderr.write(`C2 v2 · ${message}\n`),
+            store, activity, log: message => process.stderr.write(`C2 v2 · ${message}\n`),
             durableV2Runtime: runtime, durableV2Payloads: handles,
             durableV2StartTurn: startTurn, durableV2ApplyLocalEffect: applyLocalEffect,
             durableV2VerifyRunnerClosed: ({ result, error }) => result
@@ -284,7 +289,7 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
     process.on('SIGTERM', onSigterm)
     if (uiEnabled && !preflightOnly) {
       ui = require('../src/c2console').createC2Console({
-        configPath: cfg._path, stateDir, host: uiHost,
+        configPath: cfg._path, stateDir, host: uiHost, activity, store,
         getConfig: () => cfg, getBindings: () => service.bindings,
         getHeld: () => service.held, getCapacity: () => capacity.snapshot(),
         getConnHealth: () => liveTransport?.platform.connHealth?.() || {},
@@ -339,6 +344,7 @@ async function startMultiGroupService({ installation, preflightOnly, uiEnabled =
     throw error
   } finally {
     if (!running) {
+      await activity?.close()
       updater?.close()
       if (onSigint) process.off('SIGINT', onSigint)
       if (onSigterm) process.off('SIGTERM', onSigterm)

package/docs/AI-ASSISTED-INSTALL.md

@@ -1,4 +1,4 @@
-# Install SintBot 1.4.10 with an AI assistant
+# Install SintBot 1.4.12 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.10 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.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.
 ```

package/docs/install.md

@@ -1,4 +1,4 @@
-# Install SintBot 1.4.10
+# Install SintBot 1.4.12
 
 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.10` into `~/.local/share/sintbot`, and verifies the entry, built-in core and Feishu module. Continue when you see `Installed and verified SintBot 1.4.10`. No sudo is needed.
+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.
 
 To preview, append `-s -- --dry-run`. To choose another location, set `SINTBOT_INSTALL_DIR` and adjust the executable paths below.
 
@@ -51,7 +51,7 @@ Create a private directory with `mkdir -p ~/.sbot && chmod 700 ~/.sbot`, then cr
       "provider": "codex",
       "workdir": "/absolute/path/to/first/project",
       "permissionMode": "dontAsk",
-      "codexSteer": true
+      "steer": true
     },
     "oc_REPLACE_WITH_SECOND_CHAT_ID": {
       "platform": "feishu",
@@ -99,13 +99,15 @@ Any text message is a task. Replies arrive in a card that appears once the model
 | `/issue text` | Log feedback; review and close it in the console overview |
 | `/help` | List commands, with this group's project and model |
 
-Send a command as a message of its own; except for `/issue` and `/model`, do not add other text after it. If the Feishu app also subscribes to the message-recall event (the console's setup guide recommends it), recalling your own message cancels it: a queued message is dropped, and the running task stops if that message alone started it; in Codex groups, recalling a message that was added to the running task cancels the whole task.
+Send a command as a message of its own; except for `/issue` and `/model`, do not add other text after it. If the Feishu app also subscribes to the message-recall event (the console's setup guide recommends it), recalling your own message cancels it: a queued message is dropped, and the running task stops if that message alone started it; recalling a follow-up handed to either runner cancels the whole task, including accepted input not yet read.
 
-Messages sent while a task runs are added to that task in Codex groups (`codexSteer: true`) and queued in Claude Code groups. 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.
+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.
 
 ## 6. Console
 
-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, 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.
+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.
 

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

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

package/docs/zh-CN/install.md

@@ -1,4 +1,4 @@
-# 安装 SintBot 1.4.10
+# 安装 SintBot 1.4.12
 
 [English](../install.md) · 简体中文
 
@@ -10,7 +10,7 @@
 curl -fsSL https://sintbot.com/install.sh | bash
 ```
 
-安装器会自动检查环境，把 `sintbot@1.4.10` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.10` 就可以继续。不需要 sudo。
+安装器会自动检查环境，把 `sintbot@1.4.12` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.12` 就可以继续。不需要 sudo。
 
 可选预览：在命令末尾加 `-s -- --dry-run`。要自定义安装位置，设置 `SINTBOT_INSTALL_DIR` 环境变量，并同步修改后面的可执行文件路径。
 
@@ -51,7 +51,7 @@ export FEISHU_APP_ID FEISHU_APP_SECRET
       "provider": "codex",
       "workdir": "/absolute/path/to/first/project",
       "permissionMode": "dontAsk",
-      "codexSteer": true
+      "steer": true
     },
     "oc_REPLACE_WITH_SECOND_CHAT_ID": {
       "platform": "feishu",
@@ -99,13 +99,15 @@ SINTBOT="$HOME/.local/share/sintbot/bin/sintbot"
 | `/issue 一句话` | 记下问题反馈，在控制台概览里查看和标记处理 |
 | `/help` | 查看可用命令，以及本群的项目和模型 |
 
-命令单独发一条；除 `/issue` 和 `/model` 外，后面不要跟别的字。如果飞书应用还订阅了消息撤回事件（控制台接入引导里建议订阅），撤回自己发的消息即取消那件事：还在排队的直接丢弃；当前任务只由这一条触发时会停下；Codex 群里撤回已补充进当前任务的那条，会连当前任务一起取消。
+命令单独发一条；除 `/issue` 和 `/model` 外，后面不要跟别的字。如果飞书应用还订阅了消息撤回事件（控制台接入引导里建议订阅），撤回自己发的消息即取消那件事：还在排队的直接丢弃；当前任务只由这一条触发时会停下；两种执行器中，撤回已交给执行器的补话均会取消整轮，包括已受理但尚未读取的补话。
 
-任务进行中再发的消息：Codex 群（`codexSteer: true`）会补充进当前任务，Claude Code 群会排队，等这一轮结束再处理。某一轮模型报错或没有结果时，只在本群提示重新发送，不会自动重试。某个群上一轮的结果无法确认时（例如回复是否送达不明），只暂停这个群，它收到新消息会回一句说明，其他群照常；不重放、不重试。
+Codex 和 Claude Code 的忙时跟进默认开启；`steer:false` 改为排队，显式 `steer` 优先于旧 Codex 开关。Claude Code 未提供所需输入能力时保留排队。长工具调用可能延迟读取；确认读取后回复卡才跟随补话，续轮答案合并为一条最终回复。某一轮模型报错或没有结果时，只在本群提示重新发送，不会自动重试。某个群上一轮的结果无法确认时（例如回复是否送达不明），只暂停这个群，它收到新消息会回一句说明，其他群照常；不重放、不重试。
 
 ## 6. 控制台
 
-带 `--ui` 启动后，在本机浏览器打开 `http://127.0.0.1:4600`。控制台可以查看各群状态（暂停的群显示「需要处理」）、停止任务、给空闲的群开新会话、绑定新群、给空闲的群切换模型或项目目录、添加和设置模型。要从局域网访问，先在控制台的设置里设访问密码，再开启局域网访问。
+概览合并群项目与并发信息，每行显示执行器、状态与耗时、项目目录、模型和配置的思考深度、最近上报的上下文用量。选择群后查看对应任务，展开任务查看工具、回复和用量。上下文是当前会话采样，不是累计消耗；容量未知或历史采样会明确标注。群行图标按当前状态提供插话、停止与新会话操作。
+
+带 `--ui` 启动后，在本机浏览器打开 `http://127.0.0.1:4600`。控制台可以查看各群状态、停止任务、给空闲的群开新会话、绑定新群、给空闲的群切换模型或项目目录、添加和设置模型。要从局域网访问，先在控制台的设置里设访问密码，再开启局域网访问。
 
 「设置 → 软件更新」会检查新版本。按上面前台方式运行时，卡片给出升级步骤：按 Ctrl-C 等待退出，重新运行一行安装命令，再用原来的命令启动。如果用你自己的 launchd 后台任务启动 SintBot，「现在升级」会等所有群空闲、记录结清后，把新版本装到 `~/.local/share/sintbot/releases/<版本>` 并切换过去；新版本 90 秒内没连上全部群会自动换回旧版。升级时窗口逐步显示进度，服务重启时页面自动重连，也可以放到后台继续。升级后首次启动会在每个在服务的群发一张版本公告卡，列出这一版的更新；不想播报就在「设置 → 软件更新」取消「升级后向群里播报」。
 

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.10
+  version=1.4.12
   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.10",
+  "version": "1.4.12",
   "private": false,
   "description": "Drive your Mac projects from Feishu groups with Codex or Claude Code, using a built-in agent core.",
   "bin": {
@@ -44,6 +44,7 @@
     "docs/zh-CN/install.md",
     "install.sh",
     "src/agent/claudecode.js",
+    "src/agent/claudefollowup.js",
     "src/agent/claudemodels.js",
     "src/agent/claudestatus.js",
     "src/agent/claudeusage.js",
@@ -134,6 +135,8 @@
     "src/ui/console.html",
     "src/ui/dashboard.js",
     "src/ui/feishulogin.js",
+    "src/ui/liveactivity-client.js",
+    "src/ui/liveactivity.js",
     "src/ui/serverbase.js",
     "src/ui/sessions.js",
     "src/ui/takeover.js",

package/src/agent/claudecode.js

@@ -15,6 +15,7 @@
 
 const { spawn } = require('node:child_process')
 const { StringDecoder } = require('node:string_decoder')
+const { createClaudeFollowup } = require('./claudefollowup')
 const { ensureProxy, proxyBaseFor } = require('./visionproxy')
 
 // Always-on 群项目基础能力: auto-allowed regardless of preset (even read-only) so the
@@ -35,7 +36,7 @@ const closedRunnerErrors = new WeakSet()
 const isClosedRunnerError = error => !!error && typeof error === 'object' && closedRunnerErrors.has(error)
 const closedError = error => { closedRunnerErrors.add(error); return error }
 const PRE_INIT_HOOK_EVENTS = new Set(['hook_started', 'hook_response'])
-const DURABLE_EVENT_TYPES = new Set(['system', 'assistant', 'user', 'result', 'tool_result'])
+const DURABLE_EVENT_TYPES = new Set(['system', 'assistant', 'user', 'result', 'tool_result', 'turn_continue'])
 // Tool output is completion evidence only, never answer text.
 function durableToolResults(ev) {
   const results = Array.isArray(ev.results) ? ev.results : []
@@ -152,6 +153,8 @@ function runTurn({
   log = () => {}, // daemon logger — 与 codex runner 同一个口子(engine 两边都传 this.log)
   spawnFn = spawn, // 可注入,供单测驱动 spawn/解析环路(与 codexcode 同一形状)
   softStopGraceMs = 10000,
+  steer = false, onSteerReady, onSteerLanded,
+  steerReceiptTimeoutMs = 10000, steerHoldMs = 20000, interruptGraceMs = 2000,
   closeGraceMs = 3000, // short: the grace starts AFTER the answer, so we're only waiting for
   // the OS to close a possibly-clinging pipe (MCP browser children / cmd.exe shim). Claude
   // persists its session continuously, so killing ~3s post-answer is safe → the group frees
@@ -225,7 +228,7 @@ 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({ model, providerModel: provider.model, sessionId,
+      const args = claudeBuildArgs({ steer, model, providerModel: provider.model, sessionId,
         permissionMode, autocompactTokens, autocompactSupported,
         mcpConfigPath, allowedTools, pluginAllows, disallowedTools,
         appendSystemPrompt, workdir })
@@ -242,8 +245,14 @@ function runTurn({
       // Feed the prompt over stdin instead of as an argv element: cross-platform,
       // and it removes ALL Windows argv/cmd.exe escaping risk for arbitrary chat
       // text (quotes, &, |, %, newlines). Close stdin so `claude -p` starts.
-      child.stdin.on('error', () => { /* child may exit before the write drains */ })
-      child.stdin.end(prompt)
+      let followup = null
+      let stdinOpen = true
+      const endStdin = () => { if (stdinOpen) { stdinOpen = false; child.stdin.end() } }
+      const writeFrame = frame => {
+        if (!stdinOpen || childCloseObserved) throw new Error('Claude input is closed')
+        child.stdin.write(JSON.stringify(frame) + '\n')
+      }
+      child.stdin.on('error', error => { if (steer && !settled) followup?.fail(error) })
 
       let capturedSessionId = sessionId || null
       let lastResult = null
@@ -265,7 +274,7 @@ function runTurn({
       // Resolution is guarded (exactly once) because a close-grace timer can force the
       // turn to settle before the 'close' event fires — otherwise a lingering pipe would
       // wedge the per-group lock forever (never-hang invariant).
-      const finish = (fn) => { if (settled) return; settled = true; if (killTimer) clearTimeout(killTimer); if (closeTimer) clearTimeout(closeTimer); if (signal) signal.removeEventListener('abort', onAbort); fn() }
+      const finish = (fn) => { if (settled) return; settled = true; followup?.dispose(); if (killTimer) clearTimeout(killTimer); if (closeTimer) clearTimeout(closeTimer); if (signal) signal.removeEventListener('abort', onAbort); fn() }
       const resolveRun = result => {
         if (childCloseObserved) closedRunnerResults.add(result)
         resolve(result)
@@ -332,12 +341,21 @@ function runTurn({
           // Windows has no POSIX signals, and killing the cmd.exe shim would orphan
           // the real claude process underneath. taskkill /T /F ends the whole tree.
           try { spawn('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore', windowsHide: true }) } catch {}
+        } else if (followup && stdinOpen) {
+          try { followup.stop() } catch { /* close proof remains authoritative */ }
+          killTimer = setTimeout(() => {
+            try { child.kill('SIGTERM') } catch {}
+            killTimer = setTimeout(() => { try { child.kill('SIGKILL') } catch {} }, softStopGraceMs)
+          }, interruptGraceMs)
         } else {
           try { child.kill('SIGTERM') } catch { /* already gone */ }
           killTimer = setTimeout(() => { try { child.kill('SIGKILL') } catch {} }, softStopGraceMs)
         }
         armCloseGrace() // even after a kill, 'close' can hang on a clinging pipe — bound it
       }
+      if (steer) followup = createClaudeFollowup({ write: writeFrame, end: endStdin,
+        onReady: onSteerReady, onLanded: onSteerLanded, onFailure: failDurableEvent,
+        receiptTimeoutMs: steerReceiptTimeoutMs, holdMs: steerHoldMs })
       if (signal) {
         if (signal.aborted) onAbort()
         else signal.addEventListener('abort', onAbort, { once: true })
@@ -370,6 +388,7 @@ function runTurn({
           if (!line) continue
           let raw
           try { raw = JSON.parse(line) } catch { continue } // skip non-JSON noise
+          if (followup && followup.protocol(raw)) continue
           if (onTurnAccepted && !turnAccepted) {
             // Locally configured session hooks report their own lifecycle before
             // init. They are not model output; skip them and keep waiting.
@@ -396,6 +415,9 @@ function runTurn({
             }
             turnAccepted = true
           }
+          if (followup && raw.type === 'system' && raw.subtype === 'init') {
+            if (followup.init(raw) === 'unavailable') log('当前模型程序未提供忙时跟进能力，本轮后续消息排队')
+          }
           // key 错快速失败(1.0.3):claude 对 401 / 403 默认重试约 3 分钟才放弃,第一次重试时(实测 0.8 秒)就会先报一条
           // `system/api_retry` 带 error_status。只对 API key 型模型(有 baseUrl)当场收尾 —— 订阅登录的 401 可能是
           // Claude Code 自己在刷新登录,让它重试;5xx / 529 这类过载照旧重试。造一条出错 result 交给上层:账号类失败
@@ -417,12 +439,20 @@ function runTurn({
             ev.contextTokens = (lastMsgUsage.input_tokens || 0) + (lastMsgUsage.cache_read_input_tokens || 0) + (lastMsgUsage.cache_creation_input_tokens || 0)
           }
           if (ev.type === 'result') {
+            const windows = Object.values(raw.modelUsage || {}).map(value => value?.contextWindow)
+            // No model-name guesses; a single reported capacity is unambiguous.
+            if (windows.length && windows.every(value => Number.isFinite(value) && value > 0) &&
+                new Set(windows).size === 1) ev.contextWindowTokens = windows[0]
             // 当前上下文规模 = 最后一次 API 请求的输入侧总量(未命中 + 缓存读 + 缓存写)。
             // result.usage 是整轮跨请求聚合、不能当上下文用;逐请求数在 assistant 事件的
             // message.usage 里(2.1.222 真机核对),兜底走 usage.iterations 末元素(同一形状)。
             const last = lastMsgUsage || (ev.usage && Array.isArray(ev.usage.iterations) ? ev.usage.iterations[ev.usage.iterations.length - 1] : null)
             if (last) ev.contextTokens = (last.input_tokens || 0) + (last.cache_read_input_tokens || 0) + (last.cache_creation_input_tokens || 0)
           }
+          if (followup && !aborted && ev.type === 'result') {
+            ev = followup.result(ev)
+            if (ev.type === 'turn_continue') lastMsgUsage = null
+          }
           // Only transcript events reach the durable projection. Informational
           // stream additions (for example rate_limit_event) carry no answer.
           // Claude reports several tool results per event, with array content
@@ -469,6 +499,10 @@ function runTurn({
         if (onDurableEvent) durableWork.then(() => { if (!durableFailed) completeClose(code) })
         else completeClose(code)
       })
+      if (!aborted) {
+        if (followup) followup.start(prompt)
+        else child.stdin.end(prompt)
+      }
     }
   })
 }

package/src/agent/claudefollowup.js

@@ -0,0 +1,92 @@
+'use strict'
+
+// Transport adapter only: the binary decides readiness, landing and segment boundaries.
+const { randomUUID } = require('node:crypto')
+const { claudeFollowupStep } = require('./privatecore')
+
+function createClaudeFollowup({ write, end, onReady, onLanded, onFailure,
+  receiptTimeoutMs = 10000, holdMs = 20000 } = {}) {
+  let state = null, disposed = false, holdTimer = null, sessionId = null
+  const firstId = randomUUID()
+  const pending = new Map(), messages = new Map()
+  const step = event => { const result = claudeFollowupStep(state, event); state = result.state; return result }
+  const clearHold = () => { clearTimeout(holdTimer); holdTimer = null }
+  const settle = (id, error) => {
+    const waiter = pending.get(id)
+    if (!waiter) return
+    pending.delete(id); clearTimeout(waiter.timer)
+    if (error) waiter.reject(error); else waiter.resolve(true)
+  }
+  const dispose = () => {
+    disposed = true; clearHold()
+    for (const id of pending.keys()) settle(id, new Error('Follow-up closed before receipt'))
+  }
+  const fail = error => { if (disposed) return; dispose(); onFailure(error) }
+  const control = {
+    steerDurable({ msgId, text } = {}) {
+      if (disposed) return Promise.resolve(false)
+      if (typeof msgId !== 'string' || !msgId || typeof text !== 'string' || !text || text.length > 200000) {
+        return Promise.resolve(false)
+      }
+      if ([...messages.values()].includes(msgId)) return Promise.reject(new Error('Duplicate follow-up message'))
+      const id = randomUUID()
+      const decision = step({ type: 'write', id })
+      if (decision.action === 'reject') return Promise.resolve(false)
+      messages.set(id, msgId)
+      const promise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => fail(new Error('Follow-up receipt timed out; delivery unknown')), receiptTimeoutMs)
+        pending.set(id, { resolve, reject, timer })
+      })
+      // Register identity and waiter before writing: a receipt may arrive immediately.
+      try { write({ type: 'user', uuid: id, message: { role: 'user', content: text } }) }
+      catch (error) { fail(error) }
+      return promise
+    },
+  }
+  return {
+    start(prompt) { write({ type: 'user', uuid: firstId, message: { role: 'user', content: prompt } }) },
+    protocol(raw) {
+      if (raw.type === 'control_response') return true
+      if (raw.type !== 'command_lifecycle') return false
+      if (raw.command_uuid === firstId) return true
+      if (sessionId && raw.session_id && raw.session_id !== sessionId) throw new Error('Follow-up session mismatch')
+      if (disposed) return true
+      const decision = step({ type: 'lifecycle', id: raw.command_uuid, status: raw.state })
+      if (decision.accepted) settle(raw.command_uuid)
+      if (decision.landed) { clearHold(); onLanded?.(messages.get(raw.command_uuid)) }
+      return true
+    },
+    init(raw) {
+      if (sessionId) {
+        if (raw.session_id !== sessionId) throw new Error('Follow-up init session changed')
+        return 'none'
+      }
+      sessionId = raw.session_id
+      const decision = step({ type: 'init', capabilities: raw.capabilities })
+      if (decision.action === 'ready') onReady?.(control)
+      else end()
+      return decision.action
+    },
+    result(event) {
+      const decision = step({ type: 'result', usage: event.usage, isError: event.isError })
+      clearHold()
+      if (decision.action === 'continue') {
+        holdTimer = setTimeout(() => fail(new Error('Follow-up landing timed out; replay forbidden')), holdMs)
+        return { ...event, type: 'turn_continue', usage: decision.usage }
+      }
+      end()
+      return { ...event, usage: { ...event.usage, ...decision.usage } }
+    },
+    stop() {
+      if (!disposed) step({ type: 'stop' })
+      dispose()
+      write({ type: 'control_request', request_id: `stop-${randomUUID()}`,
+        request: { subtype: 'interrupt', cancel_queued: true } })
+      end()
+    },
+    dispose,
+    fail,
+  }
+}
+
+module.exports = { createClaudeFollowup }

package/src/agent/codexapp.js

@@ -143,6 +143,9 @@ function runTurn(opts = {}) {
       totalUsage = usageFromTotal(usage.total)
       if (Number.isFinite(usage.last && usage.last.inputTokens) && usage.last.inputTokens > 0) contextTokens = usage.last.inputTokens
       if (Number.isFinite(usage.modelContextWindow) && usage.modelContextWindow > 0) contextWindowTokens = usage.modelContextWindow
+      // Observational only: do not add telemetry to the durable transcript.
+      if (!completed && contextTokens > 0) legacyEmit({ type: 'system', subtype: 'context',
+        sessionId: capturedSessionId, contextTokens, contextWindowTokens })
     }
     const write = (obj) => {
       if (child.stdin.destroyed) throw new Error('codex app-server stdin closed')
@@ -402,7 +405,8 @@ function runTurn(opts = {}) {
         const next = appDeltaNext(messageDeltas.get(params.itemId) || '', delta)
         if (next !== null) {
           messageDeltas.set(params.itemId, next)
-          emit({ type: 'assistant', text: delta, contextTokens })
+          emit({ type: 'assistant', text: delta,
+            ...(contextTokens > 0 ? { contextTokens, contextWindowTokens, contextSampled: false } : {}) })
         }
       } else if (action === 4) {
         const item = params.item

package/src/agent/privatecore.js

@@ -1,9 +1,9 @@
-// ABI v34 adapter for the private binary decision core. Manifest assembly still stays in JS.
+// ABI v35 adapter for the private binary decision core. Manifest assembly still stays in JS.
 const fs = require('node:fs')
 const path = require('node:path')
 const { createHash } = require('node:crypto')
 
-const EXPECTED_SHA256 = '8c55d4f97a738e14885841f9b8f83906cca1e8e9aef46bb28f31022aef1fce2d'
+const EXPECTED_SHA256 = '9c29c9123b38aa75b9c47066c809d844f938baca41779372b77c02fa7baa9989'
 let bytes
 try {
   bytes = fs.readFileSync(path.join(__dirname, 'privatecore.wasm'))
@@ -26,7 +26,7 @@ try {
 } catch (cause) {
   throw new Error('SintBot binary core cannot start on this runtime', { cause })
 }
-if (core.abi_version() !== 34) throw new Error('SintBot binary core ABI mismatch')
+if (core.abi_version() !== 35) throw new Error('SintBot binary core ABI mismatch')
 const encoder = new TextEncoder()
 const decoder = new TextDecoder('utf-8', { fatal: true })
 
@@ -784,7 +784,21 @@ function guarded(fn) {
   }
 }
 
-const entries = { classifyError, routeBackend, sandboxTier, appErrorOverride, appNormalizeItem, appStreamTail, appNoticeAction, appDeltaNext, appLandedAction, appCompletionAction, appCompletionNoticeAction, manifestFeatures, manifestHeader, manifestContext, manifestSkills, manifestStyleBoard, manifestImagenAsset, manifestRuntime, manifestPolicy, systemAppendix, codexEffortRejection, wecomGatePrompt, imagenPrompt, turnPrompt, compactEvent, engineQueueStep, engineSlotsStep, engineTurnStep, engineSessionStep, engineHandoffStep, engineIntakeStep, engineLifecycleStep, engineTerminalStep, engineSteerStep, engineRecoveryStep, engineFailoverStep, parseResetFields, chooseResetEpoch, codexBuildPrompt, codexBuildArgs, appUsageFromTotal, settleUsage, appBuildRequest, claudeBaseSkillAllows, claudeBuildArgs, claudePluginAllowRules, claudeNormalizeEvent, codexNormalizeEvent, codexParseError }
+function followupCall(name, value) {
+  let ptr = 0, size = 0
+  try {
+    ptr = callText(name, JSON.stringify(value))
+    if (!ptr) throw new Error('Follow-up core rejected protocol state')
+    size = new DataView(core.memory.buffer).getUint32(ptr, true) + 4
+    return JSON.parse(decoder.decode(new Uint8Array(core.memory.buffer, ptr + 4, size - 4)))
+  } finally {
+    if (ptr && size) { new Uint8Array(core.memory.buffer).fill(0, ptr, ptr + size); core.dealloc(ptr, size) }
+  }
+}
+function followupEnabled(group, runner) { return followupCall('followup_policy', { group, runner }) }
+function claudeFollowupStep(state, event) { return followupCall('claude_followup_step', { state, event }) }
+
+const entries = { followupEnabled, claudeFollowupStep, classifyError, routeBackend, sandboxTier, appErrorOverride, appNormalizeItem, appStreamTail, appNoticeAction, appDeltaNext, appLandedAction, appCompletionAction, appCompletionNoticeAction, manifestFeatures, manifestHeader, manifestContext, manifestSkills, manifestStyleBoard, manifestImagenAsset, manifestRuntime, manifestPolicy, systemAppendix, codexEffortRejection, wecomGatePrompt, imagenPrompt, turnPrompt, compactEvent, engineQueueStep, engineSlotsStep, engineTurnStep, engineSessionStep, engineHandoffStep, engineIntakeStep, engineLifecycleStep, engineTerminalStep, engineSteerStep, engineRecoveryStep, engineFailoverStep, parseResetFields, chooseResetEpoch, codexBuildPrompt, codexBuildArgs, appUsageFromTotal, settleUsage, appBuildRequest, claudeBaseSkillAllows, claudeBuildArgs, claudePluginAllowRules, claudeNormalizeEvent, codexNormalizeEvent, codexParseError }
 for (const name of Object.keys(entries)) entries[name] = guarded(entries[name])
 
 module.exports = { ...entries, engineStep, resetBinaryCore, HUMAN_BY_KIND: HUMAN }