samagotchi 0.18.1 → 0.20.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -11,6 +11,7 @@ require_relative "image_input"
 require_relative "line_reader"
 require_relative "question_prompt"
 require_relative "reline_seam"
+require_relative "version_lines"
 require_relative "../bridge/turn_accumulator"
 require_relative "../bridge_client"
 require_relative "../log"
@@ -92,8 +93,10 @@ module Samagotchi
                      default_input: false, wait_at_eof: false, parent_answers: false,
                      clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                      delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) },
-                     archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) })
+                     archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) },
+                     installed_version: -> { InstalledVersions.new.newest })
         @client = client
+        @installed_version = installed_version
         @delete_session = delete_session
         @archive_session = archive_session
         @screen = screen
@@ -108,6 +111,8 @@ module Samagotchi
         @running = false
         @joined_mid_turn = false
         @attached = false
+        # The stream moved to a new worker; its snapshot resyncs (#switch_worker).
+        @worker_changed = false
         @early_lines = []
         @question = nil
         @answered_ids = Set.new
@@ -158,7 +163,12 @@ module Samagotchi
         RelineSeam.interrupt_handler = method(:note_interrupted_line)
         # Tagged, so the worker doesn't count this stream as another UI
         # when this UI asks it to exit.
-        stream = @client.follow(client_id: @client_id) { |event| queue << [:event, event] }
+        # A new worker (a restart) is followed, not lost: its sidecar is
+        # looked for whenever the stream drops.
+        stream = @client.follow(client_id: @client_id, rediscover: method(:live_worker),
+                                reconnect_delays: BridgeClient::EventStream::REDISCOVER_DELAYS) do |event|
+          queue << [:event, event]
+        end
         @reader = LineReader.new(queue, prompt: method(:prompt_text), read: input || method(:read_input_line),
                                         prefill: default_input_text).start
         loop do
@@ -280,6 +290,7 @@ module Samagotchi
         when :generation_completed
           @status.take_event(event)
           @renderer.call(event)
+        when :worker_changed then switch_worker(event)
         when :stream_closed
           @view.finish_thinking_spinner
           @screen.commit("Lost the session's worker (#{event[:reason]}). " \
@@ -292,6 +303,32 @@ module Samagotchi
 
       private
 
+      # The newest chi installed, looked at once, at the join.
+      def installed_version
+        @installed_version.call
+      rescue StandardError
+        nil
+      end
+
+      # The session's live worker for the stream to follow (EventStream's
+      # rediscover): nil while there is none yet, :gone once the session was
+      # stopped (no worker is coming).
+      def live_worker
+        id = @client.session_id
+        return :gone if Session.stopped_marker?(id)
+
+        BridgeClient.discover(id, session_dir: Session.session_dir(id), host: @client.host)
+      end
+
+      # The stream moved to a new worker (a restart): requests go there too.
+      def switch_worker(event)
+        @client = BridgeClient.new(session_id: @client.session_id, port: event[:port], host: @client.host)
+        @worker_changed = true
+        @view.finish_thinking_spinner
+        Log.info(:attached, "worker_changed", port: event[:port])
+        nil
+      end
+
       def next_item(queue)
         queue.pop
       rescue Interrupt
@@ -884,8 +921,13 @@ module Samagotchi
 
       def render_snapshot(snapshot, reset:)
         @view.finish_thinking_spinner
+        # A new worker's first snapshot is the session as it now stands.
+        moved = @worker_changed
+        reset ||= moved
+        @worker_changed = false
         if @attached
-          @screen.commit("(resynced with the session)") if reset
+          @screen.commit("(resynced with the session)") if reset && !moved
+          @screen.commit(paint(VersionLines.restarted(snapshot[:chi_version]), 2)) if moved
         else
           @attached = true
           # The recap first: what the session was about, then where it stopped.
@@ -894,6 +936,9 @@ module Samagotchi
           render_join_header(Array(snapshot[:messages]))
           @screen.commit("guardrails> #{snapshot[:guardrail_warning]}") if snapshot[:guardrail_warning]
           @screen.commit("plugins> #{snapshot[:plugin_warning]}") if snapshot[:plugin_warning]
+          version_line = VersionLines.at_attach(worker: snapshot[:chi_version], installed: installed_version,
+                                                session_id: @client.session_id)
+          @screen.commit(paint(version_line, 2)) if version_line
         end
         if snapshot[:commands]
           @command_registry = Commands::Registry.from_listing(snapshot[:commands], base: SessionCommands.builtin_registry)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -221,6 +221,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 +363,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 +386,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/image_input.rb

@@ -9,20 +9,27 @@ module Samagotchi
     # stays as typed; a token that isn't an image (a source file, a missing
     # path, an email address) is just text.
     #
-    #   @shot.png  @~/Desktop/a.jpg  @"my shot.png"  @'my shot.png'
+    #   @shot.png  @~/Desktop/a.jpg  @"my shot.png"  @'my shot.png'  @my\ shot.png
+    #
+    # A bare path takes backslash escapes the way a shell does (what a
+    # Finder drag into the terminal types): `\ ` is a space, `\(` a `(`.
     module ImageInput
-      # An @ at the start or after whitespace, then a quoted or bare path.
-      TOKEN_RE = /(?:\A|(?<=\s))@(?:"([^"]+)"|'([^']+)'|(\S+))/
+      # An @ at the start or after whitespace, then a quoted or bare path
+      # (a bare one runs on through backslash-escaped whitespace).
+      TOKEN_RE = /(?:\A|(?<=\s))@(?:"([^"]+)"|'([^']+)'|((?:\\\s|\S)+))/
 
       # @return [Array<Hash>] {path:} per image, in order, each path once
       def self.extract(text, cwd: Dir.pwd)
         text.to_s.scan(TOKEN_RE).filter_map do |quoted_double, quoted_single, bare|
-          raw = quoted_double || quoted_single || bare.sub(/[,.;:!?)\]]+\z/, "")
+          raw = quoted_double || quoted_single || unescape(bare.sub(/(?<!\\)[,.;:!?)\]]+\z/, ""))
           path = expand(raw, cwd)
           path if path && ImageStore.image_file?(path)
         end.uniq.map { |path| { path: path } }
       end
 
+      def self.unescape(bare) = bare.gsub(/\\(.)/m, '\\1')
+      private_class_method :unescape
+
       def self.expand(raw, cwd)
         return nil if raw.empty?
 

data/lib/samagotchi/terminal_ui/version_lines.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../installed_versions"
+require_relative "../version"
+
+module Samagotchi
+  class TerminalUI
+    # The line an attaching terminal shows when chi versions differ: the
+    # session's worker (its snapshot's chi_version), this terminal (VERSION)
+    # and the newest installed. Neither process can reload itself: the worker
+    # moves with `chi sessions restart`, the terminal by attaching again.
+    module VersionLines
+      module_function
+
+      # @param worker [String, nil] the worker's chi_version (nil: a worker
+      #   from before it said so; nothing is said then)
+      # @param installed [String, nil] InstalledVersions#newest
+      # @return [String, nil] one "chi> ..." line, or nil when all is current
+      def at_attach(worker:, installed:, session_id:, terminal: VERSION)
+        return nil if worker.to_s.empty?
+
+        newest = [installed, terminal].select { |v| Gem::Version.correct?(v.to_s) && !v.to_s.empty? }
+                                      .max_by { |v| Gem::Version.new(v) }
+        worker_old = InstalledVersions.newer?(newest, worker)
+        terminal_old = InstalledVersions.newer?(newest, terminal)
+        return nil unless worker_old || terminal_old
+
+        id = session_id.to_s[0, 8]
+        restart = "chi sessions restart #{id}"
+        attach = "/detach, then chi --attach #{id}"
+        if worker_old && terminal_old
+          "chi> chi #{newest} is installed; this session's worker runs #{worker} and this terminal #{terminal}. " \
+            "#{restart} moves the worker; #{attach} for the terminal."
+        elsif worker_old
+          "chi> chi #{newest} is installed; this session's worker runs #{worker}. #{restart} moves it there " \
+            "(this terminal follows)."
+        else
+          "chi> chi #{newest} is installed; this terminal runs #{terminal}. #{attach} to use it."
+        end
+      end
+
+      # After the stream moved to a new worker (a restart).
+      def restarted(worker)
+        worker.to_s.empty? ? "chi> the session's worker restarted" : "chi> the session's worker restarted on chi #{worker}"
+      end
+    end
+  end
+end

data/lib/samagotchi/token_usage.rb

@@ -1,61 +1,58 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  # TokenUsage extracts real server-reported token counts from a model API
-  # stream payload, transport-agnostically.
+  # TokenUsage is the server-reported token accounting of one model API stream
+  # payload, read transport-agnostically.
   #
   # llama.cpp's /completion stream emits per-chunk `timings.prompt_n` /
   # `timings.predicted_n` (cumulative) and a final top-level
-  # `tokens_evaluated` / `tokens_predicted`. mlx_lm.server (OpenAI-compatible)
-  # emits a `usage` object with `prompt_tokens` / `completion_tokens`.
+  # `tokens_evaluated` / `tokens_predicted`. OpenAI-compatible servers emit a
+  # `usage` object with `prompt_tokens` / `completion_tokens`.
   #
-  # Returns nil when no server token data is present, so a caller can fall back
-  # to a chars/4 heuristic. The reported values are cumulative per request, so
-  # callers should take the running MAX across chunks (see SessionMetrics).
-  class TokenUsage
+  # The last chunk can say more: llama.cpp adds a `timings` block with exact
+  # speeds and `cache_n` (its native `tokens_cached` counts the new tokens too,
+  # so it is not read); OpenRouter adds `usage.cost` (USD) and the
+  # `prompt_tokens_details.cached_tokens` / `completion_tokens_details.reasoning_tokens`
+  # breakdowns. Those fields are nil when a payload doesn't carry them.
+  #
+  # from_payload returns nil when no server token counts are present, so a
+  # caller can fall back to a chars/4 heuristic. The reported values are
+  # cumulative per request, so callers should take the running MAX across
+  # chunks (see SessionMetrics).
+  class TokenUsage < Data.define(:prompt_tokens, :completion_tokens, :cached_tokens, :reasoning_tokens, :cost,
+                                 :predicted_per_second, :prompt_per_second, :predicted_ms, :source)
     CHARS_PER_TOKEN = 4.0
 
     class << self
       # @param payload [Hash, nil] the raw streamed chunk payload
-      # @return [Hash, nil] { prompt_tokens:, completion_tokens:, source: :server }
+      # @return [TokenUsage, nil]
       def from_payload(payload)
         payload_hash = payload.is_a?(Hash) ? payload : {}
-        usage = payload_hash["usage"] || payload_hash[:usage]
-        usage = {} unless usage.is_a?(Hash)
+        usage = hash_at(payload_hash, :usage)
+        timings = hash_at(payload_hash, :timings)
 
         prompt_tokens = first_positive(
-          usage["prompt_tokens"],
-          usage[:prompt_tokens],
-          payload_hash["prompt_tokens"],
-          payload_hash[:prompt_tokens],
-          payload_hash["prompt_n"],
-          payload_hash[:prompt_n],
-          payload_hash["tokens_evaluated"],
-          payload_hash[:tokens_evaluated],
-          payload_hash.dig("timings", "prompt_n"),
-          payload_hash.dig(:timings, :prompt_n)
+          *both(usage, :prompt_tokens), *both(payload_hash, :prompt_tokens), *both(payload_hash, :prompt_n),
+          *both(payload_hash, :tokens_evaluated), *both(timings, :prompt_n)
         )
-
         completion_tokens = first_positive(
-          usage["completion_tokens"],
-          usage[:completion_tokens],
-          payload_hash["completion_tokens"],
-          payload_hash[:completion_tokens],
-          payload_hash["predicted_n"],
-          payload_hash[:predicted_n],
-          payload_hash["tokens_predicted"],
-          payload_hash[:tokens_predicted],
-          payload_hash.dig("timings", "predicted_n"),
-          payload_hash.dig(:timings, :predicted_n)
+          *both(usage, :completion_tokens), *both(payload_hash, :completion_tokens),
+          *both(payload_hash, :predicted_n), *both(payload_hash, :tokens_predicted), *both(timings, :predicted_n)
         )
-
         return nil unless prompt_tokens || completion_tokens
 
-        {
+        new(
           prompt_tokens: prompt_tokens,
           completion_tokens: completion_tokens,
+          cached_tokens: first_positive(*both(hash_at(usage, :prompt_tokens_details), :cached_tokens),
+                                        *both(timings, :cache_n)),
+          reasoning_tokens: first_positive(*both(hash_at(usage, :completion_tokens_details), :reasoning_tokens)),
+          cost: number(*both(usage, :cost)),
+          predicted_per_second: positive_number(*both(timings, :predicted_per_second)),
+          prompt_per_second: positive_number(*both(timings, :prompt_per_second)),
+          predicted_ms: positive_number(*both(timings, :predicted_ms)),
           source: :server
-        }
+        )
       end
 
       # Estimate token count from raw text length using the chars/4 heuristic.
@@ -73,16 +70,35 @@ module Samagotchi
       # float never raises RangeError; non-numeric values are skipped.
       def first_positive(*values)
         values.each do |value|
-          next if value.nil?
-
-          n = Float(value).to_i
-          return n if n.positive?
-        rescue ArgumentError, TypeError
-          next
+          n = float(value)&.to_i
+          return n if n&.positive?
         end
 
         nil
       end
+
+      private
+
+      def hash_at(hash, key)
+        value = hash[key.to_s] || hash[key]
+        value.is_a?(Hash) ? value : {}
+      end
+
+      def both(hash, key) = [hash[key.to_s], hash[key]]
+
+      def positive_number(*values) = values.filter_map { |value| float(value) }.find(&:positive?)
+
+      # A cost of 0 is a real answer (a free model), so zero counts here.
+      def number(*values) = values.filter_map { |value| float(value) }.find { |n| n >= 0 }
+
+      def float(value)
+        return nil if value.nil?
+
+        n = Float(value)
+        n.finite? ? n : nil
+      rescue ArgumentError, TypeError
+        nil
+      end
     end
   end
 end

data/lib/samagotchi/tool_runner.rb

@@ -44,6 +44,7 @@ module Samagotchi
     def run(call, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:)
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
       # The gate runs first, so tool_call_started shows the call that runs.
+      original = call.dup
       verdict = evaluate(call, iteration, params)
       call = verdict.call
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
@@ -73,6 +74,11 @@ module Samagotchi
       result, images = attach_images(call, result) if result[:images]
 
       output = scrub(result[:output].to_s)
+      # The gate may have replaced the call (known-names corrects a near
+      # miss): one leading line tells the model what actually ran.
+      if (changed = changed_call_line(original, call))
+        output = "#{changed}\n#{output}"
+      end
       capped = output
       truncated = false
       if max_tool_output_chars && output.length > max_tool_output_chars
@@ -84,14 +90,16 @@ module Samagotchi
       # full output: ok, error, blocked, stopped); a dispatcher that raised
       # left none, an error.
       status = result[:activity].is_a?(Hash) ? result[:activity][:status] : nil
-      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
-                               status: status || "error" })
       completed = { type: :tool_call_completed, iteration: iteration, call_count: call_count, call_index: call_index,
                     tool: call[:name], output: capped, output_truncated: truncated, activity: result[:activity] }
       completed[:images] = images if images&.any?
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
       emit(on_stream_event, completed)
+      # After the completed event: a hook's card (check-in, skills) prints
+      # under the call's tool row, not before it.
+      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
+                               status: status || "error" })
 
       run = { output: output, capped_output: capped, truncated: truncated, activity: result[:activity] }
       run[:images] = images if images&.any?
@@ -203,6 +211,17 @@ module Samagotchi
     # A plugin tool's label, what the UIs show for its raw name.
     def plugin_label(name) = ToolActivity.plugin_label(name, registry: tools)
 
+    # The one leading line the model gets when the gate changed the call it
+    # asked for: "ran as: <tool> <changed args>", or nil when nothing
+    # changed. The args are the changed call's activity params, so the line
+    # stays short.
+    def changed_call_line(original, call)
+      return nil if original == call
+
+      params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
+      ["ran as: #{call[:name]}", params].compact.join(" ")
+    end
+
     # The Engine sets the kernel's gate (its context, later the approval
     # flow); a bare kernel (specs) gets one that only runs the hooks.
     def gate

data/lib/samagotchi/tools/builtins.rb

@@ -22,6 +22,7 @@ require_relative "delegate"
 require_relative "delegate_result"
 require_relative "ask_user_question"
 require_relative "../guardrails/parent_approvals"
+require_relative "../model_profile"
 
 module Samagotchi
   module Tools
@@ -73,7 +74,8 @@ module Samagotchi
         TaskCreate::NAME => lambda do |call, kctx|
           next Execute::NOT_RUN_ON_STOP if cancelled_proc(kctx).call
 
-          TaskCreate.call(call[:content], cwd: call[:cwd], env: call[:env], marker_env: parent_env(kctx))
+          TaskCreate.call(call[:content], cwd: call[:cwd], env: call[:env],
+                          marker_env: task_marker_env(kctx, call[:env]))
         end,
         TaskWait::NAME => lambda do |call, kctx|
           TaskWait.call(call[:content], timeout: call[:timeout], tail_lines: call[:tail_lines],
@@ -108,17 +110,31 @@ module Samagotchi
       # wrapper. The session's id, "chi" without one. And the model the
       # session runs on (SAMAGOTCHI_SESSION_MODEL, read live, so right after
       # /model), which chi self reports; unset when unknown, so a value
-      # inherited from an outer session never passes for this one.
-      def parent_env(kctx)
+      # inherited from an outer session never passes for this one. A
+      # worker's `chi --model X` default (ModelProfile::MODEL_FROM_CLI_ENV)
+      # is unset: it was that run's, not the default of a chi run here.
+      def parent_env(kctx, env: ENV)
         peers = kctx.peers
         id = peers.respond_to?(:session_id) ? peers.session_id.to_s : ""
         model = peers.respond_to?(:model_ref) ? peers.model_ref.to_s : ""
-        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
-          SESSION_MODEL_ENV => model.empty? ? nil : model }
+        vars = { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
+                 SESSION_MODEL_ENV => model.empty? ? nil : model }
+        if env[ModelProfile::MODEL_FROM_CLI_ENV]
+          vars[ModelProfile::MODEL_ENV] = nil
+          vars[ModelProfile::MODEL_FROM_CLI_ENV] = nil
+        end
+        vars
       end
 
       SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
 
+      # task_create's parent_env, less the unsets of a variable the model
+      # set in its env (a SAMAGOTCHI_DEFAULT_MODEL it asked for stays).
+      def task_marker_env(kctx, env)
+        given = env.is_a?(Hash) ? env.keys.map(&:to_s) : []
+        parent_env(kctx).reject { |key, value| value.nil? && given.include?(key) }
+      end
+
       # Stop flips the turn's controller, seen through the Engine's PeerView
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)

data/lib/samagotchi/tools/execute.rb

@@ -199,22 +199,23 @@ module Samagotchi
         # thread; the text is safe to read afterwards.
         def finish
           @thread.join(STOP_POLL_INTERVAL_SEC) unless done?
-          Execute.send(:close_quietly, @io)
+          close_quietly
           @thread.kill unless @thread.join(STOP_GRACE_SEC)
         end
 
         def text
           @buffer.dup.force_encoding(@io.external_encoding || Encoding.default_external)
         end
-      end
-      private_constant :OutputReader
 
-      def self.close_quietly(io)
-        io.close unless io.closed?
-      rescue IOError
-        nil
+        private
+
+        def close_quietly
+          @io.close unless @io.closed?
+        rescue IOError
+          nil
+        end
       end
-      private_class_method :close_quietly
+      private_constant :OutputReader
 
       def self.terminate_process_tree(pid)
         signal_process(pid, "TERM")

data/lib/samagotchi/turn_note.rb

@@ -37,7 +37,8 @@ module Samagotchi
     # @param reason [Symbol, String, nil] the cancel reason (:ctrl_c, :user…)
     # @param seconds [Numeric, nil] how long the turn had run
     # @param shown [Boolean] visible text had streamed (an `[interrupted]`
-    #   model message precedes this note)
+    #   model message precedes this note): an answer, or only narration
+    #   before a tool call, so the note says "reply"
     # @param running_tasks [Array<Hash>] {id:, command:} of this session's
     #   background tasks still running: a Stop doesn't end them
     # @param stopped_by [Hash, nil] {by:, reason:} of a hook that stopped
@@ -45,7 +46,7 @@ module Samagotchi
     def cancelled(reason, seconds: nil, shown: false, running_tasks: [], stopped_by: nil)
       why = reason.to_s.empty? ? "" : " (#{reason.to_s.tr("_", "-")}#{stopper(stopped_by)})"
       after = seconds ? " after #{seconds.round}s" : ""
-      what = shown ? "the answer above ends where it was cut off." : "no answer had been shown."
+      what = shown ? "the reply above ends where it was cut off." : "no answer had been shown."
       message("the previous turn was cancelled#{why}#{after}; #{what}#{still_running(running_tasks)}")
     end
 

data/lib/samagotchi/update_command.rb

@@ -34,8 +34,9 @@ module Samagotchi
         --no-gem       don't install a newer gem (config update.gem: false)
         --no-bundles   leave the shipped bundles alone (config update.bundles: false)
         --no-desktop   leave the desktop helper alone (config update.desktop: false)
-        Running sessions keep their chi until they idle out (30 min) or
-        chi sessions stop ID; a running chi web needs a restart.
+        Running sessions keep their chi until restarted (chi sessions
+        restart ID) or until they idle out with nothing attached; a running
+        chi web needs a restart (the sessions it starts run the new chi).
     TEXT
 
     # Help is a flag here: it doesn't stop the parse (an unknown option
@@ -238,22 +239,42 @@ module Samagotchi
     def live_rows
       rows = []
       stale = LiveVersions.stale_workers(VERSION, state_dir: @state_dir)
-      unless stale.empty?
-        versions = stale.map { |w| w.version || "an older chi" }.uniq.join(", ")
-        ids = stale.map { |w| w.session_id[0, 8] }.join(" ")
-        rows << Row.new(component: "workers",
-                        status: "#{stale.size} live on #{versions}: they move to #{VERSION} at idle exit (30 min) " \
-                                "or chi sessions stop #{ids}")
-      end
+      rows << Row.new(component: "workers", status: workers_status(stale)) unless stale.empty?
       host, port = @web
-      web = LiveVersions.web_version(host, port)
-      if web && web != VERSION
+      info = LiveVersions.web_info(host, port)
+      web = info && info["version"].to_s
+      if web && !web.empty? && web != VERSION
+        # Since newest_workers, the sessions it starts run the newest chi.
+        spreads = !Array(info["features"]).include?("newest_workers")
         rows << Row.new(component: "chi web :#{port}", from: web,
-                        status: "running old code: new sessions it starts run #{web} too; restart it")
+                        status: "running old code#{": new sessions it starts run #{web} too" if spreads}; restart it")
       end
       rows
     end
 
+    # A worker keeps its chi until restarted: `chi sessions restart` for
+    # one that can, a stop for an older one (the next prompt starts it on
+    # the newest). It idles out on its own only with nothing attached.
+    def workers_status(stale)
+      versions = stale.map { |w| w.version || "an older chi" }.uniq.join(", ")
+      restart, stop = stale.partition(&:restart).map { |ws| ws.map { |w| w.session_id[0, 8] }.join(" ") }
+      moves = []
+      moves << "chi sessions restart #{restart}" unless restart.empty?
+      moves << "chi sessions stop #{stop}" unless stop.empty?
+      "#{stale.size} live on #{versions}: they keep it until restarted (#{moves.join("; ")})#{idle_note}"
+    end
+
+    def idle_note
+      minutes = begin
+        Config.get("session.idle_exit_minutes").to_f
+      rescue StandardError
+        30.0
+      end
+      return "; they never idle out (session.idle_exit_minutes: 0)" unless minutes.positive?
+
+      "; or they idle out after #{minutes.round(1).to_s.delete_suffix(".0")} min with nothing attached"
+    end
+
     def footers(options)
       return [] if off(options, "bundles")
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.18.1"
+  VERSION = "0.20.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end