跳转到内容
Aira 3D

Aira 模型接口新架构：宿主持有记忆的有界步进

状态：Active（裁定项 1–4、6、11–13、15–16 已定；N0–N5 已交付；0.4.0 单管线轻量接口与单轮复合计划（Composite Plan）已全面落地，提交 4a439bd1：COMPACT_STEP_SIGNATURES（1.5 KB 紧凑 TypeScript 接口声明）彻底取代 144 KB 臃肿 JSON Schema AST，确立单一管线原则，不维护复杂/简单双轨；模型首轮直出复合计划，失败精准局部点名修补；R1、R2、R4 全环裁判 100% 通过，输入 Token 暴降 99.8%，耗时减半，费用降低 90%+） 计划版本：0.4.0（0.2.x 步进原型与状态寻址；0.3.0 有界日志与 S9 矩阵；0.3.16 删除旧对话回路；0.4.0 确立单管线紧凑接口与单轮复合计划，接口瘦身 99%，彻底消除长回路多步握手与双管线维护负担） 创建日期：2026-09-15 最后更新：2026-09-17 依据：真实目标探测协议（R0–R6、R3S、R3M 已冻结）、探测结果 兼容的规范：RFC-0002 §1 决策、§7 Progressive Capability Disclosure、§9 Task Capsule、§13.2.1 合法论域物化【未实现】 上位目标：产品结构方案 S9（AI 自主性证据）与 S10（规模）；状态只记在工作进度

0. 结论先行

Section titled “0. 结论先行”

今天的架构把对话转录当作模型的记忆：每次请求把整段转录重发给提供方，上下文等于转录长度，随任务步数无界增长；探测环里所有关于上下文的修复 （增量编码、扁平 entries、compactHistory）都是对转录的压缩，上界靠启发式争取，不靠构造保证。量出来的后果（§1）：空模型第一步 42k token， R4 单步最大 331k，一次任务累计最高 3.15M；“任何模型都能操作”在这条架构上不可能成立——它要求窗口 ≥ 512k 且提供方有前缀缓存计价。

新架构把记忆交给宿主，模型每一步是一次独立、有界的调用。 宿主持有修订图、工作集、发现台账、拒绝台账与模型的显式便签；每一步由宿主按预算 B 构造一个“步胶囊”交给模型，模型返回一个结构化决策（读、查、检查 / 暂存 STEP、计划、钉住、便签、完成、弃权），宿主验证、执行、更新台账、构造下一个胶囊。 没有对话历史进入提供方。于是：

  • 单步上下文 |κ_t| ≤ B 对每一步成立，是构造的性质，不是压缩的结果；一次任务的计费输入从 Θ(S²) 变成 S·B；
  • 与提供方解耦：不依赖 reasoning_content 回传语义、工具调用能力或前缀缓存——决策是 JSON，哪种模型都能给；提供方若回传推理，宿主把它逐条留在本轮日志里送回（§6.6），没有也能跑（便签是与提供方无关的记忆）；
  • 每一步可独立计价、独立路由（读与查用便宜模型，计划用强模型）、独立重放与续跑；
  • “模型看到了什么”逐步可审计：胶囊与决策就是完整轨迹。

本文给出量测基线、信息论表述、复杂度消元、架构与协议、迁移边界、验证与裁定项。不改代码；实施按 §8 分阶段提交，付费运行逐次授权。

1. 量测基线（2026-09-15，提交 11f4725f 的服务字节）

Section titled “1. 量测基线（2026-09-15，提交 11f4725f 的服务字节）”

数据来源：假 provider 栈保存的网关请求体（fake-requests/req-*.json，与真实栈逐字节相同）；付费运行抓取里的 providerUsage（逐 provider 调用的 inputTokens、reasoningTokens）。 量具是 tools/context-accounting/（N0 交付）：account.mjs prefix 从构建好的 @aira/cad-tools 算前缀，与抓取的提供方请求逐字节一致；account.mjs captures 从抓取算逐请求字节构成与逐步 token， 每次任务的累计输入与产品计量表（输入）逐一相同。本节数字已按该工具重算（2026-09-15）。

1.1 固定前缀：五个工具的描述与 schema，172,582 字节 ≈ 41,984 token（4.11 字节 / token）

Section titled “1.1 固定前缀：五个工具的描述与 schema，172,582 字节 ≈ 41,984 token（4.11 字节 / token）”
工具 描述（字节） parameters JSON（字节） 占比
aira_compile_exact_plan 3,171 138,368 82.0%
aira_model_read 3,901 15,263 11.1%
aira_inspect_brep 6,927 206 4.1%
aira_library_reference 2,510 944 2.0%
aira_stage_brep 582 710 0.7%

计划 schema 里 100 个 $defs、29 种步骤变体；描述文字 64,732 字节（199 段），其余 73 KB 是 JSON Schema 脚手架。空模型第一步 42,146 token 中 41,984 是缓存命中的前缀，指令 162。

1.2 状态卡片：15 实例的 R3 冻结模型，67,607 字节 ≈ 28k token

Section titled “1.2 状态卡片：15 实例的 R3 冻结模型，67,607 字节 ≈ 28k token”

exactModelContext（packages/aira-cad-tools/src/tools.ts:1221）投影整份文档，附在每条用户消息末尾（agent-client.ts:992），同一投影也是每次读回的 currentModel（71,534 字节）。

块 字节 内容
configuration 22,450 effectiveProduct 8,770 · effectiveAssertions 11,739 · effectiveParameters 1,773
document 26,732 product 8,770 · assertions 11,739 · nodes 3,133 · parameters 1,773 · bodies 887
evaluation 17,923 documentAssertions 11,865 · product 4,960 · 其他 ~1,100

29 条断言出现三次（35 KB / 68 KB），产品结构两次，参数两次；312 处 {"const":{"type":…,"unit":…,"value":…}} 裹包；295 处 32 位十六进制 id（13,258 字节，仅 50 个不同）。 卡片随产品内容线性增长：各阶段起始文件的“第一步 − 前缀”从 R0 的 0.2k 到 R6 的 33.7k token。

1.3 逐步增长：自身输出回传，工具结果整份倾倒

Section titled “1.3 逐步增长：自身输出回传，工具结果整份倾倒”

@ai-sdk/deepseek 对每条带 reasoning 的助手消息回传 reasoning_content（dist index.js:331–372）；浏览器端工具执行完接着同一轮继续，所以一轮 = 整个任务， 每步推理滚进后续所有步（R3S-1 累计 87.6k 推理 token）。被拒计划与其报错留在历史里。读回默认整份状态；R4-12 第一次查库返回 52,997 字节。

1.4 各阶段单步上下文（token，providerUsage 逐步值）

Section titled “1.4 各阶段单步上下文（token，providerUsage 逐步值）”
阶段 第一步 单步最大 一次任务累计输入 一次任务推理输出
R0 42,146 54k–64k 146k–164k 8.5k–17.9k
R1 44,410 69k–133k 114k–994k 22.8k–31.1k
R2 50,521 123k–153k 289k–1.46M 29.2k–56.3k
R3 56,525 157k–290k 668k–2.16M 44.6k–70.0k
R3S 59,098 185k–231k 1.22M–1.66M 65.2k–87.6k
R3M 70,404 118k–130k 410k–441k 13.5k–20.8k
R4 70,199 171k–331k 70k–3.15M 13.7k–80.6k
R5 44,891 85k–105k 625k–712k 7.3k–12.5k
R6 75,742 147k–188k 1.04M–1.16M 21.2k–34.6k

R4-12 最后一步 197,426 = 前缀 42k + 卡片与指令 28k + 自身输出 75k（推理 59.5k）+ 工具结果约 52k。

1.5 现有护栏

Section titled “1.5 现有护栏”

DEFAULT_NATIVE_AGENT_BUDGET（apps/web/src/ai/agent-task-contract.ts:23）：48 轮、16 次修复、15 分钟、输入 3M token、输出 384k、$5；网关请求体 1 MB、消息 96 条。 注释原话：“every provider turn resends the whole context, so input tokens accumulate per turn”——这是对症状的封顶。

2. 信息论表述

Section titled “2. 信息论表述”

2.1 现状：转录即记忆

Section titled “2.1 现状：转录即记忆”

第 s 步上下文 C_s = M + U + Σ_{i<s}(O_i + T_i) + u（M 手册、U 卡片、O_i 自身输出、T_i 工具结果、u 指令）。一次任务计费输入 Σ_s C_s = S·(M + U + u) + Σ_s Σ_{i<s}(O_i + T_i)，当 O_i、T_i 均值为常数时后一项是 S(S−1)/2·(ō + t̄)——对步数二次。各项的阶：

项 阶 实测
M Θ(|Σ|·s̄) 42k token
U Θ(3K + 2N + 2P)·c 0.2k–33.7k token
Σ T_i Θ(S·(N + K + P)) 52k–178k
Σ O_i Θ(S·ō) 8k–88k
Σ_s C_s Θ(S²) 1.84M / 12 步（R4-12）

（N 实例、K 断言、P 参数、|Σ| 步骤种类、S 步数、ō / t̄ 每步自身输出与工具结果均值。）

对决策的条件熵逐块为零或接近零：重复副本 H = 0；裹包的 type/unit 由列决定，H = 0，编码效率 < 10%；32 位 id 的 128 bit 里模型只需 log₂50 < 6 bit； 手册每步只用到 3–6 种步骤（< 20%）；历史在当前修订 r_s 之外对下一步决策的互信息 ≈ 0（设计意图已持久化在状态里）；自身推理的互信息随步衰减，提供方要求回传只是“本轮”语义。 压缩转录能把这些常数压小，但四个变量 N、K、P、S 仍在上界里，且 Σ O_i 一项受提供方轮语义支配，宿主不能单方面保证。

2.2 新架构：有界记忆的决策过程

Section titled “2.2 新架构：有界记忆的决策过程”

把模型建模为一个有界记忆的决策过程：

  • 宿主状态 s_t：修订图、块哈希、别名表、台账（§4.2）。
  • 模型输入 κ_t = f(s_t, W_t, m_t, r_t)：由摘要、工作集 W_t（模型钉住的页）、便签 m_t（模型显式写的记忆）、上一步结果 r_t 构成，|κ_t| ≤ B。
  • 模型输出 (d_t, m_{t+1})：一个决策与更新后的便签，|m_{t+1}| ≤ b。
  • 宿主转移 s_{t+1} = g(s_t, d_t)。轨迹 (κ_t, d_t)_t 是完整记录。

三条性质：

  1. 充分性。对宿主，r_s 是过去的充分统计量；对模型，(摘要, W_t, m_t, r_t) 是它能合法作用的全部——它需要的任何其他信息都可按地址读入 W。转录不再是任何一方的必要输入。
  2. 速率控制。模型的记忆 m 与工作集 W 是它自己在预算 B、b 下的分配：钉住什么、记下什么、放弃什么，由模型决定；宿主在每个胶囊里报告已用与剩余，形成显式的速率控制回路，而不是宿主猜测哪段历史重要。
  3. 失真为零。宿主全量校验每份计划，与模型看到什么无关；胶囊变小改变的是速率（步数、拒绝数），不是正确性。

内容寻址让“发过的东西不再发”成为规则：页带 (rev, hash)，提交后宿主只送变化的块（哈希差），模型持有的未变页只收到“未变”一行。

2.3 复杂度消元

Section titled “2.3 复杂度消元”
项 现状 新架构 消掉的变量
手册 M Θ(|Σ|·s̄) 索引 Θ(|Σ|)（每种一句）+ 在用种类的 L2 页 O(k·页) 与 schema 细节的耦合
状态 U Θ(3K + 2N + 2P)·c 摘要 O(1)（计数、块哈希、别名首页） N、K、P
工具结果 Σ T_i Θ(S·(N + K + P)) 工作集 O(w)，w ≤ B 由模型分配 S、N、K、P
自身输出 Σ O_i Θ(S·ō) 便签 O(b) S
历史 Θ(S) 转录 台账折叠行 O(#提交)，可封顶 S
单步 C_t Θ(N + K + P + S) ≤ B 全部
任务累计 Θ(S²) S·B 二次项

B 与 b 按档位声明（§3）；S 由任务协议封顶（步数上限），于是任务总费用 ≤ S_max·B 是事前可算的数——这才是“可预测的时延与费用”。

3. 档位与目标数字

Section titled “3. 档位与目标数字”
档 目标窗口 B（胶囊上限，token） b（便签） 页上限 备注
T32 32k 24k 1k 2k 索引 + 摘要 + 两三页 + 一页 L2
T128 128k 96k 2k 4k 默认档
T200 200k 160k 4k 8k 强模型；允许更大工作集

胶囊的固定部分（索引 ≈ 1.5k、摘要 ≤ 2k、意图 ≤ 1k、预算表与台账折叠行 ≤ 1k）≈ 5k token，其余全部是模型自选的工作集与在用的 L2 页。 N2 实测修正：索引段（29 种步骤各一句 + 决策语法）≈ 6 KB；一种步骤的 L2 页 21–47 KB 而不是 ≤ 8 KB（每种都携带共享的 expectation / requirements 定义），N2 以“同时至多两页、成功使用后释放”约束，N3 索引化时把共享定义拆为独立页；lookup / inspect 结果尚无页上限（实测 75–90 KB），N3 与 select 同规则。 按 §1 的构成估算：R3M 一类任务每步 ≈ 12k–20k，R4 一类每步 ≈ 30k–60k（三份程序源码页 + 图纸读回可以分步钉住 / 释放）；R4-12 从 1.84M 累计降到约 12 × 45k ≈ 0.55M， 无缓存计价下 $0.81 → $0.24。这些是估算，以 §6 的零成本记账为准；上限 B 则不是估算，是宿主拒绝越界的硬界。

4. 架构

Section titled “4. 架构”

4.1 组件

Section titled “4.1 组件”
浏览器工作台（宿主）                                   网关（无状态）            提供方
┌──────────────────────────────────────────────┐    ┌──────────────────┐    ┌─────────┐
│ 状态存储：修订图 · 块哈希 · 别名表（按修订）      │    │ /api/step        │    │ DeepSeek │
│ 任务台账：意图 · 工作集 · 发现 · 拒绝 · 提交 · 便签 │ ─▶ │ 提供方适配 · 记账  │ ─▶ │ OpenAI… │
│ 胶囊构造器：|κ| ≤ B（构造时断言）                 │ ◀─ │ 决策原文 + usage  │ ◀─ │ Anthropic│
│ 决策校验 · 步执行器（cad-tools 宿主操作）         │    └──────────────────┘    └─────────┘
│ 人类视图：每步胶囊与决策的本地轨迹（HUD）          │
└──────────────────────────────────────────────┘
  • 状态存储：现有追加式修订图之上加块级哈希（parameters、bodies、nodes、product、assertions、drawings、linearDimensions、datums、geometricTolerances、exchangeSources…每块一个）， 以及按修订确定的别名表。文档格式、STEP、验证器不变；别名只在信道。 实施裁定（N1，2026-09-15）：别名不按 id 字典序编号，而按标签。 有唯一且 id 安全标签的体与参数为 b:<label> / p:<label>，只作一个此类体的作者节点为 n:<label>， 其余（断言、无标签或重名实体）取自身 id 的短形式 a:e6ae.6.1（摘要前四位 + 步后缀，仅在碰撞时加长）。理由：序号别名依赖其他实体的排列，而任务中创建的实体 id 是随机摘要， 每次提交都会让约一半的序号改名——模型便签里的 b3、钉住页里的引用、差分的“未变”判断全部失效；标签别名与短形式都只由该实体自身决定，提交创建新体时既有别名一个不变， 且标签就是模型本来在文本里用的名字。别名表是权威（exactModelAliases，packages/aira-contracts/src/exact-model-aliases.ts）：解析只查表、从不解析字符串。
  • 任务台账（宿主内存 + 本地持久化，随会话）：意图帧；工作集 W（path、rev、hash、字节数、是否钉住）；发现台账（送达的索引哈希与 L2 页列表 = discoveryCatalogHash）； 拒绝台账（当前一条全文，早先的折成一行）；提交台账（每份已提交计划一行：修订、种类、changes 摘要 ≤ 1 KB）；便签 m（模型显式写入，≤ b）；预算表。
  • 胶囊构造器：按固定次序拼装，逐段计量，超过 B 时先淘汰未钉住的页（最久未引用优先），仍超则拒绝并要求模型释放；淘汰与拒绝都写进胶囊让模型知道。
  • 决策校验与步执行器：决策先过决策语法（§4.4），计划再过全量 EXACT_CAD_PLAN_SCHEMA 与论域（别名按修订解析），然后调用现有 cad-tools 宿主操作 （model.read、编译计划、查库、暂存 / 检查 STEP）。这些操作与其语义不变。
  • 网关：/api/step 一次调用 = 一步：入参 {taskId, step, tier, capsule, decisionSchema}，出参 {decision, usage, providerCalls}；无状态，不存历史；记账、安全、超时与今天相同。 提供方适配是薄层：DeepSeek 首个，OpenAI-compatible 与 Anthropic 随 S9 的 provider 抽象加入；对支持工具调用的提供方，决策以一次工具调用表达，其他用 JSON 输出，两种由同一校验器验证。
  • 人类视图：本地轨迹记录每步的胶囊哈希、胶囊原文、决策、usage；HUD 的转录投影改为读这条轨迹。用户中途插话成为新的意图帧增量，进台账，不进转录。

4.2 胶囊 κ_t（固定次序）

Section titled “4.2 胶囊 κ_t（固定次序）”
1. 索引（L0/L1）：接口版本、档位、决策语法摘要、29 种步骤各一句、可读路径语法、段序说明       ≤ 1.5k
2. 意图帧：指令原文、硬要求、范围、禁止效果（宿主整理，模型可在便签里补充理解）            ≤ 1k
3. 在用种类的 L2 页：共享 `$defs` 一份在前，各种类只带自己的主体（首次由拒绝或查询送达）    ≤ k × 页
4. 工作集：模型钉住的页原文（每页带 rev、hash；提交后未变的页只留一行"unchanged @hash"）    ≤ B − 其余
5. 摘要：rev、计数、各块哈希、根、别名表首页（参数 / 体 / 装配标签）、评估状态与结果哈希      ≤ 2k
6. 便签 m_t：模型上一步写下的文字，原样                                                     ≤ b
7. 预算表与台账折叠行：步号、已用 / 剩余 B、钉住页列表（path, hash, 字节）、已提交修订各一行、
   淘汰记录（"页 X 因预算释放，可重读"）                                                   ≤ 1k
8. 上一步结果或拒绝：工具结果页 / 计划提交的 changes / 拒绝全文 + 该步骤种类的 L2 页       ≤ 8k
9. 草稿 scratch：模型上一步推理的尾部，宿主截取、每步替换（提供方不回传推理则为空）         ≤ 2k（T128）

0.3.0：胶囊一轮只建一次（§6.6）。一轮 = 一个胶囊 + 只追加的日志（每步的决策连同模型自己的推理、宿主的结果）；提示词 = 胶囊 + 日志，|胶囊| + |日志| ≤ B 由构造保证：下一步装不下时宿主压缩——先在结果里告知 host.windowFull、模型用一步写便签，再从台账重建下一轮的胶囊。 第 9 段（scratch，0.2.8）取消；段序仍按稳定优先排，只对压缩后的新胶囊有意义。轮内查到的种类页、库回答、读到的页都留在日志里（共享 $defs 一轮只送一次），台账同时记录。压缩时种类页只留在用的（0.3.6）：新轮的胶囊只带待修复拒绝所涉种类的页与上一结果点名的页，其余查过的种类页随日志离开——实测压缩后的胶囊 160–187 KB 里 110–130 KB 是本轮查过却没用于计划的种类页（8 种类 + 70–85 KB $defs），T128 下每轮 27–33k token 的固定占用决定一轮装几个重步；一个种类再要一次是一步 2–5 s、只送进日志一次。钉住页与库回答仍由模型管（pin / unpin）。

4.3 状态寻址

Section titled “4.3 状态寻址”
  • 读：read{select:[path…], limit, offset}，路径语法与 update-product 的扁平 entries 相同（["assemblies","asm.arm2"]、["nodes","n2","source"]、["assertions"]）， 现有选择器保留（bom、faces、edges、occurrences、distance、projection、drawingId、resources）。每页 ≤ 页上限，带 (rev, hash)。
  • 钉住：pin{pages} / unpin{pages}；未钉住的页在下一步默认释放（结果只在第 7 段出现一次）。模型想长期持有就钉住，并为此付预算。
  • 差分：提交后宿主比较块哈希，工作集里未变的页替换为一行；变化的页按原 select 重新取回（自动，不占决策）。
  • 别名：计划里 bodyId、nodeId、parameter、assertionId 接受别名或全 id；按胶囊里的 rev 解析；胶囊 rev 与当前 head 不一致时拒绝 EXACT_STEP_STALE_REVISION 并给新摘要。 N1 落地：编译器入口一次整体解析（compileExactCadPlan，整串匹配的值与对象键；摘要与程序源码等长文本不动），旧的全 id 计划解析为自身；读的选择器（faces / edges / occurrences / distance）也接受别名； select 路径里的别名在选页时解析并按原样回显。stale-revision 拒绝属 N2 的台账。 决策 schema 每步生成，因此把合法句柄物化为 enum（RFC-0002 §13.2.1）在这里没有前缀缓存代价——默认开启，作为裁定项 4。

4.4 决策语法（模型输出，恰好一个动作）

Section titled “4.4 决策语法（模型输出，恰好一个动作）”
{"act":"read",   "select":[["nodes","n2","source"]], "limit":1, "pin":true, "note":"…"}
{"act":"lookup", "query":"ISO 4762 M3", "detail":"summary", "note":"…"}
{"act":"inspect","contentHash":"sha256:…"}
{"act":"stage",  "name":"arm-p2.step", "mediaType":"model/step", "content":"…"}
{"act":"plan",   "summary":"…", "steps":[{"kind":"set-parameters", "…":"…"}], "note":"…"}
{"act":"pin",    "pages":["p:3"], "unpin":["p:1"]}
{"act":"note",   "note":"…"}
{"act":"done",   "summary":"…"}
{"act":"abstain","reason":"…", "missing":["…"]}
{"act":"batch",  "acts":[{"act":"read","select":[["product"],["parameters"]],"pin":true},{"act":"lookup","query":"build-program, set-parameters"}], "note":"…"}
  • inspect / stage 是 R5 路径用到的两个宿主操作（aira_inspect_brep / aira_stage_brep），N0 把冻结运行改写成决策脚本时补进语法：冻结的 R5 两次各两次 inspect，stage 由操作者代外部系统投放、模型未用过，仍保留为动作。
  • note 可附在任一动作上，替换便签全文（≤ b）；模型对自己的记忆负全责，宿主不做摘要。
  • plan 的 steps 按索引写；宿主用全量 schema 校验，失败返回 instancePath + 该种类的 L2 页（≤ 8 KB），并把该页记入发现台账；下一步胶囊第 6 段自动含此页。
  • 一步一个写动作（plan / stage）或终态；只读动作（read / lookup / inspect / pin）可以合成一个 batch，按序执行，结果合在 lastResult.results 里（至多 8 项；批里出现写动作整批拒绝 STEP_DECISION_FIELD_INVALID）。 0.2.7 之前“一步只允许一个动作”：冻结运行里模型一次响应连发多个调用的情形（R3M-2 五次查库、R4-11 五次读面）被改写成连续的多步；N4 审计（§6.5）量出每一步都要模型从零重推一遍设计，读回 / 查库步占了 56% 的时间，于是只读动作不再各占一步。
  • 传输：决策 JSON 是浏览器与网关之间唯一的契约，传输方式只是网关适配器的一个参数（tool / json），浏览器对它不可见。首期只实现 tool：七种动作映射为一个工具 aira_step 的调用， inputSchema 即本语法加当步生成的 enum——这是 DeepSeek 今天在用的通道，也是把 schema 作为一等字段送达的通道。DeepSeek V4 思考模式不能强制 tool_choice （现有 omitUnsupportedV4ThinkingToolChoice 补丁即为此），模型可能以纯文本作答：宿主把无工具调用的文本回复映射为 done{summary}，与今天“最终文本结束任务”的行为一致。 json 传输（response_format 或文本提取，schema 嵌入胶囊）随第二提供方适配在 N5 加入，届时才需要它——S9 里“无工具调用的模型”那一行。两种传输经同一校验器得到同一轨迹。
  • 一步一个写动作，是为了让每步的胶囊与费用可预测、可路由；批量读用 select 的多路径或 batch 表达。

4.5 步循环（宿主）

Section titled “4.5 步循环（宿主）”
t = 0; 台账 ← 意图帧；W ← ∅；m ← ""；κ ← 构造(s, W, m, ∅)；日志 L ← []
loop:
  断言 |κ| + |L| ≤ B
  (d, reasoning, usage) ← 网关.step(κ, L)；轨迹.append(hash(κ), |L|, d, usage)
  校验 d；不合法 → r ← 拒绝（含该种类的页，共享定义一轮只送一次）
  否则执行 d：read → r ← 页；lookup → r ← 结果（含种类页）；plan → 编译 / 校验 / 提交 → r ← changes + 新摘要 + 刷新的钉住页，或拒绝；
          pin/unpin → 更新 W；note → 更新 m；batch → 只读动作按序执行，r ← 各结果；done → 终态；abstain → 终态（弃权）
  轮的记账：若上一步已告知 windowFull，或 |κ| + |L| + |d| + |reasoning| + |r| > B：
            L ← []；κ ← 构造(s, W, m, r)                      —— 压缩：新一轮，只有台账与便签留下
          否则 L.append(d, reasoning)，L.append(r)；若 |κ| + |L| > B − M：r 附 host.windowFull（模型下一步写便签）
  预算：步数、费用、时限（按 §1.5 的常量改为按步计）；超出 → 终态 budget

轮内提供方看到的是同一前缀（胶囊 + 日志）加新追加的两条消息：推理由 reasoning_content 回传，模型接着想；前缀缓存逐字节命中。压缩是有界性的全部代价（§6.6）。

续跑：提供方中断后从轨迹最后一步重构 κ 即可，不需要转录。重放：把轨迹里的决策序列喂给假 provider，任何一次任务都能零成本重放到同一终态——这是探测环的新地基。

4.6 路由与并行（后续）

Section titled “4.6 路由与并行（后续）”

每步独立，于是 read / lookup / pin 可路由到便宜模型，plan 路由到强模型；三个程序编辑一类相互独立的子任务可以并行成三条子步序列，各自有界。 两者都不在首期范围，但架构为它们留出位置：轨迹里记录每步实际使用的模型，S9 矩阵按步而不是按任务比较。

5. 迁移边界：替换什么、保留什么

Section titled “5. 迁移边界：替换什么、保留什么”
对象 处理
apps/web/src/ai/agent-client.ts（1,281 行：AbstractChat 回路、compactHistory、modelPrompt、卡片） 替换为步循环 + 胶囊构造器 + 台账；NativeAgentTaskTrace 的 turns / operationTrace 扩展为步轨迹（胶囊哈希、决策、usage、模型）
apps/server/src/model/deepseek-agent.ts（579 行 ToolLoopAgent）与 /api/agent（UIMessage 流） 替换为 /api/step + 提供方适配；记账、安全、MAX_GATEWAY_BODY_BYTES、超时沿用
packages/aira-cad-tools/src/chat.ts（UIMessage 元数据） 替换为步 usage 记录
五个 SDK 工具的线上 schema（172 KB） 替换为索引 + 决策语法 + 按需 L2 页；宿主侧操作与 EXACT_CAD_PLAN_SCHEMA 校验不变
exactModelContext 卡片 替换为摘要 + 按地址页；同一投影函数改造，别名表由它产生
cad-tools 宿主操作、aira.exact-cad-plan 契约（升 0.22.0：别名、select）、AMIR 0.4 schema（密封）、密封 OCCT v0.21、.aira.json、STEP、验证器 保留
MCP 投影（packages/aira-cad-tools/src/mcp.ts，外部代理） 保留工具调用形态，改用索引 schema + 按需页；外部代理自管上下文
HUD 转录投影（AgentTaskProjection.ts）、任务协调（WorkbenchAgentTaskCoordinator.ts） 保留，数据源改为步轨迹
旧 /api/agent 回路 新回路在探测环上冻结之前保留（S9 用它做同模型对照），冻结后删除，不双轨维护——已删除 2026-09-16（S9 之后；网关只剩 /api/step，浏览器只剩步进回路）

RFC-0002 的对应：胶囊是 §9 Task Capsule 最强形式（模型只看得到它）；索引 / L2 页 / 拒绝附页对应 §7 的 L1 / L2 / DISCOVERY_REQUIRED； 每步生成的 enum 实现 §13.2.1；§1.1 “不靠 prompt 技巧、不要求模型记忆全部能力”由架构保证而不是由措辞保证。

6. 验证与冻结

Section titled “6. 验证与冻结”

6.1 零成本

Section titled “6.1 零成本”
  1. 胶囊记账是构造的一部分：构造器在发出前计量每段并断言 ≤ B；单元测试覆盖淘汰与拒绝路径；每步 |κ| 写进轨迹。不需要事后从 providerUsage 反推。 旧回路的对照基线由 tools/context-accounting/account.mjs 从抓取生成（N0 已交付）： 2026-09-15 记账覆盖冻结的十八次运行，前缀从构建好的包算出并与提供方请求逐字节一致，每次任务的累计输入与产品计量表相同。
  2. 冻结任务脚本化：把 R0–R6、R3S、R3M 抓取里的计划与读回序列改写为决策脚本，假 provider 按脚本逐步回答；全部冻结阶段在新回路上零成本通过（同一 OCP 回读裁判）—— 这是新架构进入付费之前的门槛，也是回放机制本身的验收。N0 已交付（2026-09-15）：十八份脚本在 target-probe-results/decisions/， 格式 aira.probe-decision-script/0.1.0（schema），生成与校验工具 tools/context-accounting/decisions.mjs。 脚本里任务自己创建的实体 id 以 <plan#k> 代替其 32 位摘要（摘要是 sha256({taskId, toolCallId})，重放时由重放方按自己的任务与调用 id 重算），修订以 <rev#k> 代替； 起始文件已有的 id 保持字面。十八份脚本零告警：没有决策引用宿主从未执行的计划，提到的修订都是本任务产生的。 N2 已通过门槛（2026-09-15）：回放结果。发现一处历史偏差：R4-11 / R4-12 的 Web 构建所含 contracts dist 早于 80e55a30 的条目深度上限，两次冻结运行各有一条深 5 / 6 层的整张图纸条目被当时的宿主接受、被今日宿主拒绝；门槛用嵌套 views 置空（逐视图条目值相同）的调整脚本覆盖 R4，产品第八项修复的行为留给 N4 全环重跑验证。
  3. 现有 44/44 闭包、read_project_revisions.py 与 STEP 验证器逐字节不变；旧计划（全 id）在 0.22.0 契约下回放通过。
  4. 假栈上验证 tool 传输的两种回复形态（aira_step 调用、纯文本 → done）经同一校验器进入轨迹；json 传输的同轨迹核对留到 N5 与第二提供方一起做。

6.2 付费（协议 §14）

Section titled “6.2 付费（协议 §14）”

新回路是新架构，全环重跑：R0–R6、R3S、R3M 各两次连续干净通过才冻结；档位 T128 的 B = 96k 作为冻结条件的一部分。 按现单价一次全环约 $8–12；新回路的单价随累计输入下降，预期每阶段 $0.1–0.4。所有付费运行逐次授权。

6.3 协议扩展 9：步记账

Section titled “6.3 协议扩展 9：步记账”

结果行新增 context：沿用增长基准 results.schema.json 的 usage 命名（inputTokens、outputTokens、cacheHitTokens、cacheMissTokens、costUsd、planCharacters、 userMessageBytes、contextBytes、inventoryBytes），加 tier、capsuleMaxTokens（宿主计量）、steps、decisions（各动作计数）、rejections、modelsUsed。 冻结条件增加 capsuleMaxTokens ≤ B(tier)。

6.4 通用性的裁判：S9 模型矩阵

Section titled “6.4 通用性的裁判：S9 模型矩阵”

同一冻结指令与判据，变量换成模型（不同家族、128k 窗口、无推理、无工具调用），每（阶段，模型）记录结局、步数、拒绝数、费用、capsuleMaxTokens。 裁定规则预先写死：在模型 B 上失败且追溯到胶囊未含、且模型无法按地址取得的信息 → 产品缺陷，修完在 A 上回归；胶囊与地址都齐全模型仍做不到 → 该模型下限，记录不修。

已跑（2026-09-16，“授权”，结果 §22）：手头只有 DeepSeek 密钥，三个变体——deepseek-flash 走 json 传输（无工具调用）、deepseek-flash 关推理、deepseek-v4-pro（同族更强）——各跑 R0 / R5 / R2 / R4，16 次 ≈ $2.63。读数：json 传输四级全过且与 tool 通道同路径（缓存 65–72% 对 80–90%，R4 推理 3 倍）；无推理模型只在不需要推导的 R5 上干净通过、R0 靠八份计划试出来、R2 / R4 失败（胶囊有的东西没用上——模型下限）；v4-pro 每步慢 3–6 倍，R0 / R5 / R2 一次提交，R4 在 15 分钟预算内 13 步没出计划（模型下限 + 预算策略开放）。矩阵找出的宿主缺陷全在通道（五处：cbb23080 / 75083234 / c59648a6 / 2830706c / a5a3d340），没有一处是胶囊缺信息；之后又修三处（99d89486、2295f841）。裁定按规则执行：宿主通道限制（网关 5 分钟一步准入）算产品缺陷修了重跑；任务时长预算是策略，没替用户改。

6.5 N4 效率审计（2026-09-16）与三处修正

Section titled “6.5 N4 效率审计（2026-09-16）与三处修正”

R0–R2 在步进回路上冻结后，与对话回路的读数（结果文件 §3）对比：单步最大输入 28.6–42.7k token 对 64k–152k，累计输入 118k–270k 对 159k–1.46M， 但输出 token 高 2–3 倍、时长 1.5–3.6 倍（R2 425–612 s 对 169–185 s，两次撞上 15 分钟 TASK_TIMEOUT），缓存命中只有 10–13%（对话回路 ≈ 95%）——按真实缓存计价 R2 大约贵一倍。 用六次冻结运行（R0-8/9、R1-9/10、R2-8/9）的逐步抓取审计（audit_step_loop.mjs，39 步）：

动作 步数 平均每步耗时 平均每步推理 token 时间占比 推理占比
read 19 27 s 5,560 31% 32%
lookup 13 32 s 6,431 25% 25%
plan 9 71 s 14,603 39% 40%
done 6 12 s 1,922 4% 3%

根因一：每步重推导。 §2.3 的成本模型只算输入字节，把每步的重推导量 R 当常数；实测 R 是主开销（每步 5–15k 推理 token × 8–12 步）：模型每一步从零重想整个设计，然后才决定“先读一下”。 R2 首份计划前要走 5 步（2.5 分钟）；对话回路里这些读回是同一请求内的工具调用，带着前面的推理继续，几乎不花推理。有界做到了，连续性被一并扔掉，是设计错误。 根因二：前缀缓存在 ledger 段断掉。 0.2.7 段序 index · intent · summary · ledger · …，台账里的步号每步变。用抓取的胶囊逐步模拟（64 token 块）：

运行 实测命中 / 输入 0.2.7 段序模拟 稳定优先段序模拟
R0-8 12.5k / 118k 8.6k 58.9k（50%）
R1-10 19.1k / 193k 13.0k 88.6k（46%）
R2-8 22.1k / 222k 13.6k 85.1k（38%）
R2-9 32.3k / 270k 21.2k 94.2k（35%）

模拟与实测吻合（说明模型对）。三处修正（0.2.8，全在宿主，接口 aira.step/0.2.0；胶囊上限、决策 schema、/api/step 无状态不变）：

  1. 推理尾部作 scratch 段（deepseek-step.ts 回传 reasoning 尾部 24k 字符；ledger.setScratch 按档位截尾 T32 1k / T128 2k / T200 4k token，去掉末尾的决策草稿 {"act"…；胶囊第 9 段 {step, reasoning}）。这正是对话回路里模型“接着想”的东西，也是它自己该写却不写的 note。
  2. 只读动作 batch（decision.ts：read / lookup / inspect / pin 至多 8 项按序执行，结果合在 lastResult.results；批里的写动作整批拒绝；loop.ts 的 applyReadOnly 让单动作与批项走同一条路）。R2-9 的 6 读 3 查可并成 2–3 步。
  3. 稳定优先段序（capsule.ts：index · intent · schemaPages（$defs 在前）· workingSet · summary · note · ledger · lastResult · scratch）；计划提交后不再删掉用过的种类页（LRU 按档位数封顶），前缀多留一段。

零成本核对（假栈 step-n4b，R0 指令）：一步 batch（读 + 两次查 + 钉）四项结果同回；下一胶囊 scratch 8,000 B 带 … 前缀且草稿已去；段序如上、$defs 在前、提交后两页仍在；批里夹 plan 被拒并指名；连续胶囊的字节公共前缀：提交步在 summary 处断（保留 93%）、只读步在 ledger 处断（98%）、写便签步在 note 处断（96%）。 付费 A/B（2026-09-16，$0.91，结果 §7）：R2 同一起始、同一指令两次，对比 R2-8/9（425 / 612 s、222k / 270k 输入、94k / 129k 输出、$0.22 / $0.29）。 R2-10（8f9e0999）12 步截停 $0.40：缓存命中 55%，批第 1 步就用上，但推理尾部让模型复读决策——提交后的下一步用 174 个推理 token 把同一份计划再发一遍；update-product 被拒 ENTRY_TOO_DEEP 后连发五次同一形式，后两次只用 4.3k / 204 个推理 token。修 f5c44bb9：scratch 只在只读步之后保留，计划 / 暂存 / 被拒后清空。 R2-11（f5c44bb9）16 步 12m57s $0.50 first-try 64/64：缓存命中 54%（只读步之间前缀 71–81%），每个只读动作的推理 3.4k（原来每步 5.6–6.4k），但每步仍 10k、第 4–6 步各 20k+（模型在找怎样声明参数），输入 2.3 倍（8 种类型页 110 KB 保留、被拒页在 lastResult 重复 52 KB）、输出 1.3 倍、时长 1.3–1.8 倍。 三项目标只达到缓存一项。 读数：段序成立；批被用但不减少思考；带尾部的 scratch 会复读、清掉后也不省重推导——每步重推导的根因是模型看不到自己上一步的推理主体，8 KB 尾部不够；拒绝（R2 四次运行里 ENTRY_TOO_DEEP 9 次）每次 30–80 s。 A/B 之后的裁定见 §6.6：不再在“每步重建胶囊”上打补丁，回路改为有界日志（0.3.0）。R0–R2 的冻结记录保留为 0.2.7 的读数。

6.6 0.3.0：有界日志——费用下界与最优性（2026-09-16）

Section titled “6.6 0.3.0：有界日志——费用下界与最优性（2026-09-16）”

用户要求“信息论和数学上的最优解，不能再反复折腾”。把三种回路放进同一个费用模型里比较，量全部来自冻结运行的逐请求 providerUsage（对话回路 R2-3 / R2-4 与 R0–R6 各阶段的逐请求推理见 2026-09-15-context-accounting.json；步进回路见 §6.5 与结果 §7）。

记号。 一次任务 S 个决策；模型在决策前必须持有任务与状态，并持有自己推导出的设计 D；从头推出 D 花 R₀ 个推理 token（实测 R2：对话回路首请求 12k / 26k，步进回路写计划的步 15–24k）；有了 D 之后每个决策只需增量 ΔR_t（实测对话回路：读回 11–260 token、1–3 s，计划 0.5–12k）。提示词 C_t；单价 p_h（缓存命中）≈ p_m / 10（未命中）≪ p_o（输出；计量表 0.44 / 1.32 $/M，不分命中）；生成速率 g ≈ 215 token/s（R2-11 实测）。时长 ≈ Σ 输出 / g + S × 调用延迟。

回路 每步提示词 输出 实测 R2（两次冻结运行）
转录（对话回路） C_t 无界（整份状态倾倒 + 全部历史），92–100% 命中 R₀ + Σ ΔR_t 推理 29k / 35k，160 / 180 s，输入 1.46M / 0.68M（95% 命中），计量 $0.69 / $0.36（按命中价折算约 $0.10–0.15）
每步胶囊（0.2.7–0.2.9） ≤ B 由构造保证，命中 10–13%（0.2.8 后 54%） ≈ S/2 × R₀（D 每步丢弃、重推） 推理 94k–162k，425–777 s，$0.22–0.50
有界日志（0.3.0） 胶囊 C_k + 日志 L_t ≤ B 由构造保证；轮内只追加 → 命中 ≈ 转录 R₀ + Σ ΔR_t + 压缩次数 × (b + R₀′) 预测：推理 35–45k，3–4 分钟，命中 ≥ 85%，按命中价约 $0.1；R2 在 T128 下 0–1 次压缩

下界。 任何回路都必须：(a) 每条新信息（工具结果、模型输出）至少以 p_m 发一次；(b) 推出 D 一次（R₀ · p_o）；(c) 每个决策产出 ΔR_t · p_o；(d) 每步把工作上下文再呈现一次——最便宜的再呈现是逐字节相同的前缀（p_h），而这要求只追加。 转录回路付 (a)(b)(c)(d)，但 (d) 里的 C_t 无界（它把整份状态与历史都塞进前缀）；每步胶囊付 (a)(c)(d) 却把 (b) 付了 S/2 次——有界性的代价是输出乘以 S/2，而输出单价最高、又决定时长，所以“有界了反而更慢更贵”不是实现问题，是这个设计的必然； 有界日志恰好付 (a)(b)(c)(d)，外加压缩项：每当日志装不下，模型以速率 b 把自己的状态压成便签（它是唯一知道什么重要的一方——§2.2 的速率控制回路，这次真的触发），宿主从台账重建胶囊，下一轮从便签重推 R₀′ < R₀。压缩次数 = ⌈Σ 增长 / B⌉，任务装得下时为 0；有界性仍是构造保证（|κ| + |L| ≤ B 每步断言）。于是在给定 B 下，有界日志在常数项以内是最优的：它付的每一项都是下界里的项，多出的只有压缩，而压缩是 B 本身的代价。

0.2.8 的 scratch 为什么错：8 KB 尾部对 D 的互信息远小于 H(D)（模型照样每步重推 20k），尾部内容又恰是“正要做 X”（R2-10 复读决策）。正确的做法是把 r_t 整条留在日志里以 p_h 回传——这是最便宜的存储，而且 DeepSeek 思考模式在工具调用轮内本来就要求回传 reasoning_content（@ai-sdk/deepseek 只对最后一条 user 消息之后的助手消息回传它，对话回路便宜的机制正是这个）。

实施（0.3.0，接口 aira.step/0.3.0，提交见 §8）：/api/step 请求带 log[]（assistant：decision + reasoning + toolCallId；tool：result），适配器按 user(胶囊) → assistant(reasoning_content + aira_step 调用) → tool(结果) 渲染；响应带整条 reasoning 与 toolCallId；宿主 log.ts 持有本轮日志，loop.ts 一轮只建一次胶囊、每步结算轮（装不下 / 已告知 → 压缩；过告知线 → 结果附 host.windowFull）；轮内种类页与共享定义一轮只送一次（roundSchemaPages），计划提交的结果带新摘要 stateAfter 与刷新的钉住页；压缩时 lastResult 里已送过的页只留种类名。假栈核对（step-log）：消息角色与 reasoning_content 逐条正确；380 KB 推理 → 无告知直接压缩；300 KB → 结果附 windowFull、下一步便签、再压缩、新胶囊 note 即该便签；提交结果带 stateAfter / pagesRefreshed；R0 指令一次提交完成。 付费 A/B（2026-09-16，“授权”，$0.58，结果 §8）：R2-12 first-try 8 步 3m21s，推理 44,065；R2-13 repaired 10 步 3m26s，推理 38,146；两次 64/64 + 参数，提示词最大 332 KB ≈ 83k token ≤ B。 预测三项中两项命中（推理 35–45k ✓、3–4 分钟 ✓）；命中率 50% / 67% 对预测 ≥ 85%——单一实现漏洞：胶囊的 ledger.commits 是台账数组引用，轮内提交改写了固定前缀，紧接提交的步全部未命中；按命中计为 84% / 81%（余下是日志首条与压缩后的新胶囊）。修 1eb25802（快照）。 逐步账验证了模型：设计只推一次（109 s / 30k、99 s / 22k），之后只读批 2–17 s / 0.2–3.6k、计划 4–16 s / 0.15–3k，两次修复合计 12.6 s / 464 token（0.2.x 每次 30–80 s / 5–18k）；真实账单约 $0.08–0.09（对话回路 R2 约 $0.10–0.15，0.2.x $0.10–0.16）。 R2 在 0.3.0 上两次通过（c115cbef）。 R0、R1（2026-09-16，“授权”，$0.61，结果 §9）：commits 快照后 R1-11 / R1-12 命中 88% / 89%（设计步之后每步 94–99%，对话回路 95–96%），R0-10 / R0-11 77% / 86%（任务短，首条日志占比大）。推理 R0 7.7k / 17.7k（0.2.7：13.4k / 23.7k），R1 13.6k / 16.6k（35.7k / 44.8k）；时长 R0 52 s / 1m45s（1m25s / 2m06s），R1 1m29s / 1m42s（3m12s / 4m06s）；R0-10 first-try、R0-11 repaired（模型写错 require-bounds 9.9 s 改对；独立 require-hole-array 被运行时 assert.holeArray 匹配到外端圆弧面——密封运行时检查器事项）、R1-11 / R1-12 first-try。0.3.0 上 R0–R2 齐。 R3（2026-09-16，“授权”，$0.54，结果 §10）：R3-7 repaired 6 步 2m29s 推理 27.9k（对话回路 R3-5/6：60.5k / 46.3k，$0.89 / $0.59）；R3-8 repaired 10 步 6m54s 推理 78.9k、三轮——两次压缩各带一次重推（第一次恰落在拒绝之后，124.9 s / 26.8k），是 §6.6 压缩项的实测：R3 的日志每个重步长约 100 KB，T128 一轮装 3–4 个重步。两次都撞上运行时 assert.holeArray 的候选面缺陷（base 原有的 Ø6 孔阵断言在加了四个 Ø3.2 装配孔后失败，检查器挑了装配孔比对），模型以 remove-assertions 绕过——已修 a13a415b（检查器在 packages/aira-geometry-kernel/src/aira/exact-hole-array.ts，不在 wasm 里：凹面按 gp_Cylinder.Direct() 与面取向一致判定，只评判声明孔心一个直径内的壁；假栈上两份被拒计划原样通过、两份真违规仍被拒）。R4 起逐次授权（R4 起始 = R3-8 副本 ea74b45e…；构建含此修复）。更正（R3-9，0.3.6）：a13a415b 的“只评判声明孔心处的壁”与密封 AMIR HoleArrayRequirement（“complete circular world-Z bores of one target solid … reject missing, extra, split or breached”）相悖——要求对目标的竖直孔是排他的，R3 两次失败是检查器按契约判的（消息误导），模型撤断言是正确动作；已撤回，拒绝点名多出的孔；凸凹判定保留。 R4（2026-09-16，“授权”，$1.64，结果 §11）：R4-13（50e59859）19 步全在猜怎么读一个体的面——索引承诺选择器结果却没写怎么要、schema 没列——2m14s 截停；修 ff3e4d02（索引逐个写出 faces / edges / occurrences / distance / projection / drawingId / bom / resources / includeReferences 的写法与回答，schema 为 read 与批项声明它们）。R4-14 repaired 22 步 7m21s 推理 76.6k（三轮，两次压缩各重推一次），R4-15 first-try 14 步 4m29s 推理 48.1k；两次 156/156 + 参数；真实账单 ≈ $0.12 / $0.08（对话回路 $0.91–1.02）。R4 是唯一一级推理未低于对话回路的（44k / 59k）：日志最长、T128 一轮只装 2 个重步，压缩项最重。0.3.0 上 R0–R4 齐。R5 起逐次授权（R5 起始按协议 §9 = 空模型 + 暂存的 F0 / F2，即 R4-12 的 P0 / P2 导出）。 R3-9（2026-09-16，“补一次 R3吧”，$0.40，结果 §12）：repaired 11 步 7m53s 推理 81.7k、三轮。模型读契约就撤了 base 的孔阵断言（正确，见上）。两次拒绝都是 EXACT_CANDIDATE_EXPECTATION_VIOLATED：一次模型的 servo 放错原点；一次是宿主缺陷——hole-array 步的 expect 量了主根 link 而不是目标体 base（beginConservation 只在 baseProgram 时传测量节点），修后一律按目标体的 authority 量。这次拒绝落在 windowFull 步，新轮重推 173 s / 35k——175 KB 胶囊里 130 KB 是没用过的种类页，由此定下压缩时只留在用的种类页（§4.2）。EXACT_PRODUCT_ENGINEERING_SOURCE_INVALID 的拒绝改为点名失败条件并附两种合法写法（R4-14 的两次 “invalid persistent producer”）。四项都零成本核对（假栈：R3-7 计划被拒点名多出的孔、去断言后提交；R0-11 计划提交；两负例仍拒；hole-array expect 量在 base 上；step-log 压缩后 schemaPages 为空；猜的 operationRef 得到点名）。 R5（2026-09-16，“授权”，$0.21，结果 §13）：R5-3（34c68481）first-try 5 步 29.8 s $0.059，一轮装下整个任务；暴露一处宿主误标——两次 inspect 的批被记成 error（资源动作报 completed，批只认 ok），修 9c415f4b；R5-4 / R5-5（9c415f4b）first-try × 2，35.7 s / 33.2 s，$0.075 / $0.072，推理 4.5k / 4.8k，138/138 + 参数。对话回路 R5-1 / R5-2：66–100 s、$0.29–0.34。0.3.0 上 R0–R5 齐。R6 起逐次授权（R6 起始 = R4 的保存副本，参数化）。 R6（2026-09-16，“继续推进N4”，$1.01，结果 §14）：R6-3（9c415f4b，起始 R4-15 副本）15 分钟到期，23 步 $0.82——连杆的每次编辑都被 ARTIFACT_GRAPH_NAMED_SHAPE_UNRESOLVED 拒：R4-15 用 includeReferences 读回的 lineage 引用（一次求值的 program-face 起源）声明连杆的面，按密封契约这种引用不随源码 / 参数变化，两种 policy 都无延续；模型找到了正确出路（命名 → 改绑 → 改参数）但 replace-program 本身也被同一批引用拒。归类步进接口文本缺口（索引把 lineage 形式当持久引用，没说绑在一次求值上），修 8097bb8a（索引 / 拒绝文本 / 出路提示，假栈核对）。R4-14 副本按名字声明、不冻：R6-4 / R6-5（8097bb8a）first-try × 2，一份 set-parameters 带三条要求改写，62 s / 78 s、$0.09 / $0.11（对话回路 132–197 s、$0.49–0.57），109/109。R6 项目判据按链结构一般化（绑定集合从起始文件推出、size 要求随动；对话回路记录仍过）。压缩规则的付费读数：新轮胶囊 53–147 KB，重推 49 s / 10k。0.3.0 上 R0–R6 齐。 R3S、R3M（2026-09-16，“继续推进N4”，$0.89，结果 §15–§16）：R3S-3 / R3S-4 repaired × 2（3m52s / 4m21s，$0.39 / $0.39；对话回路 $0.87 / $0.64、7.6 / 6.3 分钟）——base 的孔阵断言按契约点名多出的孔、模型撤回即过；R3S-4 手写螺钉被标准件身份检查拦下后改用库调用，正是 R3S 设计的路径。R3M-3 / R3M-4 first-try × 2（38 / 39 s，$0.07 / $0.04；对话回路 $0.20 / $0.23、79 / 117 s）。scratch 判定脚本为 0.3.0 链一般化（步进捕获里读 set-material、^ 幂、装配数），对话回路记录仍过。N4 完成：0.3.0 上全环 R0–R6 + R3S + R3M 各两次通过，22 次运行 $5.87（对话回路冻结 29 次 $19.89）；每级 promptMaxBytes / 4 ≤ B = 96k 成立。剩 N5。

7. 风险与待裁定项

Section titled “7. 风险与待裁定项”
# 事项 建议 需要谁定
1 采用有界步进架构，替换 AbstractChat 回路与 /api/agent 采用；旧回路只保留到新回路冻结（S9 之后已删除，2026-09-16） 已裁定（用户，2026-09-15）
2 决策传输是否在本次重构统一 不统一、也不必要：契约定在决策 JSON，传输是适配器参数；首期只做 tool（DeepSeek 现用通道，schema 与每步 enum 作一等字段送达），json 随第二提供方在 N5 加入 已裁定（用户提问后按此记录，2026-09-15）
3 档位默认值 B / b / 页上限 T128：96k / 2k / 4k 为默认 已裁定（用户，2026-09-15）
4 合法句柄物化为每步 enum 默认开启（每步生成 schema，无缓存代价）；S9 对比关闭时的拒绝数。注记（0.3.13）：枚举只在摘要列表未截断时物化，截断（> 64 体或参数）退回自由字符串、由宿主校验点名错句柄；同一计划里前步新建的句柄不在枚举里——严格模式提供方会在生成期拒绝，须拆计划 已裁定（用户，2026-09-15）
5 便签由模型全权负责，宿主不摘要 是；便签超 b 由宿主截断并在胶囊里告知 本方案
6 一步一动作 一步一个写动作；只读动作可合成 batch（0.2.8，§6.5：每步重推导是主开销） 本方案，2026-09-16 改
11 每步重建胶囊还是一轮一胶囊 + 日志 有界日志（0.3.0，§6.6）：在给定 B 下费用达下界，压缩是有界性的全部代价；每步重建胶囊把设计推导付 S/2 次 本方案，2026-09-16
12 压缩后的胶囊带哪些种类页 只带待修复拒绝所涉的与上一结果点名的（0.3.6）：种类页是参考资料，不是状态；一次查库就能再要，而 110–130 KB 的固定占用决定一轮装几个重步。运行时契约的语义以密封 schema 的描述为准，检查器不得放宽（a13a415b 的一半因此撤回） 本方案，2026-09-16
13 计划里各步的记账依据 按请求 id（0.3.11）：编译器给每步的请求盖 plan.<call>.<步>，提交与失败的响应带回它，stepsCommitted / failedStep 从响应里读出——守恒报告只登记几何步，不能当提交计数；别名对每一步运行时的头修订解析，后步可引用前步新建的 本方案，2026-09-16
14 台账段的上界 按档位折叠（0.3.13）：提交行与拒绝行只留最近 N 行（T32 6 / T128 12 / T200 16），更早的折成一行计数；至此胶囊每一段都有与产品大小、任务长度无关的上界（结果 §20） 本方案，2026-09-16
15 任务的时长预算是否按模型调 不调，也不再有任务总时钟（0.3.17，2026-09-16，“有几十种模型每个都要调吗”）：随模型变的只有每步延迟与单价；产品的界是与模型无关的量——步数（48）、token（3.384M）、费用（$5）——时间只剩一个对所有模型相同的每步存活界（maxStepDurationMs = 网关的 DEFAULT_STEP_REQUEST_DURATION_MS 15 分钟 + 1 分钟余量，每步开始时重新起算；网关自己的 504 先到）。会话授权的到期 = 步数上限 × 每步界。S9 里 v4-pro 在 R4 上的 budget 结局在这条规则下不再发生——慢模型只是慢，不是失败。轨迹版本 0.10.0（maxDurationMs → maxStepDurationMs，TASK_TIMEOUT → STEP_TIMEOUT，HUD 的耗时表不再有上限） 用户，2026-09-16（“同意”）
16 单管线紧凑接口与复合计划（Composite Plan）vs 双轨分流 坚决单管线，全量紧凑化（0.4.0，2026-09-17，“维护两套管线成本高，且无法预判几何复杂度”）：不搞简单/复杂几何的双轨路由，不搞几何复杂度模糊判定。在胶囊内用 1.5 KB TypeScript 签名（COMPACT_STEP_SIGNATURES）全面取代 144 KB 的 JSON Schema 脚手架；首轮引导模型直接规划并输出包含实体构建、参数绑定、装配放置、公差与图纸声明的完整 Composite Plan，由宿主原子提交；若某步报错，宿主精准点名 failedStep 并仅返回受影响步骤的专有 schema 进行靶向微调修补 用户，2026-09-17（“同意下一步，开干”）
7 步数可能增加、强模型总费用未必下降 目标是界与可预测性；两者都记，S9 看分布 记录
8 模型不善管理工作集（反复读同一页） 差分把未变页降为一行；淘汰记录让模型看到自己的浪费；作为速率指标记录 记录
9 按步路由、子步并行 首期不做，轨迹先记模型字段 后续
10 意图帧由宿主整理是否引入解释偏差 首期只放指令原文与范围，硬要求由模型在便签里自述 本方案

8. 实施顺序与完成条件

Section titled “8. 实施顺序与完成条件”
阶段 内容 零成本完成条件 付费完成条件 状态
N0 记账脚本；冻结任务改写为决策脚本；定 B / b / 页上限 基线表与 §1 一致；脚本覆盖九个阶段 无 已交付 2026-09-15：tools/context-accounting/，记账基线（§1 数字已按它重算），十八份决策脚本零告警通过 schema；B / b / 页上限按裁定 3 取 T128 96k / 2k / 4k
N1 状态寻址：块哈希、别名表、摘要、select 页、差分；契约 0.22.0 15 实例摘要 ≤ 2k token；旧计划回放通过 无 已交付 2026-09-15：packages/aira-contracts/src/exact-model-aliases.ts（别名表、解析、外发替换）、packages/aira-cad-tools/src/model-address.ts（块哈希、摘要、select 页、紧凑标量）、aira_model_read 新增 summary / select / offset / limit、编译器解析别名、契约 0.22.0。零成本核对（假 provider + 真网关 + 真工作台，R3 冻结起始）：15 实例摘要 2,364 B ≈ 575 token；asm.arm2 页 697 B、程序源码页 823 B；六步 set-material 全部以 b:<label> 写成，宿主一次提交，独立 OCP 回读六种零件的 aira:materialId 与 R3M 判据一致、装配无属性；同一构建上全 id 的 R3M 假脚本（含预期的 EXACT_BODY_MATERIAL_UNKNOWN 拒绝）照常通过。差分（按块哈希只送变化页）的宿主侧比较已具备（每页带块哈希），在 N2 的工作集里生效
N2 台账、胶囊构造器、决策语法与校验、步执行器（浏览器） 九个阶段决策脚本在假栈上全部通过；|κ| ≤ B 断言覆盖 无 已交付 2026-09-15：apps/web/src/ai/step/（ledger.ts 台账与档位、capsule.ts 八段胶囊与淘汰、decision.ts 语法与校验、executor.ts 步执行、loop.ts 步循环、scripted-source.ts 脚本回放源），协调器以决策来源切换回路（WorkbenchAgentTaskCoordinator.run({source})），控制器 replayDecisionScript。零成本回放：十八份脚本在新回路上宿主回答逐决策一致（十二个 needs-repair 码相同），导出经独立 OCP 回读与各阶段裁判全过；单步胶囊最大 132 KB（≈ 32k token），无一次触发淘汰。R4 两份脚本经调整（见勘误）后通过
N3 网关 /api/step + DeepSeek 适配（tool 传输；纯文本回复 → done） 假栈上 aira_step 调用与纯文本两种回复同轨迹 无 已交付 2026-09-15：apps/server/src/model/deepseek-step.ts（一步一次 generateText，唯一工具 aira_step 的 inputSchema 即当步决策 schema；无工具调用的文本回复 → done{summary}）、http-handler.ts 的 /api/step（无状态；同一准入与逐调用记账；胶囊 ≤ 640 KB、schema ≤ 64 KB）、生产 worker 同步；浏览器 gateway-source.ts + decision.ts 的 stepDecisionSchema（体 / 节点 / 参数别名物化为 enum，裁定 4）；工作台 ?loop=step 选步进回路（默认仍是对话回路，直到 N4 冻结）。假 provider 零成本核对（R3 冻结起始、R3M 指令）：五步 lookup → read+pin → plan（六步 set-material 以别名写）→ read bom → 纯文本收尾，网关逐步记账（route: /api/step，steps: 1，token 来自提供方 usage），每步胶囊 8.7–13.5 KB ≈ 2–3.3k token，决策 schema 2.6 KB 含 6 个体别名与 16 个参数别名；导出经 OCP 回读 R3 判据 30/30、六种材质属性齐全。第二场景：故意残缺的计划在浏览器被拒（STEP_DECISION_PLAN_INVALID），下一胶囊带 set-material 的 L2 页（21 KB），修正后提交，再以文本收尾
N4 全环付费重跑 — R0–R6、R3S、R3M 各两次干净通过；T128 达标 已交付 2026-09-16（0.3.0 有界日志上全环各两次通过：R0 bc8db662、R1 bc8db662、R2 bc8db662、R3 bc8db662、R4 ff3e4d02、R5 9c415f4b、R6 8097bb8a、R3S 8097bb8a、R3M 8097bb8a；22 次 $5.87；每级 promptMaxBytes / 4 ≤ 96k）。过程：协议扩展 9（步记账 context 块、capsuleMaxTokens ≤ B 冻结条件，5ba18fa5）。R0 结果：R0-6（b85244c6）37 步全是查库、无计划——查库得到的步类型 schema 只在 lastResult 里活一步，build-program 取了八次；修 9ea9bb71（类型查库进 schemaPages，页数按档位 T32 1 / T128 4 / T200 6）。R0-7（9ea9bb71）25 步全是查库、$0.30 封顶——注记里已写好整份计划却反复核对同一批签名，库回答随步消失；修 fc171178（库回答以 lookup/<query> 页留在工作集，T128 6 页 LRU，lastResult 只指向页）。R0-8 / R0-9（fc171178）连续两次 first-try（4/4 + 参数），6 步、$0.073 / $0.099、最大胶囊 27.9k / 36.3k 宿主 token（提供方 28.6k / 36.5k，4 B / token 成立）≤ 96k——R0 冻结。读数：单步最大输入 28.6k / 36.5k 对旧回路 64k；胶囊里 88% 是四页步类型 schema（共享定义逐页重复，25–37 KB / 页），列为下一产品项；note 只在写计划时用，pin 未用。R1（同一结果文件 §5）：R1-6（fc171178）aira_step 参数解析失败被适配器当成 502、任务死——修 5ff7d5ff（畸形参数作为决策交宿主拒绝，带括号账，STEP_DECISION_NOT_JSON）；R1-7（5ff7d5ff）repaired 30/30 但八层 set-product 收尾 }}}}}}}}, "note" 的 ] 连丢四次；R1-8 同一失败 + 驱动脚本 5 分钟规则截停——修 f065dcd0（适配器按解析器指名的位置放回那一个括号，只接受重新解析通过的结果，响应带 repair，行计 channelRepairs）；R1-9 / R1-10（f065dcd0）连续 first-try 30/30 + 参数，7 / 8 步、$0.12 / $0.15、最大胶囊 39.5k / 40.1k token，各修复一次、零拒绝——R1 冻结。八份 set-product 决策七份收尾写错：模型在该深度不可靠，通过靠修复。R2（§6）：R2-5（f065dcd0）15 分钟预算到期——放置坐标绑定程序数值的写法契约承诺而 schema 不接（修 21550a19：接受 {type, nodeId, value}；步里的 note 提到决策上）；R2-6（21550a19）四页 schema 上限被六种类型挤出五次、同步参数被别名再绑、update-product 带 expect 只得 anyOf 原文、计划写进文本通道当 done（修 c52c0dc9：共享 $defs 只送一份、页数 T128 8、按类型报错、同步绑定丢弃、文本决策照读）；R2-7（c52c0dc9）模型丢了 joint1 绑定（模型行为）；R2-8 / R2-9 连续 first-try 64/64 + 参数，8 / 12 步、$0.22 / $0.29、最大胶囊 39.6k / 32.2k token，零拒绝零修复——R2 冻结。设计变了：base 程序算关节位置、平放组件绑定程序值。效率审计（2026-09-16，§6.5）：步进回路有界但更慢更贵——每步重推导（读回 / 查库步占 56% 时间）、前缀缓存在 ledger 段断掉（命中 10–13%）；三处修正（推理尾部 scratch、只读 batch、稳定优先段序 + 提交后保留种类页，接口 aira.step/0.2.0）已零成本核对。R2 A/B（R2-10 8f9e0999 截停 $0.40：scratch 尾部复读决策，修 f5c44bb9；R2-11 f5c44bb9 first-try $0.50 12m57s）：缓存 54–55% 达标，时长与输出未达标（§6.5）。0.3.0 有界日志（§6.6）：一轮一胶囊 + 只追加日志、推理回传、满了模型写便签后压缩；R2-12 / R2-13（c115cbef）first-try + repaired，3m21s / 3m26s，推理 44k / 38k（预测 35–45k），真实账单约 $0.08–0.09——R2 在 0.3.0 上两次通过；命中 50% / 67%（commits 引用漏进胶囊，修后 ≈ 84% / 81%）。R0、R1 在 0.3.0 上各两次通过（bc8db662：R0 first-try + repaired 52 s / 1m45s，R1 first-try × 2 1m29s / 1m42s，命中 77–89%，推理与时长对 0.2.7 减半）；0.3.0 上 R0–R2 齐；R3 两次通过（bc8db662：repaired × 2，2m29s / 6m54s，推理 27.9k / 78.9k；两次压缩各带一次重推；assert.holeArray 运行时缺陷两次都撞上，已修 a13a415b）；R4 两次通过（ff3e4d02：repaired + first-try，4m29s / 7m21s，推理 48k / 77k；R4-13 的接口缺口——读选择器没写进索引——修 ff3e4d02）；补跑 R3-9（531a5965：repaired 7m53s 推理 81.7k；a13a415b 放宽检查器的一半与密封契约相悖、撤回；hole-array 步的 expect 曾量主根、修；压缩只留在用的种类页；工程引用拒绝点名条件——四项零成本核对）；R5 两次通过（9c415f4b：first-try × 2，30–36 s、$0.06–0.07；R5-3 的批状态误标修掉）；R6 两次通过（8097bb8a：first-try × 2 起始 R4-14 副本，62–78 s、$0.09–0.11；R6-3 在 R4-15 副本上被 lineage 引用冻住——接口文本缺口，修 8097bb8a）；R3S repaired × 2（8097bb8a，3.9 / 4.4 分钟、$0.39 × 2）；R3M first-try × 2（8097bb8a，38 / 39 s、$0.07 / $0.04）。遗留处置后的重新冻结（2026-09-16，结果 §19）：R4 在 5dcadd97 上 repaired × 2（5m33s / 6m50s、$0.44 × 2，158 判据含“声明随零件走”，两份副本 14 处声明全按名字），R5 用 R4-16 的 P0 / P2 导出 first-try × 2（34 / 35 s、$0.08 / $0.09，18/18 组件）；26 次 $6.92。四处宿主缺陷（运行时失败不带失败步种类、无守恒报告的计划记零步、同计划别名不能引用前步新建的、faces() 诊断指错方向）修于下一提交，零成本核对
N5 第二提供方适配 + json 传输；S9 矩阵；删除旧回路 假栈多提供方、两种传输同轨迹 矩阵运行（另批授权） 零成本部分已交付 2026-09-16（step-reply.ts 路由 + openai-compatible-step.ts 裸 fetch 适配器，tool / json 两种传输；AIRA_STEP_PROVIDERS_JSON（server / Worker 同一解析，Worker 逐模型要费用策略）；网页 ?provider=&providerModel=；假栈 fake-tool / fake-json 与 compare_trajectories.mjs：step-plan-steps 在 deepseek / fake-tool / fake-json 三条轨迹六步决策与结果相同、头文档在修订信封之外相同；结果 §21）。S9 矩阵已跑 2026-09-16（结果 §22，16 次 ≈ $2.63：json 四级全过、无推理过 R0 / R5、v4-pro 过 R0 / R5 / R2、R4 超预算；五处通道缺陷 + 三处后续修复）。旧回路已删除 2026-09-16（“同意删旧回路”）：服务端 /api/agent 路由、deepseek-agent.ts（ToolLoopAgent）、问题事件行；网页 agent-client.ts（AbstractChat 回路）、?loop=step 开关（步进回路即默认）；cad-tools 的对话类型；假栈的对话场景与流式分支；探测跑手的 /api/agent 抓取；生产 Worker 改路由 /api/step，GATEWAY_LEASE_TTL_MS 与策略上限提到一步的 15 分钟（DEFAULT_STEP_REQUEST_DURATION_MS，所有模型同一常数）；云端冒烟脚本改打 /api/step。假栈 step-plan-steps 在不带 ?loop= 的页面上照常六步（标签 AI SDK · step），POST /api/agent → 404。N5 完成
N6 单管线轻量化重构与单轮复合计划（Composite Plan）落地 1.5 KB TS 签名取代 144 KB AST，全工作区 check 全绿 R1（30/30）、R2（64/64）、R4 全环裁判 100% 通过；Token 降 99.8%，延迟减半，费用降 90%+ 已交付 2026-09-17（提交 4a439bd1）：apps/web/src/ai/step/decision.ts（COMPACT_STEP_SIGNATURES 1.5 KB）、apps/web/src/ai/step/capsule.ts（Composite Plan 复合计划协议）；单管线全量收敛，消除两套管线维护与几何复杂度二元判断难题；首轮直出复合计划，失败局部点名修补；R1（30/30，Token 816，33.1s，$0.011）、R2（64/64，干涉 0，Token 841，85.9s，$0.0284）；全工作区 typecheck（12 项 0 错）/ eslint（0 警告）/ build 成功
N7 按步路由、子步并行 — 另立方案

每阶段一次提交，状态只写在工作进度。§1 的基线数字不改，作为新旧架构的对照留存。