open-agents-ai 0.29.0 → 0.30.1

package/dist/index.js

@@ -18728,7 +18728,7 @@ function themeForTool(toolName) {
       return THEME_DEFAULT;
   }
 }
-var DENSITY, WAVE, THEME_DEFAULT, THEME_FILE, THEME_SHELL, THEME_WEB, THEME_SEARCH, THEME_MEMORY, THEME_SKILL, THEME_TOOL_CREATE, BrailleSpinner;
+var DENSITY, WAVE, THEME_DEFAULT, THEME_FILE, THEME_SHELL, THEME_WEB, THEME_SEARCH, THEME_MEMORY, THEME_SKILL, THEME_TOOL_CREATE, DEFAULT_METRICS, BrailleSpinner;
 var init_braille_spinner = __esm({
   "packages/cli/dist/tui/braille-spinner.js"() {
     "use strict";
@@ -18785,11 +18785,17 @@ var init_braille_spinner = __esm({
       ramp: [237, 173, 174, 179, 180, 215, 216, 222, 229],
       speed: 2
     };
+    DEFAULT_METRICS = {
+      contextPct: 0,
+      tokenRate: 0,
+      isStreaming: false
+    };
     BrailleSpinner = class {
       frame = 0;
       timer = null;
       theme = THEME_DEFAULT;
       colorRamp = buildColorRamp(THEME_DEFAULT.ramp);
+      _metrics = { ...DEFAULT_METRICS };
       /** Start the animation, calling `onFrame` every tick (~80 ms). */
       start(onFrame) {
         this.frame = 0;
@@ -18806,14 +18812,15 @@ var init_braille_spinner = __esm({
         }
         this.frame = 0;
         this.setTool(null);
+        this._metrics = { ...DEFAULT_METRICS };
       }
       /** Whether the animation timer is active. */
       get isRunning() {
         return this.timer !== null;
       }
       /**
-       * Set the active tool, changing the animation color theme and speed.
-       * Pass null to return to the default idle theme.
+       * Set the active tool, changing the animation color theme.
+       * Pass null to return to the default idle theme (e.g. on tool_result).
        */
       setTool(toolName) {
         const next = themeForTool(toolName);
@@ -18822,21 +18829,68 @@ var init_braille_spinner = __esm({
           this.colorRamp = buildColorRamp(next.ramp);
         }
       }
+      /**
+       * Update real-time metrics that drive animation dynamics.
+       * Call frequently (e.g. on each metrics update / stream tick).
+       */
+      setMetrics(metrics) {
+        if (metrics.contextPct !== void 0)
+          this._metrics.contextPct = metrics.contextPct;
+        if (metrics.tokenRate !== void 0)
+          this._metrics.tokenRate = metrics.tokenRate;
+        if (metrics.isStreaming !== void 0)
+          this._metrics.isStreaming = metrics.isStreaming;
+      }
       /**
        * Render the current animation frame as an ANSI-colored string.
-       * Each column gets a braille character whose density and color vary
-       * sinusoidally, shifted by `this.frame` to create movement.
-       * The column multiplier (speed) and colors come from the active tool theme.
+       *
+       * State-driven dynamics:
+       * - Speed: base from tool theme, boosted by token rate when streaming,
+       *   modulated by a slow breathing oscillation when idle.
+       * - Amplitude: context pressure scales how much of the density range is
+       *   used — gentle ripples at low usage, full waves at high usage.
+       * - Slinky: a secondary slow sine wave creates organic compression and
+       *   expansion across columns, making the wave feel elastic and alive.
        */
       render(width) {
         const cycleLen = WAVE.length;
-        const speed = this.theme.speed;
+        const baseSpeed = this.theme.speed;
+        const m = this._metrics;
+        const breathPhase = Math.sin(this.frame * 0.08);
+        let speed;
+        if (m.isStreaming && m.tokenRate > 0) {
+          const rateBoost = Math.min(4, m.tokenRate / 8);
+          speed = baseSpeed + rateBoost + breathPhase * 0.3;
+        } else {
+          speed = baseSpeed + breathPhase * 0.8;
+        }
+        const pressure = Math.max(0, Math.min(100, m.contextPct)) / 100;
+        const densityScale = 0.3 + pressure * 0.7;
+        const slinkyFreq = 0.02 + (m.isStreaming ? 0.01 : 0);
+        const slinkyAmp = 1.5 + pressure * 2;
         let buf = "";
         let lastColor = -1;
         for (let col = 0; col < width; col++) {
-          const idx = (col * speed + this.frame) % cycleLen;
-          const ch = WAVE[idx];
-          const color = this.colorRamp[idx];
+          const slinkyOffset = Math.sin(col * 0.1 + this.frame * slinkyFreq) * slinkyAmp;
+          const rawPhase = col * speed + this.frame + slinkyOffset;
+          const normalizedPhase = (rawPhase % cycleLen + cycleLen) % cycleLen;
+          const waveIdx = Math.round(normalizedPhase) % cycleLen;
+          let amplitude;
+          if (waveIdx <= 8) {
+            amplitude = waveIdx;
+          } else {
+            amplitude = 16 - waveIdx;
+          }
+          const scaledAmplitude = Math.round(amplitude * densityScale);
+          let scaledIdx;
+          if (waveIdx <= 8) {
+            scaledIdx = scaledAmplitude;
+          } else {
+            scaledIdx = 16 - scaledAmplitude;
+          }
+          scaledIdx = Math.max(0, Math.min(cycleLen - 1, scaledIdx));
+          const ch = WAVE[scaledIdx];
+          const color = this.colorRamp[scaledIdx];
           if (color !== lastColor) {
             buf += `\x1B[38;5;${color}m`;
             lastColor = color;
@@ -18851,13 +18905,12 @@ var init_braille_spinner = __esm({
 });
 
 // packages/cli/dist/tui/status-bar.js
-var FOOTER_ROWS, StatusBar;
+var StatusBar;
 var init_status_bar = __esm({
   "packages/cli/dist/tui/status-bar.js"() {
     "use strict";
     init_render();
     init_braille_spinner();
-    FOOTER_ROWS = 5;
     StatusBar = class {
       metrics = {
         promptTokens: 0,
@@ -18898,6 +18951,10 @@ var init_status_bar = __esm({
       /** Whether agent is actively processing (braille animation) */
       _processing = false;
       _brailleSpinner = new BrailleSpinner();
+      /** Current dynamic footer height (min 5: buffer + topSep + 1 input line + bottomSep + metrics) */
+      _currentFooterHeight = 5;
+      /** Timestamp when streaming started (for token rate calculation) */
+      _streamStartTime = 0;
       /**
        * Provide a callback that returns readline's current input state.
        * StatusBar uses this to render typed text and position the cursor
@@ -18939,11 +18996,13 @@ var init_status_bar = __esm({
           return;
         this._processing = active;
         if (active) {
+          this._brailleSpinner.setMetrics({ isStreaming: true });
           this._brailleSpinner.start(() => {
             if (this.active)
               this.renderBufferLine();
           });
         } else {
+          this._brailleSpinner.setMetrics({ isStreaming: false, tokenRate: 0 });
           this._brailleSpinner.stop();
           if (this.active)
             this.renderBufferLine();
@@ -18984,6 +19043,9 @@ var init_status_bar = __esm({
         if (update.estimatedContextTokens !== void 0)
           this.metrics.estimatedContextTokens = update.estimatedContextTokens;
         this._streamingTokens = 0;
+        this._streamStartTime = 0;
+        this.pushSpinnerContextMetrics();
+        this._brailleSpinner.setMetrics({ tokenRate: 0, isStreaming: false });
         if (this.active)
           this.renderFooterPreserveCursor();
       }
@@ -18993,6 +19055,11 @@ var init_status_bar = __esm({
       /** Increment the live streaming token counter (throttled re-render at 100ms) */
       incrementStreamingTokens(count) {
         this._streamingTokens += count;
+        if (this._streamStartTime === 0)
+          this._streamStartTime = Date.now();
+        const elapsedSec = (Date.now() - this._streamStartTime) / 1e3;
+        const tokenRate = elapsedSec > 0.1 ? this._streamingTokens / elapsedSec : 0;
+        this._brailleSpinner.setMetrics({ tokenRate, isStreaming: true });
         if (!this._streamThrottleTimer && this.active) {
           this._streamThrottleTimer = setTimeout(() => {
             this._streamThrottleTimer = null;
@@ -19011,6 +19078,7 @@ var init_status_bar = __esm({
         this.metrics.completionTokens = 0;
         this.metrics.totalTokens = 0;
         this.metrics.estimatedContextTokens = 0;
+        this.pushSpinnerContextMetrics();
         if (this.active)
           this.renderFooterPreserveCursor();
       }
@@ -19038,7 +19106,7 @@ var init_status_bar = __esm({
       }
       /**
        * Set the prompt text that StatusBar draws on the input row.
-       * Called by the REPL whenever the prompt changes (idle ↔ active).
+       * Called by the REPL whenever the prompt changes (idle <-> active).
        * The prompt is rendered as part of the atomic footer write so cursor
        * positioning never depends on readline's internal tracking.
        * @param text  The ANSI-colored prompt string (e.g. "> " or "+ ")
@@ -19051,21 +19119,29 @@ var init_status_bar = __esm({
           this.renderFooterAndPositionInput();
         }
       }
-      /** Number of rows reserved at the bottom */
+      /** Number of rows reserved at the bottom (dynamic based on input wrapping) */
       get reservedRows() {
-        return FOOTER_ROWS;
+        return this._currentFooterHeight;
       }
       /** Handle terminal resize — reapply scroll region and redraw footer */
       handleResize() {
         if (!this.active)
           return;
+        this.updateFooterHeight();
+        const rows = process.stdout.rows ?? 24;
+        const pos = this.rowPositions(rows);
+        const w = getTermWidth();
+        const sep = c2.dim("\u2500".repeat(w));
         if (this.writeDepth > 0) {
-          const rows = process.stdout.rows ?? 24;
-          const scrollEnd = Math.max(rows - FOOTER_ROWS, this.scrollRegionTop + 1);
-          const w = getTermWidth();
-          const sep = c2.dim("\u2500".repeat(w));
-          const inputRow = rows - 2;
-          process.stdout.write(`\x1B[${this.scrollRegionTop};${scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${rows - 4};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${rows - 3};1H\x1B[2K${sep}\x1B[${inputRow};1H\x1B[2K${this.promptText}\x1B[${rows - 1};1H\x1B[2K${sep}\x1B[${rows};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[${scrollEnd};1H`);
+          const inputWrap = this.wrapInput(w);
+          let buf = `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
+          for (let i = 0; i < inputWrap.lines.length; i++) {
+            const row = pos.inputStartRow + i;
+            const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
+            buf += `\x1B[${row};1H\x1B[2K${prefix}${inputWrap.lines[i]}`;
+          }
+          buf += `\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[${pos.scrollEnd};1H`;
+          process.stdout.write(buf);
         } else {
           this.applyScrollRegion();
           this.renderFooterAndPositionInput();
@@ -19093,8 +19169,9 @@ var init_status_bar = __esm({
         if (!this.active)
           return;
         this.writeDepth++;
+        this._brailleSpinner.setMetrics({ isStreaming: true });
         const rows = process.stdout.rows ?? 24;
-        const scrollEnd = Math.max(rows - FOOTER_ROWS, this.scrollRegionTop + 1);
+        const scrollEnd = Math.max(rows - this._currentFooterHeight, this.scrollRegionTop + 1);
         process.stdout.write(`\x1B[?25l\x1B[${this.scrollRegionTop};${scrollEnd}r\x1B[${scrollEnd};1H`);
       }
       /**
@@ -19109,6 +19186,7 @@ var init_status_bar = __esm({
           return;
         this.writeDepth = Math.max(0, this.writeDepth - 1);
         if (this.writeDepth === 0) {
+          this._brailleSpinner.setMetrics({ isStreaming: false });
           this.renderFooterAndPositionInput();
         }
       }
@@ -19120,8 +19198,8 @@ var init_status_bar = __esm({
         if (!this.active)
           return;
         const rows = process.stdout.rows ?? 24;
-        const inputRow = rows - 2;
-        process.stdout.write(`\x1B[${inputRow};1H\x1B[2K`);
+        const pos = this.rowPositions(rows);
+        process.stdout.write(`\x1B[${pos.inputStartRow};1H\x1B[2K`);
       }
       /** Build the metrics line string */
       buildMetricsLine() {
@@ -19162,18 +19240,93 @@ var init_status_bar = __esm({
       // -------------------------------------------------------------------------
       // Private
       // -------------------------------------------------------------------------
-      /** Set the DECSTBM scroll region to exclude the footer rows */
+      /** Push current context window usage to the braille spinner */
+      pushSpinnerContextMetrics() {
+        const ctxUsed = this.metrics.estimatedContextTokens;
+        const ctxTotal = this.metrics.contextWindowSize;
+        const contextPct = ctxTotal > 0 ? Math.round(ctxUsed / ctxTotal * 100) : 0;
+        this._brailleSpinner.setMetrics({ contextPct });
+      }
+      /** Compute how many visual lines the current input text occupies */
+      computeInputLineCount(termWidth) {
+        if (!this.inputStateProvider)
+          return 1;
+        const w = termWidth ?? getTermWidth();
+        const availWidth = Math.max(1, w - this.promptWidth);
+        const { line } = this.inputStateProvider();
+        if (line.length <= availWidth)
+          return 1;
+        return Math.ceil(line.length / availWidth);
+      }
+      /** Update _currentFooterHeight based on current input. Returns true if height changed. */
+      updateFooterHeight(termWidth) {
+        const inputLines = this.computeInputLineCount(termWidth);
+        const newHeight = 4 + inputLines;
+        if (newHeight !== this._currentFooterHeight) {
+          this._currentFooterHeight = newHeight;
+          return true;
+        }
+        return false;
+      }
+      /** Check if footer height would change, WITHOUT actually updating it */
+      footerHeightChanged(termWidth) {
+        const inputLines = this.computeInputLineCount(termWidth);
+        return 4 + inputLines !== this._currentFooterHeight;
+      }
+      /** Compute absolute row positions for all footer elements */
+      rowPositions(rows) {
+        const fh = this._currentFooterHeight;
+        return {
+          scrollEnd: Math.max(rows - fh, this.scrollRegionTop + 1),
+          bufferRow: rows - fh + 1,
+          topSepRow: rows - fh + 2,
+          inputStartRow: rows - fh + 3,
+          bottomSepRow: rows - 1,
+          metricsRow: rows
+        };
+      }
+      /**
+       * Wrap input text into lines of availWidth characters.
+       * Returns the lines, plus cursor position within the wrapped layout.
+       */
+      wrapInput(termWidth) {
+        const availWidth = Math.max(1, termWidth - this.promptWidth);
+        const inputState = this.inputStateProvider?.();
+        const fullLine = inputState?.line ?? "";
+        const cursorPos = inputState?.cursor ?? 0;
+        if (fullLine.length <= availWidth) {
+          return {
+            lines: [fullLine],
+            cursorRow: 0,
+            cursorCol: this.promptWidth + cursorPos + 1
+          };
+        }
+        const lines = [];
+        for (let i = 0; i < fullLine.length; i += availWidth) {
+          lines.push(fullLine.slice(i, i + availWidth));
+        }
+        if (lines.length === 0)
+          lines.push("");
+        const cursorLineIdx = Math.min(Math.floor(cursorPos / availWidth), lines.length - 1);
+        const cursorColInLine = cursorPos - cursorLineIdx * availWidth;
+        return {
+          lines,
+          cursorRow: cursorLineIdx,
+          cursorCol: this.promptWidth + cursorColInLine + 1
+        };
+      }
+      /** Set the DECSTBM scroll region to exclude the dynamic footer rows */
       applyScrollRegion() {
+        this.updateFooterHeight();
         const rows = process.stdout.rows ?? 24;
-        const scrollEnd = Math.max(rows - FOOTER_ROWS, this.scrollRegionTop + 1);
-        process.stdout.write(`\x1B[${this.scrollRegionTop};${scrollEnd}r\x1B[${scrollEnd};1H`);
+        const pos = this.rowPositions(rows);
+        process.stdout.write(`\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[${pos.scrollEnd};1H`);
       }
       /**
        * Draw the COMPLETE footer — separators, prompt, metrics — in a single
-       * atomic process.stdout.write() call.  The prompt is drawn on the input
-       * row as part of this write so that cursor positioning never depends on
-       * readline's internal `_refreshLine()` (which uses relative cursor
-       * movements that conflict with our absolute ANSI positioning).
+       * atomic process.stdout.write() call.  Input text wraps across multiple
+       * rows when it exceeds the available width, and the footer dynamically
+       * grows/shrinks to accommodate.
        *
        * Does NOT set DECSTBM — the scroll region is maintained by
        * applyScrollRegion() and beginContentWrite().
@@ -19183,25 +19336,38 @@ var init_status_bar = __esm({
           return;
         const rows = process.stdout.rows ?? 24;
         const w = getTermWidth();
-        const sep = c2.dim("\u2500".repeat(w));
-        const inputRow = rows - 2;
-        const inputState = this.inputStateProvider?.();
-        const fullLine = inputState?.line ?? "";
-        const cursorPos = inputState?.cursor ?? 0;
-        const availWidth = Math.max(1, w - this.promptWidth);
-        let visibleText;
-        let cursorCol;
-        if (fullLine.length <= availWidth) {
-          visibleText = fullLine;
-          cursorCol = this.promptWidth + cursorPos + 1;
-        } else {
-          const lookAhead = Math.min(8, Math.floor(availWidth / 4));
-          let scrollOffset = cursorPos - (availWidth - lookAhead);
-          scrollOffset = Math.max(0, Math.min(scrollOffset, fullLine.length - availWidth));
-          visibleText = fullLine.slice(scrollOffset, scrollOffset + availWidth);
-          cursorCol = this.promptWidth + (cursorPos - scrollOffset) + 1;
+        const oldFooterHeight = this._currentFooterHeight;
+        const heightChanged = this.updateFooterHeight(w);
+        const pos = this.rowPositions(rows);
+        if (heightChanged) {
+          const heightDelta = this._currentFooterHeight - oldFooterHeight;
+          if (heightDelta > 0) {
+            const oldScrollEnd = Math.max(rows - oldFooterHeight, this.scrollRegionTop + 1);
+            let scrollUp = `\x1B[${oldScrollEnd};1H`;
+            for (let i = 0; i < heightDelta; i++)
+              scrollUp += "\n";
+            process.stdout.write(scrollUp);
+          } else {
+            const oldScrollEnd = Math.max(rows - oldFooterHeight, this.scrollRegionTop + 1);
+            let clear = "";
+            for (let row = oldScrollEnd + 1; row <= pos.scrollEnd; row++) {
+              clear += `\x1B[${row};1H\x1B[2K`;
+            }
+            if (clear)
+              process.stdout.write(clear);
+          }
+          process.stdout.write(`\x1B[${this.scrollRegionTop};${pos.scrollEnd}r`);
         }
-        const buf = `\x1B[?7l\x1B[${rows - 4};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${rows - 3};1H\x1B[2K${sep}\x1B[${inputRow};1H\x1B[2K${this.promptText}${visibleText}\x1B[${rows - 1};1H\x1B[2K${sep}\x1B[${rows};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[?25h\x1B[${inputRow};${cursorCol}H`;
+        const sep = c2.dim("\u2500".repeat(w));
+        const inputWrap = this.wrapInput(w);
+        let buf = `\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
+        for (let i = 0; i < inputWrap.lines.length; i++) {
+          const row = pos.inputStartRow + i;
+          const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
+          buf += `\x1B[${row};1H\x1B[2K${prefix}${inputWrap.lines[i]}`;
+        }
+        const cursorTermRow = pos.inputStartRow + inputWrap.cursorRow;
+        buf += `\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[?25h\x1B[${cursorTermRow};${inputWrap.cursorCol}H`;
         process.stdout.write(buf);
       }
       /**
@@ -19210,50 +19376,87 @@ var init_status_bar = __esm({
        * move the cursor away from where readline left it.
        * Uses DEC DECSC/DECRC (\x1B7/\x1B8) for save/restore in a single write.
        *
+       * If the footer height has changed (due to input wrapping), falls back
+       * to a full renderFooterAndPositionInput() instead.
+       *
        * IMPORTANT: Does NOT set DECSTBM here — setting the scroll region between
        * cursor save/restore corrupts the restore position on many terminals.
-       * The scroll region is enforced by beginContentWrite() and renderFooterAndPositionInput().
        */
       renderFooterPreserveCursor() {
         if (!this.active)
           return;
+        if (this.footerHeightChanged()) {
+          if (this.writeDepth === 0) {
+            this.renderFooterAndPositionInput();
+          }
+          return;
+        }
         const rows = process.stdout.rows ?? 24;
         const w = getTermWidth();
+        const pos = this.rowPositions(rows);
         const sep = c2.dim("\u2500".repeat(w));
-        const buf = `\x1B7\x1B[?7l\x1B[${rows - 4};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${rows - 3};1H\x1B[2K${sep}\x1B[${rows - 1};1H\x1B[2K${sep}\x1B[${rows};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B8`;
+        const buf = `\x1B7\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B8`;
         process.stdout.write(buf);
       }
       /**
-       * Render ONLY the input row during an active content write (streaming).
+       * Render the input rows during an active content write (streaming).
        * Uses DEC save/restore cursor so the streaming cursor position is preserved.
-       * Briefly shows the cursor on the input row so the user can see their typing.
+       * If footer height changed, also updates DECSTBM and redraws full footer.
        */
       renderInputRowDuringStream() {
         if (!this.active || !this.inputStateProvider)
           return;
         const rows = process.stdout.rows ?? 24;
         const w = getTermWidth();
-        const inputRow = rows - 2;
-        const inputState = this.inputStateProvider();
-        const fullLine = inputState.line;
-        const cursorPos = inputState.cursor;
-        const availWidth = Math.max(1, w - this.promptWidth);
-        let visibleText;
-        let cursorCol;
-        if (fullLine.length <= availWidth) {
-          visibleText = fullLine;
-          cursorCol = this.promptWidth + cursorPos + 1;
+        const oldFooterHeight = this._currentFooterHeight;
+        const heightChanged = this.updateFooterHeight(w);
+        const pos = this.rowPositions(rows);
+        const inputWrap = this.wrapInput(w);
+        if (heightChanged) {
+          const heightDelta = this._currentFooterHeight - oldFooterHeight;
+          let buf = "\x1B7";
+          if (heightDelta > 0) {
+            const oldScrollEnd = Math.max(rows - oldFooterHeight, this.scrollRegionTop + 1);
+            buf += `\x1B[${oldScrollEnd};1H`;
+            for (let i = 0; i < heightDelta; i++)
+              buf += "\n";
+          } else {
+            const oldScrollEnd = Math.max(rows - oldFooterHeight, this.scrollRegionTop + 1);
+            for (let row = oldScrollEnd + 1; row <= pos.scrollEnd; row++) {
+              buf += `\x1B[${row};1H\x1B[2K`;
+            }
+          }
+          buf += `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r`;
+          buf += "\x1B[?7l";
+          const sep = c2.dim("\u2500".repeat(w));
+          buf += `\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}`;
+          buf += `\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
+          for (let i = 0; i < inputWrap.lines.length; i++) {
+            const row = pos.inputStartRow + i;
+            const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
+            buf += `\x1B[${row};1H\x1B[2K${prefix}${inputWrap.lines[i]}`;
+          }
+          buf += `\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}`;
+          buf += `\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}`;
+          buf += "\x1B[?7h";
+          buf += "\x1B8";
+          if (heightDelta > 0) {
+            buf += `\x1B[${heightDelta}A`;
+          }
+          process.stdout.write(buf);
         } else {
-          const lookAhead = Math.min(8, Math.floor(availWidth / 4));
-          let scrollOffset = cursorPos - (availWidth - lookAhead);
-          scrollOffset = Math.max(0, Math.min(scrollOffset, fullLine.length - availWidth));
-          visibleText = fullLine.slice(scrollOffset, scrollOffset + availWidth);
-          cursorCol = this.promptWidth + (cursorPos - scrollOffset) + 1;
+          let buf = "\x1B7\x1B[?7l";
+          for (let i = 0; i < inputWrap.lines.length; i++) {
+            const row = pos.inputStartRow + i;
+            const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
+            buf += `\x1B[${row};1H\x1B[2K${prefix}${inputWrap.lines[i]}`;
+          }
+          buf += "\x1B[?7h\x1B8";
+          process.stdout.write(buf);
         }
-        process.stdout.write(`\x1B7\x1B[?7l\x1B[${inputRow};1H\x1B[2K${this.promptText}${visibleText}\x1B[?7h\x1B8`);
       }
       /**
-       * Build the content for the buffer line (rows − 4).
+       * Build the content for the buffer line.
        * Returns braille animation when processing, empty string when idle.
        */
       buildBufferContent(width) {
@@ -19263,7 +19466,7 @@ var init_status_bar = __esm({
         return "";
       }
       /**
-       * Render ONLY the buffer line (rows − 4) using DEC save/restore cursor.
+       * Render ONLY the buffer line using DEC save/restore cursor.
        * Called by the braille spinner timer without disrupting scroll or input.
        */
       renderBufferLine() {
@@ -19271,15 +19474,15 @@ var init_status_bar = __esm({
           return;
         const rows = process.stdout.rows ?? 24;
         const w = getTermWidth();
-        const bufferRow = rows - 4;
+        const pos = this.rowPositions(rows);
         const content = this.buildBufferContent(w);
-        process.stdout.write(`\x1B7\x1B[?7l\x1B[${bufferRow};1H\x1B[2K${content}\x1B[?7h\x1B8`);
+        process.stdout.write(`\x1B7\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${content}\x1B[?7h\x1B8`);
       }
       /**
        * Hook into process.stdin to redraw footer after every keystroke.
        * Since readline's output is suppressed (redirected to a no-op stream),
        * this hook is responsible for rendering typed text on the input row.
-       * During streaming (writeDepth > 0), only the input row is updated using
+       * During streaming (writeDepth > 0), only the input rows are updated using
        * cursor save/restore so the streaming position isn't disrupted.
        * When idle (writeDepth === 0), the full footer is redrawn.
        */
@@ -19899,7 +20102,7 @@ async function startInteractive(config, repoPath) {
   let sessionToolCallCount = 0;
   let sessionSudoPassword = null;
   let sudoPromptPending = false;
-  const idlePrompt = `${c2.bold(c2.white("\u{1F896} "))}`;
+  const idlePrompt = `${c2.bold(c2.white("\u276F "))}`;
   const activePrompt = `${c2.bold(c2.white("+ "))}`;
   const rl = readline2.createInterface({
     input: process.stdin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",