sintbot 1.4.10 → 1.4.11

package/CHANGELOG.en.json

@@ -1,4 +1,15 @@
 [
+  {
+    "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,15 @@
 [
+  {
+    "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/docs/AI-ASSISTED-INSTALL.md

@@ -1,4 +1,4 @@
-# Install SintBot 1.4.10 with an AI assistant
+# Install SintBot 1.4.11 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.11 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.11
 
 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.11` into `~/.local/share/sintbot`, and verifies the entry, built-in core and Feishu module. Continue when you see `Installed and verified SintBot 1.4.11`. 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,9 +99,9 @@ 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
 

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

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

package/docs/zh-CN/install.md

@@ -1,4 +1,4 @@
-# 安装 SintBot 1.4.10
+# 安装 SintBot 1.4.11
 
 [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.11` 装到 `~/.local/share/sintbot`，并验证程序入口、内置核心和飞书模块。看到 `Installed and verified SintBot 1.4.11` 就可以继续。不需要 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,9 +99,9 @@ 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. 控制台
 

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.11
   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.11",
   "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",

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 交给上层:账号类失败
@@ -423,6 +445,10 @@ function runTurn({
             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 +495,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/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 }

package/src/c2console.js

@@ -18,7 +18,7 @@ const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   '/api/ui/network', '/api/ui/public-url', '/api/ui/update-settings', '/api/feishu/admins',
   '/api/groups', '/api/groups/provider', '/api/fs/mkdir',
   '/api/groups/order', '/api/groups/policy', '/api/groups/redact',
-  '/api/groups/codex-steer', '/api/groups/pause', '/api/groups/stop',
+  '/api/groups/codex-steer', '/api/groups/steer', '/api/groups/pause', '/api/groups/stop',
   // A fresh session only for an idle, settled group (same rule as /new).
   '/api/groups/new', '/api/groups/interrupt',
   '/api/agent', '/api/provider-settings', '/api/codex/verify', '/api/usage/refresh',

package/src/c2install.js

@@ -123,6 +123,7 @@ function resolveInstallation(cfg, configFile, stateDir, { allowAddedGroups = fal
     if (group.paused !== undefined && typeof group.paused !== 'boolean') {
       throw new Error('Group paused must be a boolean')
     }
+    if (group.steer !== undefined && typeof group.steer !== 'boolean') throw new Error('Group steer must be a boolean')
     if (group.codexSteer !== undefined && typeof group.codexSteer !== 'boolean') {
       throw new Error('Group codexSteer must be a boolean')
     }

package/src/config.js

@@ -40,8 +40,8 @@ const DEFAULTS = {
   // 写死会**覆盖 CLI 的默认**,于是每次 Anthropic 出新一代,sbot 的默认就悄悄落后一代
   // (2026-08-03 核对时正卡在 opus-4-8,而 CLI 默认已是 Opus 5)。要钉死型号在控制台选。
   providers: { claude: {} },
-  // "<chatId>": { workdir, provider?, model?, codexSteer?: false, allowedTools?: [], disallowedTools?: [] }
-  // codexSteer defaults on for Codex groups; explicit false opts out.
+  // "<chatId>": { workdir, provider?, model?, steer?: boolean, codexSteer?: false, allowedTools?: [], disallowedTools?: [] }
+  // steer defaults on for both executors; explicit false opts out. Legacy codexSteer applies only to Codex.
   // — one project per group; permissions are scoped to that group's own workdir.
   groups: {},
 }

package/src/core/c2runnerinput.js

@@ -1,4 +1,5 @@
 'use strict'
+const { followupEnabled } = require('../agent/privatecore')
 
 // Assemble the same user-facing runner inputs as Engine._runTurn after the
 // host has prepared its timestamped prompt and manifest. This only assembles
@@ -25,12 +26,13 @@ function prepareC2RunnerInput({ prompt, appendSystemPrompt, msg, group, provider
     throw new TypeError('C2 runner input requires an exact process-local turn')
   }
   const isCodex = provider.runner === 'codex'
-  const codexSteer = isCodex && group.codexSteer !== false
+  const enabled = followupEnabled(group, provider.runner)
+  const codexSteer = isCodex && enabled
   if ((onSteerReady !== undefined && typeof onSteerReady !== 'function') ||
       (onSteerLanded !== undefined && typeof onSteerLanded !== 'function') ||
-      (codexSteer && (typeof onSteerReady !== 'function' ||
+      (enabled && (typeof onSteerReady !== 'function' ||
         typeof onSteerLanded !== 'function'))) {
-    throw new TypeError('C2 Codex follow-up needs durable control callbacks')
+    throw new TypeError('C2 follow-up needs durable control callbacks')
   }
   const rawCompact = Number(config.agent.autocompactTokens) || 0
   const autocompactTokens = rawCompact > 0
@@ -40,6 +42,7 @@ function prepareC2RunnerInput({ prompt, appendSystemPrompt, msg, group, provider
     prompt, appendSystemPrompt, provider,
     codexApp: isCodex && group.codexApp === true,
     codexSteer,
+    steer: !isCodex && enabled,
     codexProjectDocFallback: isCodex && group.codexProjectDocFallback === true,
     onSteerReady, onSteerLanded,
     model: group.model,

package/src/core/c2turnprojection.js

@@ -24,6 +24,8 @@ function createC2TurnProjection({ receiptId, turnToken, quiet, resumed = false,
   }
   let bufferText = ''
   let answerText = ''
+  let keptText = ''
+  let segmentBreak = false
   let fullText = ''
   let sessionId = null
   let contextTokens = 0
@@ -68,6 +70,11 @@ function createC2TurnProjection({ receiptId, turnToken, quiet, resumed = false,
         throw new TypeError('C2 projection tool names invalid')
       }
       if (event.text) {
+        if (segmentBreak) {
+          segmentBreak = false
+          if (bufferText) bufferText += '\n\n'
+          if (fullText) fullText += '\n\n'
+        }
         fullText = append(fullText, event.text)
         bufferText = append(bufferText, event.text)
         answerText = append(answerText, event.text)
@@ -78,6 +85,13 @@ function createC2TurnProjection({ receiptId, turnToken, quiet, resumed = false,
       // Claude can report text and tool use in one assistant event. Text before
       // the tool is progress, while the final answer begins after that tool.
       if (tools.length) answerText = ''
+    } else if (event.type === 'turn_continue') {
+      if (event.text !== undefined && typeof event.text !== 'string') throw new TypeError('C2 segment text invalid')
+      const text = (answerText.trim() ? answerText : event.text || '').trim()
+      if (text && text !== NO_REPLY) keptText += (keptText ? '\n\n' : '') + text
+      if (bufferText.trim() === NO_REPLY) bufferText = ''
+      if (fullText.trim() === NO_REPLY) fullText = ''
+      answerText = ''; segmentBreak = true
     } else if (event.type === 'result') {
       if (event.text !== undefined && typeof event.text !== 'string') {
         throw new TypeError('C2 projection result text invalid')
@@ -138,7 +152,11 @@ function createC2TurnProjection({ receiptId, turnToken, quiet, resumed = false,
     }
     completed = true
     const runnerExit = requireResult && !observedResult && !runnerResult.aborted
-    const resultText = observedResult?.text || ''
+    const rawResultText = observedResult?.text || ''
+    const tail = (answerText.trim() ? answerText : rawResultText).trim()
+    const joined = keptText ? keptText + (tail && tail !== NO_REPLY ? '\n\n' + tail : '') : ''
+    const resultText = joined || rawResultText
+    if (joined) answerText = joined
     const payload = Object.freeze({
       type: 'finalizeEffectCommit', receiptId, turnToken, quiet,
       source: observedResult ? 'result' : runnerExit ? 'runner-exit' : 'close',

package/src/core/v2engine.js

@@ -9,7 +9,7 @@ const { isDeepStrictEqual } = require('node:util')
 const { redact } = require('./redact')
 const { fmtStamp, normalizeTz } = require('./time')
 const { settleUsage, manifestPolicy, manifestHeader, manifestContext, manifestFeatures, manifestSkills,
-  systemAppendix, turnPrompt, engineTerminalStep, engineQueueStep } = require('../agent/privatecore')
+  followupEnabled, systemAppendix, turnPrompt, engineTerminalStep, engineQueueStep } = require('../agent/privatecore')
 const { taskId } = require('./enginecheckpoint')
 const { prepareCardTerminalPath } = require('./c2cardterminalpath')
 const { terminalReplyText } = require('./c2terminaleffectbridge')
@@ -468,7 +468,7 @@ async _durableV2Command(msg, cmd, rest) {
           group.allowedTools, group.disallowedTools).tier)
       } catch {}
       return reject('help', T.help({ project: projectName(group), model: label(name, provider),
-        steer: isCodex && group.codexSteer !== false, readOnly }))
+        steer: followupEnabled(group, provider.runner), readOnly }))
     }
     if (cmd === '/status') {
       const rt = this.rts.get(msg.chatId)
@@ -651,7 +651,7 @@ async runDurableV2Message(msg, platform) {
       lane?.handoff?.[msg.chatId]?.phase === 'running' ||
       Array.isArray(queue) && queue.length > 0 ||
       rt.v2RunningJobs || rt.v2QueueReceiptIds?.length
-    if (busy && provider.runner === 'codex' && group.codexSteer !== false &&
+    if (busy && rt.v2FollowupEnabled &&
         rt.v2SteerControl && rt.v2NormalRouteActive && !rt.v2RunnerStopVerified &&
         !rt.v2TerminalStarted && !rt.v2StreamQuiescing && rt.v2Controller &&
         !rt.v2Controller.signal.aborted && !rt.v2SteerClosing) {
@@ -1534,6 +1534,7 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
         throw new Error('C2 v2 runner provider unavailable')
       }
       rt.v2CardModelInfo = cardModelInfo(job.group, provider)
+      rt.v2FollowupEnabled = followupEnabled(job.group, provider.runner)
       rt.v2SteerControl = null
       rt.v2SteerEntries = new Map()
       rt.v2SteerClosing = false

package/src/ui/console.html

@@ -2619,7 +2619,7 @@ const RUNTIME_UI_TEXT={
   "paused": "已暂停：不接收本群新消息，配置与会话保留。",
   "resume": "恢复本群：重新接收本群消息，配置与会话保留。",
   "resumeLabel": "恢复",
-  "steer": "群成员的后续文字消息可加入当前任务；只有确认消息已进入模型后才算送达。控制台插话只在群空闲时可用，不加入当前任务；定时任务暂不可用。",
+  "steer": "Codex 与 Claude Code 默认开启忙时跟进；长命令执行期间的补充会在工具步骤之间读取。只有确认模型已读取才显示已加入；不支持此能力时排队。控制台插话仅空闲时可用。",
   "preview": "当前版本未接入预览服务。",
   "providers": "可添加模型，修改型号、端点、密钥、思考深度与推理强度，测试、隐藏或拖动排序；各群的模型在「群·项目」里切换。改型号、后端或端点时，用它的群须空闲，并会开始新的一段对话；默认模型和群正在用的模型不能隐藏。移除模型暂不可用。",
   "providersView": "当前可查看模型配置与登录状态；各群的模型在「群·项目」里切换。添加或修改模型暂不可用。",
@@ -2631,7 +2631,7 @@ function renderGroups(){
     // Codex(GPT)跑自己的 agent 框架:只吃 permissionMode→沙箱层级,allow/deny 与 MCP 门控
     // 都是 Claude 专属(codexcode 根本不接收这些字段)。所以 codex 群不渲染那些无效控件。
     const pr=provOf(g), isCodex=!!pr&&pr.runner==='codex';
-    const showCodexSteer=runsCodex(g);
+
     // 群属于哪个平台(服务端按配置 / id 形态算好):企微群没有画布、没有解散、基础技能文案不同;徽标只在配了企微 / Slack 时出(只配飞书的机器零变化)
     const isWe=g.platform==='wecom', isSl=g.platform==='slack', showPlat=!!(S.platforms&&(S.platforms.wecom||S.platforms.slack));
     const platTag=showPlat?`<span class="tag tan" title="${isWe?'企业微信群:只收 @ 机器人的消息;没有画布、表情回应与撤回即停':isSl?'Slack 频道:没有画布与表情回应,群内收发文件未接;控制面用 !命令 或 /sint':'飞书群'}">${isWe?'企业微信':isSl?'Slack':'飞书'}</span>`:'';
@@ -2845,13 +2845,13 @@ function renderGroups(){
       <select class="gprov" data-g="${esc(g.chatId)}" style="width:auto;min-width:110px;padding:5px 30px 5px 10px;font-size:11.5px">
         ${S.providers.filter(pp=>!pp.hidden&&pp.configured).map(pp=>`<option value="${esc(pp.name)}" ${pp.name===(g.provider||S.defaultProvider)?'selected':''}>${esc(pp.name)}${pp.model?' · '+esc(pp.model):''}</option>`).join('')}
       </select></div>
-    ${showCodexSteer?`<div class="kv" style="align-items:flex-start"><span class="kk">忙时跟进</span><span class="vv" style="min-width:0">
-      <label class="inline" style="gap:6px;cursor:pointer" title="${esc(S.runtimeCapabilities?RUNTIME_UI_TEXT.steer:'开启后，Codex 处理任务期间：群成员的后续消息、控制台勾了「回复」的插话，都会加入当前任务 —— 相关要求及时吸收，独立请求按先后回应。定时任务和不回复的插话仍排在后面。')}">
-        <input type="checkbox" class="gsteer" data-g="${esc(g.chatId)}"${g.codexSteer?' checked':''} style="width:auto;margin:0"/>
+    <div class="kv" style="align-items:flex-start"><span class="kk">忙时跟进</span><span class="vv" style="min-width:0">
+      <label class="inline" style="gap:6px;cursor:pointer" title="${esc(S.runtimeCapabilities?RUNTIME_UI_TEXT.steer:'开启后，处理任务期间：群成员的后续消息、控制台勾了「回复」的插话，都会加入当前任务 —— 相关要求及时吸收，独立请求按先后回应。定时任务和不回复的插话仍排在后面。')}">
+        <input type="checkbox" class="gsteer" data-g="${esc(g.chatId)}"${g.followupEnabled?' checked':''} style="width:auto;margin:0"/>
         <span style="font-size:11.5px;color:var(--dim)">后续消息加入当前处理</span>
       </label>
-      <span class="faint" style="font-size:11px">仅 Codex · 默认开启 · 下轮生效</span>
-    </span></div>`:''}
+      <span class="faint" style="font-size:11px">默认开启 · 下轮生效</span>
+    </span></div>
     <div class="kv"><span class="kk">执行模式</span>${modeControl}</div>
     ${permPlug}
     <div class="spacer"></div>
@@ -2890,7 +2890,7 @@ function renderGroups(){
     try{S=await api('/api/groups/pause','POST',{chatId:b.dataset.gpause,paused:on});renderGroups();renderOverview();toast(S.runtimeCapabilities?(on?'已暂停':'已恢复'):(on?'已暂停 · 群内已通知':'已恢复 · 群内已通知'),'ok');}catch(e){toast(e.message,'err');}});
   $$('#groups .gprov').forEach(sel=>sel.onchange=async()=>{try{const r=await api('/api/groups/provider','POST',{chatId:sel.dataset.g,provider:sel.value});S=r;renderOverview();renderGroups();toast(r.switched&&r.switched.live?('已切到 '+sel.value+' · 会话已重置,下条消息生效'):('已保存 '+sel.value+' · daemon 未运行下次生效'),'ok');}catch(e){toast(e.message,'err');}});
   $$('#groups .gsteer').forEach(c=>c.onchange=async()=>{const on=c.checked;
-    try{S=await api('/api/groups/codex-steer','POST',{chatId:c.dataset.g,enabled:on});renderGroups();toast(on?'已开启 · 下轮生效':'已关闭 · 下轮恢复排队','ok');}
+    try{S=await api('/api/groups/steer','POST',{chatId:c.dataset.g,enabled:on});renderGroups();toast(on?'已开启 · 下轮生效':'已关闭 · 下轮恢复排队','ok');}
     catch(e){c.checked=!on;toast(e.message,'err');}});
   $$('#groups [data-pol]').forEach(b=>b.onclick=async()=>{const g=b.dataset.pol,allow=splitList($('.gallow[data-g="'+g+'"]').value),deny=splitList($('.gdeny[data-g="'+g+'"]').value);try{S=await api('/api/groups/policy','POST',{chatId:g,allowedTools:allow,disallowedTools:deny});toast('权限已保存 · 下轮生效','ok');}catch(e){toast(e.message,'err');}});
   // 仓库地址:保存 = 校验 + git init(若非仓库)+ 设 origin(幂等,不 clone/不提交);留空保存 = 解除关联。
@@ -3330,7 +3330,7 @@ function sayPlan(chatId,reply){
   if(lv.finalizing) return {busy:true,join:false,why:'closing',lv};
   if(lv.followups) return reply?{busy:true,join:true,lv}:{busy:true,join:false,why:'quiet',lv};
   const g=(S.groups||[]).find(x=>x.chatId===chatId)||{};
-  return {busy:true,join:false,why:!runsCodex(g)?'other':(!g.codexSteer?'off':'turn'),lv};
+  return {busy:true,join:false,why:!g.followupEnabled?'off':'turn',lv};
 }
 /* 这个群眼下实际跑的是不是 Codex(按生效中的模型,含临时切换)—— 群卡「忙时跟进」开关显不显示、插话框说不说
    「去打开忙时跟进」,都按这一个判。两处各写一份,开关和说明就会对不上。 */
@@ -4311,10 +4311,11 @@ 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"],
-  ["群成员的后续文字消息可加入当前任务；只有确认消息已进入模型后才算送达。控制台插话只在群空闲时可用，不加入当前任务；定时任务暂不可用。", "Followup text messages from group members can join the current task. Delivery is confirmed only when the model receives the message. Console messages work only while the group is idle and never join the current task; schedules are unavailable."],
+  ["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."],
   ["当前版本未接入预览服务。", "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."],
+  ["默认开启 · 下轮生效", "On by default · Applies next turn"],
   ["当前只能添加或修改 Codex 或 Claude Code 模型", "Only Codex or Claude Code models can be added or changed right now."],
   ["默认模型须是列表中未隐藏的 Codex 或 Claude Code 模型", "The default model must be a visible Codex or Claude Code model from the list."],
   ["有群因未解决的故障暂停处理，它用的模型、后端或端点要等处理完并重启后才能改", "A group is held after an unresolved fault; the model, backend or endpoint it uses can change only after the fault is handled and the service restarts."],

package/src/ui/serverbase.js

@@ -5,6 +5,7 @@
 // two stay in sync.
 
 const http = require('node:http')
+const { followupEnabled } = require('../agent/privatecore')
 const crypto = require('node:crypto')
 const fs = require('node:fs')
 const os = require('node:os')
@@ -507,7 +508,7 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
       // repo:群项目关联的 git 远端(可空)。repoState 走纯 fs 的 .git/config 读取(quickLinkState)
       // —— 群卡标签要反映真实关联(origin 被手改/删掉时不能还绿着),但这里每个 API 响应都跑一遍,
       // per-group spawn git 会把控制台拖垮,所以只读文件、不 spawn。
-      .map(([chatId, g]) => ({ chatId, name: g.name || '', workdir: g.workdir || '', repo: g.repo || '', platform: chatPlatformOf(raw, chatId) /* 群属于哪个平台:配置写了就认,没写按 id 形态 / 唯一平台推断(与 config.normalizeGroupPlatforms 同口径) */, repoState: gitrepo.quickLinkState(g.workdir, g.repo), board: g.board && g.board.url ? { url: g.board.url, createdAt: g.board.createdAt || null } : null, provider: g.provider || '', effectiveProvider: (control && control.providerOf && control.providerOf(chatId)) || g.provider || raw.defaultProvider || cfg.defaultProvider, codexSteer: g.codexSteer !== false, model: g.model || '', allowedTools: g.allowedTools || [], disallowedTools: g.disallowedTools || [], permissionMode: g.permissionMode || '', paused: g.paused === true, plugins: g.plugins || null,
+      .map(([chatId, g]) => ({ chatId, name: g.name || '', workdir: g.workdir || '', repo: g.repo || '', platform: chatPlatformOf(raw, chatId) /* 群属于哪个平台:配置写了就认,没写按 id 形态 / 唯一平台推断(与 config.normalizeGroupPlatforms 同口径) */, repoState: gitrepo.quickLinkState(g.workdir, g.repo), board: g.board && g.board.url ? { url: g.board.url, createdAt: g.board.createdAt || null } : null, provider: g.provider || '', effectiveProvider: (control && control.providerOf && control.providerOf(chatId)) || g.provider || raw.defaultProvider || cfg.defaultProvider, codexSteer: followupEnabled(g, 'codex'), steer: g.steer ?? null, followupEnabled: followupEnabled(g, cfg.providers[(control && control.providerOf && control.providerOf(chatId)) || g.provider || cfg.defaultProvider]?.runner || 'claude'), model: g.model || '', allowedTools: g.allowedTools || [], disallowedTools: g.disallowedTools || [], permissionMode: g.permissionMode || '', paused: g.paused === true, plugins: g.plugins || null,
         // 项目级插件/技能(workdir 自带声明,随项目恒加载)—— 群卡摘要行不点开也看得见。
         // projectPlugins 纯 fs 读且各错各兜(readJson/scanSkills 都 catch),与同行的 projectStyleCard 同量级。
         // ⚠ workdir 必须先判空:空串会让 path.join 退化成 daemon cwd 相对读(实验证实能读到别的项目的
@@ -1795,15 +1796,15 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
       }
       // Codex 忙时跟进默认开启；显式 false 才关闭。当前轮按启动时配置运行。
       // providerOf 覆盖运行时模型切换/额度回退，因此必须以实际有效 runner 校验。
-      if (p === '/api/groups/codex-steer' && req.method === 'POST') {
+      if ((p === '/api/groups/steer' || p === '/api/groups/codex-steer') && req.method === 'POST') {
         const { chatId, enabled } = await body(req); const raw = readRaw()
         if (!chatId || !raw.groups || !raw.groups[chatId]) return sendJSON(res, 404, { error: 'no such group' })
         if (typeof enabled !== 'boolean') return sendJSON(res, 400, { error: 'enabled 必须为布尔值' })
         const name = (control && control.providerOf && control.providerOf(chatId)) || raw.groups[chatId].provider || raw.defaultProvider || loadConfig(configPath).defaultProvider
         const provider = { ...DEFAULTS.providers, ...(raw.providers || {}) }[name]
-        if (!provider || provider.runner !== 'codex') return sendJSON(res, 400, { error: '仅实际使用 Codex 的群项目可开启忙时跟进' })
-        if (enabled) delete raw.groups[chatId].codexSteer
-        else raw.groups[chatId].codexSteer = false
+        if (p === '/api/groups/codex-steer' && (!provider || provider.runner !== 'codex')) return sendJSON(res, 400, { error: '仅实际使用 Codex 的群项目可开启忙时跟进' })
+        raw.groups[chatId].steer = enabled
+        delete raw.groups[chatId].codexSteer
         writeRaw(raw)
         return sendJSON(res, 200, await buildState())
       }