@mobius-os/mobius 0.3.9 → 0.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mobius-os/mobius",
-  "version": "0.3.9",
+  "version": "0.3.15",
   "type": "module",
   "description": "Mobius terminal client. Reuses Mobius frontend TypeScript types and jsonl entry shapes.",
   "bin": {

package/src/aimux.ts

@@ -107,6 +107,13 @@ function appendAimuxLog(write: { queue: Promise<void> }, text: string): void {
     .catch(() => {})
 }
 
+// 安装阶段(download/extract/verify)独享的日志队列 —— 与 supervisor 的分离，避免互相阻塞。
+// 关键: 原先安装阶段一行都不写 aimux.log，"卡在解压内置运行时"时日志完全空白 = 黑盒。
+// 现在每个子步骤(连接/首字节/字节增量/解压文件数/import 校验/退出码/耗时)都落盘带时间戳，
+// 下次卡住直接 tail ~/.mobius/aimux.log 就知道卡在第几秒、哪个环节、下了多少 MB。
+const installLogQueue = { queue: Promise.resolve() as Promise<void> }
+const logInstall = (text: string): void => appendAimuxLog(installLogQueue, text)
+
 /** 当前平台对应的内置运行时包名；mac-arm64 走 mac-x64（Rosetta 2）。 */
 export function bundleArch(): string | null {
   const { platform, arch } = process
@@ -139,55 +146,116 @@ async function downloadBundle(arch: string, onProgress?: (p: InstallProgress) =>
   const url = bundleUrl(arch)
   const zipPath = path.join(mobiusHome(), `python-bundle-v${BUNDLE_VER}.zip.tmp`)
   await fs.mkdir(path.dirname(zipPath), { recursive: true })   // 首次安装 ~/.mobius 可能尚未创建
+  const startedAt = Date.now()
+  logInstall(`\n===== bundle download start ${new Date().toISOString()} arch=${arch} =====\n  url=${url}\n`)
+  // fetch 无内置超时：受限网络（训练 pod 出网被掐 / 被透明代理劫持成慢速 chunked）下会永久挂起 → spinner 永转。
+  // 用一个可重置的 AbortController：连接/首字节给 CONNECT_MS，之后每收到一块重置为 STALL_MS，停滞即 abort 并给出可读原因。
+  const CONNECT_MS = 45_000, STALL_MS = 30_000
+  const controller = new AbortController()
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let stallReason = ''
+  const arm = (ms: number, reason: string) => { if (timer) clearTimeout(timer); stallReason = reason; timer = setTimeout(() => controller.abort(), ms) }
+  arm(CONNECT_MS, `连接/首字节超时（${CONNECT_MS / 1000}s 未响应，可能出网被掐）`)
   let res: Response
-  try { res = await fetch(url) } catch (e: any) { return { ok: false, error: `下载失败: ${e?.message ?? e}` } }
-  if (!res.ok) return { ok: false, error: `下载失败: HTTP ${res.status} (${url})` }
+  try { res = await fetch(url, { signal: controller.signal }) }
+  catch (e: any) {
+    if (timer) clearTimeout(timer)
+    const msg = e?.name === 'AbortError' ? `下载失败: ${stallReason}` : `下载失败: ${e?.message ?? e}`
+    logInstall(`  fetch error: ${e?.name} ${e?.message ?? e} elapsed=${Date.now() - startedAt}ms\n`)
+    return { ok: false, error: msg }
+  }
+  if (!res.ok) { if (timer) clearTimeout(timer); logInstall(`  HTTP ${res.status} ${res.statusText}\n`); return { ok: false, error: `下载失败: HTTP ${res.status} (${url})` } }
   const total = Number(res.headers.get('content-length') || 0)
+  logInstall(`  200 OK content-length=${total || 'unknown (chunked)'}\n`)
   const ws = createWriteStream(zipPath)
   let got = 0, last = 0
   try {
     const stream = Readable.fromWeb(res.body as any)
     for await (const chunk of stream) {
+      arm(STALL_MS, `下载停滞超时（已下载 ${(got / 1048576).toFixed(0)}MB，${STALL_MS / 1000}s 无新增数据）`)
       ws.write(chunk as Buffer)
       got += (chunk as Buffer).length
-      if (total && got - last > total * 0.03) { last = got; onProgress?.({ phase: 'install', detail: `下载内置运行时 ${Math.round((got / total) * 100)}%` }) }
+      // 始终反馈进度：有 content-length 用百分比，否则按 3MB 增量报 MB（chunked 传输无 total 时也能动）。
+      if (total) { if (got - last > total * 0.03) { last = got; onProgress?.({ phase: 'install', detail: `下载内置运行时 ${Math.round((got / total) * 100)}%` }) } }
+      else if (got - last > 3 * 1048576) { last = got; onProgress?.({ phase: 'install', detail: `下载内置运行时 ${(got / 1048576).toFixed(0)}MB` }) }
     }
-    if (!total && got) onProgress?.({ phase: 'install', detail: `下载内置运行时 ${(got / 1048576).toFixed(0)}MB` })
+    onProgress?.({ phase: 'install', detail: total ? `下载内置运行时 100%` : `下载内置运行时 ${(got / 1048576).toFixed(0)}MB` })
     await new Promise<void>((resolve, reject) => { ws.end(() => resolve()); ws.on('error', reject) })
+    logInstall(`  done bytes=${got} (${(got / 1048576).toFixed(1)}MB) elapsed=${Date.now() - startedAt}ms avg=${Math.round(got / 1024 / Math.max(1, (Date.now() - startedAt) / 1000))}KB/s\n`)
   } catch (e: any) {
     try { ws.destroy() } catch {}
     try { await fs.unlink(zipPath) } catch {}
-    return { ok: false, error: `下载失败: ${e?.message ?? e}` }
-  }
+    const msg = e?.name === 'AbortError' ? `下载失败: ${stallReason}` : `下载失败: ${e?.message ?? e}`
+    logInstall(`  stream error: ${e?.name} ${e?.message ?? e} got=${got} (${(got / 1048576).toFixed(1)}MB) elapsed=${Date.now() - startedAt}ms\n`)
+    return { ok: false, error: msg }
+  } finally { if (timer) clearTimeout(timer) }
   return { ok: true, zipPath }
 }
 
-async function extractBundle(zipPath: string): Promise<{ ok: boolean; error?: string }> {
+async function extractBundle(zipPath: string, onProgress?: (p: InstallProgress) => void): Promise<{ ok: boolean; error?: string }> {
   const staging = path.join(mobiusHome(), 'python-bundle.new')
   const finalDir = bundleDir()
   const stagingPython = WIN ? path.join(staging, 'python', 'python.exe') : path.join(staging, 'python', 'bin', 'python3')
   await fs.rm(staging, { recursive: true, force: true }).catch(() => {})
   await fs.mkdir(staging, { recursive: true })
-  try { await extract(zipPath, { dir: staging, defaultDirMode: 0o755, defaultFileMode: 0o644 }) }
-  catch (e: any) { await fs.rm(staging, { recursive: true, force: true }).catch(() => {}); return { ok: false, error: `解压失败: ${e?.message ?? e}` } }
+  logInstall(`  extract start → ${staging}\n`)
+  let entryCount = 0
+  const startedAt = Date.now()
+  // 解压几千个小文件在慢盘(网络 FS / CPFS)上可能耗时数十秒；用 onEntry 计数周期性反馈进度，
+  // 避免"解压内置运行时…"文案在漫长解压期间一动不动 = 看起来像死机。
+  try {
+    await extract(zipPath, {
+      dir: staging, defaultDirMode: 0o755, defaultFileMode: 0o644,
+      onEntry: () => { entryCount += 1; if (entryCount % 300 === 0) onProgress?.({ phase: 'install', detail: `解压内置运行时… ${entryCount} 个文件` }) },
+    })
+  } catch (e: any) { await fs.rm(staging, { recursive: true, force: true }).catch(() => {}); logInstall(`  extract error: ${e?.message ?? e} entries=${entryCount}\n`); return { ok: false, error: `解压失败: ${e?.message ?? e}` } }
+  logInstall(`  extract done entries=${entryCount} elapsed=${Date.now() - startedAt}ms\n`)
   if (!WIN) try { await fs.chmod(stagingPython, 0o755) } catch {}   // 保险：确保可执行位（extract-zip 通常已还原）
   await fs.rm(finalDir, { recursive: true, force: true }).catch(() => {})
   await fs.rename(staging, finalDir)
   return { ok: true }
 }
 
+/** 解压后校验内置 python 能 import aimux。用 spawn（非阻塞 spawnSync）避免冻结 Ink 渲染；
+ *  60s 上限强杀（首次 import 在慢盘上可能慢，但不会无限）；stderr(traceback) 落日志，让"解压完仍卡"可诊断。 */
+async function verifyBundle(onProgress?: (p: InstallProgress) => void): Promise<{ ok: boolean; error?: string }> {
+  onProgress?.({ phase: 'install', detail: '校验内置运行时（首次 import aimux，可能耗时）…' })
+  const py = bundlePython()
+  logInstall(`  verify start: ${py} -c "import aimux…" (expect v${BUNDLE_AIMUX_VERSION})\n`)
+  const startedAt = Date.now()
+  return new Promise(resolve => {
+    let child: ChildProcess
+    try { child = spawn(py, ['-c', bundleHealthCheckCode()], { windowsHide: true }) }
+    catch (e: any) { resolve({ ok: false, error: `校验失败: ${e?.message ?? e}` }); return }
+    let stderr = ''
+    const timer = setTimeout(() => { try { child.kill('SIGKILL') } catch {}; resolve({ ok: false, error: `校验超时（60s 未完成 import aimux，疑似慢盘）· 日志: ${aimuxLogPath()}` }) }, 60_000)
+    child.stdout?.on('data', b => logInstall(`  verify stdout: ${b.toString('utf8').slice(-200)}`))
+    child.stderr?.on('data', b => { stderr += b.toString('utf8') })
+    child.on('error', e => { clearTimeout(timer); resolve({ ok: false, error: `校验失败: ${e.message}` }) })
+    child.on('close', code => {
+      clearTimeout(timer)
+      logInstall(`  verify exit code=${code} elapsed=${Date.now() - startedAt}ms stderr=${stderr.slice(-300) || '(empty)'}\n`)
+      if (code === 0) resolve({ ok: true })
+      else resolve({ ok: false, error: `内置运行时无法 import aimux (code=${code}) · 日志: ${aimuxLogPath()}` })
+    })
+  })
+}
+
 export async function ensureFromBundle(onProgress?: (p: InstallProgress) => void): Promise<{ ok: boolean; error?: string; launcher?: AimuxLauncher }> {
-  if (bundleReady()) return { ok: true, launcher: { kind: 'module', python: bundlePython() } }
+  if (bundleReady()) { logInstall(`bundle fast-path: python-bundle already ready\n`); return { ok: true, launcher: { kind: 'module', python: bundlePython() } } }
   const arch = bundleArch()
   if (!arch) return { ok: false, error: `当前平台无内置运行时 (platform=${process.platform} arch=${process.arch})` }
+  logInstall(`bundle install begin: arch=${arch} platform=${process.platform} home=${mobiusHome()}\n`)
   onProgress?.({ phase: 'install', detail: `下载内置运行时 (${arch})…` })
   const dl = await downloadBundle(arch, onProgress)
   if (!dl.ok || !dl.zipPath) return { ok: false, error: dl.error }
   onProgress?.({ phase: 'install', detail: '解压内置运行时…' })
-  const ex = await extractBundle(dl.zipPath)
+  const ex = await extractBundle(dl.zipPath, onProgress)
   try { await fs.unlink(dl.zipPath) } catch {}
   if (!ex.ok) return { ok: false, error: ex.error }
-  if (!bundleReady()) return { ok: false, error: '内置运行时解压后仍无法 import aimux' }
+  const v = await verifyBundle(onProgress)
+  if (!v.ok) return { ok: false, error: v.error ?? '内置运行时解压后仍无法 import aimux' }
+  logInstall(`bundle install OK\n`)
   return { ok: true, launcher: { kind: 'module', python: bundlePython() } }
 }
 
@@ -203,8 +271,10 @@ export const downloadBundleForTest = downloadBundle
 
 export async function ensureAimux(onProgress?: (p: InstallProgress) => void): Promise<{ ok: boolean; error?: string; launcher?: AimuxLauncher }> {
   // Fast-path：venv 里已有 aimux 可执行 → 直接用。
-  if (existsSync(aimuxExe()) && existsSync(venvPython())) { onProgress?.({ phase: 'ready' }); return { ok: true, launcher: { kind: 'exe', path: aimuxExe() } } }
+  if (existsSync(aimuxExe()) && existsSync(venvPython())) { logInstall(`ensureAimux fast-path: venv aimux exe present\n`); onProgress?.({ phase: 'ready' }); return { ok: true, launcher: { kind: 'exe', path: aimuxExe() } } }
+  logInstall(`\n########## ensureAimux install begin ${new Date().toISOString()} platform=${process.platform} arch=${process.arch} home=${mobiusHome()} ##########\n`)
   const py = await pythonForAimux(onProgress)
+  logInstall(`  pythonForAimux → ${py ?? '(null: no system python)'}\n`)
   let venvError = '未找到 Python。请先安装 Python 3.10+（或安装 uv 后重试）。'
   if (py) {
     onProgress?.({ phase: 'venv', detail: `创建 Python 虚拟环境（${py}）…` })
@@ -222,9 +292,11 @@ export async function ensureAimux(onProgress?: (p: InstallProgress) => void): Pr
     }
   }
   // ── Plan B 兜底：本地 python/venv 不可用 → 下载内置 python+aimux 运行时 ──
+  logInstall(`  venv path failed (${venvError || ''}) → falling back to bundle\n`)
   onProgress?.({ phase: 'install', detail: '本地 Python 不可用，改用内置运行时…' })
   const bundle = await ensureFromBundle(onProgress)
   if (bundle.ok && bundle.launcher) { onProgress?.({ phase: 'ready' }); return { ok: true, launcher: bundle.launcher } }
+  logInstall(`########## ensureAimux FAILED: ${venvError}；内置运行时也失败: ${bundle.error} ##########\n`)
   return { ok: false, error: `${venvError}；内置运行时也失败: ${bundle.error}` }
 }
 
@@ -450,7 +522,7 @@ export async function startAimuxConnection(opts: { server: string; token: string
       phase: p.phase === 'ready' ? 'connecting' : p.phase,
       detail: p.detail || (p.phase === 'ready' ? 'AIMUX 已就绪，准备连接…' : p.phase),
     }))
-    if (!ready.ok || !ready.launcher) { onStatus({ state: 'failed', phase: 'idle', detail: ready.error }); return }
+    if (!ready.ok || !ready.launcher) { logInstall(`startAimuxConnection giving up: ${ready.error}\n`); onStatus({ state: 'failed', phase: 'idle', detail: `${ready.error} · 日志: ${aimuxLogPath()}` }); return }
     const identifier = tuiAimuxIdentifier()
     const launcher = ready.launcher
     supervisor = new AimuxSupervisor({

package/src/components/Chat.tsx

@@ -8,7 +8,7 @@
  * activity, composer, and a persistent context status line.
  */
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { Box, Static, Text, useInput, useStdout } from 'ink'
+import { Box, Text, useInput, useStdout } from 'ink'
 import { useChat } from '../hooks/useChat.js'
 import { MobiusClient } from '../api.js'
 import { renderMarkdownLines } from '../markdown.js'
@@ -17,7 +17,7 @@ import type { ReadyState } from './PrepScreen.js'
 import type { AnyEntry } from '../types.js'
 import type { AimuxStatus } from '../aimux.js'
 import { AimuxStatusLine, aimuxStatusText } from './AimuxStatus.js'
-import { isEscapeKeypress } from './primitives.js'
+import { isEscapeKeypress, isMouseInput, useMouseWheel } from './primitives.js'
 
 interface ChatProps {
   client: MobiusClient
@@ -38,6 +38,8 @@ interface TerminalSize {
 
 import { createRequire } from 'node:module'
 const VERSION = createRequire(import.meta.url)('../../package.json').version
+const DEFAULT_COMPOSER_ROWS = 5
+const STATUS_ROWS = 3
 
 const SLASH_COMMANDS = [
   { cmd: '/clear', desc: '清空当前对话，开启新会话' },
@@ -49,6 +51,8 @@ const SLASH_COMMANDS = [
 export function ChatScreen({ client, ready, webUserId, resumeSessionId, onClear, onResume, onQuit, aimuxStatus }: ChatProps) {
   const chat = useChat({ client, ready, resumeSessionId })
   const [showHelp, setShowHelp] = useState(false)
+  const [scrollBack, setScrollBack] = useState(0)
+  const [composerRows, setComposerRows] = useState(DEFAULT_COMPOSER_ROWS)
   const [modelLabel, setModelLabel] = useState<string | null>(null)
   const terminal = useTerminalSize()
 
@@ -71,18 +75,13 @@ export function ChatScreen({ client, ready, webUserId, resumeSessionId, onClear,
       return
     }
     setShowHelp(false)
+    setScrollBack(0)
     void chat.send(t)
   }, [chat, runSlash])
 
-  // Welcome card is for a truly fresh session only — once there's any
-  // conversation (or an in-flight message) it disappears. The transcript then
-  // streams into <Static> below and accumulates into the terminal scrollback
-  // (the terminal's own scrollback holds history; no in-app pager needed).
-  const showWelcome = chat.entries.length === 0 && chat.pendingUser === null
-
   // First query of a fresh session triggers the full backend bootstrap (lazy
   // session creation, worker spawn, context load) before any output streams.
-  // Label that phase "Initializing for the first query" instead of "Working"
+  // Label that phase "第一个问题，正在初始化+全平台同步中，请稍候" instead of "Working"
   // so it reads as startup rather than a stuck agent. Once the first assistant
   // output is observed (or the session is a resumed one with prior history),
   // the indicator falls back to the normal Working label for every turn.
@@ -92,6 +91,29 @@ export function ChatScreen({ client, ready, webUserId, resumeSessionId, onClear,
   // (type:user / response_item.message[user] / event_msg.user_message) 合并成 1 条,
   // 避免在累积视图里把同一条提问显示多次.
   const dedupedEntries = useMemo(() => dedupeUserEntries(chat.entries), [chat.entries])
+  const viewportRows = terminal.isTty ? Math.max(9, terminal.rows - 1) : terminal.rows
+  const activityRows = (chat.typing ? 2 : 0) + (chat.error ? 1 : 0)
+  const helpRows = showHelp ? SLASH_COMMANDS.length + 3 : 0
+  const transcriptRows = Math.max(1, viewportRows - composerRows - STATUS_ROWS - activityRows - helpRows - 3)
+  const fitted = useMemo(
+    () => fitTranscript(dedupedEntries, transcriptRows, terminal.columns, scrollBack),
+    [dedupedEntries, transcriptRows, terminal.columns, scrollBack],
+  )
+  const showWelcome = dedupedEntries.length === 0 && chat.pendingUser === null && scrollBack === 0
+
+  // Keep a history page pinned while new events stream in. At the latest page,
+  // new output continues to auto-follow as usual.
+  const prevLenRef = useRef(dedupedEntries.length)
+  useEffect(() => {
+    const previous = prevLenRef.current
+    const current = dedupedEntries.length
+    prevLenRef.current = current
+    if (current > previous && scrollBack > 0) {
+      setScrollBack(value => value + current - previous)
+    } else if (scrollBack > current) {
+      setScrollBack(current)
+    }
+  }, [dedupedEntries.length, scrollBack])
 
   // Show the model's friendly label (e.g. "GPT-5.6-Sol") in the header/status
   // instead of its opaque key (e.g. "codex:mobiusdefaultaabb").
@@ -106,45 +128,86 @@ export function ChatScreen({ client, ready, webUserId, resumeSessionId, onClear,
   }, [client, ready.prefs.model])
   const modelDisplay = modelLabel ?? ready.prefs.model ?? 'default'
 
+  useInput((_input, key) => {
+    const step = Math.max(1, fitted.entries.length)
+    if (key.pageUp) setScrollBack(value => Math.min(dedupedEntries.length, value + step))
+    else if (key.pageDown) setScrollBack(value => Math.max(0, value - step))
+  })
+
+  // Mouse wheel: up scrolls back through history, down returns toward the
+  // latest, mirroring PageUp/PageDown but in small fixed steps. Handled on the
+  // Ink event emitter (not useInput) so the sequence can be buffered across
+  // read() chunks; the Composer guards against inserting mouse bytes as text.
+  useMouseWheel((delta) => {
+    if (delta === 0) return
+    const step = 3
+    setScrollBack(value => Math.min(dedupedEntries.length, Math.max(0, value + delta * step)))
+  })
+
+  const olderHint = !showWelcome && (fitted.hiddenOlder > 0 || scrollBack > 0)
+    ? fitted.hiddenOlder > 0
+      ? `↑ 还有 ${fitted.hiddenOlder} 条较早记录 · 滚轮/PageUp 向上翻页`
+      : '已到最早记录 · 滚轮/PageDown 向下翻页'
+    : null
+
   return (
-    <Box flexDirection="column" width={terminal.isTty ? terminal.columns : undefined} paddingX={1}>
-      {showWelcome ? (
-        <WelcomeCard ready={ready} columns={terminal.columns} resumed={Boolean(resumeSessionId)} modelDisplay={modelDisplay} />
-      ) : null}
+    <Box
+      flexDirection="column"
+      width={terminal.isTty ? terminal.columns : undefined}
+      height={terminal.isTty ? viewportRows : undefined}
+      paddingX={1}
+      overflowY="hidden"
+    >
+      <Box flexDirection="column" flexGrow={1} flexShrink={1} overflowY="hidden">
+        {showWelcome
+          ? <WelcomeCard ready={ready} columns={terminal.columns} resumed={Boolean(resumeSessionId)} modelDisplay={modelDisplay} />
+          : <CompactHeader ready={ready} sessionId={chat.sessionId} columns={terminal.columns} />}
+
+        {/* Older-records hint is pinned OUTSIDE the flex-end scroll box so it is
+            always the first line of the transcript, spanning the full width,
+            instead of floating mid-screen when the transcript has spare rows. */}
+        {olderHint !== null
+          ? <Box width="100%" flexShrink={0}><Text dimColor>  {olderHint}</Text></Box>
+          : null}
+
+        <Box flexGrow={1} flexShrink={1} flexDirection="column" justifyContent={showWelcome ? 'flex-start' : 'flex-end'} overflowY="hidden">
+          {fitted.entries.map((entry, index) => (
+            <EntryAccum key={entry.__id ?? `entry-${fitted.startIndex + index}`} entry={entry} columns={terminal.columns} />
+          ))}
+          {chat.pendingUser !== null ? <UserLine text={chat.pendingUser} /> : null}
+          {fitted.hiddenRecent > 0
+            ? <Box width="100%" flexShrink={0}><Text dimColor>  ↓ 滚轮/PageDown 向下翻页 · 较新 {fitted.hiddenRecent} 条</Text></Box>
+            : null}
+        </Box>
 
-      {/* <Static> 累积输出: 每个 entry 永久打印进终端 scrollback, 不参与动态重绘.
-          新 entry 只追加打印, 历史靠终端自身滚动, 不再需要 in-app 翻页/视窗裁剪. */}
-      <Static items={dedupedEntries}>
-        {(entry, index) => (
-          <EntryAccum key={entry.__id ?? `e${index}`} entry={entry} columns={terminal.columns} />
-        )}
-      </Static>
-
-      {chat.pendingUser !== null ? <UserLine text={chat.pendingUser} /> : null}
-      {chat.typing ? <WorkingIndicator firstQuery={firstQueryInFlight} /> : null}
-      {chat.error ? <Text color="red">⚠ {chat.error}</Text> : null}
-
-      {chat.entries.length === 0 && chat.pendingUser === null && !showHelp
-        ? <Box marginTop={1}><Text dimColor>输入问题开始协作，或输入 <Text color="cyan">/</Text> 查看命令。</Text></Box>
-        : null}
-
-      {showHelp ? <HelpBlock commands={SLASH_COMMANDS} /> : null}
-
-      <Composer
-        onSubmit={onSubmit}
-        onStop={chat.stop}
-        onQuit={onQuit}
-        typing={chat.typing}
-        commands={SLASH_COMMANDS}
-      />
-      <StatusArea
-        ready={ready}
-        sessionId={chat.sessionId}
-        columns={terminal.columns}
-        webUrl={buildWebUrl(client.server, webUserId, ready, chat.sessionId)}
-        aimuxStatus={aimuxStatus}
-        modelDisplay={modelDisplay}
-      />
+        {dedupedEntries.length === 0 && chat.pendingUser === null && !showHelp
+          ? <Box marginTop={1}><Text dimColor>输入问题开始协作，或输入 <Text color="cyan">/</Text> 查看命令。</Text></Box>
+          : null}
+
+        {showHelp ? <HelpBlock commands={SLASH_COMMANDS} /> : null}
+      </Box>
+
+      <Box flexDirection="column" flexShrink={0}>
+        {chat.typing ? <WorkingIndicator firstQuery={firstQueryInFlight} /> : null}
+        {chat.error ? <Text color="red">⚠ {chat.error}</Text> : null}
+
+        <Composer
+          onSubmit={onSubmit}
+          onStop={chat.stop}
+          onQuit={onQuit}
+          typing={chat.typing}
+          commands={SLASH_COMMANDS}
+          onHeightChange={setComposerRows}
+        />
+        <StatusArea
+          ready={ready}
+          sessionId={chat.sessionId}
+          columns={terminal.columns}
+          webUrl={buildWebUrl(client.server, webUserId, ready, chat.sessionId)}
+          aimuxStatus={aimuxStatus}
+          modelDisplay={modelDisplay}
+        />
+      </Box>
     </Box>
   )
 }
@@ -152,8 +215,8 @@ export function ChatScreen({ client, ready, webUserId, resumeSessionId, onClear,
 function useTerminalSize(): TerminalSize {
   const { stdout } = useStdout()
   const read = useCallback((): TerminalSize => ({
-    columns: Math.max(40, stdout.columns ?? 80),
-    rows: Math.max(16, stdout.rows ?? 24),
+    columns: Math.max(20, stdout.columns ?? 80),
+    rows: Math.max(10, stdout.rows ?? 24),
     isTty: Boolean(stdout.isTTY && stdout.columns && stdout.rows),
   }), [stdout])
   const [size, setSize] = useState<TerminalSize>(read)
@@ -169,7 +232,7 @@ function useTerminalSize(): TerminalSize {
 
 function WelcomeCard({ ready, columns, resumed, modelDisplay }: { ready: ReadyState; columns: number; resumed: boolean; modelDisplay: string }) {
   const cwd = compactPath(process.cwd())
-  const width = Math.max(38, Math.min(68, columns - 4))
+  const width = Math.max(18, Math.min(68, columns - 4))
   const labelWidth = 11
   return (
     <Box flexDirection="column">
@@ -202,6 +265,16 @@ function MetaRow({ label, value, hint, labelWidth }: { label: string; value: str
   )
 }
 
+function CompactHeader({ ready, sessionId, columns }: { ready: ReadyState; sessionId: string | null; columns: number }) {
+  const context = `${ready.project.name} › ${ready.issue.title}${sessionId ? ` · ${sessionId.slice(0, 8)}` : ''}`
+  return (
+    <Box justifyContent="space-between">
+      <Text bold><Text dimColor>{'>_ '}</Text>Mobius</Text>
+      <Text dimColor>{truncateDisplay(context, columns - 14)}</Text>
+    </Box>
+  )
+}
+
 function EntryAccum({ entry, columns }: { entry: AnyEntry; columns: number }) {
   const views = viewsForEntry(entry)
   return (
@@ -212,7 +285,7 @@ function EntryAccum({ entry, columns }: { entry: AnyEntry; columns: number }) {
 }
 
 function ViewLine({ view, columns }: { view: EntryView; columns: number }) {
-  const width = Math.max(20, columns - 4)
+  const width = Math.max(8, columns - 4)
   switch (view.kind) {
     case 'skip':
       return null
@@ -365,7 +438,7 @@ function WorkingIndicator({ firstQuery }: { firstQuery: boolean }) {
   const secs = Math.floor((Date.now() - startedAt.current) / 1000)
   const elapsed = secs >= 60 ? `${Math.floor(secs / 60)}m ${String(secs % 60).padStart(2, '0')}s` : `${secs}s`
   const label = firstQuery
-    ? `• Initializing for the first query (${elapsed})`
+    ? `• 第一个问题，正在初始化+全平台同步中，请稍候 (${elapsed})`
     : `• Working (${elapsed} · esc to interrupt)`
   return (
     <Box marginTop={1}>
@@ -408,15 +481,28 @@ interface ComposerProps {
   onQuit: () => void
   typing: boolean
   commands: { cmd: string; desc: string }[]
+  onHeightChange?: (rows: number) => void
 }
 
-function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps) {
+export function Composer({ onSubmit, onStop, onQuit, typing, commands, onHeightChange }: ComposerProps) {
   const [value, setValue] = useState('')
   const [cursor, setCursor] = useState(0)
   const [popupIdx, setPopupIdx] = useState(0)
   const [popupDismissed, setPopupDismissed] = useState(false)
   const historyRef = useRef<string[]>([])
   const [histIdx, setHistIdx] = useState<number | null>(null)
+  const valueRef = useRef(value)
+  const cursorRef = useRef(cursor)
+  const pasteRef = useRef<ComposerPasteState>({
+    bracketed: false,
+    bracketedBuffer: '',
+    burstActive: false,
+    consecutivePlain: 0,
+    lastChunkAt: 0,
+    lastChunkLength: 0,
+    timer: null,
+  })
+  const { stdout } = useStdout()
 
   const filtered = useMemo(() => {
     const match = /^(\w*)$/.exec(value.slice(1))
@@ -429,14 +515,143 @@ function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps)
   const popupOpen = !popupDismissed && value.startsWith('/') && filtered.length > 0 && value.trim() !== filtered[popupIdx]?.cmd
 
   function edit(next: string, nextCursor: number) {
+    valueRef.current = next
+    cursorRef.current = nextCursor
     setValue(next)
     setCursor(nextCursor)
   }
 
+  function insertText(text: string) {
+    if (!text) return
+    const current = valueRef.current
+    const at = clampCursor(current, cursorRef.current)
+    const normalized = normalizeComposerPaste(text)
+    edit(current.slice(0, at) + normalized + current.slice(at), at + normalized.length)
+  }
+
+  function schedulePasteBurstReset() {
+    const state = pasteRef.current
+    if (state.timer) clearTimeout(state.timer)
+    state.timer = setTimeout(() => {
+      state.burstActive = false
+      state.consecutivePlain = 0
+      state.lastChunkLength = 0
+      state.timer = null
+    }, pasteBurstWindowMs())
+  }
+
+  function resetPasteBurst() {
+    const state = pasteRef.current
+    if (state.timer) clearTimeout(state.timer)
+    state.bracketed = false
+    state.bracketedBuffer = ''
+    state.burstActive = false
+    state.consecutivePlain = 0
+    state.lastChunkAt = 0
+    state.lastChunkLength = 0
+    state.timer = null
+  }
+
+  function handleBracketedPasteInput(raw: string): boolean {
+    const state = pasteRef.current
+    const start = findPasteMarker(raw, '200')
+    const end = findPasteMarker(raw, '201')
+
+    if (!state.bracketed && start >= 0) {
+      const markerLength = pasteMarkerLength(raw, start, '200')
+      const payloadStart = start + markerLength
+      const endAfterStart = findPasteMarker(raw, '201', payloadStart)
+      if (endAfterStart >= 0) {
+        const endLength = pasteMarkerLength(raw, endAfterStart, '201')
+        insertText(raw.slice(payloadStart, endAfterStart) + raw.slice(endAfterStart + endLength))
+        resetPasteBurst()
+      } else {
+        state.bracketed = true
+        state.bracketedBuffer = raw.slice(payloadStart)
+      }
+      return true
+    }
+
+    if (!state.bracketed) return false
+    if (end >= 0) {
+      const endLength = pasteMarkerLength(raw, end, '201')
+      state.bracketedBuffer += raw.slice(0, end)
+      state.bracketedBuffer += raw.slice(end + endLength)
+      insertText(state.bracketedBuffer)
+      resetPasteBurst()
+    } else {
+      state.bracketedBuffer += raw
+    }
+    return true
+  }
+
+  function moveVertical(direction: -1 | 1) {
+    const current = valueRef.current
+    const at = clampCursor(current, cursorRef.current)
+    const lineStart = current.lastIndexOf('\n', Math.max(0, at - 1)) + 1
+    const column = at - lineStart
+    const lineEnd = current.indexOf('\n', at)
+    const currentEnd = lineEnd < 0 ? current.length : lineEnd
+    const targetStart = direction < 0
+      ? current.lastIndexOf('\n', Math.max(0, lineStart - 2)) + 1
+      : (currentEnd < current.length ? currentEnd + 1 : current.length)
+    if (direction < 0 && lineStart === 0) return
+    if (direction > 0 && currentEnd === current.length) return
+    const targetEndRel = current.indexOf('\n', targetStart)
+    const targetEnd = targetEndRel < 0 ? current.length : targetEndRel
+    edit(current, targetStart + Math.min(column, targetEnd - targetStart))
+  }
+
+  function moveCursor(next: number) {
+    cursorRef.current = next
+    setCursor(next)
+  }
+
+  useEffect(() => {
+    if (!stdout.isTTY) return
+    // Match Codex/crossterm: request explicit paste events so embedded Enters
+    // stay inside the textarea. The burst detector below remains the fallback
+    // for terminals and remote chains that ignore bracketed-paste mode.
+    stdout.write('\x1b[?2004h')
+    return () => { stdout.write('\x1b[?2004l') }
+  }, [stdout])
+
+  useEffect(() => () => resetPasteBurst(), [])
+
   useInput((input, key) => {
+    if (isMouseInput(input)) return // mouse events must never become typed text
+    const now = Date.now()
     const escape = isEscapeKeypress(input, key)
     if (typing && escape) { void onStop(); return }
 
+    if (pasteRef.current.bracketed && key.return) {
+      pasteRef.current.bracketedBuffer += '\n'
+      return
+    }
+
+    // Ink 5 incorrectly marks a plain carriage-return as Shift because "\r" is
+    // unchanged by toUpperCase(). Detect enhanced-keyboard Shift+Enter from its
+    // raw sequence instead of trusting key.shift on an ordinary Enter event.
+    if (isEnhancedNewlineInput(input)) { insertText('\n'); return }
+
+    // Terminals that support bracketed paste wrap the payload in ESC[200~ / ESC[201~.
+    // Ink's parser strips a leading ESC, so accept both the raw and stripped marker forms.
+    if (handleBracketedPasteInput(input)) return
+
+    const current = valueRef.current
+    const at = clampCursor(current, cursorRef.current)
+
+    // A few terminals (notably ConPTY and some SSH/tmux combinations) do not expose
+    // bracketed paste. They deliver a paste as fast text chunks separated by Enter events.
+    // Track that short burst so those Enters become newlines instead of submitting each line.
+    if (!key.return && input && !key.ctrl && !key.meta && /[\r\n]/.test(input)) {
+      insertText(input)
+      pasteRef.current.burstActive = false
+      pasteRef.current.lastChunkAt = now
+      pasteRef.current.lastChunkLength = 0
+      return
+    }
+
     if (popupOpen) {
       if (key.upArrow) { setPopupIdx(i => (i <= 0 ? filtered.length - 1 : i - 1)); return }
       if (key.downArrow) { setPopupIdx(i => (i + 1) % filtered.length); return }
@@ -448,9 +663,22 @@ function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps)
     }
 
     if (key.return) {
-      if (value.trim()) {
-        historyRef.current.push(value)
-        onSubmit(value)
+      const state = pasteRef.current
+      const inPasteBurst = state.burstActive || (
+        state.lastChunkLength > 1 && now - state.lastChunkAt <= pasteBurstWindowMs()
+      )
+      if (inPasteBurst && !key.ctrl && !key.meta) {
+        insertText('\n')
+        state.burstActive = true
+        state.lastChunkAt = now
+        state.lastChunkLength = 0
+        schedulePasteBurstReset()
+        return
+      }
+      const submitted = valueRef.current
+      if (submitted.trim()) {
+        historyRef.current.push(submitted)
+        onSubmit(submitted)
         edit('', 0)
         setHistIdx(null)
       }
@@ -459,14 +687,24 @@ function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps)
     if (key.ctrl && input === 'c') { typing ? void onStop() : onQuit(); return }
     // Ink reports the terminal Backspace key (\x7f) as `key.delete`; handle both
     // as a backward delete so Backspace works at the end of the input.
-    if (key.backspace || key.delete) {
-      if (cursor > 0) edit(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1)
+    if (key.backspace || key.delete || (key.ctrl && (input === 'h' || input === 'w'))) {
+      if (at > 0) {
+        if (key.ctrl && input === 'w') {
+          const before = current.slice(0, at)
+          const match = before.match(/\S+\s*$/)
+          const cut = match ? match[0].length : 0
+          edit(current.slice(0, at - cut) + current.slice(at), at - cut)
+        } else {
+          const previous = previousCursorBoundary(current, at)
+          edit(current.slice(0, previous) + current.slice(at), previous)
+        }
+      }
       return
     }
-    if (key.leftArrow) { setCursor(current => Math.max(0, current - 1)); return }
-    if (key.rightArrow) { setCursor(current => Math.min(value.length, current + 1)); return }
+    if (key.leftArrow) { moveCursor(previousCursorBoundary(current, at)); return }
+    if (key.rightArrow) { moveCursor(nextCursorBoundary(current, at)); return }
 
-    const onFirstLine = value.slice(0, cursor).indexOf('\n') === -1
+    const onFirstLine = current.slice(0, at).indexOf('\n') === -1
     if (key.upArrow && onFirstLine) {
       const history = historyRef.current
       if (history.length) {
@@ -476,6 +714,7 @@ function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps)
       }
       return
     }
+    if (key.upArrow) { moveVertical(-1); return }
     if (key.downArrow && histIdx !== null) {
       const history = historyRef.current
       const next = histIdx + 1
@@ -483,22 +722,37 @@ function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps)
       else { setHistIdx(next); edit(history[next], history[next].length) }
       return
     }
-    if (key.ctrl && input === 'a') { setCursor(0); return }
-    if (key.ctrl && input === 'e') { setCursor(value.length); return }
+    if (key.downArrow) { moveVertical(1); return }
+    if (key.ctrl && input === 'a') { moveCursor(0); return }
+    if (key.ctrl && input === 'e') { moveCursor(current.length); return }
     if (key.ctrl && input === 'u') { edit('', 0); return }
-    if (key.ctrl && input === 'k') { edit(value.slice(0, cursor), cursor); return }
-    if (key.ctrl && input === 'j') { edit(value.slice(0, cursor) + '\n' + value.slice(cursor), cursor + 1); return }
+    if (key.ctrl && input === 'k') { edit(current.slice(0, at), at); return }
+    if (key.ctrl && input === 'j') { insertText('\n'); return }
     if (key.ctrl || key.meta || escape || !input) return
-    edit(value.slice(0, cursor) + input + value.slice(cursor), cursor + input.length)
+
+    const chunkAt = pasteRef.current
+    const continuesBurst = chunkAt.lastChunkAt > 0 && now - chunkAt.lastChunkAt <= pasteBurstWindowMs()
+    chunkAt.consecutivePlain = continuesBurst ? chunkAt.consecutivePlain + 1 : 1
+    if (input.length > 1 || chunkAt.consecutivePlain >= 3) {
+      chunkAt.burstActive = true
+      schedulePasteBurstReset()
+    }
+    insertText(input)
+    chunkAt.lastChunkAt = now
+    chunkAt.lastChunkLength = input.length
   })
 
-  const lines = value.split('\n')
-  const lineIdx = value.slice(0, cursor).match(/\n/g)?.length ?? 0
-  const col = cursor - (value.slice(0, cursor).lastIndexOf('\n') + 1)
-  const currentLine = lines[lineIdx] ?? ''
-  const beforeCursor = currentLine.slice(0, col)
-  const atCursor = currentLine.slice(col, col + 1)
-  const afterCursor = currentLine.slice(col + 1)
+  const composerWidth = Math.max(12, (stdout.columns ?? 80) - 9)
+  const wrapped = wrapComposerLines(value, composerWidth)
+  const visualCursor = findComposerCursorLine(wrapped, clampCursor(value, cursor))
+  const maxRows = Math.max(3, Math.min(10, Math.floor((stdout.rows ?? 24) * 0.42)))
+  const firstVisible = Math.max(0, Math.min(visualCursor - maxRows + 1, visualCursor))
+  const visible = wrapped.slice(firstVisible, firstVisible + maxRows)
+  const renderedRows = 4 + visible.length + (popupOpen ? filtered.length + 1 : 0)
+
+  useEffect(() => {
+    onHeightChange?.(renderedRows)
+  }, [onHeightChange, renderedRows])
 
   return (
     <Box flexDirection="column" marginTop={1}>
@@ -515,28 +769,141 @@ function Composer({ onSubmit, onStop, onQuit, typing, commands }: ComposerProps)
           ))}
         </Box>
       ) : null}
-      <Box>
-        <Text bold>{'› '}</Text>
-        <Text>
-          {lines.map((line, index) => {
-            if (index < lineIdx) return <Text key={index}>{line}{'\n'}</Text>
-            if (index === lineIdx) {
-              return (
-                <Text key={index}>
-                  {beforeCursor}<Text backgroundColor="white" color="black">{atCursor || ' '}</Text>{afterCursor}
-                  {index < lines.length - 1 ? '\n' : ''}
-                </Text>
-              )
-            }
-            return <Text key={index}>{'\n'}{line}</Text>
+      <Box
+        flexDirection="column"
+        borderStyle="round"
+        borderColor={typing ? 'yellow' : 'gray'}
+        borderDimColor={!typing}
+        paddingX={1}
+      >
+        <Box flexDirection="column" height={Math.min(maxRows, wrapped.length)} overflow="hidden">
+          {visible.map((line, index) => {
+            const realIndex = firstVisible + index
+            const isCursorLine = realIndex === visualCursor
+            const c = isCursorLine ? clampCursor(value, cursor) - line.start : -1
+            const before = isCursorLine ? line.text.slice(0, Math.max(0, c)) : line.text
+            const atCursor = isCursorLine ? line.text.slice(Math.max(0, c), Math.max(0, c) + 1) : ''
+            const after = isCursorLine ? line.text.slice(Math.max(0, c) + 1) : ''
+            return (
+              <Text key={`${line.start}-${realIndex}`}>
+                {index === 0 ? <Text bold>{firstVisible > 0 ? '… ' : '› '}</Text> : <Text>{'  '}</Text>}
+                {isCursorLine
+                  ? <>{before}<Text backgroundColor="white" color="black">{atCursor || ' '}</Text>{after}</>
+                  : line.text}
+                {value === '' && index === 0 ? <Text dimColor> 输入问题或 / 命令</Text> : null}
+              </Text>
+            )
           })}
-          {value === '' ? <Text dimColor> 输入问题或 / 命令</Text> : null}
-        </Text>
+        </Box>
+        <Box justifyContent="space-between">
+          <Text dimColor>{(stdout.columns ?? 80) >= 58 ? 'Enter 发送 · Shift+Enter / Ctrl+J 换行' : 'Enter 发送 · Ctrl+J 换行'}</Text>
+          <Text dimColor>{wrapped.length > maxRows ? `${visualCursor + 1}/${wrapped.length} 行` : `${wrapped.length} 行`}</Text>
+        </Box>
       </Box>
     </Box>
   )
 }
 
+interface ComposerPasteState {
+  bracketed: boolean
+  bracketedBuffer: string
+  burstActive: boolean
+  consecutivePlain: number
+  lastChunkAt: number
+  lastChunkLength: number
+  timer: ReturnType<typeof setTimeout> | null
+}
+
+function pasteBurstWindowMs(): number {
+  return process.platform === 'win32' ? 60 : 20
+}
+
+function normalizeComposerPaste(text: string): string {
+  return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
+}
+
+function isEnhancedNewlineInput(input: string): boolean {
+  return /^\[(?:13|27);2(?:u|~)$/.test(input) || input === '\x1b\r'
+}
+
+function findPasteMarker(input: string, code: '200' | '201', from = 0): number {
+  const raw = `\x1b[${code}~`
+  const stripped = `[${code}~`
+  const rawAt = input.indexOf(raw, from)
+  const strippedAt = input.indexOf(stripped, from)
+  if (rawAt < 0) return strippedAt
+  if (strippedAt < 0) return rawAt
+  return Math.min(rawAt, strippedAt)
+}
+
+function pasteMarkerLength(input: string, at: number, code: '200' | '201'): number {
+  return input.startsWith(`\x1b[${code}~`, at) ? 6 : 5
+}
+
+function clampCursor(text: string, cursor: number): number {
+  let at = Math.max(0, Math.min(text.length, cursor))
+  while (at > 0 && at < text.length && /[\uDC00-\uDFFF]/.test(text[at])) at--
+  return at
+}
+
+function previousCursorBoundary(text: string, cursor: number): number {
+  const at = clampCursor(text, cursor)
+  if (at <= 0) return 0
+  const code = text.charCodeAt(at - 1)
+  return at - (code >= 0xDC00 && code <= 0xDFFF ? 2 : 1)
+}
+
+function nextCursorBoundary(text: string, cursor: number): number {
+  const at = clampCursor(text, cursor)
+  if (at >= text.length) return text.length
+  const code = text.charCodeAt(at)
+  return at + (code >= 0xD800 && code <= 0xDBFF ? 2 : 1)
+}
+
+interface ComposerLine { text: string; start: number; end: number }
+
+function wrapComposerLines(text: string, width: number): ComposerLine[] {
+  if (!text) return [{ text: '', start: 0, end: 0 }]
+  const result: ComposerLine[] = []
+  let lineStart = 0
+  let lineText = ''
+  let lineWidth = 0
+  for (let i = 0; i < text.length;) {
+    const ch = text[i]
+    if (ch === '\n') {
+      result.push({ text: lineText, start: lineStart, end: i })
+      lineText = ''
+      lineWidth = 0
+      lineStart = i + 1
+      i++
+      continue
+    }
+    const next = nextCursorBoundary(text, i)
+    const piece = text.slice(i, next)
+    const pieceWidth = Math.max(1, displayWidth(piece))
+    if (lineText && lineWidth + pieceWidth > width) {
+      result.push({ text: lineText, start: lineStart, end: i })
+      lineText = ''
+      lineWidth = 0
+      lineStart = i
+    }
+    lineText += piece
+    lineWidth += pieceWidth
+    i = next
+  }
+  result.push({ text: lineText, start: lineStart, end: text.length })
+  return result
+}
+
+function findComposerCursorLine(lines: ComposerLine[], cursor: number): number {
+  const at = Math.max(0, cursor)
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (at < line.end || (at === line.end && (i === lines.length - 1 || lines[i + 1].start > at))) return i
+  }
+  return Math.max(0, lines.length - 1)
+}
+
 function StatusArea({ ready, sessionId, columns, webUrl, aimuxStatus, modelDisplay }: {
   ready: ReadyState
   sessionId: string | null
@@ -608,8 +975,9 @@ function compactPath(path: string): string {
 }
 
 function truncateDisplay(value: string, maxLength: number): string {
-  if (value.length <= maxLength) return value
-  return maxLength <= 1 ? '…' : `${value.slice(0, maxLength - 1)}…`
+  const limit = Math.max(1, Math.floor(maxLength))
+  if (value.length <= limit) return value
+  return limit <= 1 ? '…' : `${value.slice(0, limit - 1)}…`
 }
 
 function buildWebUrl(server: string, webUserId: string, ready: ReadyState, sessionId: string | null): string {
@@ -658,5 +1026,59 @@ function isWideCodepoint(code: number): boolean {
   )
 }
 
-// (fitTranscript / blockRows / wrappedRows 视窗裁剪 + in-app 翻页逻辑已移除:
-//  transcript 现由 <Static> 累积进终端 scrollback, 历史靠终端自身滚动.)
+function wrappedRows(text: string, width: number): number {
+  const safeWidth = Math.max(1, width)
+  return text.split('\n').reduce((sum, line) => sum + Math.max(1, Math.ceil(displayWidth(line) / safeWidth)), 0)
+}
+
+function entryRows(entry: AnyEntry, columns: number): number {
+  const width = Math.max(8, columns - 4)
+  return Math.max(1, viewsForEntry(entry).reduce((sum, view) => {
+    switch (view.kind) {
+      case 'skip': return sum
+      case 'user': return sum + 1 + wrappedRows(view.text, width - 2)
+      case 'assistant': {
+        const rows = renderMarkdownLines(view.text).reduce((total, line) => {
+          return total + (line.code ? 1 : wrappedRows(line.text || ' ', width - 2))
+        }, 0)
+        return sum + 1 + rows
+      }
+      case 'tool_call': return sum + 2 + (view.result ? 1 : 0)
+      case 'tool_result': return sum + headTailLines(view.text, width - 4, 5).length
+      case 'code_edit':
+        return sum + 2 + wrappedRows(view.filePath || '(未指定文件)', width - 4)
+          + wrappedRows(view.oldString, width - 4) + wrappedRows(view.newString, width - 4)
+      case 'write_file':
+        return sum + 2 + wrappedRows(view.filePath || '(未指定文件)', width - 4)
+          + wrappedRows(view.content, width - 4)
+      case 'reasoning': return sum + 1 + clampLines(view.text, width - 4, 2).length
+      case 'system': return sum + 1
+      case 'error': return sum + 1 + wrappedRows(view.text, width - 2)
+      default: return sum
+    }
+  }, 0))
+}
+
+function fitTranscript(entries: AnyEntry[], rowBudget: number, columns: number, scrollBack = 0): {
+  entries: AnyEntry[]
+  hiddenOlder: number
+  hiddenRecent: number
+  startIndex: number
+} {
+  const tail = Math.max(0, entries.length - scrollBack)
+  const available = tail === 0 ? [] : entries.slice(0, tail)
+  let rows = 0
+  let first = available.length
+  for (let index = available.length - 1; index >= 0; index--) {
+    const nextRows = entryRows(available[index], columns)
+    if (first < available.length && rows + nextRows > rowBudget) break
+    rows += nextRows
+    first = index
+  }
+  return {
+    entries: available.slice(first),
+    hiddenOlder: first,
+    hiddenRecent: entries.length - tail,
+    startIndex: first,
+  }
+}

package/src/components/primitives.tsx

@@ -3,13 +3,96 @@
  * Select (single-choice list + multi-choice with checkboxes), and a Spinner.
  */
 import React, { useEffect, useRef, useState } from 'react'
-import { Box, Text, useInput, useStdout } from 'ink'
+import { Box, Text, useInput, useStdout, useStdin } from 'ink'
 
 /** Windows Terminal/ConPTY may expose Esc as a named key, a raw byte, or Ctrl+[. */
 export function isEscapeKeypress(input: string, key: { escape?: boolean; ctrl?: boolean }): boolean {
   return key.escape === true || input === '\x1b' || (key.ctrl === true && input === '[')
 }
 
+// ─── Mouse wheel ─────────────────────────────────────────────────────────────
+// Terminals report wheel events only after DECSET 1000 (button-event) + 1006
+// (SGR coordinates) are enabled. A wheel tick arrives as a mouse sequence:
+//   wheel up   → ESC [ < 64 ; x ; y M   (SGR, the modern encoding)
+//   wheel down → ESC [ < 65 ; x ; y M
+// Legacy X10 (no SGR support) reports ESC [ M Cb Cx Cy with Cb = button + 32,
+// so wheel up is 0x60 (`) and wheel down is 0x61 (a). There is no release event
+// for the wheel in either form. Button 64/65 map to a delta of +1/-1 so the
+// transcript pager can scroll back/forward by a fixed step.
+const SGR_MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g
+const LEGACY_MOUSE_RE = /\x1b\[M([\s\S]{3})/g
+
+/**
+ * True when `input` (a chunk Ink forwarded to useInput handlers) begins with a
+ * mouse event. Ink strips a leading ESC before passing `input`, so both the raw
+ * and stripped forms are accepted. Guards must be added to any handler that
+ * would otherwise treat a mouse event as typed text.
+ */
+export function isMouseInput(input: string): boolean {
+  return /^\x1b?\[<\d+;\d+;\d+[Mm]/.test(input) || /^\x1b?\[M/.test(input)
+}
+
+/** Extract the wheel delta from a chunk: +1 wheel-up, -1 wheel-down, else 0. */
+export function mouseWheelDelta(input: string): number {
+  SGR_MOUSE_RE.lastIndex = 0
+  let delta = 0
+  let m: RegExpExecArray | null
+  while ((m = SGR_MOUSE_RE.exec(input)) !== null) {
+    const btn = Number(m[1])
+    if (btn === 64) delta++
+    else if (btn === 65) delta--
+  }
+  LEGACY_MOUSE_RE.lastIndex = 0
+  let lm: RegExpExecArray | null
+  while ((lm = LEGACY_MOUSE_RE.exec(input)) !== null) {
+    const btn = lm[1].charCodeAt(0) - 32 // X10 adds a 32 offset to the button
+    if (btn === 64) delta++
+    else if (btn === 65) delta--
+  }
+  return delta
+}
+
+/**
+ * Enables terminal mouse tracking for the lifetime of the calling component and
+ * forwards wheel deltas to `onWheel`. Mouse events reach the rest of Ink as raw
+ * input chunks, so any text-inserting useInput handler must guard with
+ * `isMouseInput(input)`.
+ *
+ * The DECSET enable/disable sequences are only written when stdout is a TTY
+ * (writing them into a pipe would litter the output). The emitter listener is
+ * attached unconditionally so the harness can simulate wheel events.
+ */
+export function useMouseWheel(onWheel: (delta: number) => void): void {
+  const { internal_eventEmitter } = useStdin()
+  const { stdout } = useStdout()
+  const cbRef = useRef(onWheel)
+  cbRef.current = onWheel
+
+  useEffect(() => {
+    if (!internal_eventEmitter) return
+    const isTTY = Boolean(stdout.isTTY)
+    if (isTTY) stdout.write('\x1b[?1000h\x1b[?1006h')
+    let buf = ''
+    const handler = (chunk: unknown) => {
+      // A single read() chunk may carry several wheel ticks (fast scrolling) and
+      // an SGR sequence may be split across chunks, so accumulate and re-scan.
+      buf += String(chunk)
+      const delta = mouseWheelDelta(buf)
+      // Drop the fully-matched sequences, keeping any trailing partial escape
+      // prefix so a split sequence still matches on the next chunk.
+      buf = buf.replace(SGR_MOUSE_RE, '').replace(LEGACY_MOUSE_RE, '')
+      const esc = buf.lastIndexOf('\x1b')
+      buf = esc >= 0 ? buf.slice(esc) : ''
+      if (delta !== 0) cbRef.current(delta)
+    }
+    internal_eventEmitter.on('input', handler)
+    return () => {
+      internal_eventEmitter.off('input', handler)
+      if (isTTY) stdout.write('\x1b[?1000l\x1b[?1006l')
+    }
+  }, [internal_eventEmitter, stdout])
+}
+
 // ─── TextInput ───────────────────────────────────────────────────────────────
 export interface TextInputProps {
   value: string
@@ -48,6 +131,7 @@ export function TextInput(props: TextInputProps) {
   }
 
   useInput((input, key) => {
+    if (isMouseInput(input)) return
     if (key.return) { props.onSubmit?.(); return }
     if (key.upArrow) { props.onArrowUp?.(); return }
     if (key.downArrow) { props.onArrowDown?.(); return }
@@ -172,6 +256,7 @@ export function Select(props: SelectProps) {
 
   useInput((input, key) => {
     if (!items.length) return
+    if (isMouseInput(input)) return
     if (key.upArrow) { setActive(a => (a - 1 + items.length) % items.length); return }
     if (key.downArrow) { setActive(a => (a + 1) % items.length); return }
     if (mode === 'single') {

package/src/hooks/useChat.ts

@@ -109,6 +109,7 @@ export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatContro
   const aliveRef = useRef(true)
   const stoppedRef = useRef(false)
   const doConnectRef = useRef<(sid: string) => void>(() => {})
+  const connectionGenerationRef = useRef(0)
 
   const updateTyping = useCallback((active: boolean) => {
     typingRef.current = active
@@ -147,6 +148,7 @@ export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatContro
   // ── SSE connection ────────────────────────────────────────────────────────
   const connect = useCallback((sid: string) => {
     if (process.env.MOBIUS_TUI_DEBUG) console.error('[connect]', sid)
+    const generation = ++connectionGenerationRef.current
     sseRef.current?.close()
     if (reconnectTimerRef.current) { clearTimeout(reconnectTimerRef.current); reconnectTimerRef.current = null }
     const url = `${client.server}/api/sessions/${encodeURIComponent(sid)}/events?token=${encodeURIComponent(client.token)}`
@@ -183,6 +185,10 @@ export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatContro
       },
       onError: (msg) => setError(msg),
       onClose: () => {
+        // `connect()` closes the previous stream before installing its
+        // replacement. Ignore that superseded stream's eventual close callback,
+        // otherwise it can schedule a timer that tears down the fresh stream.
+        if (generation !== connectionGenerationRef.current) return
         // Reconnect with exponential backoff as long as the session is still
         // alive; stop once it ends (alive=false) or after a few failed tries.
         if (stoppedRef.current || !aliveRef.current) return
@@ -201,6 +207,25 @@ export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatContro
   }, [client.server, client.token, appendEntries, setHistory, updateTyping])
   doConnectRef.current = connect
 
+  const ensureSseForSend = useCallback((sid: string): boolean => {
+    // A completed worker reports alive=false. If its SSE stream is later closed
+    // by an idle proxy, onClose deliberately stops reconnecting. Sending a new
+    // turn revives the same session, so reopen the stream before dispatching the
+    // message; otherwise the backend and web UI advance while this TUI remains
+    // attached to a permanently closed connection.
+    aliveRef.current = true
+    reconnectAttemptRef.current = 0
+    if (reconnectTimerRef.current) {
+      clearTimeout(reconnectTimerRef.current)
+      reconnectTimerRef.current = null
+    }
+    if (!sseRef.current || sseRef.current.isClosed()) {
+      connect(sid)
+      return true
+    }
+    return false
+  }, [connect])
+
   // Connect immediately when a resume session is provided, or after we create one.
   useEffect(() => {
     if (sessionId && !sseRef.current) connect(sessionId)
@@ -355,8 +380,11 @@ export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatContro
     setSending(true)
     try {
       const sid = await ensureSession()
-      // SSE may not be connected yet for a freshly created session; give it a tick.
-      if (!sseRef.current) await new Promise(r => setTimeout(r, 200))
+      // Fresh sessions connect via the sessionId effect. Resumed sessions may
+      // have a permanently closed idle stream after their worker exited; revive
+      // that stream explicitly before POSTing so this turn cannot be missed.
+      const reopenedSse = ensureSseForSend(sid)
+      if (reopenedSse || !sseRef.current) await new Promise(r => setTimeout(r, 200))
       if (process.env.MOBIUS_TUI_DEBUG) console.error('[send-post]', sid, 'sse=', !!sseRef.current, 'closed=', sseRef.current?.isClosed())
       const reqId = `tui-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
       await sendWithRetry(() => client.sendMessage(sid, body, reqId))
@@ -372,7 +400,7 @@ export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatContro
       setSending(false)
       pollNowRef.current?.()
     }
-  }, [sending, ensureSession, client, updateTyping])
+  }, [sending, ensureSession, ensureSseForSend, client, updateTyping])
 
   const stop = useCallback(async () => {
     if (!sessionId) return