---
title: "Chapter 07 — 管线 D：记忆巩固 (Memory Consolidation)"
date: 2026-05-20
draft: false
tags: ["PRISM", "世界模型", "空间记忆", "Gaussian Splatting", "机器人"]
categories: ["PRISM"]
---

# Chapter 07 — 管线 D：记忆巩固 (Memory Consolidation)

> 本章目标：机器人**充电 / 空闲**时跑一次"睡眠"，把 `delta/pending.jsonl` 中**反复确认**的变化真正写入 LTM，并淘汰过时锚点、重训 3DGS、版本化备份。

---

## 7.1 为什么需要"睡眠"

如果 ZED 看到一次"沙发挪了"就立刻改 LTM，机器人就会变得**易骗**：
- 客人挪一下沙发拍照？被记成永久挪动
- ZED 单帧检测错把椅子识成桌子？长期记忆被污染
- 镜面区噪声偶尔产生"虚影"？写进去再也清不掉

仿照人脑：**白天积累短期记忆 → 睡眠时筛选 → 仅把多次确认的信号转入长期记忆**。

PRISM 也一样：

```mermaid
flowchart LR
    subgraph DAY["白天（Online）"]
        D1[("delta/pending.jsonl<br/><i>各种 DeltaEvent 累积，可能很乱</i>")]
    end
    subgraph NIGHT["夜里 / 充电时（Consolidation）"]
        direction LR
        N1["pending"] --> N2["筛选"] --> N3["confirmed"] --> N4["应用到 LTM"] --> N5["版本化"]
    end
    DAY -. 触发 .-> NIGHT
    style DAY fill:#fff7d6,stroke:#c97a00
    style NIGHT fill:#d8e4ff,stroke:#1565c0
```

---

## 7.2 触发条件

| 触发 | 频率 | 模式 |
|------|------|------|
| 充电桩 + 静止 > 10 min | 通常每天 1 次 | **完整巩固** |
| 手动命令 `prism consolidate` | 按需 | 完整巩固 |
| `pending.jsonl` > 5000 条 | 紧急 | **轻量巩固**（只筛选不重训） |
| LTM 版本年龄 > 30 天 | 月级 | **深度巩固**（含重算 anchors + CLIP） |

---

## 7.3 巩固总流程

> ⚠️ **v1.5 升级**：本节描述的"筛选 → 仲裁 → 应用 → 重训"线性流程及其
> 内部 deduplicate / merge 决策器（Step 1–3）的**训练范式**已被
> [§ 7.13.1](#7131-v15-升级self-augmentation-巩固训练) 增强为
> self-augmentation 监督学习；本节流程本身仍可作为 baseline 使用，
> 决策器若由简单规则（`PROMOTION_RULES` + `arbitrate()`）实现则完全不受影响。
> 仅当决策器升级为可训练策略网络（v1.5 → v2.0 路线图）时，§ 7.13.1
> 的 self-aug 范式才生效。

```mermaid
flowchart TB
    P[("pending.jsonl")]
    S1["<b>Step 1: 事件分类与筛选</b><br/>observation_count > N<br/>时间跨度 > T<br/>多 keyframe 多视角"]
    S2["<b>Step 2: 冲突仲裁</b><br/>iPhone 标 vs ZED 改"]
    S3["<b>Step 3: 应用到 LTM</b><br/>add / update / remove node"]
    S4["<b>Step 4: 锚点 / 索引 / CLIP</b><br/>重新计算受影响项"]
    S5["<b>Step 5: 增量 3DGS 重训</b><br/>只重训受影响房间"]
    S6["<b>Step 6: 版本化 + 健康检查</b><br/>snapshots/, validate()"]
    P --> S1 --> S2 --> S3 --> S4 --> S5 --> S6
    style P fill:#f5e1ff,stroke:#7b1fa2
    style S6 fill:#d4f0d4,stroke:#2e7d32
```

---

## 7.4 Step 1：事件筛选

```python
# consolidation/filter.py
from datetime import timedelta

# 不同事件类型有不同"晋升门槛"
PROMOTION_RULES = {
    "object_moved":    dict(min_obs=5,  min_span_s=300,  min_views=2),
    "object_removed":  dict(min_obs=10, min_span_s=600,  min_views=3),
    "object_added":    dict(min_obs=8,  min_span_s=300,  min_views=2),
    "geometry_changed":dict(min_obs=15, min_span_s=900,  min_views=4),
}

def classify(ev: DeltaEvent, mem: SpatialMemory) -> str:
    rule = PROMOTION_RULES[ev.event_type]
    span = ev.last_observed - ev.first_observed
    unique_views = count_unique_viewpoints(ev.evidence, mem)

    # 若是 iPhone 的高 confidence 节点，门槛 1.5x
    target = mem.nodes.get(ev.target_uid) if ev.target_uid else None
    if target and target.source == "iphone" and target.confidence > 0.85:
        rule = {k: v*1.5 for k, v in rule.items()}

    if ev.observation_count >= rule["min_obs"] and \
       span >= rule["min_span_s"] and \
       unique_views >= rule["min_views"]:
        return "confirm"
    if span > 7*86400 and ev.observation_count < rule["min_obs"]//2:
        return "reject"           # 7 天还没攒够观测 → 拒绝
    return "keep"                  # 继续等待
```

**关键直觉**：
- `min_obs`：要"看过很多次"
- `min_span_s`：必须**跨越足够长时间**（防止瞬时假象）
- `min_views`：必须**来自多个视点**（防止单点死磕）

---

## 7.5 Step 2：冲突仲裁

不同 delta 之间，或 delta 与 LTM 之间可能冲突：

```python
# consolidation/arbiter.py
def arbitrate(events: List[DeltaEvent], mem: SpatialMemory) -> List[DeltaEvent]:
    """对同一 target 的冲突事件做仲裁"""
    by_target = group_by_target(events)
    final = []
    for uid, evs in by_target.items():
        if len(evs) == 1:
            final.append(evs[0]); continue
        # 多个事件涉及同一节点
        sorted_evs = sorted(evs, key=lambda e: e.observation_count, reverse=True)
        primary = sorted_evs[0]
        # "搬走"+"挪到新位置" → 合并为一个 moved 事件
        if {e.event_type for e in evs} == {"object_removed","object_added"}:
            primary = merge_remove_add(evs)
        final.append(primary)
    return final


def merge_remove_add(evs):
    rem = next(e for e in evs if e.event_type == "object_removed")
    add = next(e for e in evs if e.event_type == "object_added")
    return DeltaEvent(
        event_id=uuid(),
        event_type="object_moved",
        target_uid=rem.target_uid,
        new_pose=add.new_pose,
        new_bbox=add.new_bbox,
        evidence=rem.evidence + add.evidence,
        observation_count=rem.observation_count + add.observation_count,
        first_observed=min(rem.first_observed, add.first_observed),
        last_observed=max(rem.last_observed, add.last_observed))
```

---

## 7.6 Step 3：应用到 LTM

```python
# consolidation/apply.py
import shutil
from copy import deepcopy

def apply_events(events: List[DeltaEvent], mem: SpatialMemory) -> SpatialMemory:
    """返回应用后的新 SpatialMemory；不修改原对象"""
    new = deepcopy(mem)
    for ev in events:
        if ev.event_type == "object_moved":
            n = new.nodes[ev.target_uid]
            n.pose = ev.new_pose
            n.bbox_3d = ev.new_bbox
            n.last_seen = ev.last_observed
            n.confidence = min(1.0, n.confidence * 0.95)  # 轻微降低（被动过）
            # 重新计算 parent_room
            n.parent_room = find_room_for_point(n.pose.position[:2], new)
        elif ev.event_type == "object_removed":
            uid = ev.target_uid
            n = new.nodes[uid]
            # 不立刻硬删除，标记 deprecated 一段时间
            n.attributes["state"] = "removed"
            n.confidence *= 0.3
            # 切断关系
            new.edges = [e for e in new.edges
                         if e.src_uid != uid and e.dst_uid != uid]
        elif ev.event_type == "object_added":
            node = SpatialNode(**ev.payload)
            node.source = Source.FUSED   # 经过 consolidation
            node.confidence = 0.7        # 提升
            new.add_node(node)
            new.add_edge(SpatialEdge(node.parent_room, node.uid,
                                     "contains", source=Source.FUSED))
        elif ev.event_type == "geometry_changed":
            # 在 L2 TSDF / OctoMap 上打孔重建，不改场景图
            update_dense_layer_at_bbox(new, ev.new_bbox)
    return new
```

→ 注意 `deepcopy + 整体替换` 保证**原子性**：要么全部成功，要么回滚。

---

## 7.7 Step 4：锚点 / 索引 / CLIP 更新

```python
# consolidation/refresh.py
def refresh_anchors_and_index(new_mem: SpatialMemory):
    # 1) 锚点重算
    new_mem.anchors = build_anchors(new_mem)        # 同 Chapter 04

    # 2) 受影响节点的 CLIP 重算
    for ev in events_just_applied:
        if ev.event_type in ("object_moved","object_added"):
            uid = ev.target_uid or ev.payload["uid"]
            node = new_mem.nodes[uid]
            # 渲染或从近期 keyframe 裁剪
            crops = collect_recent_crops(uid)
            node.clip_embedding = mean_clip_embedding(crops)

    # 3) Faiss 索引重建（L4 全量）
    build_faiss_index(new_mem)

    # 4) L3 房间 CLIP 受影响时也重算
    affected_rooms = {ev.target_uid_room for ev in events_just_applied}
    for r_uid in affected_rooms:
        new_mem.nodes[r_uid].clip_embedding = recompute_room_clip(r_uid)
```

---

## 7.8 Step 5：增量 3DGS / TSDF 重训

完全重训 3DGS 太贵（一房间 15 k iter × 5 min），所以**只重训受影响房间** + **复用未变区域**：

```python
def incremental_retrain_3dgs(new_mem: SpatialMemory, events):
    affected_rooms = set(find_room_for_point(ev.new_pose.position[:2], new_mem)
                         for ev in events if ev.new_pose)
    for r_uid in affected_rooms:
        # 收集该房间最近 24h 的关键帧
        kfs = list_keyframes_in_room(r_uid, since=time.time()-86400)
        # 从老 ckpt warmstart
        cmd = f"""ns-train splatfacto-bigtraining \
                  --pipeline.model.warmstart-ckpt outputs/{r_uid}/last.ckpt \
                  --max-num-iterations 3000 \
                  --data {kfs_dir}"""
        subprocess.run(cmd, shell=True)
        # 替换 LTM 中的 .ply
        shutil.move(f"outputs/{r_uid}/final.ply",
                    f"robot_memory/ltm/dense/3dgs/{r_uid}.ply")

def incremental_update_tsdf(new_mem, events):
    """TSDF 更便宜，直接在受影响 bbox 内重新融合最近关键帧"""
    for ev in events:
        bbox = ev.new_bbox if ev.new_bbox is not None else \
               new_mem.nodes[ev.target_uid].bbox_3d
        # 把 LTM TSDF 在该 bbox 内"清零"
        new_mem.dense.tsdf.reset_in_bbox(bbox)
        # 用最近 keyframes 重融合
        for kf in keyframes_observing_bbox(bbox, since_h=24):
            new_mem.dense.tsdf.integrate(kf)
```

---

## 7.9 Step 6：版本化 + 健康检查 + 切换

巩固结果不直接覆盖在线版本，先写到一个 staging，校验通过才切换：

```python
# consolidation/commit.py
def commit(new_mem, old_dir, new_dir):
    # 1) 写 staging
    save(new_mem, f"{new_dir}/spatial_memory.json")
    copy_dense_dir(f"{old_dir}/dense", f"{new_dir}/dense")
    apply_dense_updates(new_dir, new_mem)

    # 2) 校验
    errs = validate(new_mem)
    sanity = run_sanity_relocalize(new_dir)  # 用 10 张历史关键帧重定位
    if errs or sanity.success_rate < 0.9:
        log.error(f"consolidation rejected: {errs}, success={sanity}")
        return False

    # 3) 原子切换
    timestamp = datetime.now().strftime("%Y%m%d_%H%M")
    snapshot = f"robot_memory/snapshots/{timestamp}.tar.zst"
    archive(old_dir, snapshot)
    os.rename(old_dir, f"{old_dir}.prev")
    os.rename(new_dir, old_dir)
    return True
```

---

## 7.10 锚点淘汰策略

```python
def prune_stale_anchors(mem, max_age_days=60, min_recent_validations=2):
    keep = []
    for anc in mem.anchors:
        node = mem.nodes[anc.anchor_uid]
        age_days = (time.time() - anc.last_validated) / 86400
        # 仍是不可移动 + 最近 60 天被巩固确认过 → 保留
        if not anc.is_mobile and \
           node.attributes.get("state","") != "removed" and \
           age_days < max_age_days:
            keep.append(anc)
        elif node.observation_count >= min_recent_validations:
            keep.append(anc)
    mem.anchors = keep
```

→ 每次巩固跑一次。

---

## 7.11 完整 CLI：`prism consolidate`

```python
# tools/prism_consolidate.py
import click

@click.command()
@click.option("--mode", default="full",
              type=click.Choice(["full","light","deep"]))
@click.option("--ltm",  default="robot_memory/ltm")
@click.option("--delta", default="robot_memory/delta/pending.jsonl")
def main(mode, ltm, delta):
    mem = load(f"{ltm}/spatial_memory.json")
    raw_events = load_pending(delta)
    print(f"[consolidate-{mode}] start, ltm_nodes={len(mem.nodes)}, "
          f"pending={len(raw_events)}")

    # Step 1: filter
    decisions = [(ev, classify(ev, mem)) for ev in raw_events]
    confirmed = [ev for ev, d in decisions if d == "confirm"]
    rejected  = [ev for ev, d in decisions if d == "reject"]
    kept      = [ev for ev, d in decisions if d == "keep"]

    # Step 2: arbitrate
    final = arbitrate(confirmed, mem)

    # Step 3-4: apply + refresh
    staging = f"{ltm}.staging"
    new_mem = apply_events(final, mem)
    refresh_anchors_and_index(new_mem)

    # Step 5: dense（mode=full/deep 时才跑）
    if mode in ("full","deep"):
        incremental_update_tsdf(new_mem, final)
    if mode == "deep":
        incremental_retrain_3dgs(new_mem, final)

    # Step 6: commit
    ok = commit(new_mem, ltm, staging)
    if not ok:
        print("[consolidate] rolled back; pending.jsonl unchanged")
        return

    # 重写 pending：把 confirmed 移走，rejected 归档，kept 留下
    write_jsonl(f"robot_memory/delta/confirmed.jsonl", final, append=True)
    write_jsonl(f"robot_memory/delta/rejected.jsonl", rejected, append=True)
    write_jsonl(delta, kept)   # 覆盖
    print(f"[consolidate-{mode}] applied={len(final)} "
          f"rejected={len(rejected)} kept={len(kept)}")
```

运行：

```bash
# 充电时自动触发
systemd-timer --on=20:00 --weekly --command "prism consolidate --mode full"
# 月度深度巩固
systemd-timer --on=monthly --command "prism consolidate --mode deep"
```

---

## 7.12 安全机制

| 风险 | 缓解 |
|------|------|
| 巩固后机器人 reloc 失败 | Step 6 的 sanity check 不通过 → 自动回滚 |
| 巩固过程中断电 | staging 写完之前不替换 `ltm/`；半成品 staging 启动时清理 |
| 误删 iPhone 高 conf 节点 | 应用 remove 前再次检查 `source==iphone && conf>0.85`，若是则需 ≥ 10 倍证据 |
| 数据竞争（在线感知与巩固同时写） | 巩固开始前发 `set_readonly(true)`，在线感知此期间只允许写 `delta/`，不能切换 LTM 句柄 |

---

## 7.13 巩固后的指标记录

```python
def log_metrics(events, mem_before, mem_after):
    with open("robot_memory/logs/consolidation.log", "a") as f:
        f.write(json.dumps({
            "ts": datetime.now().isoformat(),
            "applied": len(events),
            "nodes_before": len(mem_before.nodes),
            "nodes_after":  len(mem_after.nodes),
            "anchors_before": len(mem_before.anchors),
            "anchors_after":  len(mem_after.anchors),
            "ltm_version_new": mem_after.schema_version,
        }) + "\n")
```

便于后续画"机器人记忆演化"曲线。

---

## 7.13.1 v1.5 升级：Self-Augmentation 巩固训练

### 背景：train-test discrepancy

§ 7.4–7.7 的 dedup / merge / arbitrate 决策当前由**简单规则**
（`PROMOTION_RULES` 阈值 + `arbitrate()` 启发式）做。v1.5 → v2.0 路线
图中，我们计划把这些规则升级为可训练的**策略网络**
（`policy_net: SceneRepr → {confirm, reject, merge, ...}`）。一旦走到
策略网络，就立刻撞上 Lyra 2.0 § 3.3 描述的 train-test discrepancy：

- **训练时**：策略网络看到的是"干净的当前 L3 snapshot"——离线流水线
  bundle adjustment 完毕、节点位姿无累计漂移、CLIP 嵌入由完整观测重算。
- **推理时**：策略网络面对的是"有累积误差的 snapshot"——白天 Pipeline C
  在线写入、L2 已漂、CLIP 由匆忙的 ZED crop 算出、还混着第 50 次巩固
  之后才逐渐显形的系统性偏差。

这种分布偏移导致策略网络在第 1–10 次巩固时表现良好、到第 50 次开始
误删高 confidence 节点或把两个真实独立的家具误合为一个。Lyra 2.0
§ 3.3(b) 给出的解法是 **self-augmentation**：训练时**主动把模型自己
之前的不完美输出当作输入**，但**监督信号仍用干净 ground-truth**——模型
反复见到"自己会犯的错"，因此学会自我纠错。完整原则陈述与 $p_{\text{aug}}$
取值讨论见 [`18_lyra_inspirations.md` § 18.4](18_lyra_inspirations.md)。

### 算法：`consolidate_with_self_aug()`

```python
# consolidation/self_aug.py  (v1.5 新增,配合 policy_net 升级使用)
import numpy as np

def consolidate_with_self_aug(
    l3_clean:    SceneRepr,            # 当前离线巩固出的"干净"L3 快照
    history_l3s: List[SceneRepr],      # 过去 N 次巩固留下的不完美快照
    policy_net,                        # 待训练的 dedup/merge 决策器
    p_aug:       float = 0.7,
    t_max:       float = 0.5,
) -> torch.Tensor:
    """
    单步训练:以 p_aug 概率把"历史不完美 L3"当输入,
    监督信号始终是从 l3_clean 推得的 dedup/merge 目标。
    """
    # ---- 1. 决定本步是否使用 self-aug ----
    if np.random.rand() < p_aug and len(history_l3s) > 0:
        # 从历史中采样一份"曾经的不完美 snapshot"做基底
        t = np.random.uniform(0.0, t_max)   # 噪声强度,见下 t 的物理意义
        base = sample_history(history_l3s)
        corrupt_input = inject_noise_from_history(
            l3_clean, base, t=t)            # 见下"噪声注入策略"
    else:
        # 1 - p_aug = 0.3 概率用真实的"干净"输入做兜底
        corrupt_input = l3_clean

    # ---- 2. 前向 + 统一向"干净目标"对齐 ----
    pred    = policy_net(corrupt_input)                       # logits over actions
    targets = dedup_targets_from(l3_clean)                    # 监督一律取 clean
    loss    = cross_entropy(pred, targets)
    return loss   # 调用方负责 backward + step;典型 1000 iter / 场景(见参数表)
```

### 噪声注入策略：把历史 L3 当 "corruption source"

`inject_noise_from_history(l3_clean, base, t)` 不是凭空加 Gaussian，而是
**让 `l3_clean` 退化成"看起来像 `base` 那个时点的中间状态"**。具体扰动
按 `t ∈ [0, 0.5]` 线性加权应用以下三类：

| # | 扰动名 | 实现 | 模拟的真实失败模式 |
|---|--------|------|-------------------|
| 1 | **节点位置抖动** | 对每个节点 `pose.position` 加 `N(0, σ_xyz)`，`σ_xyz = t · 0.10 m` | L2 长走廊漂移导致 L3 节点中心偏移 ±10 cm |
| 2 | **CLIP 嵌入扰动** | 对 `clip_embedding` 加 `N(0, σ_clip)` 后重新 L2 归一化，`σ_clip = t · 0.05` | ZED 暗光 / 模糊 crop 导致嵌入轻微偏离 |
| 3 | **节点随机丢弃** | 以概率 `p_drop = t · 0.10`（即 t=0.5 时丢 5%）随机移除非锚点节点 | 在线管线漏检小物品 / 被遮挡未上报 |

实现时三种扰动**独立采样、叠加施加**，并对应 `history_l3s` 中真实出现过
的偏差量级做了线性归一（最大扰动幅度对齐"第 50 次巩固"时的统计观测）。

### 参数表

| 参数 | 默认值 | 物理意义 / 来源 |
|------|--------|----------------|
| `p_aug` | **0.7** | Lyra 2.0 § 3.3(b) 报告的最佳点；> 0.5 让模型主要见自己的错，< 1.0 保留 30% 真实兜底，避免沉迷自生失败模式 |
| `t_max` | **0.5** | $t \in [0, 0.5]$ 表示"最多让历史看起来像**巩固到一半时**的中间状态"；t=1.0 会让样本退化到几乎全噪声，监督信号失效 |
| `σ_xyz` | t · 0.10 m | 与典型 L2 长走廊漂移上限对齐 |
| `σ_clip` | t · 0.05 | 与 ZED 暗光 crop 实测 CLIP 偏移分位数对齐 |
| `p_drop` | t · 0.10 | 与 Pipeline C 漏检率（v1.4 实测 ~5%）对齐 |
| 收敛迭代数 | **~1000 iter / 场景** | Lyra 用 7000 iter（视频扩散数据规模大）；PRISM 单场景规模约小 5–10×，1000 iter 经验上够 |
| 训练批大小 | 1 场景 / step | 场景图本身就是一个 graph batch，无需 mini-batch |

### 评测建议（回链 [`13_evaluation.md`](13_evaluation.md)）

在 [`13_evaluation.md`](13_evaluation.md) 的"**长时一致性**"指标族
（典型项：第 N 次巩固后的节点误删率、误合率、ghost-node 残留率）下，
**工程预估**：使用 self-aug 训练的策略网络在第 50 次巩固之后，

- **误删高 confidence 节点率**：下降 **30–50%**（baseline 无 self-aug 训练时通常 ~8% → 预期 4–5.5%）
- **误合相邻独立家具率**：下降 **30–40%**
- 第 1–10 次巩固指标基本持平（self-aug 主要解决长尾分布偏移，不解决初期能力问题）

ablation 计划：固定其他条件，对 `p_aug ∈ {0.3, 0.5, 0.7, 0.9}` 与
`t_max ∈ {0.25, 0.5, 0.75}` 跑 2D 扫描，验证 (0.7, 0.5) 是否对 PRISM
真实数据也最优——如果最优点漂到 (0.5, 0.5)，说明 Pipeline C 已足够稳定，
self-aug 信号可以降权。

### 与原巩固管线的关系

本小节**不替换** § 7.4–7.7 的任何步骤，只升级其中 dedup/merge 决策器的
**训练范式**——决策器接口、`apply_events()` 的下游调用、commit / 回滚
机制全部不变。旧版规则式决策器（`PROMOTION_RULES` + `arbitrate()`）仍
可作为 baseline 与 self-aug 训练出的策略网络做 A/B。回链
[`18_lyra_inspirations.md` § 18.4](18_lyra_inspirations.md)
"原则三：巩固期 Self-Augmentation"。

---

## 7.14 与 Chapter 06 的接口

| 项 | Chapter 06 | Chapter 07 |
|----|-----------|------------|
| 写 LTM | ❌ 严禁 | ✅ 唯一允许的写者 |
| 写 delta | ✅ append | 读取 + 重写 confirmed/rejected/kept |
| 读 LTM | 只读 | 只读 + 写 staging |
| 频率 | 实时 | 离线（充电时） |

两者通过 **文件系统** 解耦：在线感知不必知道巩固何时跑，巩固也不必停下感知。

---

## 7.15 本章小结

| 关键点 | 一句话 |
|--------|--------|
| **何时跑** | 充电 / 空闲；典型每天 1 次 |
| **筛选规则** | observation_count + 时间跨度 + 视点多样性 |
| **冲突仲裁** | 同 target 多事件合并；iPhone 高 conf 项有更高门槛 |
| **应用** | deepcopy + 整体替换，保证原子性 |
| **重训** | 仅受影响房间 + warmstart |
| **安全** | staging + sanity check + 回滚机制 |
| **比喻** | 像人脑睡眠——白天乱记，夜里整理 |

读完本章你应能：
- ✅ 编写一个能跑通的 `prism consolidate` 脚本
- ✅ 解释为什么要"延迟修改 LTM"
- ✅ 设计安全的回滚机制

下一章 [`08_runtime_timeline.md`](08_runtime_timeline.md) 把 Chapter 04–07 的所有模块串成一个**完整的端到端时序剧本**，从 T0 到 T4。

---

**章节版本**：v1.0
**估计阅读时间**：18 分钟
**关键收获**：把"短期 delta"变成"长期 LTM"的完整安全流程