samagotchi 0.74.0 → 0.76.0

data/lib/samagotchi/session_chain.rb

@@ -6,7 +6,7 @@ require_relative "recap_store"
 
 module Samagotchi
   # Session chains: a session that continues an earlier one (Session#continues),
-  # "the next day of the same routine". The chain is derived, never stored:
+  # "the next run of the same routine". The chain is derived, never stored:
   # follow +continues+ back for the earlier links, forward (the session whose
   # +continues+ names this one) for the later ones. A link is continued at
   # most once (SessionManager.continue_session refuses a second), so the
@@ -69,7 +69,7 @@ module Samagotchi
     # @param recap [Hash, nil] RecapStore.read's
     # @return [String]
     def note_text(previous, recap:)
-      head = "This session continues #{previous.id[0, 8]} (#{day(previous.created_at)}), the previous link of its chain."
+      head = "This session continues #{previous.id[0, 8]} (#{clock(previous.created_at) || previous.created_at}), the previous link of its chain."
       text = recap && recap[:text].to_s.strip
       return "#{head} It left no recap." if text.nil? || text.empty?
 
@@ -102,12 +102,6 @@ module Samagotchi
       nil
     end
 
-    def day(iso)
-      Time.iso8601(iso.to_s).localtime.strftime("%Y-%m-%d")
-    rescue ArgumentError
-      iso.to_s
-    end
-
     def clock(iso)
       iso && Time.iso8601(iso.to_s).localtime.strftime("%Y-%m-%d %H:%M")
     rescue ArgumentError

data/lib/samagotchi/session_commands.rb

@@ -592,6 +592,8 @@ 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.
+      @engine.announce_switched_context!
     end
 
     def persist_session_model

data/lib/samagotchi/session_manager.rb

@@ -244,8 +244,7 @@ module Samagotchi
       end
       # And the spawner's XDG dirs, absolute: a relative XDG_STATE_HOME or
       # XDG_CONFIG_HOME would otherwise be read from the session's directory.
-      child_env["XDG_STATE_HOME"] = Paths.state_home unless ENV.fetch("XDG_STATE_HOME", "").to_s.strip.empty?
-      child_env["XDG_CONFIG_HOME"] = Paths.config_home unless ENV.fetch("XDG_CONFIG_HOME", "").to_s.strip.empty?
+      child_env.merge!(Paths.absolute_xdg)
       # The spawner's environment must not reach the worker's guardrails (a
       # parent agent starting or waking a session): Process.spawn unsets a
       # key mapped to nil. config.yml no longer reads them; this keeps an

data/lib/samagotchi/session_metrics/model_segment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "totals"
+
+module Samagotchi
+  class SessionMetrics
+    # A run of consecutive turns on one model (their records' model_ref, the
+    # asked host:model): /stats and the web's ctx/cost tooltip split the
+    # session's tokens, cost and speed by these, in order, so A -> B -> A is
+    # three. Derived from the turn records as they are counted, never saved
+    # on their own. A record with no ref (a turn stopped before it asked a
+    # model) joins the segment before it; records with none before the first
+    # one that names a model (a session older than model_ref) make one
+    # leading segment with no ref.
+    #
+    # +prefill_tokens+ / +prefill_cost_estimate+: what the segment's first
+    # turn prefilled on its model after the switch (the records'
+    # switch_prefill_*), 0 / nil for none.
+    class ModelSegment < Data.define(:model_ref, :started_at, :ended_at, :turns, :totals, :prefill_tokens,
+                                     :prefill_cost_estimate)
+      # The most rows a snapshot sends: older ones fold into one.
+      CAP = 6
+
+      # A segment opened by +record+ (its first turn).
+      # @param record [Hash] a turn record (symbol keys)
+      # @return [ModelSegment]
+      def self.open(record)
+        ref = record[:model_ref].to_s
+        new(model_ref: ref.empty? ? nil : ref, started_at: record[:started_at], ended_at: nil, turns: 0,
+            totals: Totals.zero, prefill_tokens: 0, prefill_cost_estimate: nil).add(record)
+      end
+
+      # The segment a snapshot shows for the running turn when it is on
+      # another model than the last segment's: no finished turn yet.
+      # @param ref [String]
+      # @param started_at [String, nil]
+      # @return [ModelSegment]
+      def self.empty(ref, started_at)
+        new(model_ref: ref, started_at: started_at, ended_at: nil, turns: 0, totals: Totals.zero, prefill_tokens: 0,
+            prefill_cost_estimate: nil)
+      end
+
+      # Whether +record+ starts a new segment after this one: it names a
+      # model, and another one than this segment's.
+      def self.splits?(segment, record)
+        ref = record[:model_ref].to_s
+        segment.nil? || (!ref.empty? && segment.model_ref != ref)
+      end
+
+      # This segment with one more finished turn record.
+      # @return [ModelSegment]
+      def add(record)
+        tokens = record[:switch_prefill_tokens]
+        estimate = record[:switch_prefill_cost_estimate]
+        with(ended_at: record[:completed_at] || ended_at, turns: turns + 1, totals: totals.add(record),
+             prefill_tokens: prefill_tokens + (tokens.is_a?(Numeric) ? tokens : 0),
+             prefill_cost_estimate: estimate.is_a?(Numeric) ? prefill_cost_estimate.to_f + estimate : prefill_cost_estimate)
+      end
+
+      # This segment with the running turn (SessionMetrics::TurnState) in:
+      # its finished generations and the prefill it recorded so far; it
+      # runs on, so it has no end.
+      # @return [ModelSegment]
+      def with_running(turn)
+        estimate = turn.switch_prefill_cost_estimate
+        with(ended_at: nil, turns: turns + 1, totals: totals.with_running(turn),
+             prefill_tokens: prefill_tokens + turn.switch_prefill_tokens.to_i,
+             prefill_cost_estimate: estimate ? prefill_cost_estimate.to_f + estimate : prefill_cost_estimate)
+      end
+
+      # The row a snapshot carries (JSON-ready). +ended_at+ nil: the segment
+      # runs now.
+      # @return [Hash]
+      def to_h
+        tokens = totals.tokens_block
+        {
+          model_ref: model_ref, started_at: started_at, ended_at: ended_at, turns: turns,
+          **tokens.slice(:prompt_sum, :completion_sum, :cached_sum, :cost_sum, :cost_estimate_sum, :avg_decode_tps,
+                         :last_decode_tps, :tps_source),
+          prefill_tokens: prefill_tokens, prefill_cost_estimate: prefill_cost_estimate
+        }
+      end
+
+      # The rows of +segments+ a snapshot sends: none for fewer than 2 (one
+      # model: the plain totals say it all); over CAP, the oldest fold into
+      # one row with no ref that says how many it holds (folded_segments).
+      # @param segments [Array<ModelSegment>]
+      # @return [Array<Hash>]
+      def self.rows(segments)
+        return [] if segments.size < 2
+        return segments.map(&:to_h) if segments.size <= CAP
+
+        older = segments.first(segments.size - CAP + 1)
+        folded = older.drop(1).reduce(older.first.with(model_ref: nil)) do |sum, segment|
+          sum.merge(segment)
+        end
+        [folded.to_h.merge(folded_segments: older.size), *segments.last(CAP - 1).map(&:to_h)]
+      end
+
+      # This segment and a later one as one row (the folded older ones).
+      # @return [ModelSegment]
+      def merge(later)
+        estimate = [prefill_cost_estimate, later.prefill_cost_estimate].compact
+        with(ended_at: later.ended_at, turns: turns + later.turns, totals: totals.merge(later.totals),
+             prefill_tokens: prefill_tokens + later.prefill_tokens, prefill_cost_estimate: estimate.empty? ? nil : estimate.sum)
+      end
+    end
+  end
+end

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