kward 0.70.0 → 0.71.0

data/lib/kward/prompt_interface/transcript_buffer.rb

@@ -10,7 +10,6 @@ module Kward
         @limit = limit
         @text = +""
         @display_rows_cache_width = nil
-        @display_rows_cache_banner_count = nil
         @display_rows_cache = nil
       end
 
@@ -42,30 +41,23 @@ module Kward
         @text
       end
 
-      def viewport_text(row_count, width, visual_banner_count:, banner_rows:)
-        viewport_rows(row_count, width, visual_banner_count: visual_banner_count, banner_rows: banner_rows).join("\n")
+      def viewport_text(row_count, width)
+        viewport_rows(row_count, width).join("\n")
       end
 
-      def viewport_rows(row_count, width, visual_banner_count:, banner_rows:)
+      def viewport_rows(row_count, width)
         return [] unless row_count.positive?
 
-        rows = display_rows(width, visual_banner_count: visual_banner_count, banner_rows: banner_rows).last(row_count)
+        rows = display_rows(width).last(row_count)
         rows = ([""] * (row_count - rows.length)) + rows if rows.length < row_count
         rows
       end
 
-      def display_rows(width, visual_banner_count:, banner_rows:)
-        if @display_rows_cache_width == width && @display_rows_cache_banner_count == visual_banner_count && @display_rows_cache
-          return @display_rows_cache
-        end
+      def display_rows(width)
+        return @display_rows_cache if @display_rows_cache_width == width && @display_rows_cache
 
-        rows = []
-        visual_banner_count.times { rows.concat(banner_rows.call(width)) }
-        rows << "" if visual_banner_count.positive? && @text.empty?
-        rows.concat(text_display_rows(width))
         @display_rows_cache_width = width
-        @display_rows_cache_banner_count = visual_banner_count
-        @display_rows_cache = rows
+        @display_rows_cache = text_display_rows(width)
       end
 
       def text_display_rows(width)
@@ -77,7 +69,6 @@ module Kward
 
       def invalidate_display_rows_cache
         @display_rows_cache_width = nil
-        @display_rows_cache_banner_count = nil
         @display_rows_cache = nil
       end
     end

data/lib/kward/prompt_interface/transcript_renderer.rb

@@ -11,7 +11,7 @@ module Kward
           prepare_transcript_output_locked unless @restoring_transcript
           if label && @stream_state.block != label
             ensure_transcript_block_separator_locked
-            write_transcript_text_locked("#{colored("#{transcript_label(label)}>", *label_styles(label))}\n")
+            write_transcript_text_locked("#{colored("#{transcript_label(label)}>", *label_styles(label))} ")
             @stream_state.start_block(label)
           end
           write_transcript_text_locked(delta) unless delta.empty?
@@ -82,11 +82,11 @@ module Kward
       end
 
       def transcript_renderable?
-        @visual_banner_count.positive? || !@transcript_buffer.empty?
+        !@transcript_buffer.empty?
       end
 
       def transcript_display_rows(width)
-        @transcript_buffer.display_rows(width, visual_banner_count: @visual_banner_count, banner_rows: method(:banner_rows))
+        @transcript_buffer.display_rows(width)
       end
 
       def transcript_text_display_rows(width)

data/lib/kward/prompt_interface.rb

@@ -41,7 +41,6 @@ module Kward
     FOOTER_REFRESH_INTERVAL = 1.0
     COMPOSER_MAX_INPUT_ROWS = 6
     TRANSCRIPT_BUFFER_LIMIT = 200_000
-    BANNER_LOGO_PIXELS = Banner::LOGO_PIXELS
     BANNER_MESSAGE = Banner::MESSAGE
 
     include SlashOverlay
@@ -70,6 +69,8 @@ module Kward
     EXIT_INPUT = :exit_input
     CANCEL_INPUT = :cancel_input
     SELECT_CANCEL = :select_cancel
+    SELECT_CONTINUE = :select_continue
+    SELECT_ACTION_MINIMUM_BUSY_SECONDS = 1.0
 
     # Submitted input string carrying optional display text for transcripts.
     class SubmittedInput < String
@@ -81,7 +82,7 @@ module Kward
       end
     end
 
-    def initialize(input: $stdin, output: $stdout, slash_commands: [], overlay_settings: nil, footer: nil, composer_status: nil, busy_help: true, attachment_badges: nil, attachment_parser: nil, banner_pixels: nil, banner_message: nil)
+    def initialize(input: $stdin, output: $stdout, slash_commands: [], overlay_settings: nil, footer: nil, composer_status: nil, busy_help: true, attachment_badges: nil, attachment_parser: nil, banner_message: nil)
       @input_io = input
       @output_io = output
       @reader = TTY::Reader.new(input: input, output: output, interrupt: :error)
@@ -105,7 +106,6 @@ module Kward
       @last_composer_rows = []
       @cursor_rendered_row = 0
       @transcript_buffer = TranscriptBuffer.new(limit: TRANSCRIPT_BUFFER_LIMIT)
-      @visual_banner_count = 0
       @transcript_viewport_rows = 0
       @restoring_transcript = false
       @pending_keys = []
@@ -128,7 +128,7 @@ module Kward
       @busy_help = busy_help
       @attachment_badges = attachment_badges
       @attachment_parser = attachment_parser
-      @banner = Banner.new(message: banner_message, pixels: banner_pixels, screen_height: method(:screen_height))
+      @banner = Banner.new(message: banner_message, screen_height: method(:screen_height))
     end
 
     def start(render: true)
@@ -203,7 +203,6 @@ module Kward
         @output_io.print(SYNCHRONIZED_OUTPUT_ENABLE)
         clear_prompt_for_output_locked unless @rendered_rows.zero? && @last_composer_rows.empty?
         @transcript_buffer.clear
-        @visual_banner_count = 0
         @transcript_viewport_rows = 0
         @stream_state.finish_block
         @stream_state.reset
@@ -275,23 +274,15 @@ module Kward
       [overlay_card_width(screen_width) - 6, 1].max
     end
 
-    def select(message, choices, title: "Sessions", custom: false, initial_index: 0)
+    def select(message, choices, title: "Sessions", custom: false, initial_index: 0, action_keys: {}, action_handlers: {})
       return nil if choices.empty? && !custom
 
       start
       @mutex.synchronize do
-        @prompt_label = message.to_s
-        self.composer_input = ""
-        self.composer_cursor = 0
-        @composer.clear_attachments
-                  @pending_keys.clear
-        @asking = true
-        @busy = false
-        @queued_count = 0
+        prepare_modal_input_locked(message, clear_attachments: true)
         choice_labels = choices.map(&:to_s)
         selection_index = choice_labels.empty? ? 0 : [[initial_index.to_i, 0].max, choice_labels.length - 1].min
-        @select_state = { choices: choice_labels, selection_index: selection_index, title: title.to_s, custom: custom }
-        reset_history_navigation
+        @select_state = { choices: choice_labels, selection_index: selection_index, title: title.to_s, custom: custom, action_keys: normalized_select_action_keys(action_keys), search_active: false }
         render_prompt_locked
       end
 
@@ -305,12 +296,20 @@ module Kward
             render_prompt_locked if resized || footer_refreshed
           else
             result = handle_select_key(key)
-            render_prompt_locked unless result.is_a?(String) || result == SELECT_CANCEL
+            result = drain_pending_select_keys_locked(result)
+            render_prompt_locked unless result.is_a?(String) || select_action_result?(result) || result == SELECT_CANCEL
           end
         end
 
-        if result.is_a?(String) || result == SELECT_CANCEL
-          finish_select_prompt
+        if select_action_result?(result) && select_action_handler(result, action_handlers)
+          action_result = run_select_action(result, select_action_handler(result, action_handlers))
+          next if action_result == SELECT_CONTINUE
+
+          return action_result
+        end
+
+        if result.is_a?(String) || select_action_result?(result) || result == SELECT_CANCEL
+          finish_select_prompt(render: !select_deferred_finish_render?(result))
           return result == SELECT_CANCEL ? nil : result
         end
 
@@ -430,20 +429,16 @@ module Kward
       end
     end
 
-    def print_visual_banner
+    def print_visual_banner(message = nil)
       @mutex.synchronize do
         width, height = screen_size
-        rows = banner_rows(width)
+        rows = banner_rows(width, message: message)
         return if rows.empty?
 
         with_synchronized_output_locked do
           prepare_transcript_output_locked
-          rows.each do |row|
-            write_visual_transcript_text_locked(row)
-            write_visual_transcript_text_locked("\n")
-          end
-          @visual_banner_count += 1
-          invalidate_transcript_display_rows_cache
+          write_transcript_text_locked(rows.join("\n"))
+          write_transcript_text_locked("\n")
           remember_transcript_viewport_locked(height)
           @stream_state.finish_block
           restore_composer_cursor_locked
@@ -487,7 +482,6 @@ module Kward
     def clear_transcript
       @mutex.synchronize do
         @transcript_buffer.clear
-        @visual_banner_count = 0
         @transcript_viewport_rows = 0
         @stream_state.finish_block
         @stream_state.reset

data/lib/kward/prompts/commands.rb

@@ -11,7 +11,9 @@ module Kward
       { name: "sessions", description: "Open the saved sessions picker.", argument_hint: "[path]" },
       { name: "resume", description: "Alias for /sessions.", argument_hint: "[path]" },
       { name: "name", description: "Name or clear the current session.", argument_hint: "[name]" },
+      { name: "rename", description: "Rename the current session.", argument_hint: "<name>" },
       { name: "clone", description: "Clone the current session.", argument_hint: "" },
+      { name: "fork", description: "Fork from an earlier prompt into a new session.", argument_hint: "" },
       { name: "rewind", description: "Revisit an earlier prompt and try a different direction.", argument_hint: "" },
       { name: "tree", description: "Inspect and navigate the full technical session tree.", argument_hint: "" },
       { name: "copy", description: "Copy clean session text to the clipboard.", argument_hint: "[last|transcript]" },
@@ -21,7 +23,6 @@ module Kward
       { name: "settings", description: "Configure prompt overlays.", argument_hint: "" },
       { name: "login", description: "Log in with an OAuth provider.", argument_hint: "" },
       { name: "model", description: "Select the default model.", argument_hint: "" },
-      { name: "openrouter/catalog", description: "List the full OpenRouter model catalog.", argument_hint: "" },
       { name: "reasoning", description: "Select reasoning effort.", argument_hint: "" },
       { name: "reload", description: "Reload installed plugins.", argument_hint: "" },
       { name: "status", description: "Show the current status message.", argument_hint: "" },

data/lib/kward/prompts.rb

@@ -32,9 +32,9 @@ module Kward
 
     def base_prompt
       <<~PROMPT.strip
-        You are Kward, a concise practical CLI coding agent. You are allowed to use the tools. Help users understand and modify software projects. Inspect files before changing them, make the smallest correct change, preserve existing style, and summarize what changed. Be honest about limitations.
+        You are Kward, a concise practical CLI coding agent. Use tools to understand and modify software projects. Inspect files before changing them, make the smallest correct change, preserve existing style, and summarize what changed. Be honest about limitations.
 
-        For web research, use web_search to discover sources, then fetch_content for important human-readable pages before relying on them. Use fetch_raw for machine-readable resources such as JSON, YAML, XML, RSS, OpenAPI specs, and plain text. Prefer official or primary sources when practical, and cite or mention the URLs you relied on.
+        For web research, use web_search to discover sources, fetch_content for important human-readable pages, and fetch_raw for machine-readable resources such as JSON, YAML, XML, RSS, OpenAPI specs, and plain text. Prefer official or primary sources and cite or mention the URLs you relied on.
       PROMPT
     end
 

data/lib/kward/rpc/server.rb

@@ -49,7 +49,7 @@ module Kward
         "sessions/tree", "sessions/tree/setLabel", "sessions/tree/navigate",
         "sessions/export", "sessions/delete", "sessions/close", "sessions/transcript"
       ].freeze
-      MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set", "openrouter/catalog"].freeze
+      MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set"].freeze
       AUTH_METHODS = [
         "auth/status", "auth/providers", "auth/loginWithApiKey", "auth/logoutProvider",
         "auth/loginWithOAuth", "auth/startOpenAILogin", "auth/submitOpenAICode", "auth/loginStatus"
@@ -166,8 +166,6 @@ module Kward
           prompts_expand(params)
         when "models/list"
           models_list
-        when "openrouter/catalog"
-          openrouter_catalog
         when "models/current"
           models_current
         when "models/set"
@@ -362,7 +360,8 @@ module Kward
             supported: true,
             methods: MODEL_METHODS,
             fields: ["provider", "id", "name", "reasoning", "reasoningEffort", "contextWindow"],
-            scopedModels: false
+            scopedModels: false,
+            openRouterRefresh: { supported: false, reason: "cliOnlyCacheRefresh" }
           },
           runtime: {
             supported: true,
@@ -458,10 +457,6 @@ module Kward
         { models: @session_manager.available_models }
       end
 
-      def openrouter_catalog
-        { models: @session_manager.openrouter_catalog }
-      end
-
       def config_update(params)
         config = @config_manager.update(params.fetch("values"))
         @session_manager.refresh_client_config

data/lib/kward/rpc/session_manager.rb

@@ -485,11 +485,6 @@ module Kward
         normalized
       end
 
-      def openrouter_catalog
-        models = @client.respond_to?(:openrouter_catalog) ? Array(@client.openrouter_catalog) : []
-        models.map { |model| normalize_model(model) }
-      end
-
       def current_model
         provider = @client.respond_to?(:current_provider) ? @client.current_provider : nil
         model = @client.respond_to?(:current_model) ? @client.current_model : nil
@@ -503,7 +498,7 @@ module Kward
         model = rpc_session.conversation.model || current[:id]
         reasoning_effort = rpc_session.conversation.reasoning_effort || current_reasoning_effort
         reasoning_effort = nil unless ModelInfo.reasoning_supported?(provider, model)
-        context_window = current[:contextWindow] if provider == current[:provider] && model == current[:id]
+        context_window = context_window_for(provider, model)
         normalize_model(
           provider: provider,
           id: model,
@@ -666,6 +661,11 @@ module Kward
       end
 
       def normalize_model(model)
+        unless model.key?(:contextWindow) || model.key?("contextWindow")
+          provider = model[:provider] || model["provider"]
+          id = model[:id] || model["id"] || model[:model] || model["model"]
+          model = model.merge(contextWindow: context_window_for(provider, id))
+        end
         ModelInfo.normalize(
           model,
           current_provider: (@client.current_provider if @client.respond_to?(:current_provider)),
@@ -674,6 +674,17 @@ module Kward
         )
       end
 
+      def context_window_for(provider, model)
+        provider = ModelInfo.provider_label(provider)
+        return @client.context_window(provider, model) if @client.respond_to?(:context_window) && @client.method(:context_window).arity != 0
+
+        if @client.respond_to?(:current_context_window) && @client.respond_to?(:current_provider) && @client.respond_to?(:current_model)
+          return @client.current_context_window if provider == @client.current_provider && model == @client.current_model
+        end
+
+        ModelInfo.context_window(provider, model)
+      end
+
       def active_persona_label(rpc_session)
         ConfigFiles.active_persona_label(
           workspace_root: rpc_session.workspace_root,

data/lib/kward/session_store.rb

@@ -496,9 +496,29 @@ module Kward
 
     def session_header(records, path)
       header = records.find { |record| record["type"] == "session" }
-      raise "Invalid Kward session file: #{path}" unless header && header["id"].to_s != ""
+      return header if header && header["id"].to_s != ""
 
-      header
+      recovered = recovered_session_header(records, path)
+      return recovered if recovered
+
+      raise "Invalid Kward session file: #{path}"
+    end
+
+    def recovered_session_header(records, path)
+      return nil unless records.any? { |record| ["message", "session_info", "system_prompt", "memory_state"].include?(record["type"]) }
+
+      basename = File.basename(path)
+      match = basename.match(/\A(?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z)_(?<id>[0-9a-fA-F-]{36})\.jsonl\z/)
+      return nil unless match
+
+      timestamp = match[:timestamp].tr("-", ":").sub(/\A(\d{4}):(\d{2}):(\d{2})T/, "\\1-\\2-\\3T")
+      {
+        "type" => "session",
+        "version" => VERSION,
+        "id" => match[:id],
+        "timestamp" => timestamp,
+        "cwd" => @cwd
+      }
     end
 
     def session_named?(session)
@@ -756,8 +776,7 @@ module Kward
 
     def session_info(path)
       records = records_from_file(path)
-      header = records.find { |record| record["type"] == "session" }
-      return nil unless header && header["id"].to_s != ""
+      header = session_header(records, path)
 
       messages = restored_messages(records)
       name = session_name(records)

data/lib/kward/telemetry/logger.rb

@@ -8,13 +8,14 @@ require_relative "../rpc/redactor"
 module Kward
   # Append-only JSONL telemetry logger with secret-conscious error payloads.
   class TelemetryLogger
-    CATEGORIES = %w[tokens performance tools errors].freeze
+    CATEGORIES = %w[tokens performance tools errors compaction].freeze
     ENV_KEYS = {
       "enabled" => "KWARD_LOGGING",
       "tokens" => "KWARD_LOGGING_TOKENS",
       "performance" => "KWARD_LOGGING_PERFORMANCE",
       "tools" => "KWARD_LOGGING_TOOLS",
-      "errors" => "KWARD_LOGGING_ERRORS"
+      "errors" => "KWARD_LOGGING_ERRORS",
+      "compaction" => "KWARD_LOGGING_COMPACTION"
     }.freeze
     DEFAULT_MAX_BYTES = 10 * 1024 * 1024
 
@@ -101,7 +102,8 @@ module Kward
         "tokens" => truthy?(logging["tokens"]),
         "performance" => truthy?(logging["performance"]),
         "tools" => truthy?(logging["tools"]),
-        "errors" => truthy?(logging["errors"])
+        "errors" => truthy?(logging["errors"]),
+        "compaction" => truthy?(logging["compaction"])
       }
     rescue StandardError
       CATEGORIES.each_with_object({ "enabled" => false }) { |category, result| result[category] = false }

data/lib/kward/tool_output_compactor.rb

@@ -0,0 +1,127 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Deterministically trims large tool outputs before they are appended to the
+  # model-facing transcript.
+  #
+  # The original output is still handed to session/tool-execution persistence by
+  # ToolRegistry; this object only decides what the next model call sees. Keep it
+  # conservative: small outputs and short errors are more valuable verbatim than
+  # compacted.
+  class ToolOutputCompactor
+    MIN_BYTES = 12 * 1024
+    ERROR_OUTPUT_MAX_BYTES = 8 * 1024
+    HEAD_LINES = 40
+    TAIL_LINES = 40
+    ERROR_CONTEXT_LINES = 2
+
+    ERROR_PATTERN = /\b(error|fatal|failed|failure|exception|traceback|panic|segmentation fault|assertion)\b/i.freeze
+    TEST_PATTERN = /(^\s*\d+\)\s|\b(\d+\s+(tests?|examples?|runs?|assertions?|failures?|errors?|skips?)|finished in|failures?:|seed\s+\d+)\b)/i.freeze
+    SEARCH_PATTERN = /(^\#{1,6}\s+\S+|^[-*]\s+\S+|\S+:\d+:|https?:\/\/\S+)/.freeze
+
+    def compact(tool_name, content, artifact_id: nil)
+      text = normalize(content)
+      return text unless text.bytesize > MIN_BYTES
+      return text if error_output?(text) && text.bytesize <= ERROR_OUTPUT_MAX_BYTES
+
+      compacted = tool_name.to_s == "run_shell_command" ? compact_shell_output(text) : compact_lines(text)
+      return text if compacted == text
+      return text if compacted.bytesize >= text.bytesize
+
+      artifact_id = yield if artifact_id.nil? && block_given?
+      header = compacted_header(tool_name, text, compacted, artifact_id: artifact_id)
+      candidate = "#{header}\n\n#{compacted}"
+      candidate.bytesize < text.bytesize ? candidate : text
+    end
+
+    private
+
+    def normalize(content)
+      return content unless content.is_a?(String)
+
+      Conversation.normalize_tool_content(content)
+    end
+
+    def error_output?(text)
+      text.match?(ERROR_PATTERN)
+    end
+
+    def compact_shell_output(text)
+      sections = shell_sections(text)
+      return compact_lines(text) if sections.empty?
+
+      sections.map do |heading, body|
+        next heading if body.empty?
+
+        "#{heading}\n#{compact_lines(body)}"
+      end.join("\n")
+    end
+
+    def shell_sections(text)
+      parts = text.split(/\n(?=STDOUT:\n|STDERR:\n)/)
+      return [] if parts.length < 2
+
+      parts.map do |part|
+        heading, body = part.split("\n", 2)
+        [heading, body.to_s]
+      end
+    end
+
+    def compact_lines(text)
+      lines = text.split("\n", -1)
+      selected = selected_line_indexes(lines)
+      return text if selected.length >= lines.length
+
+      render_selected_lines(lines, selected)
+    end
+
+    def selected_line_indexes(lines)
+      indexes = []
+      indexes.concat((0...[HEAD_LINES, lines.length].min).to_a)
+      indexes.concat(priority_context_indexes(lines))
+
+      tail_start = [lines.length - TAIL_LINES, 0].max
+      indexes.concat((tail_start...lines.length).to_a)
+      indexes.uniq.sort
+    end
+
+    def priority_context_indexes(lines)
+      indexes = []
+      lines.each_with_index do |line, index|
+        next unless line.match?(ERROR_PATTERN) || line.match?(TEST_PATTERN) || line.match?(SEARCH_PATTERN)
+
+        first = [index - ERROR_CONTEXT_LINES, 0].max
+        last = [index + ERROR_CONTEXT_LINES, lines.length - 1].min
+        indexes.concat((first..last).to_a)
+      end
+      indexes
+    end
+
+    def render_selected_lines(lines, selected)
+      output = []
+      previous = nil
+      selected.each do |index|
+        if previous && index > previous + 1
+          output << "[... omitted lines #{previous + 2}-#{index} ...]"
+        end
+        output << lines[index]
+        previous = index
+      end
+      output.join("\n")
+    end
+
+    def compacted_header(tool_name, original, compacted, artifact_id: nil)
+      [
+        "[Tool output compacted by Kward: #{original.bytesize} bytes -> #{compacted.bytesize} bytes]",
+        "Tool: #{tool_name}",
+        "Preserved first #{HEAD_LINES} lines, last #{TAIL_LINES} lines, and error/failure/search context.",
+        retrieval_instruction(artifact_id)
+      ].join("\n")
+    end
+
+    def retrieval_instruction(artifact_id)
+      return "Full output is retained outside model context." if artifact_id.to_s.empty?
+
+      "Full output id: #{artifact_id}. Use retrieve_tool_output to inspect it."
+    end
+  end
+end

data/lib/kward/tools/base.rb

@@ -24,8 +24,8 @@ module Kward
             description: @description,
             parameters: {
               type: "object",
-              properties: @properties,
-              required: @required,
+              properties: sorted_properties,
+              required: @required.sort,
               additionalProperties: false
             }
           }
@@ -34,6 +34,12 @@ module Kward
 
       private
 
+      def sorted_properties
+        @properties.keys.sort_by(&:to_s).each_with_object({}) do |key, result|
+          result[key] = @properties[key]
+        end
+      end
+
       # Reads a tool argument while accepting symbol or string keys from restored calls.
       def argument(args, key, default = nil)
         return args[key] if args.key?(key)

data/lib/kward/tools/registry.rb

@@ -1,4 +1,5 @@
 require_relative "../config_files"
+require_relative "../conversation"
 require_relative "ask_user_question"
 require_relative "code_search"
 require_relative "edit_file"
@@ -8,12 +9,16 @@ require_relative "list_directory"
 require_relative "read_file"
 require_relative "read_skill"
 require_relative "run_shell_command"
+require_relative "summarize_file_structure"
+require_relative "retrieve_tool_output"
 require_relative "web_search"
 require_relative "write_file"
 require_relative "search/code"
 require_relative "search/web"
 require_relative "search/web_fetch"
 require_relative "tool_call"
+require_relative "../telemetry/logger"
+require_relative "../tool_output_compactor"
 require_relative "../workspace"
 
 # Namespace for the Kward CLI agent runtime.
@@ -53,7 +58,7 @@ module Kward
     # @param web_search_enabled [Boolean, nil] override for web search exposure
     # @param skills [Array<ConfigFiles::Skill>, nil] override discovered skills
     # @param ask_user_question_enabled [Boolean, nil] override question exposure
-    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil)
+    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new)
       @workspace = workspace
       @prompt = prompt
       @web_search = web_search
@@ -62,6 +67,8 @@ module Kward
       @skills = skills
       @web_search_enabled = web_search_enabled
       @ask_user_question_enabled = ask_user_question_enabled
+      @tool_output_compactor = tool_output_compactor
+      @telemetry_logger = telemetry_logger
       @tools = build_tools.freeze
       @schemas = build_schema_tools.map(&:schema).freeze
     end
@@ -87,26 +94,48 @@ module Kward
                 else
                   "Unknown tool: #{name}"
                 end
-
+      content = Conversation.normalize_tool_content(content)
+      duplicate_id = conversation.tool_output_artifact_id_for(tool_name: name, content: content)
+      if conversation.tool_output_artifacts.key?(duplicate_id)
+        content = "[Same as previous tool output #{duplicate_id}; not repeated. Use retrieve_tool_output to inspect it.]"
+      end
+
+      artifact_id = nil
+      model_content = @tool_output_compactor.compact(name, content) do
+        artifact_id ||= conversation.store_tool_output_artifact(tool_name: name, content: content)
+      end
+      log_tool_output_compaction(name, artifact_id: artifact_id, before: content, after: model_content) if model_content != content
       conversation.append_tool(
         tool_call_id: tool_call["id"] || tool_call[:id],
         name: name,
-        content: content
+        content: model_content
       )
       conversation.append_tool_execution(tool_call: tool_call, content: content)
 
-      content
+      model_content
     end
 
     private
 
+    def log_tool_output_compaction(name, artifact_id:, before:, after:)
+      @telemetry_logger.log(
+        "compaction",
+        "tool_output",
+        "tool_name" => name,
+        "artifact_id" => artifact_id,
+        "bytes_before" => before.bytesize,
+        "bytes_after" => after.bytesize,
+        "bytes_saved" => before.bytesize - after.bytesize
+      )
+    end
+
     def build_tools
       all_tools.to_h { |tool| [tool.name, tool] }
     end
 
     def build_schema_tools
       tools = @tools.values_at(
-        "list_directory", "read_file", "write_file", "edit_file", "run_shell_command", "code_search"
+        "list_directory", "read_file", "write_file", "edit_file", "run_shell_command", "code_search", "summarize_file_structure", "retrieve_tool_output"
       )
       tools.concat(@tools.values_at("web_search", "fetch_content", "fetch_raw")) if web_search_available?
       tools << @tools["read_skill"] if skills_available?
@@ -131,7 +160,9 @@ module Kward
         Tools::WriteFile.new(workspace: @workspace),
         Tools::EditFile.new(workspace: @workspace),
         Tools::RunShellCommand.new(workspace: @workspace),
-        Tools::CodeSearch.new(code_search: @code_search)
+        Tools::CodeSearch.new(code_search: @code_search),
+        Tools::SummarizeFileStructure.new(workspace: @workspace),
+        Tools::RetrieveToolOutput.new
       ]
     end