thincoder 0.12.58 → 0.12.60

package/src/tools/web.mjs

@@ -4,6 +4,8 @@ import { proxyFetch } from "../proxy.mjs";
 
 export const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
 const FETCH_TIMEOUT = 15_000
+// §14 D-TF3：网络失败错误文本追加 proxy 提示——纯文本提示，不自动路由（2026-08-31 裁定：proxy 显式传不自动应用）
+const PROXY_HINT = "network failure — retry with proxy: 'http://host:port' if the target is blocked"
 
 // ── Web search (Bing; direct by default, through proxy when configured and web toggle on) ──
 
@@ -204,19 +206,19 @@ export const fetchTool = {
             const r = resolveRedirectTarget(loc, args.url)
             if (r.error) throw new Error(`fetch failed: ${r.error}`)
             const r2 = await proxyFetch(r.target, { headers: { "User-Agent": UA } }, proxyUri)
-            if (!r2.ok) throw new Error(`fetch failed: HTTP ${r2.status}`)
+            if (!r2.ok) throw new Error(`fetch failed: HTTP ${r2.status}\n${PROXY_HINT}`)
             const ct2 = headerOf(r2, "content-type") ?? ""
             const b2 = await r2.text()
             if (ct2.includes("text/html")) { const t = htmlToText(b2); return truncate(t + detectSparseHtml(b2, t)) }
             return truncate(b2)
           }
         }
-        throw new Error(`fetch failed: HTTP ${response.status}`)
+        throw new Error(`fetch failed: HTTP ${response.status}\n${PROXY_HINT}`)
       }
       const ct = headerOf(response, "content-type") ?? ""
       const body = await response.text()
       if (ct.includes("text/html")) { const t = htmlToText(body); return truncate(t + detectSparseHtml(body, t)) }
       return truncate(body)
-    } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}`, { cause: e }) }
+    } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}\n${PROXY_HINT}`, { cause: e }) }
   },
 }

package/src/tools/websearch.md

@@ -8,7 +8,8 @@ Parameters:
 - proxy: http://host:port explicit proxy (optional) — use ONLY when passed; no proxy = direct. config.json proxy is NOT auto-applied (2026-08-31 ruling); Bing/foreign sites usually need a proxy, domestic targets don't
 
 Notes:
-- Before searching the web, call `memory_search` first — you may already know the answer from a previous session. Only reach for websearch if memory comes up empty.
+- Before searching the web, call the memory tool (action: search) first — you may already know the answer from a previous session. Only reach for websearch if memory comes up empty.
+- Runs synchronously — returns when the search completes (all selected engines run in parallel).
 - Use this for information that is NOT in the local codebase — current docs, error messages, API references
 - Follow up with `fetch` to read full pages from the results
 - **Weak engine warning**: Bing's index is noisy for technical queries — if a first websearch returns irrelevant/townhall-grade results, DO NOT retry the same query. Configure a search MCP tool (e.g. `glm-websearch` via the MCP config) for technical lookups; websearch is the fallback.

package/src/tools/write.md

@@ -5,5 +5,7 @@ Parameters:
 - content (required): Full content to write
 
 Notes:
+- write replaces the WHOLE file — read it first and confirm you intend to rewrite it entirely; for a small change use edit / insert_after.
+- Returns `Wrote N chars to <path>` + git diff + syntax-check note.
 - This overwrites the entire file — use `edit` for targeted changes
 - The file is atomic: it either writes completely or fails

package/src/traces/trace-store.mjs

@@ -0,0 +1,224 @@
+/**
+ * trace-store.mjs — §18.6 完整轨迹存档（AGENT-LOOP.md §18.6 D-TR1..TR8 权威规格）。
+ *
+ * 完整请求-响应轨迹落盘：每次 chat() 调用一个 JSONL 文件到
+ * ~/.thincoder/traces/YYYY-MM-DD/<sessionKey>-<seq>.jsonl。采集点唯一 = core.mjs
+ * chat() 导出出口（所有模型调用——主回合/消化轮/compress/distill/advisor/子代理/
+ * auto-think/consult——都经该函数）——续写/重试在出口已合并（reasoning 全量）。
+ *
+ * 纪律（与 log.mjs 同源惯例）：
+ * - 真 fire-and-forget（F-TR3——模型调用路径零额外阻塞）：seq 同步预留（原子号位），
+ *   写盘异步（node:fs/promises——不 await）；落盘失败静默降级（不抛错、不阻塞
+ *   chat() 返回）。recordChatTrace 返回落盘 promise——仅供测试/显式消费方 await。
+ * - 测试隔离：node --test 进程（NODE_TEST_CONTEXT）默认不写盘——防测试事件污染真实
+ *   轨迹目录（既有测试跑真实 agent 管线会产生数百次 chat 调用）；显式设置
+ *   THINCODER_TRACES_DIR 强制写入该目录（traces.test.mjs 用它隔离临时目录——
+ *   与 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 技术组）。
+ * - seq = 当日目录内最大已有 seq + 1（D-TR3——跨会话/进程重启不覆写既有旧轨迹——
+ *   18.6.1 评审 #3）。
+ * - 日期分日按本地时区（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 = 该调用
+ *   是续写链的一环（core.mjs 续写递归传出 logCtx.isContinuation）；新调用 false。
+ *   记录不输出 round 字段（全设计无 round 定义——删——不发明无来源字段）。
+ */
+import { readdirSync, existsSync } from "node:fs"
+import { appendFile, mkdir, readdir, stat, unlink, rmdir } from "node:fs/promises"
+import { join } from "node:path"
+import { createHash } from "node:crypto"
+import { configDir } from "../config.mjs"
+import { redactSecret, errText, classifyErr } from "../log.mjs"
+import { normalizeCwd } from "../session-slots.mjs"
+
+/** 轨迹根目录：THINCODER_TRACES_DIR（测试隔离/override——同 THINCODER_LOG_DIR
+ *  惯例）> ~/.thincoder/traces（configDir——D-TR3——与 sessions/ 同域）。 */
+export function tracesRoot() {
+  return process.env.THINCODER_TRACES_DIR ?? join(configDir, "traces")
+}
+
+/** 写门（测试隔离）：test runner 进程（NODE_TEST_CONTEXT）默认跳过——除显式
+ *  THINCODER_TRACES_DIR override（traces.test.mjs 隔离临时目录）。 */
+function writeEnabled() {
+  if (process.env.NODE_TEST_CONTEXT && !process.env.THINCODER_TRACES_DIR) return false
+  return true
+}
+
+/** sessionKey = sha1(normalizeCwd(cwd))[:12]（D-TR3——与 session-slots sessionPath
+ *  同算法同 cwd 归一——两端 hash 一致）。 */
+export function traceSessionKey(cwd) {
+  return createHash("sha1").update(normalizeCwd(cwd)).digest("hex").slice(0, 12)
+}
+
+/** 本地时区日期字符串 YYYY-MM-DD（D-TR3——2026-09-04 fix round1：初版
+ *  toISOString()=UTC 日期——本地 00:00-08:00 落前一日目录；本地日期才是用户视角的
+ *  "今天"——T-TR12）。recordChatTrace 与测试读取 helpers 共用同一实现——不双写。 */
+export function localDateStr(date = new Date()) {
+  const y = date.getFullYear()
+  const m = String(date.getMonth() + 1).padStart(2, "0")
+  const d = String(date.getDate()).padStart(2, "0")
+  return `${y}-${m}-${d}`
+}
+
+/** Test hooks（_rateHooks 同惯例——rate.mjs：测试可替换 now——T-TR12 注入本地日 ≠
+ *  UTC 日的时刻验证分日；生产永远走真实时钟）。 */
+export const _traceHooks = {
+  now: () => new Date(),
+}
+
+/** 当日轨迹目录（D-TR3：traces/YYYY-MM-DD——分日组织——N-TR1）。 */
+export function tracesDirFor(dateStr) {
+  return join(tracesRoot(), dateStr)
+}
+
+// 进程内 seq 预留表：同步预留（原子——异步写盘在途时并发调用不撞号）；键 = 目录。
+// 跨进程/重启由磁盘 max 兜底（同键无预留时磁盘值即事实——T-TR10）。
+const _reservedSeq = new Map()
+
+/** seq = max(当日目录最大已有 seq, 进程内已预留) + 1（D-TR3——跨会话/进程重启
+ *  不覆写——T-TR8/T-TR10；同步预留 = 异步写盘启动前的原子号位分配）。 */
+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]))
+    }
+  }
+  const seq = Math.max(max, _reservedSeq.get(dir) ?? 0) + 1
+  _reservedSeq.set(dir, seq)
+  return seq
+}
+
+/** 开关（D-TR6）：traces.enabled 缺省 on（默认全采集）；logCtx.traces === false
+ *  显式关闭（调用点读取 agent.config.traces.enabled——D-TR6）。 */
+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
+  }
+  return value
+}
+
+/**
+ * 收集一次 chat 调用轨迹（D-TR1 字段集）——fire-and-forget（F-TR3）。
+ * 由 core.mjs chat() 导出出口调用（唯一采集点——N-TR2）；签名零参数膨胀——
+ * 数据全部来自调用方已传入的 opts（logCtx 元数据——D-TR4）+ provider + result/error。
+ *
+ * @param {Object} provider chat() 的 provider 参数（provider/model 字段来源）
+ * @param {Object} opts chat() 原始 opts —— messages（输入）与 logCtx（元数据：
+ *   role/depth/kind/session/cwd/stage/turn/traces——调用点增补，D-TR4）
+ * @param {Object|null} result chatImpl 返回值（成功路径——content/reasoning/
+ *   toolCalls/usage/finishReason；N-TR3：出口汇总——续写/重试后全量）
+ * @param {Error|null} error chat() 抛出的错误（失败路径——D-TR5：error（errText
+ *   截断 + 类别）+ finishReason:null——失败轨迹恰是分析纠结点最有效的材料）
+ */
+export function recordChatTrace(provider, opts = {}, result = null, error = null) {
+  if (!writeEnabled()) return
+  const logCtx = opts.logCtx ?? {}
+  if (!tracesEnabled(logCtx)) return
+  // cwd/session 经 logCtx 增补（调用点传 agent.cwd / agent._sessionStart——
+  // D-TR3 的 cwdHash/命名与 D-TR1 的 session 字段所需）；无 agent 作用域的调用点
+  // 回退 process.cwd()——CLI 会话即工作区。该类点开关状态：distill 已含
+  // traces 开关（D-TR6 fix round1）；auto-think 已闭环（D-TS12——chat 调用点
+  // logCtx 全字段补传：traces/session/cwd/role/depth/kind——无残留点）。
+  const cwd = logCtx.cwd ?? process.cwd()
+  // D-TR3（fix round1）：分日按本地时区（_traceHooks.now——T-TR12 注入点）；
+  // ts 与 dateStr 同源（同一时刻）——记录时间戳与目录日不撕裂。
+  const now = _traceHooks.now()
+  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,
+  }
+  if (error != null) {
+    // D-TR5：错误路径轨迹——error（errText 截断 + 类别）+ finishReason:null
+    record.error = {
+      err: redactValue("err", errText(error, 500)),
+      kind: classifyErr(error, opts.signal),
+    }
+  }
+  // 真 fire-and-forget（F-TR3——模型调用路径零额外阻塞）：seq 已在上面同步预留
+  // （原子号位——写盘在途并发不撞号）；写盘异步（不 await——chat() 出口立即返回）。
+  // 返回值 = 落盘 promise（测试 await 用；chat() 不消费——fire-and-forget 语义）。
+  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")
+    } catch {
+      // F-TR3：落盘失败静默降级——不抛错、不阻塞 chat() 返回
+    }
+  })()
+}
+
+/**
+ * D-TR10（2026-09-05 用户裁定——发布隐私 + 磁盘卫生）：启动清理——删除 traces 根下
+ * mtime 超过保留期的轨迹文件（保留期 = config.traces.retentionHours，默认 24h）；
+ * 删空的日期目录（YYYY-MM-DD）。目录里非 .jsonl 文件不碰。CLI 启动点 fire-and-forget
+ * 调用（不 await——不阻塞启动——失败静默——与轨迹写盘同纪律）。返回删除文件数。
+ */
+export async function cleanupTraces({ dir = tracesRoot(), retentionHours = 24 } = {}) {
+  const cutoff = Date.now() - retentionHours * 3_600_000
+  let days
+  try { days = await readdir(dir) } catch { return 0 } // 目录不存在/不可读 → 无事可做
+  let removed = 0
+  for (const day of days) {
+    const dayDir = join(dir, day)
+    try { if (!(await stat(dayDir)).isDirectory()) continue } catch { continue }
+    let names
+    try { names = await readdir(dayDir) } catch { continue }
+    for (const n of names) {
+      if (!n.endsWith(".jsonl")) continue
+      try {
+        if ((await stat(join(dayDir, n))).mtimeMs < cutoff) { await unlink(join(dayDir, n)); removed++ }
+      } catch { /* 单个文件失败不影响其余 */ }
+    }
+    try { if ((await readdir(dayDir)).length === 0) await rmdir(dayDir) } catch {}
+  }
+  return removed
+}

package/src/tui/agent-turn.mjs

@@ -7,35 +7,79 @@
  * + flushStream）在 tool-events.mjs buildToolCallbacks；子agent 区块缓冲与完成冻结
  * （routeSub* / finishSubTask / freeze*SubTasks）在 subagent-blocks.mjs；标题生成
  * 在 generate-title.mjs ensureSessionTitle。
+ *
+ * 2026-09-05 module-split：§17 挂起会话段（suspensionSession/digestTurn/poolLive/
+ * poolCounts 等——agent-turn.mjs 535 > 500 硬限）verbatim 迁至 suspension-drive.mjs——
+ * 本文件回合尾经 suspensionSession 进入驱动器；驱动器内 digest/用户回合经 runAgentTurn
+ * 递归回本文件（函数级静态环——模块求值期无顶层调用，环安全——session-slots ↔
+ * session.mjs 同款先例）。
  */
 import { runAgent, ContinueError } from "../agent.mjs"
 import { saveSession } from "../session.mjs"
 import { ansi, C } from "./ansi.mjs"
 import { buildToolCallbacks, sweepToolBlocks } from "./tool-events.mjs"
-import { freezeAllSubTasks } from "./subagent-blocks.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"
 
 /** 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
 
-/** Execute one agent conversation turn (triggered by submit or queue).
- *  Extracted from index.mjs: agent loop + callback construction + error handling + queue processing.
- *  ctx: { agent, state, pushLine, pushLabel, render, scheduleRender,
- *         ensureAssistantLabel, askPermission, askBatchPermission, askQuestion,
- *         handleSlash, summarize } */
-export async function runAgentTurn(ctx, text) {
+/**
+ * LOGGING（docs/design/LOGGING.md）包装：回合骨架事件（turn:start/turn:end——kind
+ * user/auto；result ok/stopped/error）。内层经 _logOutcome 载具回传终止原因（中止/
+ * turn-cap 拒绝/错误 vs 正常完成）——嵌套回合（队列递归/挂起会话内 digest 轮）各自
+ * 新开载具（每次包装调用独立），互不串扰。err:internal = 逃出内层的未分类异常。
+ */
+export async function runAgentTurn(ctx, text, opts = {}) {
+  const kind = opts?.autoTurn ? "auto" : "user"
+  const runOpts = { ...(opts ?? {}) }
+  delete runOpts._logOutcome
+  const carrier = {}
+  runOpts._logOutcome = carrier
+  const t0 = Date.now()
+  logEvent("turn:start", { kind })
+  try {
+    const result = await runAgentTurnInner(ctx, text, runOpts)
+    return result
+  } catch (e) {
+    carrier.result = "error"
+    logEvent("err:internal", { msg: errText(e, 200), where: "runAgentTurn" })
+    throw e
+  } finally {
+    logEvent("turn:end", { kind, ms: Date.now() - t0, result: carrier.result ?? "ok" })
+  }
+}
+
+/** runAgentTurn 本体（LOGGING 包装之外——见上方包装器）。 */
+async function runAgentTurnInner(ctx, text, opts) {
+  const { autoTurn = false, skipSession = false } = opts ?? {}
   const { agent, state, pushLine, pushLabel, render, scheduleRender, ensureAssistantLabel, askPermission, askBatchPermission, askQuestion, handleSlash } = ctx
   // 可注入覆盖（测试用）；默认走真实实现
   const runAgentImpl = ctx.runAgent ?? runAgent
   const saveSessionImpl = ctx.saveSession ?? saveSession
-  pushLabel(`❯ You:`, ansi.bold + C.user)
-  pushLine(text, C.text)
+  // autoTurn（消化轮）：无用户输入——不画 "❯ You:"（系统驱动回合，§17 D-S6）
+  if (!autoTurn) {
+    pushLabel(`❯ You:`, ansi.bold + C.user)
+    pushLine(text, C.text)
+  }
 
   ctx.assistantLabeled = false
   state.processing = true
   state.status = "Processing..."
+  // §17.6（advisor round2 🟡）：回合启动即解除空闲退出武装——exitArmed 只属于空闲态
+  // 双确认，跨回合残留会让"停回合后的 armed 落空穿透 + 陈旧 exitArmed"组合把一次
+  // 意图为全停/退出的按下变成无二次确认的即时退出（key-handler 落空分支落回空闲
+  // 分支时 `!state.exitArmed` 判假即 exit）；计时一并清（key-handler 空闲分支按
+  // ctx.exitArmTimer 有无决定是否重建——陈旧 timer 残留会在回合中途复位新武装）。
+  state.exitArmed = false
+  if (ctx.exitArmTimer) {
+    clearTimeout(ctx.exitArmTimer)
+    ctx.exitArmTimer = null
+  }
   state.streaming = ""
   state.reasoning = ""
   state._advisorBlocks = []
@@ -46,7 +90,27 @@ export async function runAgentTurn(ctx, text) {
   // bounded by the N2 per-child 500-line ring buffer.
   state.currentTool = null
   state.processingStarted = Date.now()
-  state.controller = new AbortController()
+  // §17 偏差修复 #3（会话 abort 全覆盖）：回合链 controller 登记。链头 = 非挂起会话内
+  // 且非释放窗口期（suspended/_suspPending 均 false）开启的回合——登记表清零；队列
+  // 递归回合（_suspPending 置位期）与会话内回合（suspended=true）继续累积。链条内每次
+  // 重建（Ctrl+I 续跑 / ContinueError 续跑 / AUTO 续跑）都登记——挂起会话的 abort 集合
+  // （_sessionAbortAll）必须在会话建立时覆盖进入会话以来的全部 controller：只 abort
+  // 最后一个会让旧 controller 下 spawn 的 async children 逃逸中止（偏差 #3）。
+  // 链头同时清掉上一链条残留的会话句柄（上一链 pool 先 live 后耗尽、未进入会话即结束
+  // 时 _sessionAbort 会滞留——不清理则下一链的会话 signal 指向旧 controller，Ctrl+C
+  // 中止集合漏掉会话期 spawn 的 children）。
+  if (!state.suspended && !state._suspPending) {
+    state._turnControllers = []
+    agent._sessionAbort = null
+    agent._sessionAbortAll = null
+  }
+  state._turnControllers ??= []
+  const makeController = () => {
+    const c = new AbortController()
+    state._turnControllers.push(c)
+    return c
+  }
+  state.controller = makeController()
   state.interruptPrompt = null
   // Refresh status bar every second during processing; also refresh when any
   // subagent block is still running so its header elapsed ticks (§7.2 D4 —
@@ -68,24 +132,55 @@ export async function runAgentTurn(ctx, text) {
   try {
     for (let resume = false; ; resume = true) {
       try {
-        await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume })
+        await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume, autoTurn, suspDriven: true })
         flushStream()
         break // Normal completion, exit loop
       } catch (error) {
         flushStream()
         if (error.name === "AbortError" || state.controller?.signal.aborted) {
-          // Ctrl+I inject: the signal was aborted with an interrupt message — the agent loop
-          // may have already injected it into history, but the aborted signal prevents retry.
-          // Recreate the controller and resume from the same context.
-          if (state.controller?.signal?.reason?.interrupt) {
-            state.controller = new AbortController()
+          const reason = state.controller?.signal?.reason
+          // §17.6 D-C1（round1 #1 区分机制——2026-09-03）：interrupt 两种语义——
+          //  有 message（Ctrl+I 注入——key-modes handleInterruptMode）= 重建 controller
+          //  续跑（既有语义——agent loop 已把消息注入 history，中止的 signal 不能重试）；
+          //  无 message（Ctrl+C 首按停回合——key-handler abort({ interrupt: true })
+          //  不带 message——非挂起 processing 态 / 挂起态 digest·会话内回合）
+          //  = 停回合不续跑——池保留由 agent.mjs 回合收尾的 !interrupt 清池条件排除
+          //  实现（D-C2——agent.mjs 零改动）。
+          if (reason?.interrupt && reason?.message) {
+            state.controller = makeController()
             resume = true
             continue
           }
+          if (reason?.interrupt) {
+            // 无 message interrupt 的注入副作用回滚：agent.mjs 中断三段（chat catch /
+            // response.interrupted / 工具执行中断）无条件把 "[User interrupt: <msg>]"
+            // 落 history，对 message 存在性无守卫——无 message 时成为 "[User interrupt:
+            // undefined]" 垃圾上下文（消息注入语义只属于 Ctrl+I 续跑——停回合无注入
+            // 消息）。D-C2 agent.mjs 零改动约束下在回合层回滚尾部垃圾（确定性：中断
+            // 注入恒为最后一条——break 前 history 不再追加）。partial 部分输出不回滚
+            // ——interrupt 家族语义（§2 Ctrl+I 同款"提交部分输出"）——advisor round1
+            // 🟡 裁定：回滚需区分工具/子代理路径的既有完整消息（history 层不可靠）。
+            const h = agent.history
+            while (h?.length > 0 && String(h.at(-1)?.content ?? "") === "[User interrupt: undefined]") h.pop()
+          }
           pushLine("[stopped]", C.warn)
+          if (opts?._logOutcome) opts._logOutcome.result = "stopped"
           break
         }
         if (error instanceof ContinueError) {
+          if (autoTurn) {
+            // §17 digest turn-cap 规则（D-S9 ContinueError 行）：无面板——AUTO 档按
+            // §2 统一规则自动 resume（无人值守授权）；手动档静默拒绝（部分消化留在
+            // 历史，会话回挂起——结果不丢，只是不再烧轮次）。
+            if (agent.autoApprove) {
+              pushLine("[auto-turn: continuing past turn cap…]", C.dim)
+              state.controller = makeController()
+              continue
+            }
+            pushLine(`[auto-turn stopped at ${error.turn} turns — partial digest; finished reports stay in history]`, C.warn)
+            if (opts?._logOutcome) opts._logOutcome.result = "stopped"
+            break
+          }
           pushLabel(`❯ Continue`, ansi.bold + C.warn)
           pushLine(`Ran ${error.turn} turns (limit ${error.turn}). Continue?`, C.warn)
           // Pause to ask: reuse permission mechanism
@@ -101,14 +196,16 @@ export async function runAgentTurn(ctx, text) {
           state.permission = null
           if (!willContinue) {
             pushLine("[continue cancelled]", C.warn)
+            if (opts?._logOutcome) opts._logOutcome.result = "stopped"
             break
           }
           pushLine("[continuing…]", C.tool)
           // Recreate AbortController: once aborted, resume immediately fails (defensive; current path unreachable but tightly coupled)
-          state.controller = new AbortController()
+          state.controller = makeController()
           continue
         }
         pushLine(`[error] ${error.message}`, C.error)
+        if (opts?._logOutcome) opts._logOutcome.result = "error"
         break
       }
     }
@@ -116,10 +213,40 @@ export async function runAgentTurn(ctx, text) {
     clearInterval(ticker)
     state.processing = false
     state._advisorBlocks = []
-    // Interrupted runs (Ctrl+C abort / error mid-turn): still-running child blocks
-    // would linger as pinned ghosts above the input box — freeze them like normal
-    // completions so the trace scrolls away with the conversation (2026-08-30).
-    freezeAllSubTasks(state)
+    // §17 D-S1/D-S8：回合正常结束且后台池仍 live → 挂起会话：子agent 区块保持 live
+    // （不冻结——各 settle 事件自行处理），本次回合 controller 交会话层作 abort 句柄
+    // （挂起期 Ctrl+C 中止全部后台子代理）；池空 / 中断 / 错误 → 现状 freezeAllSubTasks
+    // （中断态块标 interrupted；正常态块已在 settle 时各自冻结）。
+    const willSuspend = poolLive(agent)
+    // §17.5.5：挂起会话内回合（digest/会话内用户回合——skipSession 且 suspended）的
+    // 收尾**不冻结驻留块**——已消化（pinned 且条目已注入）块由 suspensionSession 在
+    // run 返回后 freezeReclaimDigestedBlocks 逐条回收（settle 锚点 splice——digest 总览文本
+    // 之前——round1 #1 裁定，不等池空）；
+    // 未消化残项由会话退出 freezeAllSubTasks 兜底。若无此例外，池空的 digest 回合会在
+    // finally 抢先按 settle 锚点冻结（旧池空补发语义）——回收时序被抢占（T-S6）。
+    const inSessionTurn = skipSession && state.suspended
+    if (!willSuspend && !inSessionTurn) {
+      // Interrupted runs (Ctrl+C abort / error mid-turn): still-running child blocks
+      // would linger as pinned ghosts above the input box — freeze them like normal
+      // completions so the trace scrolls away with the conversation (2026-08-30).
+      freezeAllSubTasks(state)
+    } else if (!agent._sessionAbort) {
+      agent._sessionAbort = state.controller // 会话 abort 句柄（children 共享此 signal）
+    }
+    // §17 偏差修复 #1（回合释放窗口守卫）：willSuspend 判定后、进入任何 await 之前置位
+    // 挂起待定标志。suspensionSession 真正启动前还有真实 await（ensureSessionTitle /
+    // distill flush ≤5s / saveSession），其间 processing=false 且 suspended 尚未置位——
+    // 无此标志 key-handler Enter 会走 submit 并发开第二个 runAgentTurn（双驱动器竞态：
+    // 两个 runAgent 循环同时 pushReal 同一 agent.history，工具配对/上下文交错）。标志
+    // 有效区间 = 释放窗口（suspensionSession 启动即清除）；会话内回合（skipSession）
+    // 由 state.suspended 覆盖；_suspAborted 时挂起会话不会启动（下方会话入口同条件）。
+    state._suspPending = willSuspend && !skipSession && !state._suspAborted
+    // §17 偏差修复 #3（会话 abort 全覆盖）：abort 集合快照 = 本链条内全部 controller
+    // （含 Ctrl+I/ContinueError 重建的旧 controller——其下 spawn 的 async children 持旧
+    // signal，Ctrl+C 只 abort 最后一个会让它们跑完整个 turn 预算，正常完成后仍
+    // mergeChildMutations 写父 guard 标记，绕过 advisor/verify 门）。会话内回合的 finally
+    // 会重复快照（链条累积），幂等。
+    if (willSuspend) agent._sessionAbortAll = [...(state._turnControllers ?? [])]
     // Tool-block carriers get the same sweep (P0-2, 2026-08-30 consult): without
     // an onToolResult their header would say "running" forever; ticks are cleared
     // so no stale start time leaks into the next turn.
@@ -156,17 +283,42 @@ export async function runAgentTurn(ctx, text) {
     render()
   }
 
-  // Queued messages: auto-process next one
+  // §17 偏差 #1 兜底：释放窗口期 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) })))
+  }
+
+  // Queued messages: auto-process next one（§24 D-24c/R15：攒批合并——合并仅限
+  // 连续文本——/cmd 逐条保序即时——单条超长直发；每条 runAgentTurn 回合后余项
+  // 由递归层的本循环续取——边界幂等不丢）
   while (state.queue.length > 0 && !state.processing) {
-    const next = state.queue.shift()
-    // Queued slash commands execute directly — check every item, not just the first
-    if (next.text.startsWith("/")) {
-      await handleSlash(next.text)
+    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") {
+      await handleSlash(head.text)
       render()
       continue
     }
     pushLabel(`❯ You: (from queue)`, ansi.bold + C.user)
-    await runAgentTurn(ctx, next.text)
+    await runAgentTurn(ctx, head.text)
     return
   }
+
+  // §17 D-S2: 回合尾后台池非空 → 挂起会话（D-S9 状态机——输入放开、settle 驱动
+  // auto-turn 消化、池空自然退出回 idle）。skipSession：会话内回合（消化轮/会话内
+  // 用户回合）由 suspensionSession 统一调度，不再递归进入新会话。
+  if (!skipSession && poolLive(agent) && !state._suspAborted) {
+    await suspensionSession(ctx)
+    // §17 round2 偏差 #1（_suspAborted 粘滞，code review round2 #1）：挂起会话退出
+    // （自然耗尽或 Ctrl+C 中止）即复位中止标志——中止 unwind 已完成、池已清空/耗尽，
+    // 复位不会误触发重入。不清则 _suspPending 守卫与下方会话入口被同一标志永久门控：
+    // 中止后用户再 spawn async、回合尾池再 live 时永不再次进入挂起态（suspensionSession
+    // 首行复位成死代码）——子代理结果退化到"下个回合尾才注入"、状态行/自动消化/区块
+    // 驻留全消失；释放窗口守卫同步失效（Enter 并发开第二个 runAgentTurn——双驱动器
+    // 竞态复现）。
+    state._suspAborted = false
+  }
 }

package/src/tui/clipboard.mjs

@@ -71,17 +71,28 @@ function spawnWait(spawn, cmd, args, stdinText) {
 }
 
 /** Insert pasted text into the active text target.
- *  Free-text question active → append to its answer (single-line field: newlines stripped).
+ *  Free-text question active → splice into its answer at cursor (codepoint array; \r\n runs
+ *  collapse to spaces — single-line field invariant, text preserved).
  *  Options question active → ignore (no text field; must not leak into the input box).
  *  Otherwise → splice into the main input box at cursor (newlines kept, tabs → 2 spaces).
  *  Shared by bracketed paste (stdin data handler) and Ctrl+V clipboard read,
- *  so pasted content lands in the same place regardless of how the terminal delivered it. */
-export function insertPastedText(state, rawText) {
+ *  so pasted content lands in the same place regardless of how the terminal delivered it.
+ *  activeQuestion（异步 Ctrl+V 路径传发起时的 q）：目标 question 已关闭/被换（Esc 中止后
+ *  readClipboardText 才 resolve）→ 整段丢弃——不得落主输入框（审计 F1 竞态守卫）。 */
+export function insertPastedText(state, rawText, activeQuestion = null) {
   if (!rawText) return
+  if (activeQuestion !== null && state.question !== activeQuestion) return // stale async paste（Esc/Enter 后到达）
   const q = state.question
   if (q) {
     if (q.options.length > 0) return
-    q.answer = (q.answer ?? "") + rawText.replace(/[\r\n]+/g, "")
+    // 自由文本态（TUI-INPUT-BOX.md §7.2 round2 #1/#2/#9）：answer 是 codepoint 数组——
+    // 粘贴落 cursor 位置；\r\n/\r 折叠为空格、\t → 2 空格（单行不变式硬守卫：不劈行、
+    // 不吞文本——粘贴文本保字）。options 态无文本字段——不落输入框。
+    if (!Array.isArray(q.answer)) q.answer = q.answer ? [...q.answer] : []
+    const cur = Math.max(0, Math.min(q.cursor ?? q.answer.length, q.answer.length))
+    const chars = [...rawText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n+/g, " ").replace(/\t/g, "  ")]
+    q.answer.splice(cur, 0, ...chars)
+    q.cursor = cur + chars.length
     return
   }
   // IKBU3J (2026-08-28)：Ctrl+I 注入框激活时，粘贴进注入文本（与按键路径同语义：去换行保单行），