samagotchi 0.22.0 → 0.24.0

data/lib/samagotchi/question_desk.rb

@@ -101,8 +101,8 @@ module Samagotchi
     # @param payload [Hash] {question:, options:, header:, multi_select:, allow_freeform:}
     # @return [String] normalized answer JSON
     def request(payload)
-      result = open_question({ **payload.slice(:question, :options, :header),
-                               multi_select: !!payload[:multi_select], allow_freeform: !!payload[:allow_freeform] })
+      result = open_question(payload.slice(:question, :options, :header)
+                                    .merge(multi_select: !!payload[:multi_select], allow_freeform: !!payload[:allow_freeform]))
       # Dismissed (the card's dismiss, Esc): an answer of its own, not a
       # tool failure the model learns to avoid the tool from.
       result = { dismissed: true, id: result[:id], note: DISMISSED_NOTE } if result.is_a?(Hash) && result[:error] == "no answer"
@@ -288,6 +288,7 @@ module Samagotchi
         if parent_agent && (reason = Guardrails::ParentContinue.refusal(pending, sel, allowed: parent_continue))
           raise Refused, reason
         end
+
         if @standing
           # No waiter: cleared here, so a second answer finds none.
           standing = @standing
@@ -332,9 +333,7 @@ module Samagotchi
       true
     end
 
-    def sync_handler=(block)
-      @sync_handler = block
-    end
+    attr_writer :sync_handler
 
     # @return [Boolean] a REPL answers inline (no wait loop)
     def sync_handler? = !@sync_handler.nil?
@@ -355,7 +354,7 @@ module Samagotchi
         next if id && pending[:id].to_s != id.to_s
         next if @answer || pending[:status].to_s != "pending"
         # Its poster closes it; nothing waits on a cancel.
-        raise NotDismissable, "answer #{Array(pending[:options]).join(' or ')}" if @standing && id
+        raise NotDismissable, "answer #{Array(pending[:options]).join(" or ")}" if @standing && id
         next if @standing
 
         pending[:status] = "cancelled"
@@ -469,9 +468,10 @@ module Samagotchi
     def validated_answer(pending, sel, fm, parent_agent:, parent_setting:)
       opts = Array(pending[:options])
       invalid = sel.reject { |v| opts.include?(v) }
-      raise ArgumentError, "invalid selection: #{invalid.join(', ')} (valid: #{opts.join(', ')})" unless invalid.empty?
+      raise ArgumentError, "invalid selection: #{invalid.join(", ")} (valid: #{opts.join(", ")})" unless invalid.empty?
       raise ArgumentError, "single-select question: got #{sel.size} selections" if !pending[:multi_select] && sel.size > 1
       raise ArgumentError, "selection required" if pending[:multi_select] == false && sel.empty? && fm.nil?
+
       indices = sel.map { |v| opts.index(v) }
       # The one whose answer settles the approval (Approval.settle, by index).
       if parent_setting

data/lib/samagotchi/recap_setup.rb

@@ -114,7 +114,7 @@ module Samagotchi
       return range if range
 
       default = IdleRecap::RecapPrompt::DEFAULT_SENTENCES
-      Log.warn(:recap, "sentences_invalid", echo: "Warning: invalid value for recap.sentences: #{value.to_s.inspect} — using #{default.join('-')}",
+      Log.warn(:recap, "sentences_invalid", echo: "Warning: invalid value for recap.sentences: #{value.to_s.inspect} — using #{default.join("-")}",
                                             value: value.to_s)
       default
     end

data/lib/samagotchi/relay_desk.rb

@@ -35,7 +35,7 @@ module Samagotchi
     # The parent's user (or a parent agent) answered the relay card.
     # @param by [String] "user" or "parent_agent"
     # @return [Boolean] false when the relay isn't open (first answer wins)
-    def record(id, selected_indices: [], freeform: nil, dismissed: false, by:)
+    def record(id, by:, selected_indices: [], freeform: nil, dismissed: false)
       @mutex.synchronize do
         relay = @relays[id.to_s]
         next false unless relay && relay[:state] == "open"

data/lib/samagotchi/reminder_store.rb

@@ -81,7 +81,7 @@ module Samagotchi
       @mutex.synchronize do
         return "No active reminders." if @reminders.empty?
 
-        lines = @reminders.map do |name, r|
+        lines = @reminders.map do |_name, r|
           "  #{r[:name]} (interval: #{r[:interval_minutes]}m, id: #{r[:id]})"
         end
         "Active reminders:\n" + lines.join("\n")
@@ -98,6 +98,7 @@ module Samagotchi
       @mutex.synchronize do
         @reminders.each_value.filter_map do |r|
           next unless r[:next_fire_at] && now >= r[:next_fire_at]
+
           { name: r[:name], description: r[:description], interval_minutes: r[:interval_minutes] }
         end.freeze
       end

data/lib/samagotchi/send_command.rb

@@ -197,6 +197,7 @@ module Samagotchi
       return usage_error("--wait takes one session") if options[:wait] && options[:ids].uniq.size > 1
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
+
       %i[dir model].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
 
@@ -229,6 +230,7 @@ module Samagotchi
     # caller never closes still hangs, as it would for cat.)
     def read_stdin
       return nil if @stdin.respond_to?(:tty?) && @stdin.tty?
+
       if @stdin.respond_to?(:stat)
         stat = @stdin.stat
         return nil unless stat.pipe? || stat.file?
@@ -328,8 +330,8 @@ module Samagotchi
 
     # The session as it was before the message went in (ReplyWait's
     # baseline).
-    def baseline_of(session, **options)
-      ReplyWait.baseline_of(session, **options)
+    def baseline_of(session, **)
+      ReplyWait.baseline_of(session, **)
     end
 
     # A new idle session's first turn, with the images. Its worker's Bridge

data/lib/samagotchi/session.rb

@@ -35,8 +35,8 @@ module Samagotchi
     SORT_ORDERS = %w[asc desc].freeze
 
     attr_accessor :id, :metadata_version, :mode, :model_name, :working_directory, :messages,
-                   :created_at, :updated_at, :status, :last_prompt, :first_preview, :test_run,
-                   :pending_question, :used_memory_names
+                  :created_at, :updated_at, :status, :last_prompt, :first_preview, :test_run,
+                  :pending_question, :used_memory_names
     # Memories the session was started with (--memory) and memories hidden
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.

data/lib/samagotchi/session_archive_command.rb

@@ -47,7 +47,11 @@ module Samagotchi
       bad = @argv.find { |arg| arg.start_with?("-") }
       return usage_error(bad ? "unknown option #{bad}" : "give session ids") if bad || @argv.empty?
 
-      @argv.uniq.map { |given| @action == "archive" ? archive(given) : unarchive(given) }.all? ? 0 : 1
+      if @argv.uniq.map { |given| @action == "archive" ? archive(given) : unarchive(given) }.all?
+        0
+      else
+        1
+      end
     end
 
     private

data/lib/samagotchi/session_commands.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 require_relative "config"
 require_relative "model_profile"
 require_relative "served_model"
@@ -65,7 +63,7 @@ module Samagotchi
         guardrails(text.delete_prefix(GUARDRAILS_COMMAND).strip)
       end
       registry.register(MODEL_COMMAND, "show or switch the model",
-                        match: ->(text) { text.match?(/\A\/model(?:\s+.*)?\z/) }) { |text| model(text) }
+                        match: ->(text) { text.match?(%r{\A/model(?:\s+.*)?\z}) }) { |text| model(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)

data/lib/samagotchi/session_manager.rb

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 require "fileutils"
@@ -272,7 +271,7 @@ module Samagotchi
       root = cwd && folder_path(cwd)
       roots = {}
       summaries = Session.list(state_dir: sd, sort: sort || "updated_at", order: order || "desc", project_root: project_root,
-                                           include_archived: include_archived).lazy
+                               include_archived: include_archived).lazy
                          .reject { |s| (!include_tests && s.test_run) || s.id == exclude }
                          .select { |s| root.nil? || in_folder?(s.working_directory, root) }
                          .filter_map do |s|
@@ -703,7 +702,7 @@ module Samagotchi
       Dir.children(dir).all? do |name|
         path = File.join(dir, name)
         if EMPTY_SKELETON_DIRS.include?(name)
-          File.directory?(path) && (!EMPTY_DIRS.include?(name) || Dir.children(path).empty?)
+          File.directory?(path) && (!EMPTY_DIRS.include?(name) || Dir.empty?(path))
         elsif name == "analytics.json"
           Array(JSON.parse(File.read(path))["turn_records"]).empty?
         # Cards and notices from before any turn (Bridge::CardStore).
@@ -1054,4 +1053,3 @@ module Samagotchi
     end
   end
 end
-

data/lib/samagotchi/session_metrics.rb

@@ -137,9 +137,9 @@ module Samagotchi
 
       tokens = data["tokens"].is_a?(Hash) ? data["tokens"] : {}
       count = ->(key) { tokens[key].is_a?(Numeric) ? tokens[key] : 0 }
-      SavedSummary.new(ctx_pct: saved_pct(data["context"]), prompt_sum: count.("prompt_sum"),
-                       completion_sum: count.("completion_sum"), cached_sum: count.("cached_sum"),
-                       reasoning_sum: count.("reasoning_sum"), cost_sum: count.("cost_sum"))
+      SavedSummary.new(ctx_pct: saved_pct(data["context"]), prompt_sum: count.call("prompt_sum"),
+                       completion_sum: count.call("completion_sum"), cached_sum: count.call("cached_sum"),
+                       reasoning_sum: count.call("reasoning_sum"), cost_sum: count.call("cost_sum"))
     rescue JSON::ParserError, SystemCallError, TypeError
       nil
     end
@@ -379,15 +379,15 @@ module Samagotchi
     # Caller holds the mutex.
     def tokens_block(totals, turn)
       add = ->(key) { totals[key] + (turn&.public_send(key) || 0) }
-      decode_ms = add.(:decode_ms_sum)
-      decode_tokens = add.(:decode_tokens_sum)
+      decode_ms = add.call(:decode_ms_sum)
+      decode_tokens = add.call(:decode_tokens_sum)
       speed_turn = turn&.last_decode_tps ? turn : nil
       {
-        prompt_sum: add.(:prompt_sum),
-        completion_sum: add.(:completion_sum),
-        cached_sum: add.(:cached_sum),
-        reasoning_sum: add.(:reasoning_sum),
-        cost_sum: add.(:cost_sum),
+        prompt_sum: add.call(:prompt_sum),
+        completion_sum: add.call(:completion_sum),
+        cached_sum: add.call(:cached_sum),
+        reasoning_sum: add.call(:reasoning_sum),
+        cost_sum: add.call(:cost_sum),
         decode_ms_sum: decode_ms.round,
         decode_tokens_sum: decode_tokens,
         avg_decode_tps: decode_ms.positive? ? (decode_tokens * 1000.0 / decode_ms).round(1) : nil,

data/lib/samagotchi/session_observer.rb

@@ -70,6 +70,7 @@ module Samagotchi
     #   already-unsubscribed never raises)
     def unsubscribe(handle:)
       return false unless handle.is_a?(SubscribedObserver)
+
       @mutex.synchronize { !!@observers.delete(handle) }
     end
 
@@ -110,8 +111,8 @@ module Samagotchi
     # Run the block while no event is being numbered or delivered, so it sees
     # (and can change) state consistently with the event log. Reentrant: the
     # block may notify. Keep it short; every emitter waits for it.
-    def synchronize(&block)
-      @mutex.synchronize(&block)
+    def synchronize(&)
+      @mutex.synchronize(&)
     end
   end
 end

data/lib/samagotchi/session_retention.rb

@@ -171,7 +171,7 @@ module Samagotchi
       end
 
       now = Time.now
-      cutoff = days.to_i.positive? ? now - days.to_i * 86_400 : nil
+      cutoff = days.to_i.positive? ? now - (days.to_i * 86_400) : nil
       max = max_count.to_i
 
       deleted = []
@@ -249,7 +249,7 @@ module Samagotchi
           begin
             FileUtils.rm_f(path)
             sidecar = File.join(state_dir, session.id)
-            FileUtils.rm_rf(sidecar) if File.exist?(sidecar)
+            FileUtils.rm_rf(sidecar)
             PluginSessionState.remove(session.id)
             deleted << session.id
           rescue StandardError

data/lib/samagotchi/sessions_command.rb

@@ -118,6 +118,7 @@ module Samagotchi
         return usage_error("unknown format #{format.inspect}: use --format text|json|tsv")
       end
       return usage_error("unknown scope #{scope.inspect}: use --scope=project|all") unless scope.nil? || %w[project all].include?(scope)
+
       # The current git project's sessions (Samagotchi::ProjectScope), like
       # chi web's; --scope=all, a folder in no repo or an explicit --cwd: every
       # project's.
@@ -175,13 +176,17 @@ module Samagotchi
           end
           # A delegated session points at its parent.
           child = summary[:parent_short_id] ? "  ↳ #{summary[:parent_short_id]}" : ""
-          flag = summary[:scratch] ? " [scratch]" : (summary[:test_run] ? " [test]" : "")
+          flag = if summary[:scratch]
+                   " [scratch]"
+                 else
+                   (summary[:test_run] ? " [test]" : "")
+                 end
           flag += " [archived]" if summary[:archived]
           ctx = Samagotchi::SessionMetrics.context_label(summary[:ctx_pct])
           @stdout.puts "#{summary[:id]}  #{state.ljust(8)}  #{ctx.ljust(8)}  #{summary[:updated_at]}  #{desc}#{flag}#{child}"
         end
         if project
-          @stdout.puts "#{summaries.empty? ? "" : "\n"}#{scope_note.call(summaries.size)}"
+          @stdout.puts "#{"\n" unless summaries.empty?}#{scope_note.call(summaries.size)}"
         else
           @stdout.puts summaries.empty? ? "No sessions." : "\n#{summaries.size} session(s)"
         end
@@ -204,7 +209,11 @@ module Samagotchi
       end
       # A delegated session points at its parent: ↳ <parent's short id>.
       row = lambda do |s|
-        flag = s.scratch ? " [scratch]" : (s.test_run ? " [test]" : "")
+        flag = if s.scratch
+                 " [scratch]"
+               else
+                 (s.test_run ? " [test]" : "")
+               end
         flag += " [archived]" if s.archived
         child = s.parent_id ? "  ↳ #{s.parent_id[0, 8]}" : ""
         # How full the context was after the last turn: "ctx 12%", blank when unknown.
@@ -222,7 +231,7 @@ module Samagotchi
       end
       if project
         sessions.each { |s| @stdout.puts row.call(s) }
-        @stdout.puts "#{sessions.empty? ? "" : "\n"}#{scope_note.call(sessions.size)}"
+        @stdout.puts "#{"\n" unless sessions.empty?}#{scope_note.call(sessions.size)}"
       elsif sessions.empty?
         @stdout.puts "No sessions."
       else
@@ -276,7 +285,7 @@ module Samagotchi
           next false
         rescue Samagotchi::SessionManager::RestartRefused => e
           @stdout.flush
-          @stderr.puts e.reason == :not_running || e.reason == :unsupported ? e.message : "session #{id}: #{e.message}"
+          @stderr.puts %i[not_running unsupported].include?(e.reason) ? e.message : "session #{id}: #{e.message}"
           next false
         rescue ArgumentError => e
           @stdout.flush

data/lib/samagotchi/steer.rb

@@ -10,20 +10,41 @@ module Samagotchi
   #
   # The user's own lines merged into a running turn are marked kind:
   # "input": they are part of that turn, not a turn of their own, so a
-  # reloaded history keeps the turn in one piece.
+  # reloaded history keeps the turn in one piece. A line can be a Line
+  # naming who sent it (a worker's input from chi send, a delegating parent,
+  # a plugin); its input message then carries that source:. The user's own
+  # lines carry none, so their saved bytes are as they always were.
   module Steer
     KIND = "steer"
     INPUT_KIND = "input"
 
+    # A drain item for an input line with its sender (source nil = the user).
+    # A plain String is still a valid item: the user's line.
+    Line = Data.define(:text, :source)
+
+    # The client ids whose input is not the user's own words. Literals, not
+    # SendCommand::CLIENT_ID / Tools::Delegate::CLIENT_PREFIX, so this file
+    # needs no requires (a spec pins them equal).
+    CHI_SEND_CLIENT = "cli:send"
+    DELEGATE_CLIENT_PREFIX = "delegate:"
+    PLUGIN_CLIENT = "plugin"
+
     # What one drain brought: the merged user text (nil when none) and how
-    # many lines made it, and the steers in order.
-    Merge = Struct.new(:content, :count, :steers, keyword_init: true) do
+    # many lines made it, the input messages' text grouped by sender
+    # (consecutive lines from one sender form one group), and the steers in
+    # order.
+    Merge = Struct.new(:content, :count, :inputs, :steers, keyword_init: true) do
       def empty? = content.nil? && steers.empty?
 
-      # The messages it appends: the user's first (marked merged input),
-      # then each steer.
+      # The messages it appends: the merged input first (one message per
+      # sender run, marked kind input, source: when not the user's), then
+      # each steer.
       def messages
-        list = content ? [{ role: "user", kind: INPUT_KIND, content: content }] : []
+        list = inputs.map do |input|
+          message = { role: "user", kind: INPUT_KIND }
+          message[:source] = input[:source] if input[:source]
+          message.merge(content: input[:content])
+        end
         list + steers.map { |steer| Steer.message(**steer) }
       end
 
@@ -36,8 +57,50 @@ module Samagotchi
       end
     end
 
+    # The one line the model reads above a steer or merged input (the wire
+    # only; the saved content stays raw): who sent it, and that it should
+    # follow it or, if it asks for nothing, carry on.
+    HEADER_TAIL = "mid-task. Follow it; if it asks for nothing, carry on with the task.]"
+    SENDERS = {
+      "user" => "from the user",
+      "parent_agent" => "from the parent agent that started this session",
+      "chi_send" => "sent with chi send",
+      "plugin_send" => "sent by a plugin"
+    }.freeze
+    USER_HEADER = "[Steer #{SENDERS["user"]}, #{HEADER_TAIL}".freeze
+
     module_function
 
+    # The saved source of a worker input line from +client_id+: nil for the
+    # user (no client id, the web, an attached TUI, anything unknown).
+    def source_for_client(client_id)
+      id = client_id.to_s
+      if id == CHI_SEND_CLIENT then "chi_send"
+      elsif id.start_with?(DELEGATE_CLIENT_PREFIX) then "parent_agent"
+      elsif id == PLUGIN_CLIENT then "plugin_send"
+      end
+    end
+
+    # The header for a steer or merged input message, else nil. No source
+    # (or "") is the user's; an input with an unknown source too; a steer
+    # with an unknown source is a plugin's (its bundle or hook label).
+    def header(message)
+      kind = (message[:kind] || message["kind"]).to_s
+      return unless [KIND, INPUT_KIND].include?(kind)
+
+      source = (message[:source] || message["source"]).to_s
+      source = "user" if source.empty?
+      sender = SENDERS[source] || (kind == KIND ? "from the #{source} plugin" : SENDERS["user"])
+      "[Steer #{sender}, #{HEADER_TAIL}"
+    end
+
+    # The text a steer or merged input goes out as: its header, a newline,
+    # then +text+ (the message's content by default). Other messages: +text+.
+    def wire_text(message, text = (message[:content] || message["content"]).to_s)
+      header = header(message)
+      header ? "#{header}\n#{text}" : text
+    end
+
     def message(text:, source:)
       { role: "user", kind: KIND, source: source.to_s, content: text.to_s }
     end
@@ -46,6 +109,24 @@ module Samagotchi
       (message[:kind] || message["kind"]).to_s == KIND
     end
 
+    # The sources of a steer a person sent (a continue card's text, from the
+    # user or a parent agent's chi answer), not a plugin's prod.
+    PERSON_SOURCES = %w[user parent_agent].freeze
+
+    # The senders whose message may cut a generation that has only been
+    # thinking (Engine#cut_for_steer): the user (no source), chi send, a
+    # parent agent. A plugin's never does.
+    CUT_SOURCES = ["", "user", "chi_send", "parent_agent"].freeze
+
+    def cuts?(source)
+      CUT_SOURCES.include?(source.to_s)
+    end
+
+    # A steer a person sent: what a recap and a side question keep.
+    def person?(message)
+      steer?(message) && PERSON_SOURCES.include?((message[:source] || message["source"]).to_s)
+    end
+
     # A user message that is a prompt or the user's steering, not a steer:
     # what "the last prompt" and "user turns" count.
     def prompt?(message)
@@ -105,8 +186,22 @@ module Samagotchi
         text = (item[:text] || item["text"]).to_s.strip
         { source: (item[:source] || item["source"]).to_s, text: text } unless text.empty?
       end
-      content = lines.map { |line| line.to_s.strip }.reject(&:empty?).join("\n\n")
-      Merge.new(content: content.empty? ? nil : content, count: content.empty? ? 0 : lines.length, steers: steers)
+      inputs = input_groups(lines)
+      content = inputs.map { |input| input[:content] }.join("\n\n")
+      Merge.new(content: content.empty? ? nil : content, count: content.empty? ? 0 : lines.length,
+                inputs: inputs, steers: steers)
+    end
+
+    # Non-blank input lines as [{content:, source:}], one per run of lines
+    # from the same sender.
+    def input_groups(lines)
+      pairs = lines.filter_map do |line|
+        text = (line.is_a?(Line) ? line.text : line).to_s.strip
+        [text, line.is_a?(Line) ? line.source : nil] unless text.empty?
+      end
+      pairs.chunk_while { |a, b| a[1] == b[1] }.map do |run|
+        { content: run.map(&:first).join("\n\n"), source: run.first[1] }
+      end
     end
   end
 end

data/lib/samagotchi/system_prompt.rb

@@ -79,9 +79,10 @@ module Samagotchi
       @built = nil
     end
 
-    # The base prompt (specs, plugins' declarations).
+    # The base prompt (specs, plugins' declarations), with Gemma's tool
+    # declarations at its end as #build has them.
     def base(chat: false, thinking: nil)
-      assist_system_prompt(chat: chat, thinking: thinking)
+      with_tail_declarations(assist_system_prompt(chat: chat, thinking: thinking), chat: chat)
     end
 
     # Names activated via preloaded --memory entries during prompt
@@ -141,15 +142,18 @@ module Samagotchi
     def assist_system_prompt(chat: false, thinking: nil)
       return chat_system_prompt if chat
 
-      declarations = tool_declarations
       hint = tool_call_hint
       turn_preamble = turn_preamble_instruction(thinking)
+      # Gemma 4's template declares the tools at the end of the system turn
+      # (#system_prompt_with_index puts them there).
+      tools = if gemma_tail_declarations?
+                "Your tools are declared at the end of this system prompt."
+              else
+                "You have access to the following tools:\n\n#{tool_declarations}\n"
+              end
 
       <<~SYS
-        You are Chi (pronounced "chee"), the friendly name for the Samagotchi assistant harness. You have access to the following tools:
-
-        #{declarations}
-
+        You are Chi (pronounced "chee"), the friendly name for the Samagotchi assistant harness. #{tools}
         #{hint}
         You may make multiple tool calls. After seeing tool results, continue reasoning or answer the user.
         #{turn_preamble}
@@ -234,9 +238,16 @@ module Samagotchi
         "Project memories:\n#{project_index}",
         "System memories:\n#{system_index}"
       ].join("\n\n")
-      [thinking_token + base, rg_guidance, project_description, project_location, current_model, current_session, memory_sections, system_identity_section, explicit_memory_section].compact.join("\n")
+      prompt = [thinking_token + base, rg_guidance, project_description, project_location, current_model, current_session, memory_sections, system_identity_section, explicit_memory_section].compact.join("\n")
+      with_tail_declarations(prompt, chat: chat)
     end
 
+    def with_tail_declarations(prompt, chat:)
+      chat || !gemma_tail_declarations? ? prompt : prompt.rstrip + tool_declarations
+    end
+
+    def gemma_tail_declarations? = profile.name == "gemma4"
+
     # B-light: auto-preload the built-in identity memory.
     # The file is installed by SystemBundle.ensure! as a normal system memory,
     # but its body is injected here so the agent has it without an extra tool call.

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -46,10 +46,10 @@ module Samagotchi
         first_command = model && (attach || resume) ? "/model #{model}" : nil
         surface = open_surface
         attached = AttachedLoop.new(client: client, screen: surface, client_id: "tui:#{Process.pid}", first_prompt: prompt,
-                                first_command: first_command, no_interrupt: no_interrupt,
-                                default_input: default_input && !prompt && !attach && !resume,
-                                wait_at_eof: !$stdin.tty?,
-                                parent_answers: Guardrails::ParentApprovals.parent_process?)
+                                    first_command: first_command, no_interrupt: no_interrupt,
+                                    default_input: default_input && !prompt && !attach && !resume,
+                                    wait_at_eof: !$stdin.tty?,
+                                    parent_answers: Guardrails::ParentApprovals.parent_process?)
         ended = begin
           attached.run
         ensure
@@ -144,7 +144,7 @@ module Samagotchi
         return if flags.empty?
 
         verb = flags.size == 1 ? "applies" : "apply"
-        err.puts "(#{flags.join(' and ')} #{verb} to a new session; #{session_id}'s prompt is already built)"
+        err.puts "(#{flags.join(" and ")} #{verb} to a new session; #{session_id}'s prompt is already built)"
       end
 
       # @return [BridgeClient, nil] the running worker's, or nil when none runs

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "../prompt_history"
@@ -1174,7 +1173,8 @@ module Samagotchi
         Bridge::TurnAccumulator.replay_events(turn).each do |event|
           case event[:type]
           # A new step starts its line over, as live (a join during a hold).
-          when :generation_started then tail, lane = nil, :writing
+          when :generation_started then tail = nil
+                                        lane = :writing
           when :generation_chunk
             tail, lane = event[:thinking].to_s.empty? ? [event[:text], :writing] : [event[:thinking], :thinking]
           when :tool_call_started
@@ -1189,7 +1189,7 @@ module Samagotchi
           # hook's notice, a retry's line), as they were drawn live.
           # Questions are left out: the pending one is asked after the
           # replay, answered ones showed no line.
-          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry then @renderer.call(event)
+          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut then @renderer.call(event)
           end
         end
         @view.resume(tail: tail, lane: lane, tool: running_tool, parts: turn[:parts])

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require_relative "formatting"
 
 module Samagotchi
@@ -80,6 +79,9 @@ module Samagotchi
         when :empty_answer_retry
           @view.finish_thinking_spinner
           @view.print_line(@view.format_empty_retry_line(event))
+        when :steer_cut
+          @view.finish_thinking_spinner
+          @view.print_line(@view.format_steer_cut_line(event))
         when :turn_completed
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
         when :turn_canceled
@@ -188,7 +190,7 @@ module Samagotchi
         Array(event[:steers]).each { |steer| @view.print_line(@view.format_steer_line(source: steer[:source], text: steer[:text])) }
       end
 
-private
+      private
 
       def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil)
         return if activity.nil?