samagotchi 0.18.0 → 0.19.0

data/lib/samagotchi/terminal_ui/one_shot_sink.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "formatting"
+require_relative "event_renderer"
+
+module Samagotchi
+  class TerminalUI
+    # The turn sink of `chi -p … --non-interactive` (Engine#run_turn's
+    # on_event): the few lines a reader wants while the turn runs, on
+    # stderr. stdout is the answer's alone, printed after the turn: a
+    # script or a parent agent reads it.
+    #
+    # It prints the retry lines the REPL shows: the loop asking again after
+    # an empty answer (:empty_answer_retry), and a generation retried after
+    # a failed request (:generation_retrying). And the hooks' notices
+    # (:hook_notice): one during the turn as it comes, one the after_turn
+    # hooks give (after :turn_completed; source-links' `sources:`) kept for
+    # #flush, which the caller runs after it has printed the answer.
+    class OneShotSink
+      include Formatting
+
+      # @param err [IO, nil] nil writes to $stderr as it is at each write
+      def initialize(err: nil)
+        @err = err
+        @turn_over = false
+        @held = []
+      end
+
+      def call(event)
+        case event[:type]
+        when :empty_answer_retry then line(format_empty_retry_line(event))
+        when :generation_retrying then line(format_generation_retry_line(event))
+        when :turn_completed, :turn_canceled then @turn_over = true
+        when :hook_notice
+          text = EventRenderer.hook_notice_line(event)
+          @turn_over ? @held << text : line(text)
+        end
+      end
+
+      # Print the notices that came after the turn's end.
+      def flush
+        line(@held.shift) until @held.empty?
+      end
+
+      private
+
+      def line(text)
+        err.puts(text)
+        err.flush
+      end
+
+      def err = @err || $stderr
+
+      # Colour when stderr, where the lines go, is a colour terminal.
+      def color_output?
+        return false unless err.tty?
+        return false if ENV.key?("NO_COLOR")
+
+        ENV.fetch("TERM", "") != "dumb"
+      end
+    end
+  end
+end

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/terminal_ui.rb

@@ -30,6 +30,7 @@ require_relative "terminal_ui/input_support"
 require_relative "terminal_ui/image_input"
 require_relative "terminal_ui/plain_surface"
 require_relative "terminal_ui/live_region"
+require_relative "terminal_ui/one_shot_sink"
 require_relative "terminal_ui/question_prompt"
 require_relative "terminal_ui/repl_input"
 require_relative "terminal_ui/status_row"
@@ -210,7 +211,9 @@ module Samagotchi
     # follow-up REPL (--non-interactive) or drops into the REPL carrying the
     # post-turn conversation.
     # @return [Symbol, nil] :turn_failed when lines came from a pipe and a
-    #   turn failed (bin/chi exits 1)
+    #   turn failed, :empty_answer when a -p --non-interactive turn ended
+    #   with no answer (bin/chi exits 1 on both), :interrupted when Ctrl-C
+    #   cancelled that turn (bin/chi exits 130)
     def run
       # --non-interactive with no --prompt is a harmless no-op exit: build
       # nothing and return (no transient session, no banner).
@@ -240,25 +243,36 @@ module Samagotchi
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
-        result = @engine.run_turn(
-          session,
-          @prompt,
-          on_event: nil,
-          max_iterations: IterationLimit.for(no_interrupt: true),
-          cancel_controller: nil,
-          images: ImageInput.extract(@prompt)
-        )
+        # Retry lines and hook notices on stderr; stdout gets the answer below.
+        sink = OneShotSink.new
+        begin
+          result = @engine.run_turn(
+            session,
+            @prompt,
+            on_event: sink,
+            max_iterations: IterationLimit.for(no_interrupt: true),
+            cancel_controller: nil,
+            images: ImageInput.extract(@prompt)
+          )
+        rescue LLM::ProviderError, ImageStore::Error => e
+          return one_shot_failed(session, e)
+        rescue Interrupt
+          return one_shot_interrupted(session)
+        end
         # No answer (the empty-answer retries used up): no text, or the chat
         # loop's placeholder (LLM::ModelResult#empty_answer?).
         if result.empty_answer?
-          # Nothing to print: say so on stderr and fail, so a script that
-          # pipes the answer doesn't take the silence for one.
+          # Nothing to print: say so on stderr and fail (bin/chi exits 1),
+          # so a script that pipes the answer doesn't take the silence for one.
           session.save
           warn EMPTY_ANSWER_ERROR
-          exit 1
+          sink.flush
+          return :empty_answer
         end
         @surface.commit(result.output)
         session.save
+        # The after_turn hooks' notices, after the answer as the REPL shows them.
+        sink.flush
         return
       end
 
@@ -286,6 +300,18 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
+    # A -p --non-interactive turn that failed (bin/chi exits 1): the error,
+    # then how to go on. The Engine saved the failed turn with its prompt,
+    # so the session is kept and `chi --resume` takes it up again.
+    # @return [Symbol] :turn_failed
+    def one_shot_failed(session, error)
+      warn "Error: #{error.respond_to?(:summary) ? error.summary : error.message}"
+      if !@scratch && Session.exist?(session.id)
+        warn "chi: the session is kept with your prompt; continue it with: chi --resume #{session.id}"
+      end
+      :turn_failed
+    end
+
     # `chi -p "/models" --non-interactive`: the command's output; a refused
     # one fails the run (bin/chi exits 1). The session is saved only when
     # the command changed it.
@@ -302,6 +328,19 @@ module Samagotchi
       :turn_failed if result.status == :error
     end
 
+    # Ctrl-C in a -p --non-interactive turn: the Engine kept the prompt and
+    # a cancel note in the session (it saves only a failed turn), so save
+    # it here: `chi --resume` takes it up again. A scratch session goes in
+    # #run's ensure, so there is nothing to keep.
+    # @return [Symbol] :interrupted
+    def one_shot_interrupted(session)
+      return :interrupted if @scratch
+
+      session.save
+      warn "chi: canceled (Ctrl-C); the session is kept: continue it with chi --resume #{session.id}"
+      :interrupted
+    end
+
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -400,19 +439,29 @@ module Samagotchi
       system_message = { role: "system", content: seed_system_prompt }
       if @resume_session
         messages = ContextNote.with_system_head(session.messages.dup, system_message)
-        @surface.commit("Resumed session: #{session.id}")
+        banner("Resumed session: #{session.id}")
         saved = @engine.saved_recap
-        @surface.commit(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
+        banner(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
       elsif @scratch
         messages = [system_message]
-        @surface.commit("Scratch session: nothing is kept, it is deleted when you leave.")
+        banner("Scratch session: nothing is kept, it is deleted when you leave.")
       else
         messages = [system_message]
-        @surface.commit("Session: #{session.id}")
+        banner("Session: #{session.id}")
       end
       messages
     end
 
+    # A line about the session, not the answer: on stderr in a
+    # --non-interactive run, whose stdout is the answer's alone (a script
+    # or a parent agent reads it), and before the turn, so it comes first.
+    def banner(text)
+      return @surface.commit(text) unless @non_interactive
+
+      $stderr.puts(text)
+      $stderr.flush
+    end
+
     # Interactive REPL loop. Session seed + messages are built by #run and
     # threaded in here (so --prompt / --resume share one code path). The
     # session's conversation is the single working copy: turns go through

data/lib/samagotchi/tool_declarations.rb

@@ -18,7 +18,7 @@ module Samagotchi
     TOOL_SCHEMAS = [
       {
         name: "execute",
-        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata.",
+        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata. Don't background with &; use task_create.",
         parameters: {
           type: "object",
           properties: {
@@ -153,7 +153,7 @@ module Samagotchi
       },
       {
         name: "task_create",
-        description: "Start a background task for a long-running shell command. Returns task id and output path for later inspection.",
+        description: "Start a background task for a long-running shell command. Servers and anything meant to keep running belong here, not in execute with &. Returns task id and output path for later inspection.",
         parameters: {
           type: "object",
           properties: {

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

@@ -21,6 +21,15 @@ module Samagotchi
       WAIT_SLICE_SEC = 0.2
       NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
       TIMEOUT_HINT = "(killed at the limit; for a long command use task_create, then task_wait)"
+      # How long the output may stay open once the shell has exited: a
+      # `server &` child keeps the pipes, and the read would never end.
+      BACKGROUND_GRACE_SEC = 1.5
+      BACKGROUND_HINT = "(a background process kept the output open and was stopped; " \
+                        "to keep a server or long job running, start it with task_create)"
+      # It had left the process group (setsid), so it is still running.
+      BACKGROUND_DETACHED_HINT = "(a background process kept the output open and was left running; " \
+                                 "to keep a server or long job running, start it with task_create)"
+      READ_CHUNK_BYTES = 65_536
 
       def self.name        = NAME
 
@@ -35,7 +44,7 @@ module Samagotchi
         return "Error: cwd not found: #{resolved_cwd}" unless resolved_cwd
 
         timeout_sec = timeout_seconds
-        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
+        stdout, stderr, status, held_open = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
                                                       env: env)
 
         stdout_block = output_block("stdout", stdout)
@@ -50,6 +59,7 @@ module Samagotchi
         # model as "done, something happened".
         silent = stdout_block.nil? && stderr_block.nil?
         parts << (silent ? "exit: #{status.exitstatus} (no output)" : "exit: #{status.exitstatus}")
+        parts << (held_open == :detached ? BACKGROUND_DETACHED_HINT : BACKGROUND_HINT) if held_open
         parts.join("\n")
       rescue CommandTimedOut => e
         # Keep the "Error:" first line (callers classify on it), say how to run
@@ -75,13 +85,14 @@ module Samagotchi
         status = nil
         timed_out = false
         was_cancelled = false
+        aborted = false
+        held_open = false
         started = monotonic_time
         deadline = started + timeout_sec
 
         Open3.popen3(env || {}, command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
-          stdout_reader = reader_thread_for(stdout)
-          stderr_reader = reader_thread_for(stderr)
+          readers = [OutputReader.new(stdout), OutputReader.new(stderr)]
 
           begin
             until wait_thr.join(WAIT_SLICE_SEC)
@@ -100,36 +111,103 @@ module Samagotchi
             # An Interrupt (or anything else) mid-wait: the child is in its own
             # process group, so it never saw the SIGINT. Kill it, or the reads
             # below block until it closes stdout.
+            aborted = true
             terminate_process_tree(wait_thr.pid)
             raise
           ensure
-            # Read the buffered output before closing the pipes. For a process
-            # that exits almost instantly (e.g. `echo hello`), the background
-            # reader thread may not have scheduled its `io.read` yet; joining
-            # the reader after the pipe is closed would return "".
-            stdout_text = stdout_reader.value
-            stderr_text = stderr_reader.value
-            close_quietly(stdout)
-            close_quietly(stderr)
+            # The shell is gone, but a child it put in the background (`cmd &`)
+            # may still hold the pipes: wait for EOF a short grace only, then
+            # stop the command's process group and keep the output so far.
+            # Already stopped (timeout, Stop, an exception): no more checks.
+            stopping = timed_out || was_cancelled || aborted
+            outcome = await_readers(readers, until_time: monotonic_time + BACKGROUND_GRACE_SEC,
+                                             deadline: stopping ? nil : deadline,
+                                             cancelled: stopping ? -> { false } : cancelled)
+            unless outcome == :done
+              was_cancelled = true if outcome == :cancelled
+              timed_out = true if outcome == :timeout
+              stopped = stop_process_group(wait_thr.pid, readers)
+              held_open = (stopped ? :stopped : :detached) if outcome == :grace && !stopping
+            end
+            readers.each(&:finish)
+            stdout_text, stderr_text = readers.map(&:text)
           end
         end
 
         raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
         raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
 
-        [stdout_text, stderr_text, status]
+        [stdout_text, stderr_text, status, held_open]
       end
       private_class_method :run_command
 
-      def self.reader_thread_for(io)
-        Thread.new do
-          Thread.current.report_on_exception = false
-          io.read.to_s
-        rescue IOError, EOFError
-          ""
+      # Waits for both readers to hit EOF until +until_time+, the overall
+      # +deadline+ or a Stop. Returns :done, :grace, :timeout or :cancelled.
+      def self.await_readers(readers, until_time:, deadline:, cancelled:)
+        loop do
+          return :done if readers.all?(&:done?)
+          return :cancelled if cancelled.call
+          return :timeout if deadline && monotonic_time > deadline
+          return :grace if monotonic_time > until_time
+
+          readers.find { |r| !r.done? }&.wait(STOP_POLL_INTERVAL_SEC)
+        end
+      end
+      private_class_method :await_readers
+
+      # The shell has exited (its pid is reaped) but its process group still
+      # has members holding the output: TERM the group, then KILL it. A process
+      # that left the group (setsid) is out of reach; the pipes get closed.
+      # True once the output was released, false if something still holds it.
+      def self.stop_process_group(pgid, readers)
+        signal_group(pgid, "TERM")
+        return true if await_readers(readers, until_time: monotonic_time + STOP_GRACE_SEC, deadline: nil,
+                                              cancelled: -> { false }) == :done
+
+        signal_group(pgid, "KILL")
+        await_readers(readers, until_time: monotonic_time + STOP_GRACE_SEC, deadline: nil, cancelled: -> { false }) == :done
+      end
+      private_class_method :stop_process_group
+
+      # Only the group: the leader's pid is reaped, so it may name another process.
+      def self.signal_group(pgid, signal)
+        Process.kill(signal, -pgid)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+      private_class_method :signal_group
+
+      # Reads a pipe in chunks on its own thread, so the output read so far
+      # survives the pipe being closed under it.
+      class OutputReader
+        def initialize(io)
+          @io = io
+          @buffer = String.new(encoding: Encoding::BINARY)
+          @thread = Thread.new do
+            Thread.current.report_on_exception = false
+            loop { @buffer << io.readpartial(READ_CHUNK_BYTES) }
+          rescue EOFError, IOError
+            nil
+          end
+        end
+
+        def done? = !@thread.alive?
+
+        def wait(seconds) = @thread.join(seconds)
+
+        # Closes the pipe (a reader still blocked gets IOError) and ends the
+        # thread; the text is safe to read afterwards.
+        def finish
+          @thread.join(STOP_POLL_INTERVAL_SEC) unless done?
+          Execute.send(:close_quietly, @io)
+          @thread.kill unless @thread.join(STOP_GRACE_SEC)
+        end
+
+        def text
+          @buffer.dup.force_encoding(@io.external_encoding || Encoding.default_external)
         end
       end
-      private_class_method :reader_thread_for
+      private_constant :OutputReader
 
       def self.close_quietly(io)
         io.close unless io.closed?

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.0"
+  VERSION = "0.19.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end