ucode-agent 1.53.0 → 1.56.0

package/src/ui/plain.js

@@ -186,14 +186,20 @@ export class Plain {
     for (const line of lines) this.output.write(`    ${dim(line)}\n`);
   }
 
-  assistant(text, { closing = false } = {}) {
-    const body = closing ? trimAnswer(tidyReply(text)) : tidyReply(text);
+  assistant(text, { closing = false, replay = false } = {}) {
+    const body = replay ? String(text) : (closing ? trimAnswer(tidyReply(text)) : tidyReply(text));
     const out = render(this.md, body);
     if (!out) return;
     this.stopSpinner();
     this.output.write(`\n${out}\n\n`);
   }
 
+  userMessage(text) {
+    this.stopSpinner();
+    const first = String(text ?? '').split('\n')[0] ?? '';
+    if (first.trim()) this.output.write(`\n${blue('›')} ${first}\n`);
+  }
+
   narrate(text) {
     const line = asLabel(text);
     if (!line) return;

package/src/ui/screen.js

@@ -99,6 +99,34 @@ const NEWLINE = String.fromCharCode(10);
 const at = (row, col) => `${ESC}[${row};${col}H`;
 const title = (t) => `${ESC}]0;${t}\x07`;
 
+/**
+ * Every paint is wrapped in these. Autowrap off means a row that is one cell
+ * wider than we counted loses its last cell instead of wrapping onto the next
+ * row and scrolling the whole frame up — that scroll was the glitch. The
+ * synchronized-update pair makes terminals that support it show the frame in
+ * one go; the rest ignore it.
+ */
+const PAINT_BEGIN = `${ESC}[?2026h${ESC}[?7l`;
+const PAINT_END = `${ESC}[?7h${ESC}[?2026l`;
+
+/**
+ * Text as it may be drawn: colour codes kept, everything that moves the cursor
+ * gone. A carriage return from a CRLF file sent the padding back over the
+ * line, a tab took eight cells while it was counted as one, and a clear-screen
+ * from a tool's output wiped the frame mid-paint.
+ *
+ * The SGR colour codes (\x1b[..m) are matched first and kept. An earlier
+ * version only excluded them from the CSI branch, so the bare-\x1b fallback
+ * stripped the ESC off every colour code and left "[36m" littered across
+ * coloured lines — visible only in a real terminal, never in tests, which is
+ * why the glitch survived the suite.
+ */
+function printable(text) {
+  return String(text)
+    .replace(/\t/g, '    ')
+    .replace(/\x1b\[[0-9;]*m|(\x1b(?:\[[0-?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|[()#][0-9A-Za-z]|[\x30-\x7e])?|[\x00-\x09\x0b-\x1a\x1c-\x1f\x7f])/g, (m, bad) => (bad ? '' : m));
+}
+
 /**
  * Fixed rows below the header: the gap under it, the gap above the input box,
  * the input box's two borders, the blank row inside it, and the status row.
@@ -181,6 +209,7 @@ export class Screen {
     this.onModeChange = null;
     this.spinTimer = null;
     this.paintedBusy = false;  // whose turn the frame on screen was drawn for
+    this.paintedLines = null; // transcript length at the last paint; growth since then belongs underneath a scrolled-back view
     this.activity = null; // the turn in flight: when it began, how many steps
     this.tick = 0;        // animation frames painted, for the spinner
     this.intro = 0;       // when the launch sweep began, 0 once it is over
@@ -292,11 +321,10 @@ export class Screen {
    */
   add(text = '') {
     const width = this.width();
-    for (const raw of String(text).split('\n')) {
+    for (const raw of printable(text).split('\n')) {
       if (visLen(raw) <= width) this.lines.push(raw);
       else for (const wrapped of wrapAnsi(raw, width)) this.lines.push(wrapped);
     }
-    this.scroll = 0; // new output snaps back to the bottom
   }
 
   push(text = '') {
@@ -329,6 +357,7 @@ export class Screen {
   clearScreen() {
     this.lines = [];
     this.scroll = 0;
+    this.paintedLines = null;
     this.render();
   }
 
@@ -339,10 +368,14 @@ export class Screen {
    * the last thing left on screen, and what the whole session reads like
    * afterwards, so it is cut to eight lines — see trimAnswer.
    */
-  assistant(text, { closing = false } = {}) {
+  assistant(text, { closing = false, replay = false, silent = false } = {}) {
     if (!text?.trim()) return;
+    // A replayed answer goes back exactly as it was first shown: no tidying,
+    // no trimming, no re-read of the request. Tidy-up exists to keep a live
+    // answer short; on a resumed one it rewrites history, which is why a
+    // resumed session read like only fragments had survived.
     const tidy = tidyReply(text, 4, this.lastPrompt);
-    const body = closing ? trimAnswer(tidy) : tidy;
+    const body = replay ? String(text) : (closing ? trimAnswer(tidy) : tidy);
     if (!body.trim()) return;
     this.endRun();
     this.add('');
@@ -355,7 +388,7 @@ export class Screen {
     this.add(render(this.md, body));
 
     this.add('');
-    this.render();
+    if (!silent) this.render();
   }
 
   /**
@@ -368,10 +401,11 @@ export class Screen {
    * ladder of rules across the page: two horizontal lines per message, each as
    * loud as the input box, none of them saying anything the rail does not.
    */
-  userMessage(text) {
+  userMessage(text, { silent = false } = {}) {
     // Kept so the reply can be checked against it: an answer that opens by
     // saying the request back is repeating the line directly above it.
     this.lastPrompt = String(text ?? '');
+    this.scroll = 0; // sending something is the one thing that jumps to the bottom
     const room = Math.max(8, this.width() - 2);   // the rail and the space after it
 
     const rows = [];
@@ -385,7 +419,7 @@ export class Screen {
     for (const row of rows) this.add(`${blue(RAIL)} ${chalk.white(row)}`);
     this.add('');
     this.add('');
-    this.render();
+    if (!silent) this.render();
   }
 
   /**
@@ -1019,10 +1053,10 @@ export class Screen {
     const width = this.width();
     const liveAt = this.activityRowAt();
     this.output.write(
-      HIDE +
+      PAINT_BEGIN + HIDE +
       (liveAt ? at(liveAt, 1) + CLEAR_LINE + padVis(this.activityLine(width), width) : '') +
       at(this.rows - 1, 1) + CLEAR_LINE + boxRow(this.statusRow(width), width, this.borderPaint()) +
-      at(row, col) + SHOW
+      at(row, col) + SHOW + PAINT_END
     );
   }
 
@@ -1149,6 +1183,7 @@ export class Screen {
     }
 
     this.pendingPrompt = 'go ahead? [y/N]';
+    this.scroll = 0; // the question has to be on screen to be answered
     this.render();
 
     return this.nextLine().then((answer) => {
@@ -1273,7 +1308,8 @@ export class Screen {
     const before = this.scroll;
     this.scroll = Math.min(Math.max(0, this.scroll + delta), max);
     if (this.scroll === before && delta > 0) this.flash('already at the top');
-    this.render();
+    // One wheel notch arrives as three arrow keys in one chunk; one frame, not three.
+    this.soon();
   }
 
   /**
@@ -1511,6 +1547,20 @@ export class Screen {
     const width = this.width();
     const height = this.viewportHeight();
 
+    // Scrolled back, the view stays on what is being read while output grows
+    // underneath: every line added since the last paint extends the scroll by
+    // the same amount, so the same rows stay on screen. Snapping to the
+    // bottom on every streamed line fought the wheel sixteen times a second.
+    // A streamed reply truncates its tail and rebuilds it on every delta, so
+    // the growth since the last paint is net — but the tail sits below a
+    // scrolled-back viewport, and net growth still moves the scroll by exactly
+    // the amount that keeps the visible rows put.
+    if (this.scroll > 0 && this.paintedLines != null) {
+      const grown = this.lines.length - this.paintedLines;
+      this.scroll = Math.min(Math.max(0, this.scroll + grown), Math.max(0, this.lines.length - height));
+    }
+    this.paintedLines = this.lines.length;
+
     // The live line is the last line of the conversation, not a fixture above
     // the input box. Pinned down there it sat at the bottom of the screen while
     // the message that started it was at the top, with the empty middle of the
@@ -1539,13 +1589,13 @@ export class Screen {
     // The cursor is hidden for the duration of the paint. Without this it is
     // dragged through every line as the frame is written, which shows up as a
     // dot flickering above the input box on every keystroke.
-    const out = [HIDE, HOME];
+    const out = [PAINT_BEGIN, HIDE];
     for (let i = 0; i < this.rows; i++) {
-      out.push(CLEAR_LINE + padVis(frame[i] ?? '', width) + (i === this.rows - 1 ? '' : '\n'));
+      out.push(at(i + 1, 1) + CLEAR_LINE + padVis(frame[i] ?? '', width));
     }
 
     const [row, col] = this.caret();
-    out.push(at(row, col) + SHOW);
+    out.push(at(row, col) + SHOW + PAINT_END);
     this.paintedBusy = this.busy();
     this.output.write(out.join(''));
   }
@@ -1637,12 +1687,12 @@ export class Screen {
       frame[this.rows - 1] = ' '.repeat(Math.max(0, g.cols - visLen(tag) - 2)) + tag;
     }
 
-    const out = [HIDE, HOME];
+    const out = [PAINT_BEGIN, HIDE];
     for (let i = 0; i < this.rows; i++) {
-      out.push(CLEAR_LINE + padVis(frame[i], g.cols) + (i === this.rows - 1 ? '' : '\n'));
+      out.push(at(i + 1, 1) + CLEAR_LINE + padVis(frame[i], g.cols));
     }
     const [row, col] = this.caret();
-    out.push(at(row, col) + SHOW);
+    out.push(at(row, col) + SHOW + PAINT_END);
     this.paintedBusy = this.busy();
     this.output.write(out.join(''));
   }

package/src/ui/theme.js

@@ -174,6 +174,21 @@ export const bare = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
  * and a table of every Unicode width would be a megabyte to get the last
  * fraction of a percent right.
  */
+/**
+ * The emoji among the older symbol blocks — ✅ ❌ ⚡ ⭐ ⌛ and friends. They sit
+ * between box-drawing characters that are one cell, so they are listed one by
+ * one rather than as a range. Counted as one cell, a model's "✅ Done" line
+ * ran a column past the edge, wrapped, and scrolled the whole frame.
+ */
+const WIDE_SYMBOLS = new Set([
+  0x231a, 0x231b, 0x23e9, 0x23ea, 0x23eb, 0x23ec, 0x23f0, 0x23f3, 0x25fd, 0x25fe,
+  0x2614, 0x2615, 0x2648, 0x2649, 0x264a, 0x264b, 0x264c, 0x264d, 0x264e, 0x264f,
+  0x2650, 0x2651, 0x2652, 0x2653, 0x267f, 0x2693, 0x26a1, 0x26aa, 0x26ab, 0x26bd,
+  0x26be, 0x26c4, 0x26c5, 0x26ce, 0x26d4, 0x26ea, 0x26f2, 0x26f3, 0x26f5, 0x26fa,
+  0x26fd, 0x2705, 0x270a, 0x270b, 0x2728, 0x274c, 0x274e, 0x2753, 0x2754, 0x2755,
+  0x2757, 0x2795, 0x2796, 0x2797, 0x27b0, 0x27bf, 0x2b1b, 0x2b1c, 0x2b50, 0x2b55,
+]);
+
 export function charWidth(code) {
   // Zero: combining marks, joiners, variation selectors.
   if ((code >= 0x0300 && code <= 0x036f)
@@ -194,10 +209,15 @@ export function charWidth(code) {
     || (code >= 0xfe30 && code <= 0xfe6f)
     || (code >= 0xff00 && code <= 0xff60)
     || (code >= 0xffe0 && code <= 0xffe6)
+    || (code >= 0x1f000 && code <= 0x1f02f)
+    || code === 0x1f0cf
+    || (code >= 0x1f18e && code <= 0x1f2ff)
     || (code >= 0x1f300 && code <= 0x1f64f)
     || (code >= 0x1f680 && code <= 0x1f6ff)
-    || (code >= 0x1f900 && code <= 0x1f9ff)
-    || (code >= 0x20000 && code <= 0x3fffd)) return 2;
+    || (code >= 0x1f7e0 && code <= 0x1f7eb)
+    || (code >= 0x1f900 && code <= 0x1faff)
+    || (code >= 0x20000 && code <= 0x3fffd)
+    || WIDE_SYMBOLS.has(code)) return 2;
 
   return 1;
 }