thincoder 0.12.60 → 0.12.62

package/src/tools/search.mjs

@@ -0,0 +1,236 @@
+import {
+  DESC,
+  truncate,
+  resolveInCwd,
+  globToRegex,
+  splitGlobPatterns,
+  compileGlobMatchers,
+  normalizeEOL,
+  IGNORED_DIRS,
+} from "./shared.mjs";
+import { readFile, readdir, stat, lstat } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Escape a string for literal regex matching (grep literal=true). */
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+// ---------------------------------------------------------------- glob
+
+export const globTool = {
+  name: "glob",
+  description: DESC("glob"),
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Glob pattern — supports **, *, ?, [..], {a,b} braces, and space-separated exclusion (\"**/*.js !test/**\")" },
+      path: { type: "string", description: "Directory to search in (default cwd)" },
+    },
+    required: ["pattern"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const base = resolveInCwd(ctx, args.path ?? ".")
+    // §17 调用侧拆分（评审 #5 职责分层）：空格分隔 include !exclude 多模式在这里拆；
+    // globToRegex 只收单个模式（数组由 compileGlobMatchers 收）。
+    let match
+    try {
+      const parts = splitGlobPatterns(args.pattern)
+      if (parts.length === 0) return "Error: pattern is required"
+      match = compileGlobMatchers(parts).test
+    } catch (e) {
+      return `glob error: invalid pattern "${args.pattern}": ${e.message}`
+    }
+    const results = []
+    for await (const relPath of walkFiles(base)) {
+      if (match(relPath)) {
+        results.push(relPath)
+        if (results.length >= 1000) break
+      }
+    }
+    if (results.length === 0) return "(no matches)"
+    return truncate(results.sort().join("\n"))
+  },
+}
+
+/** Recursively traverse files, yield relative paths (skip IGNORED_DIRS) */
+async function* walkFiles(dir, rel = "") {
+  let entries
+  try {
+    entries = await readdir(dir, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const e of entries) {
+    // Skip ignored dirs AND symbolic links (symlinks to directories would cause infinite loops)
+    if (e.isSymbolicLink()) continue
+    if (e.isDirectory() && IGNORED_DIRS.has(e.name)) continue
+    const relPath = rel ? `${rel}/${e.name}` : e.name
+    if (e.isDirectory()) {
+      yield* walkFiles(join(dir, e.name), relPath)
+    } else {
+      yield relPath
+    }
+  }
+}
+
+// ---------------------------------------------------------------- grep
+
+export const grepTool = {
+  name: "grep",
+  description: DESC("grep"),
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Regular expression, or a literal string when literal=true" },
+      path: { type: "string", description: "Directory or file to search (default cwd)" },
+      glob: { type: "string", description: "Only search files matching this glob — supports **, *, ?, [..], {a,b} braces and space-separated exclusion (\"**/*.js !test/**\")" },
+      ignoreCase: { type: "boolean", description: "Case-insensitive match (default false)" },
+      literal: { type: "boolean", description: "Literal string match — no regex interpretation (default false)" },
+      before: { type: "integer", description: "Lines of context to show before each match (grep -B). Default 0" },
+      after: { type: "integer", description: "Lines of context to show after each match (grep -A). Default 0" },
+    },
+    required: ["pattern"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const base = resolveInCwd(ctx, args.path ?? ".")
+    let regex
+    try {
+      const pat = args.literal ? escapeRegExp(String(args.pattern)) : args.pattern
+      regex = new RegExp(pat, args.ignoreCase ? "i" : "")
+    } catch (e) {
+      throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`, { cause: e })
+    }
+    // §17 调用侧拆分：glob 参数支持空格分隔 include !exclude 多模式（include/exclude 求交）。
+    let fileTest = null
+    if (args.glob) {
+      try {
+        const parts = splitGlobPatterns(args.glob)
+        if (parts.length > 0) fileTest = compileGlobMatchers(parts).test
+      } catch (e) {
+        throw new Error(`grep glob /${args.glob}/ is invalid: ${e.message}`, { cause: e })
+      }
+    }
+    const before = Math.max(0, Math.floor(args.before ?? 0))
+    const after = Math.max(0, Math.floor(args.after ?? 0))
+    const wantCtx = before > 0 || after > 0
+    const hits = [] // { file, line(1-based), text }
+    const fileLines = new Map() // file -> string[] (cached only when context lines requested)
+
+    async function search(file) {
+      let content
+      try {
+        // Large file guard: skip files over 10MB to prevent OOM
+        const fst = await stat(file)
+        if (fst.size > 10_000_000) return
+        content = normalizeEOL(await readFile(file, "utf8"))
+      } catch {
+        return // Skip unreadable files; binary files will be read as UTF-8 and searched (may produce garbled matches)
+      }
+      const lines = content.split("\n")
+      if (wantCtx) fileLines.set(file, lines)
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          hits.push({ file, line: i + 1, text: lines[i] })
+          if (hits.length >= 200) return
+        }
+      }
+    }
+
+    async function walk(target, rel) {
+      if (hits.length >= 200) return
+      // Use lstat to avoid following symlinks — prevents ./evil → /etc from making grep scan the entire system
+      let s
+      try { s = await lstat(target) } catch { return }
+      if (!s.isDirectory()) {
+        // rel 为相对搜索基的路径（排除前缀如 !test/** 必须按目录路径作用——不能用裸文件名）；
+        // 单文件目标（path 指向文件）时 rel 为空 → 退化为按文件名过滤（既有语义）。
+        if (!fileTest || fileTest(rel || target.split(/[\\/]/).pop())) await search(target)
+        return
+      }
+      let entries
+      try {
+        entries = await readdir(target, { withFileTypes: true })
+      } catch {
+        return
+      }
+      for (const e of entries) {
+        if (e.isDirectory() && IGNORED_DIRS.has(e.name)) continue
+        await walk(join(target, e.name), rel ? `${rel}/${e.name}` : e.name)
+      }
+    }
+
+    await walk(base, "")
+    if (hits.length === 0) return "(no matches)"
+
+    // No context: keep original path:line: content format
+    if (!wantCtx) {
+      return truncate(hits.map((h) => `${h.file}:${h.line}: ${h.text}`).join("\n"))
+    }
+
+    // With context: matching lines use ':', context lines use '-' (like ripgrep); overlapping ranges in same file are merged and de-duplicated
+    const fileMatched = new Map() // file -> Set<line>
+    for (const h of hits) {
+      if (!fileMatched.has(h.file)) fileMatched.set(h.file, new Set())
+      fileMatched.get(h.file).add(h.line)
+    }
+    const out = []
+    for (const [file, matchedLines] of fileMatched) {
+      const lines = fileLines.get(file) ?? []
+      const lineSet = new Set()
+      for (const ml of matchedLines) {
+        for (let l = Math.max(1, ml - before); l <= Math.min(lines.length, ml + after); l++) lineSet.add(l)
+      }
+      for (const l of [...lineSet].sort((a, b) => a - b)) {
+        const sep = matchedLines.has(l) ? ":" : "-"
+        out.push(`${file}${sep}${l}${sep} ${lines[l - 1]}`)
+      }
+    }
+    return truncate(out.join("\n"))
+  },
+}
+
+export const lsTool = {
+  name: "ls",
+  description: DESC("ls"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Directory path (default cwd)" },
+      filter: { type: "string", description: "Only list entries matching this glob (e.g. '*.mjs', '*test*')" },
+    },
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const abs = resolveInCwd(ctx, args.path ?? ".")
+    const filterRe = args.filter ? globToRegex(args.filter) : null
+    let entries
+    try {
+      entries = await readdir(abs, { withFileTypes: true })
+    } catch (e) {
+      if (e.code === "ENOENT" || e.code === "ENOTDIR") throw new Error(`ls: ${args.path ?? "."} — ${e.code === "ENOTDIR" ? "not a directory" : "not found"}`, { cause: e })
+      throw e
+    }
+    const rows = await Promise.all(
+      entries
+        .filter((e) => !filterRe || filterRe.test(e.name))
+        .slice(0, 500)
+        .map(async (e) => {
+        const s = await stat(join(abs, e.name)).catch(() => null)
+        const isDir = e.isDirectory()
+        return {
+          dir: isDir,
+          name: e.name + (isDir ? "/" : ""),
+          size: s?.size ?? 0,
+          mtime: s ? s.mtime.toISOString().slice(0, 16).replace("T", " ") : "?",
+        }
+      }),
+    )
+    rows.sort((a, b) => (a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1))
+    if (rows.length === 0) return "(no entries)"
+    const out = rows.map((r) => `${r.dir ? "d" : "-"}  ${r.name.padEnd(40)} ${String(r.size).padStart(10)}  ${r.mtime}`)
+    return truncate(out.join("\n"))
+  },
+}

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/agent-turn.mjs

@@ -21,13 +21,25 @@ import { buildToolCallbacks, sweepToolBlocks } from "./tool-events.mjs"
 import { freezeAllSubTasks } from "./subagent-blocks.mjs" // freezeReclaimDigestedBlocks 随 §17 段迁 suspension-drive.mjs
 import { ensureSessionTitle } from "../generate-title.mjs"
 import { logEvent, errText } from "../log.mjs"
-import { suspensionSession, poolLive, planQueuedInput } from "./suspension-drive.mjs"
+import { suspensionSession, poolLive } from "./suspension-drive.mjs"
 
 /** Exit-flush bound for the async end-of-run distillation (SEND-STALL-DISTILL §2.5):
  *  wait at most this long for the in-flight distill before the final session save —
  *  never let shutdown hang on the background summary call. */
 const DISTILL_FLUSH_TIMEOUT_MS = 5000
 
+/**
+ * 第 33 批（TUI §14.3(d)——纯函数，供测试直驱）：回合链尾「需要用户」谓词——agent 已停
+ * 且无自动续跑 ⇒ 置 attention 位。排除项语义（F13）：`skipSession`（digest / 会话内回合
+ *  ——由外层链尾统一置位）· 挂起两态 / 池 live / 队列非空（自动续跑中——不由用户接手）·
+ *  processing（回合在跑）。
+ *  @returns {boolean}
+ */
+export function userNeededAtTurnEnd(state, agent, skipSession) {
+  return !skipSession && !state.suspended && !state._suspPending && !poolLive(agent)
+    && state.queue.length === 0 && !state.processing
+}
+
 /**
  * LOGGING（docs/design/LOGGING.md）包装：回合骨架事件（turn:start/turn:end——kind
  * user/auto；result ok/stopped/error）。内层经 _logOutcome 载具回传终止原因（中止/
@@ -283,26 +295,25 @@ async function runAgentTurnInner(ctx, text, opts) {
     render()
   }
 
-  // §17 偏差 #1 兜底：释放窗口期 Enter 已入 pendingInput——链条走到此处若池已空
-  //（挂起会话不会启动，下方 while 是最后一个消费点）则转正队列照常续发，消息不滞留
-  // 不并发。池非空时挂起会话先消费 pendingInput（D-S5 输入优先），无需此处处理。
+  // §17 偏差 #1 兜底（INPUT-LOCK 单槽化——2026-09-09）：释放窗口期 Enter 已入
+  // pendingInput 单槽——链条走到此处若池已空（挂起会话不会启动，下方 while 是最后一个
+  // 消费点）则转正队列照常续发，消息不滞留不并发。池非空时挂起会话先消费 pendingInput
+  // （D-S5 输入优先），无需此处处理。单槽语义下残余至多一条。
   if (!skipSession && !state._suspAborted && (state.pendingInput?.length ?? 0) > 0 && !poolLive(agent)) {
-    state.queue.push(...state.pendingInput.splice(0).map((t) => ({ text: String(t) })))
+    state.queue.push({ text: String(state.pendingInput.shift()) })
   }
 
-  // Queued messages: auto-process next one（§24 D-24c/R15：攒批合并——合并仅限
-  // 连续文本——/cmd 逐条保序即时——单条超长直发；每条 runAgentTurn 回合后余项
-  // 由递归层的本循环续取——边界幂等不丢）
+  // 交接消息自动续发（INPUT-LOCK 单消息——2026-09-09）：submit 不再排队（busy 提交吞）
+  // + R15 攒批删——state.queue 只剩残项单消息（释放窗口兜底/挂起中止残余——零丢失
+  // 承诺）——逐条直发；斜杠命令直接执行（保序）；回合后的续发由递归层同循环续取。
   while (state.queue.length > 0 && !state.processing) {
-    const head = planQueuedInput(state.queue.map((q) => q.text))[0]
-    state.queue.splice(0, head.count)
-    // Queued slash commands execute directly — order-preserved, never merged
-    if (head.kind === "slash") {
+    const head = state.queue.shift()
+    // 残项斜杠命令直接执行——保序、绝不合并
+    if (head.text.startsWith("/")) {
       await handleSlash(head.text)
       render()
       continue
     }
-    pushLabel(`❯ You: (from queue)`, ansi.bold + C.user)
     await runAgentTurn(ctx, head.text)
     return
   }
@@ -321,4 +332,12 @@ async function runAgentTurnInner(ctx, text, opts) {
     // 竞态复现）。
     state._suspAborted = false
   }
+
+  // 第 33 批（TUI §14.3(d)）：顶层链尾（队列续发循环与挂起会话退出**之后**）——无人自动
+  // 接手 ⇒ 置 attention 位（渲染层实时派生 blocked/awaiting；用户任意输入清位）。D-AT6：
+  // 不放在回合末 finally——那之后还有队列续发 / 挂起会话（digest 自动消费），不是「需要用户」。
+  if (userNeededAtTurnEnd(state, agent, skipSession)) {
+    state.attentionAwaiting = true
+    render()
+  }
 }

package/src/tui/ansi.mjs

@@ -31,6 +31,7 @@ export const ansi = {
   dim: `${ESC}[2m`,
   bold: `${ESC}[1m`,
   fg: (n) => `${ESC}[${30 + n}m`,
+  bg: (n) => `${ESC}[${40 + n}m`,
   gray: `${ESC}[90m`,
 }
 
@@ -44,5 +45,6 @@ export const C = {
   dim: ansi.gray,
   warn: ansi.fg(3),
   advisor: `${ESC}[92m`,  // bright green — visible on dark backgrounds
+  attention: ansi.bg(3) + ansi.fg(0), // 第 33 批（TUI §14.3/D-AT3）：attention 态整行色对——黄底黑字（\x1b[43m\x1b[30m，与 VSC warningBackground 同色系；浅深终端均可见——不依赖主题配色）
   fold: ansi.bold + ansi.fg(6),   // bold cyan — fold markers must stay visible on light AND dark themes (dim white vanished on light backgrounds)
 }