@yanzc/claude-pro 0.5.0 → 0.5.1

package/README.md

@@ -234,13 +234,14 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 - 流式 Markdown 渲染（代码高亮、表格、中文宽度对齐），思考过程折叠显示（`ctrl+o` 展开）
 - `Esc` 中断；忙碌时输入的消息会排队并插入当前任务
 - `!` Bash 模式、`#` 写入记忆（CLAUDE.md）、`\`+回车 或 `ctrl+j` 换行、粘贴大段文本折叠为 `[Pasted text #1 +42 lines]`
+- **全屏模式（默认，和 Claude Code 的 `/tui fullscreen` 一样）**：程序画在终端的备用屏幕上（像 vim），输入框固定在窗口最底下，不随输出或终端滚动条移动；对话在程序里滚动：鼠标滚轮（每格 `CLAUDE_PRO_SCROLL_SPEED` 行，默认 3）、`PgUp`/`PgDn`（半屏）、`Ctrl+Home`（对话开头）、`Ctrl+End`（回到最新）。往上翻时新输出不会把画面拉回底部，底部浮着 `Jump to bottom (ctrl+End) ↓ · N new lines`；发消息时自动回到底部。程序接管了鼠标，**选中文字要按住 Shift 再拖动**（Windows Terminal、VS Code 终端都支持）。退出后终端回到启动前的样子（对话不留在终端滚动记录里）。`/tui default` 切回经典模式（对话写进终端自己的滚动记录，输入框在窗口底部、靠空行顶到底；`CLAUDE_PRO_PIN_INPUT=0` 让它紧跟在输出下面），`/tui fullscreen` 切回全屏，选择会记住（`CLAUDE_PRO_TUI`）
 - `ctrl+c` 或连按两次 `Esc` 清掉的草稿不会丢：在空输入框按 `↑` 找回（连同粘贴的文本和图片），中间发过别的消息也可以
 - `@文件` 补全并附加内容：走的就是 `Read` 工具，等于模型自己读了这个文件。最多带前 2000 行（被截断时会明确告诉模型，并把该文件记为"只读了一部分"，之后 `Write` 不会去覆盖没给它看过的行）；图片作为图片附加；二进制文件和超过 512KB 的文本会被跳过并提示原因；`@目录` 列出目录内容
 - `alt+v` 粘贴剪贴板里的图片（截图用 `Win+Shift+S`），输入框里显示为 `[Image #1]`；超过 1568px 的图会自动缩小。把图片文件拖进终端（或粘贴图片路径）也会作为图片附加
 - 上下文用量接近阈值时自动压缩（`CLAUDE_CODE_AUTO_COMPACT_WINDOW`），也可手动 `/compact`
 - 会话自动保存到 `~/.claude-pro/projects/`，`claude-pro -c` 继续上次，`claude-pro -r` 选择历史会话
 
-**斜杠命令**：`/help` `/rename` `/peers` `/sendfile` `/clear` `/compact` `/config` `/model` `/effort` `/status` `/cost` `/context` `/init` `/review` `/memory` `/verify` `/tasks` `/plan` `/rewind` `/skills` `/resume` `/todos` `/agents` `/mcp` `/bashes` `/verbose` `/export` `/doctor` `/remote-control`（`/rc`） `/exit`，以及 `.claude/commands/*.md`、`.claude-pro/commands/*.md`、`~/.claude-pro/commands/*.md` 中的自定义命令（支持 `$ARGUMENTS`、`$1`、`` !`cmd` ``）。
+**斜杠命令**：`/help` `/tui` `/rename` `/peers` `/sendfile` `/clear` `/compact` `/config` `/model` `/effort` `/status` `/cost` `/context` `/init` `/review` `/memory` `/verify` `/tasks` `/plan` `/rewind` `/skills` `/resume` `/todos` `/agents` `/mcp` `/bashes` `/verbose` `/export` `/doctor` `/remote-control`（`/rc`） `/exit`，以及 `.claude/commands/*.md`、`.claude-pro/commands/*.md`、`~/.claude-pro/commands/*.md` 中的自定义命令（支持 `$ARGUMENTS`、`$1`、`` !`cmd` ``）。
 
 **记忆**：自动读取 `~/.claude-pro/CLAUDE.md`、项目各级目录的 `CLAUDE.md` / `.claude/CLAUDE.md` / `CLAUDE.local.md`；某一级目录没有 `CLAUDE.md` 时读它的 `AGENTS.md` 代替（与 Claude Code 相同，两者都有时通常是同一份说明，不重复发送）。
 
@@ -297,6 +298,7 @@ claude-pro -p --plan "给出重构方案"                    # 只调研、只
 | `ctrl+t` | 显示/隐藏 todo 列表 |
 | `ctrl+l` | 清屏重绘 |
 | `alt+v` | 粘贴剪贴板图片 |
+| `PgUp` / `PgDn`、滚轮、`Ctrl+Home` / `Ctrl+End` | 全屏模式下滚动对话 / 到开头 / 回到最新 |
 | `↑` / `↓` | 在多行输入（包括自动折行的长文字）里上下移动光标；光标在第一行时 `↑` 先移到开头、再按才翻到上一条历史消息，`↓` 在最后一行同理 |
 | `Tab` | 补全命令 / 文件 |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "claude-pro: a self-implemented coding agent for Anthropic-compatible APIs or local Claude Code subscription login. Full access with no permission prompts; file edits are checkpointed and can be rewound.",
   "type": "module",
   "repository": {

package/src/commands.js

@@ -607,6 +607,27 @@ export function buildCommands(app) {
     async run(args) { await app.sendFiles(args); },
   });
 
+  add({
+    name: 'tui',
+    argHint: '[fullscreen | default]',
+    description: 'The renderer: fullscreen (the input box fixed at the bottom, the conversation scrolled with the wheel or PgUp/PgDn) or default (it scrolls in the terminal)',
+    run(args) {
+      const want = args.trim().toLowerCase();
+      if (!want) {
+        out(`The ${c.bold(app.screen.full ? 'fullscreen' : 'default')} renderer is active. /tui fullscreen or /tui default switches (and is remembered).`);
+        return;
+      }
+      if (want !== 'fullscreen' && want !== 'default') { out(c.red('Use /tui fullscreen or /tui default.')); return; }
+      const file = settingsFiles(app.cwd).user;
+      updateSettingsFile(file, (json) => { json.env = { ...(json.env || {}), CLAUDE_PRO_TUI: want }; });
+      reloadConfig();
+      app.screen.setFull(want === 'fullscreen');
+      out(want === 'fullscreen'
+        ? `Fullscreen: the input box stays at the bottom; scroll with the wheel, PgUp/PgDn, ctrl+Home/End. To select text, hold Shift while dragging. (Saved in ${file})`
+        : `Default renderer: the conversation scrolls in the terminal. (Saved in ${file})`);
+    },
+  });
+
   add({
     name: 'rename',
     argHint: '<name>',

package/src/config.js

@@ -39,6 +39,9 @@ export const KNOWN_KEYS = {
   CLAUDE_PRO_ONLINE: 'Set to 0 to keep interactive sessions off the gateway until /rc. By default a session goes online there when this computer is logged in to the gateway: its 远程控制 page shows it, and sessions on your other computers can send it tasks (@computer/name)',
   CLAUDE_PRO_DOWNLOAD_DIR: 'Where files that other sessions send this one are saved (default: the Downloads folder)',
   CLAUDE_PRO_MACHINE_NAME: 'This computer\'s name for sessions on your other computers (@公司 ...; default: the host name)',
+  CLAUDE_PRO_TUI: 'fullscreen (default: the input box fixed at the bottom, the conversation scrolled inside, like Claude Code\'s /tui fullscreen) or default (classic: it scrolls in the terminal); /tui switches',
+  CLAUDE_PRO_SCROLL_SPEED: 'Fullscreen: rows the mouse wheel scrolls a notch (default 3, at most 20)',
+  CLAUDE_PRO_PIN_INPUT: 'Set to 0 to show the input box right below the output instead of on the last rows of the window',
   CLAUDE_PRO_AUTO_RESTART: 'Restart by itself when a turn ends and claude-pro\'s own source files changed (default 1; 0 = only on /restart or the Restart tool)',
   CLAUDE_PRO_CLAUDE_CODE_MODEL: 'Model for Claude Code OAuth (default: sonnet; independent of API model settings)',
   CLAUDE_CONFIG_DIR: 'Official Claude Code configuration directory, for selecting the locally signed-in account',

package/src/supervisor.js

@@ -48,7 +48,8 @@ export function shouldSupervise(argv, env = process.env, isTty = (fd) => tty.isa
 
 function putTerminalRight() {
   // The child may have died with the terminal in the mode it had set for itself.
-  try { process.stdout.write('\x1b[?2004l\x1b[?25h'); } catch { /* nothing to do */ }
+  // (the fullscreen renderer's alternate screen and mouse reporting included)
+  try { process.stdout.write('\x1b[?1000l\x1b[?1006l\x1b[?1049l\x1b[?2004l\x1b[?25h'); } catch { /* nothing to do */ }
   try { if (tty.isatty(0)) process.stdin.setRawMode(false); } catch { /* nothing to do */ }
 }
 

package/src/ui/repl.js

@@ -7,7 +7,7 @@ import os from 'node:os';
 import readline from 'node:readline';
 import { spawn } from 'node:child_process';
 import { c, ESC, stringWidth, truncate, padEnd, wordWrap, colorEnabled } from './ansi.js';
-import { Screen } from './screen.js';
+import { Screen, queryCursorRow, mouseFilter } from './screen.js';
 import { Editor } from './editor.js';
 import { SelectDialog } from './dialogs.js';
 import { MarkdownStream, renderMarkdown } from './markdown.js';
@@ -223,8 +223,12 @@ export class App {
 
   async start(initialPrompt) {
     const stdin = this.stdin;
-    readline.emitKeypressEvents(stdin);
     stdin.setRawMode(true);
+    // Where the cursor is, before anything is drawn: the input box is kept on the last rows of the window from
+    // there (see screen.js). CLAUDE_PRO_PIN_INPUT=0 (here or in the settings) leaves it right below the output.
+    const pinOff = (v) => /^(0|false|no|off)$/i.test(v || '');
+    if (pinOff(process.env.CLAUDE_PRO_PIN_INPUT)) this.screen.pin = false;
+    else if (stdin.isTTY && this.stdout.isTTY) this.screen.pinFrom(await queryCursorRow(stdin, this.stdout));
     stdin.setEncoding('utf8');
     this.stdout.write(ESC.bracketedPasteOn);
     this.watchCopies();
@@ -238,8 +242,16 @@ export class App {
     // The conversation's id, sent to the gateway with each request (see streamMessage); it follows /clear and /resume.
     Object.defineProperty(this.runtime.config, 'sessionId', { get: () => this.store.id, configurable: true });
     this.commands = buildCommands(this);
-    // Keys typed while starting up stay buffered in stdin until we listen.
-    stdin.on('keypress', (str, key) => {
+    if (pinOff(this.config.env.CLAUDE_PRO_PIN_INPUT)) { this.screen.pin = false; this.screen.pinned = null; }
+    // What the session showed before a restart: scrolled back to in fullscreen, repainted after a resize otherwise.
+    if (Array.isArray(this.flags.restart?.screenHistory)) this.screen.history = this.flags.restart.screenHistory.filter((l) => typeof l === 'string');
+    if (this.fullscreenWanted()) this.screen.setFull(true);
+    // Keys typed while starting up stay buffered in stdin until we listen. Mouse reports (fullscreen: the wheel)
+    // are taken out before the keys are read.
+    const keys = mouseFilter(stdin, (m) => this.onMouse(m));
+    readline.emitKeypressEvents(keys);
+    keys.on('keypress', (str, key) => {
+      if (/^\x1b\[\d+;\d+R$/.test(key?.sequence || '')) return; // a late answer to the cursor position query, not a key
       try { this.onKey(str, key || {}); } catch (e) { this.logError(e); }
     });
     stdin.resume();
@@ -907,6 +919,7 @@ export class App {
       mode: this.runtime.modes.mode,
       todos: this.agent.todos,
       draft: this.editor.text,
+      screenHistory: this.screen.history.slice(-3000),
       draftCursor: this.editor.cursor,
       queue: this.queue.map((q) => ({ text: q.text, images: q.images || [] })),
       checkpoints: this.runtime.checkpoints.snapshot(),
@@ -942,6 +955,9 @@ export class App {
       if (state.checkpoints) this.runtime.checkpoints.adopt(state.checkpoints);
     }
     if (typeof state.draft === 'string' && state.draft) this.editor.set(state.draft, state.draftCursor);
+    // Fullscreen starts on an empty screen: without what the process before showed (an older version, or one
+    // that ran classic), the conversation is drawn again from the session.
+    if (this.screen.full && resumable && !Array.isArray(state.screenHistory)) this.printTranscript(this.agent.messages.slice(-80));
     this.screen.log(c.dim(`↻ Restarted${state.reason ? `: ${state.reason}` : ''}${state.continueWith ? ' · continuing' : ''}`), '');
   }
 
@@ -1054,11 +1070,32 @@ export class App {
     this.stdout.write(FOCUS_EVENTS_ON);
   }
 
+  // Fullscreen (see screen.js) unless CLAUDE_PRO_TUI=default, as Claude Code's /tui: the input box fixed at the
+  // bottom of the window, the conversation scrolled inside the program. Not in the tests that drive the App.
+  fullscreenWanted() {
+    const mode = String(this.config.env.CLAUDE_PRO_TUI || (this.noProcessExit ? 'default' : 'fullscreen')).toLowerCase();
+    return mode === 'fullscreen' && this.stdout.isTTY !== false;
+  }
+
+  // Fullscreen: the wheel scrolls the conversation (CLAUDE_PRO_SCROLL_SPEED rows a notch, 3 by default).
+  onMouse({ button }) {
+    if (!this.screen.full || this.exiting || !(button & 64) || button & 128) return;
+    const speed = Math.max(1, Math.min(20, Number(this.config.env.CLAUDE_PRO_SCROLL_SPEED) || 3));
+    this.screen.scrollBy(button & 1 ? -speed : speed);
+  }
+
   onKey(str, key) {
     if (this.exiting) return;
     if (key.sequence === '\x1b[I') { this.focused = true; return; }
     if (key.sequence === '\x1b[O') { this.focused = false; return; }
     if (key.ctrl && key.name === 'c') { this.onCtrlC(); return; }
+    if (this.screen.full) {
+      const half = Math.max(1, Math.floor((this.screen.lastArea || this.screen.height) / 2));
+      if (key.name === 'pageup') { this.screen.scrollBy(half); return; }
+      if (key.name === 'pagedown') { this.screen.scrollBy(-half); return; }
+      if (key.ctrl && key.name === 'home') { this.screen.scrollBy('top'); return; }
+      if (key.ctrl && key.name === 'end') { this.screen.scrollBy('bottom'); return; }
+    }
     const dialog = this.dialogs[0];
     if (dialog) {
       dialog.handleKey(str, key);
@@ -1074,7 +1111,7 @@ export class App {
       return;
     }
     if (key.ctrl && key.name === 't') { this.showTodos = !this.showTodos; this.screen.schedule(); return; }
-    if (key.ctrl && key.name === 'l') { this.screen.clearScreen(); return; }
+    if (key.ctrl && key.name === 'l') { if (this.screen.full) this.screen.repaint(); else this.screen.clearScreen(); return; }
     if (key.ctrl && key.name === 'd' && !this.editor.text) { this.exit(0); return; }
     if (key.name === 'escape' && this.busy) { this.interrupt(); return; }
     this.exitArmed = 0;
@@ -1163,6 +1200,7 @@ export class App {
   onSubmit(value, raw, images = []) {
     const text = value.trim();
     if (!text) { this.screen.schedule(); return; }
+    if (this.screen.scrolledUp) this.screen.scrollBy('bottom'); // what was sent, and what comes of it, is in view
     appendHistory(this.cwd, raw);
     if (this.sendTypedToPeer(text)) return;
     if (this.busy) {
@@ -1216,6 +1254,7 @@ export class App {
       ['! for bash mode', 'double tap esc to clear input'],
       ['/ for commands', 'shift + tab to cycle permission modes'],
       ['@ for file paths, & for other sessions', 'ctrl + o to toggle verbose output'],
+      ['PgUp/PgDn, wheel to scroll', 'ctrl + home/end to the top/bottom'],
       ['# to memorize', 'ctrl + t to toggle todos'],
       ['\\⏎ or alt+⏎ for newline', 'ctrl + l to redraw, ctrl + d to exit'],
       ['alt + v to paste an image', ''],

package/src/ui/screen.js

@@ -13,8 +13,23 @@
 // from memory and the live region below them, which needs no knowledge of where the cursor was.
 // Nothing is drawn while the size is still changing: a redraw made between two re-flows works from a
 // screen that is about to change again.
+//
+// Fullscreen (setFull), as Claude Code's fullscreen rendering: the program draws on the terminal's alternate
+// screen like vim, the input box fixed on the last rows, the conversation in the rows above it. The terminal's own
+// scrollback is not used: the conversation is kept here (history) and scrolled here, with the mouse wheel (mouse
+// reporting on, see mouseFilter), PgUp/PgDn and ctrl+Home/End. Scrolled up, new output does not move the view and a
+// "Jump to bottom" bar counts what arrived. Each draw writes only the rows that changed since the last one.
+//
+// Pinned to the bottom. As in Claude Code the input box sits on the last rows of the window, also when the
+// output so far does not fill it: blank rows at the top of the live region fill the space between the last
+// output and the box. New output takes their place first and only then scrolls. This needs to know where on the
+// screen the live region starts: at start-up the terminal is asked (queryCursorRow), after a repaint or a clear
+// it is known. `pinned` is how many rows the live region reaches down to the bottom of the screen (null: not
+// known, and nothing is pinned until it is). Closing removes the blank rows, so that the shell (or the process
+// of a restart) goes on right below the output.
 
-import { ESC, wrapLine, termWidth, truncate } from './ansi.js';
+import { PassThrough } from 'node:stream';
+import { ESC, wrapLine, termWidth, truncate, stringWidth } from './ansi.js';
 
 const SYNC_START = '\x1b[?2026h';
 const SYNC_END = '\x1b[?2026l';
@@ -23,6 +38,65 @@ const RESIZE_QUIET_MS = 80; // repaint once the size has not changed for this lo
 const RESIZE_MAX_WAIT_MS = 300; // ... or at the latest this long after it started changing
 const HISTORY_KEEP = 600; // static lines remembered for repainting (a screen shows far fewer)
 const HISTORY_LINE_CHARS = 20_000;
+const FULL_KEEP = 20_000; // fullscreen: lines of the conversation kept to scroll back through
+const ALT_ON = '\x1b[?1049h\x1b[?1000h\x1b[?1006h'; // the alternate screen, and mouse buttons and wheel reported (SGR)
+const ALT_OFF = '\x1b[?1000l\x1b[?1006l\x1b[?1049l';
+const MOUSE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+
+// The keys of `stdin` without the mouse reports in it (SGR: ESC [ < b ; x ; y M/m), which go to
+// `onMouse({button, x, y, release})` instead: a stream to read keys from. A report split between two chunks is
+// put together; the rest passes through as it came.
+export function mouseFilter(stdin, onMouse) {
+  const out = new PassThrough();
+  let pending = '';
+  let timer = null;
+  const pass = (text) => { if (text) out.write(text); };
+  stdin.on('data', (d) => {
+    clearTimeout(timer);
+    let text = pending + (typeof d === 'string' ? d : d.toString('utf8'));
+    pending = '';
+    text = text.replace(MOUSE, (_, b, x, y, kind) => {
+      try { onMouse({ button: Number(b), x: Number(x), y: Number(y), release: kind === 'm' }); } catch { /* the listener's problem */ }
+      return '';
+    });
+    const partial = /\x1b\[<[\d;]*$/.exec(text);
+    if (partial) {
+      pending = partial[0];
+      text = text.slice(0, partial.index);
+      timer = setTimeout(() => { const p = pending; pending = ''; pass(p); }, 50); // not a report after all
+    }
+    pass(text);
+  });
+  return out;
+}
+const CPR = /\x1b\[(\d+);(\d+)R/; // the terminal's answer to DSR 6: row;column
+
+// Ask the terminal where the cursor is (DSR 6): resolves with its row (1-based), or null when it does not answer
+// within `timeout`. Run before anything else reads `stdin`, with the terminal in raw mode; what else arrives
+// meanwhile (keys typed during start-up) is put back for the key reader.
+export function queryCursorRow(stdin, out, timeout = 300) {
+  return new Promise((resolve) => {
+    let buf = Buffer.alloc(0);
+    let timer = null;
+    const done = (row) => {
+      clearTimeout(timer);
+      stdin.off('data', onData);
+      stdin.pause();
+      const m = CPR.exec(buf.toString('latin1')); // latin1: one character a byte, so the index is a byte index
+      const rest = m ? Buffer.concat([buf.subarray(0, m.index), buf.subarray(m.index + m[0].length)]) : buf;
+      if (rest.length) stdin.unshift(rest);
+      resolve(row);
+    };
+    const onData = (d) => {
+      buf = Buffer.concat([buf, Buffer.isBuffer(d) ? d : Buffer.from(String(d), 'utf8')]);
+      const m = CPR.exec(buf.toString('latin1'));
+      if (m) done(Number(m[1]));
+    };
+    timer = setTimeout(() => done(null), timeout);
+    stdin.on('data', onData);
+    try { out.write('\x1b[6n'); } catch { done(null); }
+  });
+}
 
 // How many rows a static line takes when the terminal wraps it at `cols`.
 function rowsOf(line, cols) {
@@ -42,8 +116,18 @@ export function cleanTitle(text) {
 }
 
 export class Screen {
-  constructor(out = process.stdout) {
+  // pin: keep the live region on the last rows of the screen (see the top of this file).
+  constructor(out = process.stdout, { pin = true } = {}) {
     this.out = out;
+    this.pin = pin;
+    this.pinned = null; // rows from the top of the live region to the bottom of the screen; null: not known
+    this.full = false; // fullscreen: see the top of this file
+    this.scroll = 0; // fullscreen: rows the view is scrolled up from the end of the conversation (0: following it)
+    this.unseen = 0; // fullscreen: rows that arrived while scrolled up
+    this.frame = []; // fullscreen: the rows on screen, as last written
+    this.wrapped = []; // fullscreen: history[i] wrapped to wrapCols - 1, made when first needed
+    this.wrapCols = 0;
+    this.lastArea = 0; // fullscreen: rows the conversation had on screen at the last draw
     this.cursorRow = 0; // row of the terminal cursor, relative to the top of the live region
     this.staticQueue = [];
     this.history = []; // the most recent static lines, for repainting after a resize
@@ -87,6 +171,118 @@ export class Screen {
 
   setLive(fn) { this.renderLive = fn; this.schedule(); }
 
+  // ------------------------------------------------------------ fullscreen
+
+  // Go to (true) or leave the alternate screen. Leaving puts the newest output back on the normal screen, so that
+  // the classic renderer goes on below it.
+  setFull(on) {
+    if (on === this.full || this.closed) return;
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    this.takeStatic();
+    if (on) {
+      this.out.write('\r' + ESC.up(this.cursorRow) + ESC.clearDown); // the live region off the normal screen
+      this.cursorRow = 0;
+      this.full = true;
+      this.scroll = 0;
+      this.unseen = 0;
+      this.frame = [];
+      this.out.write(ALT_ON + '\x1b[2J');
+      this.draw();
+      return;
+    }
+    this.full = false;
+    this.frame = [];
+    this.out.write(ALT_OFF + ESC.showCursor);
+    const tail = this.history.slice(-Math.max(1, this.height - 1));
+    if (tail.length) this.out.write(tail.map((l) => l + '\x1b[0m').join('\r\n') + '\r\n');
+    this.cursorRow = 0;
+    this.pinned = null;
+    this.flush();
+  }
+
+  wrappedAt(i, cols) {
+    if (this.wrapCols !== cols) { this.wrapped = []; this.wrapCols = cols; }
+    return (this.wrapped[i] ??= wrapLine(this.history[i], Math.max(1, cols - 1)));
+  }
+
+  // Rows of the whole conversation at this width (for the scrolling to stop at its top).
+  totalRows(cols) {
+    let n = 0;
+    for (let i = 0; i < this.history.length; i++) n += this.wrappedAt(i, cols).length;
+    return n;
+  }
+
+  // `rows` rows of the conversation, ending `this.scroll` rows above its end; padded below when it is shorter.
+  view(rows, cols) {
+    const need = rows + this.scroll;
+    const got = [];
+    for (let i = this.history.length - 1; i >= 0 && got.length < need; i--) got.unshift(...this.wrappedAt(i, cols));
+    const end = Math.max(0, got.length - this.scroll);
+    const shown = got.slice(Math.max(0, end - rows), end);
+    while (shown.length < rows) shown.push('');
+    return shown;
+  }
+
+  // Scroll the conversation up (`rows` > 0) or down. 'top' and 'bottom' go to its ends.
+  scrollBy(rows) {
+    if (!this.full) return;
+    this.takeStatic();
+    const cols = this.width;
+    const max = Math.max(0, this.totalRows(cols) - this.lastArea);
+    const to = rows === 'top' ? max : rows === 'bottom' ? 0 : Math.max(0, Math.min(max, this.scroll + rows));
+    if (to === this.scroll) return;
+    this.scroll = to;
+    if (!to) this.unseen = 0;
+    this.draw();
+  }
+
+  get scrolledUp() { return this.full && this.scroll > 0; }
+
+  // The bar over the last row of the conversation while it is scrolled up.
+  jumpBar(cols) {
+    const label = ` Jump to bottom (ctrl+End) ↓${this.unseen ? ` · ${this.unseen} new line${this.unseen === 1 ? '' : 's'}` : ''} `;
+    const pad = Math.max(0, Math.floor((cols - 1 - stringWidth(label)) / 2));
+    return ' '.repeat(pad) + '\x1b[7m' + label + '\x1b[27m';
+  }
+
+  // Draw the screen: the conversation above, the live region on the last rows, the cursor in the input box.
+  draw({ full = false } = {}) {
+    if (this.closed || !this.full) return;
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    const cols = this.width;
+    const screenRows = Math.max(1, this.out.rows || this.height);
+    const layout = this.layoutLive(cols);
+    const area = Math.max(0, screenRows - layout.rows.length);
+    this.lastArea = area;
+    const top = this.view(area, cols);
+    if (this.scroll > 0 && area > 0) top[area - 1] = this.jumpBar(cols);
+    const frame = [...top, ...layout.rows];
+    let buf = SYNC_START + ESC.hideCursor + this.titleUpdate();
+    if (full) { buf += '\x1b[2J'; this.frame = []; }
+    frame.forEach((row, i) => {
+      if (this.frame[i] !== row) buf += `\x1b[${i + 1};1H` + row + '\x1b[0m\x1b[K';
+    });
+    if (frame.length < this.frame.length) buf += `\x1b[${frame.length + 1};1H` + ESC.clearDown;
+    this.frame = frame;
+    if (layout.cursorRow !== null) buf += `\x1b[${area + layout.cursorRow + 1};${layout.cursorCol + 1}H` + ESC.showCursor;
+    buf += SYNC_END;
+    this.out.write(buf);
+  }
+
+  // The live region starts on screen row `row` (1-based, as the terminal reports it): from now on it fills the
+  // screen down to its last row.
+  pinFrom(row) {
+    if (!this.pin || !Number.isFinite(row) || row < 1) return;
+    this.pinned = Math.max(0, this.height - row + 1);
+  }
+
+  // Blank rows before the live region's own rows so that it reaches the bottom of the screen, `above` rows of
+  // output being written first.
+  gapFor(above, liveRows) {
+    if (!this.pin || this.pinned === null) return 0;
+    return Math.max(0, Math.min(this.pinned, this.height) - above - liveRows);
+  }
+
   // Append lines (strings, may contain \n) to the static log. `onLog(items)` is told about each call (the remote
   // control mirrors what the terminal prints).
   log(...items) {
@@ -108,8 +304,21 @@ export class Screen {
     if (!this.staticQueue.length) return [];
     const lines = this.staticQueue.join('\n').split(/\r?\n/);
     this.staticQueue = [];
+    const first = this.history.length;
     for (const line of lines) this.history.push(line.length > HISTORY_LINE_CHARS ? line.slice(0, HISTORY_LINE_CHARS) : line);
-    if (this.history.length > HISTORY_KEEP * 2) this.history.splice(0, this.history.length - HISTORY_KEEP);
+    if (this.full && this.scroll > 0) {
+      // keep showing what is shown: the view moves up with the conversation
+      let rows = 0;
+      for (let i = first; i < this.history.length; i++) rows += this.wrappedAt(i, this.width).length;
+      this.scroll += rows;
+      this.unseen += rows;
+    }
+    const keep = this.full ? FULL_KEEP : HISTORY_KEEP;
+    if (this.history.length > keep * (this.full ? 1.25 : 2)) {
+      const drop = this.history.length - keep;
+      this.history.splice(0, drop);
+      this.wrapped.splice(0, drop);
+    }
     return lines;
   }
 
@@ -181,6 +390,14 @@ export class Screen {
   // What was on screen above our output (a short session: the shell that started us) is overwritten.
   repaint() {
     if (this.closed) return;
+    if (this.full) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = null;
+      this.resizeSince = 0;
+      this.takeStatic();
+      this.draw({ full: true });
+      return;
+    }
     if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
     clearTimeout(this.resizeTimer);
     this.resizeTimer = null;
@@ -199,6 +416,13 @@ export class Screen {
     }
     // Every row is overwritten (EL clears what the new text does not cover) and what is left below is
     // erased, so no old text survives, wherever the terminal put it when it re-flowed.
+    if (this.pin) {
+      const used = tail.reduce((n, line) => n + rowsOf(line, cols), 0);
+      this.pinned = screenRows;
+      const gap = this.gapFor(used, layout.rows.length);
+      layout.rows.unshift(...Array(gap).fill(''));
+      if (layout.cursorRow !== null) layout.cursorRow += gap;
+    }
     const all = [...tail, ...layout.rows];
     let buf = SYNC_START + ESC.hideCursor + this.titleUpdate() + '\x1b[H';
     buf += all.map((row) => row + '\x1b[0m\x1b[K').join('\r\n');
@@ -206,11 +430,13 @@ export class Screen {
     buf += this.settleCursor(layout);
     buf += SYNC_END;
     this.out.write(buf);
+    if (this.pinned !== null) this.pinned = layout.rows.length;
   }
 
   flush() {
     if (this.closed) return;
     if (this.resizing) return; // the repaint after the resize writes everything that is waiting
+    if (this.full) { this.takeStatic(); this.draw(); return; }
     if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
     const cols = this.width;
     let buf = SYNC_START + ESC.hideCursor + this.titleUpdate() + '\r' + ESC.up(this.cursorRow) + ESC.clearDown;
@@ -220,10 +446,17 @@ export class Screen {
       buf += lines.map((l) => l + '\x1b[0m').join('\r\n') + '\r\n';
     }
     const layout = this.layoutLive(cols);
+    const gap = this.gapFor(lines.reduce((n, line) => n + rowsOf(line, cols), 0), layout.rows.length);
+    if (gap) {
+      layout.rows.unshift(...Array(gap).fill(''));
+      if (layout.cursorRow !== null) layout.cursorRow += gap;
+    }
     buf += layout.rows.map((r) => r + '\x1b[0m').join('\r\n');
     buf += this.settleCursor(layout);
     buf += SYNC_END;
     this.out.write(buf);
+    // the region now ends on the last row of the screen (it did before, or the output scrolled it there)
+    if (this.pinned !== null) this.pinned = layout.rows.length;
   }
 
   // Erase the live region (used before exiting or handing the terminal to a child).
@@ -232,12 +465,23 @@ export class Screen {
     if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
     this.out.write('\r' + ESC.up(this.cursorRow) + ESC.clearDown + ESC.showCursor);
     this.cursorRow = 0;
+    this.pinned = null; // whatever is written now (a child process) moves the cursor where we cannot see
   }
 
   clearScreen() {
+    if (this.full) {
+      this.history = [];
+      this.wrapped = [];
+      this.scroll = 0;
+      this.unseen = 0;
+      this.staticQueue = [];
+      this.draw({ full: true });
+      return;
+    }
     this.out.write(ESC.clearScreen);
     this.cursorRow = 0;
     this.history = [];
+    if (this.pin) this.pinned = this.height; // from the top row
     this.flush();
   }
 
@@ -247,7 +491,14 @@ export class Screen {
     if (this.closed) return;
     if (this.resizing) this.repaint(); // the cursor is not where the last draw left it: put things in order first
     this.renderLive = () => ({ lines: [] });
-    this.flush();
+    this.pinned = null; // no blank rows left behind: the shell, or the next process, goes on right below the output
+    if (this.full) {
+      this.takeStatic();
+      this.full = false;
+      this.out.write(ALT_OFF); // the shell's screen comes back as it was
+    } else {
+      this.flush();
+    }
     this.closed = true;
     clearTimeout(this.resizeTimer);
     // Give the tab back its old label: a terminal with a title stack restores it, and one without is