thincoder 0.12.66 → 0.12.68

package/src/tui/agent-turn.mjs

@@ -8,41 +8,48 @@
  * （routeSub* / finishSubTask / freeze*SubTasks）在 subagent-blocks.mjs；标题生成
  * 在 generate-title.mjs ensureSessionTitle。
  *
- * 2026-09-05 module-split：§17 挂起会话段（suspensionSession/digestTurn/poolLive/
+ * 2026-09-05 module-split：AGENT-LOOP-ASYNC-POOL.md §6.8 挂起会话段（suspensionSession/digestTurn/poolLive/
  * poolCounts 等——agent-turn.mjs 535 > 500 硬限）verbatim 迁至 suspension-drive.mjs——
  * 本文件回合尾经 suspensionSession 进入驱动器；驱动器内 digest/用户回合经 runAgentTurn
  * 递归回本文件（函数级静态环——模块求值期无顶层调用，环安全——session-slots ↔
  * session.mjs 同款先例）。
  */
-import { runAgent, ContinueError } from "@thincoder/core/agent.mjs"
+import { runAgent } from "@thincoder/core/agent.mjs"
 import { saveSession } from "@thincoder/core/session.mjs"
+import { continueDecision } from "@thincoder/core/agent/continue-decision.mjs" // #677 · I10 续跑判定单源（#127 ④ 双写退役）
 import { ansi, C } from "./ansi.mjs"
 import { buildToolCallbacks, sweepToolBlocks } from "./tool-events.mjs"
-import { freezeAllSubTasks } from "./subagent-blocks.mjs" // freezeReclaimDigestedBlocks 随 §17 段迁 suspension-drive.mjs
+import { freezeAllSubTasks } from "./subagent-blocks.mjs" // freezeReclaimDigestedBlocks 随 AGENT-LOOP-ASYNC-POOL.md §6.8 段迁 suspension-drive.mjs
 import { ensureSessionTitle } from "@thincoder/core/generate-title.mjs"
 import { logEvent, errText } from "@thincoder/core/log.mjs"
-import { t } from "@thincoder/core/i18n.mjs"
+import { pushRecord } from "@thincoder/core/context.mjs"
 import { suspensionSession, poolLive } from "./suspension-drive.mjs"
+// #726 写点②：cap 行 ∥ cap 记录同点双动作（文案/形 = lifecycle-records 单一实现）
+import { digestCapRecord, digestTraceLines, recordCarrier } from "./lifecycle-records.mjs"
+import { timerWakeArmed } from "./timer-watch.mjs" // §6.30.3 门三件③：在途 timer ∧ 开关开 ⇒ 唤醒会武装
+import { planQueuedInput } from "./queued-merge.mjs"
+import { pickupQueuedAtStepBoundary } from "./queued-pickup.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
 
-/** Provider 失败面 URL 脱敏（X8——判据与 VSC `panel-turn-loop.mjs:153` 同式；两端各自持有
- *  字面 = 双写登记——单源化须动 VSC/核写域，出本批射程，见批档 §2.3）。 */
+/** Provider 失败面 URL 脱敏（X8——判据与 VSC `panel-turn-loop.mjs` 的 `e.message` 首行脱敏处同式；两端各自持有
+ *  字面 = 双写登记——单源化须动 VSC/核写域，出本批射程）。 */
 const PROVIDER_URL_RE = /https?:\/\/[^\s,)"]+/g
 
 /**
  * 第 33 批（TUI §14.3(d)——纯函数，供测试直驱）：回合链尾「需要用户」谓词——agent 已停
  * 且无自动续跑 ⇒ 置 attention 位。排除项语义（F13）：`skipSession`（digest / 会话内回合
  *  ——由外层链尾统一置位）· 挂起两态 / 池 live / 队列非空（自动续跑中——不由用户接手）·
- *  processing（回合在跑）。
+ *  processing（回合在跑）· **在途 timer ∧ 唤醒会武装**（`docs/cli/design/TUI.md` §7.1 awaiting
+ *  行除外 / §7.2 置位谓词——自动续跑在途 ⇒ 不计 awaiting；机判 = T-TW13；timer-wake 批 2026-09-27）。
  *  @returns {boolean}
  */
 export function userNeededAtTurnEnd(state, agent, skipSession) {
   return !skipSession && !state.suspended && !state._suspPending && !poolLive(agent)
-    && state.queue.length === 0 && !state.processing
+    && state.queue.length === 0 && !state.processing && !timerWakeArmed(agent)
 }
 
 /**
@@ -73,14 +80,40 @@ export async function runAgentTurn(ctx, text, opts = {}) {
   }
 }
 
-/** runAgentTurn 本体（LOGGING 包装之外——见上方包装器）。 */
+/** #448② 重武装守卫（KD-6「异常径重武装——会话停 ∕ 显式撤销除外」）：**粘滞位 `_timerRearmRevoked`**
+ *  = 主线（两实落点：Ctrl+C 全停 `{abortTrigger:"stop"}` 中止分支 ∕ 挂起会话中止（`_suspAborted`）复位前捕获；
+ *  链头复位 ⇒ 下一链正常重入）。余两腿为**防御面**（仅在正文异常早退、控制器尚未置空时可达）：
+ *  `_suspAborted` 未及复位 ∥ 本链控制器 stop 语义在场 ∥ 会话 abort 句柄已中止。 */
+function timerRearmBlocked(state, agent) {
+  return state?._timerRearmRevoked === true
+    || state?._suspAborted === true
+    || state?.controller?.signal?.reason?.abortTrigger === "stop"
+    || agent?._sessionAbort?.signal?.aborted === true
+}
+
+/** runAgentTurn 本体（LOGGING 包装之外——见上方包装器）：**链尾收口层**——正文（`runAgentTurnBody`）
+ *  之后收「链尾闩重同步」（§6.30.5 载体②武装点——履行原正文内同点调用；#448②：入 `finally` ⇒
+ *  异常 ∕ 中止逃逸的回合同样重武装；守卫 = `timerRearmBlocked`）。attention 仍在正文链尾原位
+ *  （谓词读 `_pendingTimers`、不读闩状态 ⇒ 与 sync 无相对序依赖）。 */
 async function runAgentTurnInner(ctx, text, opts) {
-  const { autoTurn = false, skipSession = false, upstreamTurn = false } = opts ?? {} // upstreamTurn：上行 ask 唤醒轮旗标（§6.27.12.5 D/I——透传核 runAgent，仅供域文本选择）
+  try {
+    await runAgentTurnBody(ctx, text, opts)
+  } finally {
+    if (!timerRearmBlocked(ctx?.state, ctx?.agent)) ctx?.timerWatch?.sync()
+  }
+}
+
+/** runAgentTurn 正文（原 `runAgentTurnInner` 逐字——唯一改动 = 链尾 `sync()` 上收收口层 `finally`）。 */
+async function runAgentTurnBody(ctx, text, opts) {
+  const { autoTurn = false, skipSession = false, upstreamTurn = false, timerTurn = false } = opts ?? {} // upstreamTurn / timerTurn：系统轮旗标（§6.27.12.5 D/I · §6.30.3 D-TW4）——透传核 `runAgent`，仅供域文本选择
   const { agent, state, pushLine, pushLabel, render, scheduleRender, ensureAssistantLabel, askPermission, askBatchPermission, askQuestion, handleSlash } = ctx
   // 可注入覆盖（测试用）；默认走真实实现
   const runAgentImpl = ctx.runAgent ?? runAgent
   const saveSessionImpl = ctx.saveSession ?? saveSession
-  // autoTurn（消化轮）：无用户输入——不画 "❯ You:"（系统驱动回合，§17 D-S6）
+  // F16 步边界 pickup（queue-visible 批 fix 轮 2026-09-24——TUI.md §7.5 消费时机①）：用户回合在飞 ⇒
+  // 核循环头投递回调（不中断——下一步生效，参照系 = 子代理 `send`）；系统轮不传（分流——两者轮不参与）
+  const consumeQueuedInput = autoTurn ? null : () => pickupQueuedAtStepBoundary(ctx)
+  // autoTurn（消化轮）：无用户输入——不画 "❯ You:"（系统驱动回合，AGENT-LOOP-ASYNC-POOL.md §6.8 D-S6）
   if (!autoTurn) {
     pushLabel(`❯ You:`, ansi.bold + C.user)
     pushLine(text, C.text)
@@ -89,7 +122,7 @@ async function runAgentTurnInner(ctx, text, opts) {
   ctx.assistantLabeled = false
   state.processing = true
   state.status = "Processing..."
-  // §17.6（advisor round2 🟡）：回合启动即解除空闲退出武装——exitArmed 只属于空闲态
+  // AGENT-LOOP-ASYNC-POOL.md §6.8（advisor round2 🟡）：回合启动即解除空闲退出武装——exitArmed 只属于空闲态
   // 双确认，跨回合残留会让"停回合后的 armed 落空穿透 + 陈旧 exitArmed"组合把一次
   // 意图为全停/退出的按下变成无二次确认的即时退出（key-handler 落空分支落回空闲
   // 分支时 `!state.exitArmed` 判假即 exit）；计时一并清（key-handler 空闲分支按
@@ -102,17 +135,20 @@ async function runAgentTurnInner(ctx, text, opts) {
   state.streaming = ""
   state.reasoning = ""
   state._advisorBlocks = []
-  // NOTE (§7.2 D4): state.subTasks is intentionally NOT reset here — subagent
+  // NOTE (docs/cli/design/TUI.md §6.8 D4): state.subTasks is intentionally NOT reset here — subagent
   // activity blocks persist across turns (the user can still expand a finished
   // child's block from a previous turn). Child tool calls never enter the parent
   // history, so the blocks are the only trace of child activity; memory is
   // bounded by the N2 per-child 500-line ring buffer.
   state.currentTool = null
   state.processingStarted = Date.now()
-  // §17 偏差修复 #3（会话 abort 全覆盖）：回合链 controller 登记。链头 = 非挂起会话内
+  // 停滞轻显形（docs/cli/design/TUI.md §7.7 · stall-indicator 批 2026-09-29）：静默起算初始锚 =
+  // 回合起刻（此后三类可见输出重置——流式 ∕ 工具面 ∕ 子代理面，见 tool-events ∕ subagent-blocks）。
+  state.lastOutputAt = Date.now()
+  // AGENT-LOOP-ASYNC-POOL.md §6.8 偏差修复 #3（会话 abort 全覆盖）：回合链 controller 登记。链头 = 非挂起会话内
   // 且非释放窗口期（suspended/_suspPending 均 false）开启的回合——登记表清零；队列
   // 递归回合（_suspPending 置位期）与会话内回合（suspended=true）继续累积。链条内每次
-  // 重建（Ctrl+I 续跑 / ContinueError 续跑 / AUTO 续跑）都登记——挂起会话的 abort 集合
+  // 重建（Ctrl+I 中断续跑 ∕ 撞帽续跑——核 `continueDecision` 两续跑格）都登记——挂起会话的 abort 集合
   // （_sessionAbortAll）必须在会话建立时覆盖进入会话以来的全部 controller：只 abort
   // 最后一个会让旧 controller 下 spawn 的 async children 逃逸中止（偏差 #3）。
   // 链头同时清掉上一链条残留的会话句柄（上一链 pool 先 live 后耗尽、未进入会话即结束
@@ -122,6 +158,9 @@ async function runAgentTurnInner(ctx, text, opts) {
     state._turnControllers = []
     agent._sessionAbort = null
     agent._sessionAbortAll = null
+    // 链头复位「重武装撤销」粘滞位（#448② KD-6——上一链的显式停止只约束到下一链头；新链
+    // 正常重入 ⇒ 链尾照常重武装）。会话内回合不在此列（suspended）——链条内标志始终有效。
+    state._timerRearmRevoked = false
   }
   state._turnControllers ??= []
   const makeController = () => {
@@ -132,7 +171,7 @@ async function runAgentTurnInner(ctx, text, opts) {
   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 —
+  // subagent block is still running so its header elapsed ticks (docs/cli/design/TUI.md §6.8 D4 —
   // no new timer, the existing ticker carries it). Blocks stay visible after
   // the turn ends, but frozen headers don't need 1s refreshes.
   const subRunning = () => Object.values(state.subTasks ?? {}).some((s) => !s.done)
@@ -151,55 +190,53 @@ async function runAgentTurnInner(ctx, text, opts) {
   try {
     for (let resume = false; ; resume = true) {
       try {
-        await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume, autoTurn, upstreamTurn, suspDriven: true })
+        await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume, autoTurn, upstreamTurn, timerTurn, suspDriven: true, consumeQueuedInput })
         flushStream()
         break // Normal completion, exit loop
       } catch (error) {
         flushStream()
-        if (error.name === "AbortError" || state.controller?.signal.aborted) {
-          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
-          }
+        // 续跑判定 = 核单源（#677 · I10——continueDecision；本端零第二分支——#127 ④ 双写退役）。
+        // reason = 回合 controller 的 `signal.reason`（中止面语义原源——D-C1 两义同式）。
+        const reason = state.controller?.signal?.reason
+        const decision = continueDecision(error, { autoTurn, autoApprove: agent.autoApprove, reason })
+        if (decision === "resume") {
+          // AGENT-LOOP-ASYNC-POOL.md §6.8 D-C1（round1 #1 区分机制——2026-09-03）：interrupt 有 message
+          // （Ctrl+I 注入——key-modes handleInterruptMode）⇒ 重建 controller 续跑（agent loop 已把消息注入
+          // history，中止的 signal 不能重试）。
+          state.controller = makeController()
+          resume = true
+          continue
+        }
+        if (decision === "stop") {
           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 层不可靠）。
+            // 无 message interrupt 的注入副作用回滚（Ctrl+C 首按停回合——key-handler abort({ interrupt: true })
+            // 不带 message；agent.mjs 中断三段无条件把 "[User interrupt: <msg>]" 落 history，对 message
+            // 存在性无守卫 ⇒ 无 message 时成为 "[User interrupt: undefined]" 垃圾上下文）。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)
+          // #448② KD-6「显式撤销」：Ctrl+C 全停（`{ abortTrigger: "stop" }`——key-handler 二按语义）
+          // ⇒ 落粘滞位：链尾闩不重武装（链头复位后新链恢复——见 `timerRearmBlocked`）。
+          if (reason?.abortTrigger === "stop") state._timerRearmRevoked = true
           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(t("digest.capAuto"), C.dim)
-              state.controller = makeController()
-              continue
-            }
-            pushLine(t("digest.capStop", { turns: error.turn }), C.warn)
-            if (opts?._logOutcome) opts._logOutcome.result = "stopped"
-            break
-          }
+        if (decision === "cap-stop") {
+          // TURN-CAP-CONTINUE.md §1 #7 / D-TC15（2026-09-26）：digest 无人值守档**不再自续**
+          // （原 AUTO 自动 resume 支退役——静默续期 = F8 禁止；无人可答 ⇒ 撞帽即收口）。
+          // 部分消化留在历史，会话回挂起——结果不丢，只是不再烧轮次。
+          // #726 写点2：cap 可见行 ∥ cap 记录同点双动作（文案 = lifecycle-records 单一实现）。
+          const capRec = digestCapRecord(error.turn)
+          for (const l of digestTraceLines(capRec)) pushLine(l.text, l.color)
+          pushRecord(recordCarrier(state, agent), capRec)
+          if (opts?._logOutcome) opts._logOutcome.result = "stopped"
+          break
+        }
+        if (decision === "ask") {
           pushLabel(`❯ Continue`, ansi.bold + C.warn)
           pushLine(`Ran ${error.turn} turns (limit ${error.turn}). Continue?`, C.warn)
           // Pause to ask: reuse permission mechanism
@@ -223,6 +260,7 @@ async function runAgentTurnInner(ctx, text, opts) {
           state.controller = makeController()
           continue
         }
+        // decision === "error"：其余异常 —— provider 失败面（X8 原语义）——
         // X8（2026-09-20 端差·显示面消差批）：provider 失败面 = 友好首行（判据同 VSC
         // panel-turn-loop.mjs:152-153：原文首行 + URL 脱敏）+ 诊断两行（Provider/Model）+ Retry
         // 询问（复用 permission 机制——同意 ⇒ 重建 controller + resume 重入，与 ContinueError
@@ -257,12 +295,12 @@ async function runAgentTurnInner(ctx, text, opts) {
     clearInterval(ticker)
     state.processing = false
     state._advisorBlocks = []
-    // §17 D-S1/D-S8：回合正常结束且后台池仍 live → 挂起会话：子agent 区块保持 live
-    // （不冻结——各 settle 事件自行处理），本次回合 controller 交会话层作 abort 句柄
+    // AGENT-LOOP-ASYNC-POOL.md §6.8 D-S1/D-S8：回合正常结束且后台池仍 live → 挂起会话：子agent 区块保持 live
+    // （不冻结——冻结落消费窗：起跑窗 ∥ reclaim ∥ 退出兜底），本次回合 controller 交会话层作 abort 句柄
     // （挂起期 Ctrl+C 中止全部后台子代理）；池空 / 中断 / 错误 → 现状 freezeAllSubTasks
-    // （中断态块标 interrupted；正常态块已在 settle 时各自冻结）。
+    // （中断态块标 interrupted；正常态块已在消费窗各自冻结）。
     const willSuspend = poolLive(agent)
-    // §17.5.5：挂起会话内回合（digest/会话内用户回合——skipSession 且 suspended）的
+    // AGENT-LOOP-ASYNC-POOL.md §6.8：挂起会话内回合（digest/会话内用户回合——skipSession 且 suspended）的
     // 收尾**不冻结驻留块**——已消化（pinned 且条目已注入）块由 suspensionSession 在
     // run 返回后 freezeReclaimDigestedBlocks 逐条回收（settle 锚点 splice——digest 总览文本
     // 之前——round1 #1 裁定，不等池空）；
@@ -277,7 +315,7 @@ async function runAgentTurnInner(ctx, text, opts) {
     } else if (!agent._sessionAbort) {
       agent._sessionAbort = state.controller // 会话 abort 句柄（children 共享此 signal）
     }
-    // §17 偏差修复 #1（回合释放窗口守卫）：willSuspend 判定后、进入任何 await 之前置位
+    // AGENT-LOOP-ASYNC-POOL.md §6.8 偏差修复 #1（回合释放窗口守卫）：willSuspend 判定后、进入任何 await 之前置位
     // 挂起待定标志。suspensionSession 真正启动前还有真实 await（ensureSessionTitle /
     // distill flush ≤5s / saveSession），其间 processing=false 且 suspended 尚未置位——
     // 无此标志 key-handler Enter 会走 submit 并发开第二个 runAgentTurn（双驱动器竞态：
@@ -285,7 +323,7 @@ async function runAgentTurnInner(ctx, text, opts) {
     // 有效区间 = 释放窗口（suspensionSession 启动即清除）；会话内回合（skipSession）
     // 由 state.suspended 覆盖；_suspAborted 时挂起会话不会启动（下方会话入口同条件）。
     state._suspPending = willSuspend && !skipSession && !state._suspAborted
-    // §17 偏差修复 #3（会话 abort 全覆盖）：abort 集合快照 = 本链条内全部 controller
+    // AGENT-LOOP-ASYNC-POOL.md §6.8 偏差修复 #3（会话 abort 全覆盖）：abort 集合快照 = 本链条内全部 controller
     // （含 Ctrl+I/ContinueError 重建的旧 controller——其下 spawn 的 async children 持旧
     // signal，Ctrl+C 只 abort 最后一个会让它们跑完整个 turn 预算，正常完成后仍
     // mergeChildMutations 写父 guard 标记，绕过 advisor/verify 门）。会话内回合的 finally
@@ -327,17 +365,19 @@ async function runAgentTurnInner(ctx, text, opts) {
     render()
   }
 
-  // §17 偏差 #1 兜底（INPUT-LOCK 单槽化——2026-09-09）：释放窗口期 Enter 已入
-  // pendingInput 单槽——链条走到此处若池已空（挂起会话不会启动，下方 while 是最后一个
-  // 消费点）则转正队列照常续发，消息不滞留不并发。池非空时挂起会话先消费 pendingInput
-  // （D-S5 输入优先），无需此处处理。单槽语义下残余至多一条。
+  // AGENT-LOOP-ASYNC-POOL.md §6.8 偏差 #1 兜底 + queue-visible 批（2026-09-24）收正：末步入队的排队消息（本 run 无后续
+  // 步边界 ⇒ 步边界 pickup 触不到）——按合并计划取批转 state.queue，队列 while 续发新回合；
+  // 池非空时挂起会话先消费 pendingInput（D-S5 输入优先），无需此处处理。超一批者截批先行
+  // （余下留待下批——仍在队列 ⇒ 待发送块可见，零丢失）。
   if (!skipSession && !state._suspAborted && (state.pendingInput?.length ?? 0) > 0 && !poolLive(agent)) {
-    state.queue.push({ text: String(state.pendingInput.shift()) })
+    const action = planQueuedInput(state.pendingInput)[0]
+    state.pendingInput.splice(0, action.count)
+    state.queue.push({ text: action.text })
   }
 
-  // 交接消息自动续发（INPUT-LOCK 单消息——2026-09-09）：submit 不再排队（busy 提交吞）
-  // + R15 攒批删——state.queue 只剩残项单消息（释放窗口兜底/挂起中止残余——零丢失
-  // 承诺）——逐条直发；斜杠命令直接执行（保序）；回合后的续发由递归层同循环续取。
+  // 交接消息自动续发（queue-visible 批 2026-09-24——R15 攒批恢复）：state.queue 条目 = 合并计划
+  // 的动作（残项：释放窗口兜底 / 挂起中止残余——零丢失承诺）——逐条直发；斜杠命令直接执行
+  // （保序）；回合后的续发由递归层同循环续取。
   while (state.queue.length > 0 && !state.processing) {
     const head = state.queue.shift()
     // F16（TUI.md §7.5）：消费回执——queued dim 行（消费事实的可见锚；对位 [continuing…]）
@@ -352,24 +392,29 @@ async function runAgentTurnInner(ctx, text, opts) {
     return
   }
 
-  // §17 D-S2: 回合尾后台池非空 → 挂起会话（D-S9 状态机——输入放开、settle 驱动
+  // AGENT-LOOP-ASYNC-POOL.md §6.8 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）：挂起会话退出
+    // AGENT-LOOP-ASYNC-POOL.md §6.8 round2 偏差 #1（_suspAborted 粘滞，code review round2 #1）：挂起会话退出
     // （自然耗尽或 Ctrl+C 中止）即复位中止标志——中止 unwind 已完成、池已清空/耗尽，
     // 复位不会误触发重入。不清则 _suspPending 守卫与下方会话入口被同一标志永久门控：
     // 中止后用户再 spawn async、回合尾池再 live 时永不再次进入挂起态（suspensionSession
     // 首行复位成死代码）——子代理结果退化到"下个回合尾才注入"、状态行/自动消化/区块
     // 驻留全消失；释放窗口守卫同步失效（Enter 并发开第二个 runAgentTurn——双驱动器
     // 竞态复现）。
+    if (state._suspAborted) state._timerRearmRevoked = true // #448② KD-6「会话停」：链尾闩不重武装（粘滞位——复位前捕获）
     state._suspAborted = false
   }
 
+  // §6.30.5 载体②武装点（回合链尾「无人自动接手」判据**邻位**）：已上收收口层 `finally`
+  // （#448② 异常径重武装 —— 见 `runAgentTurnInner`；本处零注册 ∕ 零动作）。
+
   // 第 33 批（TUI §14.3(d)）：顶层链尾（队列续发循环与挂起会话退出**之后**）——无人自动
   // 接手 ⇒ 置 attention 位（渲染层实时派生 blocked/awaiting；用户任意输入清位）。D-AT6：
   // 不放在回合末 finally——那之后还有队列续发 / 挂起会话（digest 自动消费），不是「需要用户」。
+  // timer-wake 批：谓词内新增「在途 timer ∧ 唤醒会武装」除外（§7.1 awaiting 行限定）。
   if (userNeededAtTurnEnd(state, agent, skipSession)) {
     state.attentionAwaiting = true
     render()

package/src/tui/clipboard.mjs

@@ -1,3 +1,9 @@
+import { mkdirSync, writeFileSync } from "node:fs"
+import { readFile, stat, unlink } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { IMAGE_MAX_BYTES, savePastedImages } from "@thincoder/core/attachments.mjs"
+import { cleanupOldToolResults } from "@thincoder/core/agent/helpers.mjs"
 import { C } from "./ansi.mjs"
 
 /** Windows clipboard-read command: force UTF-8 console output so Get-Clipboard's bytes
@@ -132,49 +138,87 @@ export function stripKeyboardProtocol(text) {
   return text.replace(/\x1b\[\d+;\d+u/g, "").replace(/\x1b\[27;\d+;\d+~/g, "")
 }
 
-/** Ctrl+V / Alt+V: read clipboard image → write temp file in working directory → insert read_image command into input box.
- *  Extracted from index.mjs.
- *  ctx: { agent, state, pushLine, render } */
-export async function pasteClipboardImage(ctx) {
-  const { agent, state, pushLine, render } = ctx
+/** 平台剪贴板图像捕获（缺省实现——写 staging ∥ 无图抛）：Windows = PowerShell
+ *  System.Windows.Forms（无图 ⇒ exit 1 ⇒ 抛）；macOS = osascript PNGf；其余 = xclip → wl-paste 回退。
+ *  截图直接写 `dest`（系统临时区 staging——不入项目树）。 */
+async function captureClipboardImage(dest) {
   const { execFile } = await import("node:child_process")
-  const { stat, unlink } = await import("node:fs/promises")
-  const { join } = await import("node:path")
-
   const run = (cmd, args) => new Promise((resolve, reject) => {
     execFile(cmd, args, { timeout: 10000 }, (err, stdout) => { if (err) reject(err); else resolve(stdout) })
   })
-
-  const dest = join(agent.cwd, `.thincoder-paste-${Date.now()}.png`)
   const isWin = process.platform === "win32"
   const isMac = process.platform === "darwin"
+  if (isWin) {
+    const psScript = `Add-Type -AssemblyName System.Windows.Forms; if ([System.Windows.Forms.Clipboard]::ContainsImage()) { [System.Windows.Forms.Clipboard]::GetImage().Save('${dest.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png); exit 0 } else { exit 1 }`
+    await run("powershell", ["-NoProfile", "-Command", psScript])
+  } else if (isMac) {
+    const script = `try; set f to (POSIX file "${dest}"); set img to the clipboard as «class PNGf»; set fd to open for access f with write permission; write img to fd; close access fd; end try`
+    await run("osascript", ["-e", script])
+  } else {
+    await run("bash", ["-c", `xclip -selection clipboard -t image/png -o > "${dest}" 2>/dev/null || { which wl-paste >/dev/null 2>&1 && wl-paste -t image/png > "${dest}" 2>/dev/null; } || exit 1`])
+  }
+}
 
+/** 贴图 buffer ⇒ 核正路落盘（**唯一写盘者 = 核 `savePastedImages`**）：写时扫除
+ *  （`cleanupOldToolResults(<cwd>/.thincoder/tmp)`——3 天窗 mtime 回收；扫除失败不影响落盘）⇒
+ *  构 dataURL ⇒ 调核 `savePastedImages(dataUrls, cwd, { fs })` ⇒ 路径 ∥ null（核弃项 ∥ 写败）。
+ *  @returns {Promise<string|null>} `<cwd>/.thincoder/tmp/paste-<id>-0.png` 绝对路径 / null */
+export async function savePastedImageBuffer(buffer, cwd) {
+  const tmpDir = join(cwd, ".thincoder", "tmp")
+  await cleanupOldToolResults(tmpDir)
+  const dataUrl = `data:image/png;base64,${buffer.toString("base64")}`
+  // 契约「路径 ∥ null」——核内异常（未接线等）归「写败」径，不越出本函数
   try {
-    if (isWin) {
-      const psScript = `Add-Type -AssemblyName System.Windows.Forms; if ([System.Windows.Forms.Clipboard]::ContainsImage()) { [System.Windows.Forms.Clipboard]::GetImage().Save('${dest.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png); exit 0 } else { exit 1 }`
-      await run("powershell", ["-NoProfile", "-Command", psScript])
-    } else if (isMac) {
-      const script = `try; set f to (POSIX file "${dest}"); set img to the clipboard as «class PNGf»; set fd to open for access f with write permission; write img to fd; close access fd; end try`
-      await run("osascript", ["-e", script])
-    } else {
-      await run("bash", ["-c", `xclip -selection clipboard -t image/png -o > "${dest}" 2>/dev/null || { which wl-paste >/dev/null 2>&1 && wl-paste -t image/png > "${dest}" 2>/dev/null; } || exit 1`])
-    }
+    const { paths } = savePastedImages([dataUrl], cwd, { fs: { mkdirSync, writeFileSync } })
+    return paths[0] ?? null
   } catch {
-    pushLine("Clipboard does not contain an image, or clipboard access failed", C.dim)
-    try { await unlink(dest) } catch {}
-    return
+    return null
   }
+}
 
-  const st = await stat(dest).catch(() => null)
+/** Ctrl+V / Alt+V：读剪贴板图像 → 系统临时区 staging（不入项目树）→ 读 buffer ⇒ staging 用毕即清
+ *  （读取后——与失败径同口径）⇒ `savePastedImageBuffer` 落 `<cwd>/.thincoder/tmp/paste-<id>-0.png`
+ *  → 插入 `read_image <最终绝对路径>`。
+ *  失败径（dim 提示行 ×3）：无图（捕获抛 ∥ 零字节）· 超阈（`IMAGE_MAX_BYTES` 单源早筛——stat 后
+ *  读前，不读巨件）· 写败（核落盘 ≤0 项）——均零插入、返回 null。
+ *  @param {{agent:{cwd:string}, state, pushLine:Function, render:Function}} ctx
+ *  @param {((dest:string)=>Promise<void>)|null} [captureImpl] — 捕获面测试缝（写 staging ∥ 无图抛）；
+ *    缺省 null ⇒ 平台捕获实现（生产调用点零改；参数作用域——零跨调用残留）
+ *  @returns {Promise<{insert:string, path:string}|null>} 成功 = 插入文本 + 最终绝对路径；失败 = null */
+export async function pasteClipboardImage(ctx, captureImpl = null) {
+  const { agent, state, pushLine, render } = ctx
+  const staging = join(tmpdir(), `thincoder-paste-${Date.now()}.png`)
+  const capture = captureImpl ?? captureClipboardImage
+  try {
+    await capture(staging)
+  } catch {
+    pushLine("Clipboard does not contain an image, or clipboard access failed", C.dim)
+    try { await unlink(staging) } catch {}
+    return null
+  }
+  const st = await stat(staging).catch(() => null)
   if (!st || st.size === 0) {
     pushLine("Clipboard does not contain an image, or clipboard access failed", C.dim)
-    try { await unlink(dest) } catch {}
-    return
+    try { await unlink(staging) } catch {}
+    return null
   }
-
-  const cmd = `read_image ${dest}`
-  state.input.splice(state.cursor, 0, ...[...cmd])
-  state.cursor += cmd.length
-  pushLine(`[image pasted → ${dest}]`, C.tool)
+  if (st.size > IMAGE_MAX_BYTES) {
+    pushLine("Clipboard image too large (max 15MB)", C.dim)
+    try { await unlink(staging) } catch {}
+    return null
+  }
+  const buffer = await readFile(staging)
+  try { await unlink(staging) } catch {}
+  const path = await savePastedImageBuffer(buffer, agent.cwd)
+  if (!path) {
+    pushLine("Clipboard image could not be saved (write failed)", C.dim)
+    return null
+  }
+  const insert = `read_image ${path}`
+  const chars = [...insert] // codepoint 数组（同 insertPastedText 口径——cwd 含星平面字符时游标不漂）
+  state.input.splice(state.cursor, 0, ...chars)
+  state.cursor += chars.length
+  pushLine(`[image pasted → ${path}]`, C.tool)
   render()
+  return { insert, path }
 }

package/src/tui/cmd-advisor.mjs

@@ -4,11 +4,16 @@
 import { readFileSync } from "node:fs"
 import { ansi, C } from "./ansi.mjs"
 import { activeSlot, slotPath } from "@thincoder/core/session.mjs"
+// off 形族单源（`docs/core/design/MODEL-SPECS.md` §16.2 / §16.3 / §16.4）——取形与「有效 off 路径」
+// 判据一律自本档取，本档零副本（叶档：零 import 纯函数）。
+import { thinkOffShape, thinkOffPath } from "@thincoder/core/think-off.mjs"
 import { writeSessionFile } from "./cmd-eng.mjs"
 
 export async function handleAdvisorCommand(ctx) {
   const { agent, showPicker, pushLine, pushLabel } = ctx
   const cfg = agent.config.advisor ??= {}
+  // 入口预载规格面（懒加载面零改：不做顶层静态 import）——同步的状态行（`advisorStatus`）亦须取 spec。
+  const { specForModel } = await import("@thincoder/core/config.mjs")
   // Deprecated field cleanup (2026-08-21): advisor.enabled is no longer read
   // anywhere; drop it here so persist() never re-writes the stale flag.
   delete cfg.enabled
@@ -17,13 +22,20 @@ export async function handleAdvisorCommand(ctx) {
     if (ctx.persistRaw) {
       await ctx.persistRaw((raw) => {
         raw.agent ??= {}
-        raw.agent.advisor = cfg
+        // advisor.guard is session-level (#382 同口径收 · slot authority — VSC parity): the guard
+        // never rides the config write — only the config-scoped keys (model/thinking/effort/timeout)
+        // persist；盘上既有 guard 值原样保留（回退面不动 —— 读链 = 槽 ?? config）。
+        const scoped = { ...cfg }
+        delete scoped.guard
+        const diskAdvisor = typeof raw.agent.advisor === "object" && raw.agent.advisor !== null ? raw.agent.advisor : {}
+        raw.agent.advisor = { ...diskAdvisor, ...scoped }
       })
     }
   }
 
-  // Guard-only dual write (2026-08-29 — advisor.guard is session-level): the guard goes into
-  // the CURRENT session slot first (shared with VS Code), the config.json mirror follows.
+  // Guard-only slot write (2026-08-29 — advisor.guard is session-level; #382 同口径收): the guard
+  // goes into the CURRENT session slot (shared with VS Code) — the slot is the single authority;
+  // no config.json mirror write (与 VSC 面板写面同判——guard 不入 config 写面).
   // Other advisor keys (model/thinking/effort/timeout) stay config-scoped — persist() only.
   const persistGuard = async () => {
     try {
@@ -33,19 +45,23 @@ export async function handleAdvisorCommand(ctx) {
         data.advisor = { ...(typeof data.advisor === "object" && data.advisor !== null ? data.advisor : {}), guard: cfg.guard === true }
         writeSessionFile(p, data)
       }
-    } catch { /* slot missing/unreadable — config mirror still written */ }
-    await persist()
+    } catch { /* slot missing/unreadable — guard stays in-memory for this session (zero config write) */ }
   }
 
   // Lazy model cache — fetched once per /advisor session
   let modelCache = null
 
   // ── State helpers ──
+  /** 状态行（§16.4）：无有效 off 路径（`thinkOffPath === false`）⇒ **不报 off**——残留 off 标记
+   *  （`null` / `{type:"disabled"}`）按「未设档」渲染：有档报 `on (<档>)`，无档报 `on`
+   *  （服务端恒思考 / 形不发字段 ⇒ 「Think: off」会是假断言）。 */
   function advisorStatus() {
     const curModel = cfg.model || agent.provider.model
-    const thinkInfo = cfg.thinking === null ? "off"
-      : cfg.thinking?.type === "disabled" ? "off"
+    const offPath = thinkOffPath(specForModel(getEffectiveModel(agent, cfg)))
+    const offMarked = cfg.thinking === null || cfg.thinking?.type === "disabled"
+    const thinkInfo = offPath && offMarked ? "off"
       : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
+      : offMarked ? "on"
       : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
     return `Advisor | Model: ${curModel} | Think: ${thinkInfo}`
   }
@@ -54,6 +70,17 @@ export async function handleAdvisorCommand(ctx) {
     return `    ${advisorStatus()}`.replace(/\|/g, ansi.dim + "|" + ansi.reset)
   }
 
+  /** off 形落盘（`think_off` 与归一后的 `effort_none` 共用——单一口径，防同状态两公式）：
+   *  取形 = 单源 `thinkOffShape`（`@thincoder/core/think-off.mjs`；§15.4-2 族别判据 / §16.2 生产者表）——
+   *  effort 族（`thinkApi === "effort"`）⇒ `thinking: null`（载荷层 off 门首款要求；`{type:"disabled"}`
+   *  不开门 ⇒ 关思考静默失效）；其余（type 族默认 / 自定义开值族）⇒ `{type:"disabled"}`（达载荷层）。
+   *  三支同清 `reasoningEffort`（§16.6-⑵：off 标记与档位不得同盘——F2 违约族）。 */
+  async function applyThinkOff() {
+    const spec = specForModel(getEffectiveModel(agent, cfg))
+    cfg.thinking = thinkOffShape(spec)
+    delete cfg.reasoningEffort
+  }
+
   // ── Model picker sub-loop ──
   async function modelPicker() {
     if (!modelCache) {
@@ -98,7 +125,6 @@ export async function handleAdvisorCommand(ctx) {
         pushLabel("❯ Advisor", ansi.bold + C.tool)
         pushLine("Thinking: using main model settings", C.tool)
       } else if (c.action === "think_on") {
-        const { specForModel } = await import("@thincoder/core/config.mjs")
         const spec = specForModel(getEffectiveModel(agent, cfg))
         cfg.thinking = { type: spec.thinkEnabledValue ?? "enabled" }
         if (spec.thinkApi === "effort") delete cfg.thinking
@@ -106,14 +132,24 @@ export async function handleAdvisorCommand(ctx) {
         pushLabel("❯ Advisor", ansi.bold + C.tool)
         pushLine(`Thinking: ON`, C.tool)
       } else if (c.action === "think_off") {
-        const { specForModel } = await import("@thincoder/core/config.mjs")
-        const spec = specForModel(getEffectiveModel(agent, cfg))
-        const isCustomThink = (spec.thinkEnabledValue ?? "enabled") !== "enabled"
-        cfg.thinking = isCustomThink ? null : { type: "disabled" }
+        await applyThinkOff()
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine("Thinking: OFF", C.tool)
+      } else if (c.action === "effort_none") {
+        // 归一（镜像 `cmd-think.mjs:104` 归一式 / `:127` 删档 / `:82` 回执）：档位 `none` 不是
+        // 「强度零」而是**关思考**——与菜单 off 项同语义。不归一则残留 `reasoningEffort:"none"`
+        // 被载荷层当强度档送（`provider/core.mjs:197-204`）⇒ 与 off 形矛盾同发、服务端仍思考。
+        delete cfg.reasoningEffort
+        await applyThinkOff()
         await persist()
         pushLabel("❯ Advisor", ansi.bold + C.tool)
         pushLine("Thinking: OFF", C.tool)
       } else if (c.action.startsWith("effort_")) {
+        // #346-①（§16.4 表末行）：选档 = 要思考 ⇒ 先清 `thinking === null` 标记（对齐
+        // `cmd-think.mjs:119-120` 先例 / §15.4-2 末句）；`{type:"disabled"}` 不动（同先例；
+        // 残余登记 = §16.6-⑸——type 族 off ⇒ 选档 后该标记保持）。
+        if (cfg.thinking === null) delete cfg.thinking
         cfg.reasoningEffort = c.action.slice(7)
         await persist()
         pushLabel("❯ Advisor", ansi.bold + C.tool)
@@ -232,6 +268,7 @@ async function buildThinkingEntries(agent, cfg) {
   const thinkOnValue = spec.thinkEnabledValue ?? "enabled"
   const isCustomThink = thinkOnValue !== "enabled"
   const isEffortOnly = spec.thinkApi === "effort"
+  const offPath = thinkOffPath(spec)
   const effortLevels = spec.reasoningEffortEnum ?? ["high", "max"]
 
   const curEffort = cfg.reasoningEffort ?? providerForDefaults.reasoningEffort
@@ -245,7 +282,11 @@ async function buildThinkingEntries(agent, cfg) {
   if (!isEffortOnly) {
     entries.push({ type: "header", text: "Thinking mode" })
     entries.push({ type: "item", text: `Enabled  ${thinkingEnabled ? "← current" : ""}`, action: "think_on" })
-    entries.push({ type: "item", text: `Disabled ${(curThinking?.type === "disabled" || curThinking === null) ? "← current" : ""}`, action: "think_off" })
+    // §16.4：无有效 off 路径（服务端强制族 / 形不发字段）⇒ Disabled 项**不渲染**；
+    // Enabled 项保留 = 残留 `{type:"disabled"}` 标记的恢复径（`/think on` 同旨）。
+    if (offPath) {
+      entries.push({ type: "item", text: `Disabled ${(curThinking?.type === "disabled" || curThinking === null) ? "← current" : ""}`, action: "think_off" })
+    }
   }
   entries.push({ type: "header", text: "Reasoning effort" })
   for (const level of effortLevels) {