samagotchi 0.76.0 → 0.77.0

data/lib/samagotchi/relay_verifier.rb

@@ -70,9 +70,9 @@ module Samagotchi
     # of range; [] for a freeform-only deny.
     def labels(indices, question_id)
       pending = @engine.pending_question
-      return [] unless pending && pending[:id].to_s == question_id
+      return [] unless pending && pending.id.to_s == question_id
 
-      options = Array(pending[:options])
+      options = Array(pending.options)
       indices = Array(indices)
       return nil unless indices.all? { |index| index.is_a?(Integer) && index >= 0 && index < options.size }
 

data/lib/samagotchi/relay_watcher.rb

@@ -37,8 +37,8 @@ module Samagotchi
     end
 
     def relayed?(pending, question_id, relay_id)
-      relay = pending && pending[:relayed_to]
-      return false unless relay.is_a?(Hash) && pending[:id].to_s == question_id.to_s
+      relay = pending&.relayed_to
+      return false unless relay.is_a?(Hash) && pending.id.to_s == question_id.to_s
 
       (relay[:relay_id] || relay["relay_id"]).to_s == relay_id.to_s
     end

data/lib/samagotchi/reply_wait.rb

@@ -30,7 +30,7 @@ module Samagotchi
     # @!attribute text [String, nil] the reply (:done) or the worker's error
     #   (:error)
     # @!attribute file [String, nil] the reply's filename, the next cursor
-    # @!attribute question [Hash, nil] the pending question
+    # @!attribute question [PendingQuestion, nil] the pending question
     #   (:waiting_for_answer)
     # @!attribute outcome [String, nil] how the turn ended when it left no
     #   reply (:no_reply): "failed", "canceled", "completed" (empty),
@@ -152,7 +152,7 @@ module Samagotchi
         # lists' rule): one a dead worker left waits for no one, and a chi
         # REPL's is answered there.
         pending = session.pending_question
-        if pending && !(baseline && pending[:id] == baseline[:question_id]) &&
+        if pending && !(baseline && pending.id == baseline[:question_id]) &&
            (turn.nil? || own_question?(session, turn, claimed)) &&
            session.waiting_question(live: SessionManager.worker_live?(id, state_dir: state_dir))
           return Result.new(status: :waiting_for_answer, question: pending, session: session)
@@ -217,7 +217,7 @@ module Samagotchi
     # its messages, the question pending then, and when its last turn
     # ended, so a turn that ends before the first look still ends the wait.
     # @return [Hash]
-    def baseline_of(session, question_id: session.pending_question&.dig(:id))
+    def baseline_of(session, question_id: session.pending_question&.id)
       { messages: session.messages.size, question_id: question_id, last_turn: session.last_turn&.ended_at }
     end
 
@@ -252,7 +252,7 @@ module Samagotchi
       end
 
       pending = session.pending_question
-      return nil unless pending && pending[:kind].to_s == "continue"
+      return nil unless pending && pending.kind.to_s == "continue"
       return nil unless turn_ids?(session_dir)
 
       session.last_turn&.enqueued_id

data/lib/samagotchi/row_refs.rb

@@ -10,7 +10,7 @@ module Samagotchi
   # whose +to_h+ the row carries as +refs+ on tool_call_started and
   # tool_call_completed (ToolRowFields::EVENT_KEYS), saved with the result
   # as tool_refs (ToolResponse::SAVED_KEYS) for a reload, which has no
-  # plugins (Web::MessageParts). Display only: the model never sees them.
+  # plugins (MessageParts). Display only: the model never sees them.
   #
   # A file ref is any file under the session's folder (plan D7): a relative
   # path is resolved against it, a path outside it is dropped. The folder

data/lib/samagotchi/session.rb

@@ -8,6 +8,7 @@ require_relative "atomic_file"
 require_relative "context_note"
 require_relative "interrupted_turn"
 require_relative "last_turn"
+require_relative "pending_question"
 require_relative "llm_context_override"
 require_relative "session_setup"
 require_relative "prompt_note"
@@ -49,7 +50,7 @@ module Samagotchi
 
     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
+                  :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.
@@ -98,6 +99,15 @@ module Samagotchi
     # A `chi scratch` session: deleted when its REPL ends, and by the next
     # sweep (or `chi sessions clean`) when the process died first.
     attr_accessor :scratch
+    # The question this session waits on (PendingQuestion), saved as
+    # session.json's "pending_question"; nil with none. A Hash (a saved
+    # record, string or symbol keys) is read with PendingQuestion.from_file.
+    attr_reader :pending_question
+
+    def pending_question=(value)
+      @pending_question = PendingQuestion.from_file(value)
+    end
+
     # How the last turn ended (LastTurn), for a parent's wait (ReplyWait)
     # and the web's notifications (the hub sends it in the summary); nil
     # before the first turn.
@@ -246,7 +256,7 @@ module Samagotchi
       @last_prompt = last_prompt
       @first_preview = first_preview
       @test_run = !!test_run
-      @pending_question = pending_question
+      self.pending_question = pending_question
       @used_memory_names = self.class.name_list(used_memory_names)
       @preloaded_memory_names = self.class.name_list(preloaded_memory_names)
       @muted_memory_names = self.class.name_list(muted_memory_names)
@@ -289,12 +299,12 @@ module Samagotchi
     # @return [Hash, nil]
     def waiting_question(live:)
       pending = pending_question
-      return nil unless live && pending.is_a?(Hash) && pending[:id]
+      return nil unless live && pending&.id
 
-      kind = pending[:kind].to_s
-      relayed = pending[:relayed_to]
+      kind = pending.kind.to_s
+      relayed = pending.relayed_to
       relayed_to = relayed.is_a?(Hash) ? (relayed[:parent_short] || relayed["parent_short"]) : nil
-      { id: pending[:id], kind: %w[approval hook continue].include?(kind) ? kind : "question", relayed_to: relayed_to }.compact
+      { id: pending.id, kind: %w[approval hook continue].include?(kind) ? kind : "question", relayed_to: relayed_to }.compact
     end
 
     # A question saved by a process that no longer runs this session (the
@@ -306,7 +316,7 @@ module Samagotchi
       return nil unless pending
 
       @pending_question = nil
-      pending[:id].to_s
+      pending.id.to_s
     end
 
     # The stored project root, else (a file from before the field) the
@@ -390,10 +400,10 @@ module Samagotchi
 
     # The fields of <id>.json, in the order #save writes them: key => the
     # value for a file without it (REQUIRED for the ones it must have).
-    # .from_h and #to_h both go by this table; messages and
-    # pending_question change key type on the way (symbols in memory,
-    # strings on disk); last_turn and prompt_notes are value objects in
-    # memory (LastTurn, PromptNote).
+    # .from_h and #to_h both go by this table; messages change key type on
+    # the way (symbols in memory, strings on disk); last_turn, prompt_notes
+    # and pending_question are value objects in memory (LastTurn,
+    # PromptNote, PendingQuestion).
     FIELDS = {
       "metadata_version" => 1,
       "id" => REQUIRED,
@@ -435,8 +445,6 @@ module Samagotchi
         [key.to_sym, default.equal?(REQUIRED) ? data.fetch(key) : data.fetch(key, default)]
       end
       attrs[:messages] = messages ? Array(attrs[:messages]).map { |msg| symbolize_message_keys(msg) } : []
-      pending = attrs[:pending_question]
-      attrs[:pending_question] = pending.is_a?(Hash) ? symbolize_message_keys(pending) : nil
       new(**attrs)
     end
 
@@ -557,7 +565,7 @@ module Samagotchi
                 when "messages"
                   (checkpoint ? checkpoint[:messages] : @messages).map { |msg| scrub_utf8(stringify_message_keys(msg)) }
                 when "interrupted_turn" then (checkpoint ? checkpoint[:marker] : @interrupted_turn)&.to_file
-                when "pending_question" then @pending_question && scrub_utf8(stringify_message_keys(@pending_question))
+                when "pending_question" then @pending_question && scrub_utf8(@pending_question.to_file)
                 when "test_run" then !!@test_run
                 when "delegate" then @delegate
                 when "llm_context" then llm_context_file

data/lib/samagotchi/session_commands.rb

@@ -592,8 +592,11 @@ module Samagotchi
       @engine.switch_model!(name, persist_default: persist_default)
       @default_model = @engine.default_model_name if persist_default
       persist_session_model
-      # The ctx % on the new model's window, before its first turn.
+      # The ctx % on the new model's window, before its first turn; saved
+      # too, so the session's card (the hub's summary reads analytics.json)
+      # stops showing the old model's % before a turn ends.
       @engine.announce_switched_context!
+      @engine.metrics.persist(state_dir: @engine.session_state_dir)
     end
 
     def persist_session_model

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -88,9 +88,10 @@ module Samagotchi
       # A question left waiting (exit 3), in full on stderr as `chi send
       # --wait` prints it (ParentReport), so a script or a parent agent
       # can answer it with chi answer.
-      # @param pending [Hash] the pending question (symbol keys)
+      # @param pending [Hash] the pending question as the Bridge sent it
       def report_unanswered(pending, session_id:, err: $stderr)
-        err.print("chi: #{ParentReport.question_text(pending, session_id: session_id)}")
+        question = PendingQuestion.from_file(pending)
+        err.print("chi: #{ParentReport.question_text(question, session_id: session_id)}")
         err.flush
       end
 

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -28,7 +28,7 @@ require_relative "../children_status"
 require_relative "../guardrails/parent_approvals"
 require_relative "../tool_activity"
 require_relative "../tool_view"
-require_relative "../web/message_parts"
+require_relative "../message_parts"
 
 module Samagotchi
   class TerminalUI
@@ -1274,7 +1274,7 @@ module Samagotchi
             @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
           elsif %w[model assistant].include?(m[:role].to_s)
             responses = messages.drop(i + 1).take_while { |r| r[:role].to_s == "tool_response" }
-            Array(Web::MessageParts.for_message(m, responses)&.dig(:tools)).each do |part|
+            Array(MessageParts.for_message(m, responses)&.dig(:tools)).each do |part|
               record = join_record(records, part)
               duration = record&.dig("duration_ms")
               @screen.commit(join_tool_line(part, duration_ms: duration.is_a?(Numeric) ? duration : nil,

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -9,6 +9,7 @@ require_relative "../steer_cut"
 require_relative "../memory_bundle/index_size"
 require_relative "../prompt_note"
 require_relative "../prompt_files"
+require_relative "model_segments_text"
 
 module Samagotchi
   class TerminalUI
@@ -16,6 +17,8 @@ module Samagotchi
     # `tool>` line, elapsed durations. Pure apart from reading whether
     # $stdout is a colour terminal.
     module Formatting
+      include ModelSegmentsText
+
       # The /stats text for a metrics snapshot, for the REPL and attached
       # views (an instance includes the module) and for `chi sessions stats`
       # (no UI: the same text from the CLI).
@@ -451,45 +454,6 @@ module Samagotchi
         "#{reported.empty? ? estimate : "#{reported} reported + #{estimate}"} (this session only)"
       end
 
-      # ── A session's rows per model (the snapshot's model_segments) ──────
-      # The words the web's ctx tooltip shares (ctx.js; spec/shared/
-      # labels_matrix.json model_segments). Rows come symbol- or
-      # string-keyed (the attached TUI's as JSON).
-
-      # A row's model: its ref; the rows folded past the cap ("3 earlier
-      # segments", told by folded_segments); a session's turns from before
-      # turns named their model ("earlier turns").
-      def model_segment_label(row)
-        folded = segment_value(row, :folded_segments).to_i
-        return "#{folded} earlier segments" if folded.positive?
-
-        ref = segment_value(row, :model_ref).to_s
-        ref.empty? ? "earlier turns" : ref
-      end
-
-      # "6.0k in / 40 out": the row's prompt and completion sums.
-      def model_segment_tokens_text(row)
-        count = ->(key) { MemoryBundle::IndexSize.count_text(segment_value(row, key).to_i) }
-        "#{count.call(:prompt_sum)} in / #{count.call(:completion_sum)} out"
-      end
-
-      # "$0.42", "~$0.12", "$0.42 + ~$0.12" (reported + estimated); "" for none.
-      def model_segment_cost_text(row)
-        [cost_text(segment_value(row, :cost_sum)), cost_text(segment_value(row, :cost_estimate_sum), estimate: true)]
-          .reject(&:empty?).join(" + ")
-      end
-
-      # "switch prefill 3.0k uncached prompt ≈$0.0060": what the switch to the
-      # row's model prefilled (its cost an estimate from the configured
-      # price, left out without one); "" for none.
-      def model_segment_prefill_text(row)
-        tokens = segment_value(row, :prefill_tokens).to_i
-        return "" unless tokens.positive?
-
-        cost = cost_text(segment_value(row, :prefill_cost_estimate))
-        "switch prefill #{MemoryBundle::IndexSize.count_text(tokens)} uncached prompt#{" ≈#{cost}" unless cost.empty?}"
-      end
-
       private
 
       # The recap shown on return: dim, one "recap>" block, noting how many
@@ -745,73 +709,6 @@ module Samagotchi
         text
       end
 
-      def segment_value(row, key)
-        row[key] || row[key.to_s]
-      end
-
-      # /stats' models: block, in place of the tokens line: a row per
-      # segment (model, when, turns, tokens, its average speed and cost), a
-      # switch's prefill under the row of the model switched to, and the
-      # total (the tokens line's sums and breakdown).
-      def models_block_lines(segments, turns, tokens, token_src_label)
-        dated = segment_dates_differ?(segments)
-        cells = segments.map do |row|
-          speed = speed_text(segment_value(row, :avg_decode_tps), segment_value(row, :tps_source))
-          [model_segment_label(row), segment_span_text(row, dated: dated), turns_text(segment_value(row, :turns)),
-           [model_segment_tokens_text(row), speed, model_segment_cost_text(row)].reject(&:empty?).join("  ")]
-        end
-        total = ["total", "", turns_text(turns),
-                 "#{MemoryBundle::IndexSize.count_text(tokens[:prompt_sum].to_i)} in / " \
-                 "#{MemoryBundle::IndexSize.count_text(tokens[:completion_sum].to_i)} out " \
-                 "(all requests, #{token_src_label}#{token_breakdown_text(tokens)})"]
-        widths = (0..2).map { |i| (cells + [total]).map { |cell| cell[i].length }.max }
-        row_text = ->(cell) { cell.each_with_index.map { |text, i| i < 3 ? text.ljust(widths[i]) : text }.join("  ") }
-        lines = []
-        segments.each_with_index do |row, i|
-          lines << "#{i.zero? ? "models:".ljust(18) : " " * 18}#{row_text.call(cells[i])}"
-          prefill = model_segment_prefill_text(row)
-          lines << "#{" " * 20}└ #{prefill}" unless prefill.empty?
-        end
-        lines << "#{" " * 18}#{row_text.call(total)}"
-      end
-
-      def turns_text(count)
-        "#{count.to_i} #{count.to_i == 1 ? "turn" : "turns"}"
-      end
-
-      # "10:02–10:41", "10:43–now" (a row with a turn running); with the
-      # day ("Oct 16 10:02") when the rows span more than one day.
-      def segment_span_text(row, dated:)
-        started = segment_time(segment_value(row, :started_at))
-        ended = segment_time(segment_value(row, :ended_at))
-        format_time = lambda { |time|
-          if time
-            time.strftime(dated ? "%b %-d %H:%M" : "%H:%M")
-          else
-            "?"
-          end
-        }
-        "#{format_time.call(started)}–#{ended ? format_time.call(ended) : "now"}"
-      end
-
-      def segment_dates_differ?(segments)
-        days = segments.flat_map { |row| [segment_value(row, :started_at), segment_value(row, :ended_at)] }
-                       .filter_map { |stamp| segment_time(stamp)&.strftime("%F") }
-        days.uniq.size > 1
-      end
-
-      def segment_time(stamp)
-        stamp ? Time.iso8601(stamp.to_s).localtime : nil
-      rescue ArgumentError
-        nil
-      end
-
-      # The row the session's last speed came from: the newest with one.
-      def last_speed_label(segments)
-        row = segments.reverse_each.find { |segment| segment_value(segment, :last_decode_tps) }
-        row && model_segment_label(row)
-      end
-
       def format_elapsed_duration(duration_ms)
         duration_ms = duration_ms.to_f
         return "" if duration_ms.negative?

data/lib/samagotchi/terminal_ui/model_segments_text.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../memory_bundle/index_size"
+
+module Samagotchi
+  class TerminalUI
+    # A session's rows per model in /stats (the snapshot's model_segments).
+    # The four public model_segment_* labels are the words the web's ctx
+    # tooltip shares (ctx.js; spec/shared/labels_matrix.json model_segments).
+    # Rows come symbol- or string-keyed (the attached TUI's as JSON).
+    # Included by Formatting, whose cost_text and speed_text it uses.
+    module ModelSegmentsText
+      # A row's model: its ref; the rows folded past the cap ("3 earlier
+      # segments", told by folded_segments); a session's turns from before
+      # turns named their model ("earlier turns").
+      def model_segment_label(row)
+        folded = segment_value(row, :folded_segments).to_i
+        return "#{folded} earlier segments" if folded.positive?
+
+        ref = segment_value(row, :model_ref).to_s
+        ref.empty? ? "earlier turns" : ref
+      end
+
+      # "6.0k in / 40 out": the row's prompt and completion sums.
+      def model_segment_tokens_text(row)
+        count = ->(key) { MemoryBundle::IndexSize.count_text(segment_value(row, key).to_i) }
+        "#{count.call(:prompt_sum)} in / #{count.call(:completion_sum)} out"
+      end
+
+      # "$0.42", "~$0.12", "$0.42 + ~$0.12" (reported + estimated); "" for none.
+      def model_segment_cost_text(row)
+        [cost_text(segment_value(row, :cost_sum)), cost_text(segment_value(row, :cost_estimate_sum), estimate: true)]
+          .reject(&:empty?).join(" + ")
+      end
+
+      # "switch prefill 3.0k uncached prompt ≈$0.0060": what the switch to the
+      # row's model prefilled (its cost an estimate from the configured
+      # price, left out without one); "" for none.
+      def model_segment_prefill_text(row)
+        tokens = segment_value(row, :prefill_tokens).to_i
+        return "" unless tokens.positive?
+
+        cost = cost_text(segment_value(row, :prefill_cost_estimate))
+        "switch prefill #{MemoryBundle::IndexSize.count_text(tokens)} uncached prompt#{" ≈#{cost}" unless cost.empty?}"
+      end
+
+      private
+
+      def segment_value(row, key)
+        row[key] || row[key.to_s]
+      end
+
+      # /stats' models: block, in place of the tokens line: a row per
+      # segment (model, when, turns, tokens, its average speed and cost), a
+      # switch's prefill under the row of the model switched to, and the
+      # total (the tokens line's sums and breakdown).
+      def models_block_lines(segments, turns, tokens, token_src_label)
+        dated = segment_dates_differ?(segments)
+        cells = segments.map do |row|
+          speed = speed_text(segment_value(row, :avg_decode_tps), segment_value(row, :tps_source))
+          [model_segment_label(row), segment_span_text(row, dated: dated), turns_text(segment_value(row, :turns)),
+           [model_segment_tokens_text(row), speed, model_segment_cost_text(row)].reject(&:empty?).join("  ")]
+        end
+        total = ["total", "", turns_text(turns),
+                 "#{MemoryBundle::IndexSize.count_text(tokens[:prompt_sum].to_i)} in / " \
+                 "#{MemoryBundle::IndexSize.count_text(tokens[:completion_sum].to_i)} out " \
+                 "(all requests, #{token_src_label}#{token_breakdown_text(tokens)})"]
+        widths = (0..2).map { |i| (cells + [total]).map { |cell| cell[i].length }.max }
+        row_text = ->(cell) { cell.each_with_index.map { |text, i| i < 3 ? text.ljust(widths[i]) : text }.join("  ") }
+        lines = []
+        segments.each_with_index do |row, i|
+          lines << "#{i.zero? ? "models:".ljust(18) : " " * 18}#{row_text.call(cells[i])}"
+          prefill = model_segment_prefill_text(row)
+          lines << "#{" " * 20}└ #{prefill}" unless prefill.empty?
+        end
+        lines << "#{" " * 18}#{row_text.call(total)}"
+      end
+
+      def turns_text(count)
+        "#{count.to_i} #{count.to_i == 1 ? "turn" : "turns"}"
+      end
+
+      # "10:02–10:41", "10:43–now" (a row with a turn running); with the
+      # day ("Oct 16 10:02") when the rows span more than one day.
+      def segment_span_text(row, dated:)
+        started = segment_time(segment_value(row, :started_at))
+        ended = segment_time(segment_value(row, :ended_at))
+        format_time = lambda { |time|
+          if time
+            time.strftime(dated ? "%b %-d %H:%M" : "%H:%M")
+          else
+            "?"
+          end
+        }
+        "#{format_time.call(started)}–#{ended ? format_time.call(ended) : "now"}"
+      end
+
+      def segment_dates_differ?(segments)
+        days = segments.flat_map { |row| [segment_value(row, :started_at), segment_value(row, :ended_at)] }
+                       .filter_map { |stamp| segment_time(stamp)&.strftime("%F") }
+        days.uniq.size > 1
+      end
+
+      def segment_time(stamp)
+        stamp ? Time.iso8601(stamp.to_s).localtime : nil
+      rescue ArgumentError
+        nil
+      end
+
+      # The row the session's last speed came from: the newest with one.
+      def last_speed_label(segments)
+        row = segments.reverse_each.find { |segment| segment_value(segment, :last_decode_tps) }
+        row && model_segment_label(row)
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui.rb

@@ -873,6 +873,7 @@ module Samagotchi
                   end
         if command
           show_command_result(command)
+          refresh_status_row(clear_unknown_context: true) if command.changed.include?(:model)
           persist_recent_history(input) if command.shell
           return
         end
@@ -1400,9 +1401,10 @@ 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
+    def refresh_status_row(clear_unknown_context: false)
       state = @engine.session_state_snapshot.merge(model_name: @effective_model_name)
       @status_row.take_state(state, default_model: @default_model_name)
+      @status_row.update(context: nil) if clear_unknown_context && state.key?(:context_status) && state[:context_status].nil?
       refresh_children_status
     end
 
@@ -1463,13 +1465,13 @@ module Samagotchi
     def drain_pending_question?
       pq = @pending_question_event
       # Also check Engine's persisted pending (covers resume)
-      pq ||= @engine.pending_question
+      pq ||= @engine.pending_question&.to_h
       return false unless pq
 
       # If the pending no longer matches the engine's current pending (stale
       # event after sync handler already answered and cleared), discard.
       current = @engine.pending_question
-      if current && (pq[:id] || pq["id"]).to_s != (current[:id] || current["id"]).to_s
+      if current && (pq[:id] || pq["id"]).to_s != current.id.to_s
         @pending_question_event = nil
         return false
       end

data/lib/samagotchi/tool_output_cut.rb

@@ -38,7 +38,7 @@ module Samagotchi
     HEAD_CUT = /\[cut: \d+ of \d+ chars; read it in parts\]\z/
 
     # What a web row keeps of a tool's output, on a reload
-    # (Web::MessageParts) and a mid-turn join (Bridge::TurnAccumulator): the
+    # (MessageParts) and a mid-turn join (Bridge::TurnAccumulator): the
     # row shows 300 chars and the rest on hover. A longer one keeps its head
     # and tail (preview).
     WEB_PREVIEW_CHARS = 2000

data/lib/samagotchi/tool_response.rb

@@ -29,7 +29,7 @@ module Samagotchi
     # Runs +calls+ in order (ToolRunner#run each), yielding each run and its
     # index as it finishes. +emit+ takes the dispatch events, the runner's
     # own go to +on_stream_event+.
-    # @return [Array<Hash>] the runs
+    # @return [Array<ToolRun>] the runs
     def run_batch(runner, calls, iteration:, emit:, on_stream_event:, cap:)
       emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
       runs = calls.each_with_index.map do |call, index|
@@ -45,7 +45,7 @@ module Samagotchi
     # The runs' activity, for the turn's tool list (none for a call whose
     # dispatcher raised).
     def activities(runs)
-      runs.filter_map { |run| run[:activity] }
+      runs.filter_map(&:activity)
     end
 
     # The native loop's entry for a batch: the capped outputs joined, every image
@@ -53,14 +53,14 @@ module Samagotchi
     # each on its own tool row), and the saved-only fields one per call:
     # +ids+ (ToolIds.next_ids) as tool_ids.
     def joined(runs, ids:)
-      images = runs.flat_map { |run| Array(run[:images]) }
-      entry = { role: "tool_response", content: runs.map { |run| run[:capped_output] }.join(SEPARATOR) }
+      images = runs.flat_map { |run| Array(run.images) }
+      entry = { role: "tool_response", content: runs.map(&:capped_output).join(SEPARATOR) }
       unless images.empty?
         entry[:images] = images
-        entry[:image_counts] = runs.map { |run| Array(run[:images]).size }
+        entry[:image_counts] = runs.map { |run| Array(run.images).size }
       end
-      saved = { tool_params: runs.map { |run| run[:shown_params] }, tool_labels: runs.map { |run| run[:shown_label] },
-                tool_diffs: runs.map { |run| run[:diff] }, tool_refs: runs.map { |run| run[:refs] } }
+      saved = { tool_params: runs.map(&:shown_params), tool_labels: runs.map(&:shown_label),
+                tool_diffs: runs.map(&:diff), tool_refs: runs.map(&:refs) }
       saved.each { |key, values| entry[key] = values if values.any? }
       entry[:tool_ids] = ids
       entry
@@ -70,12 +70,12 @@ module Samagotchi
     # call by +tool_call_id+, and its chi-owned id (a one-id +ids+, as
     # #joined's tool_ids).
     def single(run, tool_call_id:, ids:)
-      entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call_id }
-      entry[:images] = run[:images] if run[:images]&.any?
-      entry[:tool_params] = run[:shown_params] if run[:shown_params]
-      entry[:tool_labels] = run[:shown_label] if run[:shown_label]
-      entry[:tool_diffs] = run[:diff] if run[:diff]
-      entry[:tool_refs] = run[:refs] if run[:refs]
+      entry = { role: "tool_response", content: run.capped_output, tool_call_id: tool_call_id }
+      entry[:images] = run.images if run.images&.any?
+      entry[:tool_params] = run.shown_params if run.shown_params
+      entry[:tool_labels] = run.shown_label if run.shown_label
+      entry[:tool_diffs] = run.diff if run.diff
+      entry[:tool_refs] = run.refs if run.refs
       entry[:tool_ids] = ids
       entry
     end

data/lib/samagotchi/tool_row_fields.rb

@@ -7,7 +7,7 @@ require_relative "file_ref"
 module Samagotchi
   # The fields a tool row shows beyond its params, built from the call in
   # one place for every path: the live tool_call_started (ToolRunner#run)
-  # and a reload from the saved call (Web::MessageParts#tool_part). The
+  # and a reload from the saved call (MessageParts#tool_part). The
   # bridge's snapshot and replay (Bridge::TurnAccumulator) copy them by
   # these lists, so a new field is added here and travels everywhere.
   #

data/lib/samagotchi/tool_runner.rb

@@ -15,6 +15,17 @@ require_relative "memory_bundle/index_sync"
 require_relative "memory_bundle/index_size"
 
 module Samagotchi
+  # One call's result from ToolRunner#run, read by ToolResponse (the loops'
+  # tool_response entries) and the loops' activity list. Fields a call didn't
+  # produce (images, shown_params, shown_label, refs, diff, output_file) are nil.
+  ToolRun = Data.define(:output, :capped_output, :truncated, :activity, :images, :shown_params, :shown_label, :refs, :diff,
+                        :output_file) do
+    def initialize(output: nil, capped_output: nil, truncated: nil, activity: nil, images: nil, shown_params: nil,
+                   shown_label: nil, refs: nil, diff: nil, output_file: nil)
+      super
+    end
+  end
+
   # The single per-call path both loops use: the tool_call_started and
   # tool_call_completed events, the guardrail gate (before_tool_call hooks
   # and their veto), dispatch through KernelLoop, the after_tool_call hook
@@ -40,7 +51,7 @@ module Samagotchi
     end
 
     # @param call_index [Integer] 1-based position of the call in its batch
-    # @return [Hash] output:, capped_output:, truncated:, activity:,
+    # @return [ToolRun] output:, capped_output:, truncated:, activity:,
     #   output_file: (the saved whole output of a cut execute result),
     #   images: (refs) when the tool returned images the model gets to see, and
     #   shown_params: the params line the live row showed, and shown_label:
@@ -135,14 +146,10 @@ module Samagotchi
       fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
                                status: status || "error", call: call.dup, elapsed_ms: elapsed_ms, result: tool_text })
 
-      run = { output: output, capped_output: capped, truncated: truncated, activity: result[:activity] }
-      run[:images] = images if images&.any?
-      run[:shown_params] = params if params && plugin_tool?(call[:name])
-      run[:shown_label] = label if label
-      run[:refs] = refs unless refs.empty?
-      run[:diff] = diff if diff
-      run[:output_file] = output_file if output_file
-      run
+      ToolRun.new(output: output, capped_output: capped, truncated: truncated, activity: result[:activity],
+                  images: images&.any? ? images : nil,
+                  shown_params: params && plugin_tool?(call[:name]) ? params : nil,
+                  shown_label: label, refs: refs.empty? ? nil : refs, diff: diff, output_file: output_file)
     end
 
     private