单向派生与写隔离:把「AI 归纳不得回流事实层」写成 15 条可执行否证检查的讨论图

22 阅读21分钟
  • 静态检查只能看见直笔 SQL。走 revise() 的间接写,它一个字都看不到。

〇、先说这张表

很多讨论型 AI 应用都在做一件看起来很自然的事:把大量观点、反驳、修改交给模型, 让它自动总结、聚类、提炼主题。

这个仓库不是这件事。它只解决其中一个很窄的问题:

当模型参与整理时,怎么保证它不把自己的归纳,悄悄变成事实来源。

用两个词概括这件事:单向派生 与 写隔离。

  • 单向派生:底层记事实(谁说了什么、谁反驳了什么),上层把被反复质询的东西 归到一组 —— 只允许底层 → 上层派生,不允许反向流回去。
  • 写隔离:上层能影响的只有展示顺序 / 默认展开 / 推荐候选; 它不许写进底层任何字段。这条边界不靠注释,靠两层机制守住。

四条硬指标:

#指标为什么难
115 条否证检查,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() 里写的只有三样:

  1. 一个 Context artifact,内容 {"text": PENDING_NAME, "name_source": "human"}
  1. 一条 Relevance contains Context 边,从 Debate(或它的 Topic)挂过去
  1. 一条 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 []

但 [] 究竟是什么意思?可能是三种完全不同的情况:

  1. 数据确实为空 → 再等等
  1. 条件暂时不满足 → 再等等
  1. 系统根本看不到这种信号 → 这条信号这里看不见

第三种不能伪装成第一种。 所以 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 讨论系统的问题解决了」。它的边界很清楚:

  1. 只认三类结构信号,所以天然看不到没形成质询 / 修正 / 争议的内容。 这是 BLIND_SPOTS 第一条。
  1. 故意不做文本相似度。 所以这两句:

    "缓存失效以后读取旧值"
    "Cache Invalidation 导致 Stale Read"
    

    可能是同一个意思,系统不会因为语义相近归到一起。

  1. 自动建立的是结构,不是语义名称,实际产品里仍然需要人的参与。
  1. 不是完整产品 —— 没有前端、没有账号、没有部署。 它是一条跑通的结构,不是一套能用的服务。
  1. 上层只有两个写动作(建节点 / 改名),没有删除,没有合并。 哪天它自己长出观点了,那才是 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 可以负责组织信息,但组织结果不能偷偷改写信息本身。

项目地址:github.com/aic-123/nes…