samagotchi 0.9.0 → 0.10.1

data/lib/samagotchi/terminal_ui.rb

@@ -21,6 +21,7 @@ require_relative "output_formatter"
 require_relative "turn_flow"
 require_relative "session_commands"
 require_relative "terminal_ui/attached_view"
+require_relative "terminal_ui/between_turns"
 require_relative "terminal_ui/event_renderer"
 require_relative "terminal_ui/formatting"
 require_relative "terminal_ui/input_support"
@@ -63,6 +64,14 @@ module Samagotchi
     # --resume with an id that has no saved session.
     class SessionNotFound < StandardError; end
 
+    # What prints between turns (cards, notices, init lines, an idle recap):
+    # announced on other threads, printed at the open prompt.
+    # @return [BetweenTurns]
+    attr_reader :between_turns
+    # The session's Engine: the REPL drives it inline (#run_engine_turn).
+    # @return [Engine]
+    attr_reader :engine
+
     # ── System prompts (delegated to Engine) ─────────────────────────────────
     def self.system_prompt_for(profile)
       Engine.system_prompt_for(profile)
@@ -117,12 +126,6 @@ module Samagotchi
         @requested_memories = (@resume_session.preloaded_memory_names + @requested_memories).uniq
         @muted_memory_names = (@resume_session.muted_memory_names + @muted_memory_names).uniq
       end
-      # A recap written while idle, printed by the main thread at the open
-      # prompt (#flush_pending_recap).
-      @pending_recap = nil
-      # Cards and notices announced between turns, printed by the main
-      # thread at the open prompt (#flush_pending_cards).
-      @pending_cards = Queue.new
       # Every terminal write goes through the surface. The REPL swaps in a
       # live region when the terminal can show one (#assist_loop), unless it
       # was given a surface to draw on.
@@ -137,6 +140,10 @@ module Samagotchi
       @view = AttachedView.new(@surface, **view_options)
       @status_row = StatusRow.new(@surface)
       @renderer = EventRenderer.new(@view)
+      # Cards, notices and a recap announced between turns, printed by the
+      # main thread at the open prompt (#poll_input_with_reminder_check).
+      @between_turns = BetweenTurns.new(surface: @surface, view: @view, renderer: @renderer,
+                                        turn_running: -> { @engine.turn_running? }, quiet: @non_interactive)
       @render_event = ->(event) { handle_stream_event(event) }
       @engine         = Engine.new(
         client: client,
@@ -176,9 +183,9 @@ module Samagotchi
       @engine.switch_model!(@effective_model_name) if @effective_model_name != @default_model_name
       # Render an idle session-recap via the cursor-safe background writer; the
       # detector itself is Engine-owned (see Engine#recap) and opt-in.
-      @recap_handle = @engine.subscribe(observer: ->(event) { handle_recap_ready(event) })
+      @recap_handle = @engine.subscribe(observer: ->(event) { @between_turns.take_recap(event) })
       @question_handle = @engine.subscribe(observer: ->(event) { handle_question_event(event) })
-      @card_handle = @engine.subscribe(observer: ->(event) { handle_card_event(event) })
+      @card_handle = @engine.subscribe(observer: ->(event) { @between_turns.observe(event) })
       # The REPL renders events from here on: the load warnings and notices
       # now (at the first prompt), and the plugins' slow setup in the
       # background. A --non-interactive run leaves both to its turn.
@@ -251,16 +258,12 @@ module Samagotchi
 
       assist_loop(session: session, messages: messages)
       # After the idle layer has stopped: nothing writes the session now.
-      if @scratch
-        nil # deleted below, however the REPL ended
-      elsif @delete_on_exit
-        delete_after_exit(session)
-      elsif @discard_on_exit
-        discard_after_exit(session)
-      elsif @archive_on_exit
-        archive_after_exit(session)
-      else
-        keep_after_exit(session)
+      case exit_action
+      when :scratch then nil # deleted below, however the REPL ended
+      when :delete then delete_after_exit(session)
+      when :discard then discard_after_exit(session)
+      when :archive then archive_after_exit(session)
+      else keep_after_exit(session)
       end
       # Lines from a pipe (`chi -p X </dev/null`): a failed turn fails the run.
       :turn_failed if @piped_turn_failed
@@ -360,9 +363,9 @@ module Samagotchi
       @owner_lock = OwnerLock.acquire(session_dir, kind: "tui", wait: 1.0)
       return @owner_lock if @owner_lock
 
-      owner = OwnerLock.owner(session_dir) || {}
-      where = owner["kind"] == "tui" ? "another chi" : "a `chi web` worker"
-      raise SessionBusy, "Session #{session_id} is open in #{where} (pid #{owner["pid"] || "unknown"}). " \
+      owner = OwnerLock.owner(session_dir)
+      where = owner&.tui? ? "another chi" : "a `chi web` worker"
+      raise SessionBusy, "Session #{session_id} is open in #{where} (pid #{owner&.pid || "unknown"}). " \
                          "Close it there first."
     end
 
@@ -388,6 +391,124 @@ module Samagotchi
       messages
     end
 
+    # Interactive REPL loop. Session seed + messages are built by #run and
+    # threaded in here (so --prompt / --resume share one code path). The
+    # session's conversation is the single working copy: turns go through
+    # Engine#run_turn and out-of-turn edits through Engine's messages API.
+    # The checkpoint and continue state live in @turn_flow (shared with
+    # session workers). The session is persisted at the end of every turn.
+    def run_assist_loop(session:, messages:)
+      session.messages = messages
+      @engine.session = session
+      # Steering: lines submitted at the open prompt during a turn
+      # (#steer_line), merged by the kernel (#drain_steering).
+      @pending_input_queue = PendingInputQueue.new
+      open_repl_input
+
+      loop do
+        if @exit_after_turn
+          # Ctrl-D or exit came during a turn: the lines sent before it still
+          # run (all queued: the prompt closed at Ctrl-D), then the REPL ends.
+          input = queued_line
+          break if input.nil?
+        else
+          # Drain any pending ask_user_question first — it has priority over reminders and
+          # must be rendered on the REPL thread (turn thread is parked on Engine Monitor).
+          drain_pending_question?
+
+          # A due reminder runs its turn now, with the prompt open (on a
+          # terminal): the turn's output commits above it and whatever is typed
+          # there stays.
+          unless @engine.due_reminder_names.empty?
+            run_reminder_turn(session)
+            @turn_flow.after_reminder_turn
+            next
+          end
+          input = @prompt
+          @prompt = nil if input
+          if input.nil?
+            input = poll_input_with_reminder_check(awaiting_continue: @turn_flow.awaiting_continue?)
+            # A reminder fell due: run it at the top, with the prompt still open.
+            next if input == :due
+          end
+        end
+        break if input.nil?
+        local = local_command(input)
+        if local == :exit
+          @delete_on_exit ||= SessionCommands.delete_on_exit?(input)
+          break
+        end
+        if local == :archive
+          next @surface.commit(SCRATCH_ARCHIVE_REFUSED) if @scratch
+
+          @archive_on_exit = true
+          break
+        end
+        # Not an answer to a continue offer either.
+        next detach_note if local == :detach
+
+        # /stats and /recap run; the offer stays open.
+        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local)
+          answer_continue_offer(session, input)
+        else
+          # The ? read left no echo: show what ran.
+          @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{input}") if @turn_flow.awaiting_continue?
+          run_input_line(session, input)
+        end
+      end
+
+      close_repl_input
+      @discard_on_exit = !@delete_on_exit && discard_on_exit?(session)
+    end
+
+    # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
+    # Engine#run_turn, rendering via @renderer.
+    # @param images [Array<Hash>] the prompt's `@path` images ({path:})
+    def run_engine_turn(session, prompt, continue: false, max_iterations: 100, images: [])
+      cancellation_controller = CancellationController.new
+      @active_cancel_controller = cancellation_controller
+      @renderer.begin_turn
+      # The row shows the turn's model (a -p turn runs before any read).
+      refresh_status_row
+      # A prompt the user typed brings an archived session back to the lists.
+      ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir) if prompt && !continue
+      with_steering do
+        @engine.run_turn(
+          session,
+          prompt,
+          on_event: @render_event,
+          max_iterations: max_iterations,
+          cancel_controller: cancellation_controller,
+          pending_input: method(:drain_steering),
+          continue: continue,
+          images: images
+        )
+      end
+    rescue Interrupt
+      # Engine kept the prompt in the session and emitted :turn_canceled
+      # (the renderer's line).
+      cancellation_controller&.cancel!(:ctrl_c)
+      cancelled_result_from(session.messages, reason: :ctrl_c)
+    ensure
+      @active_cancel_controller = nil
+      @view.finish_thinking_spinner
+    end
+
+    # How the REPL leaves its session once the loop ended (#run): :scratch
+    # (deleted however it ends), :delete (/exit --delete), :discard (left
+    # empty), :archive (/archive) or :keep.
+    def exit_action
+      if @scratch then :scratch
+      elsif @delete_on_exit then :delete
+      elsif @discard_on_exit then :discard
+      elsif @archive_on_exit then :archive
+      else :keep
+      end
+    end
+
+    # Ctrl-D or /exit came during a turn: the REPL ends after it.
+    def exit_after_turn? = @exit_after_turn == true
+
     private
 
     # Interactive REPL loop. Session seed + messages are built by #run and
@@ -468,76 +589,7 @@ module Samagotchi
       @surface = surface
       @view.surface = surface
       @status_row.surface = surface
-    end
-
-    # Interactive REPL loop. Session seed + messages are built by #run and
-    # threaded in here (so --prompt / --resume share one code path). The
-    # session's conversation is the single working copy: turns go through
-    # Engine#run_turn and out-of-turn edits through Engine's messages API.
-    # The checkpoint and continue state live in @turn_flow (shared with
-    # session workers). The session is persisted at the end of every turn.
-    def run_assist_loop(session:, messages:)
-      session.messages = messages
-      @engine.session = session
-      # Steering: lines submitted at the open prompt during a turn
-      # (#steer_line), merged by the kernel (#drain_steering).
-      @pending_input_queue = PendingInputQueue.new
-      open_repl_input
-
-      loop do
-        if @exit_after_turn
-          # Ctrl-D or exit came during a turn: the lines sent before it still
-          # run (all queued: the prompt closed at Ctrl-D), then the REPL ends.
-          input = queued_line
-          break if input.nil?
-        else
-          # Drain any pending ask_user_question first — it has priority over reminders and
-          # must be rendered on the REPL thread (turn thread is parked on Engine Monitor).
-          drain_pending_question?
-
-          # A due reminder runs its turn now, with the prompt open (on a
-          # terminal): the turn's output commits above it and whatever is typed
-          # there stays.
-          unless @engine.due_reminder_names.empty?
-            run_reminder_turn(session)
-            @turn_flow.after_reminder_turn
-            next
-          end
-          input = @prompt
-          @prompt = nil if input
-          if input.nil?
-            input = poll_input_with_reminder_check(awaiting_continue: @turn_flow.awaiting_continue?)
-            # A reminder fell due: run it at the top, with the prompt still open.
-            next if input == :due
-          end
-        end
-        break if input.nil?
-        local = local_command(input)
-        if local == :exit
-          @delete_on_exit ||= SessionCommands.delete_on_exit?(input)
-          break
-        end
-        if local == :archive
-          next @surface.commit(SCRATCH_ARCHIVE_REFUSED) if @scratch
-
-          @archive_on_exit = true
-          break
-        end
-        # Not an answer to a continue offer either.
-        next detach_note if local == :detach
-
-        # /stats and /recap run; the offer stays open.
-        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local)
-          answer_continue_offer(session, input)
-        else
-          # The ? read left no echo: show what ran.
-          @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{input}") if @turn_flow.awaiting_continue?
-          run_input_line(session, input)
-        end
-      end
-
-      close_repl_input
-      @discard_on_exit = !@delete_on_exit && discard_on_exit?(session)
+      @between_turns.surface = surface
     end
 
     # An answer at the ? prompt of a continue offer. A valid one closes the
@@ -693,8 +745,8 @@ module Samagotchi
         sync_continue_slot(false)
         @surface.commit(QuestionSlot.continue_summary("(dropped: a reminder ran)", paint: method(:paint)))
       end
-      @surface.commit("reminder: #{names.join(", ")}")
-      hint = "reminder: #{names.join(", ")} · Ctrl-C cancels it"
+      @surface.commit(reminder_line(names))
+      hint = "#{reminder_line(names)} · Ctrl-C cancels it"
       @surface.set_slot(:hints, [color_output? ? paint(hint, 90) : hint])
       result = nil
       begin
@@ -725,7 +777,7 @@ module Samagotchi
       return :due unless @engine.due_reminder_names.empty?
       # Specs and pipes: a plain blocking read.
       unless @repl_input
-        flush_pending_cards
+        @between_turns.flush_cards
         return read_input(awaiting_continue: awaiting_continue)
       end
 
@@ -736,8 +788,8 @@ module Samagotchi
       sync_continue_slot(awaiting_continue)
       @repl_input.sync_prompt
       loop do
-        flush_pending_recap
-        flush_pending_cards
+        @between_turns.flush_recap
+        @between_turns.flush_cards
         kind, line = @repl_input.pop(timeout: REMINDER_PENDING_POLL_INTERVAL)
         if kind
           # What the line does may change the status (/model, a turn).
@@ -826,7 +878,7 @@ module Samagotchi
     end
 
     # /recap: the saved recap, and a new one asked for at once when the
-    # chat moved on (it prints when it arrives, #flush_pending_recap).
+    # chat moved on (it prints when it arrives, BetweenTurns#flush_recap).
     def handle_recap_command
       recap = @engine.recap
       return recap_command_text(enabled: false) unless recap
@@ -843,39 +895,6 @@ module Samagotchi
       Array(messages).map(&:dup)
     end
 
-    # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
-    # Engine#run_turn, rendering via @renderer.
-    # @param images [Array<Hash>] the prompt's `@path` images ({path:})
-    def run_engine_turn(session, prompt, continue: false, max_iterations: 100, images: [])
-      cancellation_controller = CancellationController.new
-      @active_cancel_controller = cancellation_controller
-      @renderer.begin_turn
-      # The row shows the turn's model (a -p turn runs before any read).
-      refresh_status_row
-      # A prompt the user typed brings an archived session back to the lists.
-      ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir) if prompt && !continue
-      with_steering do
-        @engine.run_turn(
-          session,
-          prompt,
-          on_event: @render_event,
-          max_iterations: max_iterations,
-          cancel_controller: cancellation_controller,
-          pending_input: method(:drain_steering),
-          continue: continue,
-          images: images
-        )
-      end
-    rescue Interrupt
-      # Engine kept the prompt in the session and emitted :turn_canceled
-      # (the renderer's line).
-      cancellation_controller&.cancel!(:ctrl_c)
-      cancelled_result_from(session.messages, reason: :ctrl_c)
-    ensure
-      @active_cancel_controller = nil
-      @view.finish_thinking_spinner
-    end
-
     # While a turn runs, a line submitted at the open prompt steers it: it
     # merges at the next iteration boundary (Kernel), and one that comes after
     # the last runs as the next turn. Reminder turns too.
@@ -942,16 +961,15 @@ module Samagotchi
     # D8: an anytime command runs on its own thread while the turn goes on
     # (it reads copies, and shows things through its ctx). What it prints
     # while the turn runs goes above the live region now, its cards as it
-    # shows them (#handle_card_event); once the turn has ended it waits for
+    # shows them (BetweenTurns#observe); once the turn has ended it waits for
     # the prompt's flush.
     # @return [true]
     def start_anytime_command(line)
       @engine.spawn_anytime do
         output = @engine.running_anytime { @commands.run(line) }&.output
-        items = output.nil? ? [] : [{ type: :command_output, text: "\nmodel> #{output}" }]
-        items.each { |item| @engine.turn_running? ? show_pending_item(item) : @pending_cards << item }
+        @between_turns.show_or_keep({ type: :command_output, text: "\nmodel> #{output}" }) unless output.nil?
       rescue StandardError => e
-        @pending_cards << { type: :command_output, text: "\nmodel> #{line.split.first}: #{e.message}" }
+        @between_turns.keep({ type: :command_output, text: "\nmodel> #{line.split.first}: #{e.message}" })
       end
       true
     end
@@ -970,13 +988,7 @@ module Samagotchi
     # Bridge's). Engine swallows on_event errors to protect the turn, so log
     # ours instead.
     def handle_stream_event(event)
-      case event[:type]
-      when :context_status
-        @status_row.update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
-      when :used_memories_updated then @status_row.update(used_memories: Array(event[:used_memory_names]))
-      when :generation_completed
-        @status_row.update(served: [event[:served_model], event[:requested_model]]) if event[:served_model]
-      end
+      @status_row.take_event(event)
       @renderer.call(event)
     rescue StandardError => e
       Log.error(:repl, "render_failed", echo: "[render] #{event[:type]}: #{e.class}: #{e.message}", event_type: event[:type].to_s, error: e.class.name)
@@ -997,98 +1009,8 @@ module Samagotchi
     # The status row under the prompt, from the Engine's state (what a
     # worker hands an attached TUI when it joins): drawn when it changed.
     def refresh_status_row
-      state = @engine.session_state_snapshot
-      served = state[:served_model] ? [state[:served_model], state[:served_model_for]] : nil
-      fields = { model: @effective_model_name, default_model: @default_model_name, served: served,
-                 parent_id: state[:parent_id], used_memories: Array(state[:used_memory_names]),
-                 preloaded: Array(state[:preloaded_memory_names]), muted: Array(state[:muted_memory_names]) }
-      fields[:context] = state[:context_status] if state[:context_status].is_a?(Hash)
-      @status_row.update(**fields)
-    end
-
-    # ── Idle session recap ───────────────────────────────────────────────────
-    #
-    # The Engine's idle job emits :recap_ready once the session has been idle
-    # for its inactivity threshold (or /recap asked). On the scheduler thread:
-    # kept for the main thread to print at the open prompt. One collected
-    # just as a turn started describes the chat before it.
-    def handle_recap_ready(event)
-      return unless event[:type] == :recap_ready
-      return if event[:recap].to_s.strip.empty? || @engine.turn_running?
-
-      @pending_recap = event[:recap].to_s
-    end
-
-    # Print a recap written while idle (main thread, at the open prompt).
-    def flush_pending_recap
-      recap = @pending_recap
-      return unless recap
-
-      @pending_recap = nil
-      @surface.commit(recap_block(recap))
-    end
-
-    # ── Cards and notices between turns ─────────────────────────────────────
-    #
-    # A card or a plugin's notice shown outside a turn is announced; on the
-    # announcing thread it is only kept, for the main thread to print at the
-    # open prompt (after the command that showed it). One shown during a
-    # turn is a turn event: the turn's sink prints it where it happens
-    # (EventRenderer; the Screen draws it above the live region).
-    #
-    # An anytime command's (event[:anytime]) print as it shows them: on the
-    # main thread (the command runs at the prompt) or beside a running turn
-    # (above the live region), else at the next flush.
-    #
-    # A plugin's init task (chi.init) turns the activity row while it runs
-    # (between turns too, as in attached mode) and prints a line when it is
-    # done; a load warning announced before the first turn, one. Beside a
-    # running turn they print at once; a --non-interactive run prints only
-    # its answer.
-    def handle_card_event(event)
-      if INIT_EVENTS.include?(event[:type])
-        return if @non_interactive
-        return @view.init_started(event) if event[:type] == :plugin_init_started
-
-        @view.init_finished(event) if event[:type] == :plugin_init_finished
-        return show_pending_item(event) if @engine.turn_running?
-
-        return @pending_cards << event
-      end
-      return unless (event[:type] == :card && !event[:in_turn]) || (event[:type] == :hook_notice && event[:between_turns])
-      return show_pending_item(event) if event[:anytime] && (Thread.current == Thread.main || @engine.turn_running?)
-
-      @pending_cards << event
-    end
-
-    # Print the cards, notices and anytime commands' output kept since the
-    # last flush (main thread). A card replaced later in the same batch (the
-    # same id: btw's "thinking…", then its answer) prints once, as its last.
-    def flush_pending_cards
-      items = []
-      loop { items << @pending_cards.pop(true) }
-    rescue ThreadError
-      items.each_with_index do |item, index|
-        replaced = item[:type] == :card && items.drop(index + 1).any? { |later| later[:type] == :card && later[:id] == item[:id] }
-        show_pending_item(item) unless replaced
-      end
-      nil
-    end
-
-    INIT_EVENTS = %i[plugin_init_started plugin_init_finished guardrail_warning].freeze
-
-    # A card, a notice, an anytime command's output (:command_output), a
-    # plugin init task's done line or a load warning.
-    def show_pending_item(item)
-      case item[:type]
-      when :card then @renderer.render_card(item)
-      when :command_output then @surface.commit(item[:text])
-      when :guardrail_warning then @surface.commit(EventRenderer.load_warning_line(item))
-      when :plugin_init_finished
-        line = EventRenderer.init_line(item)
-        @surface.commit(line) if line
-      else @surface.commit(EventRenderer.hook_notice_line(item))
-      end
+      state = @engine.session_state_snapshot.merge(model_name: @effective_model_name)
+      @status_row.take_state(state, default_model: @default_model_name)
     end
 
     # Resolve the recap config (on by default). Returns false when explicitly
@@ -1131,7 +1053,7 @@ module Samagotchi
       type = event[:type] || event["type"]
       return unless type.to_s == "question_requested"
 
-      pq = event[:pending_question] || event["pending_question"] || event[:pendingQuestion]
+      pq = event[:pending_question] || event["pending_question"]
       return unless pq
 
       @pending_question_event = pq

data/lib/samagotchi/thinking.rb

@@ -50,10 +50,10 @@ module Samagotchi
     # The level for +target+ and where it came from ("--thinking",
     # "models: qwen", "hosts.work", "thinking.level"; nil for the default).
     # @param target [HostRegistry::ModelTarget]
-    # @param names [Array<String>, nil] the model's lookup names (Engine#model_lookup_names)
+    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
     # @param models [Hash, nil] ConfigFile.model_settings (specs)
     # @return [Array(Symbol, String|nil)]
-    def resolve(target, names: nil, models: nil)
+    def resolve(target, names:, models: nil)
       global, origin = global_level
       return [global, origin == :cli ? "--thinking" : "SAMAGOTCHI_THINKING_LEVEL"] if global && %i[cli env].include?(origin)
 
@@ -62,7 +62,6 @@ module Samagotchi
       rescue StandardError
         {}
       end
-      names ||= [target.model, target.bare_model]
       key, value = ConfigFile.model_setting(names, :thinking, models: models)
       return [value, "models: #{key}"] if key
 

data/lib/samagotchi/thought_stream_splitter.rb

@@ -18,21 +18,22 @@ module Samagotchi
   # fragments at the end of each chunk so a marker split across a stream boundary
   # is still recognized. `ThoughtStreamSplitter.for_profile` derives the block
   # markers from the active ModelProfile, so the same splitter works for the
-  # Qwen literal-marker family and (tool_call only) the Gemma control-token family.
+  # Qwen literal-marker family and the Gemma control-token family.
   #
-  # For a profile whose `thought_close` is nil (Gemma 4), thinking blocks have no
-  # explicit close marker and are NOT split out — they remain in `:text` and the
-  # renderer's existing strip still hides them from the bubble. Qwen 3.6 (the
-  # default runtime profile) has explicit open/close markers for both families,
-  # so thinking is split cleanly.
+  # Gemma 4 thinks in a channel, `<|channel>thought` … `<channel|>`: that is
+  # its thinking block. Its bare `<|think|>` cue has no close marker, so it is
+  # not a block and stays in `:text` (the model doesn't emit it; the system
+  # prompt carries it).
   class ThoughtStreamSplitter
+    # Gemma 4's thought channel (ToolCallParser::Gemma strips the same pair).
+    GEMMA_THOUGHT_CHANNEL = { open: "<|channel>thought", close: "<channel|>" }.freeze
+
     # @return [Array<Hash>] each entry { open: String, close: String, lane: :thinking|:drop }
     def self.for_profile(profile)
       blocks = []
-      # Only register a thinking block when the profile has an explicit close
-      # marker (Qwen). A nil close (Gemma) means we can't bound the block, so we
-      # leave thinking in :text and let the renderer's strip handle it.
+      # A thinking block needs a close marker to be bounded.
       blocks << { open: profile.thought_open, close: profile.thought_close, lane: :thinking } if profile.thought_close
+      blocks << GEMMA_THOUGHT_CHANNEL.merge(lane: :thinking) if profile.name == "gemma4"
       blocks << { open: profile.tool_call_open, close: profile.tool_call_close, lane: :drop }
       new(blocks)
     end