最近 @poteto 的关于使用证明方法消除 AI 代码问题的演讲很有名。我从 2023 年开始就一直很努力想要通过在 AI 生成过程中引入形式化方法来改善 AI 的生成。而这个演讲比我的想法推的要深入更多。想到我最近正好遇到一些很直接的问题,我就想用类似方法来为软件质量做一些改进。

从两个具体问题开始

下面这两段代码有什么问题?

Case 1:

if (event.code === 4401 || event.code === 4403) {
  void this.#revoked().catch(error => console.error("Revoked machine cleanup failed", error))
} else this.#reconnect()
#revoked(expected?: MachineCredentials): Promise<void> {
  if (expected && this.#credentials !== expected) return Promise.resolve()
  if (this.#revocation) return this.#revocation
  // ... 停止同步、清理定时器、关闭 socket ...
  const credentials = this.#credentials
  if (credentials) this.#credentials = { ...credentials, revoked: true }
  // 问题根源:用 Promise.all 缓存了一个一次性 Promise
  return this.#revocation = Promise.all([
    this.#peers.closeAll(),
    this.#credentials ? this.#save(this.#credentials) : undefined,
  ]).then(() => {})
}

Daemon 收到 4403 拒绝后,用 Promise.all([closeAll(), saveRevoked()]) 缓存清理任务;下次 enroll() 先 await this.#revocation 再注册。

Case 2:

this.#enrolling = true
try {
  await this.#revocation   // <--- 如果上次清理失败,这里永远直接抛错!
  // ... 请求 /api/daemon/me 验证新 token ...
  const credentials: MachineCredentials = { /* ... */ }
  await this.#save(credentials) // <--- 用 central.json.tmp -> rename 原子覆写文件
  this.#credentials = credentials
  this.#revocation = undefined
  // ...
} finally { this.#enrolling = false }

Server 建连失败后,先 revoke_peer(id),再把返回值传给 hub.revoke(peers) 通知 Daemon 关闭。

这两个 Case 是我最近在开发开源 Agent 远程管理工具 DeskFleet 遇到的具体问题。和其它大家熟悉的 ADE (Agent Development Environmen) 不同的是,DeskFleet 采用了 P2P 网络来构建远程管理的网络模型。这意味着,当你出差或者在一个临时的终端环境中,不需要去搭建某种虚拟网络环境来和你其它开发机器连接。你可以在任何一台电脑或者手机上调度任何一台电脑工作,甚至很多时候 Agent 会自发访问其它电脑来解决问题。然而这种复杂的端到端连接也带来了代价,从第一个版本 v0.1.0 到本文写作的 v0.18.1,我几乎每个版本都在修一些网络的 corner cases 问题。

上面这两个问题它们都通过了单元测试,但在多端异步交错下,前者会把机器永久锁死,后者会留下关不掉的「幽灵 Peer」。在解释它们具体造成问题的机制前,我们来简单了解一下我们采用的形式化方法是什么,它是如何帮助我们发现这些问题的。

Quint

对我来说更熟悉的形式化工具像是交互式定理证明工具 Lean,我之前也做过一些基于 Lean 的证明程序。但 DeskFleet 不是一个「复杂算法在任意 N 下是否能收敛」的命题,而是一个多进程 / 多节点异步叫错下,协议规则之间是否会撞出预期之外的漏洞。然后我想到我以前读过一篇 TiDB 使用 TLA+ 证明其分布式系统事务的文章。TLA+ 属于一种自动化状态空间搜索。工程师只需用声明式语言写清楚「有哪些状态、每个动作的前置条件与状态转移、以及哪些不变式(Invariant)不能破」。一旦设计里有漏洞,求解器会自动把一条具体的反例轨迹(Trace)吐出来。

说起来容易,但是 TLA 是很难写的。TLA 的语法过于数学,它甚至是脱离静态类型系统的,如果要参照现有代码去写证明,即使对于 AI 来说也很容易出错。于是我们使用了 Quint 语言,Quint 的语法几乎与项目的函数式 TypeScript / Rust 代码对齐,这使得规格文件和 Rust/TS 实现可以在同一个 PR 里被同一批 Reviewer 理解。Quint 并不是抛弃了 TLA+,而是站在 TLA+ 的语义肩膀上。Quint 的编译结果会通过 TLA+ 的符号模型检测器 Apalache 做实际的证明和检验。并且 Quint 允许用两种方法来运行,对于平时改代码 + CI 可以用内置 TS 仿真器(quint test)跑固定随机种子抽样 + 确定性的 run 回归,通常只要几秒就能出结果;而改动动作规则时,直接同一份文件切换成 quint verify 交给 Apalache(基于 Z3 SMT 的符号模型检测)做有界全路径搜索。

建模

然而即使 Quint 有这样那样的优点,也不代表我们能随便建模。现实代码中有太多细节在数学证明的时候都应该被抽象掉。不然不但会让验证程序非常冗长,很多细节也很难很准确建模。像是 DTLS 密码学、ICE 连通性检测、TURN 中继分配、Mux 信用帧与字节上限全部留在实现里。模型只关心授权、信令连接、节点租约和路由所有权。然后,我们还需要剥离掉物理时钟,使用状态机来替代。不引入时间戳或 24h/30s 倒计时计数器,而是直接把超时抽象为随时可能触发的动作(reservation_due、authorization_due、claim_due、link_dead、recovery_due)。这样状态空间天然有限,改超时时长配置也不会使模型失效。

在我们的 PR 中,面对跨服务端、Daemon 和多端客户端的控制面,新手最容易踩的坑,是试图把所有实体、连接、队列和认证状态塞进一个「全能模型」里。结果往往还没开始抓 Bug,状态空间就先爆炸了。grant_lifecycle.qnt 最初把不可变字段混在一张宽 Grant 映射里,Apalache 符号检测就跑了约 12 分钟;把只写一次的 Binding 拆出来后,验证耗时才压回 5 分钟左右。

因此,我们没有造巨型模型,而是遵循「正交拆分 + 最小足够基数(Small-Scope Hypothesis)」,在 specs/ 下切出了 8 个独立小模型:

flowchart LR
  subgraph L1["授权与复用生命周期 (6 步)"]
    GL["grant_lifecycle: 1 Client / 1 Daemon / 2 Peers"]
    LC["local_claim: 1 个一次性 IPC Secret"]
    MX["mux_streams: 1 个 Peer / 2 条逻辑流"]
    GL -->|"本地 Claim 过期窗口"| LC
    GL -->|"沿用 accepted_work 状态"| MX
  end

  subgraph L2["多节点路由与链路活性 (6 步)"]
    RF["route_fence: 2 API 节点 / 1 注册 / 2 Peers"]
    LL["link_liveness: 双方各 2 代连接身份"]
    CC["credential_close: 1 机器 / 2 代凭证"]
    GL -.->|"连接建立后的双向断连"| LL
  end

  subgraph L3["长链路恢复竞态 (9~11 步)"]
    OR["offer_revocation: 1 Offer / 4 帧 FIFO 队列 (9 步)"]
    RC["revocation_cleanup: 1 注册 / 1 次故障窗口 (11 步)"]
  end

  RF <-->|"Outbox 溢出回退快照"| OR
  CC -->|"凭证拒绝后的 Daemon 清理与重试"| RC

形式化验证里有个经典的经验法则:绝大多数并发协议漏洞,不需要成百上千个节点,只要存在「能产生竞争的最小基数」就会暴露。 这 8 个模型几乎把所有维度的基数都压到了这个「最小临界点」:

  • 2 个 Peer(p1、p2):1 个 Peer 测不出并发隔离性,2 个刚好够验证「吊销/溢出 p1 时不误伤 p2」以及「旧 Peer 失败后重建新 peerId 不串号」。
  • 2 个 API 节点(n1、n2)与 2 代连接身份(c1、c2 / d1、d2):足够表达跨节点抢占路由、n1 释放路由失败自我隔离后由健康节点 n2 接管,以及旧连接迟到帧被新连接身份围栏(Fence)拦下。
  • 2 条逻辑流(s1、s2):足够检验关闭一条流不会连坐兄弟流,而底层 Peer 吊销会同步释放全部流。
  • 2 代凭证(generation 0 → 1):足够覆盖「旧 Token 被吊销 → 重注册拿到新 Token → 旧 Token 的迟到 401/4401 不得撤销新凭证」的代际隔离。
  • 4 帧的 FIFO 发送队列(OUTBOX = 4):在 offer_revocation.qnt 中,队列容量被精准设为 4,刚好够同时装下「1 个在途 Offer + 2 次通知(早到通知与补发通知)+ 1 次心跳快照」。再大不会产生新语义,只会白白拉长 SMT 求解时间。

具体问题

回到一开始的两个问题,都是验证过程中被发现的。

对于第一个问题,一旦 #save(把 { ...credentials, revoked: true } 写到 central.json.tmp 再 rename)或 closeAll() 遭遇临时 I/O 失败,this.#revocation 变成一个已 rejected 的 Promise。之后每次 enroll() 都会在 await this.#revocation 处立刻失败,且不会重试也不会清除 #revocation,除非重启整个 daemon。

对于第二个问题,Promise.all 在第一个分支失败时就立刻 reject,并不会等待另一个仍在异步执行中的分支结束。假如 closeAll() 先拒绝,而旧的 #save() 还在半途写 central.json.tmp,此时直接重新 enroll() 并写入新凭证,新旧两次 #save() 会发生文件竞态覆盖。

根据这两个发现的问题,我们很快就写出了修复代码:

// enroll() 中:失败则按次重试清理
try { await this.#revocation } catch {
  // A failed cleanup must not block every later enrollment. Retry it now
  // that the fault may have cleared; a repeated failure fails only this attempt.
  this.#revocation = this.#retire()
  await this.#revocation
}
// #retire():用 Promise.allSettled 确保两个步骤都完全结束才算结算
async #retire(): Promise<void> {
  const results = await Promise.allSettled([
    this.#peers.closeAll(),
    this.#credentials ? this.#save(this.#credentials) : undefined,
  ])
  const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : [])
  if (failures.length === 1) throw failures[0]
  if (failures.length) throw new AggregateError(failures, "Revoked machine cleanup failed")
}
// apps/server/src/peers.rs
/// Durably revoke a grant whose setup failed, then always notify its daemon and owner.
/// A concurrent revocation can reach the daemon before this setup request and close
/// nothing. The store returns only newly revoked grants, so notify this grant again.
async fn revoke_failed_setup(s: &AppState, grant: &PeerAuthorization, reason: &str) -> Result<()> {
    s.store.revoke_peer(&grant.peer_id).await?;
    s.hub.revoke(vec![grant.clone()], reason).await
}
// apps/server/src/peers/signaling.rs (offer 末尾统一收敛撤权与失败通知)
let answer = match answer {
    Ok(answer) => authorize_webrtc(&req, &s, &p).await.map(|_| answer),
    failed => failed,
};
if let Err(error) = &answer
    && withdrawn(error) // 401 UNAUTHORIZED | 403 FORBIDDEN | 404 NOT_FOUND
{
    revoke_failed_setup(&s, &authorization, "negotiation_failed").await?;
}
Ok(web::Json(json!({"sdp":answer?})))

学习到了什么?

绝大多数系统的架构设计都躺在 Markdown 文档或工程师的口头共识里。自然语言有一个天然缺陷:人脑阅读文档时会自动脑补「正常路径」,极难察觉两条看似合理的规则在边界条件下会互相打架。

但复杂网络系统真正的噩梦,来自于异步交错(Interleavings)—— 断网、重启、队列积压、消息乱序、超时、重试同时按某种极罕见的顺序叠在一起。这种长链路并发场景:

  • 靠 Code Review 基本看不出来(单看每一段代码都像对的);
  • 靠单元测试很难测出来(Mock 出来的都是人能想到的已知异常)。

TLA+ 方法并不能让你的代码绝对没有 Bug——它管不到编码手误、内存溢出或真实的物理网络抖动;它真正带来的,是在最难靠直觉推理的「异步协议与架构设计层」,把原本只能靠线上事故撞出来的逻辑死角,变成可以提前推导、被机器证伪、并随代码一起演进的工程确定性。

而且 AI 极大降低了这件事的门槛,在过去如果我们打算做一个这样的事情,常常需要找几个 PL 方向的 Ph.D. 然后仔仔细细研究一两个月,这使得在快速演进的架构中很容易落后于业务代码,稍微人员一变动,就再也没人维护了。而这个 PR 的证明只靠 Grok 4.7 模型和 GPT-6 Astra 模型花了一天时间就推进到找出了具体的 bug 并修复的程度,这实在让人叹为观止。这也体现了把形式化证明融入日常开发的高度可行性。

最后大家都来用用 DeskFleet,真的写起来很爽。