samagotchi 0.18.1 → 0.20.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
@@ -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,
@@ -296,13 +366,38 @@ module Samagotchi
         retries: totals[:retries] + (turn&.retries || 0),
         started_at: @started_at,
         last_activity_at: @last_activity_at,
-        session_duration_ms: elapsed_ms(@session_started_monotonic),
+        # From the session's first start (an earlier process's too), to now.
+        session_duration_ms: ms_since(@started_at),
         **records_view(records_mode),
         active_turn: active_turn_snapshot,
         active_tools: active_tool_snapshots
       }
     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
@@ -327,7 +422,6 @@ module Samagotchi
           load_persisted
         end
         @started_at ||= now.iso8601(3)
-        @session_started_monotonic ||= monotonic_time
         @turn = TurnState.new(
           session_id: @session_id,
           iteration_count: 0,
@@ -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,
@@ -364,6 +465,10 @@ module Samagotchi
           # A turn that failed mid-stream never saw its generation end:
           # what it got to still counts.
           close_generation if @turn.gen_open
+          # A call still running when the turn ends (a cancel, a failure)
+          # never completes: its record says so, as the count already has it.
+          @turn.tool_calls_by_id.each_value { |active| finish_tool_record(active, "canceled") }
+          @turn.tool_calls_by_id.clear
           finished_at = now
           record = {
             id: @turn.id,
@@ -403,14 +508,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?
@@ -418,11 +526,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.
@@ -431,6 +579,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
@@ -451,7 +604,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)
@@ -486,20 +656,24 @@ module Samagotchi
         active = @turn.tool_calls_by_id.delete(key)
         return unless active
 
-        finished_at = now
-        record = active.slice(
-          :id, :turn_id, :iteration, :call_index, :tool, :started_at
-        ).merge(
-          status: status.empty? ? "ok" : status,
-          completed_at: finished_at.iso8601(3),
-          # Less a guardrail approval wait (ToolRunner's waited_ms).
-          duration_ms: [elapsed_ms(active[:started_monotonic]) - event[:waited_ms].to_i, 0].max
-        )
-        @tool_records << record
-        count_tool(record)
+        finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
       end
     end
 
+    # Caller holds the mutex.
+    def finish_tool_record(active, status, waited_ms: 0)
+      record = active.slice(
+        :id, :turn_id, :iteration, :call_index, :tool, :started_at
+      ).merge(
+        status: status,
+        completed_at: now.iso8601(3),
+        # Less a guardrail approval wait (ToolRunner's waited_ms).
+        duration_ms: [elapsed_ms(active[:started_monotonic]) - waited_ms, 0].max
+      )
+      @tool_records << record
+      count_tool(record)
+    end
+
     # Accumulate token counts from a streamed generation_chunk payload.
     # Server-first: prefer real timings/usage. Prompt and completion tokens
     # are tracked as a per-generation MAX (the server's counts are cumulative
@@ -511,15 +685,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)
@@ -531,6 +700,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
@@ -558,6 +758,15 @@ module Samagotchi
       [((monotonic_time - started) * 1000.0).round, 0].max
     end
 
+    # Wall-clock ms from an ISO 8601 stamp to now (0 without one).
+    def ms_since(timestamp)
+      return 0 unless timestamp
+
+      [((now - Time.iso8601(timestamp.to_s)) * 1000.0).round, 0].max
+    rescue ArgumentError
+      0
+    end
+
     def tool_key(iteration, call_index)
       "#{iteration}:#{call_index}"
     end
@@ -609,6 +818,12 @@ module Samagotchi
       @tool_records.each { |record| count_tool(record) }
       @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
+      # Engine shows it only while that name is still the one asked for).
+      if @served_model.nil? && prior["served_model"]
+        @served_model = prior["served_model"]
+        @served_model_for = prior["served_model_for"]
+      end
       # The window last seen, until this process's first generation reports.
       window = prior["context"].is_a?(Hash) ? prior["context"] : {}
       if window["window_tokens"] && @context_window_tokens.nil?
@@ -640,7 +855,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)
@@ -651,6 +868,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/sessions_command.rb

@@ -13,7 +13,7 @@ require_relative "cli/command"
 require_relative "cli/flags"
 
 module Samagotchi
-  # `chi sessions`: list, stop, archive/unarchive, delete, prune and clean
+  # `chi sessions`: list, stop, restart, archive/unarchive, delete, prune and clean
   # sessions from the shell (bin/chi dispatches here before OptionParser;
   # the subcommands have their own flags). Not SessionCommands, the REPL's
   # slash commands for sessions (session_commands.rb).
@@ -21,7 +21,7 @@ module Samagotchi
     include CLI::Command
 
     USAGE = <<~TEXT
-      Usage: chi sessions <list|stop|archive|unarchive|delete|prune|clean> [options]
+      Usage: chi sessions <list|stop|restart|archive|unarchive|delete|prune|clean> [options]
         list [--sort updated_at|created_at] [--order desc|asc] [--limit N]
              [--live] [--cwd PATH] [--format text|json|tsv] [--archived]
              --live: sessions a worker runs now (the ones chi note reaches), 10 unless --limit
@@ -29,6 +29,7 @@ module Samagotchi
              [--scope=all]: every project's sessions; by default only this git project's (all outside a repo)
              --archived: archived sessions too (marked [archived]; json: archived: true)
         stop ID...   # stop each session's worker (IDs or unique prefixes); chi --resume ID then starts a fresh one
+        restart ID...   # hand each session to a new worker on the newest chi installed; refused while a turn, question or reminder would be lost
         archive ID...   # hide sessions (and their delegates) from every list and keep them for good; unarchive ID... brings them back
         delete [--force] ID...   # delete sessions for good (IDs or unique prefixes); --force stops a live worker first
         prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]
@@ -37,7 +38,8 @@ module Samagotchi
     TEXT
 
     STOP_USAGE = "Usage: chi sessions stop ID...\n"
-    SUBCOMMANDS = %w[list stop archive unarchive delete prune clean].freeze
+    RESTART_USAGE = "Usage: chi sessions restart ID...\n"
+    SUBCOMMANDS = %w[list stop restart archive unarchive delete prune clean].freeze
 
     # Each subcommand's flags ("--flag V" or "--flag=V" for a value): an
     # unknown flag, a value flag with nothing after it or an argument where
@@ -50,6 +52,7 @@ module Samagotchi
         f.switch "--archived", key: :include_archived
       end,
       "stop" => CLI::Flags.new,
+      "restart" => CLI::Flags.new,
       "prune" => CLI::Flags.new(args: false) do |f|
         %w[--days --keep --keep-status].each { |name| f.value name }
         f.switch "--dry-run"
@@ -94,6 +97,7 @@ module Samagotchi
       case @sub
       when "list" then list
       when "stop" then stop(parsed.args)
+      when "restart" then restart(parsed.args)
       else prune(@sub)
       end
     end
@@ -101,7 +105,7 @@ module Samagotchi
     private
 
     def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi sessions #{@sub}" : "chi sessions"
-    def usage_text = @sub == "stop" ? STOP_USAGE : USAGE
+    def usage_text = { "stop" => STOP_USAGE, "restart" => RESTART_USAGE }.fetch(@sub, USAGE)
 
     # quirk: a number that isn't one is 0 (--days=abc turns the age limit off)
     def integers(options)
@@ -257,6 +261,41 @@ module Samagotchi
       ok.all? ? 0 : 1
     end
 
+    # Each session in turn: its worker hands over to a new one on the newest
+    # chi (SessionManager.restart_session), or says why not.
+    def restart(ids)
+      return usage_error("give session ids") if ids.empty?
+
+      ok = ids.uniq.map do |given|
+        begin
+          id = Samagotchi::Session.resolve_id(given)
+          result = Samagotchi::SessionManager.restart_session(id)
+        rescue Samagotchi::SessionManager::OwnedByTUI
+          @stdout.flush
+          @stderr.puts "session #{id} is open in a chi REPL; close it there first"
+          next false
+        rescue Samagotchi::SessionManager::RestartRefused => e
+          @stdout.flush
+          @stderr.puts e.reason == :not_running || e.reason == :unsupported ? e.message : "session #{id}: #{e.message}"
+          next false
+        rescue ArgumentError => e
+          @stdout.flush
+          @stderr.puts e.message
+          next false
+        end
+        @stdout.puts restarted_line(result)
+        true
+      end
+      ok.all? ? 0 : 1
+    end
+
+    def restarted_line(result)
+      return "Restarting session #{result.session_id}; its new worker is still starting." unless result.version
+
+      from = result.from_version && result.from_version != result.version ? " (was #{result.from_version})" : ""
+      "Restarted session #{result.session_id} on chi #{result.version}#{from}."
+    end
+
     def prune(sub)
       days, keep, keep_status, dry_run, test_only = @opts.values_at(:days, :keep, :keep_status, :dry_run, :test_only)
       test_only = true if sub == "clean" && !@opts[:all]

data/lib/samagotchi/system_prompt.rb

@@ -310,6 +310,15 @@ module Samagotchi
       end
     end
 
+    # Once per name for this prompt (the Engine's, one per process): a
+    # rebuild (another level, a /model switch) doesn't repeat it.
+    def warn_preload_failed(name, echo)
+      @warned_preloads ||= Set.new
+      return unless @warned_preloads.add?(name)
+
+      Log.warn(:memory, "preload_failed", echo: echo, memory: name)
+    end
+
     def explicit_memory_section
       return nil if @requested_memories.empty?
 
@@ -322,7 +331,7 @@ module Samagotchi
           body = Tools::MemoryRead.call(actual_name, scope: scope, **overlay_keys)
           if body.start_with?("Error:")
             source = Array(@config_memories).include?(raw) ? "memory '#{name}' (from config memories:)" : "--memory '#{name}'"
-            Log.warn(:memory, "preload_failed", echo: "Warning: #{source} could not be loaded (#{body})", memory: name)
+            warn_preload_failed(name, "Warning: #{source} could not be loaded (#{body})")
             next
           end
           # Record activated names so the UI can echo them in the sticky