openclacky 0.5.6 → 0.6.1

data/lib/clacky/agent.rb

@@ -10,7 +10,7 @@ require_relative "utils/arguments_parser"
 module Clacky
   class Agent
     attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
-                :cache_stats, :cost_source
+                :cache_stats, :cost_source, :ui
 
     # System prompt for the coding agent
     SYSTEM_PROMPT = <<~PROMPT.freeze
@@ -51,7 +51,7 @@ module Clacky
       NEVER stop after just adding todos without executing them!
     PROMPT
 
-    def initialize(client, config = {}, working_dir: nil)
+    def initialize(client, config = {}, working_dir: nil, ui: nil)
       @client = client
       @config = config.is_a?(AgentConfig) ? config : AgentConfig.new(config)
       @tool_registry = ToolRegistry.new
@@ -65,7 +65,8 @@ module Clacky
         cache_creation_input_tokens: 0,
         cache_read_input_tokens: 0,
         total_requests: 0,
-        cache_hit_requests: 0
+        cache_hit_requests: 0,
+        raw_api_usage_samples: []  # Store raw API usage for debugging
       }
       @start_time = nil
       @working_dir = working_dir || Dir.pwd
@@ -74,14 +75,17 @@ module Clacky
       @cost_source = :estimated  # Track whether cost is from API or estimated
       @task_cost_source = :estimated  # Track cost source for current task
       @previous_total_tokens = 0  # Track tokens from previous iteration for delta calculation
+      @interrupted = false  # Flag for user interrupt
+      @ui = ui  # UIController for direct UI interaction
+      @debug_logs = []  # Debug logs for troubleshooting
 
       # Register built-in tools
       register_builtin_tools
     end
 
     # Restore from a saved session
-    def self.from_session(client, config, session_data)
-      agent = new(client, config)
+    def self.from_session(client, config, session_data, ui: nil)
+      agent = new(client, config, ui: ui)
       agent.restore_session(session_data)
       agent
     end
@@ -125,24 +129,60 @@ module Clacky
       end
     end
 
+    # Get recent user messages from conversation history
+    # @param limit [Integer] Number of recent user messages to retrieve (default: 5)
+    # @return [Array<String>] Array of recent user message contents
+    def get_recent_user_messages(limit: 5)
+      # Filter messages to only include real user messages (exclude system-injected ones)
+      user_messages = @messages.select do |m|
+        m[:role] == "user" && !m[:system_injected]
+      end
+      
+      # Extract text content from the last N user messages
+      user_messages.last(limit).map do |msg|
+        extract_text_from_content(msg[:content])
+      end
+    end
+
+    private def extract_text_from_content(content)
+      if content.is_a?(String)
+        content
+      elsif content.is_a?(Array)
+        # Extract text from content array (may contain text and images)
+        text_parts = content.select { |c| c.is_a?(Hash) && c[:type] == "text" }
+        text_parts.map { |c| c[:text] }.join("\n")
+      else
+        content.to_s
+      end
+    end
+
     def add_hook(event, &block)
       @hooks.add(event, &block)
     end
 
-    def run(user_input, images: [], &block)
+    def run(user_input, images: [])
       @start_time = Time.now
       @task_cost_source = :estimated  # Reset for new task
       @previous_total_tokens = 0  # Reset token tracking for new task
+      @task_start_iterations = @iterations  # Track starting iterations for this task
+      @task_start_cost = @total_cost  # Track starting cost for this task
+      
+      # Track cache stats for current task
+      @task_cache_stats = {
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        total_requests: 0,
+        cache_hit_requests: 0
+      }
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
         system_prompt = build_system_prompt
         system_message = { role: "system", content: system_prompt }
 
-        # Enable caching for system prompt if configured and model supports it
-        if @config.enable_prompt_caching
-          system_message[:cache_control] = { type: "ephemeral" }
-        end
+        # Note: Don't set cache_control on system prompt
+        # System prompt is usually < 1024 tokens (minimum for caching)
+        # Cache control will be set on tools and conversation history instead
 
         @messages << system_message
       end
@@ -152,7 +192,6 @@ module Clacky
       @messages << { role: "user", content: user_content }
       @total_tasks += 1
 
-      emit_event(:on_start, { input: user_input }, &block)
       @hooks.trigger(:on_start, user_input)
 
       begin
@@ -160,30 +199,29 @@ module Clacky
           break if should_stop?
 
           @iterations += 1
-          emit_event(:on_iteration, { iteration: @iterations }, &block)
           @hooks.trigger(:on_iteration, @iterations)
 
           # Think: LLM reasoning with tool support
-          response = think(&block)
+          response = think
 
           # Debug: check for potential infinite loops
           if @config.verbose
-            puts "[DEBUG] Iteration #{@iterations}: finish_reason=#{response[:finish_reason]}, tool_calls=#{response[:tool_calls]&.size || 'nil'}"
+            @ui&.log("Iteration #{@iterations}: finish_reason=#{response[:finish_reason]}, tool_calls=#{response[:tool_calls]&.size || 'nil'}", level: :debug)
           end
 
           # Check if done (no more tool calls needed)
           if response[:finish_reason] == "stop" || response[:tool_calls].nil? || response[:tool_calls].empty?
-            emit_event(:answer, { content: response[:content] }, &block)
+            @ui&.show_assistant_message(response[:content]) if response[:content] && !response[:content].empty?
             break
           end
 
-          # Emit assistant_message event if there's content before tool calls
+          # Show assistant message if there's content before tool calls
           if response[:content] && !response[:content].empty?
-            emit_event(:assistant_message, { content: response[:content] }, &block)
+            @ui&.show_assistant_message(response[:content])
           end
 
           # Act: Execute tool calls
-          action_result = act(response[:tool_calls], &block)
+          action_result = act(response[:tool_calls])
 
           # Observe: Add tool results to conversation context
           observe(response, action_result[:tool_results])
@@ -192,29 +230,37 @@ module Clacky
           if action_result[:denied]
             # If user provided feedback, treat it as a user question/instruction
             if action_result[:feedback] && !action_result[:feedback].empty?
-              # Add user feedback as a new user message
-              # Use a clear format that signals this is important user input
+              # Add user feedback as a new user message with system_injected marker
               @messages << {
                 role: "user",
-                content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions."
+                content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions.",
+                system_injected: true  # Mark as system-injected message for filtering
               }
               # Continue loop to let agent respond to feedback
               next
             else
               # User just said "no" without feedback - stop and wait
-              emit_event(:answer, { content: "Tool execution was denied. Please provide further instructions." }, &block)
+              @ui&.show_assistant_message("Tool execution was denied. Please give more instructions...")
               break
             end
           end
         end
 
         result = build_result(:success)
-        emit_event(:on_complete, result, &block)
+        @ui&.show_complete(
+          iterations: result[:iterations],
+          cost: result[:total_cost_usd],
+          duration: result[:duration_seconds],
+          cache_stats: result[:cache_stats]
+        )
         @hooks.trigger(:on_complete, result)
         result
+      rescue Clacky::AgentInterrupted
+        # Let CLI handle the interrupt message
+        raise
       rescue StandardError => e
+        # Build error result for session data, but let CLI handle error display
         result = build_result(:error, error: e.message)
-        emit_event(:on_complete, result, &block)
         raise
       end
     end
@@ -247,7 +293,8 @@ module Clacky
         total_cost_usd: @total_cost.round(4),
         duration_seconds: @start_time ? (Time.now - @start_time).round(2) : 0,
         last_status: status.to_s,
-        cache_stats: @cache_stats
+        cache_stats: @cache_stats,
+        debug_logs: @debug_logs
       }
 
       # Add error message if status is error
@@ -262,8 +309,6 @@ module Clacky
         config: {
           model: @config.model,
           permission_mode: @config.permission_mode.to_s,
-          max_iterations: @config.max_iterations,
-          max_cost_usd: @config.max_cost_usd,
           enable_compression: @config.enable_compression,
           enable_prompt_caching: @config.enable_prompt_caching,
           keep_recent_messages: @config.keep_recent_messages,
@@ -279,9 +324,6 @@ module Clacky
     private
 
     def should_auto_execute?(tool_name, tool_params = {})
-      # Check if tool is disallowed
-      return false if @config.disallowed_tools.include?(tool_name)
-
       case @config.permission_mode
       when :auto_approve
         true
@@ -367,120 +409,104 @@ module Clacky
       prompt
     end
 
-    def think(&block)
-      emit_event(:thinking, { iteration: @iterations }, &block)
+    def think
+      @ui&.show_progress
 
       # Compress messages if needed to reduce cost
-      compress_messages_if_needed if @config.enable_compression
+      compress_messages_if_needed
 
       # Always send tools definitions to allow multi-step tool calling
-      tools_to_send = @tool_registry.allowed_definitions(@config.allowed_tools)
+      tools_to_send = @tool_registry.all_definitions
 
-      # Show progress indicator while waiting for LLM response
-      progress = ProgressIndicator.new(verbose: @config.verbose)
-      progress.start
+      # Retry logic for network failures
+      max_retries = 10
+      retry_delay = 5
+      retries = 0
 
       begin
-        # Retry logic for network failures
-        max_retries = 10
-        retry_delay = 5
-        retries = 0
-
-        begin
-          response = @client.send_messages_with_tools(
-            @messages,
-            model: @config.model,
-            tools: tools_to_send,
-            max_tokens: @config.max_tokens,
-            verbose: @config.verbose,
-            enable_caching: @config.enable_prompt_caching
-          )
-        rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
-          retries += 1
-          if retries <= max_retries
-            progress.finish
-            puts "\n⚠️  Network request failed: #{e.class.name} - #{e.message}"
-            puts "🔄 Retry #{retries}/#{max_retries}, waiting #{retry_delay} seconds..."
-            sleep retry_delay
-            progress.start
-            retry
-          else
-            progress.finish
-            puts "\n❌ Network request failed after #{max_retries} retries, giving up"
-            raise Error, "Network connection failed after #{max_retries} retries: #{e.message}"
-          end
+        response = @client.send_messages_with_tools(
+          @messages,
+          model: @config.model,
+          tools: tools_to_send,
+          max_tokens: @config.max_tokens,
+          enable_caching: @config.enable_prompt_caching
+        )
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        retries += 1
+        if retries <= max_retries
+          @ui&.show_warning("Network failed: #{e.message}. Retry #{retries}/#{max_retries}...")
+          sleep retry_delay
+          retry
+        else
+          @ui&.show_error("Network failed after #{max_retries} retries: #{e.message}")
+          raise Error, "Network connection failed after #{max_retries} retries: #{e.message}"
         end
+      end
 
-        track_cost(response[:usage])
+      # Clear progress indicator (change to gray and show final time)
+      @ui&.clear_progress
 
-        # Handle truncated responses (when max_tokens limit is reached)
-        if response[:finish_reason] == "length"
-          # Count recent truncations to prevent infinite loops
-          recent_truncations = @messages.last(5).count { |m|
-            m[:role] == "user" && m[:content]&.include?("[SYSTEM] Your response was truncated")
-          }
+      track_cost(response[:usage], raw_api_usage: response[:raw_api_usage])
 
-          if recent_truncations >= 2
-            # Too many truncations - task is too complex
-            progress.finish
-            puts "\n⚠️  Response truncated multiple times. Task is too complex for a single response." if @config.verbose
-
-            # Create a response that tells the user to break down the task
-            error_response = {
-              content: "I apologize, but this task is too complex to complete in a single response. " \
-                       "Please break it down into smaller steps, or reduce the amount of content to generate at once.\n\n" \
-                       "For example, when creating a long document:\n" \
-                       "1. First create the file with a basic structure\n" \
-                       "2. Then use edit() to add content section by section",
-              finish_reason: "stop",
-              tool_calls: nil
-            }
-
-            # Add this as an assistant message so it appears in conversation
-            @messages << {
-              role: "assistant",
-              content: error_response[:content]
-            }
-
-            return error_response
-          end
+      # Handle truncated responses (when max_tokens limit is reached)
+      if response[:finish_reason] == "length"
+        # Count recent truncations to prevent infinite loops
+        recent_truncations = @messages.last(5).count { |m|
+          m[:role] == "user" && m[:content]&.include?("[SYSTEM] Your response was truncated")
+        }
 
-          # Insert system message to guide LLM to retry with smaller steps
-          @messages << {
-            role: "user",
-            content: "[SYSTEM] Your response was truncated due to length limit. Please retry with a different approach:\n" \
-                     "- For long file content: create the file with structure first, then use edit() to add content section by section\n" \
-                     "- Break down large tasks into multiple smaller steps\n" \
-                     "- Avoid putting more than 2000 characters in a single tool call argument\n" \
-                     "- Use multiple tool calls instead of one large call"
+        if recent_truncations >= 2
+          # Too many truncations - task is too complex
+          @ui&.show_error("Response truncated multiple times. Task is too complex.")
+
+          # Create a response that tells the user to break down the task
+          error_response = {
+            content: "I apologize, but this task is too complex to complete in a single response. " \
+                     "Please break it down into smaller steps, or reduce the amount of content to generate at once.\n\n" \
+                     "For example, when creating a long document:\n" \
+                     "1. First create the file with a basic structure\n" \
+                     "2. Then use edit() to add content section by section",
+            finish_reason: "stop",
+            tool_calls: nil
           }
 
-          puts "⚠️  Response truncated due to length limit. Retrying with smaller steps..." if @config.verbose
+          # Add this as an assistant message so it appears in conversation
+          @messages << {
+            role: "assistant",
+            content: error_response[:content]
+          }
 
-          # Recursively retry
-          return think(&block)
+          return error_response
         end
 
-        # Add assistant response to messages
-        msg = { role: "assistant" }
-        # Always include content field (some APIs require it even with tool_calls)
-        # Use empty string instead of null for better compatibility
-        msg[:content] = response[:content] || ""
-        msg[:tool_calls] = format_tool_calls_for_api(response[:tool_calls]) if response[:tool_calls]
-        @messages << msg
+        # Insert system message to guide LLM to retry with smaller steps
+        @messages << {
+          role: "user",
+          content: "[SYSTEM] Your response was truncated due to length limit. Please retry with a different approach:\n" \
+                   "- For long file content: create the file with structure first, then use edit() to add content section by section\n" \
+                   "- Break down large tasks into multiple smaller steps\n" \
+                   "- Avoid putting more than 2000 characters in a single tool call argument\n" \
+                   "- Use multiple tool calls instead of one large call"
+        }
 
-        if @config.verbose
-          puts "\n[DEBUG] Assistant response added to messages:"
-          puts JSON.pretty_generate(msg)
-        end
+        @ui&.show_warning("Response truncated. Retrying with smaller steps...")
 
-        response
-      ensure
-        progress.finish
+        # Recursively retry
+        return think
       end
+
+      # Add assistant response to messages
+      msg = { role: "assistant" }
+      # Always include content field (some APIs require it even with tool_calls)
+      # Use empty string instead of null for better compatibility
+      msg[:content] = response[:content] || ""
+      msg[:tool_calls] = format_tool_calls_for_api(response[:tool_calls]) if response[:tool_calls]
+      @messages << msg
+
+      response
     end
 
-    def act(tool_calls, &block)
+    def act(tool_calls)
       return { denied: false, feedback: nil, tool_results: [] } unless tool_calls
 
       denied = false
@@ -491,7 +517,7 @@ module Clacky
         # Hook: before_tool_use
         hook_result = @hooks.trigger(:before_tool_use, call)
         if hook_result[:action] == :deny
-          emit_event(:tool_denied, call, &block)
+          @ui&.show_warning("Tool #{call[:name]} denied by hook")
           results << build_error_result(call, hook_result[:reason] || "Tool use denied by hook")
           next
         end
@@ -499,34 +525,38 @@ module Clacky
         # Permission check (if not in auto-approve mode)
         unless should_auto_execute?(call[:name], call[:arguments])
           if @config.is_plan_only?
-            emit_event(:tool_planned, call, &block)
+            @ui&.show_info("Planned: #{call[:name]}")
             results << build_planned_result(call)
             next
           end
 
-          confirmation = confirm_tool_use?(call, &block)
+          confirmation = confirm_tool_use?(call)
           unless confirmation[:approved]
-            emit_event(:tool_denied, call, &block)
+            # Show denial warning with user feedback if provided
+            denial_message = "Tool #{call[:name]} denied"
+            if confirmation[:feedback] && !confirmation[:feedback].empty?
+              denial_message += ": #{confirmation[:feedback]}"
+            end
+            @ui&.show_warning(denial_message)
+            
             denied = true
             user_feedback = confirmation[:feedback]
             feedback = user_feedback if user_feedback
             results << build_denied_result(call, user_feedback)
 
-            # If user provided feedback, stop processing remaining tools immediately
-            # Let the agent respond to the feedback in the next iteration
-            if user_feedback && !user_feedback.empty?
-              # Fill in denied results for all remaining tool calls to avoid mismatch
-              remaining_calls = tool_calls[(index + 1)..-1] || []
-              remaining_calls.each do |remaining_call|
-                results << build_denied_result(remaining_call, "Auto-denied due to user feedback on previous tool")
-              end
-              break
+            # Auto-deny all remaining tools
+            remaining_calls = tool_calls[(index + 1)..-1] || []
+            remaining_calls.each do |remaining_call|
+              reason = user_feedback && !user_feedback.empty? ?
+                       user_feedback :
+                       "Auto-denied due to user rejection of previous tool"
+              results << build_denied_result(remaining_call, reason)
             end
-            next
+            break
           end
         end
 
-        emit_event(:tool_call, call, &block)
+        @ui&.show_tool_call(call[:name], call[:arguments])
 
         # Execute tool
         begin
@@ -540,16 +570,30 @@ module Clacky
             args[:todos_storage] = @todos
           end
 
+          # Show progress for potentially slow tools (no prefix newline)
+          if potentially_slow_tool?(call[:name], args)
+            progress_message = build_tool_progress_message(call[:name], args)
+            @ui&.show_progress(progress_message, prefix_newline: false)
+          end
+
           result = tool.execute(**args)
 
+          # Clear progress if shown
+          @ui&.clear_progress if potentially_slow_tool?(call[:name], args)
+
           # Hook: after_tool_use
           @hooks.trigger(:after_tool_use, call, result)
 
-          emit_event(:observation, { tool: call[:name], result: result }, &block)
+          # Update todos display after todo_manager execution
+          if call[:name] == "todo_manager"
+            @ui&.update_todos(@todos.dup)
+          end
+
+          @ui&.show_tool_result(tool.format_result(result))
           results << build_success_result(call, result)
         rescue StandardError => e
           @hooks.trigger(:on_tool_error, call, e)
-          emit_event(:tool_error, { call: call, error: e }, &block)
+          @ui&.show_tool_error(e)
           results << build_error_result(call, e.message)
         end
       end
@@ -594,27 +638,75 @@ module Clacky
       end
     end
 
+    # Interrupt the agent's current run
+    # Called when user presses Ctrl+C during agent execution
+    def interrupt!
+      @interrupted = true
+    end
+
+    # Check if agent is currently running
+    def running?
+      @start_time != nil && !should_stop?
+    end
+
     def should_stop?
-      if @iterations >= @config.max_iterations
-        puts "\n⚠️  Reached maximum iterations (#{@config.max_iterations})" if @config.verbose
+      if @interrupted
+        @interrupted = false  # Reset for next run
         return true
       end
 
-      if @total_cost >= @config.max_cost_usd
-        puts "\n⚠️  Reached maximum cost ($#{@config.max_cost_usd})" if @config.verbose
-        return true
-      end
 
-      # Check timeout only if configured (nil means no timeout)
-      if @config.timeout_seconds && Time.now - @start_time > @config.timeout_seconds
-        puts "\n⚠️  Reached timeout (#{@config.timeout_seconds}s)" if @config.verbose
-        return true
+      false
+    end
+
+    # Check if a tool is potentially slow and should show progress
+    private def potentially_slow_tool?(tool_name, args)
+      case tool_name.to_s.downcase
+      when 'shell', 'safe_shell'
+        # Check if the command is a slow command
+        command = args[:command] || args['command']
+        return false unless command
+        
+        # List of slow command patterns
+        slow_patterns = [
+          /bundle\s+(install|exec\s+rspec|exec\s+rake)/,
+          /npm\s+(install|run\s+test|run\s+build)/,
+          /yarn\s+(install|test|build)/,
+          /pnpm\s+install/,
+          /cargo\s+(build|test)/,
+          /go\s+(build|test)/,
+          /make\s+(test|build)/,
+          /pytest/,
+          /jest/
+        ]
+        
+        slow_patterns.any? { |pattern| command.match?(pattern) }
+      when 'web_fetch', 'web_search'
+        true  # Network operations can be slow
+      else
+        false  # Most file operations are fast
       end
+    end
 
-      false
+    # Build progress message for tool execution
+    private def build_tool_progress_message(tool_name, args)
+      case tool_name.to_s.downcase
+      when 'shell', 'safe_shell'
+        command = args[:command] || args['command']
+        # Extract the main command for display
+        cmd_parts = command.to_s.split
+        main_cmd = cmd_parts.first(2).join(' ')
+        "Running #{main_cmd}"
+      when 'web_fetch'
+        "Fetching web page"
+      when 'web_search'
+        "Searching web"
+      else
+        "Executing #{tool_name}"
+      end
     end
 
-    def track_cost(usage)
+    def track_cost(usage, raw_api_usage: nil)
       # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
       iteration_cost = nil
       if usage[:api_cost]
@@ -622,7 +714,7 @@ module Clacky
         @cost_source = :api
         @task_cost_source = :api
         iteration_cost = usage[:api_cost]
-        puts "[DEBUG] Using API-provided cost: $#{usage[:api_cost]}" if @config.verbose
+        @ui&.log("Using API-provided cost: $#{usage[:api_cost]}", level: :debug) if @config.verbose
       else
         # Priority 2: Calculate from tokens using ModelPricing
         result = ModelPricing.calculate_cost(model: @config.model, usage: usage)
@@ -637,15 +729,15 @@ module Clacky
 
         if @config.verbose
           source_label = pricing_source == :price ? "model pricing" : "default pricing"
-          puts "[DEBUG] Calculated cost for #{@config.model} using #{source_label}: $#{cost.round(6)}"
-          puts "[DEBUG] Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}"
+          @ui&.log("Calculated cost for #{@config.model} using #{source_label}: $#{cost.round(6)}", level: :debug)
+          @ui&.log("Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}", level: :debug)
         end
       end
 
       # Display token usage statistics for this iteration
       display_iteration_tokens(usage, iteration_cost)
 
-      # Track cache usage statistics
+      # Track cache usage statistics (global)
       @cache_stats[:total_requests] += 1
 
       if usage[:cache_creation_input_tokens]
@@ -656,6 +748,27 @@ module Clacky
         @cache_stats[:cache_read_input_tokens] += usage[:cache_read_input_tokens]
         @cache_stats[:cache_hit_requests] += 1
       end
+
+      # Store raw API usage samples (keep last 3 for debugging)
+      if raw_api_usage
+        @cache_stats[:raw_api_usage_samples] ||= []
+        @cache_stats[:raw_api_usage_samples] << raw_api_usage
+        @cache_stats[:raw_api_usage_samples] = @cache_stats[:raw_api_usage_samples].last(3)
+      end
+      
+      # Track cache usage for current task
+      if @task_cache_stats
+        @task_cache_stats[:total_requests] += 1
+        
+        if usage[:cache_creation_input_tokens]
+          @task_cache_stats[:cache_creation_input_tokens] += usage[:cache_creation_input_tokens]
+        end
+        
+        if usage[:cache_read_input_tokens]
+          @task_cache_stats[:cache_read_input_tokens] += usage[:cache_read_input_tokens]
+          @task_cache_stats[:cache_hit_requests] += 1
+        end
+      end
     end
 
     # Display token usage for current iteration
@@ -669,53 +782,20 @@ module Clacky
       # Calculate token delta from previous iteration
       delta_tokens = total_tokens - @previous_total_tokens
       @previous_total_tokens = total_tokens  # Update for next iteration
-      
-      # Build token summary string
-      token_info = []
-
-      # Delta tokens with color coding at the beginning
-      require 'pastel'
-      pastel = Pastel.new
-      
-      delta_str = "+#{delta_tokens}"
-      colored_delta = if delta_tokens > 10000
-        pastel.red.bold(delta_str)  # Error level: red for > 10k
-      elsif delta_tokens > 5000
-        pastel.yellow.bold(delta_str)  # Warn level: yellow for > 5k
-      else
-        pastel.green(delta_str)  # Normal: green for <= 5k
-      end
-      
-      token_info << colored_delta
-
-      # Cache status indicator
-      cache_used = cache_read > 0 || cache_write > 0
-      if cache_used
-        cache_indicator = "✓ Cached"
-        token_info << pastel.cyan(cache_indicator)
-      end
-
-      # Input tokens (with cache breakdown if available)
-      if cache_write > 0 || cache_read > 0
-        input_detail = "#{prompt_tokens} (cache: #{cache_read} read, #{cache_write} write)"
-        token_info << "Input: #{input_detail}"
-      else
-        token_info << "Input: #{prompt_tokens}"
-      end
-
-      # Output tokens
-      token_info << "Output: #{completion_tokens}"
-
-      # Total
-      token_info << "Total: #{total_tokens}"
 
-      # Cost for this iteration
-      if cost
-        token_info << "Cost: $#{cost.round(6)}"
-      end
+      # Prepare data for UI to format and display
+      token_data = {
+        delta_tokens: delta_tokens,
+        prompt_tokens: prompt_tokens,
+        completion_tokens: completion_tokens,
+        total_tokens: total_tokens,
+        cache_write: cache_write,
+        cache_read: cache_read,
+        cost: cost
+      }
 
-      # Display with color
-      puts pastel.dim("    [Tokens] #{token_info.join(' | ')}")
+      # Let UI handle formatting and display
+      @ui&.show_token_usage(token_data)
     end
 
     def compress_messages_if_needed
@@ -729,57 +809,30 @@ module Clacky
       original_size = @messages.size
       target_size = @config.keep_recent_messages + 2
 
-      # Show compression progress using ProgressIndicator
-      progress = ProgressIndicator.new(
-        verbose: @config.verbose,
-        message: "🗜️  Compressing conversation history (#{original_size} → ~#{target_size} messages)"
-      )
-      progress.start
+      @ui&.show_info("Compressing history (#{original_size} -> ~#{target_size} messages)...")
 
-      begin
-        # Find the system message (should be first)
-        system_msg = @messages.find { |m| m[:role] == "system" }
+      # Find the system message (should be first)
+      system_msg = @messages.find { |m| m[:role] == "system" }
 
-        # Get the most recent N messages, ensuring tool_calls/tool results pairs are kept together
-        recent_messages = get_recent_messages_with_tool_pairs(@messages, @config.keep_recent_messages)
+      # Get the most recent N messages, ensuring tool_calls/tool results pairs are kept together
+      recent_messages = get_recent_messages_with_tool_pairs(@messages, @config.keep_recent_messages)
 
-        # Get messages to compress (everything except system and recent)
-        messages_to_compress = @messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
+      # Get messages to compress (everything except system and recent)
+      messages_to_compress = @messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
 
-        if messages_to_compress.empty?
-          progress.finish
-          return
-        end
+      return if messages_to_compress.empty?
 
-        # Create summary of compressed messages
-        summary = summarize_messages(messages_to_compress)
+      # Create summary of compressed messages
+      summary = summarize_messages(messages_to_compress)
 
-        # Rebuild messages array: [system, summary, recent_messages]
-        # Preserve cache_control on system message if it exists
-        rebuilt_messages = [system_msg, summary, *recent_messages].compact
+      # Rebuild messages array: [system, summary, recent_messages]
+      rebuilt_messages = [system_msg, summary, *recent_messages].compact
 
-        # Re-apply cache control to system message if caching is enabled
-        if @config.enable_prompt_caching && rebuilt_messages.first&.dig(:role) == "system"
-          rebuilt_messages.first[:cache_control] = { type: "ephemeral" }
-        end
+      @messages = rebuilt_messages
 
-        @messages = rebuilt_messages
+      final_size = @messages.size
 
-        final_size = @messages.size
-
-        # Finish progress and show completion message
-        progress.finish
-        puts "✅ Compressed conversation history (#{original_size} → #{final_size} messages)"
-
-        # Show detailed summary in verbose mode
-        if @config.verbose
-          puts "\n[COMPRESSION SUMMARY]"
-          puts summary[:content]
-          puts ""
-        end
-      ensure
-        progress.finish
-      end
+      @ui&.show_info("Compressed (#{original_size} -> #{final_size} messages)")
     end
 
     def get_recent_messages_with_tool_pairs(messages, count)
@@ -908,77 +961,51 @@ module Clacky
       }
     end
 
-    def emit_event(type, data, &block)
-      return unless block
-
-      block.call({
-        type: type,
-        data: data,
-        iteration: @iterations,
-        cost: @total_cost
-      })
-    end
-
-    def confirm_tool_use?(call, &block)
-      emit_event(:tool_confirmation_required, call, &block)
-
+    def confirm_tool_use?(call)
       # Show preview first and check for errors
       preview_error = show_tool_preview(call)
 
-      # If preview detected an error (e.g., edit with non-existent string),
-      # auto-deny and provide detailed feedback
+      # If preview detected an error, auto-deny and provide feedback
       if preview_error && preview_error[:error]
-        puts "\nTool call auto-denied due to preview error"
-
-        # Build helpful feedback message
-        feedback = case call[:name]
-        when "edit"
-          "The edit operation will fail because the old_string was not found in the file. " \
-          "Please use file_reader to read '#{preview_error[:path]}' first, " \
-          "find the correct string to replace, and try again with the exact string (including whitespace)."
-        else
-          "Tool preview error: #{preview_error[:error]}"
-        end
-
+        @ui&.show_warning("Tool call auto-denied due to preview error")
+        feedback = build_preview_error_feedback(call[:name], preview_error)
         return { approved: false, feedback: feedback }
       end
 
-      # Then show the confirmation prompt with better formatting
-      prompt_text = format_tool_prompt(call)
-      puts "\n❓ #{prompt_text}"
-
-      # Use TTY::Prompt for better input handling
-      tty_prompt = TTY::Prompt.new(interrupt: :exit)
-
-      begin
-        response = tty_prompt.ask("   (Enter/y to approve, n to deny, or provide feedback):", required: false) do |q|
-          q.modify :strip
+      # Request confirmation via UI
+      if @ui
+        prompt_text = format_tool_prompt(call)
+        result = @ui.request_confirmation(prompt_text, default: true)
+
+        case result
+        when true
+          { approved: true, feedback: nil }
+        when false, nil
+          # User denied - add visual marker based on tool type
+          tool_name_capitalized = call[:name].capitalize
+          @ui&.show_info("  ↳ #{tool_name_capitalized} cancelled", prefix_newline: false)
+          { approved: false, feedback: nil }
+        else
+          # String feedback - also add visual marker
+          tool_name_capitalized = call[:name].capitalize
+          @ui&.show_info("  ↳ #{tool_name_capitalized} cancelled", prefix_newline: false)
+          { approved: false, feedback: result.to_s }
         end
-      rescue TTY::Reader::InputInterrupt
-        # Handle Ctrl+C
-        puts
-        return { approved: false, feedback: nil }
-      end
-
-      # Handle nil response (EOF/pipe input)
-      if response.nil? || response.empty?
-        return { approved: true, feedback: nil }  # Empty means approved
-      end
-
-      response_lower = response.downcase
-
-      # "y"/"yes" = approved
-      if response_lower == "y" || response_lower == "yes"
-        return { approved: true, feedback: nil }
+      else
+        # Fallback: auto-approve if no UI
+        { approved: true, feedback: nil }
       end
+    end
 
-      # "n"/"no" = denied without feedback
-      if response_lower == "n" || response_lower == "no"
-        return { approved: false, feedback: nil }
+    private def build_preview_error_feedback(tool_name, error_info)
+      case tool_name
+      when "edit"
+        "The edit operation will fail because the old_string was not found in the file. " \
+        "Please use file_reader to read '#{error_info[:path]}' first, " \
+        "find the correct string to replace, and try again with the exact string (including whitespace)."
+      else
+        "Tool preview error: #{error_info[:error]}"
       end
-
-      # Any other input = denied with feedback
-      { approved: false, feedback: response }
     end
 
     def format_tool_prompt(call)
@@ -1018,6 +1045,8 @@ module Clacky
     end
 
     def show_tool_preview(call)
+      return nil unless @ui
+
       begin
         args = JSON.parse(call[:arguments], symbolize_names: true)
 
@@ -1028,22 +1057,22 @@ module Clacky
         when "edit"
           preview_error = show_edit_preview(args)
         when "shell", "safe_shell"
-          preview_error = show_shell_preview(args)
+          show_shell_preview(args)
         else
           # For other tools, show formatted arguments
           tool = @tool_registry.get(call[:name]) rescue nil
           if tool
             formatted = tool.format_call(args) rescue "#{call[:name]}(...)"
-            puts "\nArgs: #{formatted}"
+            @ui&.show_tool_args(formatted)
           else
-            puts "\nArgs: #{call[:arguments]}"
+            @ui&.show_tool_args(call[:arguments])
           end
         end
 
-        return preview_error
+        preview_error
       rescue JSON::ParserError
-        puts "   Args: #{call[:arguments]}"
-        return nil
+        @ui&.show_tool_args(call[:arguments])
+        nil
       end
     end
 
@@ -1051,17 +1080,16 @@ module Clacky
       path = args[:path] || args['path']
       new_content = args[:content] || args['content'] || ""
 
-      puts "\n📝 File: #{path || '(unknown)'}"
+      is_new_file = !(path && File.exist?(path))
+      @ui&.show_file_write_preview(path, is_new_file: is_new_file)
 
-      if path && File.exist?(path)
-        old_content = File.read(path)
-        puts "Modifying existing file\n"
-        show_diff(old_content, new_content, max_lines: 50)
+      if is_new_file
+        @ui&.show_diff("", new_content, max_lines: 50)
       else
-        puts "Creating new file\n"
-        # Show diff from empty content to new content (all additions)
-        show_diff("", new_content, max_lines: 50)
+        old_content = File.read(path)
+        @ui&.show_diff(old_content, new_content, max_lines: 50)
       end
+      nil
     end
 
     def show_edit_preview(args)
@@ -1069,20 +1097,20 @@ module Clacky
       old_string = args[:old_string] || args['old_string'] || ""
       new_string = args[:new_string] || args['new_string'] || ""
 
-      puts "\n📝 File: #{path || '(unknown)'}"
+      @ui&.show_file_edit_preview(path)
 
       if !path || path.empty?
-        puts "   ⚠️  No file path provided"
+        @ui&.show_file_error("No file path provided")
         return { error: "No file path provided for edit operation" }
       end
 
       unless File.exist?(path)
-        puts "   ⚠️  File not found: #{path}"
-        return { error: "File not found: #{path}" }
+        @ui&.show_file_error("File not found: #{path}")
+        return { error: "File not found: #{path}", path: path }
       end
 
       if old_string.empty?
-        puts "   ⚠️  No old_string provided (nothing to replace)"
+        @ui&.show_file_error("No old_string provided (nothing to replace)")
         return { error: "No old_string provided (nothing to replace)" }
       end
 
@@ -1090,9 +1118,19 @@ module Clacky
 
       # Check if old_string exists in file
       unless file_content.include?(old_string)
-        puts "   ⚠️  String to replace not found in file"
-        puts "   Looking for (first 100 chars):"
-        puts "   #{old_string[0..100].inspect}"
+        # Log debug info for troubleshooting
+        @debug_logs << {
+          timestamp: Time.now.iso8601,
+          event: "edit_preview_failed",
+          path: path,
+          looking_for: old_string[0..500],
+          file_content_preview: file_content[0..1000],
+          file_size: file_content.length
+        }
+
+        @ui&.show_file_error("String to replace not found in file")
+        @ui&.show_file_error("Looking for (first 100 chars):")
+        @ui&.show_file_error(old_string[0..100].inspect)
         return {
           error: "String to replace not found in file",
           path: path,
@@ -1101,34 +1139,20 @@ module Clacky
       end
 
       new_content = file_content.sub(old_string, new_string)
-      show_diff(file_content, new_content, max_lines: 50)
+      @ui&.show_diff(file_content, new_content, max_lines: 50)
       nil  # No error
     end
 
     def show_shell_preview(args)
       command = args[:command] || ""
-      puts "\n💻 Command: #{command}"
-    end
-
-    def show_diff(old_content, new_content, max_lines: 50)
-      require 'diffy'
-
-      diff = Diffy::Diff.new(old_content, new_content, context: 3)
-      all_lines = diff.to_s(:color).lines
-      display_lines = all_lines.first(max_lines)
-
-      display_lines.each { |line| puts line.chomp }
-      puts "\n... (#{all_lines.size - max_lines} more lines, diff truncated)" if all_lines.size > max_lines
-    rescue LoadError
-      # Fallback if diffy is not available
-      puts "   Old size: #{old_content.bytesize} bytes"
-      puts "   New size: #{new_content.bytesize} bytes"
+      @ui&.show_shell_preview(command)
+      nil
     end
 
     def build_success_result(call, result)
       # Try to get tool instance to use its format_result_for_llm method
       tool = @tool_registry.get(call[:name]) rescue nil
-      
+
       formatted_result = if tool && tool.respond_to?(:format_result_for_llm)
         # Tool provides a custom LLM-friendly format
         tool.format_result_for_llm(result)
@@ -1136,7 +1160,7 @@ module Clacky
         # Fallback: use the original result
         result
       end
-      
+
       {
         id: call[:id],
         content: JSON.generate(formatted_result)
@@ -1174,14 +1198,20 @@ module Clacky
     end
 
     def build_result(status, error: nil)
+      # Calculate iterations for current task only
+      task_iterations = @iterations - (@task_start_iterations || 0)
+      
+      # Calculate cost for current task only
+      task_cost = @total_cost - (@task_start_cost || 0)
+      
       {
         status: status,
         session_id: @session_id,
-        iterations: @iterations,
+        iterations: task_iterations,  # Show only current task iterations
         duration_seconds: Time.now - @start_time,
-        total_cost_usd: @total_cost.round(4),
+        total_cost_usd: task_cost.round(4),  # Show only current task cost
         cost_source: @task_cost_source,  # Add cost source for this task
-        cache_stats: @cache_stats,
+        cache_stats: @task_cache_stats || @cache_stats,  # Use task cache stats if available
         messages: @messages,
         error: error
       }