@hncode/hncode 0.3.3 → 0.3.5

package/src/tui.js

@@ -34,7 +34,7 @@ import * as upd from './update.js';
 import { renderTasksBrowser, handleTasksBrowserKey, visibleTasks } from './tasks-browser.js';
 import { renderTaskOutputViewer, handleViewerKey, makeViewerState } from './task-output-viewer.js';
 import { renderSwarmProgress } from './swarm-progress.js';
-import { sortedTasks, getTask, settleTask, STATUS_LABEL } from './agent-task.js';
+import { sortedTasks, getTask, settleTask, STATUS_LABEL, backgroundTaskCard } from './agent-task.js';
 import { localVersion } from './version.js';
 import { listSkills, readSkill, importSkill, deleteSkill, skillPrompt, skillCompletions, normalizeSkillName, SKILL_PREFIX, skillsDir } from './skills.js';
 import { loadHooks, describeHooks, runShellHooks, HOOK_EVENTS } from './hooks.js';
@@ -97,11 +97,18 @@ export const COMMANDS = [
   { name: 'branch', desc: 'List, create, or switch git branches', priority: 62, argumentHint: '[list | <name> | -c <name>]' },
   { name: 'worktree', desc: 'List, add, or remove git worktrees for parallel work', priority: 60, argumentHint: '[list | add <dir> [branch] | remove <dir>]' },
   { name: 'pr', desc: 'Show the URL to open a pull request for the current branch', priority: 60, argumentHint: '[base]' },
+  { name: 'add', aliases: ['stage'], desc: 'Stage changes (all by default, or given paths)', priority: 62, argumentHint: '[<path> ...]' },
+  { name: 'diff', desc: 'Show uncommitted changes', priority: 62, argumentHint: '[--staged] [<path>]' },
+  { name: 'log', desc: 'Show recent commits', priority: 62, argumentHint: '[count] [<path>]' },
+  { name: 'push', desc: 'Push the current branch (asks first)', priority: 62, argumentHint: '[branch] [-f]' },
+  { name: 'stash', desc: 'Stash changes: list / push / pop', priority: 60, argumentHint: '[list | push [msg] | pop]' },
+  { name: 'rebase', desc: 'Rebase the current branch onto another (asks first)', priority: 60, argumentHint: '<branch>' },
   { name: 'cache', desc: 'Toggle prompt caching for long stable prefixes (saves input tokens)', priority: 58, argumentHint: '[on|off]' },
   { name: 'logout', aliases: ['disconnect'], desc: 'Log out of a configured provider', priority: 40 },
   { name: 'feedback', aliases: ['bug'], desc: 'Send feedback to the maintainers', priority: 60 },
   { name: 'update', desc: 'Check for and install a newer version', priority: 40, argumentHint: '[-y]' },
   { name: 'auto-update', desc: 'Toggle automatic background updates (check at startup + every 30 min)', priority: 40, argumentHint: '[on|off]' },
+  { name: 'auto-compact', aliases: ['autocompact'], desc: 'Toggle automatic context compaction at 85% of the window', priority: 40, argumentHint: '[on|off]' },
   { name: 'version', desc: 'Show version information', priority: 20 },
   { name: 'exit', aliases: ['quit', 'q'], desc: 'Exit the application', priority: 20 },
 ].sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.name.localeCompare(b.name));
@@ -254,7 +261,7 @@ export const TIPS = [
   '/yolo auto-approves anything inside the workspace — risky paths still ask',
   '/auto never interrupts you; everything runs and is decided automatically',
   'Shift+Arrow selects text in the composer; Backspace or Delete removes it',
-  'Ctrl+J inserts a newline without sending the message',
+  'Shift+Enter inserts a newline without sending the message',
   'Ctrl+T expands or collapses the todo panel',
   'Ctrl+O expands or collapses tool output, thinking blocks and Edit diffs',
   'Ctrl+B moves a long-running foreground Bash command to the background',
@@ -670,17 +677,25 @@ function wrapWords(str, width) {
   width = Math.max(1, width | 0);
   const out = [];
   let line = '';
+  // Running width of `line`. It used to be recomputed with
+  // `visualCol(line + ' ' + w)` on EVERY word, which is O(line) per word and so
+  // O(n²) per paragraph — a single long line (a streamed paragraph, a wide table
+  // row) cost ~46ms at 20KB and froze the UI on every markdown chunk. Widths are
+  // additive for the plain text this receives (no ANSI is present until
+  // inlineMarkdown runs later), so accumulate instead of re-measuring.
+  let lineW = 0;
   // Expand tabs first: visualCol counts '\t' as 0 columns but the terminal
   // advances to the next tab stop, which made the row wider than computed and
   // wrapped it onto the following line.
   const words = expandTabs(str).split(' ');
-  for (let w of words) {
+  for (const w of words) {
+    const wW = visualCol(w);
     // A word longer than the line must be hard-split. This MUST measure visual
     // columns (not string length): CJK characters occupy two cells, so slicing
     // by `.length` would emit lines twice as wide as the box and the terminal
     // would wrap them onto the next row, corrupting the layout.
-    if (visualCol(w) > width) {
-      if (line) { out.push(line); line = ''; }
+    if (wW > width) {
+      if (line) { out.push(line); line = ''; lineW = 0; }
       let chunk = '';
       let cw = 0;
       for (const ch of w) {
@@ -688,12 +703,18 @@ function wrapWords(str, width) {
         if (cw + chw > width) { out.push(chunk); chunk = ''; cw = 0; }
         chunk += ch; cw += chw;
       }
-      if (chunk) line = chunk;
+      if (chunk) { line = chunk; lineW = cw; }
       continue;
     }
-    const cand = line ? line + ' ' + w : w;
-    if (visualCol(cand) <= width) line = cand;
-    else { if (line) out.push(line); line = w; }
+    const sep = line ? 1 : 0;              // the single space we would add
+    if (lineW + sep + wW <= width) {
+      line = line ? line + ' ' + w : w;
+      lineW += sep + wW;
+    } else {
+      if (line) out.push(line);
+      line = w;
+      lineW = wW;
+    }
   }
   if (line) out.push(line);
   else if (out.length === 0) out.push('');
@@ -1561,6 +1582,37 @@ function messageLines(msg, width, workspace, expanded, spin, pulseStart) {
     return out;
   }
 
+  // A BACKGROUND TASK lifecycle card (kimi-style):
+  //     ● agent task completed in background (review the diff)
+  //     ✗ bash task failed in background (npm test · exit 1)
+  // The bullet is `●` normally and `✗` for a failure; the colour follows the
+  // phase. The task's conclusion sits underneath, indented, and is capped like
+  // a tool result so one chatty subagent cannot flood the transcript.
+  if (msg.role === 'bg_task') {
+    const card = msg.card || { phase: 'completed', headline: 'background task finished', detail: undefined };
+    const tone = card.phase === 'started' ? C.cyan : card.phase === 'completed' ? C.green : C.red;
+    const bullet = card.phase === 'failed' ? '✗ ' : '● ';
+    const out = [];
+    const detail = card.detail ? col(` (${card.detail})`, C.gray) : '';
+    out.push({ text: col(bullet, tone) + col(card.headline, tone) + detail, ind: '', raw: true });
+    const body = String(msg.text || '').trim();
+    if (body) {
+      const indent = '  ';
+      const avail = Math.max(1, width - visualCol(indent));
+      const lines = body.replace(/\r\n/g, '\n').split('\n');
+      const MAX = expanded ? 200 : 6;
+      for (const ln of lines.slice(0, MAX)) {
+        for (const w of (ln === '' ? [''] : wrapWords(ln, avail))) {
+          out.push({ text: col(w, C.gray), ind: indent, raw: true });
+        }
+      }
+      if (lines.length > MAX) {
+        out.push({ text: col(`… ${lines.length - MAX} more lines, ctrl+o to expand`, C.gray), ind: indent, raw: true });
+      }
+    }
+    return out;
+  }
+
   // Tool output: a single "↳ " marker on the first line, then the output
   // indented by 2 columns. Long output is capped (kimi caps result previews
   // too) so one command cannot flood the whole transcript.
@@ -2171,14 +2223,34 @@ export function argStreamLineCount(st, key) {
 // streamed (assistant text and a Write's content only ever grow), and is written
 // once when a turn completes. A large equal-length replacement does not occur on
 // these fields — the diff/content that can change arbitrarily live elsewhere.
+// Fingerprint memo. `fp()` used to build `${len}:${text}` for every field of
+// every message on EVERY frame — for a 3.4k-message transcript the key strings
+// alone measured ~60ms per frame, which starved the 80ms animation tick and
+// made the startup animation visibly stall. Text fields change rarely, so the
+// fingerprint is memoised per string VALUE: the same immutable string returns
+// the same fingerprint without re-measuring. The map is bounded so a long
+// session with ever-growing streamed text cannot grow it without limit.
 const FP_VERBATIM_MAX = 4096;
+const FP_CACHE_MAX = 8192;
+const fpCache = new Map();
 function fp(s) {
   if (s == null) return '0';
-  const str = String(s);
+  const str = typeof s === 'string' ? s : String(s);
+  const hit = fpCache.get(str);
+  if (hit !== undefined) return hit;
   const n = str.length;
-  return n <= FP_VERBATIM_MAX ? n + ':' + str : n + ':';
+  // Short strings keep the text inline (cheap and collision-free); long ones use
+  // the length alone, as before.
+  const out = n <= FP_VERBATIM_MAX ? n + ':' + str : n + ':';
+  if (fpCache.size >= FP_CACHE_MAX) {
+    const oldest = fpCache.keys().next().value;
+    if (oldest !== undefined) fpCache.delete(oldest);
+  }
+  fpCache.set(str, out);
+  return out;
 }
 
+
 // Fingerprint of a tool-args object for the render-cache key. `JSON.stringify`
 // was used here and stringified EVERY argument — including a streaming Write's
 // whole file content — on every frame. The rendered tool line only shows the key
@@ -2196,82 +2268,158 @@ function fpArgs(args) {
   return out;
 }
 
-function renderChatLines(state, w) {
+export function renderChatLines(state, w, viewport) {
   const out = [];
   const expanded = !!state.expanded;
-  // One blank column on the left of the whole transcript, so the markers (❯, ●,
-  // ↳) do not sit flush against the screen edge.
   const PAD = ' ';
   const padW = visualCol(PAD);
   const innerW = Math.max(1, w - padW);
-  for (const msg of state.chat) {
-    // A `user` / `queued` message is drawn inside a COMPOSER-STYLE BOX: rounded
-    // corners with `─`, and a `│` down each side — so a sent prompt looks exactly
-    // like the input box it was typed into.
-    // `steer` gets NO box: it is injected into the turn already in progress, so a
-    // box would falsely suggest a separate turn had started.
+  const spinFrame = SPINNER[(state.spin || 0) % SPINNER.length];
+  const chat = state.chat;
+  const n = chat.length;
+
+  // Pass 1: exact row count per message (and the total). Every message's cache
+  // is validated/rebuilt here so the counts are exact; only the STRING assembly
+  // is limited to the visible window.
+  const rowStart = new Int32Array(n);
+  const msgLen = new Int32Array(n);
+  let cursor = 0;
+  for (let mi = 0; mi < n; mi++) {
+    const m = chat[mi];
+    const border = m.role === 'user' || m.role === 'queued' || m.role === 'bash';
+    const ww = border ? Math.max(1, Math.min(1, innerW - 4)) : innerW; // placeholder
+    void ww;
+    rowStart[mi] = cursor;
+    // Reuse/minimal layout for the row count: same width/border arithmetic as
+    // the layout path below. We need boxText for bordered messages.
+    const boxInner = Math.max(1, innerW - 4);
+    const boxText = Math.max(1, boxInner - Math.min(1, Math.max(0, boxInner - 1)) * 2);
+    const rowWidth = border ? boxText : innerW;
+    const cached = m._cache;
+    const valid = cached
+      && cached.rowW === rowWidth && cached.expanded === expanded
+      && cached.textRef === m.text && cached.streamRef === m.streamContent
+      && cached.liveRef === m.liveOutput && cached.failed === m.failed
+      && cached.diffRef === m.diff && cached.countsRef === m._diffCounts
+      && cached.keyArgs === (m.toolArgs ? fpArgs(m.toolArgs) : '0')
+      && cached.spinKey === (m.role === 'tool' && m.pending ? (state.spin || 0) : 0)
+      && cached.isPending === (m.pending ? 1 : 0);
+    if (valid) {
+      msgLen[mi] = cached.rows.length + (border ? 2 : 0);
+    } else {
+      const rows = messageLines(m, rowWidth, state.cwd, expanded, state.spin, state.pulseStart);
+      const wrapped = rows.map(rowToLine);
+      const spinKey2 = (m.role === 'tool' && m.pending) ? (state.spin || 0) : 0;
+      const isPending2 = m.pending ? 1 : 0;
+      const cc = {
+        rowW: rowWidth, expanded, spinKey: spinKey2, isPending: isPending2,
+        textRef: m.text, streamRef: m.streamContent, liveRef: m.liveOutput,
+        failed: m.failed, diffRef: m.diff, countsRef: m._diffCounts,
+        keyArgs: m.toolArgs ? fpArgs(m.toolArgs) : '0',
+        rows: wrapped, spinRows: null,
+      };
+      for (let i = 0; i < wrapped.length; i++)
+        if (wrapped[i].indexOf(SPIN_PLACEHOLDER) >= 0) {
+          if (!cc.spinRows) cc.spinRows = new Set();
+          cc.spinRows.add(i);
+        }
+      m._cache = cc;
+      msgLen[mi] = wrapped.length + (border ? 2 : 0);
+    }
+    cursor += msgLen[mi];
+  }
+  const total = cursor;
+  state._chatTotal = total;
+
+  // Visible window: [total - bodyH - scroll, total - scroll), with a small
+  // margin above so a message crossing the boundary renders whole. When no
+  // viewport is given, render everything (full render).
+  let visibleFrom = 0, visibleTo = -1;
+if (viewport && Number.isFinite(viewport.bodyH) && viewport.bodyH > 0) {
+    const bodyH = viewport.bodyH;
+    // Clamp scroll against the total we just computed, so a stale scroll value
+    // cannot push the window past the end (missing the tail).
+    const maxScroll = Math.max(0, total - bodyH);
+    const scroll = Math.min(maxScroll, Math.max(0, viewport.scroll || 0));
+    const end = total - scroll;
+    const start = end - bodyH;
+    visibleFrom = Math.max(0, start - 12);
+    visibleTo = Math.min(total, end + 12);
+  }
+
+  // Pass 2: assemble final strings, but only for messages that overlap the
+  // visible range (or the whole transcript when no viewport).
+  cursor = 0;
+  for (let mi = 0; mi < n; mi++) {
+    const msg = chat[mi];
     const bordered = msg.role === 'user' || msg.role === 'queued' || msg.role === 'bash';
-    // A bash-mode echo uses the violet shellMode frame — same hue as kimi.
     const boxColor = msg.role === 'bash' ? C.shellMode : C.border;
-    // The box spans one column less than the full inner width, so the right edge
-    // has a 1-column margin (matching the left margin from `PAD`).
-    const boxW = innerW - 2;                   // total box width, including both │
-    const boxInner = Math.max(1, boxW - 2);    // span the two │s occupy
-    // One column of padding inside each wall, mirroring the composer box.
-    const boxPad = Math.min(1, Math.max(0, boxInner - 1));
-    const boxText = Math.max(1, boxInner - boxPad * 2);
-    const topRule = PAD + col('╭' + '─'.repeat(boxInner) + '╮', boxColor);
-    const botRule = PAD + col('╰' + '─'.repeat(boxInner) + '╯', boxColor);
-    // A box always needs its TOP border — including when the message is the first
-    // row of the transcript. (The earlier `out.length > 0` guard came from the
-    // rule-only version, where a leading divider looked wrong; a box without a
-    // top is simply broken.) For adjacent bordered messages the previous box's
-    // bottom already serves as this one's top, so skip the duplicate.
-    if (bordered && out[out.length - 1] !== topRule) out.push(topRule);
-    // The cache key MUST include everything messageLines() reads. toolArgs was
-    // missing, so a tool row rendered at `tool_start` (args still {}) kept its
-    // stale "Using Bash" line even after `tool_use` delivered the command —
-    // the row only appeared once some OTHER keyed field changed. liveOutput is
-    // keyed because it grows while a command runs; `failed` flips the bullet
-    // and the result colour red once the tool reports a non-zero exit.
-    // The row WIDTH is keyed (not `w`) because the rows are laid out to it:
-    // `boxText` for a bordered message (inside the box padding), `innerW` otherwise.
-    const rowW = bordered ? boxText : innerW;
-    // The cache key MUST include everything messageLines() reads. `spin` is
-    // keyed ONLY for a pending TOOL row: formatToolLine sweeps the tool name's
-    // colour with it. The pending THINKING row deliberately does not key it —
-    // its spinner is substituted outside the cache (see SPIN_PLACEHOLDER), so
-    // the 80ms tick no longer re-wraps the reasoning preview every frame.
-    const spinKey = (msg.role === 'tool' && msg.pending) ? (state.spin || 0) : 0;
-    const key = `${rowW}\u0000${expanded ? 1 : 0}\u0000${spinKey}\u0000${fp(msg.text)}\u0000${fp(msg.streamContent)}`
-        + `\u0000${msg.liveOutput ? msg.liveOutput.length : 0}\u0000${msg.failed ? 1 : 0}\u0000${fpArgs(msg.toolArgs)}`
-        + `\u0000${msg.diff ? msg.diff.length : 0}\u0000${msg._diffCounts ? msg._diffCounts.length : 0}`;
-    let cached = msg._cache;
-    if (!cached || cached.key !== key) {
-      const rows = messageLines(msg, rowW, state.cwd, expanded, state.spin, state.pulseStart);
-      cached = { key, rows: rows.map(rowToLine) };
-      msg._cache = cached;
-    }
-    // Swap the live spinner frame into any row that carries the placeholder.
-    // Done AFTER the cache, so the glyph animates without invalidating it.
-    const spinFrame = SPINNER[(state.spin || 0) % SPINNER.length];
-    const live = (r) => (r.indexOf(SPIN_PLACEHOLDER) >= 0 ? r.split(SPIN_PLACEHOLDER).join(spinFrame) : r);
-    // The margin is added here (outside the cache) so it is not baked into the
-    // cached rows. A bordered message also gets its side walls, laid out to the
-    // box's inner width so it lines up with the composer exactly.
+    let topRule = null, botRule = null, boxPad = 1, boxText = innerW;
     if (bordered) {
-      const pad = ' '.repeat(boxPad);
-      for (const r of cached.rows) {
-        out.push(PAD + col('│', boxColor) + pad + fitAnsi(live(r), boxText) + pad + col('│', boxColor));
+      const boxW = innerW - 2;
+      const boxInner = Math.max(1, boxW - 2);
+      boxPad = Math.min(1, Math.max(0, boxInner - 1));
+      boxText = Math.max(1, boxInner - boxPad * 2);
+      topRule = PAD + col('╭' + '─'.repeat(boxInner) + '╮', boxColor);
+      botRule = PAD + col('╰' + '─'.repeat(boxInner) + '╯', boxColor);
+    }
+    const cc = msg._cache || { rows: [] };
+    // Shared wall with the previous bordered message (its bottom rule is ours).
+    let shared = false;
+    if (bordered && mi > 0) {
+      const prev = chat[mi - 1];
+      shared = (prev.role === 'user' || prev.role === 'queued' || prev.role === 'bash')
+        && rowStart[mi - 1] + msgLen[mi - 1] === cursor;
+    }
+    const len = msgLen[mi];
+    const visible = visibleTo < 0 || (cursor + len > visibleFrom && cursor < visibleTo);
+    if (visible) {
+      const spinRows = cc.spinRows;
+      const liveAt = (r, i) => (spinRows && spinRows.has(i) ? r.split(SPIN_PLACEHOLDER).join(spinFrame) : r);
+      if (bordered && !shared) out.push(topRule);
+      if (bordered) {
+        const pad = ' '.repeat(boxPad);
+        const wall = col('│', boxColor);
+        for (let i = 0; i < cc.rows.length; i++)
+          out.push(PAD + wall + pad + fitAnsi(liveAt(cc.rows[i], i), boxText) + pad + wall);
+      } else {
+        for (let i = 0; i < cc.rows.length; i++) out.push(PAD + liveAt(cc.rows[i], i));
       }
+      if (bordered) out.push(botRule);
     } else {
-      for (const r of cached.rows) out.push(PAD + live(r));
+      for (let i = 0; i < len; i++) out.push('');
     }
-    if (bordered && out[out.length - 1] !== botRule) out.push(botRule);
+    cursor += len;
   }
   return out;
 }
 
+// ---- scroll anchoring --------------------------------------------------------
+// Keep a scrolled-up viewport pinned to the SAME content while new rows arrive.
+//
+// `state.scroll` counts rows up from the bottom, so when the transcript grows by
+// N rows the offset must grow by N as well — otherwise the new rows push the
+// content the user is reading off the top of the screen (the "it scrolls on its
+// own while the agent is talking" bug: measured as the viewed line moving up one
+// row per streamed chunk).
+//
+// The subtlety is the BASELINE. The previous version returned early while the
+// view was pinned (`scroll === 0`) and only recorded `_anchorRows` otherwise, so
+// during a turn the baseline went stale. The first append after the user
+// scrolled up then found `prev == null` (or an ancient value), skipped the
+// compensation, and the view drifted. Recording the baseline on EVERY call —
+// pinned or not — makes `rows - prev` always "rows added since the last paint".
+//
+// Pure: takes the state and the current chat row count, returns the new `scroll`.
+export function anchorScrollNext(state, rows) {
+  const prev = state._anchorRows;
+  state._anchorRows = rows;
+  if ((state.scroll || 0) === 0) return 0;      // pinned: keep following the tail
+  if (prev != null && rows > prev) return (state.scroll || 0) + (rows - prev);
+  return state.scroll || 0;
+}
+
+
 // Serialise a Line (array of spans) to an ANSI string.
 function lineToString(line) {
   let s = '';
@@ -2607,11 +2755,22 @@ export function refreshGitInfo(state, opts = {}) {
   if (!force && state.running) return;
   state._gitCwd = cwd;
   state._gitAt = now;
-  try {
-    state._gitInfo = gitmod.statuslineInfo(cwd);
-  } catch {
-    state._gitInfo = null;   // a git failure must never break rendering
-  }
+  // ASYNC: does not block the caller. On the startup path this is what lets the
+  // first frame draw immediately — the badge appears a moment later when git
+  // answers, instead of freezing the TUI behind four spawnSync calls. `seq`
+  // discards a stale reply if another refresh started while this one ran.
+  const seq = (state._gitSeq = (state._gitSeq || 0) + 1);
+  gitmod.statuslineInfoAsync(cwd)
+    .then((info) => {
+      if (state._gitSeq !== seq) return;      // superseded by a newer refresh
+      state._gitInfo = info;
+      if (typeof state._requestRender === 'function') state._requestRender();
+    })
+    .catch(() => {
+      if (state._gitSeq !== seq) return;
+      state._gitInfo = null;   // a git failure must never break rendering
+      if (typeof state._requestRender === 'function') state._requestRender();
+    });
 }
 
 // ---- pure frame composer (no TTY side effects) ----
@@ -3001,8 +3160,15 @@ export function composeFrame(state, cols, rows) {
   // this too and appended a whole extra viewport of rows ON TOP of the editor.
   // The frame then overflowed, the top trim ate the editor's own title and text,
   // and /personal & /set-system-prompt showed nothing but a stray caret.
-  if (!state.editor && !state.panel && !state.form && !state.picker) {
-    const chat = renderChatLines(state, w);
+if (!state.editor && !state.panel && !state.form && !state.picker) {
+    // Windowed: renderChatLines computes the visible tail from bodyH+scroll and
+    // fills the rest with padding. `chat` still has the full row count (holes
+    // are blank strings), so `chat.length` remains the true total and the
+    // slices below stay correct. `state._forceFullRender` (tests) bypasses the
+    // window so the full path can be compared.
+    const chat = state._forceFullRender
+      ? renderChatLines(state, w)
+      : renderChatLines(state, w, { bodyH, scroll: state.scroll || 0 });
     if (state.selection && state.selection.anchor && state.selection.head) {
       // Apply selection highlight directly on ANSI strings
       for (let i = 0; i < chat.length; i++) {
@@ -3642,6 +3808,46 @@ function fieldCaretCol(field, active) {
   const c = Math.max(0, Math.min(shown.length, field.caret || 0));
   return visualCol(shown.slice(0, c));
 }
+// ---- prompt history (persisted across restarts) -----------------------------
+// Kept in the hncode config directory so the history survives a restart; the
+// in-memory array alone meant every relaunch started with an empty ↑ list.
+const HISTORY_MAX = 500;
+
+function historyFile() {
+  try {
+    return path.join(path.dirname(hncodeConfigFile()), 'history.json');
+  } catch {
+    return path.join(os.homedir(), '.hncode', 'history.json');
+  }
+}
+
+export function loadHistory() {
+  try {
+    const raw = fs.readFileSync(historyFile(), 'utf8');
+    const arr = JSON.parse(raw);
+    if (!Array.isArray(arr)) return [];
+    return arr.filter((x) => typeof x === 'string' && x.trim() !== '').slice(-HISTORY_MAX);
+  } catch {
+    return [];
+  }
+}
+
+export function saveHistory(list) {
+  try {
+    const file = historyFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // Newest last, capped, and de-duplicated while keeping order.
+    const seen = new Set();
+    const out = [];
+    for (const x of (list || []).slice(-HISTORY_MAX)) {
+      if (typeof x !== 'string' || !x.trim()) continue;
+      if (seen.has(x)) continue;
+      seen.add(x);
+      out.push(x);
+    }
+    fs.writeFileSync(file, JSON.stringify(out, null, 0), 'utf8');
+  } catch { /* history is a convenience; never break the session over it */ }
+}
 
 // ---- state factory ----
 export function makeState({ cfg, session, opts }) {
@@ -3772,7 +3978,7 @@ export function makeState({ cfg, session, opts }) {
     notice: '',
     noticeKind: 'info',
     confirmExit: false,
-    history: [],
+    history: loadHistory(),   // restored from disk so ↑ works across restarts
     historyIdx: -1,
     _tipIndex: 0,
   };
@@ -3803,6 +4009,9 @@ export function reconstructChat(s) {
   const shellByAnchor = new Map();
   const shells = (s && s.shellHistory) || [];
   for (const sh of shells) {
+    // A malformed entry must not take the whole resume down: `sh.anchor` on a
+    // null threw right here, before the guard inside emitShells() could help.
+    if (!sh || typeof sh !== 'object') continue;
     const a = Number(sh.anchor != null ? sh.anchor : 0);
     if (!shellByAnchor.has(a)) shellByAnchor.set(a, []);
     shellByAnchor.get(a).push(sh);
@@ -3810,8 +4019,11 @@ export function reconstructChat(s) {
   // Emit the shell block for anchor `a` (command + its output) onto `out`.
   const emitShells = (out, a) => {
     for (const sh of shellByAnchor.get(a) || []) {
+      // Same junk-entry guard as the messages loop: a malformed shellHistory
+      // entry must not take the whole resume down with it.
+      if (!sh || typeof sh !== 'object') continue;
       out.push({ role: 'bash', text: String(sh.cmd || '') });
-      if (sh.result) out.push({ role: 'tool_result', text: sh.result, failed: sh.ok === false });
+      if (sh.result) out.push({ role: 'tool_result', text: String(sh.result), failed: sh.ok === false });
     }
   };
 
@@ -3819,6 +4031,11 @@ export function reconstructChat(s) {
   const msgs = (s && s.messages) || [];
   for (let mi = 0; mi < msgs.length; mi++) {
     const m = msgs[mi];
+    // Skip junk entries. A session file can carry a null (older writer, hand
+    // edit, truncated write); reading `m.role` off it threw and the whole resume
+    // died with an unhandled TypeError instead of showing the rest of the
+    // conversation.
+    if (!m || typeof m !== 'object') continue;
     const role = m.role;
     const text = typeof m.content === 'string' ? m.content : '';
     // Inject shell commands that anchored BEFORE this message (in the slot after
@@ -3827,7 +4044,8 @@ export function reconstructChat(s) {
     if (role === 'user') out.push({ role: 'user', text });
     else if (role === 'assistant') {
       out.push({ role: 'assistant', text });
-      for (const tc of (m.toolCalls || [])) {
+      for (const tc of (Array.isArray(m.toolCalls) ? m.toolCalls : [])) {
+        if (!tc || typeof tc !== 'object') continue;
         out.push({ role: 'tool', toolName: tc.name, toolArgs: tc.args || {}, pending: false });
       }
     } else if (role === 'tool') {
@@ -3987,7 +4205,8 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
           { label: 'provider', sub: 'manage AI providers' },
           { label: 'statusline', sub: 'configure status line items' },
           { label: 'add-dir', sub: 'add an additional workspace directory' },
-          { label: 'auto-update', sub: 'check npm for updates at startup + every 30 min' },
+          { label: 'auto-update', sub: `check npm for updates at startup + every 30 min — currently ${cfg.autoUpdate ? 'on' : 'off'}` },
+          { label: 'auto-compact', sub: `summarize older history at 85% of the window — currently ${cfg.autoCompact === false ? 'off' : 'on'}` },
         ],
         onPick: (it) => { dispatch(it.label, '', state, cfg, session, h, submit, stdout); return true; },
       });
@@ -4795,7 +5014,7 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
         '',
         'Shortcuts',
         '  Enter          send the message',
-        '  Ctrl-J         insert a newline',
+        '  Shift+Enter    insert a newline',
         '  Ctrl+Shift+C   copy the selection (or the last answer)',
         '  Ctrl+Shift+V   paste the clipboard (multi-line pastes collapse)',
         '  ↑ / ↓          input history (empty composer) · scroll the chat',
@@ -4858,6 +5077,22 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
         : 'Auto-update OFF');
       return;
     }
+    case 'auto-compact': {
+      // Toggle /auto-compact. Persists to config.toml so it survives restarts.
+      const a = raw.toLowerCase();
+      let want;
+      if (a === 'on') want = true;
+      else if (a === 'off') want = false;
+      else want = cfg.autoCompact === false;   // flip from the current state
+      try { setConfigString('auto_compact', want ? 'true' : 'false'); }
+      catch (e) { appErr('Could not write config.toml: ' + e.message); return; }
+      cfg.autoCompact = want;
+      cfg.raw.auto_compact = want;
+      app(want
+        ? 'Auto-compaction ON — older history is summarized once a request reaches 85% of the context window'
+        : 'Auto-compaction OFF — history is no longer trimmed automatically (use /compact manually)');
+      return;
+    }
     case 'update': {
       // Manual update check. This is the ONLY place an update is ever reported;
       // the automatic background check stays completely silent.
@@ -4928,28 +5163,35 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
     case 'statusline':
       openPicker({
         title: 'Status line items',
-        items: [
-          { label: 'permission mode', kind: 'toggle', isOn: state.slMode !== false },
-          { label: 'model name', kind: 'toggle', isOn: state.slModel !== false },
-          { label: 'thinking effort', kind: 'toggle', isOn: state.slEffort !== false },
-          { label: 'current directory', kind: 'toggle', isOn: state.slCwd !== false },
-          { label: 'git branch & diff', kind: 'toggle', isOn: state.slGit !== false },
-          { label: 'background tasks', kind: 'toggle', isOn: state.slTasks !== false },
-          { label: 'rotating tips', kind: 'toggle', isOn: state.slTips !== false },
-        ],
+        items: (() => {
+          // `sub` must be set here, not only in onPick: the picker renders
+          // item.sub, so without an initial value every toggle showed a blank
+          // state until the user toggled it once.
+          const toggles = [
+            ['permission mode', 'slMode'],
+            ['model name', 'slModel'],
+            ['thinking effort', 'slEffort'],
+            ['current directory', 'slCwd'],
+            ['git branch & diff', 'slGit'],
+            ['background tasks', 'slTasks'],
+            ['rotating tips', 'slTips'],
+          ];
+          return toggles.map(([label, key]) => {
+            const isOn = state[key] !== false;
+            return { label, key, kind: 'toggle', isOn, sub: isOn ? 'on' : 'off' };
+          });
+        })(),
         hint: '↑↓ navigate · Enter toggle · Esc close',
         onPick: (it) => {
           it.isOn = !it.isOn;
           it.sub = it.isOn ? 'on' : 'off';
-          const key = { 'permission mode': 'slMode', 'model name': 'slModel', 'thinking effort': 'slEffort', 'current directory': 'slCwd', 'git branch & diff': 'slGit', 'background tasks': 'slTasks', 'rotating tips': 'slTips' }[it.label];
-          state[key] = it.isOn;
-          if (key === 'slGit') refreshGitInfo(state, { force: true });
+          state[it.key] = it.isOn;
+          if (it.key === 'slGit') refreshGitInfo(state, { force: true });
           app(`Status line: ${it.label} → ${it.isOn ? 'shown' : 'hidden'}`);
           return false;
         },
       });
       return;
-
     case 'export-md': {
       const msgs = session.messages || [];
       if (!msgs.length) { appErr('Nothing to export (empty session).'); return; }
@@ -5121,7 +5363,11 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
       return;
     }
     case 'plugins': {
-      const { pluginCommands, loadedPlugins } = await import('../plugin.js');
+      const { pluginCommands, API } = await import('./plugin.js');
+      // `loadedPlugins` is module-private; the public way to read it is the
+      // API.plugins getter. Importing a non-exported name yielded `undefined`
+      // and crashed on `.length`.
+      const loadedPlugins = API.plugins;
       if (!loadedPlugins.length) { app('No plugins loaded. Check ~/.hncode/plugins/'); return; }
       const lines = ['Loaded plugins:', ...loadedPlugins.map((p) => `  • ${p.name} v${p.version} (${p.id})`)];
       if (pluginCommands.length) {
@@ -5220,6 +5466,122 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
       h.openPanel('hncode — git', lines);
       return;
     }
+    case 'add': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      // `/add` stages everything (`git add -A`); `/add <path> ...` stages just
+      // those paths. This is the explicit staging step /commit does implicitly.
+      const paths = raw.split(/\s+/).filter(Boolean);
+      const r = gitmod.stage(paths, cwd);
+      if (!r.ok) { appErr(`git add failed: ${r.error}`); return; }
+      const staged = gitmod.stagedFiles(cwd);
+      app(paths.length ? `Staged ${paths.length} path(s).` : 'Staged all changes.');
+      say(`Index now holds ${staged.length} file(s):\n` + staged.map((f) => '  ' + f).join('\n'));
+      return;
+    }
+    case 'diff': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const staged = /--staged|--cached/.test(raw);
+      const path = raw.replace(/--staged|--cached/g, '').trim();
+      const r = gitmod.diffText(cwd, { staged, path: path || undefined });
+      if (!r.ok) { appErr(`git diff failed: ${r.error}`); return; }
+      if (r.empty) { say(staged ? 'No staged changes.' : 'No uncommitted changes.'); return; }
+      say((staged ? 'Staged changes' : 'Uncommitted changes') + (path ? ` in ${path}` : '') + ':\n' + r.text);
+      return;
+    }
+    case 'log': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const count = parts[0] && /^\d+$/.test(parts[0]) ? parts.shift() : undefined;
+      const path = parts.join(' ') || undefined;
+      const r = gitmod.logText(cwd, { count, path });
+      if (!r.ok) { appErr(`git log failed: ${r.error}`); return; }
+      if (r.empty) { say('No commits yet.'); return; }
+      say(`Recent commits${path ? ` for ${path}` : ''}:\n` + r.text);
+      return;
+    }
+    case 'push': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const force = parts.includes('-f') || parts.includes('--force');
+      const branchArg = parts.find((x) => !x.startsWith('-')) || '';
+      const branch = branchArg || gitmod.currentBranch(cwd);
+      const upstream = gitmod.hasUpstream(cwd, branch);
+      const state2 = gitmod.aheadBehind(cwd, branch);
+      const detail = `${branch}${upstream ? '' : ' (no upstream — will set one)'}${state2 ? ` — ${state2}` : ''}`;
+      // Push is OUTBOUND: always confirm first, and say exactly what will happen.
+      h.openPicker({
+        title: `Push ${branch}?`,
+        items: [
+          { label: 'Push', sub: `git push ${force ? '--force-with-lease ' : ''}origin ${detail}` },
+          { label: 'Cancel', sub: 'do not push' },
+        ],
+        searchable: false,
+        hint: '↑↓ navigate · Enter select · Esc cancel',
+        onPick: (it) => {
+          if (it.label !== 'Push') { app('Push cancelled.'); return true; }
+          const r = gitmod.push(cwd, { branch: branchArg || undefined, force, setUpstream: !upstream });
+          if (!r.ok) appErr(`Push failed: ${r.error}`);
+          else { app(`Pushed ${branch}.`); say(`git push output:\n${r.output}`); }
+          return true;
+        },
+      });
+      return;
+    }
+    case 'stash': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const sub = (parts[0] || '').toLowerCase();
+      if (!sub || sub === 'list') {
+        const list = gitmod.stashList(cwd);
+        say(list.length ? `Stashes (${list.length}):\n` + list.map((s) => '  ' + s).join('\n') : 'No stashes.');
+        return;
+      }
+      if (sub === 'push' || sub === 'save') {
+        const msg = parts.slice(1).join(' ') || undefined;
+        const r = gitmod.stashPush(cwd, msg);
+        if (!r.ok) { appErr(`git stash failed: ${r.error}`); return; }
+        app('Stashed changes.'); say(r.output || 'Changes stashed.');
+        return;
+      }
+      if (sub === 'pop') {
+        const r = gitmod.stashPop(cwd);
+        if (!r.ok) { appErr(`git stash pop failed: ${r.error}`); return; }
+        app('Restored from stash.'); say(r.output || 'Stash popped.');
+        return;
+      }
+      appErr('Usage: /stash [list] | push [message] | pop');
+      return;
+    }
+    case 'rebase': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const onto = String(raw || '').trim();
+      if (!onto) { appErr('Usage: /rebase <branch>'); return; }
+      const cur = gitmod.currentBranch(cwd);
+      // Rewrites history on the current branch: confirm before running.
+      h.openPicker({
+        title: `Rebase ${cur} onto ${onto}?`,
+        items: [
+          { label: 'Rebase', sub: `git rebase ${onto}` },
+          { label: 'Cancel', sub: 'leave the branch as is' },
+        ],
+        searchable: false,
+        hint: '↑↓ navigate · Enter select · Esc cancel',
+        onPick: (it) => {
+          if (it.label !== 'Rebase') { app('Rebase cancelled.'); return true; }
+          const r = gitmod.rebase(cwd, onto);
+          if (!r.ok) appErr(`Rebase failed (resolve conflicts, then /rebase --continue or git rebase --abort): ${r.error}`);
+          else { app(`Rebased ${cur} onto ${onto}.`); say(r.output || 'Rebase complete.'); }
+          return true;
+        },
+      });
+      return;
+    }
     case 'commit': {
       const cwd = state.cwd || cfg.workspace || process.cwd();
       if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
@@ -5389,13 +5751,22 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
       // Check if this is a plugin-registered command.
       if (isPluginCommand(cmd)) {
         const pc = findCommand(cmd);
-        if (pc && pc._plugin && typeof pc.run === 'function') {
-          try { pc.run(raw, { state, cfg, session, h, app, appErr }); }
+        // NOTE: `pc` comes from the plugin registry, which does NOT carry the
+        // `_plugin` marker — that is only added by allCommands() for display. The
+        // old guard `pc._plugin` was therefore always falsy, so plugin commands
+        // fell through to "Unknown command" and never ran at all. isPluginCommand
+        // above already established that this name resolves to a plugin.
+        if (pc && typeof pc.run === 'function') {
+          // AWAIT the handler: plugins may register an async `run`, and without
+          // awaiting, a rejection escaped as an unhandled promise rejection and
+          // the catch below never saw it (the command appeared to fail silently).
+          try { await pc.run(raw, { state, cfg, session, h, app, appErr }); }
           catch (e) { appErr(`Plugin command "/${cmd}" failed: ${e.message}`); }
           return;
         }
       }
       // Unknown command: show error message
+      // Unknown command: show error message
       appErr(`Unknown command: /${cmdRaw.replace(/^\//, '')}`);
       return;
     }
@@ -5477,6 +5848,11 @@ function commandPathsAreInside(state, cmd, cwd) {
 function applyModel(state, cfg, next) {
   cfg.model = next.model; cfg.innerModel = next.innerModel; cfg.provider = next.provider;
   cfg.baseUrl = next.baseUrl; cfg.endpoint = next.endpoint; cfg.apiKey = next.apiKey; cfg.protocol = next.protocol;
+  // Carry the resolved context window over too. resolveProvider/resolveModelArg
+  // compute `maxContextTokens` for the NEW model, but it lives on the returned
+  // object — without copying it here, cfg (and the gauge below) kept the previous
+  // model's window after a switch.
+  if (next.maxContextTokens != null) cfg.maxContextTokens = next.maxContextTokens;
   state.model = cfg.model; state.provider = cfg.provider;
   state.modelLabel = modelLabel(cfg) || cfg.model || '';
   state.seenThinking = false;
@@ -5730,30 +6106,12 @@ export async function startTUI(opts) {
   const stdout = process.stdout;
   const addChat = (msg) => {
     state.chat.push(normalizeMsg(msg));
-    // Only auto-follow when the view is ALREADY pinned to the bottom. Forcing
-    // scroll = 0 unconditionally yanked the user back down whenever new output
-    // arrived — so reading history mid-turn was impossible.
-    //
-    // This used to be `if ((state.scroll||0) === 0) state.scroll = 0;`, i.e. a
-    // NO-OP. The comment promised "auto-follow" but nothing re-anchored the view,
-    // so appending a tall message (a long Read/Bash result) pushed the whole
-    // transcript up by its height in a single frame instead of scrolling by one
-    // row — the "everything jumps" report. When the user IS scrolled up we leave
-    // the offset alone, which is the other half of the original intent.
-    if ((state.scroll || 0) === 0) {
-      state.scroll = 0;              // pinned: keep following the newest message
-    } else {
-      // Scrolled up: grow the offset by exactly the number of rows this message
-      // added, so the content the user is reading does not move.
-      try {
-        const rows = renderChatLines(state, dims().cols).length;
-        if (state._addChatRows != null) {
-          const grew = Math.max(0, rows - state._addChatRows);
-          if (grew) state.scroll = (state.scroll || 0) + grew;
-        }
-        state._addChatRows = rows;
-      } catch { /* rendering is best-effort here; never break a message append */ }
-    }
+    // Auto-follow / re-anchor is delegated to anchorScroll() so exactly ONE place
+    // adjusts `scroll`. This block used to run its own row-delta compensation
+    // against a second baseline (_addChatRows) which — like anchorScroll's old
+    // one — was not refreshed while the view was pinned. After the user scrolled
+    // up, BOTH paths added the same rows, so the view jumped by twice the growth.
+    anchorScroll();
     renderFrame();
   };
   let noticeTimer = null;
@@ -5784,6 +6142,9 @@ export async function startTUI(opts) {
     if (out) stdout.write(out);
   }
   function renderFrame() { paintNow(); }
+  // Let module-level helpers (refreshGitInfo) ask for a repaint once their async
+  // data lands, without holding a reference to this closure.
+  state._requestRender = renderFrame;
   // No frame-rate cap: paint on the next event-loop turn. Calls made within the
   // same tick still coalesce (paintScheduled), so a burst of stream deltas
   // produces one frame per tick at full speed instead of being throttled to
@@ -6151,11 +6512,46 @@ export async function startTUI(opts) {
   // and doing it lazily on the first Ctrl+Shift+V made the shortcut look dead.
   warmClipboard();
   setTip(state);
-  // Populate the git badge before the first paint so the status line is correct
-  // immediately (from then on the 15s timer / turn-end keep it current).
+  // Fill the git badge — asynchronously, AFTER the first paint. It used to run
+  // before renderFrame() with a blocking spawnSync git, which added ~330ms to
+  // startup; now the frame draws at once and the badge appears when git answers.
   refreshGitInfo(state, { force: true });
   renderFrame();
 
+  // MCP: connect in the BACKGROUND, now that the UI is on screen. Each server
+  // gets up to CONNECT_TIMEOUT_MS, so doing this before the first paint would
+  // stall the whole TUI; instead we start it and report the outcome as a notice
+  // ("MCP: connected to …") when it lands. Tools registered here become visible
+  // to the model on its next turn.
+  if (typeof opts.mcpConnect === 'function') {
+    Promise.resolve()
+      .then(() => opts.mcpConnect())
+      .then((res) => {
+        const servers = (res && res.servers) || [];
+        if (!servers.length) return;
+        // The notice line is a SINGLE status-line row, so report all servers in
+        // one message — looping notice() per server only left the last one
+        // visible. Failures are listed too, and the whole notice turns red when
+        // any server failed.
+        const okServers = servers.filter((s) => s.ok);
+        const bad = servers.filter((s) => !s.ok);
+        const parts = [];
+        if (okServers.length) {
+          const tools = okServers.reduce((n, s) => n + (s.toolCount || 0), 0);
+          const names = okServers.map((s) => s.name).join(', ');
+          parts.push(`MCP connected: ${names} (${tools} tool${tools === 1 ? '' : 's'})`);
+        }
+        if (bad.length) {
+          parts.push(`MCP failed: ${bad.map((s) => s.name).join(', ')}`);
+        }
+        notice(parts.join(' · '), bad.length ? 'error' : 'info');
+        // A connecting server may have changed the tool list; repaint so any
+        // tool-count readout is current.
+        renderFrame();
+      })
+      .catch(() => { /* MCP must never break the session */ });
+  }
+
   const tipTimer = setInterval(() => { setTip(state); renderFrame(); }, TIP_INTERVAL);
   // Git badge: a fixed 15s cadence. Deliberately NOT tied to the frame loop (that
   // spawned git per keystroke) and NOT run mid-turn (the agent is still writing;
@@ -7069,12 +7465,26 @@ export async function startTUI(opts) {
         renderFrame(); return;
       }
       if (t.key === 'up' || t.key === 'down') {
-        // ↑/↓ only scroll when the COMPOSER has no use for the key. While the
-        // agent streams you are usually typing the next instruction, so a
-        // multi-line draft must still move its caret — swallowing the key for
-        // scrolling unconditionally is what made ↑/↓ "always scroll". When the
-        // caret is already on the first/last row the key falls through to the
-        // scroll below, so both behaviours are available.
+        // ↑/↓ while the agent streams: FIRST give the composer its caret move
+        // (a multi-line draft must still navigate), then fall back to scrolling
+        // ONLY when there is nothing else to do. The scroll is what made ↑ feel
+        // stuck while output streamed, so it is now the last resort.
+        const cur = state.input || '';
+        if (cur === '') {
+          // Empty composer: the key belongs to HISTORY, not to the viewport.
+          // With no history the key does nothing at all — silently scrolling
+          // the transcript is what made a bare ↑ feel like it ate the key.
+          if (state.history.length) {
+            if (state.historyIdx === -1) state.historyIdx = state.history.length;
+            state.historyIdx = t.key === 'up'
+              ? Math.max(0, state.historyIdx - 1)
+              : Math.min(state.history.length, state.historyIdx + 1);
+            state.input = state.historyIdx >= state.history.length ? '' : (state.history[state.historyIdx] || '');
+            state.caret = state.input.length;
+            refreshMenu(state); renderFrame();
+          }
+          return;
+        }
         const insideW = Math.max(0, dims().cols - 2);
         const layout = composerLayout(state, insideW - 3);
         const dir = t.key === 'down' ? 1 : -1;
@@ -7087,6 +7497,8 @@ export async function startTUI(opts) {
           state.composerSel = null;
           renderFrame(); return;
         }
+        // Draft is on its last/first row: the key is free. Scroll the transcript
+        // (useful while output streams and you want to read back).
         scrollChat(state, t.key === 'up' ? 3 : -3);
         renderFrame(); return;
       }
@@ -7095,13 +7507,36 @@ export async function startTUI(opts) {
       if (t.key === 'up' || t.key === 'down') {
         const overlay = state.picker || state.form || state.panel || state.menuOpen
           || state.mentionOpen || state.editor;
-        const cur = state.input || '';
-        if (!overlay && cur === '' && state.history.length) {
-          if (state.historyIdx === -1) state.historyIdx = state.history.length;
-          state.historyIdx = t.key === 'up' ? Math.max(0, state.historyIdx - 1) : Math.min(state.history.length, state.historyIdx + 1);
-          state.input = state.historyIdx >= state.history.length ? '' : (state.history[state.historyIdx] || '');
-          state.caret = state.input.length;
-          refreshMenu(state); renderFrame(); return;
+        if (!overlay) {
+          const cur = state.input || '';
+          const insideW = Math.max(0, dims().cols - 2);
+          const layout = composerLayout(state, insideW - 3);
+          const dir = t.key === 'down' ? 1 : -1;
+          const targetRow = layout.caretRow + dir;
+          // The composer is MULTI-LINE: ↑/↓ move the caret between its rows
+          // first, and only when it is already on the first/last row does the
+          // key fall through to history. That is the usual shell/editor rule —
+          // typing a paragraph must not have ↑ yank the draft away.
+          if (cur !== '' && targetRow >= 0 && targetRow < layout.rows.length) {
+            const starts = rowStartOffsets(cur, layout.rows.length, insideW);
+            const colInRow = Math.max(0, layout.caretCol - 1);
+            const targetStart = starts[targetRow] != null ? starts[targetRow] : 0;
+            state.caret = Math.min(cur.length, targetStart + colInRow);
+            state.composerSel = null;
+            renderFrame();
+            return;
+          }
+          // First/last row (or an empty composer): this is history's turn.
+          if (state.history.length) {
+            if (state.historyIdx === -1) state.historyIdx = state.history.length;
+            state.historyIdx = t.key === 'up'
+              ? Math.max(0, state.historyIdx - 1)
+              : Math.min(state.history.length, state.historyIdx + 1);
+            state.input = state.historyIdx >= state.history.length ? '' : (state.history[state.historyIdx] || '');
+            state.caret = state.input.length;
+            refreshMenu(state); renderFrame();
+          }
+          return;
         }
       }
     }
@@ -7417,15 +7852,20 @@ export async function startTUI(opts) {
     }
     if (t.key === 'up' || t.key === 'down') {
       const cur = state.input || '';
-      if (cur === '' && state.history.length) {
-        if (state.historyIdx === -1) state.historyIdx = state.history.length;
-        state.historyIdx = t.key === 'up'
-          ? Math.max(0, state.historyIdx - 1)
-          : Math.min(state.history.length, state.historyIdx + 1);
-        state.input = state.historyIdx >= state.history.length ? '' : (state.history[state.historyIdx] || '');
-        state.caret = state.input.length;
-        state.composerSel = null;
-        refreshMenu(state); renderFrame(); return;
+      if (cur === '') {
+        // Empty composer: history owns the key. With NO history the key does
+        // nothing — it must not silently scroll the transcript.
+        if (state.history.length) {
+          if (state.historyIdx === -1) state.historyIdx = state.history.length;
+          state.historyIdx = t.key === 'up'
+            ? Math.max(0, state.historyIdx - 1)
+            : Math.min(state.history.length, state.historyIdx + 1);
+          state.input = state.historyIdx >= state.history.length ? '' : (state.history[state.historyIdx] || '');
+          state.caret = state.input.length;
+          state.composerSel = null;
+          refreshMenu(state); renderFrame();
+        }
+        return;
       }
       const insideW = Math.max(0, dims().cols - 2);
       const layout = composerLayout(state, insideW - 3);
@@ -7439,10 +7879,23 @@ export async function startTUI(opts) {
         state.composerSel = null;
         renderFrame(); return;
       }
-      scrollChat(state, t.key === 'up' ? 3 : -3);
-      renderFrame(); return;
+      // Caret is already on the first/last row: the composer has no further use
+      // for the key, so it becomes HISTORY. (Scrolling the transcript is still
+      // available on PgUp/PgDn and the wheel — the arrows belong to the input.)
+      if (state.history.length) {
+        if (state.historyIdx === -1) state.historyIdx = state.history.length;
+        state.historyIdx = t.key === 'up'
+          ? Math.max(0, state.historyIdx - 1)
+          : Math.min(state.history.length, state.historyIdx + 1);
+        state.input = state.historyIdx >= state.history.length ? '' : (state.history[state.historyIdx] || '');
+        state.caret = state.input.length;
+        state.composerSel = null;
+        refreshMenu(state); renderFrame(); return;
+      }
+      return;
     }
     if (t.key === 'wheelup' || t.key === 'wheeldown') {
+      // With the pointer ON the scrollbar, scroll one line per notch: the bar is
       // With the pointer ON the scrollbar, scroll one line per notch: the bar is
       // the precision control, and 3-line steps there feel jumpy on a long
       // transcript. Everywhere else keeps the usual 3-line step.
@@ -7712,6 +8165,7 @@ export async function startTUI(opts) {
     state.scroll = Math.min(maxScroll, Math.max(0, (state.scroll || 0) + delta));
   }
 
+
   async function submit(forceText) {
     // `forceText` means the text came from somewhere other than the composer
     // (the queue drain). Clearing the composer in that case would throw away
@@ -7740,7 +8194,10 @@ export async function startTUI(opts) {
       state.pulseStart = null;
     }
     
-    if (state.history[state.history.length - 1] !== text) state.history.push(text);
+    if (state.history[state.history.length - 1] !== text) {
+      state.history.push(text);
+      saveHistory(state.history);   // persist so ↑ survives a restart
+    }
     // Shell passthrough. The MODE is authoritative (the `!` never entered the
     // buffer); a leading `!` in the text is still honoured so a pasted line like
     // `!git status` behaves the same as typing it.
@@ -7868,6 +8325,14 @@ export async function startTUI(opts) {
     state.rounds = (state.rounds || 0) + 1;
     state._stepsBase = state.steps || 0;
     state._turnSteps = 0;
+    // Re-base the start animation to THIS instant and paint immediately.
+    // submit() set startAnim before `running` was true, so nothing could render
+    // yet; by the time a frame was actually drawn the 1s animation had already
+    // run out and the type-out was never seen. Stamping it here — the first
+    // moment the row can be painted — makes the animation start on screen.
+    state.startAnim = { start: Date.now() };
+    state.pulseStart = null;
+    renderFrame();
     if (session) session.rounds = state.rounds;
     // system 固定在开头，且不持久化到 session（否则每轮都会堆一条）。
     // 历史里的旧 system 一律跳过，统一使用当前 system prompt：
@@ -7904,21 +8369,10 @@ export async function startTUI(opts) {
     // prompt. Injected LAST and deepest-last so a nested file outranks the root one,
     // which is the precedence order codex documents. Previously /init wrote this
     // file and nothing ever loaded it.
-    const agents = readAgentsMd(state.cwd || state.workspace || cfg.workspace, state.workspace || cfg.workspace);
+const agents = readAgentsMd(state.cwd || state.workspace || cfg.workspace, state.workspace || cfg.workspace);
     if (agents) {
       sysText += '\n\n' + agents;
     }
-    // GIT CONTEXT: the current branch and how many files are uncommitted. Cheap
-    // (two git calls) and it stops the model guessing whether the tree is dirty
-    // or which branch it is on. Skipped silently outside a repository.
-    {
-      const gitCwd = state.cwd || state.workspace || cfg.workspace;
-      let gitsum = '';
-      try { gitsum = gitmod.summary(gitCwd); } catch { gitsum = ''; }
-      if (gitsum) {
-        sysText += '\n\nGIT WORKING TREE (this repository, as of now):\n' + gitsum;
-      }
-    }
     let messages = [{ role: 'system', content: sysText }];
     if (session.messages && session.messages.length) {
       for (const m of session.messages) {
@@ -7935,10 +8389,10 @@ export async function startTUI(opts) {
     // The approved-plan handoff arrives as a SYSTEM message: it is an instruction
     // from the harness, not something the user typed, and it must not show up as a
     // user bubble or be persisted as one.
-    messages.push(asSystem ? { role: 'system', content: text } : { role: 'user', content: text });
-    // 只持久化对话本身，system 不进 session。
+messages.push(asSystem ? { role: 'system', content: text } : { role: 'user', content: text });
+    // 只持久化对话本身，system 不进 session。转折保存交给 turn 结束处
+    // （agent.run 之后），中途不写盘以保持发消息流畅。
     Object.assign(session, { model: cfg.model, messages: messages.filter((m) => m.role !== 'system') });
-    sess.saveSession(session);
 
     if (state.plan) {
       cfg.toolFilter = ['Read', 'Grep', 'Glob'];
@@ -8094,16 +8548,19 @@ export async function startTUI(opts) {
           renderSoon();
           return;
         }
+        if (e.type === 'compacting') {
+          // In-progress notice: the summary below is a full model round-trip, so
+          // show that work is happening instead of leaving the turn silent.
+          addChat({ role: 'system', text: `Context at ${fmtTokens(e.before || 0)} — auto-compacting…` });
+          renderSoon();
+          return;
+        }
         if (e.type === 'compacted') {
           state.ctxTokens = e.after || state.ctxTokens;
           state.ctxPercent = usagePercent(state.ctxTokens, state.ctxMax || 1);
           addChat({ role: 'system', text: `Context auto-compacted (${fmtTokens(e.before || 0)} → ${fmtTokens(e.after || 0)} tokens).` });
           return;
         }
-        if (e.type === 'nudge') {
-          // Silent internal signal - don't show to user
-          return;
-        }
         if (e.type === 'incomplete') {
           // Orange: this is a warning, not ordinary system output.
           addChat({ role: 'warn', text: `Stopped: ${e.reason}. The task may be unfinished — send another message to continue.` });
@@ -8127,8 +8584,16 @@ export async function startTUI(opts) {
         if (e.type === 'aborted') {
           const t = [...state.chat].reverse().find((m) => m.role === 'thinking' && m.pending);
           if (t) t.pending = false;
+          // Settle any RUNNING tool rows too. A tool that was mid-flight when the
+          // user hit Esc never gets its tool_result, so its `pending` stayed true
+          // and the `Using <Tool>` name kept pulsing forever. Clearing it drops the
+          // name to plain cyan immediately.
+          for (const m of state.chat) {
+            if (m.role === 'tool' && m.pending) { m.pending = false; m.failed = true; }
+          }
           // Use a special role that won't show the ✓ icon
           state.chat.push({ role: 'aborted', text: C.red + 'interrupted' + C.reset });
+          renderFrame();
           return;
         }
         if (e.type === 'steer') {
@@ -8299,12 +8764,12 @@ export async function startTUI(opts) {
     if (agent.ctx) {
       agent.ctx._onBackgroundTaskDone = (task) => {
         if (!task) return;
-        const status = task.status || 'completed';
-        const head = status === 'completed'
-          ? `[background agent finished: ${task.taskId}]`
-          : `[background agent ${status}: ${task.taskId}${task.stopReason ? ' - ' + task.stopReason : ''}]`;
+        // kimi-style lifecycle card: bullet colour by phase, a headline naming
+        // the kind (agent / bash / question task) and what happened, and a dim
+        // detail line. The task's conclusion is kept as the expandable body.
+        const card = backgroundTaskCard(task);
         const body = String(task.output || '').trim();
-        addChat({ role: 'system', text: body ? `${head}\n${body}` : head });
+        addChat({ role: 'bg_task', card, text: body });
       };
     }
     await agent.run();
@@ -8494,19 +8959,23 @@ export async function startTUI(opts) {
   // Appending streamed text can also add rows (the message wraps as it grows).
   // While the user is scrolled up, compensate so their view does not shift — the
   // same anchoring rule addChat applies for a whole new message.
-  function anchorScroll() {
-    if ((state.scroll || 0) === 0) return;      // pinned to the bottom: follow
-    const rows = renderChatLines(state, dims().cols).length;
-    const prev = state._anchorRows;
-    // On the first call after the user scrolled up, _anchorRows is unset — just
-    // record the current row count without adjusting scroll. Otherwise a large
-    // gap (prev=0 vs. rows=N) would jump the view to the top of the session.
-    if (prev != null) {
-      if (rows > prev) state.scroll = (state.scroll || 0) + (rows - prev);
-    }
-    state._anchorRows = rows;
+function anchorScroll() {
+    // The arithmetic lives in anchorScrollNext() (module level, unit-tested): it
+    // takes the current chat row count and returns the new `scroll`.
+    //   * the baseline is refreshed even while the view is pinned at the bottom,
+    //     so the first append after the user scrolls up has a real delta;
+    //   * the compensation is the rows added since the previous paint.
+    //
+    // The count comes from state._chatTotal, which composeFrame() refreshes on
+    // every paint. Calling renderChatLines() here (as this used to) laid out the
+    // WHOLE transcript a second time on every streamed chunk — a full ~25k-row
+    // render per chunk on top of the windowed one, which is what made markdown
+    // output appear to stall.
+    const rows = state._chatTotal || 0;
+    state.scroll = anchorScrollNext(state, rows);
   }
 
+
   // Live split of the streamed reply into prose vs. <plan> block.
   // While Plan mode is on and the model is inside <plan>…</plan>, the text is
   // routed into a `plan` bubble so it renders in its frame AS IT ARRIVES — the old
@@ -8630,6 +9099,10 @@ export async function startTUI(opts) {
       failed: !!(m && m.failed),
     };
     if (m && Array.isArray(m.diff)) out.diff = m.diff;
+    // Keep `card`: a background-task lifecycle card carries its phase/headline/
+    // detail here (see the `bg_task` renderer). Dropping it left the row with the
+    // fallback text instead of what actually happened.
+    if (m && m.card) out.card = m.card;
     return out;
   }