thincoder 0.12.49 → 0.12.51

package/src/tui/fold-block.mjs

@@ -0,0 +1,208 @@
+/**
+ * fold-block.mjs — 公共可折叠区块渲染组件（2026-08-30，自 render-conversation.mjs 抽出）。
+ *
+ * 背景（用户报告）：折叠区块展开后长度不受限——超长区块展开时折叠控制行被挤出
+ * 屏幕，点不到、收不回。本组件统一所有可折叠区块的「展开态」渲染并施加
+ * **屏幕高度 60% 的展开封顶**：封顶时在区块底部渲染第二个折叠控制行——区块
+ * 最高占屏 60%，底控件必落在视口内，展开永远可逆。
+ *
+ * 消费方（render-conversation.mjs 六处折叠点）：
+ *   1. 子agent 活动区块（运行中 / 冻结，AGENT-LOOP §7.2 D4）
+ *   2. advisor 评审块（运行中 _advisorBlocks / 冻结 _frozenAdvisor）
+ *   3. 长消息折叠（long-N）/ 连续 dim 折叠（fold-N）
+ *
+ * 分工边界：折叠态有两种既有形态（头部+tail3 / 前4+中置▶+末行），由调用方
+ * 保留各自语义；本组件统一展开态、封顶、控制行、tail 提取、blocks→行时间线。
+ */
+import { C } from "./ansi.mjs"
+import { formatTables, sanitizeDisplay, sliceByWidth, stringWidth, wrapText } from "./render.mjs"
+import { renderMarkdownInline, renderMarkdownHeading } from "./markdown.mjs"
+import { renderMathInline, renderMathBlock } from "./math.mjs"
+
+/** Expanded-section height cap: 60% of the terminal's row count (user ruled
+ *  2026-08-30 — the collapse control must stay reachable after expanding).
+ *  rows unknown (tests / odd environments) → Infinity = uncapped. */
+export function foldCapRows(rows) {
+  if (!rows) return Infinity
+  return Math.max(1, Math.floor(rows * 0.6))
+}
+
+/** Fold-state read, single source: foldEnabled===false (unfold-all mode) forces
+ *  every block expanded; otherwise the per-block key decides. */
+export function isExpanded(state, foldKey) {
+  return state.foldEnabled === false || (state.expandedBlocks?.has(foldKey) ?? false)
+}
+
+/** Bidirectional toggle (mouse click / future keyboard path share this). */
+export function toggleFoldBlock(state, foldKey) {
+  state.expandedBlocks ??= new Set()
+  if (state.expandedBlocks.has(foldKey)) state.expandedBlocks.delete(foldKey)
+  else state.expandedBlocks.add(foldKey)
+}
+
+/** Fold marker line: bold-cyan icon + "click to …" phrase underlined (clickable affordance).
+ *  No indent — flush with the content below it; callers add a blank line BEFORE the
+ *  expanded-state control so it stands apart from unrelated content (reported UX). */
+
+/** Extract the last ≤n non-empty lines across the trailing blocks (folded-tail
+ *  preview). Shared by subagent/advisor folded forms — was 3 hand-written copies
+ *  in render-conversation (P1 收编, 2026-08-30). */
+export function foldTailLines(blocks, n = 3, { strip = [] } = {}) {
+  const out = []
+  for (let bi = blocks.length - 1; bi >= 0 && out.length < n; bi--) {
+    let text = sanitizeDisplay(blocks[bi].text ?? "")
+    for (const marker of strip) text = text.replaceAll(marker, "")
+    const lines = text.split("\n").filter((l) => l.trim())
+    for (let li = lines.length - 1; li >= 0 && out.length < n; li--) out.unshift(lines[li])
+  }
+  return out
+}
+
+export function foldHintLine(text, foldKey, srcIdx) {
+  const withUnderline = text.replace(/(click to (?:expand|collapse))/, "\x1b[4m$1\x1b[24m")
+  return { text: withUnderline, color: C.fold, _foldToggle: foldKey, _src: srcIdx }
+}
+
+/**
+ * FOLDED-state rendering — the unified other half of the interaction (2026-08-30
+ * user ruling: EVERY collapsible section folds to "named header + last 3 lines,
+ * expands to a 60%-capped view"). Replaces the legacy long-message form
+ * [first 4, ▶ at the ellipsis, last 1] whose anonymous "… N more lines" header
+ * read as orphaned segments in the scrollback (user report 2026-08-30).
+ * header: the caller's control/summary line ({text, color, _foldToggle}) —
+ * subagent/advisor keep their bracket identity headers, long-message folds get
+ * `▶ <kind> · N lines — click to expand`. Tail rows are dimmed and carry
+ * _skipDimFold (never re-enter the consecutive-dim folder).
+ */
+export function renderFoldedHead({ header, body, tailLines = 3, cols = 80 }) {
+  const tail = body
+    .filter((l) => l.text && l.text.trim())
+    .slice(-tailLines)
+    .map((l) => ({
+      ...l,
+      text: sliceByWidth(`│ ${l.text.replace(/^(?:│ ?| {2}│ ?| {2})/, "")}`, cols - 2),
+      color: C.dim,
+      _skipDimFold: true,
+    }))
+  return [header, ...tail]
+}
+
+/** Blank separator before a fold control line (uncolored — must not join consecutive-dim folding). */
+export function blankLine() {
+  return { text: "", color: "" }
+}
+
+/**
+ * Render markdown markers to ANSI, then pad the line tail back to the pre-render
+ * display width (moved from render-conversation.mjs — see that file's history for
+ * the formatTables misalignment incident this compensation fixes).
+ */
+export function renderMarkdownPreservingWidth(text) {
+  return text.split("\n").map((line) => {
+    const rendered = renderMarkdownInline(renderMarkdownHeading(line))
+    const diff = stringWidth(line) - stringWidth(rendered)
+    return diff > 0 ? rendered + " ".repeat(diff) : rendered
+  }).join("\n")
+}
+
+// Math runs BEFORE markdown (TUI.md §9.1D): `$...$`/`$$...$$` are opaque to markdown
+// (so `x**2` inside a formula isn't misread as bold), and the Unicode approximation
+// is measured by renderMarkdownPreservingWidth's width-compensation math.
+export function renderMathAndMarkdown(text) {
+  return renderMarkdownPreservingWidth(renderMathInline(renderMathBlock(text)))
+}
+
+/**
+ * blocks[] → colored, guttered, wrapped timeline lines. Shared by subagent
+ * (running + frozen) and advisor (live + frozen) blocks — was 4 near-identical
+ * copies across render-conversation. Per-kind contract:
+ *   think → raw lines (no markdown), C.reason
+ *   text  → math+markdown → formatTables, C.text
+ *   tool  → formatTables raw, C.tool
+ *   meta  → plain lines (no wrap — marker is short), C.dim
+ * opts: { gutter = "│ ", pad = 3, stripPlaceholder = false, headBlank = false }
+ *   gutter/pad: frozen advisor renders full-width with no gutter (gutter "", pad 1).
+ *   stripPlaceholder: advisor streams embed ADVISOR_THINKING_PLACEHOLDER markers —
+ *   stripped in every advisor view (live expanded previously kept them; unified).
+ *   headBlank: lead with a blank separator line (renderExpandedBlock default form).
+ * All lines carry _skipDimFold: true — the consecutive-dim folder must never
+ * nest on top of an expanded block (reported stacking regression).
+ */export function renderBlockTimeline(blocks, cols, opts = {}) {
+  // strip: array of literal substrings removed from every block text (callers
+  // pass advisor-specific markers — the component itself has no advisor deps).
+  const { gutter = "│ ", pad = 3, strip = [] } = opts
+  const out = []
+  for (const block of blocks) {
+    const color = { think: C.reason, tool: C.tool, text: C.text, meta: C.dim }[block.kind] ?? C.dim
+    let source = sanitizeDisplay(block.text ?? "")
+    for (const marker of strip) source = source.replaceAll(marker, "")
+    if (block.kind === "meta") {
+      for (const line of source.split("\n")) out.push({ text: `${gutter}${line}`, color, _skipDimFold: true })
+      continue
+    }
+    const rows = block.kind === "think"
+      ? source.split("\n")
+      : formatTables(block.kind === "text" ? renderMathAndMarkdown(source) : source, cols - pad)
+    for (const line of rows) {
+      for (const wrapped of wrapText(line, cols - pad)) {
+        out.push({ text: `${gutter}${wrapped}`, color, _skipDimFold: true })
+      }
+    }
+  }
+  return out
+}
+
+/**
+ * EXPANDED-state rendering of one collapsible section — the unified half of the
+ * interaction. Layout:
+ *   foldEnabled=false → raw body only (hints would lie: toggling is a no-op;
+ *                       the 60% cap equally does not apply to unfold-all mode)
+ *   body ≤ cap        → [blank] + ▼ control + all body
+ *   body > cap        → [blank] + ▼ control + first (cap-4) lines + cap marker +
+ *                       ▼ control AT THE BOTTOM (the reachable one — the whole
+ *                       point of the cap; the top control may sit above the
+ *                       viewport when the block starts off-screen)
+ * opts: { body, foldKey, state, maxRows, label, headBlank = true }
+ *   body: pre-rendered body lines ({text, color, ...}); label: header phrase
+ *   used in both control lines (e.g. "subagent activity", "12 lines");
+ *   headBlank=false (tool-args blocks): no leading blank — the args block
+ *   belongs tightly to its ❯ title line.
+ *
+ * LEFT RULE LINE (2026-08-30 user request): every body row gets a `│ ` gutter
+ * prefix so the block's content reads as one bordered region, distinct from
+ * surrounding conversation. renderExpandedBlock OWNS the gutter: body callers
+ * pass RAW rows (no leading `│ `/indent of their own) — double gutters are
+ * stripped defensively.
+ */
+export function renderExpandedBlock({ body, foldKey, state, maxRows, label, cols = 80 }) {
+  if (state.foldEnabled === false) return body.slice()
+  // Strip caller-side gutters/indents, then apply the single owned gutter.
+  // HARD WIDTH BOUND: caller rows may already be cols-1 wide (wrapped at
+  // cols-1 upstream); adding the 2-char gutter would overflow by one column —
+  // the exact "one char past the border" bug (user report 2026-08-30). The
+  // component owns the final width: every row is sliced to cols-2 AFTER the
+  // gutter, so the frame never sees an overwide row.
+  const lined = body.map((l) => {
+    // Empty rows keep the rule line unbroken: a bare "│" (no trailing space)
+    // paints the same column without introducing trailing whitespace.
+    if (!l.text || !l.text.trim()) return { ...l, text: "│", _skipDimFold: true }
+    const raw = l.text.replace(/^(?:│ ?| {2}│ ?| {2})/, "")
+    return { ...l, text: sliceByWidth(`│ ${raw}`, cols - 2) }
+  })
+  const out = [blankLine(), foldHintLine(`▼ … ${label} — click to collapse`, foldKey)]
+  const cap = foldCapRows(maxRows)
+  if (lined.length <= cap) {
+    out.push(...lined)
+    return out
+  }
+  // Reserve room for blank + top control + cap marker + bottom control.
+  const keep = Math.max(1, cap - 4)
+  out.push(...lined.slice(0, keep))
+  out.push({
+    text: `│ … ${body.length - keep} more lines — expansion capped at 60% of screen (collapse to re-expand)`,
+    color: C.dim,
+    _skipDimFold: true,
+  })
+  out.push(foldHintLine(`▼ … ${label} — click to collapse`, foldKey))
+  return out
+}

package/src/tui/index.mjs

@@ -22,6 +22,7 @@ import { saveSession } from "../session.mjs"
 import { closeAllMcp } from "../mcp.mjs"
 import { ansi, C } from "./ansi.mjs"
 import { createRenderLoop } from "./render-loop.mjs"
+import { makeDimsState } from "./dims.mjs"
 import { SLASH_COMMANDS, SLASH_ALIASES, createSlashCommands } from "./slash-commands.mjs"
 import { createWizard } from "./wizard.mjs"
 import { createPickers } from "./pickers.mjs"
@@ -58,6 +59,14 @@ export async function startTUI(agent, opts = {}) {
 
   const distillOpts = opts
 
+  // Capture terminal dimensions BEFORE raw mode & alt buffer switch as the
+  // state.dims seed (ConPTY reads are unstable: falsy at startup, stale-small
+  // during output activity). Refresh happens ONLY in event hooks — startup
+  // convergence retry, the 300ms delayed resample, resize events, the idle
+  // watchdog, agent-turn finally — never in the render path (2026-08-30).
+  const startupCols = process.stdout.columns || 80
+  const startupRows = process.stdout.rows || 24
+
   const state = {
     lines: [], // conversation lines: { text, color }
     streaming: "", // current streaming buffer
@@ -78,12 +87,13 @@ export async function startTUI(agent, opts = {}) {
     pendingNotice: null, // 后台更新提示：有 picker 打开时挂起，picker 全部关闭后再弹
     wizard: null, // first-launch config wizard { step, index, scroll, selectedLine, fields, error, lines }
     tasks: agent.tasks ?? [], // task list from task tool (progress shown in status bar); carried over on session restore, auto-collapsed when all done
+    dims: makeDimsState({ cols: startupCols, rows: startupRows }), // terminal dims single source (Windows ConPTY instability, 2026-08-30) — seeded pre-raw-mode, re-sampled by event hooks only (startup retry / resize / idle watchdog)
     tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0, reasoningTokens: 0 }, // cumulative token usage (shown in status bar)
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
-    _autoExpand: [], // indices of completed replies kept expanded; cleared when the next user turn starts
-    subTasks: {}, // sub-agent panel: { roleName: { role, text, done } }, one line per role, marked done briefly after completion
+
+    subTasks: {}, // sub-agent activity blocks (§7.2 D4): { "coder#1": { key, role, model, started, done, doneAt, blocks: [{kind,text}], currentTool, toolArgs, turn, maxTurns, approval, lastError, dropped, blockEpoch } } — rendered as collapsible in-conversation blocks; persists across turns (blocks are the child activity's ONLY carrier — child tool calls never enter the parent history); bounded by the N2 500-line per-child ring buffer
     currentTool: null, // currently executing tool name (shown in status bar)
     processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
@@ -111,11 +121,6 @@ export async function startTUI(agent, opts = {}) {
   const keyStream = new PassThrough()
   let mousePending = "" // incomplete mouse sequence tail spanning chunks
   let lastRenderedScroll = 0
-  // Capture terminal dimensions before raw mode & alt buffer switch.
-  // On Windows, process.stdout.columns/rows can briefly return falsy after the mode switch
-  // (ConPTY buffer transition), causing the ||80/||24 fallback to produce a cramped initial layout.
-  const startupCols = process.stdout.columns || 80
-  const startupRows = process.stdout.rows || 24
   emitKeypressEvents(keyStream)
   process.stdin.setRawMode(true)
   // Keyboard enhancement — enable BOTH protocols (unsupported terminals ignore them):
@@ -242,8 +247,8 @@ export async function startTUI(agent, opts = {}) {
   }
   process.on("exit", cleanup)
 
-  const pushLine = (text, color) => {
-    state.lines.push({ text, color })
+  const pushLine = (text, color, kind) => {
+    state.lines.push({ text, color, _kind: kind })
     if (state.lines.length > 5000) {
       state.lines.splice(0, 1000)
       state.lines.unshift({ text: `... [earlier messages trimmed — ${state.lines.length} lines remaining]`, color: C.dim })
@@ -271,13 +276,17 @@ export async function startTUI(agent, opts = {}) {
     const end = full.length - loaded
     if (start >= end) return
 
-    const cols = process.stdout.columns || 80
-    const before = countConvLines(state, cols)
+    const d = state.dims ? state.dims.get() : {}
+    const cols = d.cols ?? ((state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80))
+    const before = countConvLines(state, cols, d.rows ?? (process.stdout.rows || 24))
 
     // Drop the old placeholder, prepend the older page, re-add the placeholder
     // (with an updated count) only if more remain.
     if (state.lines[0]?.text?.startsWith("… ")) state.lines.shift()
-    state.lines.unshift(...historyToLines(full, start, end))
+    state._lineIdCounter = state._lineIdCounter ?? 0
+    const older = historyToLines(full, start, end)
+    for (const l of older) l._lineId = ++state._lineIdCounter
+    state.lines.unshift(...older)
     state._historyLoaded += end - start
     state._hasOlder = start > 0
     if (state._hasOlder) {
@@ -286,7 +295,7 @@ export async function startTUI(agent, opts = {}) {
 
     // Scroll compensation: prepending N display rows must move scroll by N to
     // keep the previously-visible bottom-anchored content in place.
-    const after = countConvLines(state, cols)
+    const after = countConvLines(state, cols, (state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24))
     state.scroll += Math.max(0, after - before)
     render()
   }
@@ -309,8 +318,37 @@ export async function startTUI(agent, opts = {}) {
   const { render, scheduleRender } = renderLoop
 
   process.stdout.on("resize", () => {
-    try { render() } catch { /* resize error — ignore */ }
+    try { state.dims.refresh(); render() } catch { /* resize error — ignore */ }
   })
+  // Startup convergence (2026-08-30 consult, residual fix): ConPTY can report
+  // a stale-small 80 at launch AND keep reporting it for a while — sawValid is
+  // useless as a stop condition there (80 passes the sanity gate), which let
+  // the session lock at 80 until the first turn's finally re-sampled. Run the
+  // FULL window (~4.5s): any growth is accepted immediately by the asymmetric
+  // rule and repaints; the window just bounds how long we keep looking.
+  let startupRetries = 0
+  const startupResampler = setInterval(() => {
+    try {
+      const before = state.dims.get()
+      const after = state.dims.refresh()
+      if (after.cols !== before.cols || after.rows !== before.rows) render()
+      if (++startupRetries >= 30) clearInterval(startupResampler)
+    } catch { /* ignore */ }
+  }, 150)
+  // Idle watchdog (2026-08-30 consult): the ONLY mid-session recovery channel.
+  // ConPTY reports stale-small sizes during output activity, so sampling is
+  // gated on idleness — skipped while processing/streaming or within 500ms of
+  // the last render (heavy output); a confirmed shrink also repaints.
+  const idleResampler = setInterval(() => {
+    try {
+      const recentRender = performance.now() - renderLoop.lastRenderAt < 500
+      if (state.processing || state.streaming || state.reasoning || recentRender) return
+      const before = state.dims.get()
+      const after = state.dims.refresh()
+      if (after.cols !== before.cols || after.rows !== before.rows) render()
+    } catch { /* ignore */ }
+  }, 2000)
+  idleResampler.unref?.()
 
   // ---------------------------------------------------------- Submit
 
@@ -319,9 +357,8 @@ export async function startTUI(agent, opts = {}) {
     if (!text) return
     state.input = []
     state.cursor = 0
-    state.history.push(text)
     const wasInHistory = state.historyIndex !== -1
-    state.history.push(text)
+    state.history.push(text) // review #3 fix: single push (was duplicated — every submit appeared twice in ↑/↓ history)
     state.historyIndex = -1
     if (!wasInHistory) state._draft = null // submitted — the draft is now history. Keep draft when submitting from history mode (↓ can recover)
     state.scroll = 0

package/src/tui/key-handler-search.mjs

@@ -36,7 +36,7 @@ export function scrollToMatch(state, lineIndex) {
   for (let i = 0; i < lineIndex && i < state.lines.length; i++) {
     estimatedLine += Math.max(1, Math.ceil((state.lines[i].text?.length || 0) / 80))
   }
-  const rows = process.stdout.rows || 24
+  const rows = (state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24)
   const visibleH = Math.max(5, rows - 10) // reserve space for header, input, status, etc.
   // scroll is number of lines hidden above viewport
   // We want estimatedLine to be near the bottom of the viewport

package/src/tui/key-handler.mjs

@@ -7,10 +7,12 @@ import { QUESTION_CUSTOM } from "./interaction.mjs"
 
 /** Current conversation max scroll offset (display lines beyond the visible panel). */
 function convMaxScroll(state) {
-  const cols = process.stdout.columns || 80
-  const rows = process.stdout.rows || 24
+  // Single source (Windows ConPTY instability, 2026-08-30) — cached dims.
+  const d = state.dims ? state.dims.get() : {}
+  const cols = d.cols ?? ((state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80))
+  const rows = d.rows ?? (process.stdout.rows || 24)
   const layout = computeLayout(state, { cols, rows })
-  return Math.max(0, countConvLines(state, cols) - layout.panels.conversation.h)
+  return Math.max(0, countConvLines(state, cols, rows) - layout.panels.conversation.h)
 }
 
 /** Keyboard event dispatch: permission confirm / question / picker / wizard / edit / scroll / history / paste.
@@ -154,6 +156,7 @@ export function createKeyHandler(ctx) {
       // 延迟退出可注入（测试传大值并清理定时器，避免定时器在 mock 恢复后调到真 process.exit）
       ctx.exitTimer = setTimeout(() => process.exit(0), ctx.exitDelay ?? 100)
       ctx.exitTimer.unref?.()
+      return // review #5 fix: exiting — don't fall through to later branches
     }
 
     // F1: 显示快捷键帮助
@@ -218,7 +221,7 @@ export function createKeyHandler(ctx) {
       const items = p.filteredItems ?? p.entries.filter((e) => e.type === "item")
       // 可视窗高度：直接取 layout 算出的实际 picker 面板高（含小终端 pickerFinalH 压缩），减标题行。
       // 单一数据源，避免与 layout.mjs 公式漂移
-      const winH = Math.max(1, (computeLayout(state, { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }).panels.picker?.h ?? p.lines.length + 1) - 1)
+      const winH = Math.max(1, (computeLayout(state, { cols: (state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80), rows: (state.dims?.get() ?? {}).rows ?? ((state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24)) }).panels.picker?.h ?? p.lines.length + 1) - 1)
       const applyFilter = (f) => {
         p.filter = f
         p.index = 0
@@ -292,13 +295,13 @@ export function createKeyHandler(ctx) {
       if (state._hasOlder && loadOlder && state.scroll >= convMaxScroll(state)) {
         loadOlder()
       } else {
-        state.scroll += Math.max(1, (process.stdout.rows || 24) - 8)
+        state.scroll += Math.max(1, ((state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24)) - 8)
       }
       render()
       return
     }
     if (key.name === "pagedown") {
-      state.scroll = Math.max(0, state.scroll - Math.max(1, (process.stdout.rows || 24) - 8))
+      state.scroll = Math.max(0, state.scroll - Math.max(1, ((state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24)) - 8))
       render()
       return
     }

package/src/tui/layout.mjs

@@ -3,8 +3,9 @@
  * Computes position and height of each panel from state + terminal dimensions.
  * Does not modify state — side effects are performed by the caller before rendering.
  *
- *   header → conversation → subagent → output → todo → picker → permission → queue → input → status
- *   header → conversation → todo → subagent → output → picker → permission → queue → input → status
+ *   header → conversation → todo → picker → permission → queue → input → status
+ * Subagent activity renders INSIDE the conversation as collapsible blocks
+ * (AGENT-LOOP.md §7.2 D4) — no dedicated subagent/output panels anymore.
  * Fixed panels deducted first, conditional panels allocated by priority, remaining space to conversation.
  */
 import { layoutInput, wrapText } from "./render.mjs"
@@ -19,7 +20,6 @@ function optText(opt) {
 
 const MAX_INPUT_LINES = 5
 const MAX_TASK_LINES = 5
-export const MAX_SUB_LINES = 4
 const QWIN = 5
 
 /**
@@ -70,18 +70,14 @@ export function computeLayout(state, { cols, rows }) {
     const done = state.tasks.filter((t) => t.status === "done")
     visibleTasks = [...inProgress, ...pending, ...done].slice(0, MAX_TASK_LINES)
   }
-  const taskPanelH = visibleTasks.length
+  // +1 for the divider line separating the todo panel from the conversation
+  // (user request 2026-08-30).
+  const taskPanelH = visibleTasks.length > 0 ? visibleTasks.length + 1 : 0
+  // Squeeze target: the divider line yields first under small terminals (the
+  // task rows themselves never compress away — put() truncates by panel h).
+  let todoFinalH = taskPanelH
 
-  // Subagent (only visible during processing; height matches what's actually rendered)
-  const allSubs = state.processing ? Object.values(state.subTasks) : []
-  const subPanelH = allSubs.length > 0
-    ? Math.min(allSubs.length, MAX_SUB_LINES) + (allSubs.length > MAX_SUB_LINES ? 1 : 0)
-    : 0
-
-  // Tool output panels: max 9 lines per panel (1 title + 8 content), capped at reasonable total.
-  // Done panels stay visible until their closeAt grace elapses (render loop prunes them).
-  const panels = Object.values(state.outputPanels ?? {}).filter((p) => !p.done || (p.closeAt ?? 0) > Date.now())
-  const outputPanelsH = panels.length > 0 ? Math.min(panels.length * 9, rows - 10) : 0
+  // Subagent activity: rendered inside the conversation (§7.2 D4) — no panel slot.
 
   // Permission preview (height depends on wrapped content)
   let permPreviewLines = []
@@ -101,7 +97,7 @@ export function computeLayout(state, { cols, rows }) {
   const queueH = state.queue.length > 0 && state.processing ? 1 : 0
 
   // --- elastic panel: conversation takes remaining space ---
-  const fixedH = headerH + inputBoxH + statusH + pickerH + taskPanelH + subPanelH + outputPanelsH + permPreviewH + queueH
+  const fixedH = headerH + inputBoxH + statusH + pickerH + taskPanelH + permPreviewH + queueH
   let convH = Math.max(1, rows - fixedH)
 
   // 小终端高度补偿：先压 conversation 到最小 1 行，再压 picker 到最小 3 行，
@@ -120,15 +116,21 @@ export function computeLayout(state, { cols, rows }) {
       permFinalH = Math.max(1, permPreviewH - remaining)
       convH = Math.max(1, rows - (afterPicker - permPreviewH + permFinalH))
     }
+    // 压缩链末级：todo 面板的分隔线行让位（任务行保留——put 按 h 截断自动
+    // 丢弃第一行的分隔线，2026-08-30 用户请求加的 divider 不得在小终端挤掉输入框）。
+    const afterPerm = afterPicker - permPreviewH + permFinalH
+    const finalOverflow = afterPerm + convH - rows
+    if (finalOverflow > 0 && taskPanelH > visibleTasks.length) {
+      todoFinalH = Math.max(visibleTasks.length, taskPanelH - finalOverflow)
+      convH = Math.max(1, rows - (afterPerm - taskPanelH + todoFinalH))
+    }
   }
 
   // --- Y coordinates (0-indexed, +1 when used with ANSI) ---
   let y = 0
   const header = { y, h: headerH }; y += headerH
   const conversation = { y, h: convH }; y += convH
-  const subagent = subPanelH > 0 ? { y, h: subPanelH } : null; y += subPanelH
-  const output = outputPanelsH > 0 ? { y, h: outputPanelsH } : null; y += outputPanelsH
-  const todo = taskPanelH > 0 ? { y, h: taskPanelH } : null; y += taskPanelH
+  const todo = todoFinalH > 0 ? { y, h: todoFinalH } : null; y += todoFinalH
   const picker = pickerFinalH > 0 ? { y, h: pickerFinalH } : null; y += pickerFinalH
   const permission = permFinalH > 0 ? { y, h: permFinalH } : null; y += permFinalH
   const queue = queueH > 0 ? { y, h: queueH } : null; y += queueH
@@ -137,13 +139,12 @@ export function computeLayout(state, { cols, rows }) {
 
   return {
     W, cols, rows,
-    panels: { header, conversation, picker, todo, subagent, output, permission, queue, inputBox, status },
+    panels: { header, conversation, picker, todo, permission, queue, inputBox, status },
     // precomputed content (affects height, reused during render)
     inputLayout,
     inputOffset,
     boxLines,
     visibleTasks,
-    allSubs,
     permPreviewLines,
     overlay,
   }

package/src/tui/mouse.mjs

@@ -16,6 +16,7 @@
  */
 import { computeLayout } from "./layout.mjs"
 import { buildConvLines } from "./render-conversation.mjs"
+import { toggleFoldBlock } from "./fold-block.mjs"
 
 /** Extract left-click presses from a chunk. Returns [{ col, row }] (1-based). */
 export function parseMouseClicks(text) {
@@ -48,7 +49,9 @@ export function handleMouseClick(ctx, col, row) {
   const { state, render } = ctx
   const r = row - 1 // 0-based screen row
   if (r < 0) return false
-  const dims = { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }
+  // Single source (Windows ConPTY instability, 2026-08-30): the cached dims,
+  // never a live read that can flip between stale and fresh values.
+  const dims = state.dims ? state.dims.get() : { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }
   const layout = computeLayout(state, dims)
   const P = layout.panels
 
@@ -68,15 +71,14 @@ export function handleMouseClick(ctx, col, row) {
 
   // ── Conversation: click a fold marker (expand hint or collapse marker) toggles it ──
   if (r >= P.conversation.y && r < P.conversation.y + P.conversation.h) {
-    const convLines = buildConvLines(state, dims.cols)
+    const convLines = buildConvLines(state, dims.cols, dims.rows)
     const gIdx = convGlobalIndex(convLines.length, P.conversation.h, state.scroll ?? 0)(r - P.conversation.y)
     if (gIdx === null) return false
     const lineEl = convLines[gIdx]
     if (!lineEl?._foldToggle) return false
-    state.expandedBlocks ??= new Set()
-    // Bidirectional: click expands a folded block, collapses an expanded one
-    if (state.expandedBlocks.has(lineEl._foldToggle)) state.expandedBlocks.delete(lineEl._foldToggle)
-    else state.expandedBlocks.add(lineEl._foldToggle)
+    // Bidirectional toggle — single source in fold-block.mjs (expand a folded
+    // block, collapse an expanded one).
+    toggleFoldBlock(state, lineEl._foldToggle)
     render()
     return true
   }

package/src/tui/pickers.mjs

@@ -77,7 +77,7 @@ export function createPickers(ctx) {
     // Fallback to a reasonable default when computeLayout can't run (e.g. test mocks without full state)
     let winH
     try {
-      winH = Math.max(1, (computeLayout(state, { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }).panels.picker?.h ?? lines.length + 1) - 1)
+      winH = Math.max(1, (computeLayout(state, { cols: (state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80), rows: (state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24) }).panels.picker?.h ?? lines.length + 1) - 1)
     } catch {
       winH = 8 // safe fallback for test mocks
     }