自动续跑的规则只有一句话:开新一轮核查的只能是人的消息。旧实现把这句话交给「回合种类」去判断,重启一来就漏了。这次把它改成入口写下的一个持久状态,再把启动窗口里的内存缓冲换成一个 503。

1. 自动续跑是什么,规则是什么⌗

Web 对话可以打开「自动续跑」开关。开着的时候,一个回合结束后框架会注入一条核查消息,大意是「你真的做完了吗?没做完就接着做」。agent 输出约定的哨兵字符串,或者核查次数达到上限,才停下来。开关可以手动打开,也可以由一个小模型分类器在识别到「全部做完再停」这类显式指令时自动打开。

续跑消息并不全是人发的。一条线程上会到达好几种东西:

来源例子
人的消息「把这批接口改完」
核查注入框架自己发的第 N 次核查
后台唤醒子任务结果、落地结果、后台 shell 退出
重启续跑(restart-resume)进程重启前被挂起(park)的回合,重启后接着跑

已经定下的规则(docs/auto-continue.md 开头)是:

  1. 只有人的消息开启新一轮核查。
  2. 后台唤醒只能接着跑还没结束的那一轮。
  3. 没有进行中的一轮,就不注入核查。
  4. 由指令打开的开关随这一轮结束而关闭,手动打开的保持开着。

规则本身很清楚,难点在于让它在重启以后依然成立。

2. 旧实现:一个布尔,加上「这是哪种回合」⌗

旧版 maybeContinueAfterTurn 的核心判断是这一行:

if (!human && sourceMeta?.kind !== 'restart-resume' && !chain.autoContinueChainActive) return

后面还有一段:

// The chain remains active even when its first check waits on background work.
if (sourceMeta?.kind === 'restart-resume' && !chain.autoContinueChainActive) {
  await prefs.patch(channelKey, { autoContinueChainActive: true })
}

用意不难看懂。人发了消息,回合跑到一半被重启挂起,重启后以 restart-resume 的身份续跑完。这个续跑回合其实是那个人类回合,应该在结束时把链打开。可惜续跑回合本身不记得自己原来是谁,于是代码换了个问法:「是不是 restart-resume?是就放行,顺手把链置为 active。」

漏洞就在这里。被挂起的不只是人类回合。一个落地结果触发的后台回合同样可能被重启挂起,续跑时它的种类同样是 restart-resume,同样会被放行、同样把链打开。这时迭代计数早已归零,computeNextIteration 给出 0 + 1,结果就是一条从 iteration 1 起跑、找不到起点的新链。

把「这是哪种回合」当成「它有没有资格开链」的证据,本身就是错的。restart-resume 只说明这个回合是怎么被调度起来的,不说明是谁要它干活。

同一轮清查还翻出几个出口上的问题:

出口旧行为后果
哨兵置 inactive,关掉指令开的开关正确,但只有这一处关开关
超过上限置 inactive,不关开关指令打开的开关永久开着
人按停停止的回合直接跳过驱动,链不结束停了之后,后台 shell 一退出照样注入下一次核查
pinned 重试 3 次失败见下3 次的上限实际上到不了

最后一行是个纯粹的小 bug,值得单独看:

// 旧版 schedulePinnedRetry
clearPinnedRetry(channelKey)                 // 先把条目删了
const existing = pinnedRetries.get(channelKey) // 于是这里永远是 undefined
const attempt = (existing?.attempt ?? 0) + 1   // 于是永远是 1

定时器触发时还会再删一次条目,attempt 每轮都从 1 开始,「3 次全失败就停」这条分支永远走不到。新版让条目在一次核查的整个重试期间保留(触发后只把 timer 置 null),只有同一个 iteration 的重试才累加:existing?.iteration === iteration ? existing.attempt + 1 : 1。3 次耗尽后,它和其他出口一样结束链。

3. 三态:让入口把「谁在要求」写下来⌗

修法是把「这条链现在处于什么阶段」变成一列持久状态(迁移 0667_auto_continue_chain_state.sql):

ALTER TABLE thread_prefs
  ADD COLUMN auto_continue_chain_state text NOT NULL DEFAULT 'idle'
    CHECK (auto_continue_chain_state IN ('idle', 'armed', 'active'));

UPDATE thread_prefs SET auto_continue_chain_state = 'active' WHERE auto_continue_chain_active;
状态含义谁写
idle没有链链的每个出口
armed收到了人的消息,它的回合还没结束Web 入口,在回合开始之前
active那个人类回合正常结束且开关开着人类回合收尾

转移图:

                 人的消息到达(ingress,回合开始前)
   ┌──────────────────────────────────────────────┐
   ▼                                              │
 armed ──人类回合正常结束 / 续跑它的 restart-resume──► active ──┐
   │      (开关关着则 → idle)                       │  ▲      │
   │                                               │  └──────┘
   │ 人类回合失败:不动(model-gate 用同一条消息重跑)   │  后台唤醒 / 核查:
   │ 挂起(park):不动(状态原样持久化)               │  注入下一次核查
   │                                               │
   └───────── 人按停 ─────────┐                     │ 哨兵 / 超上限 /
                             ▼                     │ pinned 重试耗尽 / 人按停
                            idle ◄─────────────────┘
                             │
                             └─ 后台回合、restart-resume:什么都不开

关键在 armed。它是一个持久化的事实:「有一个人类回合在飞」。这个事实由入口写下,入口是全系统唯一确定知道「这条消息是人发的」的地方。之后不管回合被挂起几次、进程重启几次,状态都在数据库里。续跑回合结束时不用再猜自己是谁,读一下状态就行:

// 人类回合(或续跑它的 restart-resume 回合)结束:armed 在这里落定,开关关着也要落定。
const human = isMaxMessage(opts.turnText || '(附件消息)', sourceMeta)
if (human || sourceMeta?.kind === 'restart-resume') await activateAutoContinueChainForHumanTurn(prefs, channelKey)
...
if (chain.autoContinueChainState !== 'active') return

activateAutoContinueChainForHumanTurn 只认 armed:

if (row.autoContinueChainState !== 'armed') return
await prefs.patch(threadId, row.autoContinueEnabled
  ? { autoContinueChainState: 'active' }
  : { autoContinueChainState: 'idle', autoContinueChainStartedAt: null })

所以 restart-resume 的权限被收窄成只能提升 armed。线程是 idle 时,续跑出来的后台回合什么都开不了。这不靠哪条 if 写得够细,而是这个状态里本来就没有「从 idle 直接到 active」的边。

入口写 armed 用的是一条语句(armAutoContinueChain):

INSERT INTO thread_prefs (thread_id, auto_continue_iteration, auto_continue_chain_state, auto_continue_chain_started_at, updated_at)
VALUES ($1, 0, 'armed', $2, now())
ON CONFLICT (thread_id) DO UPDATE SET
  auto_continue_iteration = 0, auto_continue_chain_state = 'armed',
  auto_continue_chain_started_at = excluded.auto_continue_chain_started_at, updated_at = now()

旧版这里是两次写:先 setAutoContinueIteration(0),再 patch 起点和 active 标记。两次之间进程一死,就会留下「计数归零了、起点还是旧的」这种半新半旧的行。合成一条语句以后,这种中间态不存在了。

还有一个容易被忽略的细节:开关关着时人类回合也要落定。 测试「开关关着时人类回合也落定 armed,之后打开开关不会让续跑的后台回合开链」防的是这种情形:人发消息时开关关着,回合结束后状态如果一直停在 armed,之后有人打开开关,某个被挂起的后台回合一续跑,就会把这个旧的 armed 提升成一条链。所以落定这一步放在「开关是否开着」的判断之前。

4. 出口只有一个函数⌗

所有出口——哨兵、超上限、pinned 重试耗尽、人按停——都走 endAutoContinueChain:

async function endAutoContinueChain(prefs, channelKey, onDisabled?) {
  clearPinnedRetry(channelKey)
  pendingAutoContinue.delete(channelKey)
  const before = autoContinueOf(await prefs.get(channelKey))
  const closeSwitch = before.enabled && before.enabledBy === 'instruction'
  await prefs.setAutoContinueIteration(channelKey, 0)
  const setting = autoContinueOf(await prefs.patch(channelKey, {
    autoContinueChainState: 'idle', autoContinueChainStartedAt: null,
    ...(closeSwitch ? { autoContinueEnabled: false } : {}),
  }))
  if (closeSwitch) await onDisabled?.(setting)
}

第 2 节表里「只有哨兵会关开关」那一类问题,本质上是同一件事写了好几份,其中几份漏了一步。收成一个函数以后,就不存在「这个出口忘了关开关」的写法。

有两件事明确不走出口:

  • 人类回合失败。 model-gate 会用同一条人的消息重跑,armed 要留给那次重跑去落定。文档把代价写得很直白:失败后既没有重跑、人也没再发消息时,armed 会一直留着;此后如果恰好有个后台回合被重启挂起再续跑,它会以那条失败的消息为起点开链。下一条人的消息会重新 arm、覆盖掉它。这是一个被看见、被写下来的已知边角,没有被装作不存在。
  • 挂起。 状态原样持久化,交给续跑回合收尾时照常判定。

5. 启动窗口:把缓冲还给已经有缓冲的人⌗

另一半改动在重启窗口。

进程启动时,Web channel 建好以后,还要先把「重启前被挂起的回合」和「排队的用户消息」按顺序挂到各自线程的执行链上,之后才能接新消息。否则一条新消息可能抢在续跑提示前面,变成一个不知道自己前情的回合。

旧做法是服务端内存缓冲:

旧:  连接照收 ──► 消息落库 ──► 塞进 bootInbound[] ──► 恢复排队完 ──► createBootIngressDispatcher
                                                                  按每个 channel 的 injectChains 快照
                                                                  做顺序屏障,再逐条 deliver

这里有三个毛病:

问题原因
已落库、没有回合消息先存了,派发却在内存里等着;这个窗口里进程崩溃或被回滚,库里就多出一条永远不会被处理的人类消息
机制多缓冲数组、一个按 channel 拍快照的屏障、「只给恢复工作拍快照,免得后来的插话被排成队」这类注释里的微妙约束
和自动续跑纠缠缓冲里的人类消息什么时候 arm、什么时候和续跑回合交错,需要额外推理

新做法是入口不接收:

新:  closeInboundUntilRecovery()                       openInbound()
        │                                                   │
        ├── /ws/chat、实时分享 WS 升级 → 503 starting          │
        │   Retry-After: 2                                  ├── 之后的连接走平时的实时路径
        ├── 万一有 socket 越过升级门:第一帧 1013 关闭,          │   (续跑回合在跑 = 插话)
        │   不落库、不交给任何处理器                            │
        └── 续跑 → 排队消息 → 入链 ─────────────────────────────┘

src/server/http.ts 在升级前多了一行:

if (!webChannel.acceptsInbound()) return startingResponse()
// startingResponse: 503, 'Retry-After: 2', 'starting: restart recovery in progress'

openInbound() 要求 message、callback、host action、connection login 四类处理器都已注册,少一个就抛错,启动直接失败。宁可起不来,也不要接了连接却没人处理。

这样做之所以成立,是因为客户端本来就有缓冲:WebUI 的连接池在 socket 关闭后 3 秒重连,期间显示「重连中」;输入框只在 socket 打开时发送,没发出去的字留在框里。服务端那份内存缓冲,做的其实是客户端已经在做的事,只是多了「已落库没回合」的风险。删掉它以后,「服务端收到了但还没派发」这个状态在结构上就不存在了:要么没收(503),要么收了就走正常路径。

代价是重启时用户会多看到几秒「重连中」。测试和预演里向新起实例发消息的辅助(sendWebChat、混沌场景)因此要先等 /ws/chat 不再是 503(waitWebInboundOpen,每 250ms 探一次),和真实客户端的重连是同一种语义。

删掉的代码量也能说明问题:createBootIngressDispatcher 整个函数(13 行)没了,inject-outbox.test.ts 里那条验证「启动入口要跟在续跑和恢复的排队消息之后、又不能等其他 channel」的测试也一起删了,因为它要守的那个机制已经不存在。

6. 证据:两类,范围不同,分开报⌗

6.1 链的转移:留出序列⌗

auto-continue-chain.sequence.test.ts 是一条 22 步的事件序列:开关开着,人的消息、落地结果、任务结果、后台 shell 退出交替到达,中间穿插几次「重启挂起再续跑」。每一步写明收到了什么,期望是注入第几次核查(或不注入)以及之后的持久状态。几个关键步:

步骤期望注入期望状态
没有任何人的消息时,后台回合被挂起→重启→续跑完无idle
人发消息无armed
其回合正常结束1active
链内到达一个任务结果3active
第 3 次核查输出哨兵无idle
链结束后又一个后台回合被挂起→续跑完无(不开新链)idle
人发新消息,其回合被挂起→续跑完1active
第 1 次核查被挂起→续跑完2(计数延续)active
人按停,之后后台 shell 退出无idle

这条序列的写法有个规矩,写在文件头上:它按发现问题时的事件顺序和既定规则写出期望,只用来验收,不用来调代码——哪一步不符,改的是驱动,不是序列。修前代码在这条序列上有 3 步不符:两次续跑出来的后台回合各开了一条 iteration 1 的新链;人按停之后,后台 shell 退出仍注入了第 3 次核查。修后 22 步全部相符。

文档也写清了它证明不了什么:它证明的是这些转移在这些事件顺序下成立,不证明没列出的事件种类同样成立。以后新增唤醒来源时,要把它加进序列。

转移的单测(auto-continue.test.ts)另有六条新用例,覆盖「无人类回合在飞 = 续跑不开链」「哨兵结束后续跑不重开」「超上限连带关闭指令开关」「按停结束链但保留手动开关」「人类回合失败保持 armed、重跑成功后开链」「开关关着也落定」。pinned 重试计数累加这个修复,这次没有看到专门的新测试,这一点如实记下。

6.2 指令判定:调参集与留出集⌗

自动打开开关的分类器是概率性的,所以证据另算。auto-continue-instruction.eval.ts 把带标签的消息分成两份,各 13 行:

份内容它的正确率说明什么
TUNING_CASES提示词里引用的例句只说明模型能照着提示词里的例子答,不是泛化证据
HELD_OUT_CASES从不进提示词的消息:口语化正例、英文改写、无引号的规则讨论、转述别人的话、否定、「停掉某个服务」这类字面撞词、进度询问只有这一份算泛化证据

为了让「留出」名副其实,提示词从函数里抽成了常量 FINISH_INSTRUCTION_PROMPT,并配了一条污染测试:留出集任意一行、或其中任意连续 10 个字符出现在提示词里,测试就失败。反过来,调参集每一行都必须被提示词逐字引用,两份不得重叠。

const WINDOW = 10
function runsOf(text: string): string[] {
  if (text.length <= WINDOW) return [text]
  return Array.from({ length: text.length - WINDOW + 1 }, (_, i) => text.slice(i, i + WINDOW))
}

测量脚本 scripts/auto-continue-eval.ts 经生产路由与 LLM 配置把每行跑 N 次,两份分开出数,并列出实际服务的模型,不写调用记录表。首次测量(每行 3 次,全部由同一个免费档模型服务):调参集 39/39,留出集 39/39。

这个数字要打个折扣,文档自己就打了:两份都只有十几行,而且全是同一个作者写的,口语分布未必覆盖真实用户的说法;几次运行的正确率只能说明「在这些说法上的表现」,不能当成误开率的估计。真实误开率只能从生产的调用记录和人手动关开关的事件里看。另外还有一条流程约束:新的误判消息先进留出集,只有在提示词引用它的同一次修改里才移到调参集,并在报告里说明。

7. 回头看⌗

这次改动值得记下的地方,不在于三态比一个布尔多了一个状态,而在于由谁来回答「谁在要求干活」。

旧实现在回合结束时回答这个问题,手里只有回合种类这一条线索;重启又把这条线索抹掉了一半。新实现在消息到达时回答,而入口是唯一确定知道答案的地方,答案写进库里以后,重启抹不掉。后面所有判断都退化成读状态,restart-resume 从「一种身份」降回「一种调度方式」。

启动窗口是同一个思路的另一面:与其在服务端造一个「收到了但还没处理」的中间态,再用屏障去管它的顺序,不如干脆不收。客户端的重连和输入框本来就是缓冲,服务端没必要再存一份更脆弱的。

说点自嘲的:旧版那段 restart-resume 的特殊处理,注释写的是「链在第一次核查等后台工作时也保持 active」,读起来完全合理。问题不在那几行代码写错了,而在它在用一个推断出来的东西做判断,而这件事本该有人直接记下来。