Files
Obsidian/X-Articles-CN/智能体软件工程 3 |重新思考版本控制.md
T
coco 8b94d76799 a
2026-07-21 13:57:15 +08:00

34 KiB
Raw Blame History

title, source, author, published, created, description, tags
title source author published created description tags
智能体软件工程 #3 |重新思考版本控制 https://x.com/blackanger/status/2029816278454849643
Unknown
2026-03-05 2026-03-06
clippings

本文是"智能体软件工程"系列的第三篇。

22小时

3月3日

Git 是为人类设计的锋利刀具。Agent 需要的是安全的电动工具。

引言:版本控制的隐含假设正在瓦解

2019 年底,Google 工程师 Martin von Zweigbergk 以个人项目的名义启动了一个版本控制系统。他把命令行工具取名为 jj(因为好打字)。

项目叫 Jujutsu,因为和 jj 匹配,好像没啥实际含义。六年后,这个项目有了 25k 个 star,成了 Google 内部版本控制演进的重要方向,而它的设计理念正在被一个当初没有预料到的使用者群体重新发现: AI Coding Agent。

时间刚刚迈入 2026 年 3 月,几件事就同时发生了。

OpenAI 被报道正在构建 GitHub 竞品,起因是 GitHub 频繁的服务降级对依赖 AI Agent 持续集成的团队造成了不可接受的影响。

OpenAI 还开源了 Symphony。一个用 Elixir 实现的 Agent 编排层,核心理念是"让工程师管理工作而非监督 Agent",它为每个 Linear issue 创建隔离工作空间、启动 Codex 自主执行、收集工作证明。

与此同时,一家名为 JJHub 的创业公司宣布基于 Jujutsu 构建 Agent-Native 的开发平台,其核心论点是"AI Agent 让一个小创业公司在 commit 量上看起来和 Google 一样"。

我也看到曾经的 Rust 核心维护者 Steve (官方 Rust Book 作者,也为我的 Rust 书作过序),在 2025 年年底也基于 JJ 自己开了创业公司 ersc,Steve 也写一篇 JJ 教程 。

GitHub 自己则在 2026 年 1 月初推出了 Agentic Workflows 技术预览,试图把 AI Agent 嵌入现有的 CI/CD 框架中。

所有这些动作指向同一个事实:Git 这个统治了软件工程二十年的版本控制系统,其核心设计假设正在被 AI Coding Agent 系统性地挑战。

但挑战 Git 不是目的。版本控制只是手段,它服务的根本目标是:安全地管理代码变更的历史和并发。 在智能体软件工程的框架下,这个目标没有变,但实现方式必须根本性地重新思考。

第一部分:Git 的五个隐含假设

要理解为什么 Git 在 Agent 时代遇到困难,我们需要先解剖它的设计假设。这些假设在人类编码时代完全合理,但在 Agent 时代正在一个接一个地瓦解。

假设一:操作者理解上下文

Git 的每一个交互设计都假设操作者,人类开发者,理解自己在做什么。

  • git add -p(交互式暂存)假设你能逐行判断哪些修改应该进入下一个 commit。
  • git rebase -i(交互式变基)假设你能理解 commit 之间的依赖关系并做出正确的编辑决策。
  • git merge 产生冲突时假设你能理解双方修改的语义意图并做出合并决策。

Agent 不"理解"上下文。它基于统计推理做出决策。它可以执行 git add -A && git commit -m "..." 这种确定性的命令序列,但面对 git rebase -i 的交互式界面,需要在文本编辑器中重排 pick/squash/edit 行时,就变成了一个脆弱的操作,每一步都增加了出错的概率。

假设二:操作是顺序的

Git 的并发模型假设一个工作目录在同一时间只有一个操作者。git stash 的存在就是证明。当你需要切换上下文时,必须先"暂存"当前状态。git rebase 遇到冲突时进入一个"in progress"状态,在这个状态被解决之前,你不能做其他操作。

在 Agent 时代,并发是常态。像 OpenAI 的 Symphony 这样的编排系统可能同时管理 5-10 个 Agent,每个处理不同的 issue,它们可能需要在同一个代码库上工作。Git 的锁文件机制(.git/index.lock)和"in progress"状态在这种场景下变成了严重的并发瓶颈。

假设三:变更需要显式暂存

Git 的 staging area(index)是一个为人类认知设计的中间层。它的价值在于让你能"精选"哪些修改进入下一个 commit,这对编写精心组织的 commit 历史很重要。

但 Agent 不需要"精选"。它在一个隔离的工作空间中执行一个明确定义的任务,所有文件修改都是为了完成这个任务。git add 对 Agent 来说是一个纯粹的仪式动作,100% 的情况下是 git add -A。每一次这种仪式动作都消耗工具调用的 token 预算,增加上下文噪声,但不产生任何决策价值。

假设四:分支需要命名

Git 的分支模型要求每个分支有一个名字。这在人类工作流中有意义。你需要和同事沟通"我在 feature/user-registration 分支上"。但 Agent 的工作分支是临时的、隔离的、一次性的。为每个 Agent 会话取一个分支名是无意义的开销。

更深层的问题是:Git 的 branch 概念把"分支指针"和"代码变更"绑定在了一起。当 Agent amend 一个 commit 时,commit hash 变了,branch pointer 需要更新,任何引用旧 hash 的系统都需要跟着更新。这种引用不稳定性在自动化编排中造成了大量的协调开销。

假设五:冲突必须立即解决

Git 在遇到合并冲突时会停下来等待人类输入。git merge 产生冲突标记(<<<<<<<),git rebase 进入"in progress"状态,两者都要求你在继续之前解决冲突。

这对人类是合理的。冲突意味着两个人对同一段代码有不同的理解,需要人的判断来决定正确的合并。但对 Agent 编排系统来说,"停下来等待"是灾难性的。一个管理 10 个并行 Agent 的编排器,如果任何一个 Agent 的 rebase 被冲突阻塞,就需要介入处理。而介入本身需要上下文(理解为什么会冲突),这个上下文可能不在 Agent 编排器的范围内。

第二部分:Jujutsu 如何系统性地解决这些问题

Jujutsu(jj)不是"更好的 Git CLI",而是对版本控制数据模型的根本重新设计。它碰巧使用 Git 作为存储后端(保持兼容性),但其用户模型和 Git 完全不同。它用 Rust 实现,底层使用 gitoxide 库,所有核心开发者用 jj 开发 jj 自身。

解决方案一:一切皆 Commit,消除仪式性操作

jj 把 Git 中四种不同的"状态容器"(working directory、staging area、stash、commit)统一为一种:commit。

你的工作副本(@)就是一个 commit。你编辑文件时,jj 自动把变更快照为这个 commit 的更新。没有 staging area,没有 stash,没有 "dirty working directory" 的概念。

图像

对 Agent 来说这意味着:

工具调用从 2 步变成 0 步。 Git 的 git add -A && git commit -m "..." 在 jj 中不需要。修改文件就是"提交"。Agent 只需要在想表达语义边界时执行 jj new(开始一个新 change)和 jj describe(描述 change 的意图)。

永远不会出现阻塞性错误。 "Your local changes to the following files would be overwritten by merge"这种 Git 错误在 jj 中不存在,因为没有"未提交的修改"这个概念。

示例

# jj:编辑文件后 vim src/auth.rs # 修改文件——完了。 # jj 自动把当前工作副本快照为 @ commit 的更新 # 不需要 add,不需要 commit jj describe -m "实现登录" # (可选)给这个 change 加个描述

关键机制:jj 运行任何命令时(jj status、jj log、jj new 等),都会先自动快照工作副本的所有变更到当前 @ commit 中。所以你的"未保存修改"实际上每时每刻都是被保存的。

Git 的心智模型: 文件修改 ──是一种──→ "未跟踪的脏状态"(危险,可能丢失) jj 的心智模型: 文件修改 ──是一种──→ "@ commit 的最新内容"(安全,已快照)

jj 没有 staging area,但它用 split 来做同样的事,而且更灵活:

# jj:此时 @ commit 已经包含了所有 3 个文件的修改(自动快照的) jj split # 交互式地把当前 @ commit 拆分成两个 commit # 界面让你选择哪些文件/哪些 hunk 进入第一个 commit # 剩余的自动成为第二个 commit

Git 的思路: 修改 → 挑选哪些"进入"staging → commit → 剩余留在 working dir (先选后存) jj 的思路: 修改 → 全部自动进入 @ commit → split 拆分出你想要的部分 (先存后拆) 区别:jj 的方式永远不会"丢东西"——所有修改始终在某个 commit 中。 Git 的方式中 working directory 的修改可能因为误操作丢失。

所以, jj 的心智模型比 git 更加简单。

核心思想转变是:Git 要求你在做修改之前决定"这个修改去哪"(working dir? stage? stash?),jj 让你先做修改,之后再组织。 所有修改永远安全地存在于某个 commit 中,你可以事后拆分(split)、移动(squash/move)、描述(describe)。这种"先存后整理"的模型天然消除了数据丢失的风险。

对 Agent 来说,这意味着 Agent 只需要知道两个操作:jj new(开始一个新的逻辑变更)和 jj describe(给它写描述)。其他一切,诸如保存、暂存、临时保存,版本控制系统自动处理了。

解决方案二:Change ID,稳定的逻辑标识

jj 区分了两个层次的标识:

  • Revision:一个不可变的快照(类似 Git 的 commit hash),每次修改内容都产生新的 revision
  • Change:一个稳定的逻辑标识(change ID),无论你怎么修改一个 change 的内容,其 change ID 不变

图像

这对编排系统至关重要。 像 Symphony 这样的 Agent 编排系统需要追踪"这个 issue 对应的代码变更"。用 Git 的 commit hash,Agent 每次 amend 都会打断这种关联。用 jj 的 change ID,无论 Agent 修改多少次,编排器都能通过 change ID 稳定地追踪。

解决方案三:冲突是一等对象,不阻塞,不中断

这是 jj 从 Darcs/Pijul 借鉴的最深层创新。

Git 中冲突是一种阻塞状态.你被卡住了,必须先解决冲突才能继续。jj 中冲突是数据,一个 commit 可以"含有冲突",这和它含有一个函数或一个文件没有本质区别。

技术实现上,jj 不存储文本冲突标记(<<<<<<<),而是维护冲突树的逻辑表示:一系列 diff 的组合。这意味着 rebase 一个含冲突的 commit 不会产生"嵌套冲突标记"的噩梦。

图像

更重要的设计含义:

rebase 永远"成功"。 没有 git rebase --continue,没有"in progress"状态。操作是原子的——它要么完成(可能产生含冲突的 commit),要么因为其他原因失败。

冲突解决可以传播。 如果你在某个 change 中解决了冲突,jj 会自动把解决方案传播到所有后代 change。这类似 Git 的 rerere(record/replay resolve),但它是默认行为且更可靠。

冲突可以延后处理。 Agent 完成工作后,编排器可以检查是否有含冲突的 change,然后决定是让 Agent 解决、启动一个专门的冲突解决 Agent、还是升级给人类。冲突不再是"流水线卡住了",而是"产出中有一个需要额外处理的标记"。

解决方案四:Operation Log,完整的操作审计

Git 有 reflog,但它只记录 branch tip 的移动,格式晦涩,主要用于灾难恢复。

jj 的 operation log 记录你对仓库执行的每一个操作。每条记录是一个原子操作,即使一个 rebase 涉及 10 个 commit,它也是 operation log 中的一条记录。

图像

# 查看操作历史 jj op log # 撤销最近一次操作(原子的) jj undo # 回退到任意历史操作的状态 jj op restore

对 Agent 来说,这是"时间机器"。 Agent 做了一个灾难性操作?不需要从 reflog 中人肉找到正确状态,一个 jj op restore 精确回到之前的时刻。编排系统可以在 Agent 每次操作前记录 operation ID,失败时一键回滚。

解决方案五:自动 Rebase,多 Agent 并发的基础

当你修改一个 commit,jj 自动把所有后代 rebase 到新版本上。配合冲突是一等对象的设计,这个自动 rebase 即使产生冲突也不会阻塞。

图像

这是 jj 最核心也最反直觉的设计。

Git 在产生冲突时会产生嵌套冲突标记——<<<<<<< 里面套 <<<<<<<,基本上不可读。我相信这是每个人类开发者最头疼的地方吧。

jj 对冲突的理解完全不同。它不在文件里插入文本标记,而是在数据模型层面记录"这个文件有多个版本,它们之间有分歧"。

内部表示是一个冲突树(conflict tree),不是文本,而是结构化数据。

jj 内部对一个冲突文件的表示(概念模型,不是实际格式):

file: src/auth.rs
conflict:
  base:    "fn login(user: &str, pass: &str) -> bool { ... }"    # 共同祖先
  side_1:  "fn login(user: &str, pass: &str) -> bool {           # 一方的修改
               validate_credentials(user, pass)
            }"
  side_2:  "fn login(user: &str, pass: &str) -> Result<...> {    # 另一方的修改
               let valid = check_password(user, pass)?;
            }"

当你 checkout 或查看这个文件时,jj 渲染成类似 Git 的冲突标记格式给你看。但这只是展示层,底层存储的是结构化的三方数据,不是文本标记。

存储层:结构化的冲突树(base + side_1 + side_2)
         │
         ▼ (当你打开文件时,渲染为人类可读格式)
展示层:类似 Git 的 <<<<<<< 标记(但这只是视图,不是数据)

这个区别至关重要。因为结构化数据可以被程序精确操作,而文本标记只能被人类阅读。

自动 Rebase 时冲突怎么处理

情况一:rebase 没有冲突

最简单的情况。两个 change 修改了不同的文件或同一文件的不同区域:

修改前: main: A ← B ← C ↑ 你修改了 B 变成 B'(比如改了 src/auth.rs) 自动 rebase: C 依赖 B。B 变成了 B'。jj 自动把 C rebase 到 B' 上。 结果:A ← B' ← C' 如果 C 修改的是 src/config.rs(和 B' 修改的 src/auth.rs 没有重叠) → C' 干净地应用,没有冲突。自动完成,你什么都不需要做。

情况二:rebase 产生冲突,jj 怎么"成功"

关键来了。假设 B 和 C 都修改了同一个文件的同一个区域:

修改前: A ← B ← C ← D ↑ 你修改了 B 变成 B'(改了 src/auth.rs 第 10-20 行) 但 C 也修改了 src/auth.rs 第 10-20 行 Git 的行为: git rebase --onto B' B D → 处理 C 时发现冲突 → 停!在 src/auth.rs 中插入 <<<<<<< 标记 → 进入 "rebase in progress" 状态 → 等你解决冲突并执行 git rebase --continue → D 还没被处理,挂起 jj 的行为: jj 修改 B → B',自动 rebase C 和 D → 处理 C 时发现冲突 → 不停!创建 C',其中 src/auth.rs 被记录为"冲突状态": conflict: base: B 版本的 src/auth.rs 第 10-20 行 side_1: B' 版本的第 10-20 行(你的修改) side_2: C 版本的第 10-20 行(C 的修改) → C' 是一个"含有冲突的 commit"——但它是一个合法的 commit! → 继续处理 D → D' rebase 到 C' 上 → 如果 D 没碰 src/auth.rs 第 10-20 行,D' 是干净的 → 如果 D 也碰了,D' 也被标记为含有冲突 → 操作完成。整个 rebase 链没有中断。

图像

情况三:怎么解决冲突

当你决定要解决 C' 中的冲突时:

# 查看哪些 changes 有冲突
jj log
# 输出中会标记:
# ⚠ kkmpptqz (conflict) "feature: 实现注册"

# 切换到冲突的 change
jj edit kkmpptqz

# 此时你打开 src/auth.rs,看到的是渲染出来的冲突标记:
# <<<<<<< Side #1 (你的修改 B')
# fn login(...) -> bool {
#     validate_credentials(user, pass)
# ||||||| Base (共同祖先 B)
# fn login(...) -> bool {
#     check(user, pass)
# ======= Side #2 (C 的修改)
# fn login(...) -> Result<...> {
#     let valid = check_password(user, pass)?;
# >>>>>>> 

# 你(或 Agent)编辑文件,删除标记,写出正确的合并结果
# 保存文件

# jj 自动检测到冲突标记消失了 → 这个 change 不再是 conflicted
# 而且——关键——D' 会被自动 rebase 到解决了冲突的 C' 上
# 如果 D' 之前因为 C' 的冲突而连带 conflicted,
# 现在冲突解决后 D' 可能也自动变干净了

情况四:冲突解决的传播,这才是杀手级特性

解决冲突前:

A ← B' ← C'(⚠冲突) ← D'(⚠连带冲突) ← E'(⚠连带冲突)

解决 C' 的冲突后: A ← B' ← C''(✓干净) ← D''(?) ← E''(?)

jj 自动把冲突解决传播到 D'' 和 E''。
  如果 D 和 E 的冲突完全是由 C 的冲突引起的,
  D'' 和 E'' 自动变干净,不需要你逐个解决。

  Git 中你需要对 C, D, E 每一个都手动解决冲突。
  jj 中你只需要解决 C 的冲突,D 和 E 可能自动修复。

这就像 Git 的 `rerere`(record/replay resolved conflicts),但 jj 的实现更根本,它不是"记住你之前解决过类似的冲突然后重放",而是"冲突解决本身就是一个可以被 rebase 传播的 diff"。

为什么"冲突是数据"如此重要

把冲突从"状态"变成"数据"的本质影响:

图像

Agent 解决冲突的可能方式

因为 jj 的冲突是结构化数据(base + side_1 + side_2),Agent 可以获得比 Git 更丰富的信息来解决冲突:

# Agent 看到的信息

# Git:一个文件里混着 <<<<<<< 标记的文本
# Agent 需要从文本中解析出"哪是 ours,哪是 theirs,哪是 base"
# 容易解析错,尤其是嵌套冲突

# jj:结构化的三方数据
# base:   原始版本(共同祖先)
# side_1: 第一方修改
# side_2: 第二方修改
# Agent 可以精确获取三方各自的完整内容

# 一个合理的 Agent 冲突解决策略:
# 1. 提取 base, side_1, side_2 的完整内容
# 2. 理解 side_1 的意图(从 change description 或关联的 Contract)
# 3. 理解 side_2 的意图(同上)
# 4. 生成合并结果
# 5. 验证合并结果满足两方的 Contract

如果我们进一步把 Contract (某种 Spec 的约束) 和 change 绑定,冲突解决就变得更有依据了:

change kkmpptqz (side_1) → contract-042 "实现用户注册"
change rrsnntyz (side_2) → contract-057 "修复登录验证"

冲突发生在 src/auth.rs

冲突解决 Agent 可以获取两个 Contract 的意图:
  - contract-042 要求:注册时用 bcrypt-12 哈希密码
  - contract-057 要求:登录时验证密码并返回 JWT

→ Agent 有足够的语义信息来判断如何合并:
   两者修改了不同的功能(注册 vs 登录),
   合并结果应该同时包含注册逻辑和修复后的登录逻辑。

这就是冲突是数据 + Spec-Change 绑定的协同效应,冲突不再是"两段不知为何打架的代码",而是"两个已知意图的变更在同一区域的重叠",有了意图信息,解决方案就有了判断依据。

解决方案六:workspace,多 Agent 并发的优势

Git worktree 是多 Agent 并发工作的一个重要场景。jj 也有自己的方案,而且比 Git worktree 更干净。

Git worktree 的核心场景:你想同时在同一个仓库的不同分支上工作,但不想来回 stash/checkout。

jj 对应的概念叫 workspace。但它的模型比 Git worktree 更简洁,因为 jj 没有 index/staging area,每个 workspace 的状态就是一个 @ commit,没有别的东西。

# jj:创建多个 workspace
jj workspace add ../feature-login
jj workspace add ../bugfix-auth

# 现在你有三个目录:
# ./repo              ← 默认 workspace,@ = 某个 change
# ../feature-login    ← workspace "feature-login",@ = 另一个 change
# ../bugfix-auth      ← workspace "bugfix-auth",@ = 又一个 change

# 它们共享同一个 jj 仓库数据
# 每个 workspace 有自己独立的 @ (working copy commit)

# 查看所有 workspace
jj workspace list

# 输出:
# default: kkmpptqz (当前 change)
# feature-login: rrsnntyz (另一个 change)
# bugfix-auth: ppmmlkqz (又一个 change)

关键区别

图像

jj workspace 的每个实例只有 **一层状态**: 每个 jj Workspace 的状态: @ commit(当前 working copy change) 没有 staging area,没有 "in progress" 状态。 编排器只需要知道"这个 workspace 的 @ 指向哪个 change"。

这就是"一切皆 commit"在 workspace 场景下的体现: 每个 workspace 的完整状态就是一个 change ID。编排器追踪 N 个 Agent 的状态,就是追踪 N 个 change ID,而不是 N × (working dir + index + HEAD + 可能的中间状态) 的笛卡尔积。

对 Agent 编排的意义

图像

所以 jj workspace 不只是"Git worktree 的替代品",它通过消除 staging area 和中间状态,把每个工作空间的状态复杂度从 多维 压缩到了 一维(一个 change ID)。对于需要管理多个并行 Agent 的编排系统来说,这是数量级的简化。

第三部分:当 Spec 遇到版本控制,Spec-Change 绑定

回顾:Spec 在智能体软件工程中的角色

在本系列的前一篇文章中,我们建立了智能体软件工程的核心框架:Spec 是控制面,Code 是数据面,Agent 是执行面。 人类的核心工作是编写 Spec(规格说明),Agent 负责将 Spec 转化为代码实现,验证系统确认代码满足 Spec。

在这个框架中,我们把给 Agent 执行的任务级 Spec 称为 Task Contract(任务合约)。一个结构化的文档,包含四个核心要素:

  • 意图(Intent):做什么,以及为什么
  • 已定决策(Decisions):已经确定的技术选择,消除 Agent 的决策空间
  • 边界(Boundaries):允许修改哪些文件、禁止做哪些事
  • 完成条件(Completion Criteria):BDD 格式的验收标准,确定性的通过/失败检查

Contract 的概念来源于我们对 Code Review 危机的分析:当 AI 代码生产速度远超人类审查能力时,解决方案不是"更快地审查代码",而是把人类的审查点上移到意图层——人类审查 Spec/Contract 是否正确定义了意图和验收标准,机器验证代码是否满足 Contract。

当前的断裂:Spec 和版本控制是两个世界

在今天的工具链中,Spec(无论是 GitHub Issue、Jira Ticket 还是我们定义的 Contract)和版本控制系统之间的关联是脆弱的、约定式的:

图像

这种断裂在人类手动开发时可以接受——人类在心里维护着"我正在为 Issue #42 写代码"的关联。但在 Agent 编排系统中,这种关联必须是形式化的、可查询的、不会因为 amend 而断裂的。

Spec-Change 绑定:jj 提供的机会

jj 的两个特性为解决这个问题提供了基础:

Stable Change ID 解决了"amend 打断关联"的问题。无论 Agent 修改多少次,change ID 不变,编排系统可以始终用 change ID 追踪"这个 Contract 对应的代码变更"。

Git 外部的元数据存储 解决了"关联靠约定"的问题。jj 已经在 Git 仓库外存储了 bookmarks 等元数据。Contract 绑定可以作为另一种元数据,成为版本控制的一等公民。

图像

这个模型让 Spec 和版本控制从"两个松散关联的世界"变成了"一个统一的追溯链":

人类定义 Spec/Contract
       │
       ▼
Agent 生成 Changes(关联到 Contract)
       │
       ▼
验证系统检查 Changes 是否满足 Contract 的 Criteria
       │
       ▼
Contract Acceptance(人类审查 Contract 定义是否正确 + 验证是否全部通过)

Spec 层级与版本控制的对应

在我们的 Spec 设想中,Spec 分为三层:

  • L0 组织级 Spec(安全策略、架构原则),变化极慢
  • L1 项目级 Spec(技术栈、模块边界、API 契约),变化缓慢
  • L2 任务级 Spec / Contract(具体任务的意图、约束、验收标准),每任务一个

这三层和版本控制的对应关系是:

图像

关键洞察:L0 和 L1 的 Spec 本身就应该版本化在代码仓库中。它们是代码的"宪法",变更 L0/L1 Spec 应该像修宪一样慎重,并且有完整的变更历史。L2 Contract 则是"工单"级别的,它的生命周期和对应的 changes 一起开始、一起结束。

第四部分:Agent-Native VCS 还缺什么

jj 解决了 Git 在 Agent 场景下的大部分摩擦点。但从智能体软件工程的完整框架来看,还有几个维度是当前 jj 尚未覆盖的。

原语一:验证状态作为 Change 属性

当前的版本控制系统不知道一个 change 是否通过了测试。CI/CD 是外部系统,验证结果存在 GitHub Actions 或 Jenkins 里,不在版本控制系统中。

在 Agent-Native VCS 中,验证状态应该是 change 的内在属性:

Change kkmpptqz:
  revision: abc123
  description: "实现注册 endpoint"
  contract: contract-042
  verification:
    L1_type_check: PASS (2s)
    L2_contract: PASS (5s)
    L3_bdd: PASS (30s)
    L4_adversarial: PENDING
  status: verified_to_L3

这让"这个变更可以合并吗?"成为版本控制系统可以直接回答的问题,不需要去查外部 CI 系统。合并的门控从"人类点 approve"变成"验证引擎确认所有层通过"。

原语二:Agent 身份与权限

Git 的 author/committer 字段用 name + email 标识。在多 Agent 并发工作的场景下,我们需要更丰富的身份信息:

Change kkmpptqz:
  agent: claude-code-session-7a3b
  role: implementer
  contract: contract-042
  permissions: workspace-write, files=[src/auth/**]
  orchestrator: symphony-run-019

这让审计系统可以回答:"这段代码是哪个 Agent 在什么权限下生成的?" 在合规场景中,这比 "Author: bot@ci.example.com" 有价值得多。

原语三:快照时间线而非 DAG

Git 的 commit DAG(有向无环图)是为人类理解 branch/merge 历史设计的。但当 10 个 Agent 并行工作时,DAG 变成一团不可读的意大利面条。

Agent-Native 的历史可视化应该是按时间线排列的快照序列,可以按 Contract、按 Agent、按模块过滤。想象一个时间轴,每个 Agent 是一条泳道,Contract 是颜色编码,你可以 scrub 到任何时刻看到代码库在那个瞬间的状态。

jj 的 operation log 已经提供了部分基础。它按时间记录所有操作。缺的是和 Contract/Agent 身份的关联,以及可视化层。

第五部分:从 Code Review 到 Contract Acceptance

版本控制的变革不仅仅是工具层面的,它连带着改变了整个协作模型。

传统模型:Branch → PR → Code Review → Merge

GitHub 围绕 Pull Request 构建了整个协作流程。开发者创建 branch,推送代码,开 PR,同事 review 代码 diff,approve 后合并。

这个流程在 Agent 时代面临三个根本问题:

1. Review 的对象错了。 在我们之前的《重新思考 Code Review》文章中详细分析过,当 AI 以机器速度生成代码时,人类逐行审查代码 diff 是不可扩展的。Faros AI 的数据显示 PR 合并率暴涨 97.8% 而 Review 时间暴涨 91.1%。

2. Branch 的粒度错了。 一个 Agent 可能在几分钟内完成一个 Contract,创建 branch → push → 开 PR → 等 review → merge 的流程比实际工作时间还长。

3. Merge 的门控错了。 PR 的 approve 按钮是一个人类判断,"这段代码看起来对"。但验证应该是确定性的,"这段代码通过了所有验证层"。

Agent-Native 模型:Contract → Changes → Verification → Acceptance

图像

在这个模型中:

Contract 取代 Issue + PR description。 Contract 是结构化的、包含验收标准的、可自动化验证的。它不是"给人看的任务备忘录",而是"给 Agent 消费的可执行规格 + 给验证系统执行的检查清单"。

Changes 取代 Branch。 jj 的匿名 changes + stable change ID 意味着不需要 branch 名称,编排系统通过 change ID 追踪。

Verification Pipeline 取代 Code Review。 从类型检查到合约验证到 BDD 测试到对抗性 Agent 审查,多层确定性验证提供了比人类 Code Review 更全面、更快速、更可扩展的质量保证。

Contract Acceptance 取代 PR Approve。 人类审查的不是代码 diff,而是:"这个 Contract 的验收标准是否正确定义?验证结果是否表明 Contract 被正确满足?"

第六部分:实践指南 - 如何在现有工具链中渐进采用

理想很美好,但大多数团队不会一夜之间抛弃 Git 和 GitHub。以下是一个渐进式的采用路径。

Level 0:在 Git 仓库中 colocate jj(零风险)

jj 支持和 Git 仓库共存(colocate 模式),这意味着你可以在任何现有 Git 仓库中开始使用 jj,不影响团队中其他人继续使用 Git。

# 在现有 Git 仓库中初始化 jj(两者共存) cd your-repo jj git init --colocate # 现在可以同时使用 jj 和 git # jj 操作会同步到 Git,git 操作也对 jj 可见

对 Agent 的即时价值:

  • jj op log 提供了 Agent 操作的完整审计
  • 自动快照意味着 Agent 不会"丢失"未提交的修改
  • jj op restore 在 Agent 犯错时精确回退

Level 1:Agent 工作空间使用 jj

在 Claude Code / Codex CLI 的工作空间中,用 jj 替代 git 作为 Agent 的版本控制工具:

# Agent 的工具集简化 # 不需要: git add, git stash, git rebase --continue # 只需要: jj new, jj describe, jj bookmark set, jj git push

关键收益: Agent 的版本控制工具调用量减少 30-50%(消除了 git add、git stash、git rebase --continue 等仪式性操作),每次节省的工具调用都是更多可用于实际工作的上下文预算。

Level 2:用 Change ID 追踪任务

在 Agent 编排系统中,用 jj 的 change ID 替代 Git 的 commit hash 来追踪变更。change ID 跨 amend 稳定,编排器无需在 Agent 每次修改后重新绑定引用。

Level 3:利用冲突即数据的特性

在多 Agent 并发场景中,不再把冲突视为"错误",而是视为"需要额外处理的状态":Agent 完成后检查是否有冲突标记的 changes。简单冲突自动解决,复杂冲突升级给人类。流水线永远不会被"卡住"。

第七部分:对比总览

Git vs jj vs 理想 Agent-Native VCS

图像

关键结论:jj 已经解决了 80% 的 Agent-VCS 摩擦。通过"一切皆 commit"、change ID、冲突即数据、自动 rebase。剩下的 20% 是需要和智能体软件工程上层(Spec/Contract、验证管道、Agent 编排)联动的部分。

结语:版本控制反映了它服务的工作方式

回顾版本控制的历史,每一代系统都反映了它所处时代的工作方式:

CVS/SVN 时代:中央服务器,顺序提交。反映了"一个团队、一个代码库、一个集成经理"的瀑布式开发。

Git 时代:分布式,分支廉价。反映了"分布式团队、并行开发、Pull Request 协作"的敏捷开发。

Agent 时代:需要什么?自动快照、稳定标识、冲突即数据、原子操作、完整审计。反映了"多 Agent 并发、Spec/Contract 驱动、确定性验证、机器速度"的智能体软件工程。

Git 不是"错"了。它为人类开发者完美服务了二十年。但它的核心假设——操作者理解上下文、操作是顺序的、变更需要显式暂存、冲突必须立即解决,在 Agent 时代成了摩擦力而不是功能。

Jujutsu 提供了一条务实的演进路径:保持 Git 兼容性(不破坏现有生态),同时引入 Agent-Native 的数据模型和操作语义。 它不需要你抛弃 GitHub,不需要团队全员切换,不需要重建 CI/CD,但它给了 Agent 一个安全的、确定性的、不会被"卡住"的版本控制接口。

而当我们把版本控制和 Spec/Contract 系统联动起来。通过 Change ID 实现 Contract-Change 绑定、通过验证状态集成实现自动化门控、通过 Agent 身份实现完整审计,版本控制就从一个孤立的"代码存储层"升级为智能体软件工程的核心基础设施。

Spec 是控制面,Code 是数据面,Agent 是执行面,而版本控制是承载数据面的物理层。 当物理层从"为人类设计的锋利刀具"变成"为 Agent 设计的安全电动工具"时,整个上层系统的设计空间都会被打开。