ollama_chat 0.0.113 → 0.0.114

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e618b797bf1b5fa84728816e06b83fe3540424b48256ba107deb29c2beb8a219
-  data.tar.gz: f5abee2701f3fc6d7ba09513f0b0bd5133c7ec10ddb511ee5ea4238c14f9988e
+  metadata.gz: e5e93e610536ac396d18e929ef76b3dcecac7d3b9d88a35b8d6ff141e7eba8e4
+  data.tar.gz: a7792a3b397ebcc0d88552f0fa1417933f44ff00c6e0fad4eb62d567b5c98bfd
 SHA512:
-  metadata.gz: 2f2172cc90da0a8b8c1b7f2306abbc8480db92abeb3629e20b2471e88fdd79ca2d18c209c05690167b564b6911685222dce48496e9825330e43500ff520aab74
-  data.tar.gz: da6e5e8583b11cb7d766ff0745e97070f2a39ac8f1ca6314a4bcb93d8e9a6c3ec9ef087a055b7c9844317f831fc4a6a590e11f80eaf6b6c80980143ab8385771
+  metadata.gz: 95a81969d48e98ff06623f887c33bd0acf94452639fabbf4eca30127ef4d300124f9e12d7bbb97a3d8d86263116d3c772e5d9c403d1e4f4cbdc2df241e1f719f
+  data.tar.gz: 92201492f3a4a084c845d11f7957b6af6ea8630e7f242158458cb1bad059bababb8699f0dc2f24204ddfde38bcd47e8491812e03d5f38128f179b443f858a9dc

data/CHANGES.md

@@ -1,5 +1,86 @@
 # Changes
 
+## 2026-09-01 v0.0.114
+
+### Added
+
+* Context compaction pipeline:
+  * `OllamaChat::Compaction` module with `summarize_for_compaction`,
+    `compact_with_retry`, `compact_ratio_tokens`, `tool_summary_line`, and
+    `Result` value object.
+  * `CompactionError` exception.
+  * `MessageList` methods: `compact!`, `find_cut_point`, `find_summary`,
+    `compacted_messages`, `compacted_estimate_tokens`, and
+    `full_estimate_tokens`.
+  * `lookup_group` tool for retrieving pre-summary group content by UUID
+    suffix.
+  * `summary_template` base method in `Tools::Concern` and `message` field in
+    `eval_ruby` and `get_rfc` results.
+  * `compaction:` configuration block (`enabled`, `reserve`, `keep_recent`) and
+    `prompts.compaction` templates in `default_config.yml`.
+  * `conversation_length` in `Information` and dynamic runtime values.
+* Per-message token estimation:
+  * `#token_estimate(strip_thinking:)` in `OllamaChat::MessageMixin`.
+  * `#total_tokens(strip_thinking:)` in `OllamaChat::MessageList`.
+* Color-coded context gauge:
+  * `context_gauge` method in `information.rb` displaying context usage with
+    ANSI colors and emoji indicators.
+* Configurable syntax checkers for file tools:
+  * `syntax_checkers:` block in `default_config.yml` for `ruby`, `javascript`,
+    `python`, and `shell`.
+  * `ConfigHandling#syntax_checker_for` and `ConfigHandling#run_syntax_check`
+    methods.
+  * Integration into `Tools::WriteFile#execute` and `Tools::PatchFile#execute`.
+* Log rotation and restructured log configuration:
+  * `LOG` module (`CHAT`, `DATABASE`, `TAIL_LINES`) in `oc.rb`.
+  * `OllamaChat::Utils::LogRotation.truncate_tail` for in-place log truncation.
+  * `truncate_logs` call in `OllamaChat::Chat#initialize`.
+  * Database `Logger` level set to `WARN`.
+* Enabled flag for RAG collections:
+  * Migration adding `enabled` boolean to `collections` table.
+  * Filtering of disabled collections in `information.rb` and
+    `search_knowledge`.
+  * Interactive toggle in `edit_collection` and `[DISABLED]` suffix in
+    `list_collections`.
+* Monochrome flags:
+  * `-m` flag for `bin/ollama_chat_send` to strip ANSI codes from stdin.
+  * `-m` flag for `/input` command to strip ANSI codes from file content and
+    import results.
+* Session synchronization:
+  * `session_sync` method extracted from `session_close` in
+    `session_management.rb`.
+  * `ensure session.lock` in `set_new_session`.
+
+### Changed
+
+* Increased `compaction.reserve.ratio` from **0.30** to **0.60** in
+  `default_config.yml`.
+* Switched `Struct.new` to `Data.define` in `ModelMetadata`, `Estimate`, and
+  `TagResult`.
+* Standardized user-facing output format to `tokens (bytes)` across
+  `read_file`, `write_file`, `session_management`, and `information`.
+* Replaced `.size` with `.bytesize` for multi-byte-safe byte counts in
+  `token_estimator/crude.rb`, `fetcher.rb`, `paste_from_clipboard.rb`, and
+  `prompt_handling.rb`.
+* Updated `/conversation compact` to delegate to `compact_with_retry`.
+* Threaded `chat` into `TagResolver` for logging, fixing `NoMethodError` in
+  rescue blocks.
+* Capped inline directory structure depth:
+  * Added `parsing.directory_structure_max_depth` (default **1**) to
+    `default_config.yml`.
+  * Shifted `max_depth` semantics: **1** = immediate children, **2** = children
+    + grandchildren, `nil` = unlimited.
+* Acknowledged prompt state after `/prompt sync` to suppress boot drift nag.
+* Reordered `session_title` prompt for reliability.
+* `/config diff` now calls `reload_config` after `diff_config`.
+* Reordered `/config` subcommand alternatives to `edit diff reload`.
+* Clarified `suffix` description in `directory_structure` as "file extension".
+
+### Fixed
+
+* `NoMethodError` in `TagResolver#resolve` rescue block.
+* Unbounded tree expansion in directory structure parsing.
+
 ## 2026-08-25 v0.0.113
 
 *   Simplified hash syntax by replacing `text: text` with `text:` etc.

data/README.md

@@ -37,6 +37,9 @@ The following environment variables can be used to configure behavior:
 - `OLLAMA_CHAT_HISTORY` - Chat history filename
 - `OLLAMA_CHAT_USER` - Full name of the chat user
 - `OLLAMA_CHAT_DEBUG` - Debug mode toggle (1 = enabled)
+- `OLLAMA_CHAT_LOG_CHAT` - Chat log file path (default: `$XDG_STATE_HOME/chat.log`)
+- `OLLAMA_CHAT_LOG_DATABASE` - Database log file path (default: `$XDG_STATE_HOME/database.log`)
+- `OLLAMA_CHAT_LOG_TAIL_LINES` - Max lines to retain in log files (default: `10000`)
 
 #### Tool Configuration
 - `OLLAMA_CHAT_TOOLS_TEST_RUNNER` - Configured test runner for `run_tests` (default: `rspec`)
@@ -45,11 +48,14 @@ The following environment variables can be used to configure behavior:
 - `OLLAMA_CHAT_TOOLS_JIRA_URL` - Base URL for Jira instance
 - `OLLAMA_CHAT_TOOLS_JIRA_USER` - Username for Jira authentication
 - `OLLAMA_CHAT_TOOLS_JIRA_API_TOKEN` - API token for Jira authentication
+- `OLLAMA_CHAT_TOOLS_JIRA_TWG` - Path to the twg CLI binary
 - `OLLAMA_CHAT_TOOLS_IMAGE_GENERATOR_URL` - Base URL for ComfyUI server
 - `OLLAMA_CHAT_TOOLS_IMAGE_GENERATOR_WORKFLOW` - ComfyUI workflow as JSON string
 - `OLLAMA_CHAT_TOOLS_IMAGE_GENERATOR_PROMPT_NODE_ID` - Prompt node ID
 - `OLLAMA_CHAT_TOOLS_IMAGE_GENERATOR_FILENAME_PREFIX_NODE_ID` - Filename prefix node ID
 - `OLLAMA_CHAT_TOOLS_PIRATEWEATHER_API_KEY` - Pirate Weather API key
+- `OLLAMA_CHAT_TOOLS_GHR_URL` - Base URL for GHR API server
+- `OLLAMA_CHAT_TOOLS_RUBY_EVAL_IMAGE_TEMPLATE` - Docker image template for `eval_ruby` (default: `ruby:%{version}-alpine`)
 
 #### System & Infrastructure
 - `XDG_CONFIG_HOME` - XDG Configuration home directory
@@ -59,6 +65,7 @@ The following environment variables can be used to configure behavior:
 - `EDITOR` - Default text editor
 - `BROWSER` - Default web browser
 - `DIFF_TOOL` - Tool for diff operations (default: `vimdiff`)
+- `DIFF_COMMAND` - Command to generate unified diffs (default: `diff -u --color=always`)
 - `KRAMDOWN_ANSI_OLLAMA_CHAT_STYLES` - Custom ANSI styles for Markdown formatting
 - `KRAMDOWN_ANSI_STYLES` - Fallback ANSI styles configuration
 - `OLLAMA_REDIS_URL` - Redis connection URL for documents (documentrix)

data/bin/ollama_chat_log

@@ -5,7 +5,7 @@ require 'file/tail'
 require 'tins/xt'
 
 opts     = Tins::GO.go 'fm:n:h:', defaults: { ?n => 10  }
-log_path = ARGV.shift || OC::OLLAMA::CHAT::LOGFILE
+log_path = ARGV.shift || OC::OLLAMA::CHAT::LOG::CHAT
 
 if opts[?h]
   puts <<~EOT

data/bin/ollama_chat_send

@@ -5,7 +5,7 @@ include OllamaChat::FileEditing
 require 'tins/go'
 include Tins::GO
 
-opts = go 'f:d:F:rteph', ARGV
+opts = go 'f:d:F:rtemph', ARGV
 
 # Displays the usage information for the ollama_chat_send command.
 #
@@ -25,6 +25,7 @@ def usage(rc = 0)
       -f CONFIG  file to read
       -d DIR     the working directory to derive the socket file from
       -e         Edit content in editor before sending
+      -m         Strip ANSI color codes from content before sending
       -F FORMAT  file extension for editor (e.g., rb, md)
       -h         Show this help message
 
@@ -42,6 +43,7 @@ begin
            opts[?r] ? :socket_input_with_response : :socket_input
          end
   content = STDIN.read
+  content = Term::ANSIColor.uncolor(content) if opts[?m]
   if opts[?e]
     basename = %w[ text ]
     basename << opts[?F]&.sub(/\A(?=[^.])/, ?.) || '.md'

data/lib/ollama_chat/chat.rb

@@ -69,6 +69,7 @@ class OllamaChat::Chat
   include OllamaChat::PromptHandling
   include OllamaChat::SystemPromptManagement
   include OllamaChat::PromptManagement
+  include OllamaChat::Compaction
   include OllamaChat::Utils::Chooser
   include OllamaChat::Utils::ValueFormatter
   include OllamaChat::Utils::UTF8Converter
@@ -106,10 +107,11 @@ class OllamaChat::Chat
     @opts[?V] and exit version
     @ollama_chat_config = OllamaChat::OllamaChatConfig.new(@opts[?f])
     self.config         = @ollama_chat_config.config
+    truncate_logs
     @messages           = OllamaChat::MessageList.new(self)
     OllamaChat::Database.setup_models.each { _1.ask_and_send(:seed, self) }
-    setup_session
     setup_switches
+    setup_session
     setup_state_selectors(config)
     connect_ollama
     @documents = setup_documents
@@ -254,12 +256,14 @@ class OllamaChat::Chat
   # and a user message, executing it as a one-shot chat interaction.
   #
   # @param system [String] the system prompt to guide the model's behavior
-  # (defaults to current raw_system_prompt)
-  #
+  #   (defaults to current raw_system_prompt)
   # @param prompt [String] the user prompt to send to the model
+  # @param stream [Boolean] whether to stream the response (default: false)
+  # @param think [Boolean] enable thinking mode for hybrid-thinking models
+  #   (default: false)
   #
   # @return [String] the content of the resulting response message
-  def generate(system: raw_system_prompt, prompt:)
+  def generate(system: raw_system_prompt, prompt:, stream: false, think: false)
     messages = [
       OllamaChat::Message.new(
         role:        'system',
@@ -276,9 +280,8 @@ class OllamaChat::Chat
       model:    @model,
       messages: ,
       options:  model_options,
-      stream:   false,
-      think:    false,
-      tools:
+      stream:   ,
+      think:
     )&.message&.content.to_s
 
     if content.empty?
@@ -315,6 +318,18 @@ class OllamaChat::Chat
     ollama.chat(**opts, &block)
   end
 
+  # Truncates chat.log and database.log to the configured tail line count
+  # before any new logging begins for this session.
+  def truncate_logs
+    keep = OC::OLLAMA::CHAT::LOG::TAIL_LINES
+    OllamaChat::Utils::LogRotation.truncate_tail(
+      OC::OLLAMA::CHAT::LOG::CHAT, keep_lines: keep
+    )
+    OllamaChat::Utils::LogRotation.truncate_tail(
+      OC::OLLAMA::CHAT::LOG::DATABASE, keep_lines: keep
+    )
+  end
+
   # @return [Module] The module containing the database models.
   def models
     OllamaChat::Database::Models
@@ -532,14 +547,15 @@ class OllamaChat::Chat
       )
       begin
         retried = false
-        sent_messages = messages.to_ary
-        if think_strip.on?
-          sent_messages = sent_messages.map {
-            _1.dup.tap { |message|
-              message.thinking = nil
-            }
+        sent_messages = messages.compacted_messages
+        sent_messages = sent_messages.map {
+          _1.dup.tap { |message|
+            message.sender_name = nil
+            message.group_uuid  = nil
+            message.tool_calls  = nil
+            message.thinking    = nil if think_strip.on?
           }
-        end
+        }
         prepare_model(@model)
         call_ollama_chat(
           model:    @model,

data/lib/ollama_chat/commands.rb

@@ -62,8 +62,8 @@ module OllamaChat::Commands
 
   command(
     name: :config,
-    regexp: %r(^/config(?:\s+(edit|reload|diff))?$),
-    complete: [ 'config', %w[ edit reload diff ] ],
+    regexp: %r(^/config(?:\s+(edit|diff|reload))?$),
+    complete: [ 'config', %w[ edit diff reload ] ],
     optional: true,
     help: <<~EOT
       \u2699\uFE0F View, edit, diff, or reload configuration
@@ -72,11 +72,11 @@ module OllamaChat::Commands
     case subcommand
     when 'edit'
       edit_config
-    when 'reload'
-      reload_config
     when 'diff'
       diff_config
       reload_config
+    when 'reload'
+      reload_config
     else
       display_config
     end
@@ -598,14 +598,15 @@ module OllamaChat::Commands
 
   command(
     name: :conversation,
-    regexp: %r(^/conversation\s+(clean|save|load)(\s+-c)?(?:\s+([^-].*\.jsonl?))?$),
-    complete: [ 'conversation', %w[ save load clean ] ],
+    regexp: %r(^/conversation\s+(clean|compact|save|load)(\s+-c)?(?:\s+([^-].*\.jsonl?))?$),
+    complete: [ 'conversation', %w[ save load clean compact ] ],
     options: '[-c] [FILENAME]',
     help: <<~EOT
       💾 Save/Load conversation state
          (-c to clean before saving)
          FILENAME ends with .json or .jsonl
          Or clean inplace (removes tool content, images, and thinking)
+         Or compact (summarize old messages, keep recent)
     EOT
   ) do |subcommand,opts,path|
     if %w[ save load ].include?(subcommand) && path.blank?
@@ -631,6 +632,16 @@ module OllamaChat::Commands
       else
         STDOUT.puts 'Cancelled.'
       end
+    when 'compact'
+      if confirm?(
+          prompt: '🔔 Compact conversation? Old messages will be summarized. (y/n) ',
+          yes: /\Ay/i
+        )
+      then
+        compact_with_retry
+      else
+        STDOUT.puts 'Cancelled.'
+      end
     end
     :next
   end
@@ -836,22 +847,23 @@ module OllamaChat::Commands
 
   command(
     name: :input,
-    regexp: %r(^/input(?:\s+(path|context|embedding|summary)(?:\s*(?=\z))?)?((?:\s+-(?:[apre]|c\s*#{OllamaChat::COLLECTION_NAME_REGEXP.source}|w\s*\d+|t\s*[-\w\.]+(?:,[-\w\.]+)*))*)(?:\s+([^-].*))?$),
+    regexp: %r(^/input(?:\s+(path|context|embedding|summary)(?:\s*(?=\z))?)?((?:\s+-(?:[aprem]|c\s*#{OllamaChat::COLLECTION_NAME_REGEXP.source}|w\s*\d+|t\s*[-\w\.]+(?:,[-\w\.]+)*))*)(?:\s+([^-].*))?$),
     optional: true,
     complete: [ 'input', %w[ path context embedding summary ] ],
     options: <<~EOT,
-      [
-        -w|-a|-p|-e|
-        -c <collection>|
-        -t <tags>
-      ]
+       [
+         -w|-a|-p|-e|-m|
+         -c <collection>|
+         -t <tags>
+       ]
       [arg…]
     EOT
     help: <<~EOT
       📥 Import content (read, summarize, embed, context)
          Subcommands: path, context, embedding, summary
-         Options: -p (pattern), -w [words], -a (all),
-                  -c [collection], -t [tags], -e (edit)
+          Options: -p (pattern), -w [words], -a (all),
+                   -c [collection], -t [tags], -e (edit),
+                   -m (monochrome, strip ANSI from file content)
     EOT
   ) do |input_mode,opts,arg|
     disable_content_parsing
@@ -907,19 +919,21 @@ module OllamaChat::Commands
         end
       end
     when 'path'
-      opts = go_command('pae', opts)
+      opts = go_command('paem', opts)
       if opts[?p]
         all = opts.fetch(?a, false)
         patterns = extract_patterns(arg)
         read = -> pathname {
           STDOUT.puts "Reading #{pathname.to_s.inspect}."
-          pathname.read
+          content = pathname.read
+          opts[?m] ? Term::ANSIColor.uncolor(content) : content
         }
         next provide_file_set_content(patterns, all:, &read) || :next
       elsif arg
         filename = Pathname.new(arg).expand_path
         filename.file? or next :next
         content = filename.read
+        content = Term::ANSIColor.uncolor(content) if opts[?m]
         content = edit_text(content) if opts[?e]
         content
       else
@@ -927,14 +941,18 @@ module OllamaChat::Commands
         next :next
       end
     else
-      opts = go_command('pae', opts)
+      opts = go_command('paem', opts)
       if opts[?p]
         all = opts.fetch(?a, false)
         patterns = extract_patterns(arg)
-        next provide_file_set_content(patterns, all:, skip_blank: true) { import(_1) } || :next
+        next provide_file_set_content(patterns, all:, skip_blank: true) do |src|
+          content = import(src)
+          opts[?m] ? Term::ANSIColor.uncolor(content) : content
+        end || :next
       elsif arg
         source = arg
         content = import(source) or next :next
+        content = Term::ANSIColor.uncolor(content) if opts[?m]
         content = edit_text(content) if opts[?e]
         content
       else

data/lib/ollama_chat/compaction.rb

@@ -0,0 +1,289 @@
+# Provides compaction support for chat sessions. Mixed into `Chat`.
+#
+# Supplies configuration resolvers that derive concrete token budgets
+# from the `compaction:` config block (ratios of `num_ctx` with absolute
+# floors), the LLM-based summarization pipeline
+# (+summarize_for_compaction+), and the +tool_summary_line+ resolver
+# for per-tool summary templates.
+#
+# @see OllamaChat::OllamaChatConfig::DefaultConfig for the `compaction:`
+#   block structure (`reserve`, `keep_recent`, `summary`).
+module OllamaChat::Compaction
+  class << self
+    # Generates a one-line summary for a tool call result.
+    #
+    # Looks up the registered tool class and delegates to its
+    # `summary_template(result:)` class method. Falls back to a generic
+    # sentence if the tool is not registered or the template raises.
+    #
+    # @param tool_name [String] the registered name, e.g. `'read_file'`.
+    # @param result [String] the raw JSON result string from `execute`.
+    # @return [String] a short natural-language description of the call.
+    def tool_summary_line(tool_name, result)
+      default_summary = "was called."
+      klass           = OllamaChat::Tools.registered[tool_name.to_s]&.class
+      klass&.summary_template(result:) || default_summary
+    rescue StandardError
+      default_summary
+    end
+  end
+
+  # Value object carrying the outcome of a successful +compact!+ call.
+  #
+  # @!attribute [r] context_before
+  #   @return [String] formatted context usage before compaction
+  # @!attribute [r] context_after
+  #   @return [String] formatted context usage after compaction
+  # @!attribute [r] candidates
+  #   @return [Integer] number of messages that were summarized
+  # @!attribute [r] candidate_size
+  #   @return [String] formatted size of the candidate block
+  # @!attribute [r] summary_size
+  #   @return [String] formatted size of the generated summary
+  # @!attribute [r] stored_total
+  #   @return [String] formatted full conversation length
+  Result = Data.define(
+    :context_before, :context_after,
+    :candidates, :candidate_size,
+    :summary_size, :stored_total
+  )
+
+  # Generates a context summary for the given messages via LLM.
+  #
+  # Serializes non-system messages into a structured prompt, calls the
+  # model via +generate+, and assembles the final summary with
+  # deterministic tool-call entries stored out-of-band.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to summarize.
+  # @param previous_summary [OllamaChat::Message, nil] the previous summary
+  #   message for iterative re-compaction.
+  # @return [Array(String, Array<Hash>)] the assembled content and the
+  #   merged tool-call entries array.
+  def summarize_for_compaction(messages:, previous_summary: nil)
+    groups       = serialize_groups(messages)
+    tool_entries = build_tool_entries(messages)
+
+    es = OllamaChat::TokenEstimator.estimate(groups)
+    log(:info, "Compaction: #{messages.size} messages, " \
+      "#{es.tokens_formatted} (#{es.bytes_formatted}) groups")
+
+    narrative_prev = ''
+    old_tool_calls = []
+    if previous_summary
+      narrative_prev = extract_narrative(previous_summary.content)
+      old_tool_calls = extract_old_tool_calls(previous_summary)
+    end
+
+    narrative = call_summarizer(groups:, previous_summary: narrative_prev)
+    assemble_summary(narrative, tool_entries, old_tool_calls)
+  end
+
+  # Resolves the effective token budget for a concern given a context size.
+  #
+  # Computes `max(ratio * tokens, min_tokens).floor`, so the floor acts as
+  # a guaranteed minimum even for very small context windows.
+  #
+  # @param name [Symbol] the concern name, e.g. `:reserve`, `:keep_recent`,
+  #   or `:summary`.
+  # @param tokens [Integer] the context window size (`num_ctx`) to derive
+  #   the budget from.
+  # @return [Integer] the resolved token budget.
+  def compact_ratio_tokens(name, tokens)
+    [
+      compact_ratio(name).to_f * tokens,
+      compact_min_tokens(name).to_f,
+    ].max.floor
+  end
+
+  # Attempts compaction, prompting the user to retry on failure.
+  #
+  # +compact!+ is idempotent on failure: the LLM call (and thus any
+  # +CompactionError+) happens before the message list is mutated, so a
+  # retry always starts from a clean state.
+  #
+  # @return [Boolean] true if compaction succeeded, false if the user
+  #   declined to retry.
+  def compact_with_retry
+    result   = messages.compact!
+    session_sync
+    if result
+      report_compaction(result)
+    else
+      STDOUT.puts('Nothing to compact.')
+    end
+    return true
+  rescue OllamaChat::CompactionError => e
+    STDERR.puts "⚠️  Compaction failed: #{e.message}"
+    log(:error, "Compaction failed", data: {
+      model: @model,
+      ctx:   current_context_length,
+      size:  messages.size,
+    })
+    retry if confirm?(
+      prompt: '🔔 Retry compaction? (y/n) ',
+      yes: /\Ay/i
+    )
+    false
+  end
+
+  private
+
+  # Serializes non-system messages into a readable block for the prompt.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to serialize.
+  # @return [String] a formatted block of message lines.
+  def serialize_groups(messages)
+    messages
+      .reject { _1.role == 'system' }
+      .map { |m| format_summary_line(m) }
+      .join("\n")
+  end
+
+  # Formats a single message as a summary line.
+  #
+  # @param msg [OllamaChat::Message] the message to format.
+  # @return [String] a single line describing the message.
+  def format_summary_line(msg)
+    tool_name = msg.tool_name.full?
+    parts  = +"[#{msg.role}]"
+    parts << " (#{tool_name})" if tool_name
+    parts << " (g:#{msg.group_uuid.to_s[-8..]})" if msg.group_uuid
+    if tool_name
+      line = OllamaChat::Compaction.tool_summary_line(tool_name, msg.content.to_s)
+      parts << " #{line}"
+    elsif msg.content.present?
+      parts << " #{msg.content.to_s.strip}"
+    end
+    parts
+  end
+
+  # Builds the deterministic tool-call entries from tool result messages.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to scan.
+  # @return [Array<Hash>] tool-call entry hashes, empty if no tool results.
+  def build_tool_entries(messages)
+    messages.filter_map do |msg|
+      next unless tool_name = msg.tool_name.full?
+      next if tool_name == 'runtime_information'
+      uuid = msg.group_uuid.to_s[-8..]
+      summary = OllamaChat::Compaction.tool_summary_line(
+        tool_name, msg.content.to_s
+      )
+      time = msg.group_time&.strftime('%Y-%m-%d %H:%M')
+      {
+        'type'    => 'tool',
+        'name'    => tool_name,
+        'summary' => summary,
+        'uuid'    => uuid,
+        'time'    => time,
+      }
+    end
+  end
+
+  # Calls the LLM to generate the narrative portion of the summary.
+  #
+  # @param groups [String] the serialized groups block.
+  # @param previous_summary [String, nil] the prior summary for iteration.
+  # @return [String] the LLM-generated narrative text.
+  def call_summarizer(groups:, previous_summary:)
+    previous = previous_summary.to_s
+
+    prompt = prompt(:summarize, context: 'compaction').to_s % {
+      previous:, groups:
+    }
+    system = prompt(:system, context: 'compaction').to_s
+
+    es = OllamaChat::TokenEstimator.estimate(prompt)
+    log(:info, "Compaction: sending prompt " \
+      "#{es.tokens_formatted} (#{es.bytes_formatted}) to #{@model}")
+
+    response = Infobar.busy(
+      label: 'Compacting context…',
+      frames: :braille7,
+      output: STDOUT,
+    ) do
+      generate(system:, prompt:, think: true).strip
+    end
+
+    if response.empty?
+      log(:error, 'Compaction: LLM returned empty response')
+      raise OllamaChat::CompactionError,
+            'Summarization failed: model returned empty response'
+    end
+
+    res_es = OllamaChat::TokenEstimator.estimate(response)
+    log(:info, "Compaction: got response " \
+      "#{res_es.tokens_formatted} (#{res_es.bytes_formatted})")
+
+    response
+  end
+
+  # Assembles the final summary content and merged tool entries.
+  #
+  # @param narrative [String] the LLM-generated narrative.
+  # @param tool_entries [Array<Hash>] new tool-call entries from this pass.
+  # @param old_tool_entries [Array<Hash>] entries carried over from a
+  #   prior compaction.
+  # @return [Array(String, Array<Hash>)] the content string and the
+  #   merged entries array.
+  def assemble_summary(narrative, tool_entries, old_tool_entries = [])
+    all_tools    = old_tool_entries + tool_entries
+    tool_section = all_tools.map(&:to_json) * ?\n
+
+    template = prompt(:assemble, context: 'compaction').to_s
+    content  = template % { narrative:, tool_section: }
+
+    [content, all_tools]
+  end
+
+  # Extracts the narrative portion from a summary message's content.
+  #
+  # @param content [String, nil] the summary content.
+  # @return [String] the narrative text.
+  def extract_narrative(content)
+    content.to_s.sub(/\ntool_calls:\n.*\z/m, '').strip
+  end
+
+  # Returns the tool-call entries from a previous summary message.
+  #
+  # @param summary_msg [OllamaChat::Message] the previous summary message.
+  # @return [Array<Hash>] the tool-call entries, empty if none.
+  def extract_old_tool_calls(summary_msg)
+    summary_msg.tool_calls || []
+  end
+
+  # Returns the absolute minimum token floor for a given concern.
+  #
+  # @param name [Symbol] the concern name, e.g. `:reserve`, `:keep_recent`,
+  #   or `:summary`.
+  # @return [Integer] the configured `min_tokens` floor.
+  def compact_min_tokens(name)
+    config.compaction.attribute_get!(name).min_tokens
+  end
+
+  # Returns the fractional ratio (portion of `num_ctx`) for a given concern.
+  #
+  # @param name [Symbol] the concern name, e.g. `:reserve`, `:keep_recent`,
+  #   or `:summary`.
+  # @return [Float] the configured `ratio` value.
+  def compact_ratio(name)
+    config.compaction.attribute_get!(name).ratio
+  end
+
+  # Displays a compact compaction report to +STDOUT+ after the
+  # +Infobar.busy+ spinner has finished.
+  #
+  # Replaces the former bare "Conversation compacted." line with
+  # before/after context metrics, candidate volume, and summary size.
+  #
+  # @param result [Result] the compaction result from +compact!+.
+  def report_compaction(result)
+    STDOUT.puts(<<~EOT)
+      ✅ Conversation compacted.
+         Summarized:   #{result.candidates} messages (#{result.candidate_size})
+         Summary:      #{result.summary_size}
+         Context:      #{result.context_before} → #{result.context_after}
+         Stored total: #{result.stored_total}
+    EOT
+  end
+end