swarm_cli 2.0.0.pre.1 → 2.0.1

data/lib/swarm_cli/formatters/human_formatter.rb

@@ -2,79 +2,69 @@
 
 module SwarmCLI
   module Formatters
-    # HumanFormatter creates beautiful, detailed real-time output using TTY toolkit.
+    # HumanFormatter creates beautiful, detailed real-time output using reusable UI components.
     # Shows everything: agent thinking, tool calls with arguments, results, responses.
-    # Uses simple dividers for clean, readable output without box alignment issues.
+    # Uses clean component architecture for maintainability and testability.
+    #
+    # Modes:
+    # - :non_interactive - Full headers, task prompt, complete summary (for single execution)
+    # - :interactive - Minimal output for REPL (headers shown in welcome screen)
     class HumanFormatter
-      ICONS = {
-        success: "✓",
-        error: "✗",
-        info: "ℹ",
-        agent: "🤖",
-        tool: "🔧",
-        llm: "🧠",
-        thinking: "💭",
-        response: "💬",
-        cost: "💰",
-        time: "⏱",
-        tokens: "📊",
-        arrow_right: "→",
-        delegate: "📨",
-        result: "📥",
-        bullet: "•",
-        sparkles: "✨",
-        hook: "🪝",
-      }.freeze
-
-      def initialize(output: $stdout, quiet: false, truncate: false, verbose: false)
+      def initialize(output: $stdout, quiet: false, truncate: false, verbose: false, mode: :non_interactive)
         @output = output
         @quiet = quiet
         @truncate = truncate
         @verbose = verbose
-        # Enable colors when output is a TTY (terminal), disable for non-TTY (pipes, files)
-        # This ensures colors work in terminals but don't pollute piped/redirected output
+        @mode = mode
+
+        # Initialize Pastel with TTY detection
         @pastel = Pastel.new(enabled: output.tty?)
-        @llm_request_count = 0
-        @tool_call_count = 0
-        @total_cost = 0.0
-        @total_tokens = 0
-        @agents_seen = Set.new
-        @agent_depth = {}
-        @agent_colors = {}
-        @color_palette = [:cyan, :magenta, :yellow, :blue, :green, :bright_cyan, :bright_magenta]
-        @next_color_index = 0
+
+        # Initialize state managers
+        @color_cache = SwarmCLI::UI::State::AgentColorCache.new
+        @depth_tracker = SwarmCLI::UI::State::DepthTracker.new
+        @usage_tracker = SwarmCLI::UI::State::UsageTracker.new
+        @spinner_manager = SwarmCLI::UI::State::SpinnerManager.new
+
+        # Initialize components
+        @divider = SwarmCLI::UI::Components::Divider.new(pastel: @pastel, terminal_width: TTY::Screen.width)
+        @agent_badge = SwarmCLI::UI::Components::AgentBadge.new(pastel: @pastel, color_cache: @color_cache)
+        @content_block = SwarmCLI::UI::Components::ContentBlock.new(pastel: @pastel)
+        @panel = SwarmCLI::UI::Components::Panel.new(pastel: @pastel)
+
+        # Initialize event renderer
+        @event_renderer = SwarmCLI::UI::Renderers::EventRenderer.new(
+          pastel: @pastel,
+          agent_badge: @agent_badge,
+          depth_tracker: @depth_tracker,
+        )
+
+        # Track last context percentage for warnings
+        @last_context_percentage = {}
+
+        # Start time tracking
         @start_time = nil
-        @terminal_width = TTY::Screen.width
-        @active_spinner = nil
-        @recent_tool_calls = {} # tool_call_id => tool_name
       end
 
       # Called when swarm execution starts
       def on_start(config_path:, swarm_name:, lead_agent:, prompt:)
         @start_time = Time.now
-        print_header(swarm_name, lead_agent)
-        print_prompt(prompt)
-        print_divider
-        @output.puts @pastel.bold("#{ICONS[:info]} Execution Log:")
-        @output.puts
 
-        # Start spinner while waiting for first event
-        lead_color = get_agent_color(lead_agent.to_sym)
-        start_spinner("  ", "#{@pastel.public_send(lead_color, lead_agent)} is processing the request...")
+        # Only show headers in non-interactive mode
+        if @mode == :non_interactive
+          print_header(swarm_name, lead_agent)
+          print_prompt(prompt)
+          @output.puts @divider.full
+          @output.puts @pastel.bold("#{SwarmCLI::UI::Icons::INFO} Execution Log:")
+          @output.puts
+        end
       end
 
       # Called for each log entry from SwarmSDK
       def on_log(entry)
         return if @quiet
 
-        # Clear any active spinner before processing new event
-        clear_spinner
-
         case entry[:type]
-        when "swarm_start"
-          handle_swarm_start(entry)
-        when "swarm_stop"
-          handle_swarm_stop(entry)
         when "user_prompt"
           handle_user_request(entry)
         when "agent_step"
@@ -99,452 +89,422 @@ module SwarmCLI
           handle_compression_completed(entry)
         when "hook_executed"
           handle_hook_executed(entry)
+        when "breakpoint_enter"
+          handle_breakpoint_enter(entry)
+        when "breakpoint_exit"
+          handle_breakpoint_exit(entry)
         end
       end
 
       # Called when swarm execution completes successfully
       def on_success(result:)
-        clear_spinner
-        @output.puts
-        print_divider
+        if @mode == :non_interactive
+          # Full result display with summary
+          @output.puts
+          @output.puts @divider.full
+        end
+
+        # Print result (handles mode internally)
         print_result(result)
-        print_summary(result)
+
+        # Only print summary in non-interactive mode
+        print_summary(result) if @mode == :non_interactive
       end
 
       # Called when swarm execution fails
       def on_error(error:, duration: nil)
-        clear_spinner
         @output.puts
-        print_divider
+        @output.puts @divider.full
         print_error(error)
-        print_divider
+        @output.puts @divider.full
       end
 
       private
 
-      def handle_swarm_start(entry)
-        # SwarmSDK now emits this automatically
-        # The CLI's on_start method already displayed the header, so we skip it here
-        # to avoid duplicate output
-      end
-
-      def handle_swarm_stop(entry)
-        # SwarmSDK now emits this automatically
-        # The CLI's on_success/on_error methods will display the summary,
-        # so we just silently track it here
-      end
-
-      def handle_compression_started(entry)
-        agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        timestamp = format_timestamp(entry[:timestamp])
-
-        message_count = entry[:message_count]
-        estimated_tokens = entry[:estimated_tokens]
-
-        @output.puts
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.yellow("🗜️  CONTEXT COMPRESSION")} #{@pastel.public_send(agent_color, agent)}"
-        @output.puts "#{indent}  #{@pastel.dim("Compressing #{message_count} messages (~#{format_number(estimated_tokens)} tokens)...")}"
-        @output.puts
-
-        # Show spinner while compressing
-        start_spinner("#{indent}  ", "Compacting context...")
-      end
-
-      def handle_compression_completed(entry)
-        agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        timestamp = format_timestamp(entry[:timestamp])
-
-        original_messages = entry[:original_message_count]
-        compressed_messages = entry[:compressed_message_count]
-        messages_removed = entry[:messages_removed]
-
-        original_tokens = entry[:original_tokens]
-        compressed_tokens = entry[:compressed_tokens]
-        compression_ratio = entry[:compression_ratio]
-
-        time_taken = entry[:time_taken]
-
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("✓ COMPRESSION COMPLETE")} #{@pastel.public_send(agent_color, agent)}"
-        @output.puts "#{indent}  #{@pastel.dim("Messages:")} #{original_messages} → #{compressed_messages} #{@pastel.green("(-#{messages_removed})")}"
-        @output.puts "#{indent}  #{@pastel.dim("Tokens:")} #{format_number(original_tokens)} → #{format_number(compressed_tokens)} #{@pastel.green("(#{(compression_ratio * 100).round(1)}%)")}"
-        @output.puts "#{indent}  #{@pastel.dim("Time taken:")} #{format_duration(time_taken)}"
-        @output.puts
-      end
-
       def handle_user_request(entry)
         agent = entry[:agent]
-        @agents_seen.add(agent)
-        @llm_request_count += 1
+        @usage_tracker.track_agent(agent)
+        @usage_tracker.track_llm_request(entry[:usage])
 
-        @agent_depth[agent] ||= calculate_depth(agent)
-        indent = "  " * @agent_depth[agent]
-        agent_color = get_agent_color(agent)
+        # Stop any delegation waiting spinner (in case this agent was delegated to)
+        unless @quiet
+          delegation_spinner = "delegation_#{agent}".to_sym
+          @spinner_manager.stop(delegation_spinner) if @spinner_manager.active?(delegation_spinner)
+        end
 
-        timestamp = format_timestamp(entry[:timestamp])
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, "#{ICONS[:thinking]} #{agent}")} #{@pastel.dim("(#{entry[:model]})")}"
+        # Render agent thinking line
+        @output.puts @event_renderer.agent_thinking(
+          agent: agent,
+          model: entry[:model],
+          timestamp: entry[:timestamp],
+        )
 
-        # Show actual tools (non-delegation)
+        # Show tools available
         if entry[:tools]&.any?
-          tools_list = entry[:tools].join(", ")
-          @output.puts "#{indent}  #{@pastel.dim("Tools available: #{tools_list}")}"
+          @output.puts @event_renderer.tools_available(entry[:tools], indent: @depth_tracker.get(agent))
         end
 
-        # Show agents this agent can delegate to
+        # Show delegation options
         if entry[:delegates_to]&.any?
-          delegates_list = entry[:delegates_to].map do |delegate_name|
-            delegate_color = get_agent_color(delegate_name.to_sym)
-            @pastel.public_send(delegate_color, delegate_name)
-          end.join(", ")
-          @output.puts "#{indent}  #{@pastel.dim("Can delegate to:")} #{delegates_list}"
+          @output.puts @event_renderer.delegates_to(
+            entry[:delegates_to],
+            indent: @depth_tracker.get(agent),
+            color_cache: @color_cache,
+          )
         end
 
-        # Show spinner while waiting for response
-        start_spinner("#{indent}  ", "#{@pastel.public_send(agent_color, agent)} is thinking...")
+        @output.puts
+
+        # Start spinner for agent thinking
+        unless @quiet
+          spinner_key = "agent_#{agent}".to_sym
+          @spinner_manager.start(spinner_key, "#{agent} is thinking...")
+        end
       end
 
       def handle_agent_step(entry)
-        # Agent made an intermediate response with tool calls
         agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        get_agent_color(agent)
+        indent_level = @depth_tracker.get(agent)
+
+        # Stop agent thinking spinner
+        unless @quiet
+          spinner_key = "agent_#{agent}".to_sym
+          @spinner_manager.stop(spinner_key)
+        end
 
-        # Track usage for this LLM API call
+        # Track usage
         if entry[:usage]
-          cost = entry[:usage][:total_cost] || 0.0
-          tokens = entry[:usage][:total_tokens] || 0
-          @total_cost += cost
-          @total_tokens += tokens
-
-          # Build usage text with per-turn tokens and cost
-          usage_parts = ["#{format_number(tokens)} tokens", format_cost(cost)]
-
-          # Add context usage if available (cumulative tracking)
-          if entry[:usage][:tokens_used_percentage]
-            usage_percentage = entry[:usage][:tokens_used_percentage]
-            tokens_remaining = entry[:usage][:tokens_remaining]
-
-            # Color code the percentage based on usage
-            percentage_display = format_context_percentage(usage_percentage)
-
-            if tokens_remaining
-              remaining_display = format_number(tokens_remaining)
-              usage_parts << "#{percentage_display} used, #{remaining_display} remaining"
-            else
-              # Context limit not available for this model
-              cumulative = entry[:usage][:cumulative_total_tokens]
-              usage_parts << "#{format_number(cumulative)} cumulative" if cumulative
-            end
-          end
+          @usage_tracker.track_llm_request(entry[:usage])
+          @last_context_percentage[agent] = entry[:usage][:tokens_used_percentage]
 
-          usage_text = usage_parts.join(" #{@pastel.dim("│")} ")
-          @output.puts "#{indent}  #{@pastel.dim(usage_text)}"
+          # Render usage stats
+          @output.puts @event_renderer.usage_stats(
+            tokens: entry[:usage][:total_tokens] || 0,
+            cost: entry[:usage][:total_cost] || 0.0,
+            context_pct: entry[:usage][:tokens_used_percentage],
+            remaining: entry[:usage][:tokens_remaining],
+            cumulative: entry[:usage][:cumulative_total_tokens],
+            indent: indent_level,
+          )
         end
 
-        # Display the agent's thinking/explanation text if present
+        # Display thinking text (if present)
         if entry[:content] && !entry[:content].empty?
-          # Filter out system reminders for cleaner display
-          thinking_text = strip_system_reminders(entry[:content])
-
-          unless thinking_text.empty?
-            @output.puts
-            # Display thinking text in italic for visual distinction
-            thinking_text.split("\n").each do |line|
-              @output.puts "#{indent}  #{@pastel.italic(line)}"
-            end
-          end
+          thinking = @event_renderer.thinking_text(entry[:content], indent: indent_level)
+          @output.puts thinking unless thinking.empty?
+          @output.puts if thinking && !thinking.empty?
         end
 
-        # Show what the agent is doing (requesting tools)
+        # Show tool request summary
         tool_count = entry[:tool_calls]&.size || 0
         if tool_count > 0
+          indent = @depth_tracker.indent(agent)
           @output.puts "#{indent}  #{@pastel.dim("→ Requesting #{tool_count} tool#{"s" if tool_count > 1}...")}"
         end
 
         @output.puts
-        print_event_divider
+        @output.puts @divider.event(indent: indent_level)
       end
 
       def handle_agent_stop(entry)
-        # Agent completed with final response (no more tool calls)
         agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        depth = @agent_depth[agent] || 0
-
-        # Track usage for this final LLM API call
-        if entry[:usage]
-          cost = entry[:usage][:total_cost] || 0.0
-          tokens = entry[:usage][:total_tokens] || 0
-          @total_cost += cost
-          @total_tokens += tokens
-
-          # Build usage text with per-turn tokens and cost
-          usage_parts = ["#{format_number(tokens)} tokens", format_cost(cost)]
-
-          # Add context usage if available (cumulative tracking)
-          if entry[:usage][:tokens_used_percentage]
-            usage_percentage = entry[:usage][:tokens_used_percentage]
-            tokens_remaining = entry[:usage][:tokens_remaining]
-
-            # Color code the percentage based on usage
-            percentage_display = format_context_percentage(usage_percentage)
-
-            if tokens_remaining
-              remaining_display = format_number(tokens_remaining)
-              usage_parts << "#{percentage_display} used, #{remaining_display} remaining"
-            else
-              # Context limit not available for this model
-              cumulative = entry[:usage][:cumulative_total_tokens]
-              usage_parts << "#{format_number(cumulative)} cumulative" if cumulative
-            end
-          end
+        indent_level = @depth_tracker.get(agent)
 
-          usage_text = usage_parts.join(" #{@pastel.dim("│")} ")
-          @output.puts "#{indent}  #{@pastel.dim(usage_text)}"
+        # Stop agent thinking spinner with success
+        unless @quiet
+          spinner_key = "agent_#{agent}".to_sym
+          @spinner_manager.success(spinner_key, "completed")
         end
 
-        # Display final response
-        # Skip displaying content if this is a delegated agent (depth > 0)
-        # The content will be shown as a delegation_result to avoid duplication
-        if entry[:content] && !entry[:content].empty? && depth == 0
-          timestamp = format_timestamp(entry[:timestamp])
-          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, "#{ICONS[:response]} #{agent}")} responded:"
-          display_response(entry[:content], indent)
+        # Track usage
+        if entry[:usage]
+          @usage_tracker.track_llm_request(entry[:usage])
+          @last_context_percentage[agent] = entry[:usage][:tokens_used_percentage]
+
+          # Render usage stats
+          @output.puts @event_renderer.usage_stats(
+            tokens: entry[:usage][:total_tokens] || 0,
+            cost: entry[:usage][:total_cost] || 0.0,
+            context_pct: entry[:usage][:tokens_used_percentage],
+            remaining: entry[:usage][:tokens_remaining],
+            cumulative: entry[:usage][:cumulative_total_tokens],
+            indent: indent_level,
+          )
+        end
+
+        # Display final response (only for top-level agent in non-interactive mode)
+        # In interactive mode, response is shown by print_result to avoid duplication
+        if entry[:content] && !entry[:content].empty? && indent_level.zero? && @mode == :non_interactive
+          @output.puts @event_renderer.agent_response(
+            agent: agent,
+            timestamp: entry[:timestamp],
+          )
+
+          # Render response content
+          indent = @depth_tracker.indent(agent)
+          response_lines = entry[:content].split("\n")
+
+          if @truncate && response_lines.length > 12
+            response_lines.first(12).each { |line| @output.puts "#{indent}  #{line}" }
+            @output.puts "#{indent}  #{@pastel.dim("... (#{response_lines.length - 12} more lines)")}"
+          else
+            response_lines.each { |line| @output.puts "#{indent}  #{line}" }
+          end
         end
 
         @output.puts
-        @output.puts "#{indent}#{@pastel.green("#{ICONS[:success]} #{agent} completed")}"
-
+        @output.puts @event_renderer.agent_completed(agent: agent)
         @output.puts
-        print_event_divider
+        @output.puts @divider.event(indent: indent_level)
       end
 
       def handle_tool_call(entry)
-        @tool_call_count += 1
-        # Display tool call (non-delegation)
         agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
+        @usage_tracker.track_tool_call(tool_call_id: entry[:tool_call_id], tool_name: entry[:tool])
 
-        timestamp = format_timestamp(entry[:timestamp])
-        tool_name = entry[:tool]
-        tool_call_id = entry[:tool_call_id]
-        args = entry[:arguments]
-
-        # Track this tool call for later matching with results
-        @recent_tool_calls[tool_call_id] = tool_name if tool_call_id
+        # Render tool call event
+        @output.puts @event_renderer.tool_call(
+          agent: agent,
+          tool: entry[:tool],
+          timestamp: entry[:timestamp],
+        )
 
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, agent)} #{@pastel.blue("#{ICONS[:tool]} uses tool")} #{@pastel.bold.blue(tool_name)}"
-
-        # Show arguments (skip for TodoWrite unless verbose mode)
+        # Show arguments (skip TodoWrite unless verbose)
+        args = entry[:arguments]
         show_args = args && !args.empty?
-        show_args &&= tool_name != "TodoWrite" || @verbose
+        show_args &&= entry[:tool] != "TodoWrite" || @verbose
 
         if show_args
-          @output.puts "#{indent}  #{@pastel.dim("Arguments:")}"
-          args.each do |key, value|
-            formatted_value = format_argument_value(value)
-            @output.puts "#{indent}    #{@pastel.cyan("#{key}:")} #{formatted_value}"
-          end
+          @output.puts @event_renderer.tool_arguments(
+            args,
+            indent: @depth_tracker.get(agent),
+            truncate: @truncate,
+          )
         end
 
         @output.puts
 
-        # Show spinner while waiting for tool to execute
-        start_spinner("#{indent}  ", "Executing #{@pastel.bold.blue(tool_name)}...")
+        # Start spinner for tool execution
+        unless @quiet || entry[:tool] == "TodoWrite"
+          spinner_key = "tool_#{entry[:tool_call_id]}".to_sym
+          @spinner_manager.start(spinner_key, "Executing #{entry[:tool]}...")
+        end
       end
 
-      def handle_agent_delegation(entry)
-        @tool_call_count += 1
-        # Display delegation to another agent
+      def handle_tool_result(entry)
         agent = entry[:agent]
-        delegate_to = entry[:delegate_to]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        delegate_color = get_agent_color(delegate_to.to_sym)
+        tool_name = entry[:tool] || @usage_tracker.tool_name_for(entry[:tool_call_id])
 
-        timestamp = format_timestamp(entry[:timestamp])
-        args = entry[:arguments]
-
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, agent)} #{@pastel.yellow("#{ICONS[:delegate]} delegates to")} #{@pastel.public_send(delegate_color, delegate_to)}"
-        @output.puts
+        # Stop tool spinner with success
+        unless @quiet || tool_name == "TodoWrite"
+          spinner_key = "tool_#{entry[:tool_call_id]}".to_sym
+          @spinner_manager.success(spinner_key, "completed")
+        end
 
-        if args && !args.empty?
-          @output.puts "#{indent}  #{@pastel.dim("Arguments:")}"
-          args.each do |key, value|
-            formatted_value = format_argument_value(value)
-            @output.puts "#{indent}    #{@pastel.cyan("#{key}:")} #{formatted_value}"
+        # Special handling for TodoWrite
+        if tool_name == "TodoWrite"
+          display_todo_list(agent, entry[:timestamp])
+        else
+          @output.puts @event_renderer.tool_result(
+            agent: agent,
+            timestamp: entry[:timestamp],
+            tool: tool_name,
+          )
+
+          # Render result content
+          if entry[:result].is_a?(String) && !entry[:result].empty?
+            result_text = @event_renderer.tool_result_content(
+              entry[:result],
+              indent: @depth_tracker.get(agent),
+              truncate: !@verbose,
+            )
+            @output.puts result_text unless result_text.empty?
           end
         end
 
         @output.puts
+        @output.puts @divider.event(indent: @depth_tracker.get(agent))
 
-        # Show spinner while waiting for delegated agent to respond
-        start_spinner("  #{indent}  ", "Waiting for #{@pastel.public_send(delegate_color, delegate_to)}...")
+        # Start spinner for agent processing tool result
+        # The agent will determine what to do next (more tools or finish)
+        # This spinner will be stopped by the next agent_step or agent_stop event
+        unless @quiet
+          spinner_key = "agent_#{agent}".to_sym
+          indent = @depth_tracker.indent(agent)
+          @spinner_manager.start(spinner_key, "#{indent}#{agent} is processing...")
+        end
       end
 
-      def handle_tool_result(entry)
-        agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        tool_name = entry[:tool] || extract_tool_from_entry(entry)
-
-        timestamp = format_timestamp(entry[:timestamp])
+      def handle_agent_delegation(entry)
+        @usage_tracker.track_tool_call
 
-        # Check if this is a TodoWrite tool result - if so, show formatted todo list
-        if tool_name == "TodoWrite"
-          display_todo_list(agent, indent, timestamp)
-        else
-          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("#{ICONS[:result]} Tool result")} received by #{agent}"
+        @output.puts @event_renderer.delegation(
+          from: entry[:agent],
+          to: entry[:delegate_to],
+          timestamp: entry[:timestamp],
+        )
+        @output.puts
 
-          result_text = entry[:result]
-          if result_text.is_a?(String) && !result_text.empty?
-            display_result(result_text, indent)
-          end
+        # Show arguments if present
+        if entry[:arguments] && !entry[:arguments].empty?
+          @output.puts @event_renderer.tool_arguments(
+            entry[:arguments],
+            indent: @depth_tracker.get(entry[:agent]),
+            truncate: @truncate,
+          )
         end
 
         @output.puts
-        print_event_divider
 
-        # Show spinner while agent processes the result
-        start_spinner("#{indent}  ", "#{@pastel.public_send(agent_color, agent)} processing tool result...")
+        # Start spinner waiting for delegated agent
+        unless @quiet
+          spinner_key = "delegation_#{entry[:delegate_to]}".to_sym
+          indent = @depth_tracker.indent(entry[:agent])
+          @spinner_manager.start(spinner_key, "#{indent}Waiting for #{entry[:delegate_to]}...")
+        end
       end
 
       def handle_delegation_result(entry)
-        agent = entry[:agent]
-        delegate_from = entry[:delegate_from]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-
-        timestamp = format_timestamp(entry[:timestamp])
-
-        # Show who sent the result to whom
-        if delegate_from
-          delegate_color = get_agent_color(delegate_from.to_sym)
-          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("#{ICONS[:result]} Delegation result")} from #{@pastel.public_send(delegate_color, delegate_from)} #{@pastel.dim("→")} #{@pastel.public_send(agent_color, agent)}"
-        else
-          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("#{ICONS[:result]} Delegation result")} received by #{@pastel.public_send(agent_color, agent)}"
-        end
-
-        result_text = entry[:result]
-        if result_text.is_a?(String) && !result_text.empty?
-          display_result(result_text, indent)
+        @output.puts @event_renderer.delegation_result(
+          from: entry[:delegate_from],
+          to: entry[:agent],
+          timestamp: entry[:timestamp],
+        )
+
+        # Render result content
+        if entry[:result].is_a?(String) && !entry[:result].empty?
+          result_text = @event_renderer.tool_result_content(
+            entry[:result],
+            indent: @depth_tracker.get(entry[:agent]),
+            truncate: !@verbose,
+          )
+          @output.puts result_text unless result_text.empty?
         end
 
         @output.puts
-        print_event_divider
+        @output.puts @divider.event(indent: @depth_tracker.get(entry[:agent]))
 
-        # Show spinner while agent processes the delegation result
-        start_spinner("#{indent}  ", "#{@pastel.public_send(agent_color, agent)} processing result from #{@pastel.public_send(delegate_color, delegate_from)}...")
+        # Start spinner for agent processing delegation result
+        unless @quiet
+          spinner_key = "agent_#{entry[:agent]}".to_sym
+          indent = @depth_tracker.indent(entry[:agent])
+          @spinner_manager.start(spinner_key, "#{indent}#{entry[:agent]} is processing...")
+        end
       end
 
       def handle_context_warning(entry)
         agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        timestamp = format_timestamp(entry[:timestamp])
-
         threshold = entry[:threshold]
         current_usage = entry[:current_usage]
         tokens_remaining = entry[:tokens_remaining]
 
-        # Color code based on threshold
-        warning_color = threshold == "90%" ? :red : :yellow
-        icon = threshold == "90%" ? "⚠️" : "⚡"
+        # Determine warning severity
+        type = threshold == "90%" ? :error : :warning
 
-        @output.puts
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(warning_color, "#{icon} CONTEXT WARNING")} #{@pastel.public_send(agent_color, agent)}"
-        @output.puts "#{indent}  #{@pastel.public_send(warning_color, "Context usage: #{current_usage} (threshold: #{threshold})")}"
-        @output.puts "#{indent}  #{@pastel.dim("Tokens remaining: #{format_number(tokens_remaining)}")}"
-        @output.puts
+        @output.puts @panel.render(
+          type: type,
+          title: "CONTEXT WARNING #{@agent_badge.render(agent)}",
+          lines: [
+            @pastel.public_send((type == :error ? :red : :yellow), "Context usage: #{current_usage} (threshold: #{threshold})"),
+            @pastel.dim("Tokens remaining: #{SwarmCLI::UI::Formatters::Number.format(tokens_remaining)}"),
+          ],
+          indent: @depth_tracker.get(agent),
+        )
       end
 
       def handle_model_lookup_warning(entry)
         agent = entry[:agent]
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = get_agent_color(agent)
-        timestamp = format_timestamp(entry[:timestamp])
-
         model = entry[:model]
         error_message = entry[:error_message]
         suggestions = entry[:suggestions] || []
 
-        @output.puts
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.yellow("⚠️  MODEL WARNING")} #{@pastel.public_send(agent_color, agent)}"
-        @output.puts "#{indent}  #{@pastel.yellow("Model '#{model}' not found in registry")}"
+        lines = [
+          @pastel.yellow("Model '#{model}' not found in registry"),
+        ]
 
         if suggestions.any?
-          @output.puts "#{indent}  #{@pastel.dim("Did you mean one of these?")}"
+          lines << @pastel.dim("Did you mean one of these?")
           suggestions.each do |suggestion|
             model_id = suggestion[:id] || suggestion["id"]
             context = suggestion[:context_window] || suggestion["context_window"]
-            context_display = context ? " (#{format_number(context)} tokens)" : ""
-            @output.puts "#{indent}    #{@pastel.cyan("•")} #{@pastel.white(model_id)}#{@pastel.dim(context_display)}"
+            context_display = context ? " (#{SwarmCLI::UI::Formatters::Number.format(context)} tokens)" : ""
+            lines << "  #{@pastel.cyan("•")} #{@pastel.white(model_id)}#{@pastel.dim(context_display)}"
           end
         else
-          @output.puts "#{indent}  #{@pastel.dim("Error: #{error_message}")}"
+          lines << @pastel.dim("Error: #{error_message}")
         end
 
-        @output.puts "#{indent}  #{@pastel.dim("Context tracking unavailable for this model.")}"
-        @output.puts
+        lines << @pastel.dim("Context tracking unavailable for this model.")
+
+        @output.puts @panel.render(
+          type: :warning,
+          title: "MODEL WARNING #{@agent_badge.render(agent)}",
+          lines: lines,
+          indent: 0, # Always at root level (warnings shown at boot, not during execution)
+        )
+      end
+
+      def handle_compression_started(entry)
+        agent = entry[:agent]
+        message_count = entry[:message_count]
+        estimated_tokens = entry[:estimated_tokens]
+
+        @output.puts @panel.render(
+          type: :info,
+          title: "CONTEXT COMPRESSION #{@agent_badge.render(agent)}",
+          lines: [
+            @pastel.dim("Compressing #{message_count} messages (~#{SwarmCLI::UI::Formatters::Number.format(estimated_tokens)} tokens)..."),
+          ],
+          indent: @depth_tracker.get(agent),
+        )
+      end
+
+      def handle_compression_completed(entry)
+        agent = entry[:agent]
+        original_messages = entry[:original_message_count]
+        compressed_messages = entry[:compressed_message_count]
+        messages_removed = entry[:messages_removed]
+        original_tokens = entry[:original_tokens]
+        compressed_tokens = entry[:compressed_tokens]
+        compression_ratio = entry[:compression_ratio]
+        time_taken = entry[:time_taken]
+
+        @output.puts @panel.render(
+          type: :success,
+          title: "COMPRESSION COMPLETE #{@agent_badge.render(agent)}",
+          lines: [
+            "#{@pastel.dim("Messages:")} #{original_messages} → #{compressed_messages} #{@pastel.green("(-#{messages_removed})")}",
+            "#{@pastel.dim("Tokens:")} #{SwarmCLI::UI::Formatters::Number.format(original_tokens)} → #{SwarmCLI::UI::Formatters::Number.format(compressed_tokens)} #{@pastel.green("(#{(compression_ratio * 100).round(1)}%)")}",
+            "#{@pastel.dim("Time taken:")} #{SwarmCLI::UI::Formatters::Time.duration(time_taken)}",
+          ],
+          indent: @depth_tracker.get(agent),
+        )
       end
 
       def handle_hook_executed(entry)
         hook_event = entry[:hook_event]
         agent = entry[:agent]
-        command = entry[:command]
-        exit_code = entry[:exit_code]
         success = entry[:success]
-        stderr = entry[:stderr]
         blocked = entry[:blocked]
+        stderr = entry[:stderr]
+        exit_code = entry[:exit_code]
 
-        indent = "  " * (@agent_depth[agent] || 0)
-        agent_color = agent ? get_agent_color(agent.to_sym) : :white
-        timestamp = format_timestamp(entry[:timestamp])
-
-        # Determine hook display color and status
-        if blocked
-          # Exit code 2 - blocked execution
-          status_color = :red
-          ICONS[:error]
-          status_text = "BLOCKED"
-        elsif success
-          # Exit code 0 - success
-          status_color = :green
-          ICONS[:success]
-          status_text = "executed"
-        else
-          # Other exit codes - non-blocking error
-          status_color = :yellow
-          status_text = "warning"
-        end
-
-        # Format hook event name
-        hook_display = @pastel.cyan(hook_event || "unknown")
-
-        # Show hook execution
-        agent_display = agent ? @pastel.public_send(agent_color, agent) : ""
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(status_color, "#{ICONS[:hook]} Hook #{status_text}")} #{hook_display} #{agent_display}"
-
-        # Show command if verbose mode
-        if @verbose
-          @output.puts "#{indent}  #{@pastel.dim("Command:")} #{@pastel.dim(command)}"
-        end
+        @output.puts @event_renderer.hook_executed(
+          hook_event: hook_event,
+          agent: agent,
+          timestamp: entry[:timestamp],
+          success: success,
+          blocked: blocked,
+        )
 
-        # Show stderr if present (errors or messages)
-        # For user_prompt blocks, show prominently since prompt was erased
+        # Show stderr if present
         if stderr && !stderr.empty?
+          indent = @depth_tracker.indent(agent)
+
           if blocked && hook_event == "user_prompt"
-            # User prompt was blocked - show prominently to user
             @output.puts
             @output.puts "#{indent}  #{@pastel.bold.red("⛔ Prompt Blocked by Hook:")}"
-            stderr.lines.each do |line|
-              @output.puts "#{indent}  #{@pastel.red(line.chomp)}"
-            end
+            stderr.lines.each { |line| @output.puts "#{indent}  #{@pastel.red(line.chomp)}" }
             @output.puts "#{indent}  #{@pastel.dim("(Prompt was not sent to the agent)")}"
           elsif blocked
             @output.puts "#{indent}  #{@pastel.red("Blocked:")} #{@pastel.red(stderr)}"
@@ -555,7 +515,8 @@ module SwarmCLI
 
         # Show exit code in verbose mode
         if @verbose && exit_code
-          code_color = if exit_code == 0
+          indent = @depth_tracker.indent(agent)
+          code_color = if exit_code.zero?
             :green
           else
             (exit_code == 2 ? :red : :yellow)
@@ -564,49 +525,43 @@ module SwarmCLI
         end
 
         @output.puts
-
-        # Show spinner after hook execution so user knows agent is processing
-        # Skip spinner for user_prompt blocks (prompt was erased, execution stops)
-        if agent && !(blocked && hook_event == "user_prompt")
-          agent_display = @pastel.public_send(agent_color, agent)
-          if blocked
-            start_spinner("#{indent}  ", "#{agent_display} adapting to blocked operation...")
-          else
-            start_spinner("#{indent}  ", "#{agent_display} processing hook result...")
-          end
-        end
       end
 
-      def display_result(content, indent)
-        # Filter out system reminders unless verbose mode is enabled
-        filtered_content = @verbose ? content : strip_system_reminders(content)
+      def handle_breakpoint_enter(entry)
+        agent = entry[:agent]
+        event = entry[:event]
 
-        lines = filtered_content.split("\n")
+        # Pause all spinners to allow clean interactive debugging
+        @spinner_manager.pause_all
 
-        # Truncate based on verbose flag
-        display_lines = if @verbose
-          # Verbose mode: show everything
-          lines
-        else
-          # Non-verbose mode: truncate to first 2 lines and 300 chars
-          truncate_tool_result(lines, filtered_content)
-        end
+        # Show debugging notice
+        @output.puts
+        @output.puts @pastel.yellow("#{SwarmCLI::UI::Icons::THINKING} Breakpoint: Entering interactive debugging (#{event} hook)")
+        @output.puts @pastel.dim("  Agent: #{agent}")
+        @output.puts @pastel.dim("  Type 'exit' to continue execution")
+        @output.puts
+      end
 
-        display_lines.each do |line|
-          @output.puts "#{indent}  #{@pastel.bright_green(line)}"
-        end
+      def handle_breakpoint_exit(entry)
+        # Resume all spinners after debugging
+        @spinner_manager.resume_all
+
+        @output.puts
+        @output.puts @pastel.green("#{SwarmCLI::UI::Icons::SUCCESS} Breakpoint: Resuming execution")
+        @output.puts
       end
 
-      def display_todo_list(agent, indent, timestamp)
-        # Get the current todos from TodoManager
+      def display_todo_list(agent, timestamp)
         todos = SwarmSDK::Tools::Stores::TodoManager.get_todos(agent.to_sym)
+        indent = @depth_tracker.indent(agent)
+        time = SwarmCLI::UI::Formatters::Time.timestamp(timestamp)
 
         if todos.empty?
-          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.cyan("#{ICONS[:bullet]} Todo list")} updated (empty)"
+          @output.puts "#{indent}#{@pastel.dim(time)} #{@pastel.cyan("#{SwarmCLI::UI::Icons::BULLET} Todo list")} updated (empty)"
           return
         end
 
-        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.cyan("#{ICONS[:bullet]} Todo list")} updated:"
+        @output.puts "#{indent}#{@pastel.dim(time)} #{@pastel.cyan("#{SwarmCLI::UI::Icons::BULLET} Todo list")} updated:"
         @output.puts
 
         todos.each_with_index do |todo, index|
@@ -614,129 +569,41 @@ module SwarmCLI
           content = todo[:content] || todo["content"]
           num = index + 1
 
-          # Format based on status
-          case status
+          line = case status
           when "completed"
-            # Strikethrough for completed - use dim and strikethrough
-            @output.puts "#{indent}  #{@pastel.dim("#{num}.")} #{@pastel.dim.strikethrough(content)}"
+            "#{indent}  #{@pastel.dim("#{num}.")} #{@pastel.dim.strikethrough(content)}"
           when "in_progress"
-            # Bold for in progress items
-            @output.puts "#{indent}  #{@pastel.bold.yellow("#{num}.")} #{@pastel.bold(content)}"
+            "#{indent}  #{@pastel.bold.yellow("#{num}.")} #{@pastel.bold(content)}"
           when "pending"
-            # Regular for pending
-            @output.puts "#{indent}  #{@pastel.white("#{num}.")} #{content}"
+            "#{indent}  #{@pastel.white("#{num}.")} #{content}"
           else
-            # Fallback
-            @output.puts "#{indent}  #{num}. #{content}"
+            "#{indent}  #{num}. #{content}"
           end
-        end
-      end
-
-      def extract_tool_from_entry(entry)
-        # Try to extract tool name from the entry
-        # First check if it has :tool directly
-        return entry[:tool] if entry[:tool]
-
-        # Otherwise look up from tool_call_id
-        tool_call_id = entry[:tool_call_id]
-        return unless tool_call_id
-
-        @recent_tool_calls[tool_call_id]
-      end
-
-      def display_response(content, indent)
-        lines = content.split("\n")
 
-        # Only truncate if flag is enabled
-        display_lines = if @truncate
-          if lines.length > 12
-            lines.first(12) + ["", @pastel.dim("... (#{lines.length - 12} more lines)")]
-          elsif content.length > 500
-            [content[0..500], "", @pastel.dim("... (#{content.length} total chars)")]
-          else
-            lines
-          end
-        else
-          lines
-        end
-
-        display_lines.each do |line|
-          @output.puts "#{indent}  #{line}"
-        end
-      end
-
-      def format_argument_value(value)
-        case value
-        when String
-          if @truncate && value.length > 300
-            lines = value.split("\n")
-            if lines.length > 3
-              preview = lines.first(3).join("\n")
-              "#{@pastel.white(preview)}\n#{@pastel.dim("        ... (#{lines.length} lines, #{value.length} chars)")}"
-            else
-              preview = value[0..300]
-              "#{@pastel.white(preview)}\n#{@pastel.dim("        ... (#{value.length} chars)")}"
-            end
-          else
-            @pastel.white(value)
-          end
-        when Array
-          @pastel.dim("[#{value.join(", ")}]")
-        when Hash
-          formatted = value.map { |k, v| "#{k}: #{v}" }.join(", ")
-          @pastel.dim("{#{formatted}}")
-        when Numeric
-          @pastel.white(value.to_s)
-        when TrueClass, FalseClass
-          @pastel.white(value.to_s)
-        when NilClass
-          @pastel.dim("nil")
-        else
-          @pastel.white(value.to_s)
-        end
-      end
-
-      def calculate_depth(agent)
-        @agents_seen.size == 1 ? 0 : 1
-      end
-
-      def get_agent_color(agent)
-        @agent_colors[agent] ||= begin
-          color = @color_palette[@next_color_index % @color_palette.length]
-          @next_color_index += 1
-          color
+          @output.puts line
         end
       end
 
       def print_header(swarm_name, lead_agent)
         @output.puts
-        @output.puts @pastel.bold.bright_cyan("#{ICONS[:sparkles]} SwarmSDK - AI Agent Orchestration #{ICONS[:sparkles]}")
-        print_divider
+        @output.puts @pastel.bold.bright_cyan("#{SwarmCLI::UI::Icons::SPARKLES} SwarmSDK - AI Agent Orchestration #{SwarmCLI::UI::Icons::SPARKLES}")
+        @output.puts @divider.full
         @output.puts "#{@pastel.bold("Swarm:")} #{@pastel.cyan(swarm_name)}"
         @output.puts "#{@pastel.bold("Lead Agent:")} #{@pastel.cyan(lead_agent)}"
         @output.puts
       end
 
       def print_prompt(prompt)
-        @output.puts @pastel.bold("#{ICONS[:thinking]} Task Prompt:")
+        @output.puts @pastel.bold("#{SwarmCLI::UI::Icons::THINKING} Task Prompt:")
         @output.puts @pastel.bright_white(prompt)
         @output.puts
       end
 
-      def print_divider
-        @output.puts @pastel.dim("─" * @terminal_width)
-      end
-
       def print_result(result)
-        @output.puts
-        @output.puts @pastel.bold.green("#{ICONS[:success]} Execution Complete")
-        @output.puts
-
-        if result.content && !result.content.empty?
-          @output.puts @pastel.bold("#{ICONS[:response]} Final Response from #{@pastel.public_send(get_agent_color(result.agent.to_sym), result.agent)}:")
-          @output.puts
-          print_divider
+        return unless result.content && !result.content.empty?
 
+        # Interactive mode: Just show the response content directly
+        if @mode == :interactive
           # Render markdown if content looks like markdown
           content_to_display = if looks_like_markdown?(result.content)
             begin
@@ -749,164 +616,72 @@ module SwarmCLI
           end
 
           @output.puts content_to_display
-          print_divider
           @output.puts
+          return
         end
+
+        # Non-interactive mode: Full result display with header and dividers
+        @output.puts
+        @output.puts @pastel.bold.green("#{SwarmCLI::UI::Icons::SUCCESS} Execution Complete")
+        @output.puts
+        @output.puts @pastel.bold("#{SwarmCLI::UI::Icons::RESPONSE} Final Response from #{@agent_badge.render(result.agent)}:")
+        @output.puts
+        @output.puts @divider.full
+
+        # Render markdown if content looks like markdown
+        content_to_display = if looks_like_markdown?(result.content)
+          begin
+            TTY::Markdown.parse(result.content)
+          rescue StandardError
+            result.content
+          end
+        else
+          result.content
+        end
+
+        @output.puts content_to_display
+        @output.puts @divider.full
+        @output.puts
       end
 
       def print_summary(result)
-        @output.puts @pastel.bold("#{ICONS[:info]} Execution Summary:")
+        @output.puts @pastel.bold("#{SwarmCLI::UI::Icons::INFO} Execution Summary:")
         @output.puts
 
-        # Agent involvement with colors
-        agents_display = @agents_seen.map do |agent|
-          color = get_agent_color(agent)
-          @pastel.public_send(color, agent)
-        end.join(", ")
+        # Agents used (colored list)
+        agents_display = @agent_badge.render_list(@usage_tracker.agents)
+        @output.puts "  #{SwarmCLI::UI::Icons::AGENT} #{@pastel.bold("Agents used:")} #{agents_display}"
 
-        @output.puts "  #{ICONS[:agent]} #{@pastel.bold("Agents used:")} #{agents_display}"
-        @output.puts "  #{ICONS[:llm]} #{@pastel.bold("LLM Requests:")} #{result.llm_requests}"
-        @output.puts "  #{ICONS[:tool]} #{@pastel.bold("Tool Calls:")} #{result.tool_calls_count}"
-        @output.puts "  #{ICONS[:tokens]} #{@pastel.bold("Total Tokens:")} #{format_number(result.total_tokens)}"
-        @output.puts "  #{ICONS[:cost]} #{@pastel.bold("Total Cost:")} #{format_cost(result.total_cost)}"
-        @output.puts "  #{ICONS[:time]} #{@pastel.bold("Duration:")} #{format_duration(result.duration)}"
+        # Metrics
+        @output.puts "  #{SwarmCLI::UI::Icons::LLM} #{@pastel.bold("LLM Requests:")} #{result.llm_requests}"
+        @output.puts "  #{SwarmCLI::UI::Icons::TOOL} #{@pastel.bold("Tool Calls:")} #{result.tool_calls_count}"
+        @output.puts "  #{SwarmCLI::UI::Icons::TOKENS} #{@pastel.bold("Total Tokens:")} #{SwarmCLI::UI::Formatters::Number.format(result.total_tokens)}"
+        @output.puts "  #{SwarmCLI::UI::Icons::COST} #{@pastel.bold("Total Cost:")} #{SwarmCLI::UI::Formatters::Cost.format(result.total_cost, pastel: @pastel)}"
+        @output.puts "  #{SwarmCLI::UI::Icons::TIME} #{@pastel.bold("Duration:")} #{SwarmCLI::UI::Formatters::Time.duration(result.duration)}"
 
         @output.puts
       end
 
       def print_error(error)
         @output.puts
-        @output.puts @pastel.bold.red("#{ICONS[:error]} Execution Failed")
+        @output.puts @pastel.bold.red("#{SwarmCLI::UI::Icons::ERROR} Execution Failed")
         @output.puts
         @output.puts @pastel.red("Error: #{error.class.name}")
         @output.puts @pastel.red(error.message)
         @output.puts
 
-        if error.backtrace
-          @output.puts @pastel.dim("Backtrace:")
-          error.backtrace.first(5).each do |line|
-            @output.puts @pastel.dim("  #{line}")
-          end
-          @output.puts
+        return unless error.backtrace
+
+        @output.puts @pastel.dim("Backtrace:")
+        error.backtrace.first(5).each do |line|
+          @output.puts @pastel.dim("  #{line}")
         end
+        @output.puts
       end
 
       def looks_like_markdown?(text)
         text.match?(/^#+\s|^\*\s|^-\s|^\d+\.\s|```|\[.+\]\(.+\)/)
       end
-
-      def format_cost(cost)
-        if cost < 0.01
-          @pastel.green("$#{format("%.6f", cost)}")
-        elsif cost < 1.0
-          @pastel.yellow("$#{format("%.4f", cost)}")
-        else
-          @pastel.red("$#{format("%.2f", cost)}")
-        end
-      end
-
-      def format_context_percentage(percentage_string)
-        # Extract numeric value from percentage string (e.g., "12.5%" -> 12.5)
-        percentage = percentage_string.to_s.gsub("%", "").to_f
-
-        if percentage < 50
-          @pastel.green(percentage_string)
-        elsif percentage < 80
-          @pastel.yellow(percentage_string)
-        else
-          @pastel.red(percentage_string)
-        end
-      end
-
-      def format_duration(seconds)
-        if seconds < 1
-          "#{(seconds * 1000).round}ms"
-        elsif seconds < 60
-          "#{seconds.round(2)}s"
-        else
-          minutes = (seconds / 60).floor
-          secs = (seconds % 60).round
-          "#{minutes}m #{secs}s"
-        end
-      end
-
-      def format_number(num)
-        num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
-      end
-
-      def format_timestamp(timestamp)
-        return "" unless timestamp
-
-        time = Time.parse(timestamp)
-        time.strftime("[%H:%M:%S]")
-      rescue StandardError
-        ""
-      end
-
-      def print_event_divider
-        @output.puts @pastel.dim("  " + "·" * 60)
-      end
-
-      def start_spinner(indent, message)
-        return if @quiet
-
-        @active_spinner = TTY::Spinner.new("#{indent}:spinner #{message}", format: :dots, output: @output)
-        @active_spinner.auto_spin
-      end
-
-      def clear_spinner
-        return unless @active_spinner
-
-        @active_spinner.stop
-        @active_spinner = nil
-      end
-
-      def strip_system_reminders(content)
-        # Remove <system-reminder>...</system-reminder> blocks
-        content.gsub(%r{<system-reminder>.*?</system-reminder>}m, "").strip
-      end
-
-      def truncate_tool_result(lines, full_content)
-        # Truncate to first 2 lines and 300 characters
-        total_lines = lines.length
-        total_chars = full_content.length
-
-        # Take first 2 lines
-        preview_lines = lines.first(2)
-        preview_text = preview_lines.join("\n")
-
-        # Track what we're actually showing
-        shown_lines = preview_lines.length
-        shown_chars = preview_text.length
-
-        # If preview already exceeds 300 chars, truncate it
-        if preview_text.length > 300
-          preview_text = preview_text[0..299]
-          # Convert back to array with single truncated element
-          preview_lines = [preview_text]
-          shown_lines = 1 # We only show partial content now
-          shown_chars = 300
-        end
-
-        # Calculate what's hidden
-        if total_lines <= 2 && total_chars <= 300
-          # Nothing hidden, show as-is
-          preview_lines
-        else
-          # Build truncation message
-          hidden_parts = []
-
-          hidden_lines = total_lines - shown_lines
-          hidden_chars = total_chars - shown_chars
-
-          hidden_parts << "#{hidden_lines} more lines" if hidden_lines > 0
-          hidden_parts << "#{hidden_chars} more characters" if hidden_chars > 0
-
-          truncation_msg = @pastel.dim("... (#{hidden_parts.join(", ")})")
-
-          preview_lines + ["", truncation_msg]
-        end
-      end
     end
   end
 end