rubino-agent 0.5.2.1 → 0.5.2.2

data/lib/rubino/ui/bottom_composer.rb

@@ -1120,9 +1120,10 @@ module Rubino
         end
         rows, caret_row, caret_col = visible_input_rows
         status = status_row
-        # Rows drawn BELOW the input, top→bottom: the subagent panel (one calm
-        # representation of the running children) then the status footer. A fresh
-        # array so appending the status never mutates the panel's own rows.
+        # Rows drawn BELOW the input, top→bottom: the "⏳ queued:" type-ahead
+        # indicators, then the subagent panel (one calm representation of the
+        # running children), then the status footer. A fresh array so appending
+        # the status never mutates the panel's own rows.
         below_rows = below_input_rows
         below_rows += [status] if status
 
@@ -1535,12 +1536,16 @@ module Rubino
       #   [committed lines]   ← only when +committed+ is given; scroll into
       #                         scrollback and stay there
       #   [live rows]         ← cards, completion menu, transient announce,
-      #                         "⏳ queued:" indicators, streamed partial —
-      #                         redrawn in place every frame (do NOT scroll)
+      #                         streamed partial — redrawn in place every
+      #                         frame (do NOT scroll)
       #   [input block]       ← "▍❯ " + buffer (the rail leads every row),
       #                         wrapped over up to @max_input_rows visual
       #                         rows; the cursor parks at the caret's
       #                         row/column
+      #   [queued + panel]    ← "⏳ queued:" type-ahead indicators, then the
+      #                         subagent panel/switcher — drawn BELOW the input
+      #                         so a pending line sits next to the prompt it was
+      #                         typed at, not up in the streamed-output area
       #   [status bar]        ← the dim model + context line (when set/fits)
       #
       # The +buffer+ is redrawn on every frame, so it can never be lost across
@@ -1584,18 +1589,26 @@ module Rubino
       # The live rows for this frame, top → bottom: the subagent cards; the
       # completion menu (a navigable list redrawn in place each frame, so it
       # never scrolls or smears); the TRANSIENT announcement (mode confirmation
-      # — one row, never committed, D2/D3); the EXPLICITLY-queued "⏳ queued:"
-      # indicators (removed, and the item committed as a normal message, when
-      # its turn runs); and the streamed partial (one row per line, capped, so
-      # a rolling markdown tail can't push the prompt off-screen, #127).
+      # — one row, never committed, D2/D3); and the streamed partial (one row
+      # per line, capped, so a rolling markdown tail can't push the prompt
+      # off-screen, #127). The "⏳ queued:" indicators are NOT here — they draw
+      # BELOW the input (see #below_input_rows) so a pending line sits next to
+      # the prompt it was typed at, not up in the streamed-output area.
       def live_rows
         rows = menu_rows
         rows << @announce unless @announce.empty?
-        rows.concat(@queued.rows)
         rows.concat(partial_rows)
         rows
       end
 
+      # Rows drawn BELOW the input line, top → bottom: the "⏳ queued:" type-ahead
+      # indicators (the user's pending lines — kept next to the input they were
+      # typed at), then the subagent panel / switcher. The status footer is
+      # appended by the caller (#draw_input).
+      def below_input_rows
+        @queued.rows + subagent_panel_rows
+      end
+
       # The single subagent panel, drawn BELOW the input (see Composer::SubagentPanel).
       #
       # While ATTACHED to a sub (#main_render_suppressed?) the parent's idle
@@ -1610,7 +1623,7 @@ module Rubino
       #   - otherwise: a single COMPACT line listing the running subs with the
       #     focused one marked, plus the "↓ to switch" hint, so the other subs
       #     are visible at a glance and ↓ opens the picker to jump.
-      def below_input_rows
+      def subagent_panel_rows
         attached = @focused_agent_id != :main
         return @agent_menu.rows(@cols) if attached && @agent_menu.open?
         return attached_switcher_rows if attached

data/lib/rubino/ui/cli.rb

@@ -25,6 +25,10 @@ module Rubino
     #   ◆  approval required
     #   ┄  low-priority metadata
     class CLI < PrinterBase
+      # The REPL host installs a per-turn render lambda here so the `ctx` gauge
+      # climbs live during a turn (#608e); see @live_status_provider.
+      attr_writer :live_status_provider
+
       # Page size tty-prompt paginates a select menu at (its Paginator's
       # DEFAULT_PAGE_SIZE) — the count of menu rows visible at once, used to wipe
       # a cancelled picker's frame (#219).
@@ -95,6 +99,11 @@ module Rubino
         @turn_started_at    = nil
         @turn_tool_count    = 0
         @turn_tok_chars     = 0
+        # Optional cheap render lambda (set by the REPL host per turn) that maps a
+        # LIVE in-flight token estimate to a status-bar line, so the `ctx ~Xk/…`
+        # gauge climbs DURING a turn instead of freezing until it ends (#608e).
+        # nil off the interactive REPL (one-shot/API/tests) — the bar is unchanged.
+        @live_status_provider = nil
         @thinking_started_at = nil
         @reasoning_buffer   = +""
         # :full-mode LIVE reasoning stream state. @reasoning_md splits the streamed
@@ -113,6 +122,19 @@ module Rubino
         # the footer (the frozen tail stays above the prompt). Touched only under
         # @status_mutex.
         @last_stream_at = nil
+        # Transient live-region repaint COALESCING (#freeze): a fast model streams
+        # deltas hundreds of times a second and each one repainted the live tail
+        # in full (clear + redraw, wrapped in synchronized-output) — rubino's CPU
+        # stays low but the volume of cursor-churn ANSI floods the terminal, which
+        # is what reads as a "freeze" (worst in the :full reasoning aside). We cap
+        # transient repaints to ~LIVE_FRAME_HZ: a too-soon frame is stored as
+        # @live_pending and the LATEST one is flushed by the ticker thread (≤ one
+        # STATUS_TICK later) or the next delta. Clearing frames bypass the cap so
+        # the tail tears down instantly on commit/turn-end. Guarded by its own
+        # mutex (paint comes from the delta thread AND the ticker thread).
+        @live_mutex      = Mutex.new
+        @live_pending    = nil # latest coalesced frame awaiting flush, or nil
+        @live_painted_at = nil # monotonic time of the last actual emit
         # The last retained reasoning block (committed/collapsed), revealable via
         # ctrl-o even after the answer has streamed. Reset per turn.
         @last_reasoning = nil
@@ -499,10 +521,18 @@ module Rubino
       # tool-iteration ceiling and is asking for more. Reuses the same unified
       # #approval_menu component, but the vocabulary is GRANT/DENY budget — there
       # is no "always" (no command to allowlist; budget is a one-shot grant). The
-      # caller maps :grant→continue and :deny/:summarize→summarize.
+      # caller maps :grant→continue, :later→snooze (leave parked), :summarize→summarize.
+      #
+      # "Decide later" sits BETWEEN grant and summarize on purpose (#586): the
+      # default highlight is the safe "Grant", and a stray ↓+Enter — the exact
+      # gesture used to open+attach in the subagent picker — lands on the
+      # non-destructive "Decide later", never on "Summarize now". The destructive
+      # option needs a deliberate ↓↓, so an auto-popped budget modal can't
+      # force-summarize a child by a mis-aimed picker keystroke.
       def subagent_budget_choice
         approval_menu("grant more budget?", [
                         ["Grant more iterations", :grant],
+                        ["Decide later", :later],
                         ["Summarize now", :summarize]
                       ])
       end
@@ -943,6 +973,21 @@ module Rubino
         nil
       end
 
+      # Repaints the persistent status bar with the live in-flight token estimate
+      # so `ctx ~Xk/…` climbs during a turn (#608e). The provider (installed by
+      # the REPL host for the duration of a turn) maps the estimate → a bar line;
+      # @turn_tok_chars/4 is the SAME chars/4 estimate the facet's `~N tok` uses.
+      # No-op off the interactive REPL (provider nil) or between turns. Cosmetic:
+      # a paint failure must never disturb the turn.
+      def refresh_live_ctx_bar
+        return unless @turn_active && @live_status_provider
+
+        line = @live_status_provider.call(@turn_tok_chars / 4)
+        BottomComposer.current&.set_status(line) if line
+      rescue StandardError
+        nil
+      end
+
       def subagent_cards
         @subagent_cards ||= SubagentCards.new(pastel: @pastel)
       end
@@ -1055,8 +1100,11 @@ module Rubino
         # Each rendered line is rubino-built with its own per-token SGR, off a
         # source already sanitize_terminal'd in #render_markdown_block before
         # parse. PATH 2 (#emit_styled) keeps that SGR and strips any residual
-        # danger byte.
-        render_markdown_block(text).each { |line| emit_styled("#{MD_MARGIN}#{line}") }
+        # danger byte. Emit the whole block in ONE write (lines joined by "\n",
+        # which #emit_styled preserves) so it commits as a SINGLE frame instead of
+        # one full live-region repaint per line — the #FREEZE storm on long blocks.
+        lines = render_markdown_block(text).map { |line| "#{MD_MARGIN}#{line}" }
+        emit_styled(lines.join("\n")) unless lines.empty?
       end
 
       # A markdown string -> Array<String> of ANSI-styled lines (no indent).
@@ -1134,6 +1182,23 @@ module Rubino
         text = chunk[:text].to_s
         return if text.empty?
 
+        # A tool call is starting to stream (#608). The NAME arrives once on
+        # :tool_preparing — open the tool card NOW, at the start of the call, so
+        # the timeline shows the tool being invoked (NOT a "preparing" label in
+        # the footer: the footer stays a pure token meter). The argument FRAGMENTS
+        # then arrive on :tool_args — count them toward the live token meter (so a
+        # long `write` shows the count climbing instead of freezing) and stream
+        # them into the card as the live params. Neither enters the answer buffer.
+        if type == :tool_preparing
+          tool_params_begin(text)
+          return
+        end
+        if type == :tool_args
+          @turn_tok_chars += text.length if @turn_active
+          tool_params_feed(text)
+          return
+        end
+
         @turn_tok_chars += text.length if @turn_active
 
         # Reasoning deltas are handled by #handle_thinking_delta: ALWAYS buffered
@@ -1254,6 +1319,9 @@ module Rubino
         @turn_started_at = monotonic_now
         @turn_tool_count = 0
         @turn_tok_chars  = 0
+        # Streaming-params card state (#608): no tool call is mid-stream yet.
+        @tool_params_open   = nil
+        @tool_params_stream = nil
         # Fresh turn: silence clock unarmed (#21).
         @status_mutex.synchronize { @last_stream_at = nil }
         # Per-turn tally of plain "Approve once" choices by tool — drives the
@@ -1370,7 +1438,72 @@ module Rubino
       #     repaints in place via CR + clear-line;
       #   * a pipe hosts nothing — raw escapes must not leak into the cooked
       #     output (#56).
+      # Transient live repaints are capped to this many per second (coalesced).
+      # ~20 fps is smooth to the eye but turns a fast model's hundreds-of-deltas-
+      # per-second repaint storm into at most 20 frames/s of terminal output —
+      # the fix for the streaming "freeze" (the terminal, not rubino, was the
+      # bottleneck). The trailing frame is flushed by the ticker (#flush_pending_live).
+      LIVE_FRAME_HZ = 20.0
+      LIVE_FRAME_INTERVAL = 1.0 / LIVE_FRAME_HZ
+
+      # Coalescing front door for the transient live region (tail / partial table
+      # / reasoning aside). A CLEARING frame (nil/empty — a commit/teardown) is
+      # painted immediately and cancels any pending frame, so the row never
+      # lingers. A content frame paints immediately if at least LIVE_FRAME_INTERVAL
+      # has passed since the last emit; otherwise it is stored as @live_pending and
+      # the LATEST stored frame is flushed by the ticker thread (#flush_pending_live)
+      # or superseded by the next delta — bounding repaints regardless of token rate.
       def paint_live(frame)
+        emit = false
+        to_emit = nil
+        @live_mutex.synchronize do
+          clearing = frame.nil? || frame.to_s.empty?
+          now = monotonic_now
+          # Coalesce ONLY a content frame that arrives within the interval, and
+          # ONLY while the ticker is running to flush the trailing one. A clearing
+          # (teardown) frame is never withheld and RESETS the window so the next
+          # content frame — often painted in the SAME delta right after a tail
+          # clear — emits at once.
+          if !clearing && throttle_live? && @live_painted_at &&
+             (now - @live_painted_at) < LIVE_FRAME_INTERVAL
+            @live_pending = frame # ticker/next delta paints the latest
+          else
+            @live_pending = nil
+            @live_painted_at = clearing ? nil : now
+            to_emit = frame
+            emit = true
+          end
+        end
+        emit_live_frame(to_emit) if emit
+      end
+
+      # Coalesce live repaints only while the turn ticker thread is alive — it
+      # provides the trailing-edge flush (#flush_pending_live). Outside a turn
+      # (tests, the cooked /probe wait, plain non-TTY paths) there is no flusher,
+      # so paint every frame immediately to preserve exact legacy behavior.
+      def throttle_live?
+        @thinking_thread&.alive? || false
+      end
+
+      # Paint the latest coalesced frame if the interval has elapsed. Called by the
+      # ticker thread every STATUS_TICK so a burst that stops mid-stream still
+      # settles to its final tail within ~one tick (no stale rows during a pause).
+      # The actual terminal write happens OUTSIDE @live_mutex (its own seam mutex),
+      # mirroring #refresh_live_cards' un-nested-locks discipline.
+      def flush_pending_live
+        emit = nil
+        @live_mutex.synchronize do
+          return if @live_pending.nil?
+          return if @live_painted_at && (monotonic_now - @live_painted_at) < LIVE_FRAME_INTERVAL
+
+          emit = @live_pending
+          @live_pending = nil
+          @live_painted_at = monotonic_now
+        end
+        emit_live_frame(emit)
+      end
+
+      def emit_live_frame(frame)
         # The $stdout proxy belongs to the MAIN turn (the main thread swaps it in);
         # only the main CLI may write through it. A background subagent's CLI runs
         # on its own thread where the GLOBAL $stdout is the main's proxy (or real
@@ -1496,6 +1629,17 @@ module Rubino
       # contract #confirm uses before the approval card.
       def tool_started(name, arguments: nil, at: nil, call_id: nil)
         record_subagent_tool_started(name, arguments)
+        # Streaming path: the card was already opened at the START of the call
+        # (#tool_params_begin) and its params streamed live. Commit the held
+        # params tail and DON'T redraw the header — just relabel the status row.
+        if @tool_params_open == name
+          tool_params_flush
+          return delegation_started(arguments, call_id) if name == "task"
+
+          status_show(name, phase: :tool, hint: status_hint(arguments)) if @turn_active
+          return
+        end
+
         finalize_stream
         return delegation_started(arguments, call_id) if name == "task"
 
@@ -1507,6 +1651,67 @@ module Rubino
         status_show(name, phase: :tool, hint: status_hint(arguments)) if @turn_active
       end
 
+      # The streaming tool call just started (its NAME arrived, #608). Open the
+      # tool card at the START — before the arguments finish — so the user sees
+      # the invocation and its params stream in, rather than a frozen footer.
+      # #tool_started reconciles against @tool_params_open so the `● name` header
+      # is drawn exactly once. No-op off-turn or if this call is already open.
+      def tool_params_begin(name)
+        return unless @turn_active
+        return if @tool_params_open == name
+        # `task` (subagent delegation) has a bespoke card (#delegation_started);
+        # don't pre-open a generic `● task` that would clash with it.
+        return if name == "task"
+
+        # Close any open answer block first (the normal #tool_started path does
+        # this via #finalize_stream) so the card never opens under a live tail.
+        finalize_stream
+        activity_started(name)
+        @tool_params_open   = name
+        @tool_params_stream = ToolArgsStream.new
+        # Keep the animated facet ALIVE for the whole argument stream (#608d).
+        # A large `write` streams its content for MINUTES past the 30-line preview
+        # cap; without a live status the screen sits silent (measured: ~38s of
+        # dead UI on a 100-line file) and reads as a freeze. status_text already
+        # renders the "writing" phase with the ~N-tok meter climbing — it just
+        # needs the facet visible. Mirrors the SAME facet+tool_chunk pairing the
+        # tool-EXECUTION phase (#tool_started) already uses, so the params scroll
+        # above an animated `tool · Ns · ~N tok` footer instead of nothing.
+        status_show(name, phase: :tool) if @turn_active
+      end
+
+      # An argument fragment of the in-flight call: decode the JSON arg VALUES and
+      # render the complete lines unlocked so far under the card (the partial last
+      # line is held by the decoder until its newline lands), reusing the
+      # head-N-lines preview collapse. Token counting happens in #stream.
+      def tool_params_feed(fragment)
+        return unless @tool_params_stream
+
+        lines = @tool_params_stream.feed(fragment)
+        # Stream the params IN FULL (no 30-line preview cap): a `write`/`edit`'s
+        # content is exactly what the user wants to watch land, line by line, as
+        # the model generates it (#608d). The cap is for collapsing a finished
+        # tool's OUTPUT in the transcript — not for hiding the file being authored
+        # right now. Streaming every line also keeps the screen alive the whole
+        # time, so a long write never sits silent.
+        tool_chunk(@tool_params_open, lines, full: true) unless lines.empty?
+      end
+
+      # Flush the held params tail and close the streaming-params state. Called
+      # when the tool actually starts (args complete) and at turn end so the last
+      # line is never lost.
+      def tool_params_flush
+        stream = @tool_params_stream
+        @tool_params_stream = nil
+        @tool_params_open   = nil
+        return unless stream
+
+        tail = stream.flush
+        # Full (uncapped) to match the live params stream (#608d) — the final
+        # partial line is part of the content the user is watching land.
+        tool_chunk(@activity_name, "#{tail}\n", full: true) unless tail.empty?
+      end
+
       # DISPLAY-ONLY collapse (P2): the transcript shows the head few lines of
       # a tool's output plus a `… +N lines (full output → context)` marker —
       # the FULL output still goes to the model/context unchanged. Governed by
@@ -1536,7 +1741,7 @@ module Rubino
       # accumulated across chunks. Lines past the preview budget are counted
       # silently; #activity_finished flushes the `… +N lines` marker right
       # before the close row.
-      def tool_chunk(_name, chunk, kind: :plain)
+      def tool_chunk(_name, chunk, kind: :plain, full: false)
         record_subagent_tool_output(chunk)
         return if chunk.nil? || chunk.to_s.empty?
 
@@ -1549,9 +1754,12 @@ module Rubino
           return
         end
 
+        # +full+ (live `write`/`edit` params, #608d) shows EVERY line — the user
+        # is watching the file being authored, not reviewing a finished dump.
         limit = tool_preview_limit
-        unless limit.positive?
+        if full || !limit.positive?
           write_body_lines(chunk.to_s) { |chomped| @pastel.dim(chomped) }
+          @last_block = :tool
           return
         end
 
@@ -1740,8 +1948,7 @@ module Rubino
       # Short human labels for the post-turn inline jobs the status row tracks.
       JOB_STATUS_LABELS = {
         "ExtractMemoryJob" => "memory",
-        "DistillSkillJob" => "skills",
-        "SummarizeSessionJob" => "summary"
+        "DistillSkillJob" => "skills"
       }.freeze
 
       def job_enqueued(type)
@@ -2028,6 +2235,7 @@ module Rubino
         # Width left for body text after the 2-space margin; a small floor keeps
         # a very narrow terminal from looping on a 1-col field.
         budget = [terminal_cols - 1 - BODY_MARGIN.length, 4].max
+        rows = []
         Util::Output.sanitize_terminal(text).each_line do |line|
           chomped = line.chomp
           # HARD-WRAP a long no-break token inside the output body instead of
@@ -2038,11 +2246,15 @@ module Rubino
           # continuation lines hang-indent under the first.
           wrap_tail_row(chomped, budget).each do |row|
             rendered = style ? style.call(row) : row
-            # +text+ was sanitize_terminal'd above; the style block adds rubino's
-            # own SGR → PATH 2 (#emit_styled) keeps that colour, strips danger.
-            emit_styled("#{BODY_MARGIN}#{rendered}")
+            rows << "#{BODY_MARGIN}#{rendered}"
           end
         end
+        # +text+ was sanitize_terminal'd above; the style block adds rubino's own
+        # SGR → PATH 2 (#emit_styled) keeps that colour, strips danger. Emit the
+        # whole captured body in ONE write so a large tool output (a multi-hundred-
+        # line `read`) commits as a SINGLE frame, not one full repaint per line
+        # — the storm that wedged tmux on "read many files" (#FREEZE).
+        emit_styled(rows.join("\n")) unless rows.empty?
       end
 
       # COMPOSE-TIME span defang: neutralizes an UNTRUSTED span (a tool metric, a
@@ -2125,7 +2337,7 @@ module Rubino
         end
       end
 
-      # display.live_markdown — opt-in formatted live region (default false).
+      # display.live_markdown — formatted live region (default true, defaults.rb).
       def live_markdown?
         Rubino.configuration.display_live_markdown?
       end
@@ -2151,7 +2363,12 @@ module Rubino
       # the styled rows carry only rubino's own SGR — they must NOT pass through
       # #margined_tail again (that would caret-escape our own escapes).
       def live_markdown_lines(stream_md)
-        raw = stream_md.tail
+        # #live_source, not #tail: render only a bounded trailing window of the
+        # in-flight block (with the fence opener preserved), not the WHOLE
+        # growing block on every delta — re-parsing the full block per token was
+        # O(N²) and froze the stream on long ``` code/file dumps. The visible
+        # last-LIVE_TAIL_ROWS rows are unchanged.
+        raw = stream_md.live_source
         return [] if raw.nil? || raw.empty?
 
         repaired = MarkdownRepair.close_open_spans(raw, fence: stream_md.open_fence)
@@ -2572,12 +2789,30 @@ module Rubino
             # Outside @status_mutex (set_subagent_cards takes the composer's own
             # render mutex; keeping the locks un-nested avoids any ordering risk).
             refresh_live_cards if (i % 10).zero?
+            # Repaint the persistent `ctx ~Xk/…` bar ~1/s with the live in-flight
+            # token estimate so it climbs during the turn (#608e) instead of
+            # sitting frozen until the turn ends. ~1 Hz (not per delta) keeps the
+            # full bar redraw cheap. Outside @status_mutex (set_status takes the
+            # composer's own render mutex; keeps the locks un-nested).
+            refresh_live_ctx_bar if (i % 10).zero?
+            # Trailing-edge flush for the coalesced live region: if a burst of
+            # deltas left a frame pending (repaints capped to LIVE_FRAME_HZ), paint
+            # the latest one now so a stream that paused never shows a stale tail.
+            # Outside @status_mutex (paint takes the composer's own render mutex).
+            flush_pending_live
             i += 1
             sleep STATUS_TICK
           end
-        rescue StandardError
+        rescue StandardError => e
           # The animation is cosmetic — a repaint failure must never break the
-          # turn. Stop quietly.
+          # turn. But NEVER swallow it silently: a programming slip here (e.g. a
+          # private-method call) used to kill this thread on tick one, freezing the
+          # spinner for the whole turn while the wait looked like a hang (#FREEZE).
+          # Log it (to the file logger, not the raw-mode $stdout) so it is
+          # diagnosable instead of invisible.
+          Rubino.logger.error(event: "ui.status_ticker.died",
+                              error: "#{e.class}: #{e.message}",
+                              at: e.backtrace&.first)
         end
       end
 
@@ -2625,10 +2860,14 @@ module Rubino
         if s[:phase] == :thinking
           parts << "#{(now - (@turn_started_at || s[:phase_started_at])).to_i}s"
           parts << "#{@turn_tool_count} tool#{"s" if @turn_tool_count != 1}" if @turn_tool_count.positive?
-          parts << "~#{format_status_tokens(@turn_tok_chars / 4)} tok" if @turn_tok_chars >= 4
         else
           parts << "#{(now - s[:phase_started_at]).to_i}s"
         end
+        # The live token meter rides EVERY phase (#608), not just thinking: while a
+        # long `write`'s params stream, the facet resurfaces labelled "writing" and
+        # must still show the count climbing — that's the whole point of counting
+        # the tool-arg fragments. Estimate, hence the leading ~.
+        parts << "~#{format_status_tokens(@turn_tok_chars / 4)} tok" if @turn_tok_chars >= 4
         text = parts.join(" · ")
         budget = [terminal_cols, 80].min - FACET_TRACK_CELLS - 2
         text.length > budget ? "#{text[0, budget - 1]}…" : text

data/lib/rubino/ui/markdown_renderer.rb

@@ -247,7 +247,10 @@ module Rubino
         # raw "##" would otherwise show through verbatim. A leading bar gives a
         # subtle visual cue without leaking markdown syntax.
         body = inline_tokens(el.children, style)
-        wrap_lines(tokens_to_lines([["▌ ", style]] + body), hang: 2)
+        rendered = wrap_lines(tokens_to_lines([["▌ ", style]] + body), hang: 2)
+        # Big headings (H1/H2) get breathing room above and below so they
+        # visually break the prose instead of sitting glued to surrounding text.
+        level <= 2 ? [[]] + rendered + [[]] : rendered
       end
 
       # Raw (un-wrapped) paragraph lines. Wrapping is applied by the CALLER

data/lib/rubino/ui/stdout_proxy.rb

@@ -133,19 +133,34 @@ module Rubino
         return if str.nil? || str.empty?
 
         @partial << str
-        commit_complete_lines
-        render_partial
+        committed = commit_complete_lines
+        # print_above ALREADY cleared the partial row and repainted the prompt for
+        # each line it committed; when nothing is left over, a second set_partial("")
+        # would repaint the very same empty row — the double-frame-per-line that
+        # helped wedge tmux during reasoning/tool streaming (#FREEZE). Only render
+        # the partial when there's a non-empty remainder, or when no line committed
+        # (a partial growing in place still needs its live row redrawn).
+        render_partial unless committed && @partial.empty?
       end
 
       def commit_complete_lines
-        while (idx = @partial.index("\n"))
-          line = @partial[0...idx]
-          @partial = @partial[(idx + 1)..] || +""
-          # A committed line is a finished row; embedded "\r" (e.g. the CLI's
-          # in-place clear before a streamed chunk) is preserved so print_above's
-          # clear-line semantics still apply.
-          @composer.print_above(line)
-        end
+        nl = @partial.rindex("\n")
+        return false unless nl
+
+        # Commit the WHOLE run of finished lines in ONE frame. print_above →
+        # LiveRegion#commit splits the embedded "\n" into CRLF-terminated rows
+        # that each scroll into scrollback, so a 500-line tool result (a big
+        # `read`, a long rendered markdown block) lands with a SINGLE live-region
+        # clear+redraw instead of one full repaint PER line — the storm that
+        # wedged tmux on "read many files / write file" (#FREEZE). Embedded "\r"
+        # (the CLI's in-place clear before a streamed chunk) is preserved.
+        # Strip ONLY the final "\n" (not a preceding "\r"): the per-line path this
+        # replaces excluded just the newline and kept any in-place-clear "\r", and
+        # LiveRegion#commit re-adds the row terminators.
+        block = @partial[0...nl]
+        @partial = @partial[(nl + 1)..] || +""
+        @composer.print_above(block)
+        true
       end
 
       # Show the in-progress (un-newlined) line above the composer without