thincoder 0.12.61 → 0.12.62

package/src/session.mjs

@@ -25,6 +25,14 @@ import {
 import { guardForeignSlotFile } from "./session-guard.mjs"
 import { scheduleSessionGC } from "./session-gc.mjs"
 import { engTokenSlotFields, restoreEngTokens } from "./token-ttl.mjs"
+// TUI-OOM-ROOTCAUSE 批（SESSION.md §14）：人读线记录存储（磁盘为准 + 内存窗口）。
+// slimForDisplay/isLegacyTransient 迁入 store 模块（§14.5 文件表）——本文件 re-export 保持
+// 既有 import 面（session-slots.mjs 引 isLegacyTransient）。依赖方向单向：store 零项目内依赖。
+import {
+  bindRecordStore, unbindRecordStore, saveProjectedSlot, isLegacyTransient, slimForDisplay,
+  RECORD_WINDOW_MESSAGES,
+} from "./session-store.mjs"
+export { isLegacyTransient, slimForDisplay, bindRecordStore, unbindRecordStore }
 
 // re-export slot 管理（保持既有 import session.mjs 的调用点不变；resumeSlot 下方本地包装导出）
 export {
@@ -43,60 +51,44 @@ export function resumeSlot(cwd) {
   return slotsResumeSlot(cwd)
 }
 
-// ========== legacy transient prefix cleanup ==========
-
-const LEGACY_TRANSIENT_PREFIXES = [
-  "[System reminder: working directory snapshot:",
-  "[Relevant memories from previous sessions",
-]
+// ========== core read/write ==========
+// （legacy transient 判定 + slimForDisplay 自本区迁至 session-store.mjs——§14.5 文件表；
+//  上方 re-export 保持既有 import 面。）
 
-function isLegacyTransient(m) {
-  return (
-    m.role === "user" &&
-    typeof m.content === "string" &&
-    LEGACY_TRANSIENT_PREFIXES.some((p) => m.content.startsWith(p))
-  )
+/** 未绑定路径的人读线全量物化（模式 F——既有语义逐字保留）。 */
+function legacyHistory(agent) {
+  return (agent._fullHistory ?? agent.history)
+    .filter((m) => !m.transient && !isLegacyTransient(m))
+    .map(slimForDisplay)
 }
 
-export { isLegacyTransient }
-
-// ========== core read/write ==========
-
-/** Slim the HUMAN line (history) for storage — the machine line (contextHistory)
- *  keeps everything byte-identical for the provider. Deepseek-consult design
- *  (2026-08-30): the human line is never compacted and carries the bulk of
- *  session-file size (tool args JSON / full tool results / base64 images), while
- *  nothing consumes its verbatim fidelity. Rules (copy-on-write ONLY — the two
- *  lines share object references via pushReal; mutating in place would corrupt
- *  the machine line and provider prefix cache):
- *   - assistant.tool_calls[].function.arguments → trimmed to 300 chars (head + …)
- *   - tool messages content → 500 chars (head + …)
- *   - multimodal user content array → keep text parts, DROP image_url base64 parts
- *   - plain string messages → untouched (not the size driver)
- */
-function slimForDisplay(m) {
-  if (m && Array.isArray(m.content)) {
-    // Multimodal user message: keep text parts, drop image parts.
-    const textParts = m.content.filter((p) => p?.type !== "image_url")
-    if (textParts.length === m.content.length) return m
-    return { ...m, content: textParts }
+/** 恢复描述符（§14.3.6——两调用点统一形态）：`{ history, total, base }`。
+ *  绑定态：history = 尾窗 + ±1 页沿头一条（跨页回合标签判定用——不渲染）、total = 绝对
+ *  总条数（「N messages」标签口径）、base = history[0] 的绝对序号；未绑定（模式 F）：
+ *  回退全量数组（total = 数组长）。 */
+export function sessionDescriptor(agent, data) {
+  const store = agent?._recordStore
+  if (store) {
+    const total = store.total()
+    const win = store.page(Math.max(0, total - RECORD_WINDOW_MESSAGES), total, { margin: 1 })
+    return { history: win.messages, total, base: win.base }
   }
-  if (m && m.role === "assistant" && Array.isArray(m.tool_calls)) {
-    let changed = false
-    const tool_calls = m.tool_calls.map((tc) => {
-      const args = tc.function?.arguments
-      if (typeof args === "string" && args.length > 300) {
-        changed = true
-        return { ...tc, function: { ...tc.function, arguments: args.slice(0, 300) + "…" } }
-      }
-      return tc
-    })
-    return changed ? { ...m, tool_calls } : m
-  }
-  if (m && m.role === "tool" && typeof m.content === "string" && m.content.length > 500) {
-    return { ...m, content: m.content.slice(0, 500) + "\n… (truncated for storage)" }
+  const full = Array.isArray(data?.history) ? data.history : []
+  return { history: full, total: full.length, base: 0 }
+}
+
+/** 槽摘要（记录存储绑定路径——history 不物化）：与 slotDigest(extractSlotMeta) 同形。 */
+function digestFromStore(fields, counters) {
+  const meta = {
+    messageCount: counters.total,
+    turnCount: counters.userReal,
+    firstMessage: counters.firstMessage,
+    activeProvider: fields.activeProvider ?? "",
+    updatedAt: fields.updatedAt ?? Date.now(),
+    title: fields.title ?? "",
   }
-  return m
+  if (fields.activeModel) meta.activeModel = fields.activeModel
+  return { ts: Date.now(), ...meta }
 }
 
 /** Save agent state to the active slot file (atomic write). `display` (the old
@@ -111,16 +103,17 @@ export function saveSession(agent) {
   // history        = FULL, never-compacted (human-readable; VS Code panel & CLI resume read this)
   // contextHistory = machine context (possibly compacted) so CLI resume keeps the token savings
   // Human line: transient machine injections never enter the readable record.
-  const history = (agent._fullHistory ?? agent.history)
-    .filter((m) => !m.transient && !isLegacyTransient(m))
-    .map(slimForDisplay)
+  // TUI-OOM-ROOTCAUSE 批（SESSION.md §14.3.5）：绑定记录存储后 `history` 字段由
+  // saveProjectedSlot 流式拼接段原文生成（磁盘为准——不物化全量数组）；未绑定
+  // （模式 F：thincoder chat/测试/未覆盖路径）→ 既有全量物化路径逐字保留（D-R6）。
   // Machine line (contextHistory): KEEP transient messages — resume must rebuild the
   // machine line byte-identical to what the provider cache saw. Dropping them made every
   // process restart diverge at the first injection position (git/OS/time reminders are
   // re-injected with FRESH content) → whole-prefix cache miss on the CLI's very first
   // request of each session (2026-08-16 cache-hit report; Kimi review).
   const contextHistory = agent.history.filter((m) => !isLegacyTransient(m))
-  const data = {
+  // fields = 槽 JSON 数据面（history 由投影插入——键序与既有 data 形态同序，history/contextHistory 居后）
+  const fields = {
     version: 2,
     cwd: agent.cwd,
     title: agent.title ?? "",
@@ -129,8 +122,6 @@ export function saveSession(agent) {
     activeProvider: agent.activeProvider ?? agent.provider?.name ?? "",
     activeModel: agent.activeModel ?? agent.provider?.model ?? null,
     updatedAt: Date.now(),
-    history,
-    contextHistory,
     tasks: agent.tasks ?? [],
     planMode: agent.planMode ?? false,
     autoApprove: agent.autoApprove ?? false,
@@ -141,13 +132,18 @@ export function saveSession(agent) {
     pendingReminders: agent._pendingReminders ?? [],
     sessionStart: agent._sessionStart ?? null,
   }
-  // 2026-09-05 §10 D-4：首认领（_slot 为 null——如 /session 切换后首保存、"查看对方活槽 →
-  // 保存 fork 新槽"的落盘槽跟随）写本端记录——marker = 端内最后认领者；粘性 _slot 期间
+  // 2026-09-05 §10 D-4：首认领（_slot 为 null——如 /session 切换后首保存、“查看对方活槽 →
+  // 保存 fork 新槽”的落盘槽跟随）写本端记录——marker = 端内最后认领者；粘性 _slot 期间
   // 的日常保存不写（F1：保存永不参与竞争）
   const claimedNow = agent._slot == null
   const slot = agent._slot ??= activeSlot(agent.cwd)
   if (claimedNow) writeEndMarker(agent.cwd, slot)
   const p = slotPath(agent.cwd, slot)
+  // 首保存补绑（§14.3.4 表末行——兜底所有未覆盖路径）：未绑定且有槽 → 绑定记录存储
+  // （baseHistory = 当前 _fullHistory 全量；identity = 当前 _sessionStart）
+  if (!agent._recordStore) {
+    bindRecordStore(agent, { slotFile: p, identity: agent._sessionStart ?? null, baseHistory: agent._fullHistory ?? [] })
+  }
   // 2026-08-31 会诊 F2 🔴：写前校验磁盘文件的 sessionStart——与本进程会话不符（另一
   // 进程/会话的现场）→ 先轮转 .bak 保留再写（11311 条历史被新进程覆盖的实锤场景）。
   // 守卫自 2026-09-08 提取为 guardForeignSlotFile（session-guard.mjs——DESIGN-TOKEN-
@@ -155,13 +151,17 @@ export function saveSession(agent) {
   // saveSession 与 token-ttl persistEngTokens（settle 当场落盘）共用同一份（检查按
   // mtime 缓存 _slotMtime：自写未变跳过全量解析）。
   const rotated = guardForeignSlotFile(agent, p, slot)
-  writeSessionFile(p, data)
+  // 绑定态 → 流式投影（段原文拼接——VSC 兼容面逐字同形）；未绑定 → 既有全量物化写
+  if (agent._recordStore) saveProjectedSlot(agent, p, fields, contextHistory)
+  else writeSessionFile(p, { ...fields, history: legacyHistory(agent), contextHistory })
   // 记录我们刚写的 mtime——下次保存跳过重复解析
   try { agent._slotMtime = statSync(p).mtimeMs } catch {}
   // Update slot metadata in manifest
   try {
     const m = loadManifest(agent.cwd)
-    m.slots[slot] = slotDigest(data)
+    m.slots[slot] = agent._recordStore
+      ? digestFromStore(fields, agent._recordStore.counters())
+      : slotDigest({ ...fields, history: legacyHistory(agent) })
     saveManifest(agent.cwd, m)
   } catch (e) {
     // Manifest update failure is non-fatal — data is safe, metadata will lazy-recover on next listSlots
@@ -268,7 +268,7 @@ function stripTruncatedToolArgs(m) {
  *     复验 validateProvider 弹重选）。
  *  删旧支："activeModel==null 清 stale override 回渠道默认"——前提 = 渠道默认字段——已随
  *  三旧层删除消失——双字段恒非空故不可能触发（评审 #7）。 */
-export function applySession(agent, data) {
+export function applySession(agent, data, opts = {}) {
   // 机读线语义（历史注释保留）：data.history = FULL 未压缩记录（人读线）；data.contextHistory =
   // 压缩后机器线——恢复各从其源（保留压缩收益——从完整 history 重建会塞回中间过程——实测
   // prompt 膨胀 283%）。v1 老文件（无 contextHistory）回退播种，剥离被 slimForDisplay 截断的
@@ -289,7 +289,8 @@ export function applySession(agent, data) {
   agent._envResumed = full.length > 0
   const ch = data.contextHistory
   const machine = (Array.isArray(ch) && ch.length > 0) ? ch : full.map(stripTruncatedToolArgs)
-  agent._fullHistory = [...full]
+  // 绑定态（opts.slot 在场）：人读线 = 记录存储尾窗（下方绑定块填充）——不复制全量 JSON 数组
+  agent._fullHistory = opts.slot != null ? [] : [...full]
   agent.history = [...machine]
   agent.title = data.title ?? ""
   agent.tasks = data.tasks ?? []
@@ -316,6 +317,20 @@ export function applySession(agent, data) {
   agent._verifyPassed = false
   agent._slot = null // 粘性缓存清空——切换后重新认领（F1b）
   agent._slotMtime = null
+  // ── 记录存储绑定（TUI-OOM-ROOTCAUSE——§14.3.4/§14.3.5）──
+  // opts.slot 在场（启动恢复 / 非占用的 /session 切换 / ACP 钉槽）→ 绑定（身份核验 + 对账 +
+  // 窗口）——人读线 = store.tail(200)；未传（模式 F：被他人活进程占用的槽 / 测试 / ACP fork）
+  // → 解绑——人读线维持全量数组（D-R6 零回归）。
+  if (opts.slot != null) {
+    const store = bindRecordStore(agent, {
+      slotFile: slotPath(agent.cwd, opts.slot),
+      identity: data.sessionStart ?? null,
+      baseHistory: full,
+    })
+    agent._fullHistory = store.tail(RECORD_WINDOW_MESSAGES)
+  } else {
+    unbindRecordStore(agent)
+  }
   // ── MODEL-MERGE-SESSION 恢复（F-4——两支）──
   const slotProvider = data.activeProvider ? agent.providers?.find((pr) => pr.name === data.activeProvider) : null
   if (slotProvider) {
@@ -436,6 +451,8 @@ export function resetSessionState(agent) {
   agent._envResumed = false
   agent._processRestartPending = false
   agent._lastEngState = false
+  // /new 或切换：记录存储解绑（新槽由 cmd-new / 首保存补绑重新挂载——§14.3.4）
+  unbindRecordStore(agent)
 }
 
 /** Switch the manifest active pointer to a slot. Returns the slot's session data

package/src/text-budget.mjs

@@ -0,0 +1,46 @@
+/**
+ * text-budget.mjs — 文本额度纯函数（零依赖——TUI-OOM-ROOTCAUSE 批，AGENT-LOOP.md §23.3.1 / TUI.md §15.3.2）。
+ *
+ * 单一来源（D2）：agent 侧捕获截断（spawn-child.mjs——子代理 `_capturedOutput`）与 TUI 面
+ * 载体额度（tui/display-budget.mjs）共用本体的 `capText` / `appendCappedText`——两处各自
+ * 复制截断逻辑的漂移面被消除。本模块零 import（可被任意层直接引用）。
+ *
+ * 计量口径 = **UTF-16 码元**（`String.length`——与 JS 字符串内存近似、确定、O(1) 计长；
+ * TUI.md §15.2 表 1）。截断形态 = 头保 + 中段标记 + 尾保（标记含真实省略数 N）。
+ *
+ * 标记串约定：`marker` 模板中以字面 `N` 为省略数占位（逐字进测试断言——如
+ * `… [captured output truncated: N chars omitted] …`）。
+ */
+
+/** 省略数占位符替换（首个 `N`——模板约定；TUI 面 capLines 等复用）。 */
+export function fillMarker(marker, omitted) {
+  if (typeof marker === "function") return String(marker(omitted))
+  const tpl = String(marker ?? "")
+  const i = tpl.indexOf("N")
+  return i === -1 ? `${tpl} (${omitted} omitted)` : `${tpl.slice(0, i)}${omitted}${tpl.slice(i + 1)}`
+}
+
+/**
+ * 头尾保真截断：`text` ≤ `max` 时零拷贝原样返回；超限 → 头 `keepHead` + 标记 + 尾 `keepTail`。
+ * keepHead/keepTail 各自夹紧到文本长度（互不重叠——头 + 尾 ≤ 文本长）。
+ * @returns {string} 原串或截断串（含 `marker` 替换后的省略数）
+ */
+export function capText(text, { max, keepHead = 0, keepTail = 0, marker = "" } = {}) {
+  const t = String(text ?? "")
+  if (!(max > 0) || t.length <= max) return t
+  const head = Math.max(0, Math.min(keepHead, t.length))
+  const tail = Math.max(0, Math.min(keepTail, t.length - head))
+  const omitted = t.length - head - tail
+  return t.slice(0, head) + fillMarker(marker, omitted) + (tail > 0 ? t.slice(t.length - tail) : "")
+}
+
+/**
+ * 流式累积（滞后水位——摊还 O(1)）：`prev + add`；超 `hard` 时立即裁至
+ * 头 `head` + 标记 + 尾 `tail`（下一轮从截断值继续累积——稳态长度 ≤ hard）。
+ * @returns {string} 合并（可能已截断）的累积串
+ */
+export function appendCappedText(prev, add, { hard, head = 0, tail = 0, marker = "" } = {}) {
+  const merged = String(prev ?? "") + String(add ?? "")
+  if (!(hard > 0) || merged.length <= hard) return merged
+  return capText(merged, { max: hard, keepHead: head, keepTail: tail, marker })
+}

package/src/traces/trace-store.mjs

@@ -16,12 +16,21 @@
  *   与 log.mjs 的 THINCODER_LOG_DIR 同惯例）。
  * - 脱敏（D-TR2）：复用 log.mjs 字段名黑名单（apikey/designtoken/password/secret/
  *   token/authorization/proxyuri/proxy）+ SECRET_FORM 形态扫描（redactSecret）——对
- *   messages/content/reasoning/toolCalls/error 全字段递归应用；不发明新遮蔽模式。
- * - 容量有界（N-TR1）：单条轨迹一个文件，大小不限（"成本不是问题"——不截断、不
- *   脱漏行）；目录按日组织（YYYY-MM-DD），可按日/会话过滤；不自动清理（D-TR8——
- *   清理机制记 docs/TODO.md 技术组）。
+ *   messages/content/reasoning/toolCalls/error 全字段应用；不发明新遮蔽模式。
+ *   **单遍序列化（TUI-OOM-ROOTCAUSE——§23.3.2：修正轮 #2 使「不截断」表述作废）**：
+ *   脱敏内联进输出缓冲（不再构造复制图 + 二次全量字符串）——字段名/次序与既有
+ *   `JSON.stringify` 形态同构（T-TR1 等价断言）。
+ * - 容量有界（N-TR1 修订）：单消息字符串超 `TRACE_MESSAGE_MAX_CHARS` 截断（头 16K +
+ *   中段标记 + 尾 48K）；序列化总长超 `TRACE_RECORD_MAX_CHARS` → `messages` 降级为
+ *   stub 串（其余字段保留）；在途写盘份数 ≤ `TRACE_PENDING_MAX`（超限丢弃并计数——
+ *   尽力面，可观测）。目录按日组织（YYYY-MM-DD），可按日/会话过滤；保留期清理见
+ *   `cleanupTraces`（D-TR8）。
  * - seq = 当日目录内最大已有 seq + 1（D-TR3——跨会话/进程重启不覆写既有旧轨迹——
- *   18.6.1 评审 #3）。
+ *   18.6.1 评审 #3）；**进程内 seqCache（§23.3.2——消除逐调用同步扫目录）**：首次
+ *   readdirSync 后进程内递增预留，目录被清理（retention）后取下界重扫一次（防御）。
+ *   多进程语义（修正轮 #10——登记）：同 cwd 多实例各自进程内缓存——seq 可撞、同
+ *   sessionKey 记录并入同名文件（append 不覆写）；**可容忍**（本机 traces = 诊断面、
+ *   默认 OFF、撞号不损坏数据）；不做跨进程协调/落盘校验。
  * - 日期分日按本地时区（D-TR3——2026-09-04 fix round1：初版 toISOString()=UTC——
  *   本地 00:00-08:00 的调用会落进前一日目录——改本地日期字符串 YYYY-MM-DD——T-TR12）。
  * - isContinuation（D-TR1——2026-09-04 fix round1）：续写/重试链标记——true = 该调用
@@ -35,6 +44,7 @@ import { createHash } from "node:crypto"
 import { configDir } from "../config.mjs"
 import { redactSecret, errText, classifyErr } from "../log.mjs"
 import { normalizeCwd } from "../session-slots.mjs"
+import { capText } from "../text-budget.mjs"
 
 /** 轨迹根目录：THINCODER_TRACES_DIR（测试隔离/override——同 THINCODER_LOG_DIR
  *  惯例）> ~/.thincoder/traces（configDir——D-TR3——与 sessions/ 同域）。 */
@@ -65,10 +75,15 @@ export function localDateStr(date = new Date()) {
   return `${y}-${m}-${d}`
 }
 
-/** Test hooks（_rateHooks 同惯例——rate.mjs：测试可替换 now——T-TR12 注入本地日 ≠
- *  UTC 日的时刻验证分日；生产永远走真实时钟）。 */
+/** Test hooks（_rateHooks 同惯例——rate.mjs）：now/readdir/exists/mkdir/append 注入缝
+ *  （T-TR5 计数 readdirSync；T-TR4 慢写替身；T-TR12 注入本地日 ≠ UTC 日的时刻）。
+ *  生产永远走真实实现。 */
 export const _traceHooks = {
   now: () => new Date(),
+  readdir: (dir) => readdirSync(dir),
+  exists: (p) => existsSync(p),
+  mkdir: (dir) => mkdir(dir, { recursive: true }),
+  append: (path, text) => appendFile(path, text, "utf8"),
 }
 
 /** 当日轨迹目录（D-TR3：traces/YYYY-MM-DD——分日组织——N-TR1）。 */
@@ -76,32 +91,71 @@ export function tracesDirFor(dateStr) {
   return join(tracesRoot(), dateStr)
 }
 
-// 进程内 seq 预留表：同步预留（原子——异步写盘在途时并发调用不撞号）；键 = 目录。
-// 跨进程/重启由磁盘 max 兜底（同键无预留时磁盘值即事实——T-TR10）。
-const _reservedSeq = new Map()
+// ─── 额度常量（§23.3.2——编译期常量，不新增配置项 D-TR4）─────────────────────
+
+/** 单消息字符串额度（消息内容/推理/工具参数串）——超限：头 16K + 中段标记 + 尾 48K。 */
+export const TRACE_MESSAGE_MAX_CHARS = 65_536
+/** 单记录总长额度——超限：`messages` 字段整体降级为 stub 串（元数据保留）。 */
+export const TRACE_RECORD_MAX_CHARS = 4_000_000
+/** 在途写盘份数上限（超限丢弃本记录 + 计数——不阻塞模型调用路径）。 */
+export const TRACE_PENDING_MAX = 8
+
+/** 内容额度标记（逐字——进测试断言；同族工具预览形态）。 */
+const MSG_MARKER = "… [trace truncated: N chars omitted] …"
+const HEAD_CHARS = 16_384
+const TAIL_CHARS = 49_152
+
+/** 受额度约束的字段名（消息内容/推理/工具参数串——§23.3.2 字面集）。 */
+const CAPPED_KEYS = new Set(["content", "reasoning", "reasoning_content", "reasoningContent", "arguments"])
+
+// ─── 在途计数（§23.3.2 表 4 候选 1：待写计数上限 8 + 超限丢弃计数）────────────
+
+let _pendingWrites = 0
+let _droppedRecords = 0
+let _saturationNotified = false
+
+// 进程内 seq 缓存（§23.3.2：dir → 已见/已预留 max——首次 readdirSync 后递增预留；
+// 目录被清理（retention）后取下界重扫一次（防御））。
+const _seqCache = new Map()
+
+/** 在途/丢弃观测（测试缝——T-TR4）。 */
+export function _traceStoreStats() {
+  return { pending: _pendingWrites, dropped: _droppedRecords }
+}
+
+/** 测试缝：清进程内状态（seqCache + 在途/丢弃计数）。 */
+export function _resetTraceStateForTest() {
+  _seqCache.clear()
+  _pendingWrites = 0
+  _droppedRecords = 0
+  _saturationNotified = false
+}
+
+function scanMaxSeq(dir) {
+  if (!_traceHooks.exists(dir)) return 0
+  let names
+  try { names = _traceHooks.readdir(dir) } catch { return 0 }
+  let max = 0
+  for (const name of names) {
+    const m = name.match(/-(\d+)\.jsonl$/)
+    if (m) max = Math.max(max, Number(m[1]))
+  }
+  return max
+}
 
 /** seq = max(当日目录最大已有 seq, 进程内已预留) + 1（D-TR3——跨会话/进程重启
- *  不覆写——T-TR8/T-TR10；同步预留 = 异步写盘启动前的原子号位分配）。 */
+ *  不覆写——T-TR8/T-TR10；同步预留 = 异步写盘启动前的原子号位分配）。
+ *  §23.3.2：seqCache 进程内递增——不逐调用 readdirSync（目录被清理/缺失 → 重扫一次）。 */
 export function nextTraceSeq(dateStr) {
   const dir = tracesDirFor(dateStr)
-  let max = 0
-  if (existsSync(dir)) {
-    let names
-    try {
-      names = readdirSync(dir)
-    } catch {
-      // 目录不可读——按预留表续号（不静默撞号）
-      max = _reservedSeq.get(dir) ?? 0
-      _reservedSeq.set(dir, max + 1)
-      return max + 1
-    }
-    for (const name of names) {
-      const m = name.match(/-(\d+)\.jsonl$/)
-      if (m) max = Math.max(max, Number(m[1]))
-    }
+  let max = _seqCache.get(dir)
+  if (max === undefined || !_traceHooks.exists(dir)) {
+    // 首次调用（或目录被 retention 清理/缺失）——重扫磁盘取真实下界（防御：清除后重号安全）
+    const disk = scanMaxSeq(dir)
+    max = Math.max(disk, max ?? 0)
   }
-  const seq = Math.max(max, _reservedSeq.get(dir) ?? 0) + 1
-  _reservedSeq.set(dir, seq)
+  const seq = max + 1
+  _seqCache.set(dir, seq)
   return seq
 }
 
@@ -111,18 +165,57 @@ export function tracesEnabled(logCtx) {
   return logCtx?.traces !== false
 }
 
-/** 递归脱敏（D-TR2）：对 messages/content/reasoning/toolCalls/error 全字段应用——
- *  字段名命中黑名单 → 遮蔽；字符串内容命中密钥形态（sk-/Bearer/-key=）→ 截断到
- *  形态前 + 标记。数组/对象递归（消息 content 可为 parts 数组、toolCalls 嵌套）。 */
-function redactValue(fieldKey, value) {
-  if (typeof value === "string") return redactSecret(fieldKey, value)
-  if (Array.isArray(value)) return value.map((v) => redactValue(fieldKey, v))
-  if (value && typeof value === "object") {
-    const out = {}
-    for (const [k, v] of Object.entries(value)) out[k] = redactValue(k, v)
-    return out
+// ─── 单遍序列化（§23.3.2 D-TR1——脱敏内联、零复制图、字段名/次序同构）────────
+
+const OMIT = Symbol("omit") // JSON.stringify 语义：对象属性省略（数组元素 → null）
+
+function scalarJson(key, v) {
+  if (typeof v === "string") {
+    // 额度（§23.3.2）+ 脱敏（D-TR2）单点：先限长（标记随附）再遮蔽形态扫描——
+    // 输出与既有 redactValue(key, s) 串值路径逐字同形（除外显式截断标记）。
+    if (v.length > TRACE_MESSAGE_MAX_CHARS && CAPPED_KEYS.has(key)) {
+      return JSON.stringify(redactSecret(key, capText(v, { max: TRACE_MESSAGE_MAX_CHARS, keepHead: HEAD_CHARS, keepTail: TAIL_CHARS, marker: MSG_MARKER })))
+    }
+    return JSON.stringify(redactSecret(key, v))
+  }
+  if (v === null) return "null"
+  if (typeof v === "number") return Number.isFinite(v) ? String(v) : "null" // JSON.stringify(NaN/±Infinity) === "null"
+  if (typeof v === "boolean") return v ? "true" : "false"
+  return undefined // undefined/function/symbol/bigint → 省略（JSON.stringify 同语义）
+}
+
+function writeValue(out, key, v) {
+  const s = scalarJson(key, v)
+  if (s !== undefined) { out.push(s); return true }
+  if (Array.isArray(v)) {
+    out.push("[")
+    for (let i = 0; i < v.length; i++) {
+      if (i) out.push(",")
+      if (!writeValue(out, key, v[i])) out.push("null") // 数组元素不可省略
+    }
+    out.push("]")
+    return true
+  }
+  if (v && typeof v === "object") {
+    if (typeof v.toJSON === "function") { // Date/宿主对象：保持 JSON.stringify 等价
+      const js = JSON.stringify(v)
+      out.push(js === undefined ? "null" : js)
+      return true
+    }
+    out.push("{")
+    let first = true
+    for (const [k, val] of Object.entries(v)) {
+      const omit = val === undefined || typeof val === "function" || typeof val === "symbol" || typeof val === "bigint"
+      if (omit) continue
+      if (!first) out.push(",")
+      first = false
+      out.push(JSON.stringify(k), ":")
+      writeValue(out, k, val)
+    }
+    out.push("}")
+    return true
   }
-  return value
+  return false // OMIT
 }
 
 /**
@@ -142,6 +235,16 @@ export function recordChatTrace(provider, opts = {}, result = null, error = null
   if (!writeEnabled()) return
   const logCtx = opts.logCtx ?? {}
   if (!tracesEnabled(logCtx)) return
+  // §23.3.2 在途上界（表 4 候选 1）：饱和即丢弃本记录（尽力面——丢弃可观测），
+  // 首次饱和打一行 stderr（每饱和段一次；排空后复位）。
+  if (_pendingWrites >= TRACE_PENDING_MAX) {
+    _droppedRecords++
+    if (!_saturationNotified) {
+      _saturationNotified = true
+      console.error(`[trace] pending write queue full — ${_droppedRecords} record(s) dropped`)
+    }
+    return
+  }
   // cwd/session 经 logCtx 增补（调用点传 agent.cwd / agent._sessionStart——
   // D-TR3 的 cwdHash/命名与 D-TR1 的 session 字段所需）；无 agent 作用域的调用点
   // 回退 process.cwd()——CLI 会话即工作区。该类点开关状态：distill 已含
@@ -154,44 +257,72 @@ export function recordChatTrace(provider, opts = {}, result = null, error = null
   const dateStr = localDateStr(now)
   const seq = nextTraceSeq(dateStr)
   const sessionKey = traceSessionKey(cwd)
-  const record = {
-    ts: now.toISOString(),
-    session: logCtx.session ?? null,
-    cwdHash: createHash("sha1").update(normalizeCwd(cwd)).digest("hex"),
-    role: logCtx.role ?? null,
-    depth: logCtx.depth ?? null,
-    turn: logCtx.turn ?? null,
-    provider: provider?.name ?? provider?.model ?? "unknown",
-    model: provider?.model ?? "",
-    stage: logCtx.stage ?? null,
-    kind: logCtx.kind ?? null,
-    // D-TR1（fix round1）：续写/重试链标记——true = 该调用是续写链的一环
-    // （core.mjs 续写递归传出）；新调用缺省 false——round 字段已删（无来源）。
-    isContinuation: logCtx.isContinuation === true,
-    messages: redactValue("messages", opts.messages ?? []),
-    content: redactValue("content", result?.content ?? null),
-    reasoning: redactValue("reasoning", result?.reasoning ?? null),
-    toolCalls: redactValue("toolCalls", result?.toolCalls ?? null),
-    usage: result?.usage ?? null,
-    finishReason: result?.finishReason ?? null,
+
+  // 单遍序列化：头段字段 + messages（独立缓冲——记录级额度降级用）+ 尾段字段。
+  const parts = ["{"]
+  let first = true
+  const put = (k, v) => {
+    if (!first) parts.push(",")
+    first = false
+    parts.push(JSON.stringify(k), ":")
+    writeValue(parts, k, v)
   }
+  put("ts", now.toISOString())
+  put("session", logCtx.session ?? null)
+  put("cwdHash", createHash("sha1").update(normalizeCwd(cwd)).digest("hex"))
+  put("role", logCtx.role ?? null)
+  put("depth", logCtx.depth ?? null)
+  put("turn", logCtx.turn ?? null)
+  put("provider", provider?.name ?? provider?.model ?? "unknown")
+  put("model", provider?.model ?? "")
+  put("stage", logCtx.stage ?? null)
+  put("kind", logCtx.kind ?? null)
+  // D-TR1（fix round1）：续写/重试链标记——true = 该调用是续写链的一环
+  // （core.mjs 续写递归传出）；新调用缺省 false——round 字段已删（无来源）。
+  put("isContinuation", logCtx.isContinuation === true)
+  const msgAt = parts.length
+  const msgParts = []
+  writeValue(msgParts, "messages", opts.messages ?? [])
+  put("content", result?.content ?? null)
+  put("reasoning", result?.reasoning ?? null)
+  put("toolCalls", result?.toolCalls ?? null)
+  put("usage", result?.usage ?? null)
+  put("finishReason", result?.finishReason ?? null)
   if (error != null) {
     // D-TR5：错误路径轨迹——error（errText 截断 + 类别）+ finishReason:null
-    record.error = {
-      err: redactValue("err", errText(error, 500)),
+    put("error", {
+      err: redactSecret("err", errText(error, 500)),
       kind: classifyErr(error, opts.signal),
-    }
+    })
   }
+  const headStr = parts.slice(0, msgAt).join("")
+  const tailStr = parts.slice(msgAt).join("")
+  const msgStr = msgParts.join("")
+  const msgsArr = Array.isArray(opts.messages) ? opts.messages : []
+  const record = (() => {
+    const total = headStr.length + msgStr.length + tailStr.length + 1
+    if (total > TRACE_RECORD_MAX_CHARS) {
+      // 单记录额度（§23.3.2）：messages 整体降级 stub——元数据字段保留、标记含计数
+      const stub = `[trace record truncated for size: ${total} chars / ${msgsArr.length} messages]`
+      return `${headStr},${JSON.stringify("messages")}:${JSON.stringify(stub)}${tailStr}}`
+    }
+    return `${headStr},${JSON.stringify("messages")}:${msgStr}${tailStr}}`
+  })()
+
   // 真 fire-and-forget（F-TR3——模型调用路径零额外阻塞）：seq 已在上面同步预留
   // （原子号位——写盘在途并发不撞号）；写盘异步（不 await——chat() 出口立即返回）。
   // 返回值 = 落盘 promise（测试 await 用；chat() 不消费——fire-and-forget 语义）。
+  _pendingWrites++
   return (async () => {
     try {
       const dir = tracesDirFor(dateStr)
-      await mkdir(dir, { recursive: true }) // D-TR3：写前建目录（与 sessions/tool-results 同惯例）
-      await appendFile(join(dir, `${sessionKey}-${seq}.jsonl`), JSON.stringify(record) + "\n", "utf8")
+      await _traceHooks.mkdir(dir) // D-TR3：写前建目录（与 sessions/tool-results 同惯例）
+      await _traceHooks.append(join(dir, `${sessionKey}-${seq}.jsonl`), record + "\n")
     } catch {
       // F-TR3：落盘失败静默降级——不抛错、不阻塞 chat() 返回
+    } finally {
+      _pendingWrites--
+      if (_pendingWrites === 0) _saturationNotified = false // 排空 → 下个饱和段可再报一次
     }
   })()
 }

package/src/tui/cmd-clear.mjs

@@ -9,12 +9,14 @@ export async function handleClearCommand(ctx) {
     ], { defaultIndex: 1 })
     if (e?.action === "yes") {
       state.lines = []
+      state._linesChars = 0 // TUI-OOM-ROOTCAUSE（§15.3.2）：行集清空 → 字符账同步归零
       state.streaming = ""
       render()
     }
     return
   }
   state.lines = []
+  state._linesChars = 0 // TUI-OOM-ROOTCAUSE（§15.3.2）：行集清空 → 字符账同步归零
   state.streaming = ""
   render()
 }

package/src/tui/cmd-new.mjs

@@ -1,4 +1,4 @@
-import { newSession, resetSessionState } from "../session.mjs"
+import { newSession, resetSessionState, bindRecordStore, slotPath } from "../session.mjs"
 import { C } from "./ansi.mjs"
 
 /** /new command: start a new session in a fresh slot.
@@ -14,8 +14,12 @@ export async function handleNewCommand(ctx) {
     // slot（实锤 .19/.3 双副本）。_slot 更新为粘性新槽位。
     resetSessionState(agent)
     agent._slot = slot
+    // §14.3.4：/new 绑定新槽记录存储（baseHistory 空——identity 此时为 null = 待固化；
+    // 首次保存/首条追加时补写现场身份）
+    bindRecordStore(agent, { slotFile: slotPath(agent.cwd, slot), identity: agent._sessionStart ?? null, baseHistory: [] })
     state.tasks = []
     state.lines = []
+    state._linesChars = 0 // TUI-OOM-ROOTCAUSE（§15.3.2）：行集清空 → 字符账同步归零
     state.streaming = ""
     render()
     pushLine(`New session started (slot ${slot}; /session to switch back)`, C.dim)