open-agents-ai 0.28.0 → 0.30.0

package/dist/index.js

@@ -10413,32 +10413,31 @@ Rules:
        * Build a self-eval prompt for the agent when approaching timeout.
        * Returns the prompt to inject. The agent will respond with a plan.
        */
-      buildTimeoutSelfEvalPrompt(elapsedMs2, toolCallCount, repetitionScore, remainingMs) {
+      buildHealthCheckPrompt(elapsedMs2, toolCallCount, repetitionScore, checkNumber) {
         const elapsedMin = (elapsedMs2 / 6e4).toFixed(1);
-        const remainingMin = (remainingMs / 6e4).toFixed(1);
         const stuckWarning = repetitionScore > 0.5 ? `
 \u26A0 REPETITION DETECTED: Your recent tool calls are ${Math.round(repetitionScore * 100)}% repetitive. You may be stuck in a loop.` : "";
-        return `[TIMEOUT APPROACHING \u2014 Self-Assessment Required]
+        return `[HEALTH CHECK #${checkNumber} \u2014 Progress Assessment]
 
-You have been working for ${elapsedMin} minutes with ${toolCallCount} tool calls. You have approximately ${remainingMin} minutes remaining.${stuckWarning}
+You have been working for ${elapsedMin} minutes with ${toolCallCount} tool calls. There is no time limit \u2014 take as long as you need.${stuckWarning}
 
-ASSESS YOUR SITUATION and choose ONE action:
+Briefly assess your situation and choose ONE action:
 
-1. CONTINUE \u2014 If you are making genuine progress on a long task, say "CONTINUE" and briefly explain what progress you've made and what remains. You will get an extended time window.
+1. CONTINUE \u2014 If you are making progress, briefly note what you've done and what remains. Keep working.
 
-2. PIVOT \u2014 If your current approach isn't working, say "PIVOT" and describe a completely different strategy. Then immediately try that new approach.
+2. PIVOT \u2014 If your current approach isn't working, describe a different strategy and immediately try it.
 
-3. CHECKPOINT \u2014 If you've made partial progress, say "CHECKPOINT" and call task_complete with a summary of what you accomplished so far. The user can continue from where you left off.
+3. CHECKPOINT \u2014 If you've made partial progress and want to save it, call task_complete with a summary. The user can continue later.
 
-Respond with your assessment, then take action. Do NOT just say you'll continue without explaining concrete progress. Be honest about whether you're stuck.`;
+Respond with your assessment, then take action.`;
       }
       /** Run a task through the agentic loop */
       async run(task, context) {
         const start = Date.now();
         const taskTimeoutMs = this.options.taskTimeoutMs;
-        const softDeadline = start + Math.floor(taskTimeoutMs * 0.8);
-        const hardDeadline = start + Math.floor(taskTimeoutMs * 1.5);
-        let softTimeoutTriggered = false;
+        const selfEvalInterval = taskTimeoutMs;
+        let nextSelfEval = start + selfEvalInterval;
+        let selfEvalCount = 0;
         const toolCallLog = [];
         this.aborted = false;
         this.pendingUserMessages.length = 0;
@@ -10467,24 +10466,20 @@ TASK: ${task}` : task }
             break;
           }
           const now = Date.now();
-          if (now > hardDeadline) {
-            this.emit({ type: "error", content: "Task hard timeout reached", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-            break;
-          }
-          if (!softTimeoutTriggered && now > softDeadline) {
-            softTimeoutTriggered = true;
+          if (now > nextSelfEval) {
+            selfEvalCount++;
             const elapsed = now - start;
-            const remaining = hardDeadline - now;
             const repetitionScore = this.detectRepetition(toolCallLog);
             this.emit({
               type: "compaction",
-              content: `Timeout approaching (${(elapsed / 6e4).toFixed(1)}m elapsed) \u2014 injecting self-assessment`,
+              content: `Health check #${selfEvalCount} (${(elapsed / 6e4).toFixed(1)}m elapsed) \u2014 assessing progress`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             messages.push({
               role: "user",
-              content: this.buildTimeoutSelfEvalPrompt(elapsed, toolCallCount, repetitionScore, remaining)
+              content: this.buildHealthCheckPrompt(elapsed, toolCallCount, repetitionScore, selfEvalCount)
             });
+            nextSelfEval = now + selfEvalInterval;
           }
           while (this.pendingUserMessages.length > 0) {
             const userMsg = this.pendingUserMessages.shift();
@@ -10693,7 +10688,7 @@ ${result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : resul
             });
           }
         }
-        while (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles && Date.now() < hardDeadline) {
+        while (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
           bruteForceCycle++;
           const totalTurns = messages.filter((m) => m.role === "assistant").length;
           this.emit({
@@ -10727,24 +10722,20 @@ You have ${this.options.maxTurns} more turns. Continue making progress. Call tas
               break;
             }
             const bfNow = Date.now();
-            if (bfNow > hardDeadline) {
-              this.emit({ type: "error", content: "Task hard timeout reached", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-              break;
-            }
-            if (!softTimeoutTriggered && bfNow > softDeadline) {
-              softTimeoutTriggered = true;
+            if (bfNow > nextSelfEval) {
+              selfEvalCount++;
               const elapsed = bfNow - start;
-              const remaining = hardDeadline - bfNow;
               const repetitionScore = this.detectRepetition(toolCallLog);
               this.emit({
                 type: "compaction",
-                content: `Timeout approaching (${(elapsed / 6e4).toFixed(1)}m elapsed) \u2014 injecting self-assessment`,
+                content: `Health check #${selfEvalCount} (${(elapsed / 6e4).toFixed(1)}m elapsed) \u2014 assessing progress`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
               messages.push({
                 role: "user",
-                content: this.buildTimeoutSelfEvalPrompt(elapsed, toolCallCount, repetitionScore, remaining)
+                content: this.buildHealthCheckPrompt(elapsed, toolCallCount, repetitionScore, selfEvalCount)
               });
+              nextSelfEval = bfNow + selfEvalInterval;
             }
             while (this.pendingUserMessages.length > 0) {
               const userMsg = this.pendingUserMessages.shift();
@@ -11416,8 +11407,7 @@ ${newerSummary}` : newerSummary;
         const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
           method: "POST",
           headers: this.authHeaders(),
-          body: JSON.stringify(body),
-          signal: AbortSignal.timeout(request.timeoutMs)
+          body: JSON.stringify(body)
         });
         if (!resp.ok) {
           const text = await resp.text().catch(() => "");
@@ -11477,8 +11467,7 @@ ${newerSummary}` : newerSummary;
         const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
           method: "POST",
           headers: this.authHeaders(),
-          body: JSON.stringify(body),
-          signal: AbortSignal.timeout(request.timeoutMs)
+          body: JSON.stringify(body)
         });
         if (!resp.ok) {
           const text = await resp.text().catch(() => "");
@@ -18739,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";
@@ -18796,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;
@@ -18817,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);
@@ -18833,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;
@@ -18862,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,
@@ -18909,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
@@ -18950,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();
@@ -18994,15 +19042,43 @@ var init_status_bar = __esm({
           this.metrics.totalTokens = update.totalTokens;
         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();
       }
+      /** Running count of tokens estimated during streaming (reset on authoritative updateMetrics) */
+      _streamingTokens = 0;
+      _streamThrottleTimer = null;
+      /** 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;
+            if (this.active)
+              this.renderFooterPreserveCursor();
+          }, 100);
+        }
+      }
+      /** Get the effective completion tokens (authoritative + live streaming estimate) */
+      get effectiveCompletionTokens() {
+        return this.metrics.completionTokens + this._streamingTokens;
+      }
       /** Reset metrics (e.g. on session start) */
       resetMetrics() {
         this.metrics.promptTokens = 0;
         this.metrics.completionTokens = 0;
         this.metrics.totalTokens = 0;
         this.metrics.estimatedContextTokens = 0;
+        this.pushSpinnerContextMetrics();
         if (this.active)
           this.renderFooterPreserveCursor();
       }
@@ -19030,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 "+ ")
@@ -19043,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();
@@ -19085,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`);
       }
       /**
@@ -19101,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();
         }
       }
@@ -19112,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() {
@@ -19122,7 +19208,8 @@ var init_status_bar = __esm({
         const pipe = pastel2(60, " \u2502 ");
         const tokIn = m.promptTokens > 0 ? m.promptTokens.toLocaleString() : `~${Math.max(m.estimatedContextTokens, 0).toLocaleString()}`;
         const tokInLabel = pastel2(117, "In: ") + c2.bold(tokIn);
-        const tokOut = m.completionTokens > 0 ? m.completionTokens.toLocaleString() : `~${Math.ceil(m.totalTokens > 0 ? m.totalTokens - m.promptTokens : m.estimatedContextTokens * 0.3).toLocaleString()}`;
+        const effectiveOut = this.effectiveCompletionTokens;
+        const tokOut = effectiveOut > 0 ? effectiveOut.toLocaleString() : `~${Math.ceil(m.totalTokens > 0 ? m.totalTokens - m.promptTokens : m.estimatedContextTokens * 0.3).toLocaleString()}`;
         const tokOutLabel = pastel2(151, "Out: ") + c2.bold(tokOut);
         const ctxUsed = m.estimatedContextTokens;
         const ctxTotal = m.contextWindowSize;
@@ -19153,18 +19240,88 @@ 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;
+      }
+      /** 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().
@@ -19174,25 +19331,21 @@ 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 heightChanged = this.updateFooterHeight(w);
+        const pos = this.rowPositions(rows);
+        if (heightChanged) {
+          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);
       }
       /**
@@ -19201,50 +19354,66 @@ 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.updateFooterHeight()) {
+          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 heightChanged = this.updateFooterHeight(w);
+        const pos = this.rowPositions(rows);
+        const inputWrap = this.wrapInput(w);
+        let buf = "\x1B7\x1B[?7l";
+        if (heightChanged) {
+          buf += `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r`;
+          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()}`;
         } 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;
+          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]}`;
+          }
         }
-        process.stdout.write(`\x1B7\x1B[?7l\x1B[${inputRow};1H\x1B[2K${this.promptText}${visibleText}\x1B[?7h\x1B8`);
+        buf += "\x1B[?7h\x1B8";
+        process.stdout.write(buf);
       }
       /**
-       * 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) {
@@ -19254,7 +19423,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() {
@@ -19262,15 +19431,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.
        */
@@ -19505,7 +19674,7 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
     streamEnabled: stream?.enabled ?? false,
     bruteForce: bruteForce ?? true,
     bruteForceMaxCycles: 100,
-    // effectively unlimited — hard timeout is the real bound
+    // effectively unlimited — no hard timeout, agent runs until complete or aborted
     contextWindowSize: contextWindowSize ?? 0
   });
   const tools = buildTools(repoRoot, config);
@@ -19594,6 +19763,10 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
         if (stream?.enabled) {
           stream.renderer.write(event.content ?? "", event.streamKind ?? "content");
         }
+        if (statusBar && event.content) {
+          const estimatedNewTokens = Math.max(1, Math.ceil(event.content.length / 4));
+          statusBar.incrementStreamingTokens(estimatedNewTokens);
+        }
         break;
       case "stream_end":
         if (stream?.enabled) {
@@ -19886,7 +20059,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.28.0",
+  "version": "0.30.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",