ollama_agent 0.1.0 → 0.3.0

data/lib/ollama_agent/cli.rb

@@ -3,40 +3,429 @@
 require "thor"
 
 require_relative "agent"
+require_relative "external_agents"
+require_relative "prompt_skills"
 
 module OllamaAgent
   # Thor CLI for single-shot and interactive agent sessions.
+  # rubocop:disable Metrics/ClassLength -- Thor commands and shared helpers
   class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
     desc "ask [QUERY]", "Run a natural-language task (reads, search, patch)"
     method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
     method_option :interactive, type: :boolean, aliases: "-i", desc: "Interactive REPL"
+    method_option :read_only, type: :boolean, default: false, aliases: "-R",
+                              desc: "Read/search only (no edit_file, write_file, patches, or delegation)"
     method_option :yes, type: :boolean, aliases: "-y", desc: "Apply patches without confirmation"
     method_option :root, type: :string, desc: "Project root (default: OLLAMA_AGENT_ROOT or cwd)"
     method_option :timeout, type: :numeric, aliases: "-t", desc: "HTTP timeout seconds (default 120)"
     method_option :think, type: :string, desc: "Thinking mode: true|false|high|medium|low (see OLLAMA_AGENT_THINK)"
+    method_option :no_skills, type: :boolean, default: false,
+                              desc: "Disable bundled prompt skills (same as OLLAMA_AGENT_SKILLS=0)"
+    method_option :skill_paths, type: :string,
+                                desc: "Extra .md paths or dirs, colon-separated; merged with OLLAMA_AGENT_SKILL_PATHS"
+    method_option :stream, type: :boolean, default: false,
+                           desc: "Stream tokens to terminal as they arrive (OLLAMA_AGENT_STREAM=1)"
+    method_option :audit, type: :boolean, default: false,
+                          desc: "Enable structured audit log under .ollama_agent/logs/ (OLLAMA_AGENT_AUDIT=1)"
+    method_option :max_retries, type: :numeric,
+                                desc: "HTTP retry attempts (0=disable, default 3)"
+    method_option :session, type: :string,  desc: "Named session id (saves/resumes conversation)"
+    method_option :resume,  type: :boolean, default: false,
+                            desc: "Resume the named (or most recent) session"
+    method_option :max_tokens, type: :numeric,
+                               desc: "Context window budget (OLLAMA_AGENT_MAX_TOKENS)"
+    method_option :context_summarize, type: :boolean, default: false,
+                                      desc: "Summarize dropped context vs sliding window"
     def ask(query = nil)
       agent = build_agent
 
       if options[:interactive]
         start_interactive(agent)
       elsif query
-        agent.run(query)
+        run_single_shot_agent!(agent, query)
+      else
+        puts Console.error_line("Error: provide a QUERY or use --interactive")
+        exit 1
+      end
+    end
+
+    desc "orchestrate [QUERY]", "Like ask, with tools to list/delegate to external CLI agents (Claude, Gemini, …)"
+    method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
+    method_option :interactive, type: :boolean, aliases: "-i", desc: "Interactive REPL"
+    method_option :read_only, type: :boolean, default: false, aliases: "-R",
+                              desc: "Read/search only (no edit_file, write_file, patches, or delegation)"
+    method_option :yes, type: :boolean, aliases: "-y", desc: "Apply patches and run delegations without confirmation"
+    method_option :root, type: :string, desc: "Project root (default: OLLAMA_AGENT_ROOT or cwd)"
+    method_option :timeout, type: :numeric, aliases: "-t", desc: "HTTP timeout seconds (default 120)"
+    method_option :think, type: :string, desc: "Thinking mode: true|false|high|medium|low (see OLLAMA_AGENT_THINK)"
+    method_option :no_skills, type: :boolean, default: false,
+                              desc: "Disable bundled prompt skills (same as OLLAMA_AGENT_SKILLS=0)"
+    method_option :skill_paths, type: :string,
+                                desc: "Extra .md paths or dirs, colon-separated; merged with OLLAMA_AGENT_SKILL_PATHS"
+    method_option :stream, type: :boolean, default: false,
+                           desc: "Stream tokens to terminal as they arrive (OLLAMA_AGENT_STREAM=1)"
+    method_option :audit, type: :boolean, default: false,
+                          desc: "Enable structured audit log under .ollama_agent/logs/ (OLLAMA_AGENT_AUDIT=1)"
+    method_option :max_retries, type: :numeric,
+                                desc: "HTTP retry attempts (0=disable, default 3)"
+    method_option :max_tokens, type: :numeric,
+                               desc: "Context window budget (OLLAMA_AGENT_MAX_TOKENS)"
+    method_option :context_summarize, type: :boolean, default: false,
+                                      desc: "Summarize dropped context vs sliding window"
+    def orchestrate(query = nil)
+      agent = build_orchestrator_agent
+
+      if options[:interactive]
+        start_interactive(agent)
+      elsif query
+        run_single_shot_agent!(agent, query)
       else
         puts Console.error_line("Error: provide a QUERY or use --interactive")
         exit 1
       end
     end
 
+    desc "sessions", "List saved sessions for the current project root"
+    method_option :root, type: :string, desc: "Project root (default: OLLAMA_AGENT_ROOT or cwd)"
+    def sessions
+      root = resolved_root_for_self_review
+      list = Session::Store.list(root: root)
+      if list.empty?
+        puts "No sessions found in #{root}"
+        return
+      end
+      puts "SESSION ID                      STARTED"
+      list.each { |s| puts format("%-30<id>s  %<started>s", id: s.session_id, started: s.started_at) }
+    end
+
+    desc "agents", "List configured external CLI agents and whether they are on PATH"
+    def agents
+      reg = ExternalAgents::Registry.load
+      ExternalAgents::Probe.print_table(reg)
+    end
+
+    desc "doctor", "Alias for agents"
+    def doctor
+      agents
+    end
+
+    desc "self_review", "Self-review / improvement: --mode analysis | interactive | automated (see help)"
+    method_option :mode, type: :string, default: "analysis",
+                         desc: "analysis (1)=read-only report; interactive (2)=confirm patches in tree; " \
+                               "automated (3)=sandbox+RSpec+optional --apply"
+    long_desc <<~HELP
+      Modes:
+        analysis     Read-only tools; prints a report; no writes (default).
+        interactive  Full tools on --root; you confirm each patch (like `ask`); optional -y / --semi.
+        automated    Temp sandbox, agent edits, `bundle exec rspec`; optional --apply to merge back.
+
+      Aliases: 1/2/3, readonly, fix, confirm, sandbox, full.
+    HELP
+    method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
+    method_option :root, type: :string, desc: "Project root (default: OLLAMA_AGENT_ROOT or cwd)"
+    method_option :timeout, type: :numeric, aliases: "-t", desc: "HTTP timeout seconds (default 120)"
+    method_option :think, type: :string, desc: "Thinking mode: true|false|high|medium|low (see OLLAMA_AGENT_THINK)"
+    method_option :yes, type: :boolean, aliases: "-y",
+                        desc: "interactive/automated: apply patches without confirmation"
+    method_option :semi, type: :boolean, default: true,
+                         desc: "interactive/automated: auto-approve obvious patches; prompt for risky (default: true)"
+    method_option :apply, type: :boolean, default: false,
+                          desc: "automated only: after green tests, copy changed files from sandbox into --root"
+    method_option :no_skills, type: :boolean, default: false,
+                              desc: "Disable bundled prompt skills (same as OLLAMA_AGENT_SKILLS=0)"
+    method_option :skill_paths, type: :string,
+                                desc: "Extra .md paths or dirs, colon-separated; merged with OLLAMA_AGENT_SKILL_PATHS"
+    method_option :stream, type: :boolean, default: false,
+                           desc: "Stream tokens to terminal as they arrive (OLLAMA_AGENT_STREAM=1)"
+    method_option :max_tokens, type: :numeric,
+                               desc: "Context window budget (OLLAMA_AGENT_MAX_TOKENS)"
+    method_option :context_summarize, type: :boolean, default: false,
+                                      desc: "Summarize dropped context vs sliding window"
+    method_option :verify, type: :string,
+                           desc: "automated only: comma-separated checks after agent (default: rspec or " \
+                                 "OLLAMA_AGENT_IMPROVE_VERIFY). Steps: syntax, rubocop, rspec"
+    method_option :no_ruby_mastery, type: :boolean, default: false,
+                                    desc: "Skip prepending ruby_mastery static analysis (see OLLAMA_AGENT_RUBY_MASTERY)"
+    def self_review
+      dispatch_self_review_mode(SelfImprovement::Modes.normalize(options[:mode]))
+    end
+
+    desc "improve", "Shortcut for: self_review --mode automated"
+    method_option :mode, type: :string, default: "automated",
+                         desc: "Optional; must be automated (or 3, sandbox, full). Other modes: use self_review --mode"
+    method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
+    method_option :root, type: :string, desc: "Source tree to copy and test (default: OLLAMA_AGENT_ROOT or cwd)"
+    method_option :timeout, type: :numeric, aliases: "-t", desc: "HTTP timeout seconds (default 120)"
+    method_option :think, type: :string, desc: "Thinking mode: true|false|high|medium|low (see OLLAMA_AGENT_THINK)"
+    method_option :yes, type: :boolean, aliases: "-y", desc: "Apply all patches without confirmation"
+    method_option :semi, type: :boolean, default: true,
+                         desc: "Without -y: auto-approve obvious patches; prompt for risky (default: true)"
+    method_option :apply, type: :boolean, default: false,
+                          desc: "After green tests, copy changed files from sandbox into --root"
+    method_option :no_skills, type: :boolean, default: false,
+                              desc: "Disable bundled prompt skills (same as OLLAMA_AGENT_SKILLS=0)"
+    method_option :skill_paths, type: :string,
+                                desc: "Extra .md paths or dirs, colon-separated; merged with OLLAMA_AGENT_SKILL_PATHS"
+    method_option :stream, type: :boolean, default: false,
+                           desc: "Stream tokens to terminal as they arrive (OLLAMA_AGENT_STREAM=1)"
+    method_option :max_tokens, type: :numeric,
+                               desc: "Context window budget (OLLAMA_AGENT_MAX_TOKENS)"
+    method_option :context_summarize, type: :boolean, default: false,
+                                      desc: "Summarize dropped context vs sliding window"
+    method_option :verify, type: :string,
+                           desc: "Comma-separated post-agent checks (default: rspec; env " \
+                                 "OLLAMA_AGENT_IMPROVE_VERIFY). Steps: syntax, rubocop, rspec"
+    method_option :no_ruby_mastery, type: :boolean, default: false,
+                                    desc: "Skip prepending ruby_mastery static analysis (see OLLAMA_AGENT_RUBY_MASTERY)"
+    def improve
+      ensure_improve_mode_only_automated!
+      dispatch_self_review_mode("automated")
+    end
+
     private
 
+    def ensure_improve_mode_only_automated!
+      m = SelfImprovement::Modes.normalize(options[:mode])
+      return if m == "automated"
+
+      warn Console.error_line(improve_mode_error_message(m))
+      exit 1
+    end
+
+    def improve_mode_error_message(normalized_mode)
+      return invalid_improve_mode_message unless SelfImprovement::Modes.valid?(normalized_mode)
+
+      "Command \"improve\" only runs automated (sandbox) mode. For other modes use: " \
+        "ollama_agent self_review --mode analysis | interactive"
+    end
+
+    def invalid_improve_mode_message
+      "Invalid --mode for improve: use automated (or 3, sandbox, full). Got: #{options[:mode].inspect}"
+    end
+
+    def dispatch_self_review_mode(mode)
+      validate_self_review_mode!(mode)
+      send(:"run_mode_#{mode}")
+    end
+
+    def validate_self_review_mode!(mode)
+      return if SelfImprovement::Modes.valid?(mode)
+
+      warn Console.error_line(
+        "Invalid --mode: use analysis, interactive, or automated (or 1, 2, 3). Got: #{options[:mode].inspect}"
+      )
+      exit 1
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- stream + context kwargs exceed limits
+    def run_mode_analysis
+      agent = Agent.new(
+        model: options[:model],
+        root: resolved_root_for_self_review,
+        read_only: true,
+        confirm_patches: false,
+        http_timeout: options[:timeout],
+        think: options[:think],
+        max_tokens: options[:max_tokens],
+        context_summarize: options[:context_summarize],
+        **skill_agent_options
+      )
+      attach_console_streamer(agent) if stream_enabled?
+      preamble = ruby_mastery_preamble(resolved_root_for_self_review)
+      SelfImprovement::Analyzer.new(agent).run(preamble: preamble)
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def run_mode_interactive
+      agent = Agent.new(**interactive_agent_keywords)
+      attach_console_streamer(agent) if stream_enabled?
+      preamble = ruby_mastery_preamble(resolved_root_for_self_review)
+      SelfImprovement::Analyzer.new(agent).run(SelfImprovement::Analyzer::INTERACTIVE_PROMPT, preamble: preamble)
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- context kwargs push over limit
+    def interactive_agent_keywords
+      semi = options[:semi] != false
+      {
+        model: options[:model],
+        root: resolved_root_for_self_review,
+        read_only: false,
+        confirm_patches: !options[:yes],
+        patch_policy: semi ? PatchRisk.method(:assess).to_proc : nil,
+        http_timeout: options[:timeout],
+        think: options[:think],
+        max_tokens: options[:max_tokens],
+        context_summarize: options[:context_summarize]
+      }.merge(skill_agent_options)
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def run_mode_automated
+      result = SelfImprovement::Improver.new.run(**improve_run_options)
+      report_improve_result(result)
+    end
+
+    def resolved_root_for_self_review
+      raw = options[:root] || ENV.fetch("OLLAMA_AGENT_ROOT", nil)
+      base = raw.to_s.strip.empty? ? Dir.pwd : raw
+      File.expand_path(base)
+    end
+
+    def ruby_mastery_enabled?
+      return false if options[:no_ruby_mastery]
+      return false if ENV.fetch("OLLAMA_AGENT_RUBY_MASTERY", "1") == "0"
+
+      true
+    end
+
+    def ruby_mastery_preamble(root)
+      return nil unless ruby_mastery_enabled?
+
+      SelfImprovement::RubyMasteryContext.markdown_section(root)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- context kwargs push over limit
+    def improve_run_options
+      {
+        model: options[:model],
+        root: options[:root] || ENV.fetch("OLLAMA_AGENT_ROOT", nil),
+        yes: options[:yes],
+        semi: options[:semi] != false,
+        apply: options[:apply],
+        http_timeout: options[:timeout],
+        think: options[:think],
+        max_tokens: options[:max_tokens],
+        context_summarize: options[:context_summarize],
+        stream: stream_enabled?,
+        verify: options[:verify],
+        ruby_mastery: ruby_mastery_enabled?
+      }.merge(skill_agent_options)
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def report_improve_result(result)
+      unless result[:success]
+        warn Console.error_line("Tests failed in sandbox.")
+        puts result[:test_output]
+        exit 1
+      end
+
+      root = result[:source_root]
+      puts "ollama_agent: tests passed in sandbox (#{root})"
+      copied = result[:copied_to_source]
+      report_improve_copied_files(copied, root)
+      report_improve_merge_outcome(copied, root)
+    end
+
+    def report_improve_merge_outcome(copied, root)
+      if options[:apply]
+        puts "ollama_agent: no changed files to copy from sandbox" if copied.empty?
+        return
+      end
+
+      puts "ollama_agent: sandbox was discarded — your project tree was not updated. " \
+           "Re-run with --apply to merge sandbox changes into #{root} after a green run."
+    end
+
+    def report_improve_copied_files(copied, root)
+      return if copied.empty?
+
+      puts "ollama_agent: copied #{copied.size} file(s) to #{root}"
+      copied.sort.each { |rel| puts "  #{rel}" }
+    end
+
+    # Build an Agent for the `ask` command.
+    # Same root as `self_review` / interactive: cwd when unset (see README).
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- session + orchestrator + audit kwargs exceed limits
     def build_agent
-      Agent.new(
+      orch  = orchestrator_mode?
+      agent = Agent.new(
         model: options[:model],
-        root: options[:root],
+        root: resolved_root_for_self_review,
+        read_only: options[:read_only],
         confirm_patches: !options[:yes],
         http_timeout: options[:timeout],
-        think: options[:think]
+        think: options[:think],
+        orchestrator: orch,
+        confirm_delegation: orch ? !options[:yes] : true,
+        audit: options[:audit],
+        max_retries: options[:max_retries],
+        session_id: resolved_session_id,
+        resume: options[:resume] || false,
+        max_tokens: options[:max_tokens],
+        context_summarize: options[:context_summarize],
+        **skill_agent_options
       )
+      attach_console_streamer(agent) if stream_enabled?
+      agent
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def resolved_session_id
+      return options[:session] if options[:session]
+      return nil unless options[:resume]
+
+      list = Session::Store.list(root: resolved_root_for_self_review)
+      list.first&.session_id
+    end
+
+    def orchestrator_mode?
+      return true if ENV.fetch("OLLAMA_AGENT_ORCHESTRATOR", "0").to_s == "1"
+
+      ENV.fetch("OLLAMA_AGENT_MODE", "").to_s.strip.casecmp("orchestrator").zero?
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- mirrors build_agent; stream attachment adds one line
+    def build_orchestrator_agent
+      agent = Agent.new(
+        model: options[:model],
+        root: resolved_root_for_self_review,
+        read_only: options[:read_only],
+        confirm_patches: !options[:yes],
+        http_timeout: options[:timeout],
+        think: options[:think],
+        orchestrator: true,
+        confirm_delegation: !options[:yes],
+        audit: options[:audit],
+        max_retries: options[:max_retries],
+        max_tokens: options[:max_tokens],
+        context_summarize: options[:context_summarize],
+        **skill_agent_options
+      )
+      attach_console_streamer(agent) if stream_enabled?
+      agent
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def skill_agent_options
+      out = {}
+      out[:skills_enabled] = false if options[:no_skills]
+      paths = PromptSkills.split_paths(options[:skill_paths])
+      out[:skill_paths] = paths unless paths.empty?
+      out
+    end
+
+    def stream_enabled?
+      options[:stream] || ENV.fetch("OLLAMA_AGENT_STREAM", "0") == "1"
+    end
+
+    def attach_console_streamer(agent)
+      Streaming::ConsoleStreamer.new.attach(agent.hooks)
+    end
+
+    def run_single_shot_agent!(agent, query)
+      agent.run(query)
+    rescue Ollama::Error, OllamaAgent::Error => e
+      warn Console.error_line("#{e.class}: #{e.message}")
+      exit 1
+    rescue StandardError => e
+      warn Console.error_line("#{e.class}: #{e.message}")
+      warn e.full_message(order: :top, highlight: false) if ENV["OLLAMA_AGENT_DEBUG"] == "1"
+      exit 1
     end
 
     def start_interactive(agent)
@@ -70,4 +459,5 @@ module OllamaAgent
       end
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ollama_agent/console.rb

@@ -3,6 +3,7 @@
 module OllamaAgent
   # ANSI styling for TTY output. Respects https://no-color.org/ via NO_COLOR.
   # Assistant replies use tty-markdown when enabled (headings, lists, bold, code blocks).
+  # rubocop:disable Metrics/ModuleLength -- single-responsibility output module; methods are all short
   module Console
     module_function
 
@@ -38,6 +39,116 @@ module OllamaAgent
       markdown_enabled? && ENV["OLLAMA_AGENT_THINKING_MARKDOWN"] == "1"
     end
 
+    # +compact+ (default): one "Thinking" label per agent run; later reasoning uses blank lines only (Cursor-like).
+    # +framed+: repeat the full banner + rulers on every assistant message (legacy).
+    def thinking_framed_style?
+      ENV.fetch("OLLAMA_AGENT_THINKING_STYLE", "compact").to_s.strip.downcase == "framed"
+    end
+
+    # @api private  Reset at the start of each {Agent#run} so multi-turn tool loops share one thinking header.
+    def reset_thinking_session!
+      Thread.current[:ollama_agent_thinking_shown] = false
+      Thread.current[:ollama_agent_stream_thinking_open] = false
+      Thread.current[:ollama_agent_stream_had_thinking] = false
+      Thread.current[:ollama_agent_stream_thinking_buffer] = nil
+    end
+
+    def thinking_already_shown_in_session?
+      Thread.current[:ollama_agent_thinking_shown] == true
+    end
+
+    def mark_thinking_shown_in_session!
+      Thread.current[:ollama_agent_thinking_shown] = true
+    end
+
+    # --- Streaming (ollama-client passes thinking only via patched hooks[:on_thinking]) ---
+
+    # Print one dim "Thinking" label, then stream fragments in dim until content tokens arrive.
+    # Handles both cumulative thinking strings (common from Ollama) and plain deltas; sanitizes UTF-8.
+    def write_streaming_thinking_fragment(fragment)
+      text = utf8_for_stream(fragment)
+      return if text.empty?
+
+      open_streaming_thinking_section_if_needed
+      to_print = streaming_thinking_increment_to_print(text)
+      return if to_print.empty?
+
+      print to_print
+      $stdout.flush
+    end
+
+    def write_stream_token(fragment)
+      print utf8_for_stream(fragment)
+      $stdout.flush
+    end
+
+    # Call before the first streamed content token: closes dim reasoning, optional Assistant heading.
+    def finalize_streaming_thinking_before_content!
+      return unless Thread.current[:ollama_agent_stream_thinking_open]
+
+      Thread.current[:ollama_agent_stream_thinking_open] = false
+      had = Thread.current[:ollama_agent_stream_had_thinking]
+      Thread.current[:ollama_agent_stream_had_thinking] = false
+      Thread.current[:ollama_agent_stream_thinking_buffer] = nil
+      print "\e[0m" if color_enabled?
+      puts
+      puts assistant_reply_heading if had
+    end
+
+    # When the model returns only thinking (no content), close ANSI state on stream end.
+    def close_streaming_thinking_if_still_open!
+      return unless Thread.current[:ollama_agent_stream_thinking_open]
+
+      Thread.current[:ollama_agent_stream_thinking_open] = false
+      Thread.current[:ollama_agent_stream_had_thinking] = false
+      Thread.current[:ollama_agent_stream_thinking_buffer] = nil
+      print "\e[0m" if color_enabled?
+      puts
+    end
+
+    def open_streaming_thinking_section_if_needed
+      return if Thread.current[:ollama_agent_stream_thinking_open]
+
+      Thread.current[:ollama_agent_stream_thinking_open] = true
+      Thread.current[:ollama_agent_stream_had_thinking] = true
+      label = color_enabled? ? "#{dim("Thinking")}\n" : "Thinking\n"
+      print label
+      print "\e[2m" if color_enabled?
+    end
+    private_class_method :open_streaming_thinking_section_if_needed
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- cumulative vs delta stream shapes
+    def streaming_thinking_increment_to_print(next_utf8)
+      prev = Thread.current[:ollama_agent_stream_thinking_buffer].to_s
+      if prev.empty?
+        Thread.current[:ollama_agent_stream_thinking_buffer] = next_utf8
+        return next_utf8
+      end
+
+      if next_utf8.start_with?(prev) && next_utf8.bytesize >= prev.bytesize
+        slice = next_utf8.byteslice(prev.bytesize..)
+        Thread.current[:ollama_agent_stream_thinking_buffer] = next_utf8
+        return slice
+      end
+
+      return +"" if next_utf8 == prev
+
+      if next_utf8.bytesize < prev.bytesize
+        Thread.current[:ollama_agent_stream_thinking_buffer] = next_utf8
+        return next_utf8
+      end
+
+      Thread.current[:ollama_agent_stream_thinking_buffer] = prev + next_utf8
+      next_utf8
+    end
+    private_class_method :streaming_thinking_increment_to_print
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def utf8_for_stream(fragment)
+      fragment.to_s.encode("UTF-8", invalid: :replace, undef: :replace)
+    end
+    private_class_method :utf8_for_stream
+
     def style(text, *codes)
       return text.to_s unless color_enabled?
 
@@ -85,6 +196,36 @@ module OllamaAgent
       "#{header}#{body}\n#{line}"
     end
 
+    def format_thinking_compact_open(text)
+      label = color_enabled? ? dim("Thinking") : "Thinking"
+      body = thinking_compact_body(text)
+      "#{label}\n#{body}"
+    end
+
+    # Later thinking in the same run (tool rounds, new chat chunks): same block, separated by a blank line.
+    def format_thinking_compact_merge(text)
+      "\n#{thinking_compact_body(text)}"
+    end
+
+    def thinking_compact_body(text)
+      if thinking_markdown_enabled?
+        parsed = markdown_parse(text, thinking: true)
+        return parsed if parsed
+
+        return dim_indent_body(text)
+      end
+
+      dim_indent_body(text)
+    end
+
+    def dim_indent_body(text)
+      s = text.to_s.rstrip
+      return "" if s.empty?
+
+      indent = "  "
+      dim(s.lines.map { |l| "#{indent}#{l.rstrip}" }.join("\n"))
+    end
+
     def assistant_reply_heading
       bold(green("Assistant"))
     end
@@ -113,13 +254,33 @@ module OllamaAgent
 
     # Prints thinking (if any) then main content; duck-types #thinking and #content.
     def puts_assistant_message(message)
-      t = message.thinking
-      c = message.content
-      thinking_present = t && !t.to_s.empty?
+      thinking_present = assistant_message_thinking_present?(message.thinking)
+      if thinking_present
+        puts thinking_output_chunk(message.thinking)
+        mark_thinking_shown_in_session! unless thinking_framed_style?
+      end
+      assistant_reply_if_present(message.content, thinking_present)
+    end
+
+    def assistant_message_thinking_present?(text)
+      text && !text.to_s.strip.empty?
+    end
+    private_class_method :assistant_message_thinking_present?
+
+    def assistant_reply_if_present(content, thinking_present)
+      return unless content && !content.to_s.strip.empty?
 
-      puts format_thinking(t) if thinking_present
-      write_assistant_reply(c, thinking_present) if c && !c.to_s.empty?
+      write_assistant_reply(content, thinking_present)
     end
+    private_class_method :assistant_reply_if_present
+
+    def thinking_output_chunk(text)
+      return format_thinking(text) if thinking_framed_style?
+      return format_thinking_compact_open(text) unless thinking_already_shown_in_session?
+
+      format_thinking_compact_merge(text)
+    end
+    private_class_method :thinking_output_chunk
 
     def patch_title(text)
       bold(yellow(text))
@@ -132,5 +293,16 @@ module OllamaAgent
     def error_line(text)
       red(text)
     end
+
+    def tool_call_line(name, args)
+      keys = args.is_a?(Hash) ? args.keys.first(2).join(", ") : ""
+      cyan("[tool→] #{name}(#{keys})")
+    end
+
+    def tool_result_line(name, result)
+      preview = result.to_s[0, 60].gsub(/\s+/, " ")
+      dim("[tool←] #{name}: #{preview}")
+    end
   end
+  # rubocop:enable Metrics/ModuleLength
 end