怎么让 200 轮的长任务不崩——三层保全策略

0 阅读10分钟

怎么让 200 轮的长任务不崩——三层保全策略

2026-10-06·上下文工程·长对话

长任务不可避免——代码重构 200 轮、合同审查 300 轮。不是'别做长任务'能解决的。正确的问法是:怎么在 200 轮之后仍然保持完整性?答案是三层保全——Run 中认知交班(MidRunHandoff)+ Run 结束认知结算(Settlement)+ 多 Session 接力。

长任务不可避免

"长会话的三种死法"一章的结论是"不要试图用一个 Session 做 50+ 轮"。但有些任务天然就是 200+ 轮:

  • 代码重构——分析 15 个文件、设计接口、逐个迁移、写测试——200 轮很正常
  • 合同审查——14 个条款逐条分析、标注风险、交叉引用——300 轮在企业场景中常见
  • SWE-bench 评测——复杂 issue 的修复可能需要 196 轮(设计文档中的真实案例)

"别做长任务"不是解决方案——"怎么在长任务中保持完整性"才是。

行业对此的共识越来越清晰——Zylos Research(2026-03/04)总结的三层策略:

  1. 压缩——当上下文逼近窗口时释放空间("压缩策略与降级"系列已详细讲过)
  2. 结构化外部记忆——关键决策和进度持久化到上下文之外("TaskMemory"和"认知结算"系列已详细讲过)
  3. 多 Session 接力——不靠一个 Session 走完全程,而是多个短 Session 通过持久状态接力

这篇聚焦第三层——多 Session 接力——以及它和前两层怎么协作。


一个 200 轮任务的正确打开方式

不要这样做(一个 Session 200 轮)

Session 1: 轮次 1-200
  ├── 轮次 1-15:   正常(Comfortable)
  ├── 轮次 15-25:  开始压缩(Warning/Pressure)
  ├── 轮次 25-50:  第一次认知交班释放空间
  ├── 轮次 50-80:  第二次压缩
  ├── 轮次 80-120: 第三次压缩——规则开始退化
  ├── 轮次 120-160: context rot 加剧——假完成开始出现
  └── 轮次 160-200: 严重退化——Agent "变蠢了"

问题:5+ 次压缩后,早期的规则、决策、发现被反复有损摘要——信息质量逐次衰减。第 150 轮的 Agent 和第 10 轮的 Agent 是不同质量的 Agent——即使是同一个模型。

应该这样做(多个 Session 接力)

Session 1: 轮次 1-20(分析 + 设计)
  ├── 正常执行,无压缩
  └── Run 结束 → Settlement → SessionState 持久化
      "分析了 15 个 DAO,选了 Repository 模式,SQL 注入纳入迁移"

Session 2: 轮次 1-20(迁移前 5 个 DAO)
  ├── 从 Session 1 的 SessionState 恢复
  ├── 正常执行,无压缩
  └── Run 结束 → Settlement → SessionState 更新
      "完成 UserDAO/OrderDAO/CacheDAO/PaymentDAO/AuditDAO,发现 CacheDAO 有自定义连接池"

Session 3: 轮次 1-20(迁移后 5 个 DAO + 测试)
  ├── 从 Session 2 的 SessionState 恢复
  ├── 正常执行,无压缩
  └── Run 结束 → Settlement
      "全部 15 个 DAO 迁移完成,测试通过"

三个 Session × 20 轮 = 60 轮总计。 每个 Session 都在 Comfortable 区间内——零压缩、零 context rot。每个 Session 的质量和第一轮一样高。

vs 一个 Session 200 轮——前 20 轮质量高、后 180 轮逐步退化。


三层保全策略的协作

第一层:Run 内——MidRunHandoff(认知交班)

当上下文达到 70% 压力线时——主模型对完整历史产出一个"工作记忆快照"(约 1-2K token),替代大量旧消息。

交班前(80K token 占用):
  [系统提示 12K] [msg-1..msg-40 = 68K]

交班后(28K token 占用):
  [系统提示 12K] [快照 1.5K (Pinned)] [msg-36..msg-40 = 14.5K]

释放了 ~52K → 回到 Comfortable

MidRunHandoff 的价值:让一个 Session 的有效长度从 ~20 轮延长到 ~40-50 轮——因为在 70% 时交班一次释放大量空间,可以再跑 15-20 轮。

但交班是有损的——快照不可能包含 40 轮对话的所有细节。交班两次(跑 60+ 轮)后——早期的细节被交班摘要了两次——质量开始下降。

经验值:一个 Session 内最多交班 2 次(即最多跑 ~50-60 轮)比较安全。超过这个长度——开新 Session 更好。

第二层:Run 终——CognitiveSettlement(认知结算)

Run 结束时——主模型对完整对话做一次全量审视,产出四类产物:SessionState / MemoryEntries / Reflections / Learnings。

SessionState 是下一个 Session 的起点——新 Session 从 SessionState 恢复上下文,不需要回溯旧消息。

关键设计——Settlement 在所有终止路径上执行:

终止方式Settlement?SessionState 内容
正常完成(end_turn)✅完整认知快照
用户中断✅快照标记 interrupted
CycleDetector 终止✅快照标记 cycle_detected
预算用尽✅快照标记 budget_exhausted
进程崩溃(panic)❌无(下次检测到孤儿 Run)

除了进程崩溃——所有终止方式都有 SessionState。 用户中断一个 Run——SessionState 仍然被产出——下一个 Session 可以从中断点继续。

第三层:跨 Session——多 Session 接力

当一个 Session 结束(不管是正常完成还是中断)——下一个 Session 通过读取上一个 Session 的 SessionState恢复上下文。

Session N 结束:
  Settlement → SessionState 写入存储
    {
      pending_task: "迁移剩余 5 个 DAO",
      completed_actions: ["UserDAO 迁移完成", "OrderDAO 迁移完成", ...],
      key_decisions: ["选 Repository 模式", "SQL 注入纳入迁移"],
      plan_snapshot: { steps: [...], progress: "5/10" }
    }

Session N+1 开始:
  Assembler Stage 2 → 从存储加载 SessionState → 注入系统提示词
  
  模型看到:
    "上次的工作:完成了 5/10 的 DAO 迁移。
     关键决策:Repository 模式(因为已有 BaseDAO)。
     下一步:迁移 CacheDAO(注意自定义连接池)。"
  
  用户说:"继续"
  → 模型知道"继续"= "继续迁移 CacheDAO"

接力的成本:两个——

  1. SessionState 不包含对话细节——"第 15 轮讨论过 CacheDAO 的连接池问题"这种细节可能在 SessionState 中只被摘要为"CacheDAO 有自定义连接池"。如果新 Session 需要详细信息——Agent 需要重新读取相关文件。
  2. 一次额外的 Settlement LLM 调用——但 Settlement 的 token 消耗(~4K output)远小于继续在退化上下文中工作的浪费。

接力的收益:新 Session 从全新的上下文开始——零 context rot、零压缩历史、完整的注意力。SessionState(~1-2K token)比 200 轮对话历史(~200K token)轻得多、精确得多。


三层保全策略的协作·谁在什么时候做什么

跨会话续接——显式标记

默认情况下新 Session 不读旧 Session 的 SessionState——每个 Session 是独立的。

显式续接

消费方在 Run 请求中标注 metadata["resume_session"] = "旧会话ID"——引擎从旧会话加载 SessionState(只读),注入到新 Session。

"只读"意味着——新 Session 不修改旧 Session 的任何数据。新 Session 的后续 Settlement 写入自己的 SessionState——从此独立演化。是"续接"不是"共享"。

自动续接(消费方实现)

一些消费方实现了自动续接——同一用户、同一 Agent 的新 Session 自动加载上一个 Session 的 SessionState。

这在"每天和同一个 Agent 讨论同一个项目"的场景中很有用——用户不需要每次都手动说"接着昨天的继续"。


孤儿 Run 恢复

如果 Run 因为进程崩溃(panic)而终止——Settlement 没有执行、SessionState 没有产出。

下次 Cell 启动时——引擎检测孤儿 Run:

  1. MarkInterruptedSessions() 标记所有未正常结束的 Session
  2. ListOrphanedRuns() 列出没有终态事件的 Run
  3. 孤儿 Run 标记为 status=resumable

用户可以通过 API 查询 GET /observe/runs?status=resumable 找到这些孤儿 Run。 恢复时——引擎从 TaskMemory 读取 Plan 和 Findings(它们在崩溃前已持久化),从最后一个 Checkpoint 继续。

没有 Settlement 的恢复比有 Settlement 的恢复质量低——因为缺少 SessionState 的精炼摘要。Agent 需要从 TaskMemory 的原始制品(Plan 步骤列表 + 若干 Findings)重建上下文——比从 SessionState 的结构化快照恢复慢且粗糙。

这就是为什么 Settlement 在所有非 panic 终止路径上都执行——包括用户中断。 即使用户说"停"——也值得花 2-5 秒做一次 Settlement。


孤儿Run恢复·崩溃后的自救机制

行业的三层共识

Zylos Research 的总结代表了截至本文写作时的行业共识:

"The most robust production systems combine all three: compaction, structured external memory, and sub-agent delegation."

层我们的实现Claude CodeCursor
压缩6 种策略分级管线 + MidRunHandoffautocompact + PreCompact/PostCompact hooksprompt-based summarization
结构化外部记忆TaskMemory 5 种制品 + SessionStateAuto Memory(文件级)+ memory tool.cursor/rules/ + 社区方案(Recallium / ContextPool)
多 Session 接力SessionState 跨会话续接 + 孤儿 Run 恢复/clear + Auto Memory 跨 Session每次新 Chat 从零开始(无内建接力)

关键差异:

  • Claude Code 有压缩和外部记忆,但多 Session 接力依赖用户手动(/clear 后手动描述上次做了什么,或等 Auto Memory 自动加载文件级笔记)
  • Cursor 没有内建的接力——每次新 Chat 从零开始。社区方案(MCP 插件)可以在 Session 之间传递上下文,但不是框架内建的
  • 我们的引擎——Settlement 自动产出 SessionState → 新 Session 自动加载 → 不需要用户手动描述"上次做了什么"

Anthropic 的建议

Anthropic 在 Claude Code 的工程博文中间接承认了多 Session 接力的价值:

"With capable enough models, multi-session handoff complexity could be dropped entirely — compaction alone was sufficient."

但用户报告(#81988、#32659)表明——在长 Session 中 compaction alone 不够。规则仍然退化、假完成仍然出现。

Anthropic 的"capable enough models"可能指的是未来的模型——不是截至本文写作时的现实。 在当前模型能力下,多 Session 接力仍然是最可靠的长任务策略。


一个完整的 200 轮任务生命周期

Session 1(轮次 1-25):分析 + 设计 + 前 3 个 DAO 迁移
  ├── 轮次 1-15: Comfortable(无压缩)
  ├── 轮次 15-20: Warning(FileCard 折叠)
  ├── 轮次 20-25: Pressure → MidRunHandoff 交班一次
  └── Run 结束 → Settlement
      SessionState: "完成 3/15 DAO,选 Repository 模式"
      MemoryEntries: "用户偏好 Repository""SQL 注入纳入迁移"
      Learnings: "CacheDAO 有自定义连接池"

Session 2(轮次 1-25):迁移 DAO 4-8
  ├── 从 Session 1 的 SessionState 恢复
  ├── 读到"接下来迁移 DAO 4,注意 CacheDAO 连接池"
  ├── 轮次 1-25: 正常执行 + 1 次交班
  └── Settlement: "完成 8/15 DAO"

Session 3(轮次 1-25):迁移 DAO 9-15 + 测试
  ├── 从 Session 2 恢复
  └── Settlement: "全部完成,15/15 DAO 迁移 + 测试通过"

总计: 3 × 25 = 75 轮(实际工作量)
每个 Session: Comfortable-Warning 区间,最多 1 次交班
context rot: 几乎为零(每个 Session 起点都是精炼后的 SessionState)

vs 一个 Session 200 轮——3+ 次交班、5+ 次压缩、规则在第 80 轮开始退化、假完成在第 120 轮开始出现。

75 轮分三个 Session > 200 轮一个 Session。 不只是质量更高——总 token 消耗可能更低(因为没有反复处理被压缩又恢复的历史)。


200轮任务完整生命周期·五个Run的接力赛

你现在能做什么

1. 200 轮的任务拆成 3-5 个 Session。 每个 Session 15-25 轮。在自然断点(一个模块完成、一个阶段结束)开新 Session。

2. 新 Session 开始时注入上次的状态。 如果你的框架支持 SessionState / Auto Memory——让新 Session 自动加载。如果不支持——在第一条消息里手动粘贴上次的总结。

3. 关键规则写在文件里——每个 Session 重新加载。 CLAUDE.md / .cursorrules / AGENTS.md 是每个 Session 的起点——不受上一个 Session 的压缩影响。

4. Run 中断后也要做 Settlement。 用户说"停"——花 2-5 秒做一次结算。下次恢复时有 SessionState vs 没有 SessionState 的体验差距巨大。

5. 监控"单 Session 压缩次数"。 如果一个 Session 压缩了 3+ 次——context rot 可能已经开始。考虑在下一个自然断点开新 Session 而非继续。

6. 不要被"模型窗口越来越大"误导。 1M 窗口不解决 context rot。context rot 从第 30 条消息开始——不管窗口是 200K 还是 1M。短 Session + 持久状态 > 一个超长 Session。


引用来源

  • Claude Code GitHub issue #81988, "Long-context degradation" — 规则退化的生产报告
  • Claude Code issue #32659, "Context amnesia in long sessions" — 量化退化数据
  • Zylos Research, "Agent Context Compaction for Long-Running Sessions" (2026-04) — 三层策略共识
  • Zylos Research, "Context Window Management and Session Lifecycle" (2026-03) — 多 Session 接力
  • neura.market, "Cursor's compression isn't a bug" — PocketOS 事故
  • Anthropic 官方文档 — "more context isn't automatically better"
  • Cursor Blog, "Training Composer for longer horizons" (Mar 2026) — "summarization is lossy"