openclacky 0.6.2 → 0.6.4

data/lib/clacky/agent.rb

@@ -10,7 +10,7 @@ require_relative "utils/file_processor"
 module Clacky
   class Agent
     attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
-                :cache_stats, :cost_source, :ui
+                :cache_stats, :cost_source, :ui, :skill_loader
 
     # System prompt for the coding agent
     SYSTEM_PROMPT = <<~PROMPT.freeze
@@ -49,6 +49,9 @@ module Clacky
       Adding todos is NOT completion - it's just the planning phase!
       Workflow: add todo 1 → add todo 2 → add todo 3 → START WORKING on todo 1 → complete(1) → work on todo 2 → complete(2) → etc.
       NEVER stop after just adding todos without executing them!
+
+      NOTE: Available skills are listed below in the AVAILABLE SKILLS section.
+      When a user's request matches a skill, you MUST use the skill tool instead of implementing it yourself.
     PROMPT
 
     def initialize(client, config = {}, working_dir: nil, ui: nil)
@@ -79,6 +82,13 @@ module Clacky
       @ui = ui  # UIController for direct UI interaction
       @debug_logs = []  # Debug logs for troubleshooting
 
+      # Compression tracking
+      @compression_level = 0  # Tracks how many times we've compressed (for progressive summarization)
+      @compressed_summaries = []  # Store summaries from previous compressions for reference
+
+      # Skill loader for skill management
+      @skill_loader = SkillLoader.new(@working_dir)
+
       # Register built-in tools
       register_builtin_tools
     end
@@ -108,6 +118,9 @@ module Clacky
         cache_hit_requests: 0
       }
 
+      # Restore previous_total_tokens for accurate delta calculation across sessions
+      @previous_total_tokens = session_data.dig(:stats, :previous_total_tokens) || 0
+
       # Check if the session ended with an error
       last_status = session_data.dig(:stats, :last_status)
       last_error = session_data.dig(:stats, :last_error)
@@ -213,6 +226,17 @@ module Clacky
           # Check if done (no more tool calls needed)
           if response[:finish_reason] == "stop" || response[:tool_calls].nil? || response[:tool_calls].empty?
             @ui&.show_assistant_message(response[:content]) if response[:content] && !response[:content].empty?
+
+            # Debug: log why we're stopping
+            if @config.verbose && (response[:tool_calls].nil? || response[:tool_calls].empty?)
+              reason = response[:finish_reason] == "stop" ? "API returned finish_reason=stop" : "No tool calls in response"
+              @ui&.log("Stopping: #{reason}", level: :debug)
+              if response[:content] && response[:content].is_a?(String)
+                preview = response[:content].length > 200 ? response[:content][0...200] + "..." : response[:content]
+                @ui&.log("Response content: #{preview}", level: :debug)
+              end
+            end
+
             break
           end
 
@@ -266,6 +290,100 @@ module Clacky
       end
     end
 
+    # ===== Skill-related methods =====
+
+    # Get the skill loader instance
+    # @return [SkillLoader]
+    def skill_loader
+      @skill_loader
+    end
+
+    # Load all skills from configured locations
+    # @return [Array<Skill>]
+    def load_skills
+      @skill_loader.load_all
+    end
+
+    # Check if input is a skill command and process it
+    # @param input [String] User input
+    # @return [Hash, nil] Returns { skill: Skill, arguments: String } if skill command, nil otherwise
+    def parse_skill_command(input)
+      # Check for slash command pattern
+      if input.start_with?("/")
+        # Extract command and arguments
+        match = input.match(%r{^/(\S+)(?:\s+(.*))?$})
+        return nil unless match
+
+        skill_name = match[1]
+        arguments = match[2] || ""
+
+        # Find skill by command
+        skill = @skill_loader.find_by_command("/#{skill_name}")
+        return nil unless skill
+
+        # Check if user can invoke this skill
+        unless skill.user_invocable?
+          return nil
+        end
+
+        { skill: skill, arguments: arguments }
+      else
+        nil
+      end
+    end
+
+    # Execute a skill command
+    # @param input [String] User input (should be a skill command)
+    # @return [String] The expanded prompt with skill content
+    def execute_skill_command(input)
+      parsed = parse_skill_command(input)
+      return input unless parsed
+
+      skill = parsed[:skill]
+      arguments = parsed[:arguments]
+
+      # Process skill content with arguments
+      expanded_content = skill.process_content(arguments)
+
+      # Log skill usage
+      @ui&.log("Executing skill: #{skill.identifier}", level: :info)
+
+      expanded_content
+    end
+
+    # Generate skill context - loads all auto-invocable skills
+    # @return [String] Skill context to add to system prompt
+    def build_skill_context
+      # Load all auto-invocable skills
+      all_skills = @skill_loader.load_all
+      auto_invocable = all_skills.select(&:model_invocation_allowed?)
+
+      return "" if auto_invocable.empty?
+
+      context = "\n\n" + "=" * 80 + "\n"
+      context += "AVAILABLE SKILLS:\n"
+      context += "=" * 80 + "\n\n"
+      context += "CRITICAL SKILL USAGE RULES:\n"
+      context += "- When a user's request matches any available skill, this is a BLOCKING REQUIREMENT:\n"
+      context += "  invoke the relevant skill tool BEFORE generating any other response about the task\n"
+      context += "- NEVER mention a skill without actually calling the skill tool\n"
+      context += "- NEVER implement the skill's functionality yourself - always delegate to the skill\n"
+      context += "- Skills provide specialized capabilities - use them instead of manual implementation\n"
+      context += "- When users reference '/<skill-name>' (e.g., '/pptx'), they are requesting a skill\n\n"
+      context += "Workflow: Use file_reader to read the SKILL.md file, then follow its instructions.\n\n"
+      context += "Available skills:\n\n"
+
+      auto_invocable.each do |skill|
+        skill_md_path = skill.directory.join("SKILL.md")
+        context += "- name: #{skill.identifier}\n"
+        context += "  description: #{skill.context_description}\n"
+        context += "  SKILL.md: #{skill_md_path}\n\n"
+      end
+
+      context += "\n"
+      context
+    end
+
     # Generate session data for saving
     # @param status [Symbol] Status of the last task: :success, :error, or :interrupted
     # @param error_message [String] Error message if status is :error
@@ -295,7 +413,8 @@ module Clacky
         duration_seconds: @start_time ? (Time.now - @start_time).round(2) : 0,
         last_status: status.to_s,
         cache_stats: @cache_stats,
-        debug_logs: @debug_logs
+        debug_logs: @debug_logs,
+        previous_total_tokens: @previous_total_tokens
       }
 
       # Add error message if status is error
@@ -407,6 +526,10 @@ module Clacky
         prompt += "=" * 80
       end
 
+      # Add all loaded skills to system prompt
+      skill_context = build_skill_context
+      prompt += skill_context if skill_context && !skill_context.empty?
+
       prompt
     end
 
@@ -414,7 +537,7 @@ module Clacky
       @ui&.show_progress
 
       # Compress messages if needed to reduce cost
-      compress_messages_if_needed
+      compression_message = compress_messages_if_needed
 
       # Always send tools definitions to allow multi-step tool calling
       tools_to_send = @tool_registry.all_definitions
@@ -440,13 +563,16 @@ module Clacky
           retry
         else
           @ui&.show_error("Network failed after #{max_retries} retries: #{e.message}")
-          raise Error, "Network connection failed after #{max_retries} retries: #{e.message}"
+          raise AgentError, "Network connection failed after #{max_retries} retries: #{e.message}"
         end
       end
 
       # Clear progress indicator (change to gray and show final time)
       @ui&.clear_progress
 
+      # Show compression message after clearing progress (so it doesn't get deleted)
+      @ui&.show_info(compression_message) if compression_message
+
       track_cost(response[:usage], raw_api_usage: response[:raw_api_usage])
 
       # Handle truncated responses (when max_tokens limit is reached)
@@ -501,7 +627,10 @@ module Clacky
       # 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]
+      # Only add tool_calls if they actually exist (don't add empty arrays)
+      if response[:tool_calls]&.any?
+        msg[:tool_calls] = format_tool_calls_for_api(response[:tool_calls])
+      end
       @messages << msg
 
       response
@@ -543,7 +672,8 @@ module Clacky
             denied = true
             user_feedback = confirmation[:feedback]
             feedback = user_feedback if user_feedback
-            results << build_denied_result(call, user_feedback)
+            system_injected = confirmation[:system_injected]
+            results << build_denied_result(call, user_feedback, system_injected)
 
             # Auto-deny all remaining tools
             remaining_calls = tool_calls[(index + 1)..-1] || []
@@ -551,7 +681,7 @@ module Clacky
               reason = user_feedback && !user_feedback.empty? ?
                        user_feedback :
                        "Auto-denied due to user rejection of previous tool"
-              results << build_denied_result(remaining_call, reason)
+              results << build_denied_result(remaining_call, reason, system_injected)
             end
             break
           end
@@ -571,6 +701,11 @@ module Clacky
             args[:todos_storage] = @todos
           end
 
+          # For safe_shell, skip safety check if user has already confirmed
+          if call[:name] == "safe_shell" || call[:name] == "shell"
+            args[:skip_safety_check] = true
+          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)
@@ -593,9 +728,21 @@ module Clacky
           @ui&.show_tool_result(tool.format_result(result))
           results << build_success_result(call, result)
         rescue StandardError => e
+          # Log complete error information to debug_logs for troubleshooting
+          @debug_logs << {
+            timestamp: Time.now.iso8601,
+            event: "tool_execution_error",
+            tool_name: call[:name],
+            tool_args: call[:arguments],
+            error_class: e.class.name,
+            error_message: e.message,
+            backtrace: e.backtrace&.first(20) # Keep first 20 lines of backtrace
+          }
+
           @hooks.trigger(:on_tool_error, call, e)
           @ui&.show_tool_error(e)
-          results << build_error_result(call, e.message)
+          # Use build_denied_result with system_injected=true so LLM knows it can retry
+          results << build_denied_result(call, e.message, true)
         end
       end
 
@@ -608,35 +755,11 @@ module Clacky
 
     def observe(response, tool_results)
       # Add tool results as messages
-      # Using OpenAI format which is compatible with most APIs through LiteLLM
-
-      # CRITICAL: Tool results must be in the same order as tool_calls in the response
-      # Claude/Bedrock API requires this strict ordering
+      # Use Client to format results based on API type (Anthropic vs OpenAI)
       return if tool_results.empty?
 
-      # Create a map of tool_call_id -> result for quick lookup
-      results_map = tool_results.each_with_object({}) do |result, hash|
-        hash[result[:id]] = result
-      end
-
-      # Add results in the same order as the original tool_calls
-      response[:tool_calls].each do |tool_call|
-        result = results_map[tool_call[:id]]
-        if result
-          @messages << {
-            role: "tool",
-            tool_call_id: result[:id],
-            content: result[:content]
-          }
-        else
-          # This shouldn't happen, but add a fallback error result
-          @messages << {
-            role: "tool",
-            tool_call_id: tool_call[:id],
-            content: JSON.generate({ error: "Tool result missing" })
-          }
-        end
-      end
+      formatted_messages = @client.format_tool_results(response, tool_results, model: @config.model)
+      formatted_messages.each { |msg| @messages << msg }
     end
 
     # Interrupt the agent's current run
@@ -795,41 +918,426 @@ module Clacky
       @ui&.show_token_usage(token_data)
     end
 
+    # Estimate token count for a message content
+    # Simple approximation: characters / 4 (English text)
+    # For Chinese/other languages, characters / 2 is more accurate
+    # This is a rough estimate for compression triggering purposes
+    private def estimate_tokens(content)
+      return 0 if content.nil?
+
+      text = if content.is_a?(String)
+               content
+             elsif content.is_a?(Array)
+               # Handle content arrays (e.g., with images)
+               # Add safety check to prevent nil.compact error
+               mapped = content.map { |c| c[:text] if c.is_a?(Hash) }
+               (mapped || []).compact.join
+             else
+               content.to_s
+             end
+
+      return 0 if text.empty?
+
+      # Detect language mix - count non-ASCII characters
+      ascii_count = text.bytes.count { |b| b < 128 }
+      total_bytes = text.bytes.length
+
+      # Mix ratio (1.0 = all English, 0.5 = all Chinese)
+      mix_ratio = total_bytes > 0 ? ascii_count.to_f / total_bytes : 1.0
+
+      # English: ~4 chars/token, Chinese: ~2 chars/token
+      base_chars_per_token = mix_ratio * 4 + (1 - mix_ratio) * 2
+
+      (text.length / base_chars_per_token).to_i + 50 # Add overhead for message structure
+    end
+
+    # Calculate total token count for all messages
+    # Returns estimated tokens and breakdown by category
+    private def total_message_tokens
+      system_tokens = 0
+      user_tokens = 0
+      assistant_tokens = 0
+      tool_tokens = 0
+      summary_tokens = 0
+
+      @messages.each do |msg|
+        tokens = estimate_tokens(msg[:content])
+        case msg[:role]
+        when "system"
+          system_tokens += tokens
+        when "user"
+          user_tokens += tokens
+        when "assistant"
+          assistant_tokens += tokens
+        when "tool"
+          tool_tokens += tokens
+        end
+      end
+
+      {
+        total: system_tokens + user_tokens + assistant_tokens + tool_tokens,
+        system: system_tokens,
+        user: user_tokens,
+        assistant: assistant_tokens,
+        tool: tool_tokens
+      }
+    end
+
+    # Compression thresholds
+    COMPRESSION_THRESHOLD = 80_000  # Trigger compression when exceeding this (in tokens)
+    MESSAGE_COUNT_THRESHOLD = 100   # Trigger compression when exceeding this (in message count)
+    TARGET_COMPRESSED_TOKENS = 70_000  # Target size after compression
+    MAX_RECENT_MESSAGES = 30  # Keep this many recent message pairs intact
+
     def compress_messages_if_needed
       # Check if compression is enabled
       return unless @config.enable_compression
 
-      # Only compress if we have more messages than threshold
-      threshold = @config.keep_recent_messages + 80 # +80 to trigger at ~100 messages
-      return if @messages.size <= threshold
+      # Calculate total tokens and message count
+      token_counts = total_message_tokens
+      total_tokens = token_counts[:total]
+      message_count = @messages.length
+
+      # Check if we should trigger compression
+      # Either: token count exceeds threshold OR message count exceeds threshold
+      token_threshold_exceeded = total_tokens >= COMPRESSION_THRESHOLD
+      message_count_exceeded = message_count >= MESSAGE_COUNT_THRESHOLD
+
+      # Only compress if we exceed at least one threshold
+      return unless token_threshold_exceeded || message_count_exceeded
 
-      original_size = @messages.size
-      target_size = @config.keep_recent_messages + 2
+      # Calculate how much we need to reduce
+      reduction_needed = total_tokens - TARGET_COMPRESSED_TOKENS
 
-      @ui&.show_info("Compressing history (#{original_size} -> ~#{target_size} messages)...")
+      # Don't compress if reduction is minimal (< 10% of current size)
+      # Only apply this check when triggered by token threshold
+      if token_threshold_exceeded && reduction_needed < (total_tokens * 0.1)
+        return
+      end
+
+      # If only message count threshold is exceeded, force compression
+      # to keep conversation history manageable
+
+      # Calculate target size for recent messages based on compression level
+      target_recent_count = calculate_target_recent_count(reduction_needed)
+
+      # Increment compression level for progressive summarization
+      @compression_level += 1
+
+      original_tokens = total_tokens
 
       # 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)
+      recent_messages = get_recent_messages_with_tool_pairs(@messages, target_recent_count)
+      recent_messages = [] if recent_messages.nil?
 
       # Get messages to compress (everything except system and recent)
       messages_to_compress = @messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
 
       return if messages_to_compress.empty?
 
-      # Create summary of compressed messages
-      summary = summarize_messages(messages_to_compress)
+      # Create hierarchical summary based on compression level
+      summary = generate_hierarchical_summary(messages_to_compress)
 
       # Rebuild messages array: [system, summary, recent_messages]
       rebuilt_messages = [system_msg, summary, *recent_messages].compact
 
       @messages = rebuilt_messages
 
-      final_size = @messages.size
+      # Track this compression for progressive summarization
+      @compressed_summaries << {
+        level: @compression_level,
+        message_count: messages_to_compress.size,
+        timestamp: Time.now.iso8601
+      }
+
+      final_tokens = total_message_tokens[:total]
+
+      # Return compression message (to be shown after clearing progress)
+      "History compressed (~#{original_tokens} -> ~#{final_tokens} tokens, level #{@compression_level})"
+    end
+
+    # Calculate how many recent messages to keep based on how much we need to compress
+    private def calculate_target_recent_count(reduction_needed)
+      # We want recent messages to be around 20-30% of the total target
+      # This keeps the context window useful without being too large
+      tokens_per_message = 500  # Average estimate for a message with content
+
+      # Target recent messages budget (~20% of target compressed size)
+      recent_budget = (TARGET_COMPRESSED_TOKENS * 0.2).to_i
+      target_messages = (recent_budget / tokens_per_message).to_i
+
+      # Clamp to reasonable bounds
+      [[target_messages, 20].max, MAX_RECENT_MESSAGES].min
+    end
+
+    # Generate hierarchical summary based on compression level
+    # Level 1: Detailed summary with files, decisions, features
+    # Level 2: Concise summary with key items
+    # Level 3: Minimal summary (just project type)
+    # Level 4+: Ultra-minimal (single line)
+    private def generate_hierarchical_summary(messages)
+      level = @compression_level
+
+      # Extract key information from messages
+      extracted = extract_key_information(messages)
+
+      summary_text = case level
+      when 1
+        generate_level1_summary(extracted)
+      when 2
+        generate_level2_summary(extracted)
+      when 3
+        generate_level3_summary(extracted)
+      else
+        generate_level4_summary(extracted)
+      end
+
+      {
+        role: "user",
+        content: "[SYSTEM][COMPRESSION LEVEL #{level}] #{summary_text}",
+        system_injected: true,
+        compression_level: level
+      }
+    end
+
+    # Extract key information from messages for summarization
+    private def extract_key_information(messages)
+      return empty_extraction_data if messages.nil?
+
+      {
+        # Message counts
+        user_msgs: messages.count { |m| m[:role] == "user" },
+        assistant_msgs: messages.count { |m| m[:role] == "assistant" },
+        tool_msgs: messages.count { |m| m[:role] == "tool" },
+
+        # Tools used
+        tools_used: extract_from_messages(messages, :assistant) { |m| extract_tool_names(m[:tool_calls]) },
+
+        # Files created/modified
+        files_created: extract_from_messages(messages, :tool) { |m| filter_write_results(parse_write_result(m[:content]), :created) },
+        files_modified: extract_from_messages(messages, :tool) { |m| filter_write_results(parse_write_result(m[:content]), :modified) },
+
+        # Key decisions (limit to first 5)
+        decisions: extract_from_messages(messages, :assistant) { |m| extract_decision_text(m[:content]) }.first(5),
+
+        # Completed tasks (from TODO results)
+        completed_tasks: extract_from_messages(messages, :tool) { |m| filter_todo_results(parse_todo_result(m[:content]), :completed) },
+
+        # Current in-progress work
+        in_progress: find_in_progress(messages),
+
+        # Key results from shell commands
+        shell_results: extract_from_messages(messages, :tool) { |m| parse_shell_result(m[:content]) }
+      }
+    end
+
+    # Helper: safely extract from messages with proper nil handling
+    private def extract_from_messages(messages, role_filter = nil, &block)
+      return [] if messages.nil?
+
+      results = messages
+        .select { |m| role_filter.nil? || m[:role] == role_filter.to_s }
+        .map(&block)
+        .compact
 
-      @ui&.show_info("Compressed (#{original_size} -> #{final_size} messages)")
+      # Flatten if we have nested arrays (from methods returning arrays of items)
+      results.any? { |r| r.is_a?(Array) } ? results.flatten.uniq : results.uniq
+    end
+
+    # Helper: extract tool names from tool_calls
+    private def extract_tool_names(tool_calls)
+      return [] unless tool_calls.is_a?(Array)
+      tool_calls.map { |tc| tc.dig(:function, :name) }
+    end
+
+    # Helper: filter write results by action
+    private def filter_write_results(result, action)
+      result && result[:action] == action ? result[:file] : nil
+    end
+
+    # Helper: filter todo results by status
+    private def filter_todo_results(result, status)
+      result && result[:status] == status ? result[:task] : nil
+    end
+
+    # Helper: extract decision text from content (returns array of decisions or empty array)
+    private def extract_decision_text(content)
+      return [] unless content.is_a?(String)
+      return [] unless content.include?("decision") || content.include?("chose to") || content.include?("using")
+
+      sentences = content.split(/[.!?]/).select do |s|
+        s.include?("decision") || s.include?("chose") || s.include?("using") ||
+        s.include?("decided") || s.include?("will use") || s.include?("selected")
+      end
+      sentences.map(&:strip).map { |s| s[0..100] }
+    end
+
+    # Helper: find in-progress task
+    private def find_in_progress(messages)
+      return nil if messages.nil?
+
+      messages.reverse_each do |m|
+        if m[:role] == "tool"
+          content = m[:content].to_s
+          if content.include?("in progress") || content.include?("working on")
+            return content[/[Tt]ODO[:\s]+(.+)/, 1]&.strip || content[/[Ww]orking[Oo]n[:\s]+(.+)/, 1]&.strip
+          end
+        end
+      end
+      nil
+    end
+
+    # Helper: empty extraction data
+    private def empty_extraction_data
+      {
+        user_msgs: 0,
+        assistant_msgs: 0,
+        tool_msgs: 0,
+        tools_used: [],
+        files_created: [],
+        files_modified: [],
+        decisions: [],
+        completed_tasks: [],
+        in_progress: nil,
+        shell_results: []
+      }
+    end
+
+    private def parse_write_result(content)
+      return nil unless content.is_a?(String)
+
+      # Check for "Created: path" or "Updated: path" patterns
+      if content.include?("Created:")
+        { action: "created", file: content[/Created:\s*(.+)/, 1]&.strip }
+      elsif content.include?("Updated:") || content.include?("modified")
+        { action: "modified", file: content[/Updated:\s*(.+)/, 1]&.strip || content[/File written to:\s*(.+)/, 1]&.strip }
+      else
+        nil
+      end
+    end
+
+    private def parse_todo_result(content)
+      return nil unless content.is_a?(String)
+
+      if content.include?("completed")
+        { status: "completed", task: content[/completed[:\s]*(.+)/i, 1]&.strip || "task" }
+      elsif content.include?("added")
+        { status: "added", task: content[/added[:\s]*(.+)/i, 1]&.strip || "task" }
+      else
+        nil
+      end
+    end
+
+    private def parse_shell_result(content)
+      return nil unless content.is_a?(String)
+
+      if content.include?("passed") || content.include?("success")
+        "tests passed"
+      elsif content.include?("failed") || content.include?("error")
+        "command failed"
+      elsif content =~ /bundle install|npm install|go mod download/
+        "dependencies installed"
+      elsif content.include?("Installed")
+        content[/Installed:\s*(.+)/, 1]&.strip
+      else
+        nil
+      end
+    end
+
+    # Level 1: Detailed summary (for first compression)
+    private def generate_level1_summary(data)
+      parts = []
+
+      parts << "Previous conversation summary (#{data[:user_msgs]} user requests, #{data[:assistant_msgs]} responses, #{data[:tool_msgs]} tool calls):"
+
+      # Files created
+      if data[:files_created].any?
+        files_list = data[:files_created].map { |f| File.basename(f) }.join(", ")
+        parts << "Created: #{files_list}"
+      end
+
+      # Files modified
+      if data[:files_modified].any?
+        files_list = data[:files_modified].map { |f| File.basename(f) }.join(", ")
+        parts << "Modified: #{files_list}"
+      end
+
+      # Completed tasks
+      if data[:completed_tasks].any?
+        tasks_list = data[:completed_tasks].first(3).join(", ")
+        parts << "Completed: #{tasks_list}"
+      end
+
+      # In progress
+      if data[:in_progress]
+        parts << "In Progress: #{data[:in_progress]}"
+      end
+
+      # Key decisions
+      if data[:decisions].any?
+        decisions_text = data[:decisions].map { |d| d.gsub(/\n/, " ").strip }.join("; ")
+        parts << "Decisions: #{decisions_text}"
+      end
+
+      # Tools used
+      if data[:tools_used].any?
+        parts << "Tools: #{data[:tools_used].join(', ')}"
+      end
+
+      parts << "Continuing with recent conversation..."
+      parts.join("\n")
+    end
+
+    # Level 2: Concise summary (for second compression)
+    private def generate_level2_summary(data)
+      parts = []
+
+      parts << "Conversation summary:"
+
+      # Key files (limit to most important)
+      all_files = (data[:files_created] + data[:files_modified]).uniq
+      if all_files.any?
+        key_files = all_files.first(5).map { |f| File.basename(f) }.join(", ")
+        parts << "Files: #{key_files}"
+      end
+
+      # Key accomplishments
+      accomplishments = []
+      accomplishments << "#{data[:completed_tasks].size} tasks completed" if data[:completed_tasks].any?
+      accomplishments << "#{data[:tool_msgs]} tools executed" if data[:tool_msgs] > 0
+      accomplishments << "Level #{data[:completed_tasks].size + 1} progress" if data[:in_progress]
+
+      parts << accomplishments.join(", ") if accomplishments.any?
+
+      parts << "Recent context follows..."
+      parts.join("\n")
+    end
+
+    # Level 3: Minimal summary (for third compression)
+    private def generate_level3_summary(data)
+      parts = []
+
+      parts << "Project progress:"
+
+      # Just counts and key items
+      all_files = (data[:files_created] + data[:files_modified]).uniq
+      parts << "#{all_files.size} files modified, #{data[:completed_tasks].size} tasks done"
+
+      if data[:in_progress]
+        parts << "Currently: #{data[:in_progress]}"
+      end
+
+      parts << "See recent messages for details."
+      parts.join("\n")
+    end
+
+    # Level 4: Ultra-minimal summary (for fourth+ compression)
+    private def generate_level4_summary(data)
+      all_files = (data[:files_created] + data[:files_modified]).uniq
+      "Progress: #{data[:completed_tasks].size} tasks, #{all_files.size} files. Recent: #{data[:tools_used].last(3).join(', ')}"
     end
 
     def get_recent_messages_with_tool_pairs(messages, count)
@@ -837,7 +1345,7 @@ module Clacky
       # with ALL their corresponding tool_results, maintaining the correct order.
       # This is critical for Bedrock Claude API which validates the tool_calls/tool_results pairing.
 
-      return [] if messages.empty?
+      return [] if messages.nil? || messages.empty?
 
       # Track which messages to include
       messages_to_include = Set.new
@@ -923,51 +1431,14 @@ module Clacky
       messages_to_include.to_a.sort.map { |idx| messages[idx] }
     end
 
-    def summarize_messages(messages)
-      # Count different message types
-      user_msgs = messages.count { |m| m[:role] == "user" }
-      assistant_msgs = messages.count { |m| m[:role] == "assistant" }
-      tool_msgs = messages.count { |m| m[:role] == "tool" }
-
-      # Extract key information
-      tools_used = messages
-        .select { |m| m[:role] == "assistant" && m[:tool_calls] }
-        .flat_map { |m| m[:tool_calls].map { |tc| tc.dig(:function, :name) } }
-        .compact
-        .uniq
-
-      # Count completed tasks from tool results
-      completed_todos = messages
-        .select { |m| m[:role] == "tool" }
-        .map { |m| JSON.parse(m[:content]) rescue nil }
-        .compact
-        .select { |data| data.is_a?(Hash) && data["message"]&.include?("completed") }
-        .size
-
-      summary_text = "Previous conversation summary (#{messages.size} messages compressed):\n"
-      summary_text += "- User requests: #{user_msgs}\n"
-      summary_text += "- Assistant responses: #{assistant_msgs}\n"
-      summary_text += "- Tool executions: #{tool_msgs}\n"
-      summary_text += "- Tools used: #{tools_used.join(', ')}\n" if tools_used.any?
-      summary_text += "- Completed tasks: #{completed_todos}\n" if completed_todos > 0
-      summary_text += "\nContinuing with recent conversation context..."
-
-      {
-        role: "user",
-        content: "[SYSTEM] " + summary_text,
-        system_injected: true
-      }
-    end
-
     def confirm_tool_use?(call)
       # Show preview first and check for errors
       preview_error = show_tool_preview(call)
 
       # If preview detected an error, auto-deny and provide feedback
       if preview_error && preview_error[:error]
-        @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 }
+        return { approved: false, feedback: feedback, system_injected: true }
       end
 
       # Request confirmation via UI
@@ -998,7 +1469,7 @@ module Clacky
     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. " \
+        "Tool edit denied: 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
@@ -1126,9 +1597,7 @@ module Clacky
           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)
+        @ui&.show_file_error("Edit file error")
         return {
           error: "String to replace not found in file",
           path: path,
@@ -1172,19 +1641,30 @@ module Clacky
       }
     end
 
-    def build_denied_result(call, user_feedback = nil)
-      message = if user_feedback && !user_feedback.empty?
-                  "Tool use denied by user. User feedback: #{user_feedback}"
-                else
-                  "Tool use denied by user"
-                end
+    def build_denied_result(call, user_feedback = nil, system_injected = false)
+      if system_injected
+        # System-generated feedback (e.g., from preview errors)
+        tool_content = {
+          error: "Tool #{call[:name]} denied: #{user_feedback}",
+          system_injected: true
+        }
+      else
+        # User manually denied or provided feedback
+        message = if user_feedback && !user_feedback.empty?
+                    "Tool use denied by user. User feedback: #{user_feedback}"
+                  else
+                    "Tool use denied by user"
+                  end
 
-      {
-        id: call[:id],
-        content: JSON.generate({
+        tool_content = {
           error: message,
           user_feedback: user_feedback
-        })
+        }
+      end
+
+      {
+        id: call[:id],
+        content: JSON.generate(tool_content)
       }
     end