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

557 lines
34 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
title: "智能体软件工程 #3 |重新思考版本控制"
source: "https://x.com/blackanger/status/2029816278454849643"
author:
- "[[Unknown]]"
published: 2026-03-05
created: 2026-03-06
description:
tags:
- "clippings"
---
本文是"智能体软件工程"系列的第三篇。
> 22小时
> 3月3日
> Git 是为人类设计的锋利刀具。Agent 需要的是安全的电动工具。
## 引言:版本控制的隐含假设正在瓦解
2019 年底,Google 工程师 Martin von Zweigbergk 以个人项目的名义启动了一个版本控制系统。他把命令行工具取名为 jj(因为好打字)。
项目叫 [Jujutsu](https://github.com/jj-vcs/jj),因为和 jj 匹配,好像没啥实际含义。六年后,这个项目有了 25k 个 star,成了 Google 内部版本控制演进的重要方向,而它的设计理念正在被一个当初没有预料到的使用者群体重新发现: AI Coding Agent。
时间刚刚迈入 2026 年 3 月,几件事就同时发生了。
[OpenAI 被报道正在构建 GitHub 竞品](https://www.reddit.com/r/technology/comments/1rk8bfa/openai_is_developing_alternative_to_microsofts/),起因是 GitHub 频繁的服务降级对依赖 AI Agent 持续集成的团队造成了不可接受的影响。
OpenAI 还开源了 [Symphony](https://github.com/openai/symphony)。一个用 Elixir 实现的 Agent 编排层,核心理念是"让工程师管理工作而非监督 Agent",它为每个 Linear issue 创建隔离工作空间、启动 Codex 自主执行、收集工作证明。
与此同时,一家名为 [JJHub](https://markdowntorichtext.com/[https://jjhub.tech]\(https://jjhub.tech/\)) 的创业公司宣布基于 Jujutsu 构建 Agent-Native 的开发平台,其核心论点是"AI Agent 让一个小创业公司在 commit 量上看起来和 Google 一样"。
> 我也看到曾经的 Rust 核心维护者 Steve (官方 Rust Book 作者,也为我的 Rust 书作过序),在 2025 年年底也基于 JJ 自己开了创业公司 [ersc](https://ersc.io/),Steve 也写一篇 [JJ 教程](https://steveklabnik.github.io/jujutsu-tutorial/introduction/introduction.html) 。
GitHub 自己则在 2026 年 1 月初推出了 [Agentic Workflows](https://github.com/github/gh-aw) 技术预览,试图把 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" 的概念。
![图像](https://pbs.twimg.com/media/HCtVLy7aUAcEA_Y?format=png&name=large)
对 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 不变
![图像](https://pbs.twimg.com/media/HCtVhR0aUAIiUZI?format=png&name=large)
**这对编排系统至关重要。** 像 Symphony 这样的 Agent 编排系统需要追踪"这个 issue 对应的代码变更"。用 Git 的 commit hash,Agent 每次 amend 都会打断这种关联。用 jj 的 change ID,无论 Agent 修改多少次,编排器都能通过 change ID 稳定地追踪。
**解决方案三:冲突是一等对象,不阻塞,不中断**
这是 jj 从 Darcs/Pijul 借鉴的最深层创新。
Git 中冲突是一种**阻塞状态**.你被卡住了,必须先解决冲突才能继续。jj 中冲突是**数据**,一个 commit 可以"含有冲突",这和它含有一个函数或一个文件没有本质区别。
技术实现上,jj 不存储文本冲突标记(<<<<<<<),而是维护冲突树的逻辑表示:一系列 diff 的组合。这意味着 rebase 一个含冲突的 commit 不会产生"嵌套冲突标记"的噩梦。
![图像](https://pbs.twimg.com/media/HCtWAiqaUAIB152?format=png&name=large)
更重要的设计含义:
**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 中的一条记录。
![图像](https://pbs.twimg.com/media/HCtWFszbIAAzd-x?format=png&name=large)
\# 查看操作历史 jj op log # 撤销最近一次操作(原子的) jj undo # 回退到任意历史操作的状态 jj op restore <operation-id>
**对 Agent 来说,这是"时间机器"。** Agent 做了一个灾难性操作?不需要从 reflog 中人肉找到正确状态,一个 jj op restore 精确回到之前的时刻。编排系统可以在 Agent 每次操作前记录 operation ID,失败时一键回滚。
**解决方案五:自动 Rebase,多 Agent 并发的基础**
当你修改一个 commit,jj 自动把所有后代 rebase 到新版本上。配合冲突是一等对象的设计,这个自动 rebase 即使产生冲突也不会阻塞。
![图像](https://pbs.twimg.com/media/HCtWSxIaUAQVrno?format=png&name=large)
这是 jj 最核心也最反直觉的设计。
Git 在产生冲突时会产生**嵌套冲突标记**——<<<<<<< 里面套 <<<<<<<,基本上不可读。我相信这是每个人类开发者最头疼的地方吧。
jj 对冲突的理解完全不同。它不在文件里插入文本标记,而是在**数据模型层面**记录"这个文件有多个版本,它们之间有分歧"。
内部表示是一个**冲突树(conflict tree)**,不是文本,而是结构化数据。
jj 内部对一个冲突文件的表示(概念模型,不是实际格式):
```text
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 的冲突标记格式给你看。但这只是**展示层**,底层存储的是结构化的三方数据,不是文本标记。
```text
存储层:结构化的冲突树(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 链没有中断。
![图像](https://pbs.twimg.com/media/HCtWoC4aUAIFD0Q?format=png&name=large)
**情况三:怎么解决冲突**
当你决定要解决 C' 中的冲突时:
```text
# 查看哪些 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''(?)
```text
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"。
**为什么"冲突是数据"如此重要**
把冲突从"状态"变成"数据"的本质影响:
![图像](https://pbs.twimg.com/media/HCtYa8vaUAA2tIJ?format=png&name=large)
**Agent 解决冲突的可能方式**
因为 jj 的冲突是结构化数据(base + side\_1 + side\_2),Agent 可以获得比 Git 更丰富的信息来解决冲突:
```text
# 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 绑定,冲突解决就变得更有依据了:
```text
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,没有别的东西。
```text
# 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)
```
关键区别
![图像](https://pbs.twimg.com/media/HCtZKL9bgAAzfy9?format=png&name=large)
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 编排的意义**
![图像](https://pbs.twimg.com/media/HCtZaFfbUAAvrhD?format=png&name=large)
所以 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)和版本控制系统之间的关联是**脆弱的、约定式的**:
![图像](https://pbs.twimg.com/media/HCtZn4faUAQfyg_?format=png&name=large)
这种断裂在人类手动开发时可以接受——人类在心里维护着"我正在为 Issue #42 写代码"的关联。但在 Agent 编排系统中,这种关联必须是形式化的、可查询的、不会因为 amend 而断裂的。
**Spec-Change 绑定:jj 提供的机会**
jj 的两个特性为解决这个问题提供了基础:
**Stable Change ID** 解决了"amend 打断关联"的问题。无论 Agent 修改多少次,change ID 不变,编排系统可以始终用 change ID 追踪"这个 Contract 对应的代码变更"。
**Git 外部的元数据存储** 解决了"关联靠约定"的问题。jj 已经在 Git 仓库外存储了 bookmarks 等元数据。Contract 绑定可以作为另一种元数据,成为版本控制的一等公民。
![图像](https://pbs.twimg.com/media/HCtaHgabsAAiAfP?format=png&name=large)
这个模型让 Spec 和版本控制从"两个松散关联的世界"变成了"一个统一的追溯链":
```text
人类定义 Spec/Contract
│
▼
Agent 生成 Changes(关联到 Contract)
│
▼
验证系统检查 Changes 是否满足 Contract 的 Criteria
│
▼
Contract Acceptance(人类审查 Contract 定义是否正确 + 验证是否全部通过)
```
**Spec 层级与版本控制的对应**
在我们的 Spec 设想中,Spec 分为三层:
- **L0 组织级 Spec**(安全策略、架构原则),变化极慢
- **L1 项目级 Spec**(技术栈、模块边界、API 契约),变化缓慢
- **L2 任务级 Spec / Contract**(具体任务的意图、约束、验收标准),每任务一个
这三层和版本控制的对应关系是:
![图像](https://pbs.twimg.com/media/HCtagDhaUAEOg21?format=png&name=large)
关键洞察:**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 的内在属性:
```text
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 并发工作的场景下,我们需要更丰富的身份信息:
```text
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](https://x.com/blackanger/status/)" 有价值得多。
原语三:快照时间线而非 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
![图像](https://pbs.twimg.com/media/HCtav3obkAAg2H8?format=png&name=large)
在这个模型中:
**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
![图像](https://pbs.twimg.com/media/HCtbBEDaUAYXWBb?format=png&name=large)
**关键结论: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 设计的安全电动工具"时,整个上层系统的设计空间都会被打开。