sintbot 1.4.4 → 1.4.6

package/src/c2configcontrol.js

@@ -5,12 +5,24 @@ const path = require('node:path')
 const { isDeepStrictEqual } = require('node:util')
 const { atomicWriteJSON } = require('./core/store')
 const { loadInstallationFromRaw, assertJournalScope, assertRunnerExecutable,
-  MANIFEST, VALIDATORS } = require('./c2install')
+  MANIFEST, VALIDATORS, SUPPORTED_RUNNERS } = require('./c2install')
 const { C2DurableJournal } = require('./core/c2durablejournal')
 const { assertNoLegacyGroupState } = require('./c2migration')
 
-const GLOBAL_TASK_KEYS = ['providers', 'agent', 'defaultProvider', 'timezone', 'brand']
+const GLOBAL_TASK_KEYS = ['agent', 'timezone', 'brand']
 const RESET_KEYS = ['provider', 'model', 'workdir', 'codexApp']
+const EFFORT_ENV = 'CLAUDE_CODE_EFFORT_LEVEL'
+
+// What a group's session belongs to: backend, executable, endpoint, model and
+// the environment the backend starts with. Effort, reasoning effort, tool
+// quality, key, image support, visibility and order apply from the next turn.
+function sessionIdentity(provider, group) {
+  if (!provider || typeof provider !== 'object') return null
+  const env = { ...(provider.env && typeof provider.env === 'object' ? provider.env : {}) }
+  delete env[EFFORT_ENV]
+  return { runner: provider.runner, bin: provider.bin || '', baseUrl: provider.baseUrl || '',
+    model: group?.model || provider.model || '', env }
+}
 
 // Synchronous validation/application around one atomic configuration write.
 // A group-scoped edit waits only for that group to settle. Changing a group's
@@ -30,22 +42,55 @@ function createC2ConfigControl({ installation, getBindings, getHeld = () => new
   }
   const { cfg, routes, stateDir } = installation
   let prepared = null
+  let appliedResets = []
 
   function held() {
     if (assertWriterLock() !== true) throw new Error('Service writer authority is unavailable')
   }
-  function assertSettled(chatId, binding) {
+  function assertSettled(chatId, binding,
+    message = 'Wait until the group task is settled before changing its task settings') {
     if (!binding) return
     if (binding.gate.blocked || binding.runtime.blocked ||
         [...binding.engine.rts.values()].some(rt => rt.v2NormalRouteActive ||
           rt.v2AdmissionPending || rt.v2Controller || rt.v2QueueReceiptIds?.length)) {
-      throw new Error('Wait until the group task is settled before changing its task settings')
+      throw new Error(message)
     }
     assertJournalScope(binding.journal, chatId, { requireSettled: true })
   }
 
+  // Model library edits. A provider that is added or edited must be one the
+  // durable route can run; the default must stay a visible runnable model;
+  // a provider still used by an active group or as the default stays listed.
+  function assertProviderEdits(next, effective) {
+    const before = cfg.providers || {}, after = next.cfg.providers || {}
+    for (const [name, provider] of Object.entries(after)) {
+      if (isDeepStrictEqual(before[name], provider)) continue
+      if (!provider || typeof provider !== 'object' || !SUPPORTED_RUNNERS.includes(provider.runner)) {
+        throw new Error(`模型「${name}」的后端不受支持；只能添加或修改 Codex 或 Claude Code 模型`)
+      }
+    }
+    if (cfg.defaultProvider !== next.cfg.defaultProvider) {
+      const chosen = after[next.cfg.defaultProvider]
+      if (!chosen || typeof chosen !== 'object' || chosen.hidden ||
+          !SUPPORTED_RUNNERS.includes(chosen.runner)) {
+        throw new Error('默认模型须是列表中未隐藏的 Codex 或 Claude Code 模型')
+      }
+    }
+    for (const [name, provider] of Object.entries(before)) {
+      if (!provider || provider.hidden || (after[name] && !after[name].hidden)) continue
+      const action = after[name] ? '隐藏' : '移除'
+      if (name === cfg.defaultProvider) {
+        throw new Error(`「${name}」是默认模型，先把默认模型换成别的再${action}`)
+      }
+      const users = next.routes.filter(route => !route.paused &&
+        effective(route.chatId, route.group, next.cfg) === name).length
+      if (users) throw new Error(`「${name}」正被 ${users} 个群使用，先把这些群切到其它模型再${action}`)
+    }
+  }
+
   function validateConfig(raw) {
     prepared = null
+    appliedResets = []
     held()
     if (isFrozen()) throw new Error('SintBot is upgrading; settings cannot change until it restarts')
     const next = loadInstallationFromRaw(raw, cfg._path, { dataDir: stateDir,
@@ -67,30 +112,48 @@ function createC2ConfigControl({ installation, getBindings, getHeld = () => new
     if (!isDeepStrictEqual(connectionOnly(cfg.feishu), connectionOnly(next.cfg.feishu))) {
       throw new Error('Connection settings require a service restart')
     }
-    for (const key of ['wecom', 'slack', 'proxy', 'projectsRoots', 'browser', 'providers', 'defaultProvider']) {
+    for (const key of ['wecom', 'slack', 'proxy', 'projectsRoots', 'browser']) {
       if (!isDeepStrictEqual(cfg[key], next.cfg[key])) throw new Error('Connection and filesystem settings require a service restart')
     }
     if (cfg.agent.maxConcurrent !== next.cfg.agent.maxConcurrent) {
       throw new Error('Changing global concurrency requires a service restart')
     }
-    const resets = [], activations = [], changed = []
+    // The model a group runs: a runtime override first (as the engine
+    // resolves it), then the group's own provider, then the default.
+    const sessions = chatId => store || bindings.get(chatId)?.engine?.store || null
+    const effective = (chatId, group, config) =>
+      sessions(chatId)?.getProvider?.(chatId) || group.provider || config.defaultProvider
+    assertProviderEdits(next, effective)
+    const resets = [], activations = [], changed = [], moved = []
     const heldGroups = getHeld()
     for (const route of routes) {
       const target = next.routes.find(item => item.chatId === route.chatId)
       if (route.group.platform !== target.group.platform) {
         throw new Error('Moving a group to another platform requires an explicit state migration')
       }
+      // A model library or default change reaches every group that runs
+      // the edited provider, even though its own settings stay the same.
+      const providerMoved = !isDeepStrictEqual(
+        sessionIdentity(cfg.providers?.[effective(route.chatId, route.group, cfg)], route.group),
+        sessionIdentity(next.cfg.providers?.[effective(route.chatId, target.group, next.cfg)], target.group))
       if (heldGroups.has(route.chatId)) {
         // Edits elsewhere proceed; the held group keeps its exact settings.
         if (!isDeepStrictEqual(route.group, target.group)) {
           throw new Error('This group is held after an unresolved fault; seal its incident and restart before changing it')
         }
+        if (providerMoved) {
+          throw new Error('有群因未解决的故障暂停处理，它用的模型、后端或端点要等处理完并重启后才能改')
+        }
         continue
       }
       if (!isDeepStrictEqual(route.group, target.group)) changed.push(route.chatId)
-      if (RESET_KEYS.some(key => !isDeepStrictEqual(route.group[key], target.group[key]))) {
+      const groupReset = RESET_KEYS.some(key => !isDeepStrictEqual(route.group[key], target.group[key]))
+      if (groupReset || providerMoved) {
         if (!store) throw new Error('Changing model or project requires session reset authority')
         resets.push(route.chatId)
+        if (!groupReset) moved.push(route.chatId)
+        // A reset also clears any runtime override: the group then runs
+        // its configured provider, which is the one probed here.
         if (!target.paused) probeRunner(target.provider, next.cfg)
       }
       if (!bindings.has(route.chatId)) {
@@ -115,6 +178,11 @@ function createC2ConfigControl({ installation, getBindings, getHeld = () => new
     const global = GLOBAL_TASK_KEYS.some(key => !isDeepStrictEqual(cfg[key], next.cfg[key]))
     for (const [chatId, binding] of bindings) {
       if (global || changed.includes(chatId)) assertSettled(chatId, binding)
+      else if (moved.includes(chatId)) {
+        const name = next.cfg.groups?.[chatId]?.name || chatId.slice(-8)
+        assertSettled(chatId, binding,
+          `「${name}」有任务进行中或记录未结账，等它结束后再改它用的模型、后端或端点`)
+      }
     }
     prepared = { raw: JSON.stringify(raw), next, resets, activations, added }
     return true
@@ -155,9 +223,15 @@ function createC2ConfigControl({ installation, getBindings, getHeld = () => new
     if (assertWriterLock() !== true || !prepared || prepared.raw !== JSON.stringify(raw)) {
       throw new Error('Configuration was not validated against the current service')
     }
-    const { next, activations, added } = prepared
+    const { next, activations, added, resets } = prepared
     const global = GLOBAL_TASK_KEYS.some(key => !isDeepStrictEqual(cfg[key], next.cfg[key]))
+    // Every engine copies the model library at construction and reads it
+    // when a turn starts: a library edit must reach all of them, including
+    // busy ones (their running turn keeps the settings it started with).
+    const library = !isDeepStrictEqual(cfg.providers, next.cfg.providers) ||
+      cfg.defaultProvider !== next.cfg.defaultProvider
     prepared = null
+    appliedResets = [...resets]
     for (const key of Object.keys(cfg)) delete cfg[key]
     Object.assign(cfg, next.cfg)
     const bindings = getBindings()
@@ -166,7 +240,7 @@ function createC2ConfigControl({ installation, getBindings, getHeld = () => new
       const groupChanged = !isDeepStrictEqual(route.group, target.group)
       Object.assign(route, target)
       const engine = bindings.get(route.chatId)?.engine
-      if (engine && (global || groupChanged)) {
+      if (engine && (global || groupChanged || library)) {
         engine.cfg = { ...cfg, groups: { [route.chatId]: route.group } }
         engine.tz = cfg.timezone
       }
@@ -209,7 +283,9 @@ function createC2ConfigControl({ installation, getBindings, getHeld = () => new
     })
   }
 
-  return { validateConfig, beforeWrite, applyConfig, writeConfig, switchGroupProvider }
+  return { validateConfig, beforeWrite, applyConfig, writeConfig, switchGroupProvider,
+    // Groups whose session the last applied write reset (for the console).
+    appliedResets: () => [...appliedResets] }
 }
 
 module.exports = { createC2ConfigControl }

package/src/c2console.js

@@ -3,6 +3,7 @@
 const path = require('node:path')
 const { createUiServer } = require('./ui/serverbase')
 const { START_PATH, CALLBACK_PATH } = require('./ui/feishulogin')
+const { assertJournalScope } = require('./c2install')
 
 // A host facade over existing v2 authorities, not a second execution engine.
 // The allowlist applies after the existing console's authentication boundary.
@@ -10,13 +11,23 @@ const READ_PATHS = ['/api/state', '/api/events', '/api/inbox', '/api/activity',
   '/api/changelog', '/api/changelog-en', '/api/codex/models', '/api/usage',
   '/api/plugins', '/api/design/styles', '/api/design/icons', '/api/fs/listdir',
   '/api/feishu/admin-candidates', '/api/feishu/org-users', '/api/feishu/resolve-contact',
-  '/api/feishu/chats', '/api/feishu/chat-members', '/api/update', START_PATH, CALLBACK_PATH]
+  '/api/feishu/chats', '/api/feishu/chat-members', '/api/update', '/api/claude/models',
+  START_PATH, CALLBACK_PATH]
 const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
   '/api/ui/network', '/api/ui/public-url', '/api/ui/update-settings', '/api/feishu/admins',
   '/api/groups', '/api/groups/provider', '/api/fs/mkdir',
   '/api/groups/order', '/api/groups/policy', '/api/groups/redact',
   '/api/groups/codex-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',
+  // The model library goes through the same validated writer: an edit that
+  // changes what a group runs waits for that group and starts a new session.
+  '/api/providers/add', '/api/provider-key', '/api/providers/hidden', '/api/providers/order',
+  '/api/default-provider', '/api/claude/verify',
+  // One headless trial reply outside every journal and session (like a
+  // one-off agent run); it does not take a group concurrency slot.
+  '/api/test',
   '/api/inbox/dismiss', '/api/issues/status',
   // Software updates: check and ignore anywhere; install only when launchd
   // manages this exact entry (the updater refuses every other run mode).
@@ -24,9 +35,10 @@ const WRITE_PATHS = ['/api/login', '/api/logout', '/api/logout/all',
 const SUPPORTED_RUNNERS = ['claude', 'codex']
 
 function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld = () => new Map(),
-  assertWriterLock, validateConfig, applyConfig, beforeWrite = () => true, now = Date.now } = {}) {
+  assertWriterLock, validateConfig, applyConfig, beforeWrite = () => true,
+  appliedResets = () => [], now = Date.now } = {}) {
   for (const callback of [getBindings, getCapacity, getConfig, getHeld, assertWriterLock,
-    validateConfig, applyConfig, beforeWrite, now]) {
+    validateConfig, applyConfig, beforeWrite, appliedResets, now]) {
     if (typeof callback !== 'function') throw new TypeError('C2 console needs live authority and configuration hooks')
   }
   if ([validateConfig, applyConfig, beforeWrite].some(callback => callback.constructor?.name === 'AsyncFunction')) {
@@ -35,7 +47,7 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
   const startedAt = now()
   const capabilities = Object.freeze({ mode: 'durable-v2',
     reason: '此操作尚未接入当前版本的持久处理流程，未执行。',
-    summary: '实时状态、认证管理、停止任务、绑定新群、空闲群的模型切换（Codex / Claude Code）和项目目录修改，以及后台运行时的软件升级已接入；该群有任务或未结记录时不能修改。开新会话、解除绑定、控制台插话、定时任务和画布暂不可用。',
+    summary: '实时状态、认证管理、停止任务、空闲群开新会话、绑定新群、空闲群的模型切换（Codex / Claude Code）和项目目录修改、模型的添加与设置，以及后台运行时的软件升级已接入；该群有任务或未结记录时不能修改，也不能开新会话；改模型的型号、后端或端点时，用它的群须空闲，并会开始新的一段对话。解除绑定、移除模型、控制台插话、定时任务和画布暂不可用。',
     allowed: { GET: READ_PATHS, POST: WRITE_PATHS } })
   function held() {
     if (assertWriterLock() !== true) throw new Error('服务写入权限已失效，操作未执行')
@@ -45,6 +57,33 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     if (!(value instanceof Map)) throw new TypeError('C2 console bindings must be a Map')
     return value
   }
+  // The engine's /new guard, read from the same runtime and journal the live
+  // view uses: a running, admitted, controlled or queued turn, any receipt of
+  // this group's journal not yet settled, or an outbound effect still in
+  // flight keeps the current session.
+  function groupBusy(chatId, binding) {
+    const rt = binding.engine?.rts?.get(chatId)
+    const snapshot = binding.journal?.snapshot()
+    return !!(rt?.v2NormalRouteActive || rt?.v2AdmissionPending || rt?.v2Controller ||
+      rt?.v2QueueReceiptIds?.length || snapshot?.receipts?.pending?.length ||
+      snapshot?.state?.lanes?.queue?.[chatId]?.queue?.length ||
+      binding.gate?.blocked || binding.runtime?.blocked)
+  }
+  function clearSession(chatId) {
+    held()
+    const binding = bindings().get(chatId)
+    if (!binding) throw new Error('此群未运行，未开新会话')
+    if (binding.runtime?.closed === true) throw new Error('此群当前未开放，未开新会话')
+    const busy = '该群有任务进行中或记录未结账，先停止或等它结束再开新会话'
+    if (groupBusy(chatId, binding)) throw new Error(busy)
+    // The configuration writer's settled check as well: an effect not yet
+    // acknowledged or a notice of unknown outcome also keeps the session.
+    try { assertJournalScope(binding.journal, chatId, { requireSettled: true }) } catch (error) {
+      throw new Error(busy, { cause: error })
+    }
+    binding.engine.store.resetSessionAndStats(chatId)
+    return true
+  }
   function getLiveState() {
     const cfg = getConfig()
     const capacity = getCapacity()
@@ -109,6 +148,8 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
     validateConfig(raw) { held(); validateConfig(raw) },
     beforeWrite(raw) { held(); beforeWrite(raw) },
     applyConfig(raw) { held(); applyConfig(raw) },
+    // Groups whose session the last applied configuration write reset.
+    appliedResets: () => appliedResets(),
     decorateState(state) {
       state.runtimeCapabilities = capabilities
       state.previews = (state.previews || []).filter(item => getConfig().groups?.[item.chatId])
@@ -126,6 +167,13 @@ function createC2ConsoleFacade({ getBindings, getCapacity, getConfig, getHeld =
         if (!binding) throw new Error('此群未运行，未执行停止')
         return binding.engine.stop(chatId)
       },
+      clearSession,
+      // A durable stop settles later, so a busy group is never reset here:
+      // the operator stops it first and starts the new session once idle.
+      interrupt(chatId) {
+        clearSession(chatId)
+        return { wasBusy: false }
+      },
     },
   }
 }

package/src/core/c2durableruntime.js

@@ -683,9 +683,19 @@ class C2DurableRuntime {
     } catch (error) { this.close(); throw error }
 
     let phase = 'attempting'
+    // Two host witnesses prove that no model turn began: the exec child never
+    // spawned (no pid), or the App Server rejected initialize/thread before
+    // any turn/start and its child has already closed.
+    const runnerNotStartedWitness = failure => {
+      const keys = failure && typeof failure === 'object' ? Object.keys(failure).sort() : []
+      return (isDeepStrictEqual(keys, ['backend', 'code', 'pid']) &&
+          failure.backend === 'codex-exec' && failure.code === 'ENOENT' && failure.pid === null) ||
+        (isDeepStrictEqual(keys, ['backend', 'closed', 'code', 'turnStarted']) &&
+          failure.backend === 'codex-app-server' && failure.code === 'THREAD_REJECTED' &&
+          failure.turnStarted === false && failure.closed === true)
+    }
     const onSpawnFailed = (failure) => {
-      if (phase !== 'attempting' || failure?.backend !== 'codex-exec' ||
-          failure.code !== 'ENOENT' || failure.pid !== null ||
+      if (phase !== 'attempting' || !runnerNotStartedWitness(failure) ||
           !isDeepStrictEqual(witness.jobReceiptIds, [receiptId]) ||
           !isDeepStrictEqual(witness.batchReceiptIds, [receiptId]) ||
           verifyGeneration({ chatId, receiptId, turnToken, generation }) !== true ||

package/src/core/v2engine.js

@@ -19,6 +19,10 @@ const progress = require('./turnprogress')
 const NO_REPLY = 'NO_REPLY'
 const SYSTEM_APPENDIX = systemAppendix(NO_REPLY)
 const V2_NORMAL_ROUTE_MISSING = Object.freeze(['complete durable v2 authority'])
+// Permission tiers the manifest describes to the agent as read-only: 1 is
+// 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'])
 function fmtWan(n) {
   n = Number(n) || 0
@@ -33,21 +37,43 @@ function humanDuration(ms) {
   if (minutes < 60) return `${minutes} 分 ${seconds % 60} 秒`
   return `${Math.floor(minutes / 60)} 小时 ${minutes % 60} 分`
 }
+// Group texts name the project by its folder only, never by a machine path.
+function projectName(group) {
+  return String(group?.workdir || '').split(/[\\/]/).filter(Boolean).pop() || '（未设）'
+}
 const T = {
   queued: n => n > 1 ? `⏳ 已排队 — 当前任务结束后与前面 ${n - 1} 条一并处理` : '⏳ 已排队 — 当前任务结束后处理',
   stopped: '已停止',
   noActiveTask: '没有正在运行的任务',
-  unsupportedCommand: '这个命令暂不支持。要停止当前任务请发 /stop，其他需求直接用文字说明。',
+  unsupportedCommand: '这个命令暂不支持。只放弃手头这件发 /skip，连排队的一起取消发 /stop；其他需求直接用文字说明。',
   unsupportedCommandWithModel: '这个命令暂不支持，发 /help 查看可用命令；其他需求直接用文字说明。',
-  help: steer => ['【可用命令】',
-    '/status 本群状态：模型、项目、是否在忙',
-    '/model 查看模型；/model 名字 切换（会开始新的一段对话）',
-    '/new 开始新的一段对话',
-    '/stop 停止当前任务，连同排队的一起取消',
-    '/hud 额度与本段对话的用量',
-    '/issue 一句话 记下问题反馈',
-    steer ? '直接发文字就是派任务；任务进行中再发的消息会补充进当前任务。'
-      : '直接发文字就是派任务；任务进行中再发的消息会排队，等这一轮结束再处理。'].join('\n'),
+  // Plain text: 【】 sections and "· " items, each read in one glance, no
+  // alignment. Commands go by urgency; the three cancel commands rise in what
+  // they discard and describe the queue and the conversation in the same words.
+  help: ({ project, model, steer, readOnly }) => ['【这是什么】',
+    `· 本群绑着项目「${project}」，模型 ${model}`,
+    readOnly ? '· 直接问它，它看代码、答问题；之前聊的都记得'
+      : '· 直接说事它就干，做完在群里回你；之前聊的都记得',
+    steer ? '· 任务进行中再发的消息会补充进当前任务'
+      : '· 任务进行中再发的消息会排队，等这一轮结束再处理',
+    '',
+    '【命令】',
+    '· /status — 跑了多久、还有没有动静、排队几条',
+    '· /skip — 只放弃手头这件，排队的继续；之前聊的还记得',
+    '· /stop — 手头和排队的全取消；之前聊的还记得',
+    '· /new — 忘掉之前聊的，从头开始（要等手头任务结束）',
+    '· /model — 本群在用的模型；换：/model 名字（要等手头任务结束，换完之前聊的不再带着）',
+    '· /hud — 额度与本段对话的用量',
+    '· /issue 一句话 — 记下问题反馈，给管理员看',
+    '· /help — 这份说明',
+    // Not "trailing text is ignored": /stop with text after it is not recognised.
+    '⚠ 命令单独发一条，后面别跟别的字（/issue、/model 除外）',
+    // Same boundary as handleRecall: a queued message, or the task running on
+    // that message alone; a steered follow-up takes its whole task with it.
+    steer ? '⚠ 撤回自己发的消息 = 取消那件事；撤回补进当前任务的那条，会连当前任务一起取消'
+      : '⚠ 撤回自己发的消息 = 取消那件事（已和别的消息合成一轮在做的除外）',
+    ...(readOnly ? ['⚠ 本群为只读模式：能看代码、答问题；要改文件需管理员放开权限'] : []),
+  ].join('\n'),
   status: ({ model, project, state, doing = [], queue, session }) => ['【本群状态】', `· 模型：${model}`,
     `· 项目：${project}`, `· 状态：${state}`,
     ...(doing.length ? [`· 最近在做：${doing.join(' · ')}`] : []),
@@ -71,6 +97,9 @@ const T = {
   stopPending: '正在停止当前任务，这条消息没有处理，请稍后重发。',
   stopUnavailable: '当前任务正在收尾，暂时无法停止。',
   stoppedWithQueue: n => `已停止 — 连同排队的 ${n} 条一并取消`,
+  skipped: n => n > 0 ? `已跳过当前任务（后面还有 ${n} 条排队，接着处理）` : '已跳过当前任务',
+  skipUnavailable: '当前任务正在收尾，暂时无法跳过。',
+  skipPending: '正在跳过当前任务，这条消息没有处理，请稍后重发。',
   quotaFailure: 'Codex 订阅额度已用完，本次任务未完成。请恢复额度后重新发送；本次请求不会自动重试。',
   cardFooter: ({ ms, tokens }) => {
     const parts = [`耗时 ${Math.max(0, Math.round(ms / 1000))} 秒`]
@@ -347,10 +376,20 @@ async _durableV2Command(msg, cmd, rest) {
     const group = this._resolveGroup(msg.chatId)
     if (!group || group.paused) return reject('unsupported-command', T.unsupportedCommandWithModel)
     const { name, provider } = this._resolveProvider(msg.chatId, group)
-    const label = (n, p) => p?.model ? `${n} · ${p.model}` : n
+    // 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
     if (cmd === '/model') return this._durableV2ModelCommand(msg, rest, group)
     if (cmd === '/help') {
-      return reject('help', T.help(provider?.runner === 'codex' && group.codexSteer !== false))
+      const isCodex = provider?.runner === 'codex'
+      // Read-only exactly when the manifest tells the agent so, for either
+      // runner; an unreadable policy reads as read-only.
+      let readOnly = true
+      try {
+        readOnly = READ_ONLY_TIERS.includes(manifestPolicy(group.permissionMode, isCodex,
+          group.allowedTools, group.disallowedTools).tier)
+      } catch {}
+      return reject('help', T.help({ project: projectName(group), model: label(name, provider),
+        steer: isCodex && group.codexSteer !== false, readOnly }))
     }
     if (cmd === '/status') {
       const rt = this.rts.get(msg.chatId)
@@ -360,8 +399,7 @@ async _durableV2Command(msg, cmd, rest) {
       const state = busy
         ? `运行中（已跑 ${humanDuration(Date.now() - (rt.v2StartedAt || Date.now()))}${rt.v2Steps ? ` · 已执行 ${rt.v2Steps} 步` : ''}${rt.v2AliveAt ? ` · 最近动静 ${humanDuration(Date.now() - rt.v2AliveAt)}前` : ''}）`
         : rt?.v2AdmissionPending ? '消息已登记，等待并发名额' : '空闲'
-      const project = String(group.workdir || '').split(/[\\/]/).filter(Boolean).pop() || '（未设）'
-      return reject('status', T.status({ model: label(name, provider), project, state,
+      return reject('status', T.status({ model: label(name, provider), project: projectName(group), state,
         doing: busy && Array.isArray(rt.v2Doing) ? rt.v2Doing : [], queue: queued,
         session: this.store.getSession(msg.chatId) ? '进行中（记着上下文）' : '未开始' }))
     }
@@ -437,6 +475,9 @@ async runDurableV2Message(msg, platform) {
     if (msg?.text?.trim() === '/stop') {
       return this.runDurableV2Stop(msg, platform)
     }
+    if (typeof msg?.text === 'string' && /^\/skip(?:\s|$)/.test(msg.text.trim())) {
+      throw await this.runDurableV2Skip(msg)
+    }
     if (!this.durableV2NormalRoute) {
       const error = new Error('C2 v2 normal route is closed: runner transcript, tool/stream effects, and terminal projection lack durable evidence')
       error.code = 'C2_V2_NORMAL_ROUTE_CLOSED'
@@ -501,6 +542,12 @@ async runDurableV2Message(msg, platform) {
       throw rejectC2Input('C2 v2 ordinary route is waiting for stop acknowledgement',
         { reason: 'stop-pending', notice: T.stopPending })
     }
+    // Between /skip and its durable cancellation the runner may already be
+    // closed; refuse before receipt instead of reaching the closed busy route.
+    if (rt.v2SkipWaiter) {
+      throw rejectC2Input('C2 v2 ordinary route is waiting for /skip to settle',
+        { reason: 'skip-pending', notice: T.skipPending })
+    }
     const lane = before.state?.lanes
     const queue = lane?.queue?.[msg.chatId]?.queue
     if (rt.v2AdmissionPending) {
@@ -850,6 +897,79 @@ async runDurableV2Stop(msg, platform) {
     }
   }
 
+// /skip cancels only the running turn, through the same durable cancellation
+// as the console stop: queued receipts stay queued and run next, and the
+// session is kept. Like the other chat commands it gets no receipt and is
+// answered as an input rejection, here only after the cancellation has
+// committed. That reply is best effort: the durable stop acknowledgement
+// exists only for /stop, whose transition empties the queue.
+async runDurableV2Skip(msg) {
+    const authority = this.durableV2Runtime
+    const chatId = msg?.chatId
+    if (!this.durableV2NormalRoute || !authority ||
+        !msg || msg.synthetic || msg.cron || msg.polled || msg.quiet ||
+        msg.wantsAck || msg.batch ||
+        typeof chatId !== 'string' || !chatId ||
+        typeof msg.msgId !== 'string' ||
+        !/^om_[A-Za-z0-9_-]{1,124}$/.test(msg.msgId) ||
+        msg.replyCtx?.chatId !== chatId ||
+        msg.replyCtx?.messageId !== msg.msgId) {
+      throw new Error('C2 v2 /skip is unsupported or closed')
+    }
+    const group = this._resolveGroup(chatId)
+    if (!group || group.paused || group.platform && group.platform !== 'feishu') {
+      throw new Error('C2 v2 /skip group control is not migrated')
+    }
+    // As for /stop, a /skip with nothing it may cancel is refused before receipt.
+    const reject = (reason, notice) => rejectC2Input(reason === 'skipped'
+      ? 'C2 v2 /skip answered after durable cancellation'
+      : 'C2 v2 /skip is unsupported or closed', { reason, notice })
+    // Without a receipt nothing durable dedupes this command, so a platform
+    // redelivery must not cancel a later task: a repeat this process has seen
+    // is dropped silently, and so is a /skip sent before the newest message of
+    // the running task (both are platform times).
+    const seen = this.durableV2SkipSeen || (this.durableV2SkipSeen = new Set())
+    const key = `${chatId}\n${msg.msgId}`
+    if (seen.has(key)) return reject('skip-duplicate', null)
+    seen.add(key)
+    if (seen.size > 256) seen.delete(seen.values().next().value)
+    const rt = this.rts.get(chatId)
+    if (!rt?.v2NormalRouteActive || !rt.v2RunningJobs?.length) {
+      return reject('skip-idle', T.noActiveTask)
+    }
+    const sentAt = Number(msg.createTimeMs)
+    if (Number.isSafeInteger(sentAt) && sentAt > 0 && rt.v2RunningJobs.some(job =>
+      Number(job?.msg?.createTimeMs) > sentAt)) {
+      return reject('skip-stale', null)
+    }
+    const route = rt.v2NormalRoutePromise
+    let settle
+    const settled = new Promise(resolve => { settle = resolve })
+    const waiter = { turnToken: rt.v2TurnToken, settle }
+    if (rt.v2SkipWaiter || !route || !Number.isSafeInteger(waiter.turnToken)) {
+      return reject('skip-unavailable', T.skipUnavailable)
+    }
+    rt.v2SkipWaiter = waiter
+    try {
+      if (!this.requestDurableV2Stop(chatId)) {
+        if (authority.blocked) throw new Error('C2 v2 /skip closed its durable authority')
+        return reject('skip-unavailable', T.skipUnavailable)
+      }
+      const queued = await Promise.race([settled, route.then(() => null)])
+      if (queued === null) {
+        // The turn ended without this cancellation, e.g. its runner was proven
+        // never started. Nothing was skipped and the group is not at fault;
+        // only a closed authority is.
+        if (authority.blocked) throw new Error('C2 v2 /skip cancellation was not durably settled')
+        return reject('skip-unavailable', T.skipUnavailable)
+      }
+      this.log(`/skip: ${chatId} (by ${msg.senderName || 'unknown'}), ${queued} queued`)
+      return reject('skipped', T.skipped(queued))
+    } finally {
+      if (rt.v2SkipWaiter === waiter) rt.v2SkipWaiter = null
+    }
+  }
+
 async _cleanupDurableV2CancelledCard(rt, identity, generation,
     verifyGeneration) {
     if (!rt.v2CardBinding?.opened) return null
@@ -963,6 +1083,13 @@ async _drainDurableV2NormalChain(initial) {
             terminalEffectId: null, cancellationEventId: cancelled.eventId })
         }
         if (authority.blocked) throw new Error('C2 v2 cancellation closed ingress')
+        // A chat /skip answers once its own turn is durably cancelled; what
+        // stays in the queue is the work that runs next.
+        const skip = rt.v2SkipWaiter
+        if (!stop && skip?.turnToken === identity.turnToken) {
+          rt.v2SkipWaiter = null
+          skip.settle(authority.snapshot().state.lanes.queue?.[identity.chatId]?.queue?.length || 0)
+        }
         const nextReceiptId = this._nextDurableV2NormalAnchor(identity.chatId)
         if (nextReceiptId) {
           const next = this.commitDurableV2InitialDispatch({
@@ -1627,7 +1754,8 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
       if (controller && rt.v2Controller === controller) rt.v2Controller = null
       const proofId = `sbot-c2-runner-not-started-v1:${receiptId}:${generation}`
       const eventId = `sbot-c2-runner-not-started-commit-v1:${receiptId}:${turnToken}:${generation}`
-      const provenNotStarted = !accepted && error?.code === 'AGENT_BIN_MISSING' &&
+      const provenNotStarted = !accepted &&
+        ['AGENT_BIN_MISSING', 'AGENT_THREAD_REJECTED'].includes(error?.code) &&
         this.durableV2Journal?.lookupRunnerNotStarted(proofId)?.dispatchEffectId === effectId &&
         this.durableV2Journal?.hasEvent(eventId) === true
       if (provenNotStarted) {
@@ -1638,10 +1766,44 @@ async startDurableV2Runner({ chatId, receiptId, turnToken, effectId } = {}) {
           authority.close()
           throw new Error('C2 v2 unstarted runner receipt remains unsettled')
         }
+        // Recovery also settles messages queued behind this turn, each with its
+        // own confirmed notice. Forget their bodies and the local queue so the
+        // next message is admitted as idle, not as a busy follow-up. A queue
+        // the recovery left in place has no dispatcher here: fail closed.
+        const durableQueue = authority.snapshot().state.lanes.queue?.[chatId]?.queue || []
+        if (durableQueue.length) {
+          authority.close()
+          throw new Error('C2 v2 unstarted runner left queued receipts unsettled')
+        }
+        try {
+          for (const id of rt.v2QueueReceiptIds || []) this.durableV2Payloads.dropConfirmed(id)
+        } catch (dropError) { authority.close(); throw dropError }
+        rt.v2QueueReceiptIds = []
+        // A resume the server itself rejected leaves the saved thread unusable
+        // (missing rollout, unreadable history). As /new on this now idle and
+        // settled group: the next message starts a fresh session instead of
+        // meeting the same rejection again.
+        if (error.code === 'AGENT_THREAD_REJECTED' && this.store.getSession(chatId)) {
+          let locked = false
+          try { locked = this.durableV2AssertWriterLock?.() === true } catch {}
+          if (!locked) {
+            authority.close()
+            throw new Error('C2 v2 rejected-session reset lost single-writer lock')
+          }
+          this.store.resetSessionAndStats(chatId)
+          this.log(`group ${chatId}: Codex rejected the saved session before any turn; the next message starts a new session`)
+        }
         rt.v2RunnerGeneration = null
         rt.v2RunningJobs = null
         rt.v2DispatchEffect = null
         rt.v2RunnerNotStarted = true
+        // A console stop or /skip asked of this turn has nothing left to
+        // cancel; carried over, it would cancel the group's next turn.
+        if (!rt.v2StopControl) {
+          rt.v2CancelControl = null
+          rt.v2StreamQuiescing = false
+          rt.v2StopIntentGate = null
+        }
         return { effectId, accepted: false, startFailureRecovered: true }
       }
       if (capability && !accepted) {