@hackerrank/astra-cli 0.1.24 → 0.1.26

package/README.md

@@ -82,6 +82,8 @@ astra -m claude-sonnet-5 -y         # auto-run commands (no prompts)
 
 In-REPL commands: `/help /plan <task> /exit /clear /history /tokens /yolo`.
 
+Keyboard shortcuts: `Shift+Return` (or `Opt+Return`) for multi-line input, `Alt/Opt+Tab` to toggle bench mode, `Opt+Left/Right` to cycle models, `Opt+Up/Down` to cycle reasoning effort, `Esc` to clear input.
+
 ### Autonomous task run
 
 When you pass a task with `-t`/`-f`, astra appends the autonomous rules and runs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackerrank/astra-cli",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Minimal zero-dependency AI coding agent for the HackerRank AI Gateway.",
   "type": "module",
   "bin": {

package/src/model.js

@@ -42,7 +42,7 @@ export class GatewayModel {
    * @param {number} [opts.maxRetries]
    * @param {(info:object)=>void} [opts.onRetry] called before each retry sleep
    */
-  constructor({ model, baseUrl, apiKey, modelKwargs = {}, maxRetries = 5, maxTokens = 8192, requestTimeoutMs = 0, onRetry } = {}) {
+  constructor({ model, baseUrl, apiKey, modelKwargs = {}, maxRetries = 8, maxTokens = 8192, requestTimeoutMs = 0, onRetry } = {}) {
     if (!model) throw new Error("GatewayModel: `model` is required");
     this.model = model;
     this.maxTokens = maxTokens;
@@ -124,14 +124,15 @@ export class GatewayModel {
           // Retry on transient server / rate-limit errors with exponential
           // backoff (honoring Retry-After when the server provides it).
           if ((res.status === 429 || res.status >= 500) && attempt < this.maxRetries) {
-            const wait = retryAfterMs(res.headers) ?? backoffMs(attempt);
+            const serverWait = retryAfterMs(res.headers, text);
+            const wait = serverWait != null ? Math.max(serverWait + 250, 1000) : backoffMs(attempt);
             this.nRetries++;
             this.onRetry({
               attempt: attempt + 1,
               maxRetries: this.maxRetries,
               status: res.status,
               waitMs: wait,
-              reason: `HTTP ${res.status}`,
+              reason: res.status === 429 ? "HTTP 429 (rate limited)" : `HTTP ${res.status}`,
             });
             await sleep(wait);
             continue;
@@ -282,14 +283,180 @@ function hintForStatus(status) {
   }
 }
 
-/** Parse a Retry-After header (seconds or HTTP-date) into milliseconds. */
-function retryAfterMs(headers) {
-  const v = headers?.get?.("retry-after");
-  if (!v) return null;
-  const secs = Number(v);
-  if (Number.isFinite(secs)) return Math.max(0, secs * 1000);
-  const when = Date.parse(v);
-  if (Number.isFinite(when)) return Math.max(0, when - Date.now());
+/**
+ * Parse a duration string, number, or date into milliseconds.
+ * Supports numbers (seconds or timestamps), units (ms, s, m, h, d),
+ * composite durations ("1m 30s"), and HTTP/ISO dates.
+ */
+export function parseDurationMs(val) {
+  if (typeof val === "number" && Number.isFinite(val) && val >= 0) {
+    if (val > 1e11) return Math.max(0, val - Date.now());
+    if (val > 1e9) return Math.max(0, val * 1000 - Date.now());
+    return Math.max(0, Math.round(val * 1000));
+  }
+  if (!val || typeof val !== "string") return null;
+  const s = val.trim();
+
+  const rawNum = Number(s);
+  if (Number.isFinite(rawNum) && rawNum >= 0) {
+    if (rawNum > 1e11) return Math.max(0, rawNum - Date.now());
+    if (rawNum > 1e9) return Math.max(0, rawNum * 1000 - Date.now());
+    return Math.max(0, Math.round(rawNum * 1000));
+  }
+
+  const when = Date.parse(s);
+  if (Number.isFinite(when) && when > Date.now()) {
+    return Math.max(0, when - Date.now());
+  }
+
+  const pattern = /([0-9]+(?:\.[0-9]+)?)\s*(milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b/gi;
+  let match;
+  let totalMs = 0;
+  let matched = false;
+  while ((match = pattern.exec(s)) !== null) {
+    matched = true;
+    const n = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    if (!Number.isFinite(n)) continue;
+    if (unit.startsWith("ms") || unit.startsWith("milli")) {
+      totalMs += n;
+    } else if (unit.startsWith("s")) {
+      totalMs += n * 1000;
+    } else if (unit.startsWith("m")) {
+      totalMs += n * 60 * 1000;
+    } else if (unit.startsWith("h")) {
+      totalMs += n * 3600 * 1000;
+    } else if (unit.startsWith("d")) {
+      totalMs += n * 86400 * 1000;
+    }
+  }
+  return matched ? Math.round(totalMs) : null;
+}
+
+/**
+ * Extract retry duration from unstructured error message text.
+ * Matches phrases like "retry after 12.5s", "try again in 5 seconds", "resets in 30s", "wait 10s".
+ */
+export function extractDurationFromText(text) {
+  if (!text || typeof text !== "string") return null;
+
+  const p1 = /(?:retry(?:ing)?|try\s+again|wait(?:ing)?|resets?|available|back\s*off)\s+(?:again\s+)?(?:after|in|for)\s+([0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b(?:\s+[0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b)*|[0-9]+(?:\.[0-9]+)?)/i;
+  const m1 = text.match(p1);
+  if (m1) {
+    const parsed = parseDurationMs(m1[1]);
+    if (parsed != null) return parsed;
+  }
+
+  const p2 = /(?:wait(?:ing)?)\s+([0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b)/i;
+  const m2 = text.match(p2);
+  if (m2) {
+    const parsed = parseDurationMs(m2[1]);
+    if (parsed != null) return parsed;
+  }
+
+  const p3 = /in\s+([0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b)\s*[,.]?\s*(?:please\s+)?(?:retry|try)/i;
+  const m3 = text.match(p3);
+  if (m3) {
+    const parsed = parseDurationMs(m3[1]);
+    if (parsed != null) return parsed;
+  }
+
+  return null;
+}
+
+/**
+ * Parse retry delay from response headers or error response body into milliseconds.
+ * Checks standard and provider-specific rate-limit headers as well as JSON fields
+ * and error messages returned by AI gateways (HackerRank, OpenAI, Anthropic, LiteLLM, Gemini, etc.).
+ */
+export function retryAfterMs(headers, bodyText) {
+  const msHeader = headers?.get?.("retry-after-ms");
+  if (msHeader) {
+    const ms = Number(msHeader);
+    if (Number.isFinite(ms) && ms >= 0) return Math.round(ms);
+  }
+
+  const headerKeys = [
+    "retry-after",
+    "x-retry-after",
+    "x-ratelimit-reset-requests",
+    "x-ratelimit-reset-tokens",
+    "x-ratelimit-reset",
+  ];
+  for (const k of headerKeys) {
+    const val = headers?.get?.(k);
+    if (val) {
+      const parsed = parseDurationMs(val);
+      if (parsed != null) return parsed;
+    }
+  }
+
+  if (bodyText) {
+    let json = null;
+    if (typeof bodyText === "object") {
+      json = bodyText;
+    } else if (typeof bodyText === "string") {
+      try {
+        json = JSON.parse(bodyText);
+      } catch {}
+    }
+
+    if (json && typeof json === "object") {
+      const msCandidates = [json.retry_after_ms, json.error?.retry_after_ms];
+      for (const c of msCandidates) {
+        if (Number.isFinite(Number(c)) && Number(c) >= 0) {
+          return Math.round(Number(c));
+        }
+      }
+
+      const durationCandidates = [
+        json.retry_after,
+        json.retryAfter,
+        json.retry_after_seconds,
+        json.retry_after_sec,
+        json.reset_in,
+        json.reset_after,
+        json.reset_at,
+        json.wait_seconds,
+        json.wait_time,
+        json.error?.retry_after,
+        json.error?.retryAfter,
+        json.error?.retry_after_seconds,
+        json.error?.retry_after_sec,
+        json.error?.reset_in,
+        json.error?.reset_after,
+        json.error?.reset_at,
+        json.error?.wait_seconds,
+        json.error?.wait_time,
+      ];
+      for (const c of durationCandidates) {
+        if (c != null) {
+          const parsed = parseDurationMs(c);
+          if (parsed != null) return parsed;
+        }
+      }
+
+      const msgCandidates = [
+        json.error?.message,
+        typeof json.error === "string" ? json.error : null,
+        json.message,
+        json.detail,
+        typeof json.details === "string" ? json.details : null,
+      ];
+      for (const msg of msgCandidates) {
+        if (msg) {
+          const extracted = extractDurationFromText(msg);
+          if (extracted != null) return extracted;
+        }
+      }
+    }
+
+    if (typeof bodyText === "string") {
+      const extracted = extractDurationFromText(bodyText);
+      if (extracted != null) return extracted;
+    }
+  }
+
   return null;
 }
 

package/src/repl.js

@@ -159,7 +159,7 @@ function footerLines(agent, model, yolo, mode = "agent") {
     C.dim(rule),
     modeTag + "  " + C.cyan(repoLabel()) + "    " + C.dim(modelBits.join("  ")),
     C.dim(usage),
-    C.dim("opt+left/right: model  ·  opt+up/down: reasoning  ·  shift+tab: mode"),
+    C.dim("shift+return: newline  ·  opt+left/right: model  ·  opt+up/down: reasoning  ·  shift+tab: mode"),
   ];
 }
 
@@ -219,19 +219,73 @@ function setReasoning(model, level) {
   }
 }
 
+/** Strip ANSI color/style escape codes to calculate visual string lengths. */
+export function stripAnsi(str) {
+  return String(str || "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+/**
+ * Break an input buffer (with potential newlines and line wraps) into
+ * visual lines suitable for terminal display.
+ */
+export function computeVisualLines(buf, promptPrefix, cols = 80) {
+  const logicalLines = String(buf || "").split("\n");
+  const visualLines = [];
+  const prefixVisible = stripAnsi(promptPrefix);
+  const contPrefix = "  ";
+  const contPrefixVisible = "  ";
+
+  for (let i = 0; i < logicalLines.length; i++) {
+    const p = i === 0 ? promptPrefix : contPrefix;
+    const pVis = i === 0 ? prefixVisible : contPrefixVisible;
+    const line = logicalLines[i];
+    const full = p + line;
+    const fullVis = pVis + line;
+
+    if (fullVis.length <= cols || cols <= 0) {
+      visualLines.push({ text: full, visibleLength: fullVis.length });
+    } else {
+      let remaining = line;
+      let first = true;
+      while (remaining.length > 0 || first) {
+        const currentP = first ? p : contPrefix;
+        const currentPVis = first ? pVis : contPrefixVisible;
+        const availableWidth = Math.max(1, cols - currentPVis.length);
+        const take = remaining.slice(0, availableWidth);
+        remaining = remaining.slice(availableWidth);
+        visualLines.push({ text: currentP + take, visibleLength: currentPVis.length + take.length });
+        first = false;
+        if (remaining.length === 0) break;
+      }
+    }
+  }
+  return visualLines.length > 0 ? visualLines : [{ text: promptPrefix, visibleLength: prefixVisible.length }];
+}
+
+/** Check if an escape sequence or key code is a newline-insertion shortcut (Shift+Enter, Option+Enter, etc.). */
+export function isNewlineKey(s, pendingEsc = false) {
+  if (s === "\x1b[13;2u" || s === "\x1b[27;2;13~" || s === "\x1b[13;2~" || s === "\x1bOM") return true; // Shift+Enter
+  if (s === "\x1b[13;3u" || s === "\x1b[27;3;13~" || s === "\x1b\r" || s === "\x1b\n") return true; // Alt/Option+Enter
+  if (s === "\x1b[13;5u" || s === "\x1b[27;5;13~") return true; // Ctrl+Enter
+  if (pendingEsc && (s === "\r" || s === "\n")) return true; // Esc then Enter
+  if (s === "\x0a") return true; // Ctrl+J (LF)
+  return false;
+}
+
 /**
  * A bottom-anchored screen: conversation output scrolls in the top region
  * (bounded by a DECSTBM scroll margin) while the footer + input prompt stay
  * glued to the terminal's bottom rows. Input is read via raw keypresses (not
- * readline) so nothing fights the scroll margin. Requires a TTY; callers use
- * the readline fallback otherwise.
+ * readline) so nothing fights the scroll margin. Multi-line input and wrapped
+ * typing adjust the scroll margin dynamically to prevent overwriting status
+ * lines or history. Requires a TTY; callers use the readline fallback otherwise.
  */
-class Screen {
+export class Screen {
   constructor(out = process.stdout, inp = process.stdin) {
     this.out = out;
     this.inp = inp;
     this.footer = [];
-    this.buf = "";       // current input line
+    this.buf = "";       // current input buffer (can contain newlines)
     this.resolve = null;  // pending readLine() resolver
     this._lastWasCR = false;
     this._guardEnterUntil = 0;  // ignore stray Enter until this timestamp
@@ -241,21 +295,37 @@ class Screen {
     this._busyFrame = 0;
     this._busyLabel = "working";
     this._busyResume = false;
+    this._prevScrollBottom = 0;
+    this._prevFooterTop = 0;
+    this._inPaste = false;
     this.promptLabel = PROMPT_PREFIX;
     this._onData = this._onData.bind(this);
     this._onResize = this._onResize.bind(this);
   }
 
-  get rows() { return this.out.rows || 24; }  // Footer block (4 rows) pinned to the bottom: divider, prompt, repo/model, usage.
-  get reserved() { return FOOTER_LINES + 1; } // +1 for the prompt row
-  get scrollBottom() { return Math.max(1, this.rows - this.reserved); } // last scrollable row
-  get footerTop() { return this.scrollBottom + 1; } // divider row
-  get promptRow() { return this.footerTop + 1; }    // input row: right under the divider
+  get cols() { return this.out.columns || 80; }
+  get rows() { return this.out.rows || 24; }
+
+  get promptLines() {
+    if (this._busy) return 1;
+    const visual = computeVisualLines(this.buf, this.promptLabel || PROMPT_PREFIX, this.cols);
+    const maxLines = Math.max(1, Math.floor((this.rows - FOOTER_LINES) / 2));
+    return Math.min(visual.length, maxLines);
+  }
+
+  get reserved() { return FOOTER_LINES + this.promptLines; }
+  get scrollBottom() { return Math.max(1, this.rows - this.reserved); }
+  get footerTop() { return this.scrollBottom + 1; }
+  get promptRow() { return this.footerTop + 1; }
+  get statusStartRow() { return this.promptRow + this.promptLines; }
 
   /** Enter sticky mode: set scroll margin, park cursor, start listening. */
   enter() {
+    this._prevScrollBottom = this.scrollBottom;
+    this._prevFooterTop = this.footerTop;
     this.out.write(`\x1b[1;${this.scrollBottom}r`);     // scroll region = top area
     this.out.write(`\x1b[${this.scrollBottom};1H`);      // cursor at bottom of scroll area
+    this.out.write("\x1b[?2004h"); // enable bracketed paste mode
     if (this.inp.isTTY) this.inp.setRawMode(true);
     this.inp.resume();
     this.inp.setEncoding("utf8");
@@ -268,6 +338,7 @@ class Screen {
     this.inp.off("data", this._onData);
     this.out.off("resize", this._onResize);
     if (this.inp.isTTY) this.inp.setRawMode(false);
+    this.out.write("\x1b[?2004l"); // disable bracketed paste mode
     this.out.write("\x1b[r");                    // reset scroll region
     this.out.write(`\x1b[${this.rows};1H\n`);    // move below footer
   }
@@ -282,40 +353,78 @@ class Screen {
   log(text) {
     this.out.write(`\x1b[${this.scrollBottom};1H`); // park at bottom of scroll area
     this.out.write(String(text) + "\n");            // trailing \n scrolls the region
-    this.drawFooter();
-    this.drawPrompt();
+    this.redraw();
   }
 
   /** Redraw the pinned footer + prompt (e.g. when usage changes). */
   refresh(footer) {
     if (footer) this.footer = footer;
-    this.drawFooter();
-    this.drawPrompt();
+    this.redraw();
   }
 
-  drawFooter() {
+  /** Unified redraw of footer divider, multi-line prompt, and status lines without overwriting. */
+  redraw() {
+    if (this._prevScrollBottom !== this.scrollBottom) {
+      this.out.write(`\x1b[1;${this.scrollBottom}r`);
+      this._prevScrollBottom = this.scrollBottom;
+    }
+
     this.out.write("\x1b[s"); // save cursor
-    // footer[0] = divider (row footerTop), footer[1..] = status lines that go
-    // BELOW the prompt row (footerTop+1). So skip the prompt row when placing
-    // the status lines.
-    this.out.write(`\x1b[${this.footerTop};1H\x1b[2K`);
-    this.out.write(this.footer[0] || "");           // divider
-    for (let i = 1; i < FOOTER_LINES; i++) {
-      const row = this.promptRow + i;               // status lines under the prompt
-      this.out.write(`\x1b[${row};1H\x1b[2K`);
-      this.out.write(this.footer[i] || "");
+
+    // Clear old footer/prompt lines down to terminal bottom
+    const clearFrom = Math.min(this._prevFooterTop || this.footerTop, this.footerTop);
+    for (let r = clearFrom; r <= this.rows; r++) {
+      this.out.write(`\x1b[${r};1H\x1b[2K`);
     }
-    this.out.write("\x1b[u"); // restore cursor
-  }
+    this._prevFooterTop = this.footerTop;
 
-  drawPrompt() {
-    this.out.write(`\x1b[${this.promptRow};1H\x1b[2K`);
+    // Draw top divider rule at footerTop
+    this.out.write(`\x1b[${this.footerTop};1H`);
+    this.out.write(this.footer[0] || "");
+
+    // Draw prompt (or busy spinner)
     if (this._busy) {
+      this.out.write(`\x1b[${this.promptRow};1H`);
       const frame = SPINNER_FRAMES[this._busyFrame % SPINNER_FRAMES.length];
       this.out.write(C.cyan(frame + " ") + C.dim(this._busyLabel + "…"));
-      return;
+    } else {
+      const visual = computeVisualLines(this.buf, this.promptLabel || PROMPT_PREFIX, this.cols);
+      const visibleLines = visual.slice(-this.promptLines);
+      for (let i = 0; i < visibleLines.length; i++) {
+        const row = this.promptRow + i;
+        this.out.write(`\x1b[${row};1H`);
+        this.out.write(visibleLines[i].text);
+      }
     }
-    this.out.write((this.promptLabel || PROMPT_PREFIX) + this.buf);
+
+    // Draw status lines below the prompt
+    for (let i = 1; i < FOOTER_LINES; i++) {
+      const row = this.statusStartRow + i - 1;
+      if (row <= this.rows) {
+        this.out.write(`\x1b[${row};1H`);
+        this.out.write(this.footer[i] || "");
+      }
+    }
+
+    // Place cursor at the end of input
+    if (!this._busy) {
+      const visual = computeVisualLines(this.buf, this.promptLabel || PROMPT_PREFIX, this.cols);
+      const visibleLines = visual.slice(-this.promptLines);
+      const lastLine = visibleLines[visibleLines.length - 1] || { visibleLength: 0 };
+      const cursorRow = this.promptRow + (visibleLines.length - 1);
+      const cursorCol = Math.min(this.cols, lastLine.visibleLength + 1);
+      this.out.write(`\x1b[${cursorRow};${cursorCol}H`);
+    } else {
+      this.out.write("\x1b[u"); // restore cursor
+    }
+  }
+
+  drawFooter() {
+    this.redraw();
+  }
+
+  drawPrompt() {
+    this.redraw();
   }
 
   /** Start the minimal loading state on the prompt row. */
@@ -323,11 +432,11 @@ class Screen {
     this._busy = true;
     this._busyLabel = label;
     this._busyFrame = 0;
-    this.drawPrompt();
+    this.redraw();
     if (this._busyTimer) clearInterval(this._busyTimer);
     this._busyTimer = setInterval(() => {
       this._busyFrame++;
-      this.drawPrompt();
+      this.redraw();
     }, 90);
     if (this._busyTimer.unref) this._busyTimer.unref();
   }
@@ -337,7 +446,7 @@ class Screen {
     if (this._busyTimer) { clearInterval(this._busyTimer); this._busyTimer = null; }
     this._busy = false;
     this._busyResume = false;
-    this.drawPrompt();
+    this.redraw();
   }
 
   /** True while the agent is working (a turn is in progress). */
@@ -349,16 +458,9 @@ class Screen {
    * Resolve with the next full line the user types. An optional prompt label
    * replaces the default "you › " (used by the approval gate so the question
    * is shown right where the user is typing).
-   *
-   * `opts.guardEnter` ignores a bare Enter that lands within a short window of
-   * the prompt appearing. This prevents a stray newline still in the input
-   * buffer (from the previous line, a CRLF pair, or a paste) from instantly
-   * "answering" a confirmation prompt the user never actually saw.
    */
   readLine(promptLabel, opts = {}) {
     return new Promise((res) => {
-      // A prompt (main input or approval) takes over the row; pause the spinner
-      // timer but remember whether we were busy so we can resume after.
       this._busyResume = this._busy;
       if (this._busyTimer) { clearInterval(this._busyTimer); this._busyTimer = null; }
       this._busy = false;
@@ -367,37 +469,50 @@ class Screen {
       this.resolve = res;
       this._guardEnterUntil = opts.guardEnter ? Date.now() + 250 : 0;
       this._echoOnCommit = opts.echo !== false;
-      this.drawPrompt();
+      this.redraw();
     });
   }
 
   _onResize() {
-    this.out.write(`\x1b[1;${this.scrollBottom}r`);
-    this.footer = this.footer; // caller refreshes content separately
-    this.drawFooter();
-    this.drawPrompt();
+    this.redraw();
   }
 
   _onData(chunk) {
     const s = chunk.toString();
-    // Optional key debug: set ASTRA_KEYDEBUG=1 to print the raw bytes of every
-    // keypress into the transcript. Use it to discover what your terminal
-    // actually sends for Option/Alt+Tab, then report it.
     if (process.env.ASTRA_KEYDEBUG && this.log) {
       const bytes = Array.from(chunk).map((b) => "0x" + b.toString(16).padStart(2, "0")).join(" ");
       this.log(`\x1b[35m[keydebug] ${bytes}\x1b[0m`);
     }
-    // --- Key sequences: mode toggle, model/reasoning cycling, Esc-to-clear ---
-    //
-    // Mode toggle: Alt/Option+Tab is delivered as ESC+Tab ("\x1b\t"); Shift+Tab
-    // ("\x1b[Z") is a reliable fallback. Model/reasoning cycling uses Option +
-    // arrow keys. A bare Esc (nothing following it) clears the input line.
-    //
-    // Because some terminals split escape sequences across reads (a lone ESC,
-    // then the rest), we latch a lone ESC briefly. If a Tab follows -> toggle;
-    // if nothing follows within the window -> treat it as bare Esc (clear).
-
-    // Whole-chunk fast paths first.
+
+    // Bracketed paste handling (pasting multi-line blocks into the input)
+    let str = s;
+    if (str.includes("\x1b[200~") || this._inPaste) {
+      if (str.includes("\x1b[200~")) {
+        this._inPaste = true;
+        str = str.slice(str.indexOf("\x1b[200~") + 6);
+      }
+      if (str.includes("\x1b[201~")) {
+        const end = str.indexOf("\x1b[201~");
+        const pasted = str.slice(0, end);
+        this.buf += pasted.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        this._inPaste = false;
+        this.redraw();
+        return;
+      }
+      this.buf += str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      this.redraw();
+      return;
+    }
+
+    // Newline insertion shortcut (Shift+Enter, Option+Enter, Alt+Enter, Ctrl+Enter, Esc+Enter)
+    if (isNewlineKey(s, this._pendingEsc)) {
+      this._clearEscLatch();
+      this.buf += "\n";
+      this.redraw();
+      return;
+    }
+
+    // Mode toggle: Alt/Option+Tab or Shift+Tab
     if (this.onToggleMode && (s === "\x1b\t" || s === "\x1b[Z")) {
       this._clearEscLatch();
       this.onToggleMode();
@@ -415,17 +530,17 @@ class Screen {
           this.onCycleReasoning(opt === "up" ? 1 : -1);
           return;
         }
-        return; // recognized an option-arrow we don't act on; swallow it
+        return;
       }
     }
 
-    // A Tab following a latched ESC -> mode toggle (split Alt+Tab delivery).
+    // A Tab following a latched ESC -> mode toggle
     if (this._pendingEsc && s === "\t" && this.onToggleMode) {
       this._clearEscLatch();
       this.onToggleMode();
       return;
     }
-    // A latched ESC followed by an arrow tail (e.g. "[C", "b", "f") -> option-arrow.
+    // A latched ESC followed by an arrow tail -> option-arrow
     if (this._pendingEsc) {
       const opt = matchOptionArrow("\x1b" + s, true);
       if (opt) {
@@ -440,13 +555,10 @@ class Screen {
         }
         return;
       }
-      // Any other input right after a latched ESC cancels the latch and is
-      // processed normally below.
       this._clearEscLatch();
     }
 
-    // A lone ESC: latch briefly to disambiguate from split escape sequences.
-    // If nothing arrives, the timer treats it as a bare Esc and clears input.
+    // A lone ESC: latch briefly to disambiguate from split escape sequences
     if (s === "\x1b") {
       this._pendingEsc = true;
       clearTimeout(this._escTimer);
@@ -454,19 +566,15 @@ class Screen {
         this._pendingEsc = false;
         if (this.onClearInput) this.onClearInput();
         this.buf = "";
-        this.drawPrompt();
+        this.redraw();
       }, 60);
       return;
     }
 
-    for (const ch of chunk) {
+    for (const ch of s) {
       if (ch === "\r" || ch === "\n") {
-        // Collapse a CRLF pair into one Enter: ignore a \n right after a \r.
         if (ch === "\n" && this._lastWasCR) { this._lastWasCR = false; continue; }
         this._lastWasCR = ch === "\r";
-        // Guard: ignore a bare Enter (empty buffer) that arrives immediately
-        // after a guarded prompt was shown. This stops a leftover newline from
-        // auto-resolving a confirmation the user never got to answer.
         if (
           this.buf === "" &&
           this._guardEnterUntil &&
@@ -474,30 +582,25 @@ class Screen {
         ) {
           continue;
         }
-        const line = this.buf;
+        const text = this.buf;
         this.buf = "";
-        // Echo the committed line into the scroll area for a transcript.
-        // User input is echoed with the "you › " history prefix; approval
-        // prompts pass echo:false so their Q&A stays out of the transcript.
-        // Empty input is skipped so a bare Enter doesn't stack blank lines.
-        if (this._echoOnCommit && line.trim() !== "") {
+        if (this._echoOnCommit && text.trim() !== "") {
           const isUserPrompt = (this.promptLabel || PROMPT_PREFIX) === PROMPT_PREFIX;
-          this.log((isUserPrompt ? HISTORY_PREFIX : this.promptLabel) + line);
+          const prefix = isUserPrompt ? HISTORY_PREFIX : this.promptLabel;
+          const lines = text.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            this.log((i === 0 ? prefix : "      ") + lines[i]);
+          }
         }
         this.promptLabel = PROMPT_PREFIX;
         this._echoOnCommit = true;
-        // Resume the loading state if a turn is still in progress (e.g. after
-        // an approval prompt hands control back to the running agent).
         if (this._busyResume) { this._busyResume = false; this.startBusy(this._busyLabel); }
         const r = this.resolve; this.resolve = null;
-        if (r) r(line);
+        if (r) r(text);
       } else if (ch === "\x7f" || ch === "\b") {  // backspace
         this.buf = this.buf.slice(0, -1);
-        this.drawPrompt();
+        this.redraw();
       } else if (ch === "\x03") {                  // Ctrl+C
-        // If a prompt is pending (idle), resolve it so the loop can react.
-        // Also always notify the interrupt hook so a *running* agent turn can
-        // be aborted even when no readLine is pending.
         const r = this.resolve; this.resolve = null;
         if (r) r("__SIGINT__");
         if (this.onInterrupt) this.onInterrupt();
@@ -507,7 +610,7 @@ class Screen {
       } else if (ch >= " ") {                       // printable
         this._lastWasCR = false;
         this.buf += ch;
-        this.drawPrompt();
+        this.redraw();
       }
     }
   }
@@ -524,6 +627,7 @@ Interactive commands:
   /yolo            toggle auto-run of commands (no confirmation)
 
 Keyboard shortcuts:
+  shift+return     insert a newline for multi-line input (alt/opt+enter also works)
   alt/opt+tab      switch agent / bench mode (shift+tab also works)
   opt+left/right   cycle the model
   opt+up/down      cycle reasoning effort (off/low/medium/high)