thincoder 0.12.59 → 0.12.61

package/src/tui/agent-turn.mjs

@@ -1,6 +1,5 @@
 /**
- * agent-turn.mjs — runAgentTurn：一个用户回合的驱动器（submit / 队列递归入口）
- * + §17 挂起会话（suspensionSession：async 子代理后台运行期间主会话可继续对话）。
+ * agent-turn.mjs — runAgentTurn：一个用户回合的驱动器（submit / 队列递归入口）。
  *
  * 2026-08-30 拆分（回回 500 行硬限）：回合生命周期（状态复位 → runAgent 循环 →
  * 错误/Continue/中断处理 → finally 收尾 → 队列）留在这里；工具事件 → TUI 状态的
@@ -9,35 +8,36 @@
  * （routeSub* / finishSubTask / freeze*SubTasks）在 subagent-blocks.mjs；标题生成
  * 在 generate-title.mjs ensureSessionTitle。
  *
- * §17（2026-09-02，AGENT-LOOP.md §17 D-S1..S9）：回合尾后台池非空 → 不阻塞等待，
- * 进入挂起态——输入放开（Enter = 新回合 / digest 中 Enter 排队 pendingInput）、
- * settle 事件驱动 auto-turn 消化（手动档 organize-only / AUTO 档全语义）、池空 + 无
- * 待处理输入 → 补发 done 冻结自然退出。状态机行表见 AGENT-LOOP.md §17 D-S9。
+ * 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, freezeReclaimDigestedBlocks } 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 } 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
 
-/** 后台池计数（LOGGING susp/digest 事件字段——pendingN/poolN）。
- *  poolN = _asyncSubagents map 大小（queued 条目同样在 map 内——2026-09-03 code
- *  review #2：不再 +queue.length 双计；与 vscode suspension poolCounts 口径一致）。 */
-function poolCounts(agent) {
-  const map = agent?._asyncSubagents
-  const running = map ? [...map.values()].filter((e) => e.status === "running").length : 0
-  return {
-    poolN: map?.size ?? 0,
-    pendingN: agent?._pendingAsyncResults?.length ?? 0,
-    runningN: running,
-  }
+/**
+ * 第 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
 }
 
 /**
@@ -295,24 +295,26 @@ 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
+  // 交接消息自动续发（INPUT-LOCK 单消息——2026-09-09）：submit 不再排队（busy 提交吞）
+  // + R15 攒批删——state.queue 只剩残项单消息（释放窗口兜底/挂起中止残余——零丢失
+  // 承诺）——逐条直发；斜杠命令直接执行（保序）；回合后的续发由递归层同循环续取。
   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 = state.queue.shift()
+    // 残项斜杠命令直接执行——保序、绝不合并
+    if (head.text.startsWith("/")) {
+      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
   }
 
@@ -330,206 +332,12 @@ async function runAgentTurnInner(ctx, text, opts) {
     // 竞态复现）。
     state._suspAborted = false
   }
-}
-
-// ─── §17 挂起会话（AGENT-LOOP.md §17 D-S2/D-S9 状态机行表）────────────────
-
-/** 后台池存活判据（D-S2/F5 口径）：running/queued 子代理，或已 settle 未注入结果
- *  （_pendingAsyncResults 非空 = D-S3 "未注入"）。回合尾与每次轮末都用它评估退出。 */
-function poolLive(agent) {
-  const map = agent._asyncSubagents
-  return (map && map.size > 0) || (agent._pendingAsyncResults?.length ?? 0) > 0
-}
-
-/** D-S3 ③ 记账清扫：回合边界竞态落下的已 settle 项（settle 回调未及移交——发生在
- *  回合刚结束、_suspended 尚未置位的窗口）补入 pending。幂等：回调已移交的条目已
- *  从 map 删除并带 _inPending 标记，不会重复入列。 */
-function sweepSettledToPending(agent) {
-  const map = agent._asyncSubagents
-  if (!map || map.size === 0) return
-  agent._pendingAsyncResults ??= []
-  for (const e of [...map.values()]) {
-    if (e.done && !e._inPending) {
-      e._inPending = true
-      agent._pendingAsyncResults.push(e)
-      map.delete(String(e.id))
-    }
-  }
-}
-
-/** 等待下一次 settle（running 子代理 promise 完成）或用户唤醒（Enter 入队 / Ctrl+C /
- *  会话 abort）。唤醒器经 state._suspWake 单槽注入；abort 监听兜底。 */
-function waitForSettleOrWake(agent, state) {
-  return new Promise((resolve) => {
-    let finished = false
-    const cleanup = () => {
-      state._suspWake = null
-      const i = (agent._asyncWaiters ?? []).indexOf(w)
-      if (i >= 0) agent._asyncWaiters.splice(i, 1)
-      agent._sessionAbort?.signal.removeEventListener("abort", onAbort)
-    }
-    const finish = (why) => {
-      if (finished) return
-      finished = true
-      cleanup()
-      resolve(why)
-    }
-    const w = () => finish("settle")
-    const wake = () => finish("wake")
-    const onAbort = () => finish("aborted")
-    ;(agent._asyncWaiters ??= []).push(w)
-    state._suspWake = wake
-    if (agent._sessionAbort?.signal.aborted) { onAbort(); return }
-    agent._sessionAbort?.signal.addEventListener("abort", onAbort, { once: true })
-  })
-}
-
-/** 后台模式状态行文本（D-S8；17.5.4 #6 顺手对齐）："后台 N 子代理运行中 · M 完成待消化"
- *  ——"运行中" = running + queued；"完成待消化" = pending 移交项 + §17.5 回合尾留池的
- *  settled 未消费项（挂起会话 sweep 前的可见窗口）。 */
-function backgroundStatusText(agent) {
-  const map = agent._asyncSubagents
-  const running = map ? [...map.values()].filter((e) => e.status === "running").length : 0
-  const queued = agent._asyncQueue?.length ?? 0
-  const pending = agent._pendingAsyncResults?.length ?? 0
-  const doneInPool = map ? [...map.values()].filter((e) => e.done).length : 0 // §17.5 留池未消费
-  const awaiting = pending + doneInPool
-  const active = running + queued
-  return active > 0 || awaiting > 0
-    ? `后台 ${active} 子代理运行中${awaiting ? ` · ${awaiting} 完成待消化` : ""}`
-    : "后台子代理收尾…"
-}
-
-/** 消化轮：系统驱动的 auto-turn（D-S6）。手动档不传权限/问答 handler（D-S7 装配
- *  契约——denied 不弹面板、不悬挂）；AUTO 档沿用普通回调（autoApprove 短路自动
- *  执行）。_suspended 保持 true：消化中 settle 延迟冻结 + 移交 pending。 */
-async function digestTurn(ctx) {
-  const { agent, pushLine } = ctx
-  const manual = !agent.autoApprove
-  pushLine(manual
-    ? "[auto-turn: digesting finished subagent reports…]"
-    : "[auto-turn: continuing background work…]", C.dim)
-  const digestCtx = manual
-    ? { ...ctx, askPermission: null, askBatchPermission: null, askQuestion: null }
-    : ctx
-  // LOGGING：digest:* 事件（D-S9 消化轮边界——LOGGING.md F-L4 挂起态覆盖）
-  const d0 = Date.now()
-  const pend0 = agent?._pendingAsyncResults?.length ?? 0
-  logEvent("digest:start", { pendingN: pend0 })
-  await runAgentTurn(digestCtx, "", { autoTurn: true, skipSession: true })
-  logEvent("digest:end", { pendingN: agent?._pendingAsyncResults?.length ?? 0, ms: Date.now() - d0 })
-}
 
-/**
- * §17 挂起会话驱动（D-S9 行表；由 runAgentTurn 回合尾进入，池空自然退出）：
- * - suspension：池项 settle → 入 pending → 开 auto-turn（合并消化近邻 settle）；
- *   用户 Enter → pendingInput（digest 运行中排队，D-S5）——用户输入优先于 digest；
- * - auto-turn：消化中 settle 不并发开新轮（单 runAgent 循环），轮末按 pending/池态
- *   续开合并消化轮或回挂起；pendingInput 非空 → 以该消息开新回合（不触发新 digest）；
- * - §17.5.5：每次消化/会话内用户回合消费 pending 后 → freezeReclaimDigestedBlocks
- *   逐条冻结回收（消化完成块不滞留面板——不等池空；settle 锚点 splice——digest 总览
- *   文本之前——round1 #1 裁定）；
- * - 退出：池空 + pending 空 + 无待处理输入 → freezeAllSubTasks 补发冻结（仅兜底
- *   未消化残项——17.5.5 块回收与池空解耦）→ idle。
- * _suspended 翻转：会话期 true（settle 回调据此延迟冻结 + 移交 pending）；会话内
- * 用户回合执行期翻 false（普通回合语义：settle 即冻结 + 回合尾直注入 ①）。
- */
-async function suspensionSession(ctx) {
-  const { agent, state, render, pushLine } = ctx
-  state.pendingInput ??= []
-  state._suspAborted = false
-  agent._suspended = true
-  agent._sessionSignal = agent._sessionAbort.signal // 会话内 spawn 的 children 共享（subagent.mjs）
-  state.suspended = true
-  state._suspPending = false // 偏差 #1：进入真正挂起态——标志只在释放窗口期有效（此后由 state.suspended 分流）
-  const suspTick = setInterval(() => {
-    if (state.suspended && !state.processing) {
-      state.status = backgroundStatusText(agent)
-      render()
-    }
-  }, 1000)
-  state.status = backgroundStatusText(agent)
-  render()
-  // LOGGING：susp:* 事件（挂起态进入/退出——F-L4；挂起期输入事件 v1 不记——refinement #1）
-  const s0 = Date.now()
-  logEvent("susp:enter", poolCounts(agent))
-  try {
-    while (!state._suspAborted && !agent._sessionAbort.signal.aborted) {
-      sweepSettledToPending(agent)
-      // 1. 用户输入优先（D-S5）：pendingInput 队列 + 消化期排队的 slash 命令
-      const queuedText = state.pendingInput.length > 0 ? state.pendingInput.shift()
-        : state.queue.length > 0 ? state.queue.shift().text : null
-      if (queuedText) {
-        if (String(queuedText).startsWith("/")) {
-          await ctx.handleSlash?.(queuedText)
-          render()
-          continue
-        }
-        agent._suspended = false // 用户回合 = 普通回合语义（① 直注入 + settle 即冻结）
-        await runAgentTurn(ctx, String(queuedText), { skipSession: true })
-        agent._suspended = true
-        // §17.5.5：该回合消化完 pending（run 首行注入）→ 逐条冻结回收驻留块
-        // （不等池空——settle 锚点 splice——digest 总览文本之前；与 digest 回收同规则）
-        freezeReclaimDigestedBlocks(state, agent._pendingAsyncResults ?? [])
-        state.status = backgroundStatusText(agent)
-        continue
-      }
-      // 2. pending 非空 → 合并消化轮（注入由 runAgent 首行统一完成——D-S3 单注入点）
-      if ((agent._pendingAsyncResults?.length ?? 0) > 0) {
-        await digestTurn(ctx)
-        // §17.5.5 实测修订（2026-09-03）：digest 消化完成（pending 条目已注入）→ 逐条补发
-        // done 冻结回收——不等池空——块从面板移除进流（settle 锚点 splice 落位——digest
-        // 总览文本之前——round1 #1 裁定）；池空 freeze-out 仅兜底未消化残项（挂起会话
-        // 结束统一清场）——块回收与池空解耦（T-H7/AC-H5）。
-        // 归属不变式：会话内任何 run 开始前 pinned 块（awaitingDigest）的条目必在 pending
-        // ——run 消费后不在 pending 的 pinned 块即本 run 消化者（无需快照即精确归属）。
-        freezeReclaimDigestedBlocks(state, agent._pendingAsyncResults ?? [])
-        state.status = backgroundStatusText(agent)
-        continue
-      }
-      // 3. 池空（无 running/queued/未注入）→ 自然退出回 idle（补发冻结在 finally）
-      if (!poolLive(agent)) break
-      // 4. 等下一 settle / 用户唤醒（Enter 入队、Ctrl+C）
-      await waitForSettleOrWake(agent, state)
-    }
-  } finally {
-    clearInterval(suspTick)
-    const aborted = state._suspAborted || agent._sessionAbort.signal.aborted
-    if (aborted && (agent._asyncSubagents?.size ?? 0) > 0) logEvent("ev:stopped", { poolN: agent._asyncSubagents?.size ?? 0, where: "suspension-abort" })
-    logEvent("susp:exit", { ...poolCounts(agent), ms: Date.now() - s0, reason: aborted ? "aborted" : "idle" })
-    agent._suspended = false
-    agent._sessionSignal = null
-    agent._sessionAbort = null
-    agent._sessionAbortAll = null // 偏差 #3：会话期 controller 集合随句柄一并释放
-    state.suspended = false
-    state._suspWake = null
-    state.suspAbortArmed = false // round2 偏差 #4：会话退出即解除挂起中止武装（防跨会话粘滞）
-    if (aborted) {
-      // §15 abort 语义：清池不注入（用户显式停——不注入陈旧错误）
-      agent._asyncSubagents?.clear()
-      agent._asyncQueue = []
-      agent._pendingAsyncResults = []
-      // §17 round2 偏差 #2-CLI（code review round2 #2-CLI）：中止时不静默丢弃挂起期
-      // 排队的用户消息——Enter 已清空输入框并入 pendingInput（用户视为已发送），
-      // 残余转回 state.queue（{text} 条目，下个普通回合的队列循环续发——零丢失）
-      // + 提示行明示去向（不静默丢）。
-      const queuedN = state.pendingInput?.length ?? 0
-      if (queuedN > 0) {
-        state.queue.push(...state.pendingInput.splice(0).map((t) => ({ text: String(t) })))
-        pushLine(`[background work stopped — ${queuedN} queued message${queuedN > 1 ? "s" : ""} will run as a normal turn]`, C.warn)
-      }
-    } else {
-      // D-S3 ③ 兜底：退出前残余（极端竞态）直注入再退——结果零丢失（AC-S2）
-      const residual = agent._pendingAsyncResults
-      if (residual?.length) {
-        const { injectAsyncResult } = await import("../agent-tools/subagent.mjs")
-        for (const e of residual.splice(0)) await injectAsyncResult(agent, e)
-      }
-    }
-    // 补发 done 冻结：驻留面板的 awaiting-digest 块随池空冻结进流（T-S14）
-    freezeAllSubTasks(state)
-    sweepToolBlocks(state)
-    state.status = "Ready"
+  // 第 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)
 }

package/src/tui/clipboard.mjs

@@ -97,8 +97,14 @@ export function insertPastedText(state, rawText, activeQuestion = null) {
   }
   // IKBU3J (2026-08-28)：Ctrl+I 注入框激活时，粘贴进注入文本（与按键路径同语义：去换行保单行），
   // 不得落入主输入框——此前缺失该分支导致粘贴进 state.input、Esc 后残留主输入框。
+  // 第 31 批：注入框 = { chars, cursor } codepoint 模型——粘贴落 cursor 位置（§8.1 键表）。
   if (state.interruptPrompt) {
-    state.interruptPrompt.text += rawText.replace(/[\r\n]+/g, "")
+    const p = state.interruptPrompt
+    if (!Array.isArray(p.chars)) p.chars = p.chars ? [...p.chars] : [] // 形态防御（同 question 面——保文本不丢）
+    const cur = Math.max(0, Math.min(p.cursor ?? p.chars.length, p.chars.length))
+    const chars = [...rawText.replace(/[\r\n]+/g, "").replace(/\t/g, "  ")]
+    p.chars.splice(cur, 0, ...chars)
+    p.cursor = cur + chars.length
     return
   }
   const text = rawText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "  ")

package/src/tui/cmd-advisor.mjs

@@ -86,7 +86,7 @@ export async function handleAdvisorCommand(ctx) {
   async function thinkingPicker() {
     let thinkIdx = 0
     for (;;) {
-      const entries = buildThinkingEntries(agent, cfg)
+      const entries = await buildThinkingEntries(agent, cfg)
       const c = await showPicker("Advisor Thinking", entries, { defaultIndex: thinkIdx })
       if (!c) return
       thinkIdx = Math.max(0, entries.filter((e) => e.type === "item").indexOf(c))
@@ -183,7 +183,8 @@ async function fetchAdvisorModels(agent) {
   const result = new Map()
   await Promise.all((agent.providers || []).map(async (p) => {
     try {
-      const models = await listModels({ baseURL: p.baseURL, apiKey: p.apiKey ?? "" }, { signal: AbortSignal.timeout(10000) })
+      // format 透传（M1 分派依据——claude/gemini 走 anthropic/google 拉取分支）
+      const models = await listModels({ baseURL: p.baseURL, apiKey: p.apiKey ?? "", format: p.format }, { signal: AbortSignal.timeout(10000) })
       result.set(p.name, { models, error: null })
     } catch (err) {
       result.set(p.name, { models: [], error: err.message.slice(0, 40) })

package/src/tui/cmd-config.mjs

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs"
 import { ansi, C } from "./ansi.mjs"
+import { probeChannelModels, dedupeModels } from "./model-catalog.mjs"
 /** Merge an embedding-key save into the raw config, backfilling baseURL/model from defaults.
  *  Keeps existing custom values (Ollama/local embedding); defaults are the single source
  *  (TUI.md §9.3D — NF1). Exported for unit tests. */
@@ -13,6 +13,13 @@ export function embeddingPatch(raw, embKey, defaults) {
   }
 }
 
+/** 并发池三键当前值读取（POOL-CONFIG-UNIFIED F-3——2026-09-09）：配置值合法（≥1 整数）
+ *  读配置——非法/缺省回退 DEFAULTS（agent.poolLimits 三键——/config 并发池子菜单/
+ *  主菜单/view 三面共用同一读取——config-pool.test.mjs 单测面）。 */
+export function poolCur(pl, defaults) {
+  return (k) => (Number.isInteger(pl?.[k]) && pl[k] >= 1 ? pl[k] : defaults.agent.poolLimits[k])
+}
+
 /** /config command: view and set agent/embedding/proxy config. */
 export async function handleConfigCommand(ctx, args = []) {
   const { agent, pushLine, pushLabel, showPicker, askQuestion, persistRaw, maskKey, pickModelForSlot } = ctx
@@ -31,9 +38,10 @@ export async function handleConfigCommand(ctx, args = []) {
   async function setEmbedKey() {
     const embKey = await askQuestion("Enter embedding API key (default: SiliconFlow bge-m3):")
     if (!embKey) return false
+    // D-F5b 语义先盘后存（embeddingPatch 在磁盘 fresh raw 上合并——冲突放弃不留 ghost）
+    await persistRaw((raw) => { raw.embedding = embeddingPatch(raw, embKey, DEFAULTS.embedding) })
     agent.config.embedding ??= {}
     agent.config.embedding.apiKey = embKey
-    await persistRaw((raw) => { raw.embedding = embeddingPatch(raw, embKey, DEFAULTS.embedding) })
     if (agent.memory) {
       const { createEmbedder } = await import("../embedding.mjs")
       agent.memory.embedder = createEmbedder(agent.config.embedding)
@@ -43,48 +51,53 @@ export async function handleConfigCommand(ctx, args = []) {
     return true
   }
 
-  /** 保存后的公共重载：loadConfig → injectProxy → 恢复 provider 选择。
-   *  运行时 /model 切过 provider（未落盘）时保持它，不回滚到磁盘值。 */
+  /** 保存后的公共重载：loadConfig → injectProxy → 恢复运行时 provider 选择。
+   *  MODEL-MERGE-SESSION 三支改写（cfg 无 active*）：运行时由「会话槽复合仍在 providers 中 →
+   *  保持槽值」或「config defaultModel（新会话起点）」决定——不再有渠道默认字段可回退。 */
   async function reloadConfig() {
     const { loadConfig } = await import("../config.mjs")
     const { injectProxy } = await import("../proxy.mjs")
     const cfg = loadConfig()
     injectProxy(cfg.providersList, cfg)
-    const runtimeName = agent.activeProvider
-    const runtimeModel = agent.activeModel
+    const sessionName = agent.activeProvider
+    const sessionModel = agent.activeModel
     agent.providers = cfg.providersList
     agent.config = cfg
     agent.config.agent ??= {}
-    const keep = cfg.providersList.find((p) => p.name === runtimeName)
-    if (runtimeName && runtimeName !== cfg.activeProvider && keep) {
-      // 运行时选择在新配置里仍存在 → 保持（provider 为注入 proxyUri 后的新对象）
-      agent.activeProvider = runtimeName
-      agent.activeModel = runtimeModel
+    const keep = sessionName ? cfg.providersList.find((p) => p.name === sessionName) : null
+    if (keep) {
+      // 会话 provider 仍存在 → 会话复合优先（槽值——不看 cfg 默认；模型空时落默认复合/渠道默认单值）
+      const dm = cfg.provider.name ? cfg.provider : null
+      const model = sessionModel ?? (dm && dm.name === sessionName ? dm.model : keep.model ?? "")
+      agent.activeProvider = keep.name
+      agent.activeModel = model || null
       agent.provider = { ...keep }
-      if (agent.activeModel) agent.provider.model = agent.activeModel
-    } else if (runtimeName && runtimeName === cfg.activeProvider && runtimeModel) {
-      // Same provider, runtime had a model override — keep it
-      agent.activeProvider = cfg.activeProvider
-      agent.activeModel = runtimeModel
-      const p = cfg.providersList.find((pr) => pr.name === cfg.activeProvider)
-      agent.provider = p ? { ...p } : cfg.provider
-      agent.provider.model = runtimeModel
-      agent.provider.proxyUri = p?.proxyUri
+      agent.provider.model = model
     } else {
-      agent.activeProvider = cfg.activeProvider
-      agent.activeModel = cfg.activeModel ?? null
-      agent.provider = cfg.provider
-      agent.provider.proxyUri = cfg.providersList.find((p) => p.name === cfg.activeProvider)?.proxyUri
+      // 会话 provider 没了（D-S3 静默保留处置）/尚未选 → 采纳 config defaultModel 运行时
+      agent.activeProvider = cfg.provider.name ?? ""
+      agent.activeModel = cfg.provider.model ?? null
+      agent.provider = cfg.provider.name ? { ...cfg.provider } : {}
+    }
+    // 运行时重建后同步注入结果（cfg.provider 系 loadConfig 内建——injectProxy 后建）
+    agent.provider.proxyUri = cfg.providersList.find((p) => p.name === agent.activeProvider)?.proxyUri
+    if (agent.config?.agent?.compactThresholdAuto) {
+      const { resolveCompactThreshold } = await import("../config.mjs")
+      agent.config.agent.compactThreshold = resolveCompactThreshold(null, agent.provider).value
     }
   }
 
-  /** 保存 config（mutate 改 raw）→ reloadConfig（provider 代理无需重启即生效） */
+  /** 保存 config（mutate 改 raw）→ reloadConfig（provider 代理无需重启即生效）。
+   *  D-F5b：磁盘新鲜读 → mutate → 写前 mtime 门控（writeConfigAtomic——冲突放弃 +
+   *  .bak 留现场）；冲突时先 reloadConfig 采纳磁盘新值再 throw——调用方 try/catch
+   *  统一展示 "Save failed: config changed on disk concurrently — retry"。
+   *  写链走 ctx.persistRaw（与 TUI 其余 config 写点同源——createConfigHelpers 的
+   *  configPath 测试注入缝随之生效；生产 = 同一 writeConfigAtomic 调用）。 */
   async function saveProxy(mutate) {
-    const raw = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf8")) : {}
-    mutate(raw)
-    const { saveConfig } = await import("../config.mjs")
-    saveConfig(raw)
+    let failure = null
+    try { await persistRaw(mutate) } catch (e) { failure = e }
     await reloadConfig()
+    if (failure) throw failure
   }
 
   // ── Proxy sub-menu loop：每轮重建 entries 显示最新状态，defaultIndex 记住上次位置 ──
@@ -229,6 +242,89 @@ export async function handleConfigCommand(ctx, args = []) {
     }
   }
 
+  // ── 并发池子菜单（§11.1/§11.2——agent.poolLimits——读/改三域；保存经 saveProxy
+  // 落盘 + reloadConfig 热应用——下个 spawn 生效）──
+  async function poolMenu() {
+    let poolIdx = 0
+    for (;;) {
+      const pl = agent.config?.agent?.poolLimits ?? {}
+      // 显示回退与默认同源（DEFAULTS.agent.poolLimits——配置 DEFAULTS 与运行时回退常量
+      // ASYNC_POOL_LIMITS/ADVISOR_POOL_LIMIT 的耦合由 T-24a4 锚定断言（config-pool.test.mjs）
+      // 锁住——防默认值单侧漂移）
+      const cur = poolCur(pl, DEFAULTS)
+      const entries = [
+        { type: "header", text: `Async pools: eng-coder ${cur("engCoder")} / other ${cur("other")} / advisor ${cur("advisor")}（默认 4/4/4——分域互不阻塞——subagent 超限排队/advisor 超限即拒）` },
+        { type: "item", text: `eng-coder 池上限 = ${cur("engCoder")}`, action: "engCoder" },
+        { type: "item", text: `其他角色池上限 = ${cur("other")}`, action: "other" },
+        { type: "item", text: `advisor 评审池上限 = ${cur("advisor")}`, action: "advisor" },
+      ]
+      const c = await showPicker("并发池（agent.poolLimits）", entries, { defaultIndex: poolIdx })
+      if (!c) return // Esc 返回主菜单
+      poolIdx = Math.max(0, entries.filter((e) => e.type === "item").indexOf(c))
+      const val = await askQuestion(`${c.action} pool limit (current: ${cur(c.action)} — positive integer ≥1):`)
+      if (!val) continue // 空输入不改动
+      const num = Number(val)
+      if (!Number.isInteger(num) || num < 1) { pushLine("Pool limit must be a positive integer (≥1)", C.error); continue }
+      // 写盘全对象（三键——未触碰的键带当前值重写——全非法/空输入不改动）
+      const next = { engCoder: cur("engCoder"), other: cur("other"), advisor: cur("advisor"), [c.action]: num }
+      try {
+        await saveProxy((raw) => { raw.agent ??= {}; raw.agent.poolLimits = { engCoder: next.engCoder, other: next.other, advisor: next.advisor } })
+        pushLabel("❯ Config", ansi.bold + C.tool)
+        pushLine(`agent.poolLimits = { engCoder: ${next.engCoder}, other: ${next.other}, advisor: ${next.advisor} }（下个 spawn 生效——分域互不阻塞）`, C.tool)
+      } catch (error) { pushLine(`Save failed: ${error.message}`, C.error) }
+    }
+  }
+
+  // ── 默认模型子菜单（F-5：config.defaultModel 专用入口——L1 provider → L2 **运行期拉取**候选 →
+  // 写 config.defaultModel——saveProxy/writeConfigAtomic 通道——不落会话槽；不加手输行——O1 已裁）──
+  async function defaultModelMenu() {
+    let idx = 0
+    // M9 配置阶段准入：进本子菜单探一次各渠道 `/models`（复用 M1 + 会话缓存）。
+    // 探通 → 渠道可用 + 候选直接可用；探不通 → 不缓存不阻断（标「不可用」且不入可选来源）。
+    const probes = new Map()
+    pushLine("Fetching channel model lists (GET /models)…", C.dim)
+    await Promise.all(agent.providers.map(async (p) => {
+      const r = await probeChannelModels(p)
+      probes.set(p.name, r)
+      if (r.ok) delete p._unavailable
+      else p._unavailable = true
+    }))
+    for (;;) {
+      const dm = agent.config?.defaultModel ?? null
+      const entries = [
+        { type: "header", text: `config.defaultModel = ${dm ?? "(not set — 新会话起点未配置)"}` },
+        ...agent.providers.map((p) => {
+          const r = probes.get(p.name)
+          if (!r?.ok) return { type: "item", text: `${p.name.padEnd(10)} 不可用`, action: "provider", provider: p.name, unavailable: true }
+          const n = r.list.length
+          // M3③：渠道行显示渠道默认模型（单值）+ 探得候选数
+          return { type: "item", text: `${p.name.padEnd(10)} ${p.model ?? "(no default model)"} (${n} model${n === 1 ? "" : "s"})`, action: "provider", provider: p.name }
+        }),
+      ]
+      const c = await showPicker("Default Model (新会话起点)", entries, { defaultIndex: idx })
+      if (!c) return // Esc → 返回主菜单
+      idx = Math.max(0, entries.filter((e) => e.type === "item").indexOf(c))
+      if (c.action !== "provider") continue
+      const r = probes.get(c.provider)
+      if (!r?.ok) {
+        // 准入判据：探不通的渠道不作为默认模型的可选来源——明示原因（M8 长句），不阻断菜单
+        pushLine(r?.message ?? `${c.provider} 不可用`, C.error)
+        continue
+      }
+      if (r.list.length === 0) { pushLine(`${c.provider}: /models 未返回任何模型`, C.error); continue }
+      const me = await showPicker(`${c.provider} models`, [
+        { type: "header", text: "选为 config.defaultModel（新会话起点——当前会话槽不受影响）" },
+        ...dedupeModels(r.list).map((m) => ({ type: "item", text: m, action: "model", model: m })),
+      ])
+      if (!me) continue // Esc → 回默认模型菜单
+      try {
+        await saveProxy((raw) => { raw.defaultModel = `${c.provider}:${me.model}` })
+        pushLabel("❯ Config", ansi.bold + C.tool)
+        pushLine(`config.defaultModel = ${c.provider}:${me.model}（新会话起点；会话模型不受影响）`, C.tool)
+      } catch (error) { pushLine(`Save failed: ${error.message}`, C.error) }
+    }
+  }
+
   // ── Main config loop ──
   let running = true
   let mainIdx = 0 // 记住上次选中位置，改完一项回主菜单时恢复
@@ -238,11 +334,15 @@ export async function handleConfigCommand(ctx, args = []) {
     ec = agent.config?.embedding ?? {}
     tc = agent.config?.traces ?? {}
     const consultCount = (ac.consultModels ?? []).length
+    const pl = ac.poolLimits ?? {}
+    const cur = poolCur(pl, DEFAULTS)
     const mainEntries = [
       { type: "header", text: `proxy=${proxySummary()} | maxTurns=${ac.maxTurns ?? 200} | compactThreshold=${ac.compactThreshold ?? 100000} | verifyGuard=${ac.verifyGuard === true ? "on" : "off"} | consult=${consultCount} model(s) | embedding=${agent.memory?.embedder ? "on" : "off"} | traces=${tc.enabled === false ? "off" : "on"}` },
       { type: "item", text: `agent.maxTurns = ${ac.maxTurns ?? 200}`, action: "agent.maxTurns" },
       { type: "item", text: `agent.subagentTurns = ${ac.subagentTurns ?? 100}`, action: "agent.subagentTurns" },
+      { type: "item", text: `并发池 agent.poolLimits = engCoder ${cur("engCoder")} / other ${cur("other")} / advisor ${cur("advisor")}（async 分域上限）`, action: "pool" },
       { type: "item", text: `agent.compactThreshold = ${ac.compactThreshold ?? 100000}${agent.config?.agent?.compactThresholdAuto ? " (auto)" : ""}`, action: "agent.compactThreshold" },
+      { type: "item", text: `config.defaultModel = ${agent.config?.defaultModel ?? "(未设置 — 新会话起点)"}`, action: "defaultModel" },
       { type: "item", text: `agent.verifyGuard = ${ac.verifyGuard === true ? "on" : "off"}`, action: "agent.verifyGuard" },
       { type: "item", text: `traces.enabled = ${tc.enabled === false ? "off" : "on"}（轨迹存档——发布默认关——隐私）`, action: "traces.enabled" },
       { type: "item", text: `traces.retentionHours = ${tc.retentionHours ?? 24} h（超期文件启动时清理）`, action: "traces.retentionHours" },
@@ -260,7 +360,8 @@ export async function handleConfigCommand(ctx, args = []) {
 
     if (choice.action === "view") {
       pushLabel("❯ Config", ansi.bold + C.tool)
-      pushLine(`Active: ${agent.activeProvider} / ${agent.provider.model}`, C.dim)
+      pushLine(`Session model: ${agent.activeProvider ? `${agent.activeProvider}:${agent.activeModel ?? ""}` : "(none)"}`, C.dim)
+      pushLine(`defaultModel (config): ${agent.config?.defaultModel ?? "(not set — 新会话起点)"}`, C.dim)
       pushLine(`Key:    ${maskKey(agent.provider.apiKey)}`, C.dim)
       pushLine(`agent.maxTurns: ${ac.maxTurns ?? 200}`, C.dim)
       pushLine(`agent.subagentTurns: ${ac.subagentTurns ?? 100}`, C.dim)
@@ -269,6 +370,7 @@ export async function handleConfigCommand(ctx, args = []) {
       pushLine(`traces.enabled: ${tc.enabled === false ? "off" : "on"}（默认 off——发布隐私——本地分析可开）`, C.dim)
       pushLine(`traces.retentionHours: ${tc.retentionHours ?? 24}（超期文件启动清理——D-TR10）`, C.dim)
       pushLine(`agent.consultModels: ${(ac.consultModels ?? []).map((m) => `${m.provider}:${m.model}${m.effort ? ` (${m.effort})` : ""}`).join(", ") || "(none)"}`, C.dim)
+      pushLine(`agent.poolLimits: { engCoder: ${cur("engCoder")}, other: ${cur("other")}, advisor: ${cur("advisor")} }（async 分域上限——默认 4/4/4——agent.poolLimits 可配）`, C.dim)
       pushLine(`agent.consultTurns: ${ac.consultTurns ?? 40}`, C.dim)
       pushLine(`agent.consultTimeoutMs: ${Math.round((ac.consultTimeoutMs ?? 600000) / 60000)} min`, C.dim)
       pushLine(`embedding: ${agent.memory?.embedder ? `enabled (${ec.model ?? ""})` : "disabled (FTS only)"}`, C.dim)
@@ -287,6 +389,16 @@ export async function handleConfigCommand(ctx, args = []) {
       continue
     }
 
+    if (choice.action === "pool") {
+      await poolMenu()
+      continue
+    }
+
+    if (choice.action === "defaultModel") {
+      await defaultModelMenu()
+      continue
+    }
+
     if (choice.action === "embedkey") {
       await setEmbedKey() // 保存成功/取消都回主菜单（Esc 退出）
       continue