openclacky 0.9.30 → 0.9.32

data/lib/clacky/tools/shell.rb

@@ -3,41 +3,10 @@
 require "tmpdir"
 require_relative "base"
 require_relative "../utils/encoding"
+require_relative "../utils/limit_stack"
 
 module Clacky
   module Tools
-    # A StringIO wrapper that scrubs invalid/undefined bytes to UTF-8 on every
-    # write.  Shell commands (via popen3) can emit bytes in any encoding
-    # (GBK, Latin-1, binary, …).  By sanitizing at the earliest possible point
-    # we guarantee that every downstream operation — regex matching, line
-    # splitting, JSON serialization — never sees invalid byte sequences.
-    class EncodingSafeBuffer
-      def initialize
-        # Use ASCII-8BIT backing store to accept raw bytes from popen3 without
-        # encoding conflicts.  Scrubbing happens on write; the string method
-        # re-labels the result as UTF-8 on the way out so callers (JSON.generate,
-        # regex, etc.) always see a properly-tagged UTF-8 string.
-        @io = StringIO.new("".b)
-      end
-
-      def write(data)
-        return unless data && !data.empty?
-
-        # Shell output arrives as binary (ASCII-8BIT) bytes.  Use the shared
-        # helper which scrubs only genuinely invalid sequences, preserving
-        # multibyte characters (e.g. CJK).  The result is written as raw bytes
-        # into the ASCII-8BIT buffer.
-        @io.write(Clacky::Utils::Encoding.to_utf8(data).b)
-      end
-
-      def string
-        # Re-label the accumulated bytes as UTF-8.  By this point every byte
-        # has already been scrubbed by to_utf8 on write, so force_encoding is
-        # safe and avoids an unnecessary copy.
-        @io.string.force_encoding("UTF-8")
-      end
-    end
-
     class Shell < Base
       self.tool_name = "shell"
       self.tool_description = "Execute shell commands in the terminal"
@@ -90,14 +59,28 @@ module Clacky
         'go build'
       ].freeze
 
+      # Maximum characters per line (handles minified CSS/JS/JSON)
+      MAX_LINE_CHARS = 500
+      # Maximum total characters sent to LLM
+      MAX_LLM_OUTPUT_CHARS = 4_000
+      # Maximum lines kept in the rolling buffer
+      MAX_LLM_OUTPUT_LINES = 500
+
       def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000, on_output: nil, working_dir: nil)
         require "open3"
-        require "stringio"
 
         soft_timeout, hard_timeout = determine_timeouts(command, soft_timeout, hard_timeout)
 
-        stdout_buffer = EncodingSafeBuffer.new
-        stderr_buffer = EncodingSafeBuffer.new
+        # OutputLimitBuffer built on LimitStack:
+        #   - max_line_chars: truncates each individual line at write-time
+        #     (prevents single-line minified JSON/CSS from filling the buffer)
+        #   - max_chars: stops accepting new content once budget is exhausted
+        #     (prevents runaway output from consuming LLM tokens)
+        #   - max_size: rolling window keeps the LAST N lines
+        #     (preserves the most recent/relevant output tail)
+        # All limits are enforced at write-time — no post-processing needed.
+        stdout_buffer = new_output_buffer
+        stderr_buffer = new_output_buffer
         soft_timeout_triggered = false
 
         # pgroup: 0 puts the child in its own process group so that Ctrl-C
@@ -138,12 +121,12 @@ module Clacky
 
                   return format_timeout_result(
                     command,
-                    stdout_buffer.string,
-                    stderr_buffer.string,
+                    stdout_buffer.to_s,
+                    stderr_buffer.to_s,
                     elapsed,
                     :hard_timeout,
                     hard_timeout,
-                    max_output_lines
+                    stdout_buffer.truncated? || stderr_buffer.truncated?
                   )
                 end
 
@@ -151,8 +134,8 @@ module Clacky
                 if elapsed > soft_timeout && !soft_timeout_triggered
                   soft_timeout_triggered = true
 
-                  interaction = detect_interaction(stdout_buffer.string) ||
-                                detect_interaction(stderr_buffer.string) ||
+                  interaction = detect_interaction(stdout_buffer.to_s) ||
+                                detect_interaction(stderr_buffer.to_s) ||
                                 detect_sudo_waiting(command, wait_thr)
                   if interaction
                     Process.kill('TERM', -wait_thr.pid) rescue nil
@@ -160,10 +143,10 @@ module Clacky
                     stderr.close rescue nil
                     return format_waiting_input_result(
                       command,
-                      stdout_buffer.string,
-                      stderr_buffer.string,
+                      stdout_buffer.to_s,
+                      stderr_buffer.to_s,
                       interaction,
-                      max_output_lines
+                      stdout_buffer.truncated? || stderr_buffer.truncated?
                     )
                   end
                 end
@@ -178,11 +161,11 @@ module Clacky
                         data = io.read_nonblock(4096)
                         if io == stdout
                           utf8 = Clacky::Utils::Encoding.to_utf8(data)
-                          stdout_buffer.write(data)
+                          stdout_buffer.push_lines(utf8)
                           on_output.call(:stdout, utf8) if on_output
                         else
                           utf8 = Clacky::Utils::Encoding.to_utf8(data)
-                          stderr_buffer.write(data)
+                          stderr_buffer.push_lines(utf8)
                           on_output.call(:stderr, utf8) if on_output
                         end
                       rescue IO::WaitReadable, EOFError
@@ -212,7 +195,8 @@ module Clacky
                   ready[0].each do |io|
                     buf = io == stdout ? stdout_buffer : stderr_buffer
                     begin
-                      buf.write(io.read_nonblock(4096))
+                      chunk = io.read_nonblock(4096)
+                      buf.push_lines(Clacky::Utils::Encoding.to_utf8(chunk))
                     rescue IO::WaitReadable
                       # not ready yet, keep waiting
                     rescue EOFError
@@ -223,17 +207,14 @@ module Clacky
               rescue StandardError
               end
 
-              stdout_output = stdout_buffer.string
-              stderr_output = stderr_buffer.string
-
               {
                 command: command,
-                stdout: truncate_output(stdout_output, max_output_lines),
-                stderr: truncate_output(stderr_output, max_output_lines),
+                stdout: stdout_buffer.to_s,
+                stderr: stderr_buffer.to_s,
                 exit_code: wait_thr.value.exitstatus,
                 success: wait_thr.value.success?,
                 elapsed: Time.now - start_time,
-                output_truncated: output_truncated?(stdout_output, stderr_output, max_output_lines)
+                output_truncated: stdout_buffer.truncated? || stderr_buffer.truncated?
               }
             ensure
               # Ensure child process group is killed when block exits
@@ -245,16 +226,16 @@ module Clacky
             end
           end
         rescue StandardError => e
-          stdout_output = stdout_buffer.string
-          stderr_output = "Error executing command: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+          stdout_str = stdout_buffer.to_s
+          stderr_str = "Error executing command: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
 
           {
             command: command,
-            stdout: truncate_output(stdout_output, max_output_lines),
-            stderr: truncate_output(stderr_output, max_output_lines),
+            stdout: stdout_str,
+            stderr: stderr_str,
             exit_code: -1,
             success: false,
-            output_truncated: output_truncated?(stdout_output, stderr_output, max_output_lines)
+            output_truncated: stdout_buffer.truncated?
           }
         end
       end
@@ -396,21 +377,22 @@ module Clacky
         { type: "password", line: "[sudo] password:" }
       end
 
-      def format_waiting_input_result(command, stdout, stderr, interaction, max_output_lines)
+      def format_waiting_input_result(command, stdout, stderr, interaction, truncated)
         {
           command: command,
-          stdout: truncate_output(stdout, max_output_lines),
-          stderr: truncate_output(stderr, max_output_lines),
+          stdout: stdout,
+          stderr: stderr,
           exit_code: -2,
           success: false,
           state: 'WAITING_INPUT',
           interaction_type: interaction[:type],
-          message: format_waiting_message(truncate_output(stdout, max_output_lines), interaction),
-          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
+          interaction: interaction,
+          message: format_waiting_message(interaction),
+          output_truncated: truncated
         }
       end
 
-      def format_waiting_message(output, interaction)
+      def format_waiting_message(interaction)
         password_hint = if interaction[:type] == "password"
           <<~HINT
 
@@ -423,9 +405,10 @@ module Clacky
           HINT
         end
 
+        # NOTE: Do NOT embed `output` here — the caller already has stdout/stderr
+        # in dedicated fields.  Including output here would duplicate tokens sent
+        # to the LLM (potentially 2×), causing unnecessarily high costs.
         <<~MSG
-          #{output}
-
           #{'=' * 60}
           [Terminal State: WAITING_INPUT]
           #{'=' * 60}
@@ -441,42 +424,24 @@ module Clacky
         MSG
       end
 
-      def format_timeout_result(command, stdout, stderr, elapsed, type, timeout, max_output_lines)
+      def extract_last_line(output)
+        return "" if output.nil? || output.empty?
+        output.lines.last&.strip.to_s[0..200]
+      end
+
+      def format_timeout_result(command, stdout, stderr, elapsed, type, timeout, truncated)
         {
           command: command,
-          stdout: truncate_output(stdout, max_output_lines),
-          stderr: truncate_output(
-            stderr.empty? ? "Command timed out after #{elapsed.round(1)} seconds (#{type}=#{timeout}s)" : stderr,
-            max_output_lines
-          ),
+          stdout: stdout,
+          stderr: stderr.empty? ? "Command timed out after #{elapsed.round(1)} seconds (#{type}=#{timeout}s)" : stderr,
           exit_code: -1,
           success: false,
           state: 'TIMEOUT',
           timeout_type: type,
-          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
+          output_truncated: truncated
         }
       end
 
-      # Truncate output to max_lines and max line length, adding a truncation notice if needed
-      def truncate_output(output, max_lines)
-        return output if output.nil? || output.empty?
-
-        output = truncate_long_lines(output, MAX_LINE_CHARS)
-        lines = output.lines
-        return output if lines.length <= max_lines
-
-        truncated_lines = lines.first(max_lines)
-        truncation_notice = "\n\n... [Output truncated: showing #{max_lines} of #{lines.length} lines] ...\n"
-        truncated_lines.join + truncation_notice
-      end
-
-      # Check if output was truncated
-      def output_truncated?(stdout, stderr, max_lines)
-        stdout_lines = stdout&.lines&.length || 0
-        stderr_lines = stderr&.lines&.length || 0
-        stdout_lines > max_lines || stderr_lines > max_lines
-      end
-
       def format_call(args)
         cmd = args[:command] || args['command'] || ''
         cmd_parts = cmd.split
@@ -499,103 +464,59 @@ module Clacky
         end
       end
 
-      # Format result for LLM consumption - limit output size to save tokens
-      # Maximum characters to include in LLM output
-      MAX_LLM_OUTPUT_CHARS = 4000
-      # Maximum characters per line before truncating (handles minified CSS/JS files)
-      MAX_LINE_CHARS = 500
-
       def format_result_for_llm(result)
-        return result if result[:error] || result[:state] == 'TIMEOUT' || result[:state] == 'WAITING_INPUT'
+        return result if result[:error]
 
         enc = Clacky::Utils::Encoding
+
+        # stdout/stderr are already size-limited by the LimitStack buffer used
+        # during execution (MAX_LINE_CHARS per line, MAX_LLM_OUTPUT_CHARS total,
+        # MAX_LLM_OUTPUT_LINES rolling window).  No further truncation needed.
         stdout = enc.to_utf8(result[:stdout] || "")
         stderr = enc.to_utf8(result[:stderr] || "")
-        exit_code = result[:exit_code] || 0
 
         compact = {
           command: enc.to_utf8(result[:command].to_s),
-          exit_code: exit_code,
-          success: result[:success]
+          exit_code: result[:exit_code] || 0,
+          success: result[:success],
+          stdout: stdout,
+          stderr: stderr
         }
 
-        compact[:elapsed] = result[:elapsed] if result[:elapsed]
-
-        command_name = extract_command_name(compact[:command])
-
-        stdout_info = truncate_and_save(stdout, MAX_LLM_OUTPUT_CHARS, "stdout", command_name)
-        compact[:stdout] = stdout_info[:content]
-        compact[:stdout_full] = stdout_info[:temp_file] if stdout_info[:temp_file]
-
-        stderr_info = truncate_and_save(stderr, MAX_LLM_OUTPUT_CHARS, "stderr", command_name)
-        compact[:stderr] = stderr_info[:content]
-        compact[:stderr_full] = stderr_info[:temp_file] if stderr_info[:temp_file]
-
         compact[:output_truncated] = true if result[:output_truncated]
+        compact[:elapsed] = result[:elapsed] if result[:elapsed]
 
-        compact
-      end
-
-      # Extract command name from full command for temp file naming
-      def extract_command_name(command)
-        first_word = command.strip.split(/\s+/).first
-        File.basename(first_word, ".*")
-      end
-
-      # Truncate output for LLM and optionally save full content to temp file
-      def truncate_and_save(output, max_chars, label, command_name)
-        return { content: "", temp_file: nil } if output.empty?
-
-        output = truncate_long_lines(output, MAX_LINE_CHARS)
-        return { content: output, temp_file: nil } if output.length <= max_chars
-
-        safe_name = command_name.gsub(/[^\w\-.]/, "_")[0...50]
-        temp_dir = Dir.mktmpdir
-        temp_file = File.join(temp_dir, "#{safe_name}_#{Time.now.strftime("%Y%m%d_%H%M%S")}.output")
-        File.write(temp_file, output)
-
-        lines = output.lines
-        return { content: output, temp_file: nil } if lines.length <= 2
-
-        notice_overhead = 200
-        available_chars = max_chars - notice_overhead
-
-        first_part = []
-        accumulated = 0
-        lines.each do |line|
-          break if accumulated + line.length > available_chars
-          first_part << line
-          accumulated += line.length
+        # Preserve WAITING_INPUT state fields
+        if result[:state] == 'WAITING_INPUT'
+          compact[:state] = 'WAITING_INPUT'
+          compact[:interaction_type] = result[:interaction_type]
+          interaction = result[:interaction_type] ? { type: result[:interaction_type], line: result.dig(:interaction, :line) || extract_last_line(stdout) } : { type: 'question', line: extract_last_line(stdout) }
+          compact[:message] = format_waiting_message(interaction)
         end
 
-        total_lines = lines.length
-        shown_lines = first_part.length
-
-        notice = if label == "stderr"
-          "\n... [Error output truncated for LLM: showing #{shown_lines} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ...\n"
-        else
-          "\n... [Output truncated for LLM: showing #{shown_lines} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ...\n"
+        # Preserve TIMEOUT state fields
+        if result[:state] == 'TIMEOUT'
+          compact[:state] = 'TIMEOUT'
+          compact[:timeout_type] = result[:timeout_type]
         end
 
-        { content: first_part.join + notice, temp_file: temp_file }
+        compact
       end
 
-      # Truncate individual lines that exceed max_line_chars
-      # Useful for minified CSS/JS files where a single line can be megabytes
-      def truncate_long_lines(output, max_line_chars)
-        lines = output.lines
-        return output if lines.none? { |l| l.chomp.length > max_line_chars }
-
-        lines.map do |line|
-          chopped = line.chomp
-          if chopped.length > max_line_chars
-            "#{chopped[0...max_line_chars]}... [line truncated: #{chopped.length} chars total]\n"
-          else
-            line
-          end
-        end.join
+      # Create a new output buffer with write-time limits.
+      # - max_line_chars: each line is truncated at this length on push
+      #   (prevents single-line minified JSON/CSS from filling the budget)
+      # - max_chars: stops accepting content once total chars are exhausted
+      #   (hard ceiling on tokens sent to LLM)
+      # - max_size: rolling window — keeps the LAST N lines
+      #   (preserves the most recent, relevant tail of long output)
+      private def new_output_buffer
+        Clacky::Utils::LimitStack.new(
+          max_size: MAX_LLM_OUTPUT_LINES,
+          max_line_chars: MAX_LINE_CHARS,
+          max_chars: MAX_LLM_OUTPUT_CHARS
+        )
       end
-
     end
   end
 end

data/lib/clacky/ui2/ui_controller.rb

@@ -398,6 +398,34 @@ module Clacky
         # doesn't bleed into the next one, and so the buffer is ready before
         # on_output starts firing (which can happen before show_progress is called).
         @stdout_lines = nil
+
+        # Special handling for request_user_feedback: render as a readable interactive card
+        # with the full question and options, rather than the truncated format_call summary.
+        if name.to_s == "request_user_feedback"
+          args_data = args.is_a?(String) ? (JSON.parse(args, symbolize_names: true) rescue {}) : args
+          args_data = args_data.transform_keys(&:to_sym) if args_data.is_a?(Hash)
+
+          question = args_data[:question].to_s.strip
+          context  = args_data[:context].to_s.strip
+          options  = Array(args_data[:options])
+
+          theme = ThemeManager.current_theme
+          parts = []
+
+          parts << context unless context.empty?
+          parts << question unless question.empty?
+
+          if options.any?
+            parts << ""
+            options.each_with_index { |opt, i| parts << "  #{i + 1}. #{opt}" }
+          end
+
+          card_text = parts.join("\n")
+          output = @renderer.render_system_message(card_text, prefix_newline: true)
+          append_output(output)
+          return
+        end
+
         formatted_call = format_tool_call(name, args)
         output = @renderer.render_tool_call(tool_name: name, formatted_call: formatted_call)
         append_output(output)
@@ -465,30 +493,72 @@ module Clacky
 
       # Show progress indicator with dynamic elapsed time
       # @param message [String] Progress message (optional, will use random thinking verb if nil)
-      # @param prefix_newline [Boolean] Whether to add a blank line before progress (default: true)
+      # Show or stop a progress indicator.
+      #
+      # Rendering strategies by progress_type:
+      #   "thinking"      — spinner in yellow (render_working), session bar → 'working' (default)
+      #   "retrying"      — spinner in gray (render_progress), no session bar change;
+      #                     shows "attempt/total" from metadata: { attempt: N, total: M }
+      #   "idle_compress" — same as "retrying"; background work the user need not watch closely
+      #
+      # phase:
+      #   "active" — start/update the progress indicator (default)
+      #   "done"   — stop progress; auto-appends elapsed time to the final line
+      #
+      # @param message [String, nil] Progress message (nil uses a random thinking verb for "thinking")
+      # @param prefix_newline [Boolean] Prepend blank line before new progress line (default: true)
+      # @param progress_type [String] "thinking" | "retrying" | "idle_compress"
+      # @param phase [String] "active" | "done"
+      # @param metadata [Hash] { attempt: N, total: M } for "retrying" type
       def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
-        # Stop any existing progress thread
+        # ── phase "done": stop progress and render final state ──────────────────────────
+        if phase.to_s == "done"
+          elapsed_time  = @progress_start_time ? (Time.now - @progress_start_time).to_i : 0
+          saved_message = @progress_message
+
+          stop_progress_thread
+          @stdout_lines = nil
+
+          # Prefer caller-supplied message; fall back to elapsed-time summary
+          final_msg = if message && !message.to_s.strip.empty?
+            message.to_s
+          elsif saved_message && elapsed_time > 0
+            "#{saved_message}… (#{elapsed_time}s)"
+          end
+
+          if final_msg
+            update_progress_line(@renderer.render_progress(final_msg))
+          else
+            clear_progress_line
+          end
+          return
+        end
+
+        # ── "active": start or update spinner ───────────────────────────────────────────
         stop_progress_thread
 
-        # Update status to 'working'
-        update_sessionbar(status: 'working')
+        # "thinking" updates session bar; "retrying"/"idle_compress" are background — leave it alone
+        update_sessionbar(status: 'working') if progress_type.to_s == "thinking"
+
+        # Build display message; "retrying" appends attempt/total from metadata
+        attempt = metadata[:attempt]
+        total   = metadata[:total]
+        attempt_suffix = attempt && total ? " (#{attempt}/#{total})" : ""
 
-        @progress_message = message || Clacky::THINKING_VERBS.sample
+        @progress_message    = (message || Clacky::THINKING_VERBS.sample) + attempt_suffix
         @progress_start_time = Time.now
-        # Flag used by the progress thread to know when to stop gracefully.
-        # Using a flag + join is safe because Thread#kill can interrupt a thread
-        # while it holds @render_mutex, causing a permanent deadlock.
         @progress_thread_stop = false
 
-        # Show initial progress (yellow, active)
+        # Choose render style: yellow for thinking, gray for retrying/idle
+        quiet_type = %w[retrying idle_compress].include?(progress_type.to_s)
+        render_active = ->(msg) {
+          quiet_type ? @renderer.render_progress(msg) : @renderer.render_working(msg)
+        }
+
         append_output("") if prefix_newline
-        # Initial hint — no stdout yet, so no Ctrl+O tip at this point.
-        # The background thread will add the Ctrl+O tip as soon as any stdout arrives.
-        output = @renderer.render_working("#{@progress_message}… (Ctrl+C to interrupt)")
-        append_output(output)
+        append_output(render_active.call("#{@progress_message}… (Ctrl+C to interrupt)"))
 
-        # Start background thread to update elapsed time.
-        # Also dynamically adds "Ctrl+O to view output" hint once @stdout_lines is populated.
+        # Background thread: update elapsed time every 0.5s
         @progress_thread = Thread.new do
           until @progress_thread_stop
             sleep 0.5
@@ -502,7 +572,7 @@ module Clacky
             hint = has_output ?
               "(Ctrl+C to interrupt · Ctrl+O to view output · #{elapsed}s)" :
               "(Ctrl+C to interrupt · #{elapsed}s)"
-            update_progress_line(@renderer.render_working("#{@progress_message}… #{hint}"))
+            update_progress_line(render_active.call("#{@progress_message}… #{hint}"))
           end
         rescue StandardError
           # Silently handle thread errors
@@ -510,70 +580,10 @@ module Clacky
       end
 
       # Returns true if a progress indicator is currently active.
-      # Used to guard calls to clear_progress so we don't accidentally
-      # remove a non-progress line from the output buffer.
       def progress_active?
         @progress_start_time != nil
       end
 
-      # Clear progress indicator
-      def clear_progress
-        # Guard: if no progress is active, do nothing.
-        # This makes clear_progress idempotent — safe to call multiple times
-        # (e.g. once from handle_submit and again from handle_agent_exception).
-        return unless progress_active?
-
-        # Calculate elapsed time before stopping
-        elapsed_time = @progress_start_time ? (Time.now - @progress_start_time).to_i : 0
-
-        # Stop the progress thread (blocks until thread exits or timeout)
-        stop_progress_thread
-
-        # stdout buffer no longer needed after command finishes
-        @stdout_lines = nil
-
-        # Update the final progress line to gray (stopped state)
-        if @progress_message && elapsed_time > 0
-          final_output = @renderer.render_progress("#{@progress_message}… (#{elapsed_time}s)")
-          update_progress_line(final_output)
-        else
-          clear_progress_line
-        end
-      end
-
-      # Non-blocking variant of clear_progress, used by handle_submit so the
-      # user message appears on screen immediately without waiting for the
-      # progress thread to fully exit.
-      #
-      # Strategy:
-      #   1. Snapshot elapsed time and message before touching any state.
-      #   2. Signal the progress thread to stop (sets flag + nulls start time)
-      #      so it will exit on its own next wake-up — no join here.
-      #   3. Immediately render the final (gray) progress line or remove it.
-      #   4. The thread finishes in the background; clear_progress called later
-      #      via the interrupt path is idempotent and will be a no-op.
-      def clear_progress_nonblocking
-        return unless progress_active?
-
-        elapsed_time = @progress_start_time ? (Time.now - @progress_start_time).to_i : 0
-        saved_message = @progress_message
-
-        # Signal thread to stop without joining — it will exit on next loop tick
-        @progress_start_time = nil
-        @stdout_lines = nil
-        @progress_thread_stop = true
-        # Detach: let the thread die on its own; we do NOT join here
-        @progress_thread = nil
-
-        # Immediately update the visual progress line (no waiting)
-        if saved_message && elapsed_time > 0
-          final_output = @renderer.render_progress("#{saved_message}… (#{elapsed_time}s)")
-          update_progress_line(final_output)
-        else
-          clear_progress_line
-        end
-      end
-
       # Stop the fullscreen refresh thread gracefully via flag + join.
       def stop_fullscreen_refresh_thread
         @fullscreen_refresh_stop = true
@@ -609,14 +619,6 @@ module Clacky
         append_output(output)
       end
 
-      # Show idle compression status (two-phase: start → end).
-      # In terminal mode, only the final state is printed.
-      def show_idle_status(phase:, message:)
-        return unless phase.to_s == "end"
-        output = @renderer.render_system_message(message)
-        append_output(output)
-      end
-
       # Show warning message
       # @param message [String] Warning message
       def show_warning(message)
@@ -1082,16 +1084,21 @@ module Clacky
 
       # Handle submit action
       private def handle_submit(data)
-        # If progress is currently active, clear the progress line BEFORE appending
-        # the user message. This avoids a race condition where clear_progress (called
-        # later via the interrupt path) would call update_last_line/remove_last_line
-        # on the user message instead of the progress line.
-        #
-        # We use a non-blocking variant here so that the progress thread's join()
-        # does NOT block the main thread — the user message appears on screen
-        # immediately with no perceptible delay.
+        # If progress is currently active, stop it before appending the user message.
+        # We do this non-blocking (signal thread to stop without joining) so the user
+        # message appears on screen immediately with no perceptible delay.
         if progress_active?
-          clear_progress_nonblocking
+          elapsed_time  = @progress_start_time ? (Time.now - @progress_start_time).to_i : 0
+          saved_message = @progress_message
+          @progress_start_time  = nil
+          @stdout_lines         = nil
+          @progress_thread_stop = true
+          @progress_thread      = nil  # detach; thread exits on its next tick
+          if saved_message && elapsed_time > 0
+            update_progress_line(@renderer.render_progress("#{saved_message}… (#{elapsed_time}s)"))
+          else
+            clear_progress_line
+          end
         end
 
         # Render user message immediately before running agent

data/lib/clacky/ui_interface.rb

@@ -35,7 +35,6 @@ module Clacky
     # phase: "active" | "done"
     # metadata: extensible hash (e.g., {attempt: 3, total: 10} for retries)
     def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
-    def clear_progress; end
 
     # === State updates ===
     def update_sessionbar(tasks: nil, cost: nil, status: nil); end