samagotchi 0.19.0 → 0.21.0

data/lib/samagotchi/session_metrics.rb

@@ -20,8 +20,10 @@ module Samagotchi
   # sums over the records, kept as running counters as records are added, so
   # a worker that stops and wakes again (a new collector) keeps counting:
   # #session_id= loads the records already saved.
-  # Only prompt and completion counts, which every backend reports the same
-  # way, are kept.
+  # Prompt and completion counts come from every backend. Cached and reasoning
+  # tokens, cost (OpenRouter's usage.cost) and the server's speeds (llama.cpp's
+  # timings) are kept when the server reports them; a generation without a
+  # server speed gets an estimated decode speed (see #close_generation).
   #
   # A snapshot is surfaced via Engine#session_state_snapshot (the Bridge's
   # /state, /snapshot, /stats and SSE frames) and persisted to a sibling
@@ -35,6 +37,25 @@ module Samagotchi
     # unsaved ones of a collector whose saves keep failing stay bounded.
     LIVE_RECORDS_CAP = 20
 
+    # A generation shorter than this gets no decode speed of its own: one
+    # tiny generation would skew the session's average.
+    SPEED_MIN_TOKENS = 8
+    SPEED_MIN_MS = 100
+
+    # The session's token totals as a saved analytics.json has them (zeros
+    # where an older file lacks a count), with how full the context was.
+    # A generation's decode speed (tokens per second) and where it came
+    # from: "server" (llama.cpp's timings) or "estimate".
+    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)
+
+    SavedSummary = Data.define(:ctx_pct, :prompt_sum, :completion_sum, :cached_sum, :reasoning_sum, :cost_sum) do
+      def tokens = to_h.except(:ctx_pct)
+    end
+
     # Per-turn transient state, reset on each turn_started.
     TurnState = Struct.new(
       :session_id,
@@ -56,6 +77,17 @@ module Samagotchi
       # comes cumulative per request) and whether it is still streaming.
       :gen_prompt_max,
       :gen_open,
+      # The rest of this generation's server report: the largest cached and
+      # reasoning counts, the last cost, and the server's speeds and decode
+      # time (llama.cpp's timings); and when its first content, reasoning or
+      # tool call chunk came (an estimated speed runs from there).
+      :gen_cached_max,
+      :gen_reasoning_max,
+      :gen_cost,
+      :gen_decode_tps,
+      :gen_prefill_tps,
+      :gen_decode_ms,
+      :gen_first_chunk_at,
       # The turn's generations, folded as each one ends: the count, the last
       # one's prompt and completion, the sums, and which kinds of counts
       # (server / estimate) they came from.
@@ -65,6 +97,18 @@ module Samagotchi
       :completion_last,
       :completion_sum,
       :token_sources,
+      # Summed over the turn's generations: cached and reasoning tokens, the
+      # cost (nil until one reports it), and the decode time and completion
+      # tokens of the generations with a speed. The last speeds and where the
+      # decode one came from (server / estimate).
+      :cached_sum,
+      :reasoning_sum,
+      :cost_sum,
+      :decode_ms_sum,
+      :decode_tokens_sum,
+      :last_decode_tps,
+      :last_prefill_tps,
+      :tps_source,
       :retries,
       :model,
       :id,
@@ -80,7 +124,27 @@ module Samagotchi
     # @param session_dir [String]
     # @return [Float, nil]
     def self.saved_context_pct(session_dir)
-      context = JSON.parse(File.read(File.join(session_dir, "analytics.json")))["context"]
+      saved_summary(session_dir)&.ctx_pct
+    end
+
+    # The context's fill and the token totals from the session's saved
+    # analytics.json, read once; nil without a readable file.
+    # @param session_dir [String]
+    # @return [SavedSummary, nil]
+    def self.saved_summary(session_dir)
+      data = JSON.parse(File.read(File.join(session_dir, "analytics.json")))
+      return nil unless data.is_a?(Hash)
+
+      tokens = data["tokens"].is_a?(Hash) ? data["tokens"] : {}
+      count = ->(key) { tokens[key].is_a?(Numeric) ? tokens[key] : 0 }
+      SavedSummary.new(ctx_pct: saved_pct(data["context"]), prompt_sum: count.("prompt_sum"),
+                       completion_sum: count.("completion_sum"), cached_sum: count.("cached_sum"),
+                       reasoning_sum: count.("reasoning_sum"), cost_sum: count.("cost_sum"))
+    rescue JSON::ParserError, SystemCallError, TypeError
+      nil
+    end
+
+    def self.saved_pct(context)
       return nil unless context.is_a?(Hash)
 
       used = context["used_tokens"]
@@ -88,9 +152,8 @@ module Samagotchi
       return nil unless used.is_a?(Numeric) && window.is_a?(Numeric) && window.positive?
 
       used * 100.0 / window
-    rescue JSON::ParserError, SystemCallError, TypeError
-      nil
     end
+    private_class_method :saved_pct
 
     # One turn's tool records from the session's saved analytics.json, in
     # call order (iteration, then call_index), string-keyed as saved: what a
@@ -214,7 +277,7 @@ module Samagotchi
       when :turn_completed
         end_turn(status: "completed")
       when :turn_canceled
-        end_turn(status: "canceled", reason: event[:cancellation_reason])
+        end_turn(status: "canceled", reason: event[:cancellation_reason], by: event[:cancelled_by])
       when :turn_failed
         end_turn(status: "failed")
       end
@@ -236,6 +299,17 @@ module Samagotchi
       @mutex.synchronize { build_snapshot(:recent) }
     end
 
+    # Close the open generation now, ahead of its :generation_completed
+    # (which then finds it closed), and report its speed with the session's
+    # running token totals: what the event carries to the UIs.
+    # @return [GenerationReport]
+    def finish_generation
+      @mutex.synchronize do
+        speed = close_generation if @turn&.gen_open
+        GenerationReport.new(speed: speed, tokens: tokens_block(@totals, @turn))
+      end
+    end
+
     # The served model a generation last reported and the name asked for
     # then, without building a snapshot (Engine#served_model).
     # @return [Hash] :served_model, :served_model_for
@@ -278,11 +352,7 @@ module Samagotchi
         session_id: @session_id,
         turns: @turn_records.size + (turn ? 1 : 0),
         cancellations: totals[:cancellations],
-        tokens: {
-          prompt_sum: totals[:prompt_sum] + (turn&.prompt_sum || 0),
-          completion_sum: totals[:completion_sum] + (turn&.completion_sum || 0),
-          source: combined_source(totals[:token_sources] + (turn&.token_sources || []))
-        },
+        tokens: tokens_block(totals, turn),
         context: context_block(@turn_records),
         profile: @profile,
         profile_source: @profile_source,
@@ -304,6 +374,30 @@ 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.(:decode_ms_sum)
+      decode_tokens = add.(:decode_tokens_sum)
+      speed_turn = turn&.last_decode_tps ? turn : nil
+      {
+        prompt_sum: add.(:prompt_sum),
+        completion_sum: add.(:completion_sum),
+        cached_sum: add.(:cached_sum),
+        reasoning_sum: add.(:reasoning_sum),
+        cost_sum: add.(:cost_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 || []))
+      }
+    end
+
     # The records a snapshot carries, copied. :all is every record; :recent
     # the newest turn this collector finished (live before its save lands)
     # and the unsaved ones (capped), and the tool records of those turns and
@@ -340,12 +434,19 @@ module Samagotchi
           gen_estimate_sum: 0,
           gen_prompt_max: 0,
           gen_open: false,
+          gen_cached_max: 0,
+          gen_reasoning_max: 0,
           generations: 0,
           prompt_last: nil,
           prompt_sum: 0,
           completion_last: 0,
           completion_sum: 0,
           token_sources: [],
+          cached_sum: 0,
+          reasoning_sum: 0,
+          cost_sum: nil,
+          decode_ms_sum: 0,
+          decode_tokens_sum: 0,
           retries: 0,
           model: nil,
           id: event[:turn_id] || SecureRandom.uuid,
@@ -356,9 +457,10 @@ module Samagotchi
       end
     end
 
-    # A canceled turn's record keeps why (+reason+: "user", "ctrl_c", ...), so
-    # a reloaded web history can show the cancel line the live one did.
-    def end_turn(status: "completed", reason: nil)
+    # A canceled turn's record keeps why (+reason+: "user", "ctrl_c", ...)
+    # and who stopped it (+by+: a hook's bundle), so a reloaded web history
+    # can show the cancel line the live one did.
+    def end_turn(status: "completed", reason: nil, by: nil)
       @mutex.synchronize do
         if @turn
           # A turn that failed mid-stream never saw its generation end:
@@ -377,6 +479,7 @@ module Samagotchi
             duration_ms: elapsed_ms(@turn.started_monotonic)
           }
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
+          record[:cancelled_by] = by.to_s unless by.nil? || by.to_s.empty?
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)
@@ -407,14 +510,17 @@ module Samagotchi
     # instead (there is no prompt count then). The two paths are mutually
     # exclusive per generation, so a final chunk carrying timings while
     # earlier chunks did not will not double count. Caller holds the mutex.
+    # @return [GenerationSpeed, nil] the generation's speed, if it had one
     def close_generation
       turn = @turn
       turn.gen_open = false
+      speed = nil
       if turn.gen_had_server
         completion = turn.gen_completion_max
         turn.prompt_last = turn.gen_prompt_max
         turn.prompt_sum += turn.gen_prompt_max
         turn.token_sources |= ["server"]
+        speed = close_server_report(turn, completion)
       else
         completion = turn.gen_estimate_sum
         turn.token_sources |= ["estimate"] if completion.positive?
@@ -422,11 +528,51 @@ module Samagotchi
       turn.completion_last = completion
       turn.completion_sum += completion
       started = turn.gen_started_at
-      return unless started
+      return speed unless started
 
       elapsed_ms = (monotonic_time - started) * 1000.0
       turn.gen_latency_accum += elapsed_ms if elapsed_ms > 0
       turn.gen_started_at = nil
+      speed
+    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
+    # over the time from the first streamed chunk to now (that leaves out
+    # queueing and the prefill). An estimated chars/4 generation never gets
+    # here: it has no speed. Caller holds the mutex.
+    def close_server_report(turn, completion)
+      turn.cached_sum += turn.gen_cached_max
+      turn.reasoning_sum += turn.gen_reasoning_max
+      turn.cost_sum = turn.cost_sum.to_f + turn.gen_cost if turn.gen_cost
+      turn.last_prefill_tps = turn.gen_prefill_tps.round(1) if turn.gen_prefill_tps
+      speed = generation_speed(turn, completion)
+      return unless speed
+
+      tps, decode_ms, source = speed
+      turn.decode_ms_sum += decode_ms
+      turn.decode_tokens_sum += completion
+      turn.last_decode_tps = tps.round(1)
+      turn.tps_source = source
+      GenerationSpeed.new(decode_tps: turn.last_decode_tps, source: source)
+    end
+
+    # [tokens per second, decode ms, "server" | "estimate"], or nil for a
+    # generation too short (or without a first chunk) to time.
+    def generation_speed(turn, completion)
+      if turn.gen_decode_tps && turn.gen_decode_ms
+        decode_ms = turn.gen_decode_ms
+        tps = turn.gen_decode_tps
+        source = "server"
+      elsif turn.gen_first_chunk_at
+        decode_ms = (monotonic_time - turn.gen_first_chunk_at) * 1000.0
+        tps = decode_ms.positive? ? completion * 1000.0 / decode_ms : 0
+        source = "estimate"
+      end
+      return nil unless decode_ms && completion >= SPEED_MIN_TOKENS && decode_ms >= SPEED_MIN_MS
+
+      [tps, decode_ms, source]
     end
 
     # Caller holds the mutex.
@@ -435,6 +581,11 @@ module Samagotchi
       @turn.gen_prompt_max = 0
       @turn.gen_had_server = false
       @turn.gen_estimate_sum = 0
+      @turn.gen_cached_max = 0
+      @turn.gen_reasoning_max = 0
+      @turn.gen_cost = nil
+      @turn.gen_decode_tps = @turn.gen_prefill_tps = @turn.gen_decode_ms = nil
+      @turn.gen_first_chunk_at = nil
     end
 
     # The turn record's model and token fields. The context used at the end
@@ -455,7 +606,24 @@ module Samagotchi
         tool_errors: turn.tool_errors,
         iterations: turn.iteration_count,
         retries: turn.retries
+      }.merge(turn_usage_fields(turn))
+    end
+
+    # The rest of the server's report: cached and reasoning tokens, the cost,
+    # and the speeds (decode_tps is the turn's last generation's, decode_ms
+    # and decode_tokens what the session's average is weighted by).
+    def turn_usage_fields(turn)
+      fields = {
+        cached_tokens_sum: turn.cached_sum,
+        reasoning_tokens: turn.reasoning_sum,
+        decode_ms: turn.decode_ms_sum.round,
+        decode_tokens: turn.decode_tokens_sum,
+        decode_tps: turn.last_decode_tps,
+        prefill_tps: turn.last_prefill_tps,
+        tps_source: turn.tps_source
       }
+      fields.merge!(cost: turn.cost_sum, cost_source: "reported") if turn.cost_sum
+      fields
     end
 
     def record_tool_call_start(event)
@@ -519,15 +687,10 @@ module Samagotchi
       payload = event[:payload]
       payload = {} unless payload.is_a?(Hash)
 
+      @mutex.synchronize { note_first_chunk(payload, event) }
       usage = TokenUsage.from_payload(payload)
       if usage
-        @mutex.synchronize do
-          if @turn
-            @turn.gen_prompt_max = [@turn.gen_prompt_max, usage[:prompt_tokens].to_i].max
-            @turn.gen_completion_max = [@turn.gen_completion_max, usage[:completion_tokens].to_i].max
-            @turn.gen_had_server = true
-          end
-        end
+        @mutex.synchronize { note_server_usage(usage) if @turn }
       else
         @mutex.synchronize do
           chars = event_content_chars(payload, event)
@@ -539,6 +702,37 @@ module Samagotchi
       end
     end
 
+    # Caller holds the mutex.
+    def note_server_usage(usage)
+      turn = @turn
+      turn.gen_prompt_max = [turn.gen_prompt_max, usage.prompt_tokens.to_i].max
+      turn.gen_completion_max = [turn.gen_completion_max, usage.completion_tokens.to_i].max
+      turn.gen_cached_max = [turn.gen_cached_max, usage.cached_tokens.to_i].max
+      turn.gen_reasoning_max = [turn.gen_reasoning_max, usage.reasoning_tokens.to_i].max
+      turn.gen_cost = usage.cost if usage.cost
+      if usage.predicted_per_second && usage.predicted_ms
+        turn.gen_decode_tps = usage.predicted_per_second
+        turn.gen_decode_ms = usage.predicted_ms
+      end
+      turn.gen_prefill_tps = usage.prompt_per_second if usage.prompt_per_second
+      turn.gen_had_server = true
+    end
+
+    # The first chunk with content, reasoning or a tool call starts the
+    # generation's decode clock (an estimated speed runs from it). Caller
+    # holds the mutex.
+    def note_first_chunk(payload, event)
+      return unless @turn && @turn.gen_open && @turn.gen_first_chunk_at.nil?
+      return unless !event[:content].to_s.empty? || tool_call_delta?(payload)
+
+      @turn.gen_first_chunk_at = monotonic_time
+    end
+
+    def tool_call_delta?(payload)
+      choice = payload["choices"].is_a?(Array) ? payload["choices"].first : nil
+      choice.is_a?(Hash) && choice["delta"].is_a?(Hash) && !Array(choice["delta"]["tool_calls"]).empty?
+    end
+
     def event_content_chars(payload, event)
       len = payload_content(payload, event).length
       len.positive? ? len : nil
@@ -663,7 +857,9 @@ module Samagotchi
     # (#snapshot adds the running turn). 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, by_tool: {}, tool_errors: 0 }
+                  gen_ms: 0, retries: 0, by_tool: {}, tool_errors: 0, cached_sum: 0, reasoning_sum: 0,
+                  cost_sum: 0, decode_ms_sum: 0, decode_tokens_sum: 0, last_decode_tps: nil,
+                  last_prefill_tps: nil, tps_source: nil }
     end
 
     def count_turn(record)
@@ -674,6 +870,17 @@ module Samagotchi
       totals[:iterations] += number(record[:iterations])
       totals[:gen_ms] += number(record[:gen_ms])
       totals[:retries] += number(record[:retries])
+      totals[:cached_sum] += number(record[:cached_tokens_sum])
+      totals[:reasoning_sum] += number(record[:reasoning_tokens])
+      totals[:cost_sum] += number(record[:cost])
+      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]
+      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?
     end

data/lib/samagotchi/steer.rb

@@ -80,7 +80,7 @@ module Samagotchi
     # :pending_input_merged. After a cancel the input stays queued: it runs
     # as the next turn instead of dying with this one. +answer+ (a String,
     # or a Proc called only on a merge) is the answer the merge follows, for
-    # the UIs; given, the drain is told it is the after-answer site (plugin
+    # the TUI's line (the web has it as the step's streamed text); given, the drain is told it is the after-answer site (plugin
     # steers are dropped there). A blank answer is none.
     # @return [Boolean] whether anything was injected
     def inject!(conversation, pending_input, iteration:, emit:, cancel_controller:, answer: nil)

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -47,6 +47,10 @@ module Samagotchi
       DETACH_HINT = "Ctrl-D to detach, /exit stops the worker"
       # Why a request the Bridge read after its deadline didn't go through.
       LATE = "worker not answering in time"
+      # An exit the worker agreed to in an empty session. Said before it has
+      # left: it checks again once it lets go, and a note or prompt arriving
+      # first keeps the session (SessionManager.discard_left_session).
+      EMPTY_EXIT = "Detached; the session is empty: it will be discarded if nothing arrives before its worker stops."
       # Why the worker stayed up after /exit, by the reason it gave.
       HELD_REASONS = {
         "turn_running" => "a turn is running", "input_queued" => "prompts are queued",
@@ -420,7 +424,9 @@ module Samagotchi
           return detach("#{line} Not deleted.")
         end
         # An empty session: the worker deletes it as it leaves.
-        @delete_session.call(id) unless discards?(reply)
+        return detach(EMPTY_EXIT) if discards?(reply)
+
+        @delete_session.call(id)
         detach("Detached; deleted session #{id}.")
       rescue SystemCallError, IOError => e
         detach("#{exit_failed_line(e.message)} Not deleted.")
@@ -429,14 +435,15 @@ module Samagotchi
       end
 
       # /archive: the worker is asked to exit as for /exit, then the session
-      # is archived. A worker staying up for another UI (or reminders, a
-      # queued prompt) is stopped by the archive, as the web's archive
-      # stops it; a turn running refuses it. An empty session: the worker
+      # is archived. A worker staying up for another UI (or reminders) is
+      # stopped by the archive, as the web's archive stops it; a turn
+      # running, a queued prompt or an open continue offer refuses it
+      # (SessionManager.archive_session). An empty session: the worker
       # deletes it as it leaves.
       def exit_and_archive
         reply = @client.request_exit(client_id: @client_id)
         id = @client.session_id
-        return detach("Detached; the session was empty, so it is discarded.") if reply.status == 200 && discards?(reply)
+        return detach(EMPTY_EXIT) if reply.status == 200 && discards?(reply)
         return detach("#{exit_line(reply)} Not archived.") unless [200, 409].include?(reply.status)
 
         result = @archive_session.call(id)
@@ -454,15 +461,14 @@ module Samagotchi
         error = reply.json&.fetch("error", nil)
         case reply.status
         when 200
-          # Said as the worker agreed to leave; a note coming in before it
-          # does keeps the session after all (rare, left as is).
-          return "Detached; the session was empty, so it is discarded." if discards?(reply)
+          return EMPTY_EXIT if discards?(reply)
 
           "Detached; the session's worker is stopping. Resume with: chi --resume #{id}"
         when 409
           reason = reply.json&.fetch("reason", nil).to_s
           "Detached; the session keeps running (#{HELD_REASONS.fetch(reason, reason)}). Re-attach with: chi --attach #{id}"
         when 0 then exit_failed_line("no reply")
+        when 408 then exit_failed_line(LATE)
         else
           # A worker from before the route answers the Bridge's plain 404.
           return "Detached; this worker runs an older chi and can't be stopped from here: chi sessions stop #{id}" if error == "not_found"
@@ -1029,7 +1035,8 @@ module Samagotchi
         exchange = messages.select { |m| %w[user model assistant].include?(m[:role].to_s) }
         # The id stays findable: the detach line and chi sessions list show it.
         Log.session_id = @client.session_id
-        Log.info(:attached, "joined", session: @client.session_id, messages: exchange.size)
+        Log.info(:attached, "joined", session: @client.session_id, messages: exchange.size,
+                                      notes: messages.count { |m| ContextNote.note?(m) })
         last_user = exchange.rindex { |m| Steer.prompt?(m) }
         render_join_notes(messages)
         return unless last_user
@@ -1166,6 +1173,8 @@ module Samagotchi
         running_tool = nil
         Bridge::TurnAccumulator.replay_events(turn).each do |event|
           case event[:type]
+          # A new step starts its line over, as live (a join during a hold).
+          when :generation_started then tail, lane = nil, :writing
           when :generation_chunk
             tail, lane = event[:thinking].to_s.empty? ? [event[:text], :writing] : [event[:thinking], :thinking]
           when :tool_call_started

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -84,7 +84,7 @@ module Samagotchi
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
         when :turn_canceled
           @view.finish_thinking_spinner
-          @view.print_line(@view.turn_canceled_line(event[:cancellation_reason], event[:duration_ms]))
+          @view.print_line(@view.turn_canceled_line(event[:cancellation_reason], event[:duration_ms], by: event[:cancelled_by]))
           @view.print_line(@view.turn_end_hint(Formatting::ROLLBACK_HINT)) unless @turn_continues
         when :turn_failed
           # A provider error's one-line summary, else the message (an image

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -203,8 +203,13 @@ module Samagotchi
       # started): its partial progress stays in the conversation.
       ROLLBACK_HINT = "partial progress kept; !rollback restores the pre-turn state"
 
-      # "✕ turn canceled (Ctrl-C) · 3.1s"
-      def turn_canceled_line(reason, duration_ms)
+      # "✕ turn canceled (Ctrl-C) · 3.1s"; a hook's stop that names who
+      # (+by+, turn_canceled's cancelled_by): "✕ turn stopped by loop-guard"
+      def turn_canceled_line(reason, duration_ms, by: nil)
+        if reason.to_s == "hook" && !by.to_s.empty?
+          return "#{paint("✕", 33)} turn stopped by #{by}#{turn_duration_suffix(duration_ms)}"
+        end
+
         label = reason.to_s.empty? ? nil : CANCEL_REASONS.fetch(reason.to_s, reason.to_s)
         "#{paint("✕", 33)} turn canceled#{" (#{label})" if label}#{turn_duration_suffix(duration_ms)}"
       end
@@ -221,6 +226,26 @@ module Samagotchi
         duration_ms.nil? ? "" : " · #{format_elapsed_duration(duration_ms)}"
       end
 
+      # "87 tok/s", "1.9k tok/s"; "~64 tok/s" for an estimate; "" without a
+      # speed. The web says the same (ctx.js speedText;
+      # spec/shared/labels_matrix.json).
+      def speed_text(tps, source)
+        value = tps.to_f
+        return "" unless value.positive?
+
+        number = value >= 1000 ? "#{format('%.1f', (value / 100).round / 10.0)}k" : value.round.to_s
+        "#{'~' if source.to_s == 'estimate'}#{number} tok/s"
+      end
+
+      # "$0.42"; a cost under a cent keeps four decimals ("$0.0012"); "" for
+      # none. As ctx.js costText.
+      def cost_text(cost)
+        value = cost.to_f
+        return "" unless value.positive?
+
+        value >= 0.01 ? format("$%.2f", value) : format("$%.4f", value)
+      end
+
       private
 
       # The recap shown on return: dim, one "recap>" block, noting how many
@@ -343,7 +368,11 @@ module Samagotchi
         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})"
+        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)
+        lines << "speed:            #{speed}" if speed
+        lines << "cost:             #{cost_text(tokens[:cost_sum])} (this session only)" if tokens[:cost_sum].to_f.positive?
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
         lines << "retries:          #{snapshot[:retries]}"
@@ -362,6 +391,33 @@ module Samagotchi
         lines.join("\n")
       end
 
+      # ", cached 4864 (93%), reasoning 212" for the tokens line; the counts a
+      # server didn't report are left out.
+      def token_breakdown_text(tokens)
+        cached = tokens[:cached_sum].to_i
+        reasoning = tokens[:reasoning_sum].to_i
+        prompt = tokens[:prompt_sum].to_i
+        text = +""
+        text << ", cached #{cached} (#{(cached * 100.0 / prompt).round}%)" if cached.positive? && prompt.positive?
+        text << ", reasoning #{reasoning}" if reasoning.positive?
+        text
+      end
+
+      # "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)
+        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 << ", avg #{speed_text(tokens[:avg_decode_tps], source)}" if tokens[:avg_decode_tps]
+        text
+      end
+
       def format_elapsed_duration(duration_ms)
         duration_ms = duration_ms.to_f
         return "" if duration_ms.negative?

data/lib/samagotchi/terminal_ui/live_region.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "io/console"
 require_relative "screen"
 require_relative "reline_seam"
 
@@ -22,10 +23,48 @@ module Samagotchi
         screen
       end
 
-      # Hand Reline its own drawing back, then close the surface.
-      def close(surface)
+      # How long #drain_input waits for input still on its way.
+      DRAIN_WINDOW = 0.05
+      # How long Reline waits for the reply to its cursor query (Reline::ANSI#cursor_pos).
+      CURSOR_REPLY_WAIT = 0.5
+      CURSOR_REPLY = /\e\[\d+;\d+R/
+
+      # Hand Reline its own drawing back, close the surface, then drop the
+      # input nobody read (#drain_input).
+      def close(surface, input: $stdin)
         RelineSeam.detach(surface)
         surface.close
+        query_at = RelineSeam.unanswered_query_at
+        RelineSeam.unanswered_query_at = nil
+        drain_input(input, query_at: query_at) if surface.is_a?(Screen)
+      end
+
+      # Reline asks the terminal for the cursor row (ESC[6n) as each read
+      # starts; the reply to one cut short at exit, read by nobody, would
+      # land at the shell's prompt. What came, or comes within DRAIN_WINDOW,
+      # is read and dropped (keys typed in that moment too), in raw mode, so
+      # a reply with no newline is readable. With a query left unanswered
+      # (RelineSeam.unanswered_query_at), until its reply, up to as long as
+      # Reline would have waited for it.
+      def drain_input(input, query_at: nil)
+        return unless input.is_a?(IO) && input.tty?
+
+        now = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        deadline = now.call + DRAIN_WINDOW
+        deadline = [deadline, query_at + CURSOR_REPLY_WAIT].max if query_at
+        dropped = +""
+        input.raw do
+          while (left = deadline - now.call).positive? && input.wait_readable(left)
+            read = input.read_nonblock(1024, exception: false)
+            break if read.nil?
+
+            dropped << read if read.is_a?(String)
+            # The reply came: no need to wait out the rest.
+            deadline = [now.call + DRAIN_WINDOW, deadline].min if query_at && dropped.match?(CURSOR_REPLY)
+          end
+        end
+      rescue IOError, SystemCallError
+        nil
       end
 
       def available?(out:, input:, env:)