samagotchi 0.24.0 → 0.26.0

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -11,11 +11,21 @@ module Samagotchi
     # $stdout is a colour terminal.
     module Formatting
       def format_tool_activity_line(activity, duration_ms: nil)
-        params = activity[:params].to_s.strip
-        params_suffix = params.empty? ? "" : " #{paint(params, 90)}"
         status = activity[:status].to_s
         elapsed_suffix = duration_ms.nil? ? "" : " (#{format_elapsed_duration(duration_ms)})"
-        "#{paint("tool>", 36)} #{activity[:action]} (#{activity[:tool]}#{params_suffix}): #{paint(status, status_color(status))}#{elapsed_suffix}"
+        "#{paint("tool>", 36)} #{activity[:action]} (#{activity[:tool]}#{tool_params_suffix(activity)}): " \
+          "#{paint(status, status_color(status))}#{elapsed_suffix}"
+      end
+
+      # What a tool line says the call did: the model's description of a
+      # command (": List the specs") in place of its cut params, else the
+      # params, dim.
+      def tool_params_suffix(activity)
+        description = activity[:description].to_s.strip
+        return ": #{description}" unless description.empty?
+
+        params = activity[:params].to_s.strip
+        params.empty? ? "" : " #{paint(params, 90)}"
       end
 
       # Green ok, yellow stopped (a wait the user's Stop ended), red the rest.
@@ -30,12 +40,22 @@ module Samagotchi
 
       STEER_PREVIEW = 80
 
+      # Who a steer names as its sender: a plugin's own label, chi's sender
+      # ids in words (the web's format.js steerSender agrees;
+      # spec/shared/labels_matrix.json). "": no one named.
+      STEER_SENDERS = { "parent_agent" => "parent agent", "chi_send" => "chi send", "plugin_send" => "plugin" }.freeze
+
+      def steer_sender(source)
+        STEER_SENDERS.fetch(source.to_s, source.to_s)
+      end
+
       # "check-in> nudged: <text>", dim, one line cut: a plugin's steer
       # (Steer) in the running turn or the join's last exchange.
       def format_steer_line(source:, text:)
         first = text.to_s.strip.split("\n").first.to_s
         first = "#{first[0, STEER_PREVIEW - 1]}…" if first.length > STEER_PREVIEW || text.to_s.strip.include?("\n")
-        paint("#{source.to_s.empty? ? "plugin" : source}> nudged: #{first}", 90)
+        sender = steer_sender(source)
+        paint("#{sender.empty? ? "plugin" : sender}> nudged: #{first}", 90)
       end
 
       # "↻ empty answer, asking again (1/1)": the loop retries an empty answer;
@@ -119,10 +139,8 @@ module Samagotchi
 
       # A tool call from the snapshot: it has no action text, only the tool.
       def snapshot_tool_line(part)
-        params = part[:params].to_s.strip
-        params_suffix = params.empty? ? "" : " #{paint(params, 90)}"
         status = part[:status].to_s
-        "#{paint("tool>", 36)} #{part[:tool]}#{params_suffix}: #{paint(status, status_color(status))}" \
+        "#{paint("tool>", 36)} #{part[:tool]}#{tool_params_suffix(part)}: #{paint(status, status_color(status))}" \
           "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
       end
 
@@ -385,6 +403,9 @@ module Samagotchi
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
         lines << "retries:          #{snapshot[:retries]}"
+        # A looped session: loop-guard's cuts, or thinking that ran to the cap.
+        lines << "thinking cuts:    #{snapshot[:cuts].to_i}"
+        lines << "output cap hits:  #{snapshot[:capped].to_i}"
         context = snapshot[:context] || {}
         if context[:used_tokens]
           pct = context[:window_tokens].to_i.positive? ? format(" (%.1f%%)", context[:used_tokens] * 100.0 / context[:window_tokens]) : ""
@@ -400,14 +421,15 @@ module Samagotchi
         lines.join("\n")
       end
 
-      # ", cached 4864 (93%), reasoning 212" for the tokens line; the counts a
-      # server didn't report are left out.
+      # ", cached 4864 (93%), cache writes 312, reasoning 212" for the tokens
+      # line; the counts a server didn't report are left out.
       def token_breakdown_text(tokens)
         cached = tokens[:cached_sum].to_i
         reasoning = tokens[:reasoning_sum].to_i
         prompt = tokens[:prompt_sum].to_i
         text = +""
         text << ", cached #{cached} (#{(cached * 100.0 / prompt).round}%)" if cached.positive? && prompt.positive?
+        text << ", cache writes #{tokens[:cache_write_sum].to_i}" if tokens[:cache_write_sum].to_i.positive?
         text << ", reasoning #{reasoning}" if reasoning.positive?
         text
       end

data/lib/samagotchi/terminal_ui.rb

@@ -173,6 +173,8 @@ module Samagotchi
       # -p without --non-interactive drops into the REPL, which can answer
       # an approval; --non-interactive can't, so an approval there denies.
       @engine.interface = @non_interactive ? :non_interactive : :repl
+      # A --non-interactive run exits after its turn: no turn-end warm-up.
+      @engine.next_turn_waiting = -> { true } if @non_interactive
       @turn_flow = TurnFlow.new(engine: @engine)
       # A recap written while a continue offer waits says the turn stopped
       # unfinished. (Answering at the prompt is typing: activity already.)

data/lib/samagotchi/thinking_tails.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "atomic_file"
+
+module Samagotchi
+  # The thinking a session would otherwise lose: a SessionObserver
+  # subscriber (next to SessionMetrics) that keeps the tail of a generation
+  # cut mid-stream (a plugin's stop_generation, loop-guard's cut, a steer's
+  # cut), stopped with its turn by a plugin (stop_turn), or ended at the
+  # provider's output cap (finish_reason length). A cut generation's
+  # thinking is dropped from the conversation, and a looping one is what a
+  # fixture needs.
+  #
+  # The tails go to <session dir>/thinking_tails.jsonl, one JSON record a
+  # line, the newest MAX_RECORDS kept: next to the session's analytics.json,
+  # so an archived session (and a copied session dir) keeps them. Not in the
+  # session's messages (nothing there can reach the model, hooks or the
+  # web's reload by accident) and not in the turn records (the live snapshot
+  # carries those on every /state frame).
+  class ThinkingTails
+    FILE = "thinking_tails.jsonl"
+    # The last chars of a generation's thinking kept: a loop's cycle and
+    # some of its lead-in.
+    TAIL_CHARS = 20_000
+    MAX_RECORDS = 10
+
+    # @param session_dir [#call] the current session's directory, or nil
+    #   (no session yet: nothing is written)
+    def initialize(session_dir:, clock: -> { Time.now })
+      @session_dir = session_dir
+      @clock = clock
+      @turn_id = nil
+      reset
+    end
+
+    # The saved records of +dir+, oldest first (empty without a file).
+    # @return [Array<Hash>] string-keyed
+    def self.read(dir)
+      File.readlines(File.join(dir, FILE), chomp: true).filter_map do |line|
+        JSON.parse(line)
+      rescue JSON::ParserError
+        nil
+      end
+    rescue SystemCallError
+      []
+    end
+
+    def call(event)
+      case event[:type]
+      when :turn_started then @turn_id = event[:turn_id]
+      when :generation_started, :generation_retrying then reset
+      when :generation_chunk then add(event[:thinking].to_s)
+      when :generation_completed then completed(event)
+      when :generation_cancelled
+        # A plugin's stop_turn mid-generation (the bundle that stopped it,
+        # "hook" when unknown); a user's Stop is not kept.
+        keep(event, finish_reason: "cancelled", stopped_by: (event[:stopped_by] || "hook").to_s) if event[:reason].to_s == "hook"
+      end
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    def reset
+      @tail = +""
+      @chars = 0
+    end
+
+    def add(thinking)
+      return if thinking.empty?
+
+      @chars += thinking.length
+      @tail << thinking
+      @tail = @tail[-TAIL_CHARS..] if @tail.length > 2 * TAIL_CHARS
+    end
+
+    def completed(event)
+      stopped_by = event[:stopped_by]
+      return reset unless stopped_by || event[:finish_reason].to_s == "length"
+
+      keep(event, finish_reason: event[:finish_reason].to_s, stopped_by: stopped_by&.to_s, stop_reason: event[:stop_reason])
+    end
+
+    # Writes the record and forgets the generation (the native loop's cut
+    # with no retry left reports :generation_cancelled after it too).
+    def keep(event, **fields)
+      return reset if @chars.zero?
+
+      record = { at: @clock.call.utc.iso8601(3), turn_id: @turn_id, iteration: event[:iteration], **fields,
+                 thinking_chars: @chars, tail: @tail.length > TAIL_CHARS ? @tail[-TAIL_CHARS..] : @tail }.compact
+      reset
+      dir = @session_dir.call
+      return unless dir
+
+      FileUtils.mkdir_p(dir)
+      lines = self.class.read(dir).last(MAX_RECORDS - 1).map { |kept| JSON.generate(kept) }
+      AtomicFile.write(File.join(dir, FILE), (lines + [JSON.generate(record)]).join("\n") << "\n")
+    end
+  end
+end

data/lib/samagotchi/token_usage.rb

@@ -12,15 +12,16 @@ module Samagotchi
   # The last chunk can say more: llama.cpp adds a `timings` block with exact
   # speeds and `cache_n` (its native `tokens_cached` counts the new tokens too,
   # so it is not read); OpenRouter adds `usage.cost` (USD) and the
-  # `prompt_tokens_details.cached_tokens` / `completion_tokens_details.reasoning_tokens`
-  # breakdowns. Those fields are nil when a payload doesn't carry them.
+  # `prompt_tokens_details.cached_tokens` / `cache_write_tokens` /
+  # `completion_tokens_details.reasoning_tokens` breakdowns (cache writes:
+  # Anthropic models, prompt caching's first request). Those fields are nil when a payload doesn't carry them.
   #
   # from_payload returns nil when no server token counts are present, so a
   # caller can fall back to a chars/4 heuristic. The reported values are
   # cumulative per request, so callers should take the running MAX across
   # chunks (see SessionMetrics).
-  class TokenUsage < Data.define(:prompt_tokens, :completion_tokens, :cached_tokens, :reasoning_tokens, :cost,
-                                 :predicted_per_second, :prompt_per_second, :predicted_ms, :source)
+  class TokenUsage < Data.define(:prompt_tokens, :completion_tokens, :cached_tokens, :cache_write_tokens,
+                                 :reasoning_tokens, :cost, :predicted_per_second, :prompt_per_second, :predicted_ms, :source)
     CHARS_PER_TOKEN = 4.0
 
     class << self
@@ -41,11 +42,12 @@ module Samagotchi
         )
         return nil unless prompt_tokens || completion_tokens
 
+        details = hash_at(usage, :prompt_tokens_details)
         new(
           prompt_tokens: prompt_tokens,
           completion_tokens: completion_tokens,
-          cached_tokens: first_positive(*both(hash_at(usage, :prompt_tokens_details), :cached_tokens),
-                                        *both(timings, :cache_n)),
+          cached_tokens: first_positive(*both(details, :cached_tokens), *both(timings, :cache_n)),
+          cache_write_tokens: first_positive(*both(details, :cache_write_tokens)),
           reasoning_tokens: first_positive(*both(hash_at(usage, :completion_tokens_details), :reasoning_tokens)),
           cost: number(*both(usage, :cost)),
           predicted_per_second: positive_number(*both(timings, :predicted_per_second)),
@@ -55,6 +57,16 @@ module Samagotchi
         )
       end
 
+      # A request's prompt-cache counts as a :generation_completed event
+      # carries them (the log line too): the prompt, the part of it the
+      # server reused from its cache, and the part it wrote to it (nil when
+      # none: only some remote servers report writes).
+      # @return [Hash] {prompt_tokens:, cached_tokens:, cache_write_tokens:}
+      def cache_fields(prompt:, cached:, cache_write:)
+        { prompt_tokens: prompt.to_i, cached_tokens: cached.to_i,
+          cache_write_tokens: cache_write.to_i.positive? ? cache_write.to_i : nil }
+      end
+
       # Estimate token count from raw text length using the chars/4 heuristic.
       # @param text [String]
       # @return [Integer]

data/lib/samagotchi/tool_activity.rb

@@ -2,6 +2,8 @@
 
 require "json"
 require_relative "log"
+require_relative "command_steps"
+require_relative "tool_view"
 require_relative "tools/execute"
 require_relative "tools/read"
 require_relative "tools/write"
@@ -42,15 +44,34 @@ module Samagotchi
       }
       title = tool_title(tool_name, call, cwd: cwd)
       event[:title] = title if title
+      # The model's own words for a command, which the TUI's tool line
+      # shows in place of the cut params.
+      description = command_description(tool_name, call)
+      event[:description] = description if description
       event
     end
 
+    # An execute's description, cut as a row's title; nil for the rest.
+    def command_description(tool_name, call)
+      return nil unless call.is_a?(Hash) && ToolView::TOOLS.include?(tool_name)
+
+      ToolView.description_title(call)
+    end
+
     # What the call did, for a web row's one line ("edit lib/a.rb", the
     # command without its "cd … &&"): a file tool's path relative to +cwd+
-    # when it is under it, a command's first line, a memory's name; nil for
-    # the other tools (a plugin's row keeps its preview, the params).
-    # +params+ stays the full key=value line (the TUI, the guardrails).
+    # when it is under it, a command's description (the model's few words),
+    # else its first step and how many more (CommandSteps; its first line
+    # when it has no steps), a memory's name;
+    # nil for the other tools (a plugin's row keeps its preview, the
+    # params). +params+ stays the full key=value line (the TUI, the
+    # guardrails).
     def tool_title(tool_name, call, cwd: nil)
+      if [Tools::Execute::NAME, Tools::TaskCreate::NAME].include?(tool_name)
+        title = command_description(tool_name, call) || steps_title(call[:content])
+        return title if title
+      end
+
       text = case tool_name
              when Tools::Read::NAME, Tools::MemoryRead::NAME then call[:content]
              when Tools::Write::NAME, Tools::Edit::NAME, Tools::MemoryWrite::NAME then call[:path]
@@ -73,6 +94,19 @@ module Samagotchi
     # eats the line.
     LEADING_CD = /\Acd\s+(?:"[^"]*"|'[^']*'|\S+)\s*(?:&&|;)\s*/
 
+    # "<first step> +N" (N the steps after it), cut to fit
+    # TOOL_ACTIVITY_PREVIEW_LIMIT; nil when the command has no steps.
+    def steps_title(command)
+      steps = CommandSteps.parse(command)&.steps
+      return nil unless steps
+
+      first = steps.first.text.gsub(/\s+/, " ")
+      more = steps.size > 1 ? " +#{steps.size - 1}" : ""
+      room = TOOL_ACTIVITY_PREVIEW_LIMIT - more.length
+      first = "#{first[0, room - 1]}…" if first.length > room
+      "#{first}#{more}"
+    end
+
     def command_title(command)
       line = command.to_s.lines.map(&:strip).find { |l| !l.empty? }.to_s
       line.sub(LEADING_CD, "")

data/lib/samagotchi/tool_declarations.rb

@@ -26,6 +26,10 @@ module Samagotchi
               type: "string",
               description: "The shell command to run"
             },
+            description: {
+              type: "string",
+              description: "What this command does, in a few words (what, not why). Shown to the user as the step's title, so include it on every call."
+            },
             cwd: {
               type: "string",
               description: "Optional working directory to run in (defaults to the project root). Relative paths are resolved against the project root."
@@ -425,6 +429,16 @@ module Samagotchi
 
     module_function
 
+    # +schema+ without execute's description property: what a session
+    # with execute.description off declares (the parameter isn't offered
+    # at all). Any other schema as given.
+    def without_command_description(schema)
+      return schema unless schema[:name] == "execute"
+
+      parameters = schema[:parameters]
+      schema.merge(parameters: parameters.merge(properties: parameters[:properties].except(:description)))
+    end
+
     # Gemma 4 <|tool>declaration:NAME{…}<tool|> blocks for every tool, back
     # to back, as Gemma 4's chat template declares tools.
     # @param schemas [Array<Hash>] a Tools::Registry's schemas

data/lib/samagotchi/tool_view.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "command_steps"
 require_relative "tools/execute"
 require_relative "tools/task_create"
 
@@ -12,9 +13,14 @@ module Samagotchi
   # 80-char cut stay as they are (the guardrails, "ran as:", the TUI).
   #
   # +truncated+: the command was longer than COMMAND_LIMIT and is cut to it;
-  # +chars+ is then its full length.
-  ToolView = Data.define(:command, :cwd, :truncated, :chars) do
-    def to_h = super.compact.reject { |_key, value| value == false }
+  # +chars+ is then its full length. +cd+ and +steps+: the command as
+  # CommandSteps reads it (its leading cd, its steps), both nil when it
+  # can't (the fallback: the UI shows the command itself) or the command
+  # is cut. +description+: what the model said the command does (execute's
+  # optional description), whitespace collapsed, a trailing period gone;
+  # nil when it gave none.
+  ToolView = Data.define(:command, :cwd, :truncated, :chars, :cd, :steps, :description) do
+    def to_h = super.merge(steps: steps&.map(&:to_h)).compact.reject { |_key, value| value == false }
   end
 
   class ToolView
@@ -23,6 +29,11 @@ module Samagotchi
 
     TOOLS = [Tools::Execute::NAME, Tools::TaskCreate::NAME].freeze
 
+    # The longest description a view carries; a row's title shows the
+    # first TITLE_LIMIT characters of it.
+    DESCRIPTION_LIMIT = 300
+    TITLE_LIMIT = 60
+
     # @return [ToolView, nil] nil for a tool without a view and for an
     #   empty command
     def self.for(tool_name, call)
@@ -33,8 +44,33 @@ module Samagotchi
 
       cwd = call[:cwd].to_s.strip
       truncated = command.length > COMMAND_LIMIT
+      parsed = truncated ? nil : CommandSteps.parse(command)
       new(command: truncated ? command[0, COMMAND_LIMIT] : command, cwd: cwd.empty? ? nil : cwd,
-          truncated: truncated, chars: truncated ? command.length : nil)
+          truncated: truncated, chars: truncated ? command.length : nil, cd: parsed&.cd, steps: parsed&.steps,
+          description: description(call))
+    end
+
+    # The call's description as a view shows it, nil for none.
+    def self.description(call)
+      text = call[:description]
+      return nil unless text.is_a?(String)
+
+      text = text.gsub(/\s+/, " ").strip.sub(/(?<!\.)\.\z/, "")
+      return nil if text.empty?
+
+      text.length > DESCRIPTION_LIMIT ? "#{text[0, DESCRIPTION_LIMIT - 1]}…" : text
+    end
+
+    # A row's title from the call's description: cut to TITLE_LIMIT, at a
+    # word when one ends in its second half. nil for none.
+    def self.description_title(call)
+      text = description(call)
+      return text if text.nil? || text.length <= TITLE_LIMIT
+
+      cut = text[0, TITLE_LIMIT - 1]
+      space = cut.rindex(" ")
+      cut = cut[0, space] if space && space >= TITLE_LIMIT / 2
+      "#{cut.sub(/[\s,;:.-]+\z/, "")}…"
     end
   end
 end

data/lib/samagotchi/tools/builtins.rb

@@ -142,11 +142,14 @@ module Samagotchi
         -> { !!peers&.cancelled? }
       end
 
+      # @param command_description [Boolean] false: execute declares no
+      #   description parameter (execute.description off)
       # @return [Registry] a new registry with the built-ins, in
       #   TOOL_SCHEMAS order (an Engine's own, which bundles add to)
-      def registry
+      def registry(command_description: true)
         by_name = CLASSES.to_h { |klass| [klass::NAME, klass] }
         ToolDeclarations::TOOL_SCHEMAS.each_with_object(Registry.new) do |schema, registry|
+          schema = ToolDeclarations.without_command_description(schema) unless command_description
           klass = by_name.fetch(schema[:name])
           handler = HANDLERS.fetch(klass::NAME) { ->(call, _kctx) { klass.call(call[:content]) } }
           registry.register(klass::NAME, schema: schema, handler: handler)

data/lib/samagotchi/tools/execute.rb

@@ -2,6 +2,7 @@
 
 require "open3"
 require_relative "output_guardrails"
+require_relative "shell"
 
 module Samagotchi
   module Tools
@@ -90,7 +91,7 @@ module Samagotchi
         started = monotonic_time
         deadline = started + timeout_sec
 
-        Open3.popen3(env || {}, command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
+        Open3.popen3(env || {}, *Shell.argv(command), chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
           readers = [OutputReader.new(stdout), OutputReader.new(stderr)]
 

data/lib/samagotchi/tools/registry.rb

@@ -3,7 +3,11 @@
 module Samagotchi
   module Tools
     # The tools a session offers the model, in declaration order: the
-    # built-ins (Tools::Builtins), and later the ones bundles add. The
+    # built-ins (Tools::Builtins) as registered, then the ones bundles add,
+    # by bundle and name. That order doesn't depend on which plugin
+    # finished its init first or re-registered a changed tool, so the
+    # tool list (part of the prompt's cached prefix) is the same in every
+    # session with the same tools. The
     # native prompts and the chat path's tools: are rendered from #schemas,
     # and KernelLoop#dispatch runs a call through its entry's handler.
     class Registry
@@ -43,13 +47,16 @@ module Samagotchi
       def key?(name) = @entries.key?(name.to_s)
 
       # @return [Array<String>] in declaration order
-      def names = @entries.keys
+      def names = entries.map(&:name)
 
       # @return [Array<Entry>] in declaration order
-      def entries = @entries.values
+      def entries
+        core, added = @entries.values.partition(&:core?)
+        core + added.sort_by { |entry| [entry.source.to_s, entry.name] }
+      end
 
       # @return [Array<Hash>] the schemas, in declaration order
-      def schemas = @entries.values.map(&:schema)
+      def schemas = entries.map(&:schema)
 
       def freeze
         @entries.freeze

data/lib/samagotchi/tools/shell.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Samagotchi
+  module Tools
+    # The shell a model's (or the user's `!`) command runs in: execute,
+    # task_create and the shell bang. Non-login (a login shell re-sources
+    # profile files, which can rebuild PATH and shadow the inherited toolchain).
+    #
+    # macOS's /bin/sh is bash 3.2, which can't parse an apostrophe in a
+    # heredoc inside "$( )" -- the usual `git commit -m "$(cat <<'EOF' ...`.
+    # There, zsh in sh emulation runs instead (it reads no rc files in that
+    # mode), with the options that keep bash habits working: `{1..3}` brace
+    # expansion, unquoted `( )` in `[[ =~ ]]`, BASH_REMATCH, and echo
+    # expanding `\t` as macOS's sh does. Elsewhere (Linux) /bin/sh as before.
+    module Shell
+      ZSH = "/bin/zsh"
+      ZSH_SH_MODE = [ZSH, "--emulate", "sh", "+o", "ignore_braces", "+o", "sh_glob", "-o", "bash_rematch",
+                     "+o", "bsd_echo"].freeze
+      SH = ["/bin/sh"].freeze
+
+      # @return [Array<String>] the argv that runs +command+
+      def self.argv(command) = [*program, "-c", command]
+
+      # @return [Array<String>] the shell and its options, without -c
+      def self.program(host_os: RbConfig::CONFIG["host_os"], zsh: File.executable?(ZSH))
+        host_os.to_s.include?("darwin") && zsh ? ZSH_SH_MODE : SH
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/task_runtime.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "shellwords"
 require "time"
 require_relative "../atomic_file"
+require_relative "shell"
 
 module Samagotchi
   module Tools
@@ -49,11 +50,10 @@ module Samagotchi
         output_io.sync = true
 
         wrapped_command = wrapped_shell_command(normalized_command, exit_code_path)
-        # Non-login shell (matches Execute): a login shell re-sources profile
-        # files, which can rebuild PATH and shadow the inherited toolchain.
+        # Non-login, the shell Execute uses too (Shell).
         pid = Process.spawn(
           spawn_env,
-          "/bin/sh", "-c", wrapped_command,
+          *Shell.argv(wrapped_command),
           chdir: resolved_cwd,
           out: output_io,
           err: output_io,

data/lib/samagotchi/turn_note.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "model_profile"
+
 module Samagotchi
   # The one-line system note a turn leaves in the conversation when it ends
   # without an answer: failed before the model replied, cancelled, or over
@@ -19,6 +21,12 @@ module Samagotchi
     TASK_COMMAND_CHARS = 60
     RETRY_NUDGE = :retry_nudge
     EMPTY_ANSWER = :empty_answer
+    # An empty step's thinking kept on the marker: its tail, so a model
+    # that thought for minutes doesn't put megabytes in the session file.
+    STEP_CHARS = 20_000
+    # A step's native thinking starts with one of these; the cut keeps it,
+    # so the UIs still find the thinking (MessageParts).
+    THINK_OPENS = ["<think>", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN].freeze
 
     module_function
 
@@ -75,16 +83,32 @@ module Samagotchi
     # UIs, which draw the turn's notice and steps from it after a reload:
     # +retries+ the empty-answer retries spent, +steps+ the empty
     # generations as model messages (their thinking; the loops keep them out
-    # of the conversation, where they'd be empty assistant turns). Never
+    # of the conversation, where they'd be empty assistant turns), each
+    # text cut to its last STEP_CHARS. Never
     # sent: the payload builders send a system message's content, and the
     # copies for hooks, plugins and the recap drop it (AnswerDisplay.strip).
     def empty(retries: 0, steps: [])
       marker = { retries: retries.to_i }
-      marker[:steps] = steps.map { |step| step.slice(:role, :content, :thinking) } unless steps.empty?
+      marker[:steps] = steps.map { |step| capped_step(step) } unless steps.empty?
       message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
         .merge(EMPTY_ANSWER => marker)
     end
 
+    def capped_step(step)
+      step.slice(:role, :content, :thinking).to_h do |key, value|
+        [key, key == :role || !value.is_a?(String) ? value : tail_of(value)]
+      end
+    end
+
+    # The last STEP_CHARS of +text+ after a line saying how much was cut
+    # (and the thinking's opening tag when it had one); short text as is.
+    def tail_of(text)
+      return text if text.length <= STEP_CHARS
+
+      open = THINK_OPENS.find { |tag| text.start_with?(tag) }
+      "#{open}[… #{text.length - STEP_CHARS} earlier characters cut]\n#{text[-STEP_CHARS..]}"
+    end
+
     # The empty-answer marker of +entry+ (either key type), or nil.
     def empty_answer(entry)
       return nil unless note?(entry)

data/lib/samagotchi/turn_state.rb

@@ -133,6 +133,12 @@ module Samagotchi
       true
     end
 
+    # @return [Boolean] whether #steer_next_turn queued anything a turn has
+    #   yet to begin with
+    def carried_steers?
+      @lock.synchronize { !@carried_steers.empty? }
+    end
+
     # Drop what #steer_next_turn queued and no turn began with (a no-op
     # once #begin! took it).
     # @return [Array<Hash>] the steers dropped ({text:, source:})