thincoder 0.12.60 → 0.12.61

package/src/tools/question.mjs

@@ -0,0 +1,26 @@
+import { DESC } from "./shared.mjs";
+
+export const questionTool = {
+  name: "question",
+  description: DESC("question"),
+  parameters: {
+    type: "object",
+    properties: {
+      question: { type: "string", description: "The question to ask the user" },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Single-choice options for the user to pick from (optional)",
+      },
+    },
+    required: ["question"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    if (!ctx.onQuestion) throw new Error("question tool not supported in this context (no UI to ask)")
+    // §22 D-Q3 机械限制（2026-09-06 用户裁定：100 字符 / 4 条——超限拒绝回模型，不弹卡、不调 onQuestion）
+    if (args.question.length > 100) return "(error: question too long (>100 chars) — ask ONE short question; background belongs in your normal reply text)"
+    if (Array.isArray(args.options) && args.options.length > 4) return "(error: too many options (>4) — offer at most 4 plain-string options)"
+    return ctx.onQuestion(args.question, args.options ?? [])
+  },
+}

package/src/tools/read.md

@@ -11,7 +11,7 @@ Read a text file. Returns numbered lines. Use offset/limit to page large files.
 Parameters:
 - path (required): File path, relative to cwd or absolute (alias: filePath)
 - offset: 1-based line number to start reading from
-- limit: Max lines to return (default 2000)
+- limit: Max lines to return (default 2000) — windows over files beyond that return head + `…(truncated: K lines in middle, use offset to continue)` + the file's real tail lines, so the file end is never hidden
 - hashes: Include SHA256 content hashes per line (for hashline_edit). Set true before using hashline_edit.
 
 Notes:

package/src/tools/read_image.md

@@ -5,4 +5,4 @@ Parameters:
 
 Notes:
 - Raster formats only (png/jpg/gif/webp): no mainstream vision API (Kimi, Anthropic, OpenAI, Gemini) accepts svg or bmp, and an unsupported image part in history makes every subsequent request fail with 400. svg files are returned as text source instead (readable by any model); bmp is rejected — convert to PNG first.
-- This tool only works with models that support vision/image input (Kimi K3, Qwen3.8, MiniMax M3, GLM-5.3-Flash). Pure text models (DeepSeek V4, GLM-5) will receive an error — except svg, which needs no vision support since it is read as text.
+- This tool only works with models that support vision/image input (capability is spec-driven — the model spec decides, not a hardcoded list). Models without vision support will receive an error — except svg, which needs no vision support since it is read as text.

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/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)
 }

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,4 +1,5 @@
 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. */
@@ -12,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
@@ -43,50 +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 代理无需重启即生效）。
    *  D-F5b：磁盘新鲜读 → mutate → 写前 mtime 门控（writeConfigAtomic——冲突放弃 +
    *  .bak 留现场）；冲突时先 reloadConfig 采纳磁盘新值再 throw——调用方 try/catch
-   *  统一展示 "Save failed: config changed on disk concurrently — retry"。 */
+   *  统一展示 "Save failed: config changed on disk concurrently — retry"。
+   *  写链走 ctx.persistRaw（与 TUI 其余 config 写点同源——createConfigHelpers 的
+   *  configPath 测试注入缝随之生效；生产 = 同一 writeConfigAtomic 调用）。 */
   async function saveProxy(mutate) {
-    const { writeConfigAtomic, configPath } = await import("../config.mjs")
-    const r = writeConfigAtomic(configPath, mutate)
+    let failure = null
+    try { await persistRaw(mutate) } catch (e) { failure = e }
     await reloadConfig()
-    if (!r.ok) throw new Error("config changed on disk concurrently — retry")
+    if (failure) throw failure
   }
 
   // ── Proxy sub-menu loop：每轮重建 entries 显示最新状态，defaultIndex 记住上次位置 ──
@@ -231,19 +242,21 @@ export async function handleConfigCommand(ctx, args = []) {
     }
   }
 
-  // ── 并发池子菜单（§24 D-24a/R14——agent.poolLimits——读/改两域；保存经 saveProxy
+  // ── 并发池子菜单（§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 的耦合由 T-24a4 锚定断言锁住——防默认值单侧漂移）
-      const cur = (k) => (Number.isInteger(pl[k]) && pl[k] >= 1 ? pl[k] : DEFAULTS.agent.poolLimits[k])
+      // 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")}（默认 4/4——分域互不阻塞——超限排队）` },
+        { 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 返回主菜单
@@ -252,11 +265,62 @@ export async function handleConfigCommand(ctx, args = []) {
       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"), [c.action]: num }
+      // 写盘全对象（三键——未触碰的键带当前值重写——全非法/空输入不改动）
+      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.agent ??= {}; raw.agent.poolLimits = { engCoder: next.engCoder, other: next.other } })
+        await saveProxy((raw) => { raw.defaultModel = `${c.provider}:${me.model}` })
         pushLabel("❯ Config", ansi.bold + C.tool)
-        pushLine(`agent.poolLimits = { engCoder: ${next.engCoder}, other: ${next.other} }（下个 spawn 生效——分域互不阻塞）`, C.tool)
+        pushLine(`config.defaultModel = ${c.provider}:${me.model}（新会话起点；会话模型不受影响）`, C.tool)
       } catch (error) { pushLine(`Save failed: ${error.message}`, C.error) }
     }
   }
@@ -271,13 +335,14 @@ export async function handleConfigCommand(ctx, args = []) {
     tc = agent.config?.traces ?? {}
     const consultCount = (ac.consultModels ?? []).length
     const pl = ac.poolLimits ?? {}
-    const cur = (k) => (Number.isInteger(pl[k]) && pl[k] >= 1 ? pl[k] : DEFAULTS.agent.poolLimits[k])
+    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")}（async 分域上限）`, action: "pool" },
+      { 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" },
@@ -295,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)
@@ -304,7 +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")} }（async 分域上限——默认 4/4——agent.poolLimits 可配）`, 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)
@@ -328,6 +394,11 @@ export async function handleConfigCommand(ctx, args = []) {
       continue
     }
 
+    if (choice.action === "defaultModel") {
+      await defaultModelMenu()
+      continue
+    }
+
     if (choice.action === "embedkey") {
       await setEmbedKey() // 保存成功/取消都回主菜单（Esc 退出）
       continue