samagotchi 0.76.0 → 0.78.0

data/lib/samagotchi/relay.rb

@@ -18,29 +18,28 @@ module Samagotchi
     module_function
 
     # @param child [Session] the child as loaded (its id, its first prompt)
-    # @param pending [Hash] the child's pending question (string keys inside
-    #   when it came from a saved session)
+    # @param pending [PendingQuestion] the child's pending question (string
+    #   keys inside its approval and relay when it came from a saved session)
     # @param relay_id [String] RelayDesk's id
     # @param more [Integer] other delegates' approvals waiting behind this one
     # @return [Hash] Engine#open_question fields
     def card(child, pending, relay_id:, more: 0)
-      pending = deep_symbolize(pending)
-      facts = pending[:approval].is_a?(Hash) ? pending[:approval] : {}
+      facts = pending.approval.is_a?(Hash) ? deep_symbolize(pending.approval) : {}
       short = child.id.to_s[0, 8]
-      inner = pending[:relay].is_a?(Hash) ? pending[:relay] : nil
+      inner = pending.relay.is_a?(Hash) ? deep_symbolize(pending.relay) : nil
       chain = inner ? [*Array(inner[:chain]), short] : [short]
-      asked = inner ? inner[:asked].to_s : pending[:question].to_s
+      asked = inner ? inner[:asked].to_s : pending.question.to_s
       task = inner ? inner[:task].to_s : task_of(child)
       who = chain.reverse.join(" → ")
       {
         question: question_text(who, task, asked),
-        options: relabel(Array(pending[:options]), facts[:scopes], who),
+        options: relabel(Array(pending.options), facts[:scopes], who),
         header: header(who, more),
         multi_select: false,
-        allow_freeform: pending.key?(:allow_freeform) ? !!pending[:allow_freeform] : true,
+        allow_freeform: pending.allow_freeform.nil? || !!pending.allow_freeform,
         kind: Guardrails::Approval::KIND,
         approval: facts,
-        relay: { id: relay_id, child_id: child.id, child_short: short, child_question_id: pending[:id].to_s,
+        relay: { id: relay_id, child_id: child.id, child_short: short, child_question_id: pending.id.to_s,
                  task: task, chain: chain, asked: asked, more: more.to_i }
       }
     end

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

@@ -6,9 +6,8 @@ require_relative "session_inbox"
 require_relative "worker_sidecar"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools that use this (a require cycle
-  # otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
   # Waiting for a session's next reply. A reply is the worker's
@@ -30,7 +29,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 +151,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 +216,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 +251,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/session_manager.rb

@@ -37,7 +37,6 @@ require_relative "plugin_session_state"
 require_relative "context_sources"
 require_relative "session_chain"
 require_relative "child_move"
-require_relative "terminal_ui"
 
 module Samagotchi
   # SessionManager coordinates background session processes.

data/lib/samagotchi/session_metrics/totals.rb

@@ -8,7 +8,7 @@ module Samagotchi
     # mid-turn. The tool tallies (by tool, aliased, errors) are counted per
     # tool record, not per turn: SessionMetrics keeps those apart.
     class Totals < Data.define(
-      :cancellations, :iterations, :gen_ms, :retries, :cuts, :capped,
+      :cancellations, :iterations, :gen_ms, :retries, :cuts, :capped, :thinking_dropped,
       :prompt_sum, :completion_sum, :cached_sum, :cache_write_sum, :reprefill_sum, :reasoning_sum,
       :cost_sum, :cost_estimate_sum, :decode_ms_sum, :decode_tokens_sum,
       # The newest speeds a record has, and where the decode one came from.
@@ -19,7 +19,8 @@ module Samagotchi
       # The record keys each sum adds up (a turn record's own names).
       RECORD_SUMS = {
         prompt_sum: :prompt_tokens_sum, completion_sum: :completion_tokens, iterations: :iterations,
-        gen_ms: :gen_ms, retries: :retries, cuts: :cuts, capped: :capped, cached_sum: :cached_tokens_sum,
+        gen_ms: :gen_ms, retries: :retries, cuts: :cuts, capped: :capped, thinking_dropped: :thinking_dropped,
+        cached_sum: :cached_tokens_sum,
         cache_write_sum: :cache_write_tokens_sum, reprefill_sum: :reprefill_tokens_sum,
         reasoning_sum: :reasoning_tokens, cost_sum: :cost, cost_estimate_sum: :cost_estimate,
         decode_ms_sum: :decode_ms, decode_tokens_sum: :decode_tokens
@@ -28,7 +29,7 @@ module Samagotchi
       # The running turn's (TurnState) counters each sum adds while it runs.
       TURN_SUMS = {
         iterations: :iteration_count, gen_ms: :gen_latency_accum, retries: :retries, cuts: :cuts,
-        capped: :capped, prompt_sum: :prompt_sum, completion_sum: :completion_sum, cached_sum: :cached_sum,
+        capped: :capped, thinking_dropped: :thinking_dropped, prompt_sum: :prompt_sum, completion_sum: :completion_sum, cached_sum: :cached_sum,
         cache_write_sum: :cache_write_sum, reprefill_sum: :reprefill_sum, reasoning_sum: :reasoning_sum,
         cost_sum: :cost_sum, cost_estimate_sum: :cost_estimate_sum, decode_ms_sum: :decode_ms_sum,
         decode_tokens_sum: :decode_tokens_sum

data/lib/samagotchi/session_metrics.rb

@@ -144,6 +144,9 @@ module Samagotchi
       # (finish_reason length). `retries` counts the network's only.
       :cuts,
       :capped,
+      # Replayed thinking blocks a preserved-thinking recovery dropped
+      # (:generation_completed's thinking_dropped, ChatLoop).
+      :thinking_dropped,
       :model,
       # The model the turn ran on (asked host:model, :generation_started's
       # model_ref; the first generation's), and whether its open generation
@@ -505,6 +508,7 @@ module Samagotchi
         retries: totals.retries,
         cuts: totals.cuts,
         capped: totals.capped,
+        thinking_dropped: totals.thinking_dropped,
         started_at: @started_at,
         last_activity_at: @last_activity_at,
         # From the session's first start (an earlier process's too), to now.
@@ -589,6 +593,7 @@ module Samagotchi
           retries: 0,
           cuts: 0,
           capped: 0,
+          thinking_dropped: 0,
           model: nil,
           model_ref: nil,
           gen_switch: false,
@@ -679,12 +684,15 @@ module Samagotchi
       end
     end
 
+    # A generation's cut, output cap and dropped thinking blocks, into the turn.
     def count_cut(event)
       @mutex.synchronize do
         next unless @turn
 
         @turn.cuts += 1 if event[:stopped_by] && event[:stopped_by].to_s != "steer"
         @turn.capped += 1 if event[:finish_reason].to_s == "length"
+        dropped = event[:thinking_dropped]
+        @turn.thinking_dropped += dropped if dropped.is_a?(Integer) && dropped.positive?
       end
     end
 
@@ -872,6 +880,7 @@ module Samagotchi
       }
       fields[:cache_write_tokens_sum] = turn.cache_write_sum if turn.cache_write_sum.positive?
       fields[:reprefill_tokens_sum] = turn.reprefill_sum if turn.reprefill_sum.positive?
+      fields[:thinking_dropped] = turn.thinking_dropped if turn.thinking_dropped.positive?
       fields.merge!(cost: turn.cost_sum, cost_source: "reported") if turn.cost_sum
       fields[:cost_estimate] = turn.cost_estimate_sum if turn.cost_estimate_sum.positive?
       fields[:switch_prefill_tokens] = turn.switch_prefill_tokens if turn.switch_prefill_tokens

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
@@ -636,6 +600,9 @@ module Samagotchi
         # 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}"
+        # Claude 5.x: replayed thinking a prefix change made the API drop.
+        dropped = snapshot[:thinking_dropped].to_i
+        lines << "thinking dropped: #{dropped} blocks (preserved-thinking recovery)" if dropped.positive?
         context = snapshot[:context] || {}
         if context[:used_tokens]
           pct = context_pct_text(context, snapshot[:llm_context])
@@ -745,73 +712,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