samagotchi 0.75.0 → 0.76.0

data/lib/samagotchi/session_metrics/totals.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class SessionMetrics
+    # The sums over a session's finished turn records, kept as running
+    # counters (#add folds one record in) and read with the running turn's
+    # finished generations folded in (#with_running), so /stats agrees
+    # 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,
+      :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.
+      :last_decode_tps, :last_prefill_tps, :tps_source,
+      # The kinds of counts (server / estimate / mixed) the records came from.
+      :token_sources
+    )
+      # 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,
+        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
+      }.freeze
+
+      # 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,
+        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
+      }.freeze
+
+      def self.zero
+        new(cancellations: 0, **RECORD_SUMS.keys.to_h { |key| [key, 0] }, last_decode_tps: nil,
+            last_prefill_tps: nil, tps_source: nil, token_sources: [].freeze)
+      end
+
+      # These totals with one finished turn record (symbol keys, as saved;
+      # an older record lacks some counts) counted in.
+      # @param record [Hash]
+      # @return [Totals]
+      def add(record)
+        sums = RECORD_SUMS.to_h { |sum, key| [sum, public_send(sum) + number(record[key])] }
+        sums[:cancellations] = cancellations + 1 if record[:status] == "canceled"
+        # The newest speeds a record has (an older record has none).
+        if record[:decode_tps].is_a?(Numeric)
+          sums[:last_decode_tps] = record[:decode_tps]
+          sums[:tps_source] = record[:tps_source]
+        end
+        sums[:last_prefill_tps] = record[:prefill_tps] if record[:prefill_tps].is_a?(Numeric)
+        source = record[:token_source]
+        sums[:token_sources] = (token_sources | [source.to_s]).freeze unless source.nil?
+        with(**sums)
+      end
+
+      # These totals with a later segment's counts and newest speeds.
+      # @param later [Totals]
+      # @return [Totals]
+      def merge(later)
+        sums = RECORD_SUMS.keys.to_h { |key| [key, public_send(key) + later.public_send(key)] }
+        with(**sums, cancellations: cancellations + later.cancellations,
+                     token_sources: (token_sources | later.token_sources).freeze,
+                     last_decode_tps: later.last_decode_tps || last_decode_tps,
+                     tps_source: later.last_decode_tps ? later.tps_source : tps_source,
+                     last_prefill_tps: later.last_prefill_tps || last_prefill_tps)
+      end
+
+      # These totals with the running turn's counters so far (its finished
+      # generations, calls and iterations) added; the last speeds are the
+      # newest a generation reported. nil: these totals.
+      # @param turn [TurnState, nil]
+      # @return [Totals]
+      def with_running(turn)
+        return self unless turn
+
+        sums = TURN_SUMS.to_h { |sum, key| [sum, public_send(sum) + (turn.public_send(key) || 0)] }
+        if turn.last_decode_tps
+          sums[:last_decode_tps] = turn.last_decode_tps
+          sums[:tps_source] = turn.tps_source
+        end
+        sums[:last_prefill_tps] = turn.last_prefill_tps if turn.last_prefill_tps
+        sums[:token_sources] = (token_sources + turn.token_sources).freeze
+        with(**sums)
+      end
+
+      # The snapshot's tokens block.
+      # @return [Hash]
+      def tokens_block
+        {
+          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.round,
+          decode_tokens_sum: decode_tokens_sum,
+          avg_decode_tps: decode_ms_sum.positive? ? (decode_tokens_sum * 1000.0 / decode_ms_sum).round(1) : nil,
+          last_decode_tps: last_decode_tps,
+          last_prefill_tps: last_prefill_tps,
+          tps_source: tps_source,
+          source: combined_source
+        }
+      end
+
+      private
+
+      def number(value)
+        value.is_a?(Numeric) ? value : 0
+      end
+
+      # server, estimate, or mixed when both kinds of counts (or a turn that
+      # was already mixed) are in; nil before any.
+      def combined_source
+        kinds = token_sources.compact.map(&:to_s)
+                             .flat_map { |source| source == "mixed" ? %w[server estimate] : [source] }.uniq
+        kinds.size > 1 ? "mixed" : kinds.first
+      end
+    end
+  end
+end

data/lib/samagotchi/session_metrics.rb

@@ -10,6 +10,8 @@ require_relative "atomic_file"
 require_relative "token_usage"
 require_relative "model_price"
 require_relative "session"
+require_relative "session_metrics/totals"
+require_relative "session_metrics/model_segment"
 
 module Samagotchi
   # SessionMetrics is a persistent, error-isolated collector of per-session
@@ -54,8 +56,9 @@ module Samagotchi
     GenerationSpeed = Data.define(:decode_tps, :source)
 
     # What #finish_generation reports: the generation's speed (nil when it
-    # had none) and the session's tokens block as the snapshot has it.
-    GenerationReport = Data.define(:speed, :tokens)
+    # had none), the session's tokens block and its per-model rows
+    # (model_segments) as the snapshot has them.
+    GenerationReport = Data.define(:speed, :tokens, :model_segments)
 
     # memory_index: the memory indexes the session's prompt held
     # ({ system: { tokens:, lines: }, project: … }, string keys as saved),
@@ -142,6 +145,13 @@ module Samagotchi
       :cuts,
       :capped,
       :model,
+      # The model the turn ran on (asked host:model, :generation_started's
+      # model_ref; the first generation's), and whether its open generation
+      # is the first after a /model switch (its prefill is recorded).
+      :model_ref,
+      :gen_switch,
+      :switch_prefill_tokens,
+      :switch_prefill_cost_estimate,
       # A turn with no prompt of its own (:turn_started's +continue+): a
       # step-limit Continue, a reminder's or a wake's turn; its record
       # carries it.
@@ -280,6 +290,22 @@ module Samagotchi
       end
     end
 
+    # The model ref the last turn that named one ran on (a loaded session's
+    # too), nil before any: Engine#session= compares it with the effective
+    # model's.
+    # @return [String, nil]
+    def last_model_ref = @mutex.synchronize { @last_model_ref }
+
+    # /model's new window (Engine#announce_switched_context!), until the
+    # new model's first generation reports one: what the snapshot's context
+    # (a page's ctx % on load) counts against.
+    def note_context_window(tokens, source)
+      @mutex.synchronize do
+        @context_window_tokens = tokens
+        @context_window_source = source
+      end
+    end
+
     # The memory indexes the session's prompt holds (SystemPrompt#memory_index:
     # { system: { tokens:, lines: }, project: … }), set by the Engine when
     # it builds the prompt it sends; the snapshot and analytics.json carry it.
@@ -344,6 +370,7 @@ module Samagotchi
             reset_generation_tokens
             @turn.gen_price = generation_price(event[:price])
             @turn.gen_open = true
+            note_model_ref(event[:model_ref])
           end
         end
       when :generation_completed, :generation_cancelled
@@ -401,7 +428,8 @@ module Samagotchi
     def finish_generation
       @mutex.synchronize do
         speed = close_generation if @turn&.gen_open
-        GenerationReport.new(speed: speed, tokens: tokens_block(@totals, @turn))
+        GenerationReport.new(speed: speed, tokens: @totals.with_running(@turn).tokens_block,
+                             model_segments: ModelSegment.rows(segments_with_running(@turn)))
       end
     end
 
@@ -449,14 +477,17 @@ module Samagotchi
     # Caller holds the mutex. +records+: :recent (the live snapshot) or :all
     # (analytics.json).
     def build_snapshot(records_mode)
-      totals = @totals
       turn = @turn
+      totals = @totals.with_running(turn)
       in_flight = turn ? turn.tool_calls_by_id.values : []
       {
         session_id: @session_id,
         turns: @turn_records.size + (turn ? 1 : 0),
-        cancellations: totals[:cancellations],
-        tokens: tokens_block(totals, turn),
+        cancellations: totals.cancellations,
+        tokens: totals.tokens_block,
+        # The tokens, cost and speeds per model, in order (ModelSegment.rows:
+        # none with one model); they add up to +tokens+.
+        model_segments: ModelSegment.rows(segments_with_running(turn)),
         context: context_block(@turn_records),
         memory_index: @memory_index,
         profile: @profile,
@@ -464,16 +495,16 @@ module Samagotchi
         served_model: @served_model,
         served_model_for: @served_model_for,
         tool_calls_total: @tool_records.size + in_flight.size,
-        tool_calls_by_tool: tally_into(totals[:by_tool].dup, in_flight),
+        tool_calls_by_tool: tally_into(@tool_tallies[:by_tool].dup, in_flight),
         # The calls the model made under an alias's name (bash run as
         # execute), by its own spelling; only when there are any.
-        **(totals[:aliased].empty? ? {} : { tool_calls_aliased: totals[:aliased].dup }),
-        tool_errors: totals[:tool_errors],
-        iterations_total: totals[:iterations] + (turn&.iteration_count || 0),
-        gen_latency_ms: (totals[:gen_ms] + (turn&.gen_latency_accum || 0)).round,
-        retries: totals[:retries] + (turn&.retries || 0),
-        cuts: totals[:cuts] + (turn&.cuts || 0),
-        capped: totals[:capped] + (turn&.capped || 0),
+        **(@tool_tallies[:aliased].empty? ? {} : { tool_calls_aliased: @tool_tallies[:aliased].dup }),
+        tool_errors: @tool_tallies[:errors],
+        iterations_total: totals.iterations,
+        gen_latency_ms: totals.gen_ms.round,
+        retries: totals.retries,
+        cuts: totals.cuts,
+        capped: totals.capped,
         started_at: @started_at,
         last_activity_at: @last_activity_at,
         # From the session's first start (an earlier process's too), to now.
@@ -484,31 +515,19 @@ module Samagotchi
       }
     end
 
-    # The session's token totals, with the running turn's finished
-    # generations; the last speeds are the newest a generation reported.
-    # Caller holds the mutex.
-    def tokens_block(totals, turn)
-      add = ->(key) { totals[key] + (turn&.public_send(key) || 0) }
-      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.call(:prompt_sum),
-        completion_sum: add.call(:completion_sum),
-        cached_sum: add.call(:cached_sum),
-        cache_write_sum: add.call(:cache_write_sum),
-        reprefill_sum: add.call(:reprefill_sum),
-        reasoning_sum: add.call(:reasoning_sum),
-        cost_sum: add.call(:cost_sum),
-        cost_estimate_sum: add.call(:cost_estimate_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,
-        last_decode_tps: speed_turn ? speed_turn.last_decode_tps : totals[:last_decode_tps],
-        last_prefill_tps: turn&.last_prefill_tps || totals[:last_prefill_tps],
-        tps_source: speed_turn ? speed_turn.tps_source : totals[:tps_source],
-        source: combined_source(totals[:token_sources] + (turn&.token_sources || []))
-      }
+    # The model segments with the running turn in: the last one's when it
+    # runs on that model or names none yet, else a new one. Caller holds
+    # the mutex.
+    def segments_with_running(turn)
+      return @segments unless turn
+
+      last = @segments.last
+      ref = turn.model_ref
+      if last.nil? || (ref && last.model_ref != ref)
+        return @segments + [ModelSegment.empty(ref, turn.started_at).with_running(turn)]
+      end
+
+      @segments[0...-1] + [last.with_running(turn)]
     end
 
     # The records a snapshot carries, copied. :all is every record; :recent
@@ -571,6 +590,8 @@ module Samagotchi
           cuts: 0,
           capped: 0,
           model: nil,
+          model_ref: nil,
+          gen_switch: false,
           continue: event[:continue] ? true : false,
           resumed: event[:resumed] ? true : false,
           id: event[:turn_id] || SecureRandom.uuid,
@@ -689,6 +710,7 @@ module Samagotchi
     def close_generation
       turn = @turn
       turn.gen_open = false
+      note_switch_prefill(turn)
       speed = nil
       if turn.gen_had_server
         completion = turn.gen_completion_max
@@ -712,6 +734,42 @@ module Samagotchi
       speed
     end
 
+    # The turn's model, from its first generation that names one; that
+    # generation is a switch's when the last turn that named a model ran on
+    # another (a turn with none, stopped before it asked, never counts; nor
+    # does a legacy session's first named one). Caller holds the mutex.
+    def note_model_ref(ref)
+      return if @turn.model_ref || ref.to_s.empty?
+
+      @turn.model_ref = ref.to_s
+      @turn.gen_switch = !@last_model_ref.nil? && @last_model_ref != @turn.model_ref
+      @last_model_ref = @turn.model_ref
+    end
+
+    # The first generation after a switch prefilled the history on the new
+    # model: its uncached prompt (the whole prompt less the cached reads;
+    # llama.cpp's native tokens_evaluated is the whole prompt too), with its
+    # cost estimated from the configured price, never a completion's. None
+    # for a generation with estimated tokens only or a prefill too small to
+    # be one (REPREFILL_MIN_TOKENS). Caller holds the mutex.
+    def note_switch_prefill(turn)
+      return unless turn.gen_switch
+
+      turn.gen_switch = false
+      return unless turn.gen_had_server
+
+      tokens = [turn.gen_prompt_max - turn.gen_cached_max, 0].max
+      return if tokens < TokenUsage::REPREFILL_MIN_TOKENS
+
+      turn.switch_prefill_tokens = tokens
+      return unless turn.gen_price
+
+      turn.switch_prefill_cost_estimate = turn.gen_price.cost(prompt_tokens: turn.gen_prompt_max,
+                                                              cached_tokens: turn.gen_cached_max,
+                                                              cache_write_tokens: turn.gen_cache_write_max,
+                                                              completion_tokens: 0)
+    end
+
     # The generation's cached/reasoning counts, cost and decode speed, into
     # the turn. The speed is the server's (llama.cpp's predicted_per_second
     # over its predicted_ms) or, without one, an estimate: the completion
@@ -781,6 +839,7 @@ module Samagotchi
       sources = turn.token_sources
       {
         model: turn.model,
+        model_ref: turn.model_ref,
         generations: turn.generations,
         prompt_tokens: turn.prompt_last,
         prompt_tokens_max: turn.prompt_max,
@@ -815,6 +874,8 @@ module Samagotchi
       fields[:reprefill_tokens_sum] = turn.reprefill_sum if turn.reprefill_sum.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
+      fields[:switch_prefill_cost_estimate] = turn.switch_prefill_cost_estimate if turn.switch_prefill_cost_estimate
       fields
     end
 
@@ -1017,6 +1078,7 @@ module Samagotchi
       reset_totals
       @turn_records.each { |record| count_turn(record) }
       @tool_records.each { |record| count_tool(record) }
+      @last_model_ref = @turn.model_ref if @turn&.model_ref
       @started_at = earliest_timestamp(prior["started_at"], @started_at)
       @last_activity_at ||= prior["last_activity_at"]
       # The served model last reported, with the name asked for then (the
@@ -1057,48 +1119,32 @@ module Samagotchi
     end
 
     # The session totals over the finished records, as running counters
-    # (#snapshot adds the running turn). Caller holds the mutex.
+    # (#snapshot adds the running turn), and the tool tallies over the tool
+    # records. Caller holds the mutex.
     def reset_totals
-      @totals = { cancellations: 0, prompt_sum: 0, completion_sum: 0, token_sources: [], iterations: 0,
-                  gen_ms: 0, retries: 0, cuts: 0, capped: 0, by_tool: {}, aliased: {}, tool_errors: 0, cached_sum: 0, cache_write_sum: 0,
-                  reprefill_sum: 0, reasoning_sum: 0,
-                  cost_sum: 0, cost_estimate_sum: 0, decode_ms_sum: 0, decode_tokens_sum: 0, last_decode_tps: nil,
-                  last_prefill_tps: nil, tps_source: nil }
+      @totals = Totals.zero
+      @segments = []
+      @last_model_ref = nil
+      @tool_tallies = { by_tool: {}, aliased: {}, errors: 0 }
     end
 
     def count_turn(record)
-      totals = @totals
-      totals[:cancellations] += 1 if record[:status] == "canceled"
-      totals[:prompt_sum] += number(record[:prompt_tokens_sum])
-      totals[:completion_sum] += number(record[:completion_tokens])
-      totals[:iterations] += number(record[:iterations])
-      totals[:gen_ms] += number(record[:gen_ms])
-      totals[:retries] += number(record[:retries])
-      totals[:cuts] += number(record[:cuts])
-      totals[:capped] += number(record[:capped])
-      totals[:cached_sum] += number(record[:cached_tokens_sum])
-      totals[:cache_write_sum] += number(record[:cache_write_tokens_sum])
-      totals[:reprefill_sum] += number(record[:reprefill_tokens_sum])
-      totals[:reasoning_sum] += number(record[:reasoning_tokens])
-      totals[:cost_sum] += number(record[:cost])
-      totals[:cost_estimate_sum] += number(record[:cost_estimate])
-      totals[:decode_ms_sum] += number(record[:decode_ms])
-      totals[:decode_tokens_sum] += number(record[:decode_tokens])
-      # The newest speeds a record has (an older record has none).
-      if record[:decode_tps].is_a?(Numeric)
-        totals[:last_decode_tps] = record[:decode_tps]
-        totals[:tps_source] = record[:tps_source]
+      @totals = @totals.add(record)
+      if ModelSegment.splits?(@segments.last, record)
+        @segments << ModelSegment.open(record)
+      else
+        @segments[-1] = @segments.last.add(record)
       end
-      totals[:last_prefill_tps] = record[:prefill_tps] if record[:prefill_tps].is_a?(Numeric)
-      source = record[:token_source]
-      totals[:token_sources] |= [source.to_s] unless source.nil?
+      # The model the last turn that named one ran on: what a switch is
+      # told by (#note_model_ref).
+      @last_model_ref = record[:model_ref].to_s unless record[:model_ref].to_s.empty?
     end
 
     def count_tool(record)
-      @totals[:tool_errors] += 1 if record[:status] == "error"
-      tally_into(@totals[:by_tool], [record])
+      @tool_tallies[:errors] += 1 if record[:status] == "error"
+      tally_into(@tool_tallies[:by_tool], [record])
       called_as = record[:called_as].to_s
-      @totals[:aliased][called_as] = @totals[:aliased].fetch(called_as, 0) + 1 unless called_as.empty?
+      @tool_tallies[:aliased][called_as] = @tool_tallies[:aliased].fetch(called_as, 0) + 1 unless called_as.empty?
     end
 
     def tally_into(counts, tools)
@@ -1109,17 +1155,6 @@ module Samagotchi
       counts
     end
 
-    def number(value)
-      value.is_a?(Numeric) ? value : 0
-    end
-
-    # server, estimate, or mixed when both kinds of counts (or a turn that
-    # was already mixed) are in; nil before any.
-    def combined_source(sources)
-      kinds = sources.compact.map(&:to_s).flat_map { |source| source == "mixed" ? %w[server estimate] : [source] }.uniq
-      kinds.size > 1 ? "mixed" : kinds.first
-    end
-
     def earliest_timestamp(*timestamps)
       timestamps.compact.min_by { |value| Time.iso8601(value.to_s) }
     rescue ArgumentError

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -435,17 +435,61 @@ module Samagotchi
       # /stats' cost: the reported part and the estimated one, each when present.
       # +price_host+ names the host whose hosts.<name>.models prices the
       # estimate came from (Engine#stats_snapshot; nil from an older worker).
-      def stats_cost_text(tokens, price_host: nil)
+      # +per_model+: the session ran on several models (model_segments), each
+      # priced from its own host's prices.
+      def stats_cost_text(tokens, price_host: nil, per_model: false)
         reported = cost_text(tokens[:cost_sum])
         estimated = cost_text(tokens[:cost_estimate_sum], estimate: true)
         return nil if reported.empty? && estimated.empty?
         return "#{reported} (this session only)" if estimated.empty?
 
-        source = price_host.to_s.empty? ? "configured prices" : "hosts.#{price_host}.models prices"
+        source = if per_model then "each model's host prices"
+                 elsif price_host.to_s.empty? then "configured prices"
+                 else "hosts.#{price_host}.models prices"
+                 end
         estimate = "#{estimated} from #{source}"
         "#{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
@@ -574,12 +618,17 @@ module Samagotchi
           lines << "  called as:      #{aliased.map { |k, v| "#{k}=#{v}" }.join(", ")}"
         end
         lines << "iterations:       #{snapshot[:iterations_total]}"
-        # Summed over every request: each prompt is sent in full again.
-        lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})" \
-                 "#{token_breakdown_text(tokens)}"
-        speed = stats_speed_text(tokens)
+        segments = Array(snapshot[:model_segments])
+        if segments.size >= 2
+          lines.concat(models_block_lines(segments, snapshot[:turns], tokens, token_src_label))
+        else
+          # Summed over every request: each prompt is sent in full again.
+          lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})" \
+                   "#{token_breakdown_text(tokens)}"
+        end
+        speed = stats_speed_text(tokens, last_model: segments.size >= 2 ? last_speed_label(segments) : nil)
         lines << "speed:            #{speed}" if speed
-        cost = stats_cost_text(tokens, price_host: snapshot[:price_host])
+        cost = stats_cost_text(tokens, price_host: snapshot[:price_host], per_model: segments.size >= 2)
         lines << "cost:             #{cost}" if cost
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
@@ -682,19 +731,87 @@ module Samagotchi
 
       # "87 tok/s out, 1.9k tok/s prompt (last, server), avg 81 tok/s", or nil
       # before a generation had a speed. The prompt (prefill) speed only when
-      # the server reported it.
-      def stats_speed_text(tokens)
+      # the server reported it. +last_model+: the model the last speed came
+      # from, named when the session ran on several.
+      def stats_speed_text(tokens, last_model: nil)
         last = tokens[:last_decode_tps]
         return nil unless last
 
         source = tokens[:tps_source].to_s
         text = "#{speed_text(last, source)} out"
         text << ", #{speed_text(tokens[:last_prefill_tps], "server")} prompt" if tokens[:last_prefill_tps]
-        text << " (last, #{source})"
+        text << " (last, #{source}#{", #{last_model}" if last_model})"
         text << ", avg #{speed_text(tokens[:avg_decode_tps], source)}" if tokens[:avg_decode_tps]
         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/status_row.rb

@@ -89,7 +89,9 @@ module Samagotchi
       # hint). Other events change nothing.
       def take_event(event)
         case event[:type]
-        when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
+        # usage nil (a /model whose window didn't resolve) clears it.
+        when :context_status
+          update(context: event[:usage] ? { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] } : nil)
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
           update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]