- 静态检查只能看见直笔 SQL。走
revise()的间接写,它一个字都看不到。
〇、先说这张表
很多讨论型 AI 应用都在做一件看起来很自然的事:把大量观点、反驳、修改交给模型, 让它自动总结、聚类、提炼主题。
这个仓库不是这件事。它只解决其中一个很窄的问题:
当模型参与整理时,怎么保证它不把自己的归纳,悄悄变成事实来源。
用两个词概括这件事:单向派生 与 写隔离。
- 单向派生:底层记事实(谁说了什么、谁反驳了什么),上层把被反复质询的东西 归到一组 —— 只允许底层 → 上层派生,不允许反向流回去。
- 写隔离:上层能影响的只有展示顺序 / 默认展开 / 推荐候选; 它不许写进底层任何字段。这条边界不靠注释,靠两层机制守住。
四条硬指标:
| # | 指标 | 为什么难 |
|---|---|---|
| 1 | 15 条否证检查,python checks.py 一把跑完 | 「只派生不倒流」是承诺;这 15 条把它变成跑得起来的判据 |
| 2 | 两层守卫:B14 守单向性(写隔离),B15 守命名归人 | 不变量不靠注释和自觉,靠静态扫源码 + 行为层拍快照 |
| 3 | 信号档次比算法档次更根本 | 聚类在这里被否掉 —— 不是算法不行,是信号类别错了 |
| 4 | 核心三文件 1689 行(去空行/#注释 1202 行);全仓 Python 2860 行 | 零第三方依赖 —— scaffold.py 只 import json / sqlite3 / datetime,全仓仅用标准库。克隆下来直接跑 |
仓库地址:
https://github.com/aic-123/nested-traceable-discussion-graph
一、问题:原始事实和上层归纳混在了一起
先看一个具体的坑。
如果 AI 的某个归纳结果被重新写回底层数据,后续的人看到的已经不再是原始讨论, 而是被 AI 处理过的讨论。跑几轮以后,系统会很难回答一个最基本的问题:
这条结论究竟是用户说的,还是系统后来推出来的?
更麻烦的是,这条路径是自我强化的:
原始讨论
↓
AI 自动总结
↓
总结被写回原始知识库
↓
下一轮 AI 再读知识库,把自己的总结当成事实
↓
再次总结
所以我这个仓库的第一件事是从数据结构层面切断这条路径。
二、架构:两层,边界画在"写"上
上层:派生结构
┌─────────────────────────┐
│ Context / 分组 / 展示顺序 │
│ 推荐候选 / 默认展开 │
└───────────▲─────────────┘
│
只读派生
│
┌───────────┴─────────────┐
│ 底层事实层 │
│ Artifact / Relation │
│ Revision / Event │
└─────────────────────────┘
底层保存「发生过什么」:谁说了什么、哪个节点被质询、哪个关系被修正、 某个对象有哪些版本、哪个事件由谁触发。
上层只做另一件事:哪些内容值得集中展示、哪些节点可以放进一个 Context、 哪些内容默认展开、哪些结构可以推荐。
单向性这条约束,我写在 upper.py 的模块 docstring 里,原文是:
底层 → 上层 派生,允许
上层 → 底层 禁止写成事实
关键不是"上层尽量只读",而是"上层必须能够被证明没有越界"。 这是后面 B14 的由来。
三、为什么这里不用 embedding + 聚类
看到「讨论图 + 自动归纳」,第一反应当然是这条链路:
文本 → Embedding → 相似度矩阵 → K-Means / 谱聚类 → Topic
但它在类别上就不成立 —— 聚类在这里违规,而且不是实现问题:
聚类的驱动信号是文本相似度,那是距离度量,不是「反复出现」。
后果是这样:
换算法(k-means → 谱聚类 → 换任何聚类):信号还是「文本长得像」,一样违规。
换信号(相似度 → 被质询次数):算法一行不用改,合规了。
信号类别比算法选择更根本。 所以这里有一条前置问题:
不要急着讨论"用什么模型、什么算法",先问"这个算法到底在读什么信号"。
一个模型哪怕准确率再高,如果它读的信号本身就不属于系统允许使用的数据, 换模型并不能解决架构问题。
四、白名单里只有三个信号
upper.py 里定义的白名单就这三个:
COUNT_SIGNALS = {
"challenge_counts": "relation:challenged_by", # 某个假设被反复质询
"revision_counts": "revision", # 某条关系 / 节点被反复修正
"dispute_counts": "relation:contradicts", # 某类争议反复出现
}
count_signals() 做的就三件事:从 SQLite 读结构关系、统计次数、交给上层。 比如第一条:
rows = conn.execute(
"SELECT r.from_id AS target, COUNT(*) AS n FROM relation r"
" WHERE r.kind = 'challenged_by' AND r.state = 'active'"
" GROUP BY r.from_id ORDER BY r.from_id",
).fetchall()
没有的东西比有的东西更值得说:这里没有点赞数、没有热度、没有参与人数、 没有曝光量、没有投票数。它们不是系统认可的「结构证据」—— 因为读热度等于把「受欢迎」读成「对」。
有一处细节值得单独拎出来:这里也没有「高于多少次算重要」的神秘评分。 代码更关心的是「这个东西发生过什么」,而不是「这个东西是不是更重要」。
五、底层数据模型:revision 是追加,不是 UPDATE
底层主要四类数据:
artifact 代表一个具体对象
revision 记录 artifact 的版本历史
relation 记录对象之间的关系(有独立身份和来源)
event 记录发生过什么操作
一个值得单看的设计点在 scaffold.revise() 里:
def revise(conn, artifact_id, *, content, author, parent_rev=None) -> int:
"""加一个新版本。**不覆盖旧版本** —— 旧版本一行都不会被改。
`parent_rev=None` 时挂到当前 head。若此时有两个 head(已分叉),
必须显式指定 `parent_rev` —— 系统不会替你挑一个,
因为挑一个就是替用户做了一个判断。
"""
heads = heads_of(conn, artifact_id)
if parent_rev is None:
if len(heads) > 1:
raise ScaffoldError(
f"{artifact_id} 已有 {len(heads)} 个分支 "
f"({[h['id'] for h in heads]}),必须显式指定 parent_rev。"
"系统不替你选分支 —— 那是一次判断。"
)
所以版本历史允许分叉:
┌── rev2-A
rev1 ──┤
└── rev2-B
系统不会自作聪明帮你挑一个。 做协同编辑 / 审计 / 知识库 / Agent 工作流的 同学应该很熟悉这个味道:宁可保留分叉,也不要为了让数据「看起来整洁」而悄悄丢掉分歧。
六、上层归纳的四个动作
count_signals() 数信号 只读
propose_clusters() 提出候选 只读
promote_candidates() 创建结构 唯一写动作
rename_context() 人来命名 写版本表
6.1 提议必须是只读的
propose_clusters() 一个字都不写。为什么刻意拆开:
提议是高频动作,建是低频动作。混在一起的话,每次重算都会多出一批节点, 而「不得不清理自动产出的垃圾」正是让人开始乱删结构的起点。
6.2 「至少 2 条依据」不是阈值,是下限
MIN_SUPPORT = 2
这个数看着像阈值,但它是结构下限,区别在这里:
阈值是「过了这条线就算重要」—— 那是个判断。 下限是「一条依据的簇不叫簇」—— 那是「这一簇是否成立」的结构问题。
前者需要有人授权去定,后者不需要。这个区分避开了把 「系统内部的结构规则」和「业务上的价值判断」混在一起。
6.3 创建的是结构,不是重新定义
promote_candidates() 里写的只有三样:
- 一个
Contextartifact,内容{"text": PENDING_NAME, "name_source": "human"}
- 一条
Relevance contains Context边,从 Debate(或它的 Topic)挂过去
- 一条
clustered_into边,从每个依据节点指向这个 Context
依据节点原有的 content / state / revision 全程只读。
底层:Claim A / Claim B / Claim C ──被质询 / 修正 / 争议──►
上层:Context-0001
↑
├── Claim A
├── Claim B
└── Claim C
新增的是归组关系,而不是重新定义 Claim A/B/C。
七、最值得讨论的一点:节点可以自动建,但不能自动命名
创建 Context 时,系统不会生成「关于性能优化的核心争议」这样的名字,而是先设:
PENDING_NAME = "(待命名)"
逻辑很直接:
如果系统自己给这个节点命名,那么「这个节点到底代表什么」本身就是系统新增的一句话。
而一旦系统新增了一句话,就等于新增了一个需要解释和追溯的判断。
于是我做了这样一个拆分:
结构可以自动生成
名字必须由人决定
AI:这几条内容应该被放在一起
人:这组内容叫"缓存一致性问题"
系统只发现结构,没有自己替用户发明语义。
这个拆分免掉了一整道工序。理由是有一档区分:
提议新结构 + 系统给它命名 → 要人工确认
提议新结构 + 名字由人给 → 不用 ← 走这条
为什么能免确认:因为命名是那句断言的全部内容。 名字空着,系统就一句话都没说 —— 它只把「这几条该并在一起」这个结构判断摆出来。 所以那个空名字不是占位符,它是这条设计能成立的前提。
顺带一个语义分离:state 管的是「这条断言有没有被确认」, 而这里节点的「待定」是**「还没起名」**—— 那是另一种东西,由 name_source + PENDING_NAME 表达。把这两种「待定」压进同一个字段,就等于说「未命名 = 未确认」, 而那恰好会把「免确认」这条设计的理由抹掉。
八、一个"看起来正常"的 Bug:改名把依据弄丢了
最典型的那类失败:程序没崩,界面看起来是成功的。
一个直接调 revise() 的改名实现:
rev = revise(conn, context_id, content={"text": name, "name_source": "human"}, author=by)
节点「改名成功」了,但:
signal → None
evidence_ids → []
依据全丢了。
页面看起来完全没问题:
Context-0001:缓存一致性问题
但系统已经回答不了:
这个 Context 最初为什么会被创建?
这就是最典型的那种失败:程序没崩,界面看起来是成功的。
✅ 名字变了
✅ 页面能显示
✅ 查询正常
❌ 为什么创建这个节点,已经说不清了
根因在 revise() 换的是整个 content(那是对的,它是通用版本接口), 所以调用方必须读-改-写:
content = dict(content_of(conn, context_id))
content["text"] = name.strip()
content["name_source"] = "human"
rev = revise(conn, context_id, content=content, author=by)
只换 text,signal / evidence_ids / induction_version 原样带过去。
做可追溯系统时,不能只测「功能有没有成功」,还要测「操作之后因果链还在不在」。
九、把架构原则变成会失败的检查:B14 / B15
很多项目的设计文档里都写「上层不得污染底层」,然后结束。我不想停在文档层面。
python checks.py 跑出来是这样:
[B1] 不引入锁 §C11.2 §C11.3 过
[B2] 无权重 / 评分 / 名次 / 真值 §C6.1 §C9 #4 #5 #7 过
[B3] 不实现自动分裂 / 自动合并 / 阈值 §C12.5 §C9 #9 过
[B4] 上层归纳不读热度类信号(`vote.py` 数票是正当的,不在此列) §C7.1 §C9 #5 过
[B5] 无标量分 §C6.1 §C9 #7 过
[B11] 版本表只增不改(无覆盖式更新) §C10 §C9 #10 过
[B6] 观测点只记不算——不拿它的值与任何数比较 §C7.2 §T0.3 过
[B7] 第三方依赖为零 §T4.3 §T5 过
[B8] 声明待标注的样本,标注区为空 §C5.5.1 过
[B9] 并发装置不注入延迟 / 不直接改库 / 不内部协调 §C11.2 过
[B10] 发号器不携带判断(号出不了 scaffold.py) §C9 #5 #7 过
[B12] 命题类型不许写死 —— 写死就推翻不了(confirm.py 无类型字面量) §T0.3 §C2.5 缺口② 过
[B13] 标注区有值的样本,必须说清值是谁填的(B8 的另一半) §C5.5.1 过
[B14] 上层 → 底层不许写成事实(单向性) §C7.1 ④ 过
[B15] 上层节点不带系统生成的名字(命名归人) §C2.0 §C7.1 ③ 过
否证检查全部通过:共 15 条,B1, B10, B11, B12, B13, B14, B15, B2, B3, B4, B5, B6, B7, B8, B9 无命中。
每一行右边挂着我自己约束文档里的条款号,可以逐条对回去。
B14:上层不能向底层写事实
_UPPER_WRITES_DOWN = re.compile(
r"""\b(?:UPDATE|INSERT\s+INTO|DELETE\s+FROM)\s+(?:artifact|revision|relation)\b""",
re.IGNORECASE)
def check_upper_does_not_write_down(target=None):
target = target or (ROOT / "upper.py")
if not target.is_file():
return [] # 还没有上层模块 —— 暂不适用,不是「过」
return [(target.name, n, line.strip())
for n, line in code_lines(target)
if _UPPER_WRITES_DOWN.search(line)]
它为什么必须存在:这条不变量坏起来不像坏。 上层顺手把「这一簇很重要」写进底层某个字段 —— 短期看一切正常(排序确实变好了), 长期看底层的真值被相关性判断污染了,而且不可追溯 (底层字段没有「这是上层写的」这个标记)。
它为什么刻意做得又笨又窄:只扫 upper.py 一个文件、只抓四种 SQL 动词 + 三张表名。 底层模块当然要写库 —— 这条盯的只是「上层那一侧不许自己动手」。
它自己承认有洞 —— 这一点比 B14 本身更值得看:
静态扫只能拦「直接写 SQL」;走
scaffold.revise()之类的间接写它看不见。
所以必须配第二层:
静态检查:防止直接写
行为测试:防止绕路写
静态规则守「代码形状」,动态测试守「运行结果」。
行为层的做法是拍快照比对。建节点前后测量底层:
① 「只提议」阶段:
底层 artifact / relation / revision 变化量: (0, 0, 0)
② 「建节点」之后:
新建节点: ['ctx-0001']
新增底层记录: 1(就是新节点自己)
新增边: 4 条 = 3 条上层专属 + 1 条挂在锚点上
被修改的底层记录: 无
被删除的底层记录: 无
底层节点的 revision: 4 → 4 ← 一条没动
对应 test_upper.py 里的两个用例,其中 test_promote_never_touches_the_lower_layer 是拿 revision 表的 (id, artifact_id, parent_rev, content) 四元组 + artifact.state 逐字段比对的 —— 不是比条数。
B15:上层节点不能带系统生成的名字
_MACHINE_NAME_LITERAL = re.compile(r"""["']text["']\s*:\s*["'][^"']+["']""")
它盯的是最容易发生的退化:有人图省事,从依据里抄第一条命题当名字。
name = evidence_ids[0]
从功能角度这完全可用。但从设计约束上它已经越界了 —— 节点自动带了一个系统选的名字,而它看起来完全正常。
十、第三个设计点:空结果也必须"有解释"
工程里经常看到:
return []
但 [] 究竟是什么意思?可能是三种完全不同的情况:
- 数据确实为空 → 再等等
- 条件暂时不满足 → 再等等
- 系统根本看不到这种信号 → 这条信号这里看不见
第三种不能伪装成第一种。 所以 upper.scan() 返回的不是裸数组:
{
"contexts": ...,
"empty_reason": ...,
"blind_spots": ...,
}
BLIND_SPOTS 明确写出当前机制看不到的东西:
BLIND_SPOTS = (
"只看 `challenged_by` / `contradicts` / `revision` 三种结构量",
"看不见「没被质询但也没人支持」的东西 —— 那是沉默,不是信号",
"看不见跨语言、跨表述的同一观点(不做文本相似度,见模块开头)",
)
我在真实库上跑出来是这样):
================================================================
上层上下文 debate-0001
规则集 upper-context/1 · `§C7.1`(MVP 阶段本机制按留白项处理)
还没有上层节点。
⚠️ 「还没有」和「算不出来」不是一回事,所以两句都印:
· 还没有 —— 底层的结构性信号还没攒够(同一条假设至少被质询 2 次)
· 算不出 —— 本模块看不见某种信号(见 BLIND_SPOTS)
零候选,而且这不是坏了。 原因是:
库里 30 个 artifact、18 条 Claim、31 条 revision
relationship 只有 contains 一种(55 条)
challenged_by 边数: 0 ← 没有一条质询
contradicts 边数: 0 ← 没有一条反驳
有 >1 个 revision 的 artifact: 0 ← 没有一条被改过
三个量全是 0,因为这套语料里还没有出现过「反复」 —— 讨论还停在 「各说各的、互不交叉」的阶段。这是按设计该有的结果,不是坏掉。
「没有检测到」绝不等于「没有发生」。 如果规则根本没覆盖某一类信号, 输出 0 会制造一种虚假的确定性。
对应地,test_upper.py 里有一条用例专门钉住这个 0: 哪天它开始吐候选,要么是真攒够信号了,要么是判据被放宽了,两种都该被人看见。
十一、跑起来
零第三方依赖,不需要 pip install。 只要 Python 3(3.13 与 3.14 实测)。
规模口径(可自己核对):
| 口径 | 行数 |
|---|---|
核心三文件(scaffold.py / upper.py / checks.py) | 1689(去空行与 # 注释 1202) |
全仓 Python(含 _console.py 与两个测试文件) | 2860(去空行与 # 注释 2115) |
依赖:scaffold.py 只 import json / sqlite3 / datetime; 全仓 import 的是 datetime / functools / io / json / pathlib / re / sqlite3 / sys / tokenize / unittest —— 全是标准库,第三方为零。
git clone https://github.com/aic-123/nested-traceable-discussion-graph.git
cd nested-traceable-discussion-graph
python checks.py # 15 条否证检查
python -m unittest test_upper # 29 条:单向性 / 命名归人 / 视图边界
python -m unittest test_checks # 证明那 15 条检查不是空转
⚠️ 第三条会打印
OK (skipped=7),那是有意的。 跳过的 7 条验的是上游产品(arena)的vote.py/concurrency.py/confirm.py/samples/,那几个文件不在这个仓库里。跳过原因逐条印出来,不静默通过。跳过而不是删掉,是因为「跳过」和「通过」是两件事。 删掉之后
test_checks会报「全过」,但 B4 / B8 / B9 / B12 / B13 这五条检查 在这个仓库里没被验伪过。跳过并把原因逐条印出来,就是这份报告 如实说出自己验到哪的方式。
⚠️ 这里有一条检查专门处理「报告和事实脱钩」,值得单独看。
test_checks会往仓库里写临时探针、跑完在finally里删掉。 于是有一种情况:探针留下了,但这一轮的检查全过。这时候应该报什么?
报「通过」→ 残留会污染下一轮,而且没人知道。 报「失败」→ 拿上一轮的事故判这一轮不合格,读者会以为检查坏了。
这个仓库选了第三条:分开归因,而且都要说出来。
用例 管什么 有残留时 Test00NoResidueAtStart上一轮留下的 清掉 + skipTest,说明里带绝对路径TestNoResidue这一轮留下的 判红 —— 收尾代码全跑过还有残留,只能是清理漏了路径 判据不是「严不严」,是**「谁的事故」**。
跑前残留:['_tmp_probe_zzz.py'] ← 真实场景,上一轮留下的 本次跑: OK (skipped=8) ← 自愈,说明里带绝对路径 跑后残留:[] 再跑一次:OK (skipped=7) ← 恢复可见,但不判死。 多出来那 1 个 skip 就是它,报告里能看到:
skipped "上一轮被硬终止,留下 1 个探针残留,已自动清理: ['<仓库的绝对路径>/_tmp_probe_zzz.py']"这条设计有一个反向验收判据 —— 修「上一轮的事故」不能顺手把 「这一轮的漏清」也改软:
场景 期望 干净连跑三次 OK (skipped=7)× 3预置一个残留 OK (skipped=8)(自愈)直跑 TestNoResidue且预置残留仍 FAIL它是怎么定位到「上一轮被硬终止」的
因为要回答的是「残留从哪来」,不是「残留是多少」。方法两步:
一、给
open装审计钩子,抓调用栈。def hook(event, args): if event == "open" and "_tmp_probe" in str(args[0]): mode = args[1] if len(args) > 1 else "?" if mode in ("w", "wb", "x", "xt"): print("".join(traceback.format_stack(limit=12)[:-1])) sys.addaudithook(hook)
拿到唯一写入点,再把它与残留文件的内容比对 —— 一致即来源确认。
二、单变量对照,找出唯一能制造残留的跑法。
跑法 跑完残留 正常跑 无 重定向到文件 > log.txt无 stdout 接管道后提前关闭(` head -5`) 无 跑到一半被 SIGKILL 有 结论:
finally只在进程能跑到收尾时执行。唯一会留残留的是SIGKILL—— 也就是Ctrl-C、任务被取消、进程被 kill、机器休眠。⚠️ 这张表值钱的地方在于它同时否掉了一个很像结论的错答案: 「重定向会打断清理」。把「重定向」和「同时被 Ctrl-C」判成因果的写法 曾经写进过 README —— 判定因果必须单变量对照,否则产出的是一条 看起来像经验的错误规矩,还会被照抄。
这条设计的根,和整个仓库防的是同一条
「上一轮的事故」和「这一轮的失败」,必须分开报。
这和
_need()是同一个形状:上游文件不在时skipTest并说明原因, 而不是判红 —— 因为报出来的是「检查坏了」,真因是「靶文件不在」。一个假绿(空转的检查打印「过」),一个假红(事故记成失败), 形状相反,成因同类:报告和事实脱钩。
分工是清楚的:
checks.py的 15 条查代码;test_checks这一层额外查 报告本身有没有和事实脱钩(Test00NoResidueAtStart/TestNoResidue)。
核心调用:
import scaffold
import upper
conn = scaffold.connect(":memory:")
scaffold.init(conn)
# 此处构造底层讨论数据……
result = upper.propose_clusters(conn) # ← 只读,一个字都不写
made = upper.promote_candidates( # ← 唯一的写动作
conn,
candidates=result["candidates"],
by="alice",
debate_id=debate,
)
upper.rename_context( # ← 人做的动作
conn,
context_id=made[0],
name="围绕假设甲的分歧",
by="bob",
)
注意 propose_clusters() 是只读的 —— 它不会因为「发现了一个候选」 就顺手改数据库。提议高频跑,建节点低频做,这两个动作被我刻意拆开了。
十二、这本质上就是"事实账本 + 只读投影"
它没有包装成某个流行架构模式,但从工程角度看就是一个清晰分层:
事实层:原始对象 / 版本 / 关系 / 事件
│
▼
派生层:结构统计 / 候选 / Context / 展示视图
跟传统 CRUD 最大的区别是:派生结果不是下一次计算的输入事实。
facts → derived view ← 我这条路
facts → derived view → overwrite facts
↑
下一轮继续计算 ← 自我强化那条路
这条路跑几轮以后,系统就不知道最初的用户数据是什么了。
十三、代价和边界
这套设计不意味着「AI 讨论系统的问题解决了」。它的边界很清楚:
- 只认三类结构信号,所以天然看不到没形成质询 / 修正 / 争议的内容。 这是
BLIND_SPOTS第一条。
-
故意不做文本相似度。 所以这两句:
"缓存失效以后读取旧值" "Cache Invalidation 导致 Stale Read"可能是同一个意思,系统不会因为语义相近归到一起。
- 自动建立的是结构,不是语义名称,实际产品里仍然需要人的参与。
- 不是完整产品 —— 没有前端、没有账号、没有部署。 它是一条跑通的结构,不是一套能用的服务。
- 上层只有两个写动作(建节点 / 改名),没有删除,没有合并。 哪天它自己长出观点了,那才是 bug。
这几个限制不是「缺功能」,是我刻意保留的边界。
十四、最值得抄走的五条
1. 先定义不能发生什么,再定义功能。 这个仓库大量篇幅在定义「不能改什么 / 不能读什么 / 不能自动命名什么」。 这比描述「系统有什么功能」更接近真正的边界设计。
2. 把架构原则写成会失败的测试。 「上层不能写底层」不该只是 README 里的一句话,应该是 B14 + test_promote_never_touches_the_lower_layer。而且要测绕路 API。
3. 派生数据和事实数据要有明确物理边界。 如果两者最后都写进同一张表、共用字段,很快就会出现 「这是用户说的?还是系统推出来的?」。 结构化分层比给字段加一个 generated_by_ai=true 可靠得多。
4. 不要让「未知」伪装成「0」。 任何统计或观测系统都该回答:真的没有,还是暂时看不到。
5. 最危险的 Bug 往往是「看起来正常」的。 改名导致 evidence 丢失就是一个例子。 不能只测「功能有没有成功」,还要测**「操作之后因果链和 provenance 还在不在」**。
十五、结语
这个仓库没回答「如何让 AI 更聪明地总结讨论」。
它回答的是另一个更底层的问题:
当 AI 开始替人整理、归纳、组织信息时,怎么避免它不知不觉把自己的归纳变成事实?
答案很朴素:
底层记录事实
↓
上层读取事实
↓
上层产生派生结构
↓
派生结构不能倒流
↓
新的语义命名交给人
↓
所有关键边界都用测试固定下来
AI 可以负责组织信息,但组织结果不能偷偷改写信息本身。