samagotchi 0.4.0 → 0.5.0

data/lib/samagotchi/live_versions.rb

@@ -40,9 +40,15 @@ module Samagotchi
     # The version a chi web on host:port runs, or nil when nothing (or not
     # chi web) answers.
     def web_version(host, port, timeout: WEB_TIMEOUT)
+      web_info(host, port, timeout: timeout)&.fetch("version", nil).to_s.then { |v| v.empty? ? nil : v }
+    end
+
+    # The /api/info of a chi web on host:port, or nil when nothing (or not
+    # chi web) answers.
+    def web_info(host, port, timeout: WEB_TIMEOUT)
       response = Net::HTTP.start(host, port, open_timeout: timeout, read_timeout: timeout) { |http| http.get("/api/info") }
       info = response.code.to_i == 200 ? JSON.parse(response.body.to_s) : nil
-      info.is_a?(Hash) && info["app"] == "chi-web" ? info["version"].to_s : nil
+      info.is_a?(Hash) && info["app"] == "chi-web" ? info : nil
     rescue StandardError
       nil
     end

data/lib/samagotchi/llm/errors.rb

@@ -283,9 +283,26 @@ module Samagotchi
           return nil
         end
 
+        from_error_json(raw, host: host)
+      end
+
+      # The error a 200's whole body carries when it is a plain JSON error
+      # object instead of a stream (OpenRouter's "503 inside a 200":
+      # {"error":{"code":503,"message":"…"}}), or nil for anything else.
+      def from_error_body(body, host:)
+        parsed = parse_json(body.to_s)
+        return nil unless parsed.is_a?(Hash) && parsed.key?("error")
+
+        from_error_json(body.to_s, host: host)
+      end
+
+      # The ProviderError for a JSON error object, by its error.code (an HTTP
+      # status); 500 when it has none.
+      def from_error_json(raw, host:)
         parsed = parse_json(raw)
         error = parsed.is_a?(Hash) && parsed["error"].is_a?(Hash) ? parsed["error"] : parsed
         code = error.is_a?(Hash) ? error["code"] : nil
+        code = code.to_i if code.is_a?(String) && code.match?(/\A\d{3}\z/)
         status = code.is_a?(Integer) && code.between?(400, 599) ? code : 500
         from_response(status: status, body: raw, host: host)
       end

data/lib/samagotchi/llm/http.rb

@@ -21,9 +21,6 @@ module Samagotchi
     # the listener falls back to raising RequestCancelled in the requesting
     # thread, as Client did before.
     class HTTP
-      RETRY_MAX_ENV = "SAMAGOTCHI_RETRY_MAX"
-      RETRY_BASE_DELAY_ENV = "SAMAGOTCHI_RETRY_BASE_DELAY"
-      RETRY_MAX_DELAY_ENV = "SAMAGOTCHI_RETRY_MAX_DELAY"
       DEFAULT_RETRY_MAX = 5
       DEFAULT_RETRY_BASE_DELAY = 0.5
       DEFAULT_RETRY_MAX_DELAY = 8.0
@@ -46,15 +43,14 @@ module Samagotchi
       # Exponential backoff: base_delay * 2^(attempt-1), capped at max_delay,
       # for up to +max+ retries (max + 1 attempts).
       RetryPolicy = Data.define(:max, :base_delay, :max_delay) do
-        # retry.* from config, then the SAMAGOTCHI_RETRY_* env, then defaults.
+        # retry.* (Config); a value out of range is the default.
         def self.from_config
           new(
-            max: config_value("retry.max") { |v| v.is_a?(Integer) && v >= 0 } ||
-              env_integer(RETRY_MAX_ENV, DEFAULT_RETRY_MAX),
+            max: config_value("retry.max") { |v| v.is_a?(Integer) && v >= 0 } || DEFAULT_RETRY_MAX,
             base_delay: config_value("retry.base_delay") { |v| v.is_a?(Numeric) && v.positive? }&.to_f ||
-              env_float(RETRY_BASE_DELAY_ENV, DEFAULT_RETRY_BASE_DELAY),
+              DEFAULT_RETRY_BASE_DELAY,
             max_delay: config_value("retry.max_delay") { |v| v.is_a?(Numeric) && v.positive? }&.to_f ||
-              env_float(RETRY_MAX_DELAY_ENV, DEFAULT_RETRY_MAX_DELAY)
+              DEFAULT_RETRY_MAX_DELAY
           )
         end
 
@@ -67,16 +63,6 @@ module Samagotchi
           nil
         end
 
-        def self.env_integer(name, default)
-          value = ENV.fetch(name, default.to_s).to_i
-          value.negative? ? default : value
-        end
-
-        def self.env_float(name, default)
-          value = ENV.fetch(name, default.to_s).to_f
-          value.positive? ? value : default
-        end
-
         # Seconds to wait before retrying after failed attempt +attempt+
         # (1-based), or nil when the budget is spent.
         def delay_for(attempt)

data/lib/samagotchi/llm/openai_chat.rb

@@ -44,6 +44,8 @@ module Samagotchi
     # only; the chat loop owns the conversation and the tools.
     class OpenAIChat
       MAX_MODEL_PAGES = 20
+      # How much of a 200's non-stream body is read as a possible JSON error.
+      PLAIN_ERROR_LIMIT = 64 * 1024
       DEFAULT_MODELS_TTL = 60
 
       attr_reader :base_url, :host_name, :api_key_env, :models_ttl, :first_token_timeout
@@ -120,15 +122,18 @@ module Samagotchi
         assembly = Assembly.new
         events = 0
         other = +""
+        plain = +""
         # A retry streams the answer from the start again.
         restart = lambda do |**event|
           assembly = Assembly.new
+          plain = +""
           on_retry&.call(**event)
         end
         @http.stream_lines(URI(request.uri.to_s), request, cancel_controller: cancel_controller, on_retry: restart,
                                                            log_fields: log_fields) do |line, shown|
           events += 1 if line.start_with?("data:")
           other << line[0, 200] if !line.start_with?("data:") && other.length < 200
+          raise_plain_error(plain, line) if events.zero?
           payload = parse_line(line)
           next unless payload
 
@@ -256,6 +261,18 @@ module Samagotchi
 
       # The parsed payload of a `data:` line; nil for blank lines, comments
       # and [DONE]. Error events raise their ProviderError.
+      # A 200 whose body is a plain JSON error instead of a stream (OpenRouter
+      # sends an upstream 503 so): raised, from inside the stream so it is
+      # retried by its kind, once the lines so far parse as an error object.
+      def raise_plain_error(plain, line)
+        return if line.empty? || line.start_with?(":") || (plain.empty? && !line.start_with?("{"))
+        return if plain.bytesize > PLAIN_ERROR_LIMIT
+
+        plain << line << "\n"
+        error = ProviderErrors.from_error_body(plain, host: @host_name)
+        raise error if error
+      end
+
       def parse_line(line)
         error = HTTP.sse_error(line, host: @host_name)
         raise error if error

data/lib/samagotchi/model_profile.rb

@@ -116,18 +116,12 @@ module Samagotchi
       end
     end
 
-    def self.required_model_name(model_name = nil, env: ENV)
+    def self.required_model_name(model_name = nil)
       value = model_name.to_s.strip
       if value.empty?
-        begin
-          require_relative "config"
-          cfg = Samagotchi::Config.get("default.model") rescue nil
-          value = cfg.to_s.strip unless cfg.nil? || cfg.to_s.strip.empty?
-        rescue StandardError
-          nil
-        end
+        require_relative "config"
+        value = Samagotchi::Config.get("default.model").to_s.strip
       end
-      value = env[MODEL_ENV].to_s.strip if value.empty?
       raise MissingModel, missing_model_message if value.empty?
 
       value
@@ -181,7 +175,7 @@ module Samagotchi
     end
 
     def self.from_env
-      from_model_name(required_model_name(nil, env: ENV))
+      from_model_name(required_model_name(nil))
     end
 
     # ── Resolution: which profile a model gets ───────────────────────────

data/lib/samagotchi/note_command.rb

@@ -102,7 +102,8 @@ module Samagotchi
 
     # --all: every live session. @return [Integer] exit status
     def deliver_to_live(text, source)
-      ids = SessionManager.session_summaries(live: true, include_tests: false, state_dir: @state_dir).map { |s| s[:id] }
+      ids = SessionManager.session_summaries(live: true, include_tests: Session.test_session_env?,
+                                             state_dir: @state_dir).map { |s| s[:id] }
       if ids.empty?
         error_line("chi note: no live sessions (chi sessions list --live --scope=all)")
         return 1

data/lib/samagotchi/reply_wait.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "session"
+require_relative "turn_note"
 
 module Samagotchi
   # Loaded on first use: session_manager requires terminal_ui, which
@@ -23,7 +24,11 @@ module Samagotchi
     # @!attribute file [String, nil] the reply's filename, the next cursor
     # @!attribute question [Hash, nil] the pending question
     #   (:waiting_for_answer)
-    Result = Struct.new(:status, :text, :file, :question, keyword_init: true)
+    # @!attribute outcome [String, nil] how the turn ended when it left no
+    #   reply (:no_reply): "failed", "canceled" or "completed" (empty), from
+    #   the session's last_turn; nil when unknown. With "failed", text is
+    #   the failure's summary when the turn note has one.
+    Result = Struct.new(:status, :text, :file, :question, :outcome, keyword_init: true)
 
     module_function
 
@@ -38,7 +43,10 @@ module Samagotchi
     #   messages (a failed, canceled or empty one leaves its note) and went
     #   idle again ends the wait even if it was never seen running, and a
     #   question already pending then is not the answer's. A nil
-    #   messages: skips the count.
+    #   messages: skips the count. last_turn: (the session's
+    #   last_turn["ended_at"] then, maybe nil) ends the wait on any turn
+    #   that ended since, idle again, however fast it ran: a failure after
+    #   a failure replaces the note and leaves the count as it was.
     # @param owner_grace [Numeric, nil] seconds with no live worker before
     #   :worker_gone (one that died before its rescue leaves it running)
     # @return [Result]
@@ -72,13 +80,13 @@ module Samagotchi
 
         if session.status == Session::STATUS_RUNNING
           seen_running = true
-        elsif seen_running || (baseline&.dig(:messages) && session.messages.size > baseline[:messages])
+        elsif seen_running || turn_ended_since?(session, baseline)
           # It ran and is idle again with no new reply: canceled, failed or
           # empty. Before it was ever seen running, idle means a
           # file-delivered message its worker has not picked up yet.
           # The worker writes the reply before its idle save, so the read
           # above has it; one more look costs nothing should that change.
-          return reply_past(id, state_dir: state_dir, cursor: cursor) || Result.new(status: :no_reply)
+          return reply_past(id, state_dir: state_dir, cursor: cursor) || no_reply(session, baseline)
         end
 
         if owner_grace
@@ -95,6 +103,42 @@ module Samagotchi
       end
     end
 
+    # An idle session whose turn ended after the baseline was taken: its
+    # last_turn moved on, or its messages grew (a turn's note).
+    def turn_ended_since?(session, baseline)
+      return false unless baseline
+
+      if baseline.key?(:last_turn)
+        ended = session.last_turn.is_a?(Hash) ? session.last_turn["ended_at"] : nil
+        return true if ended && ended != baseline[:last_turn]
+      end
+      !!(baseline[:messages] && session.messages.size > baseline[:messages])
+    end
+
+    # @return [Result] :no_reply with the outcome the session's last_turn
+    #   records, when it is the turn waited for
+    def no_reply(session, baseline)
+      last = session.last_turn.is_a?(Hash) ? session.last_turn : {}
+      fresh = baseline.nil? || !baseline.key?(:last_turn) || (last["ended_at"] && last["ended_at"] != baseline[:last_turn])
+      outcome = fresh ? last["outcome"] : nil
+      text = outcome == "failed" ? failure_summary(session.messages) : nil
+      Result.new(status: :no_reply, outcome: outcome, text: text)
+    end
+
+    # The summary in the failed-turn note at the conversation's tail, nil
+    # without one.
+    def failure_summary(messages)
+      list = Array(messages)
+      index = TurnNote.trailing_index(list)
+      return nil unless index
+
+      text = (list[index][:content] || list[index]["content"]).to_s
+      prefix = "#{TurnNote::OPEN}#{TurnNote::FAILED}"
+      return nil unless text.start_with?(prefix)
+
+      text[prefix.length..].sub(/\. [^.]*\.\]\z/, "")
+    end
+
     # @return [Result, nil] :done with the newest reply past the cursor
     def reply_past(id, state_dir:, cursor:)
       file = newest_reply(id, state_dir: state_dir)

data/lib/samagotchi/self_report.rb

@@ -16,12 +16,15 @@ require_relative "memory_bundle/provenance"
 require_relative "memory_bundle/manifest"
 require_relative "memory_bundle/system_bundle"
 require_relative "desktop"
+require_relative "live_versions"
+require_relative "web/lan"
 
 module Samagotchi
   # `chi self`: where this chi lives and what it is configured to use.
   #
   # Read-only and nearly offline (one short /props GET for the served model,
-  # nothing else asks a model server), so the agent can run it via `execute`
+  # nothing else asks a model server; one /api/info GET on this machine's
+  # chi web port), so the agent can run it via `execute`
   # to orient itself — source dir to rg, config path, memory dirs, sessions,
   # model/host, bundle versions — without guessing from $PATH.
   module SelfReport
@@ -55,10 +58,25 @@ module Samagotchi
         ["served model", model ? served_model_for(model, env) : "-"],
         ["context window", context_window(env)],
         ["bundles", bundles_summary],
-        ["desktop", desktop_summary(env)]
+        ["desktop", desktop_summary(env)],
+        ["chi web", web_summary]
       ]
     end
 
+    WEB_TIMEOUT = 0.3
+
+    # Whether a chi web answers on this machine's web port, and whether a
+    # phone can reach it (LAN mode: /api/info's lan).
+    def web_summary
+      port = Config.get("web.port").to_i
+      port = 4567 unless port.positive?
+      info = LiveVersions.web_info(Web::Lan.local_host(Config.get("web.host")), port, timeout: WEB_TIMEOUT)
+      return "not running on port #{port}" unless info
+      return "LAN on #{info["lan"]}:#{port} (and 127.0.0.1)" if info["lan"]
+
+      "on 127.0.0.1:#{port} (this machine only)"
+    end
+
     # "git checkout" when running from a repo (bin/chi), "installed gem" when
     # under a gem path; the installed gem's files are not meant to be edited.
     def install_kind(dir = SOURCE_DIR)

data/lib/samagotchi/send_command.rb

@@ -5,6 +5,9 @@ require_relative "session_manager"
 require_relative "context_quote"
 require_relative "reply_wait"
 require_relative "image_store"
+require_relative "host_registry"
+require_relative "model_profile"
+require_relative "vision_support"
 
 module Samagotchi
   # `chi send`: put text into sessions as the user's message, the same as
@@ -36,7 +39,8 @@ module Samagotchi
                     an image sent with the message (png, jpeg, gif, webp;
                     others converted, large ones downscaled); repeat for
                     more, up to 20. Needs text too (-m or stdin) and a
-                    model that sees images
+                    model that sees images: a session whose model is
+                    known not to is refused before anything is sent
         --new       start a new session with the message instead, as the
                     web does, and print its id
         --dir DIR   (--new) its folder, the project it belongs to; default
@@ -54,6 +58,40 @@ module Samagotchi
         Find ids with: chi sessions list --live [--scope=all] [--format tsv]
     TEXT
 
+    # Whether +model_name+ (a session's; blank: the configured default)
+    # takes images, decided as its worker decides before a turn with images
+    # (Engine#turn_vision: VisionSupport, with models.<name>.vision under
+    # the name as given (maybe an alias), the alias's target, the part
+    # after a host prefix and the bare name, as after /model). A native
+    # host whose /props doesn't answer is unknown here, not a no: the
+    # worker asks again when the turn runs.
+    # @return [VisionSupport::Answer] value nil when unknown
+    def self.vision_answer(model_name, registry: nil)
+      registry ||= HostRegistry.new
+      name = ModelProfile.required_model_name(model_name)
+      aliased = ConfigFile.resolve_model_alias(name)
+      target = registry.resolve(aliased)
+      names = [name, aliased, registry.parse_qualified_model(name).last, target.bare_model].compact.uniq
+      entry = target.entry
+      return VisionSupport.for(target, adapter: registry.adapter_for(entry), names: names) if entry.chat?
+
+      profile = ModelProfile.resolve(names: names, entry: entry, client: target.client, bare_model: target.bare_model).profile
+      answer = VisionSupport.for(target, profile: profile, names: names)
+      props = target.client.respond_to?(:server_props) ? target.client.server_props(model: target.bare_model) : nil
+      return UNKNOWN_VISION if answer.no? && !props&.answered? && !configured_no?(answer)
+
+      answer
+    rescue StandardError
+      UNKNOWN_VISION
+    end
+
+    UNKNOWN_VISION = VisionSupport::Answer.new(value: nil, reason: nil)
+
+    # A no from the config (models: / hosts: vision: false) holds without
+    # the server.
+    def self.configured_no?(answer) = answer.reason.to_s.include?("sets vision: false")
+    private_class_method :configured_no?
+
     # @param argv [Array<String>] the arguments after "send"
     def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil)
       @argv = argv.dup
@@ -205,6 +243,10 @@ module Samagotchi
     # @return [Integer] the exit status
     def run_new(prompt, options)
       images = !@images.empty?
+      if images && (refusal = vision_refusal(options[:model]))
+        error_line("chi send: refused: #{refusal}")
+        return 1
+      end
       begin
         # With images the web's way: idle (the message names it in the
         # lists), the images copied in, then the message as a turn.
@@ -222,7 +264,7 @@ module Samagotchi
       end
       return 0 unless options[:wait]
 
-      wait_for_reply(session.id, cursor: nil, baseline: { messages: session.messages.size, question_id: nil },
+      wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
                                  timeout: options[:timeout])
     end
 
@@ -241,7 +283,7 @@ module Samagotchi
       end
 
       cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
-      baseline = { messages: session.messages.size, question_id: session.pending_question&.dig(:id) }
+      baseline = baseline_of(session)
       return 1 unless deliver(id, prompt)
 
       wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout])
@@ -260,10 +302,19 @@ module Samagotchi
       session = Session.load(id, state_dir: @state_dir)
       live = session.status == Session::STATUS_RUNNING || SessionManager.session_owner(id, state_dir: @state_dir)
       wait_for_reply(id, cursor: ReplyWait.newest_reply(id, state_dir: @state_dir),
-                         baseline: { messages: nil, question_id: session.pending_question&.dig(:id) },
+                         baseline: baseline_of(session).merge(messages: nil),
                          timeout: options[:timeout], owner_grace: live ? WORKER_GONE_AFTER : nil)
     end
 
+    # The session as it was before the message went in (ReplyWait's
+    # baseline): its messages, the question pending then, and when its last
+    # turn ended, so a turn that ends before the first look still ends the
+    # wait.
+    def baseline_of(session, question_id: session.pending_question&.dig(:id))
+      last = session.last_turn.is_a?(Hash) ? session.last_turn["ended_at"] : nil
+      { messages: session.messages.size, question_id: question_id, last_turn: last }
+    end
+
     # @return [Integer] the exit status
     def wait_for_reply(id, cursor:, baseline:, timeout:, owner_grace: WORKER_GONE_AFTER)
       result = ReplyWait.call(id, state_dir: @state_dir, cursor: cursor, timeout: timeout, baseline: baseline,
@@ -275,7 +326,7 @@ module Samagotchi
                      when :waiting_for_answer
                        question = result.question[:question].to_s.strip.lines.first.to_s.strip
                        ["waiting for an answer: #{question}; open it: #{attach} or the web", 3]
-                     when :no_reply then ["the turn ended without a reply (canceled, failed or empty); #{attach} shows it", 1]
+                     when :no_reply then ["#{no_reply_line(result)}; #{attach} shows it", 1]
                      when :error then ["the worker failed: #{result.text}; #{attach} shows what happened", 1]
                      when :worker_gone then ["the worker is gone; #{attach} shows what happened", 1]
                      when :stopped then ["the session was stopped (chi sessions stop)", 1]
@@ -291,6 +342,15 @@ module Samagotchi
       1
     end
 
+    def no_reply_line(result)
+      case result.outcome
+      when "failed" then result.text.to_s.strip.empty? ? "the turn failed" : "the turn failed: #{result.text.strip}"
+      when "canceled" then "the turn was canceled"
+      when "completed" then "the turn ended with no visible answer"
+      else "the turn ended without a reply (canceled, failed or empty)"
+      end
+    end
+
     def reply(text)
       @stdout.puts(utf8(text))
       @stdout.flush
@@ -332,8 +392,13 @@ module Samagotchi
     # @return [Boolean] whether the message was queued
     def deliver(id, prompt)
       short = id[0, 8]
+      session = Session.load(id, state_dir: @state_dir)
+      if !@images.empty? && (refusal = vision_refusal(session.model_name))
+        @info.puts("#{short}  refused: #{refusal}")
+        return false
+      end
       owner = SessionManager.session_owner(id, state_dir: @state_dir)
-      running = owner && Session.load(id, state_dir: @state_dir).status == Session::STATUS_RUNNING
+      running = owner && session.status == Session::STATUS_RUNNING
       refs = copy_images(Session.session_dir(id, state_dir: @state_dir))
       result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir)
       unless result[:status] == :accepted
@@ -356,6 +421,19 @@ module Samagotchi
       false
     end
 
+    # What to say when +model_name+ is known not to take images, or nil
+    # (it does, or it is unknown: sent as before). Asked once per model.
+    def vision_refusal(model_name)
+      @vision ||= {}
+      answer = @vision[model_name.to_s] ||= self.class.vision_answer(model_name)
+      return nil unless answer.no?
+
+      name = model_name.to_s.strip
+      name = Samagotchi::Config.get("default.model").to_s.strip if name.empty?
+      name = "the model" if name.empty?
+      "#{name} can't take images (#{answer.reason}); send text only or switch the model (/model)"
+    end
+
     # Each --image read, converted and downscaled once, into a scratch
     # session dir; each target then gets copies of the stored files. A file
     # that can't be sent stops everything before anything is sent.

data/lib/samagotchi/session.rb

@@ -22,11 +22,13 @@ module Samagotchi
     STATUS_ERROR = "error"
     STATUS_STOPPED = "stopped"
 
-    # Retention / ordering defaults (14 days, 500 sessions) — env overrides in SessionManager.
+    # Retention defaults, the session.retention_days / max_count /
+    # keep_status defaults (SessionManager resolves the settings).
     DEFAULT_RETENTION_DAYS = 14
     DEFAULT_MAX_COUNT = 500
     # status is turn state; a live owner (the prune alive_check) is what
-    # protects a session in use, so no status is kept by default.
+    # protects a session in use, so no status is kept by default: a
+    # "running" left by a crashed worker must not keep it forever.
     DEFAULT_KEEP_STATUS = [].freeze
     SORT_KEYS = %w[created_at updated_at].freeze
     SORT_ORDERS = %w[asc desc].freeze

data/lib/samagotchi/session_manager.rb

@@ -173,10 +173,10 @@ module Samagotchi
     end
 
     # Build the opts hash passed to Process.spawn for a forked worker. The
-    # child inherits this process's ENV; opts[:env] adds to it (merged, not
-    # replaced) the values a worker can't read from its own config: the
-    # hosts, default model and log settings as this `chi` resolved them
-    # (CLI flags included).
+    # child inherits this process's ENV and reads config.yml itself (as it
+    # is when the worker starts); opts[:env] adds to it (merged, not
+    # replaced) what it can't read there: this `chi`'s CLI settings
+    # (Config.cli_env), the hosts and the absolute log file.
     private_class_method def self.spawn_options(session)
       # Own process group: workers outlive `chi web`, and a Ctrl-C in its
       # terminal must not reach them.
@@ -198,11 +198,9 @@ module Samagotchi
       rescue StandardError
         nil
       end
-      # Also propagate current default model (may be host-qualified)
-      child_env["SAMAGOTCHI_DEFAULT_MODEL"] = ENV["SAMAGOTCHI_DEFAULT_MODEL"] if ENV["SAMAGOTCHI_DEFAULT_MODEL"]
-      # A worker gets no CLI args: pass on an idle exit set by any layer.
-      idle_exit = config_idle_exit_minutes
-      child_env["SAMAGOTCHI_SESSION_IDLE_EXIT_MINUTES"] = idle_exit.to_s unless idle_exit.nil?
+      # A worker gets no CLI args: --model, --thinking, --log-level and the
+      # other flags this chi was started with.
+      child_env.merge!(Config.cli_env)
       # And the spawner's debug log, absolute: a relative log.file would
       # otherwise land in the worker's (the session's) directory.
       log_path = begin LogPath.resolve rescue nil end
@@ -211,9 +209,6 @@ module Samagotchi
       else
         child_env["SAMAGOTCHI_LOG_DISABLE"] = "true"
       end
-      # And its level (a --log-level flag isn't in the worker's own config).
-      level = begin Config.get("log.level") rescue nil end
-      child_env["SAMAGOTCHI_LOG_LEVEL"] = level.to_s if level
       opts[:env] = child_env unless child_env.empty?
       opts
     end
@@ -246,7 +241,7 @@ module Samagotchi
     # @param include_archived [Boolean] archived sessions too
     # @return [Array<Hash>] {id:, short_id:, desc:, preview:, cwd:, project:,
     #   updated_at:, status:, live:, busy:, owner:, recap:, parent_id:,
-    #   parent_short_id:, archived:, scratch:}; busy = live with
+    #   parent_short_id:, archived:, scratch:, test_run:}; busy = live with
     #   a turn running, recap = the saved recap's first sentence, project =
     #   Session#project_root
     def self.session_summaries(live: false, cwd: nil, limit: nil, include_tests: true, exclude: nil, state_dir: nil,
@@ -268,7 +263,7 @@ module Samagotchi
           owner: owner, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
           ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd))&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), archived: s.archived,
-          scratch: s.scratch }
+          scratch: s.scratch, test_run: s.test_run }
       end
       (limit ? summaries.first(limit) : summaries.to_a)
     end
@@ -455,12 +450,8 @@ module Samagotchi
       sd = state_dir || Session.default_state_dir
       return unless Dir.exist?(sd)
 
-      cfg_interval = begin Samagotchi::Config.get("session.sweep_interval_hours") rescue nil end
-      interval = if cfg_interval && cfg_interval.to_i.positive?
-                   cfg_interval.to_i * 3600
-                 else
-                   (ENV.fetch("SAMAGOTCHI_SESSION_SWEEP_INTERVAL_HOURS", RETENTION_SWEEP_INTERVAL_HOURS.to_s).to_i * 3600)
-                 end
+      hours = Samagotchi::Config.get("session.sweep_interval_hours").to_i
+      interval = (hours.positive? ? hours : RETENTION_SWEEP_INTERVAL_HOURS) * 3600
       marker = File.join(sd, RETENTION_MARKER)
       if File.exist?(marker)
         age = Time.now - File.mtime(marker)
@@ -477,32 +468,22 @@ module Samagotchi
       nil
     end
 
+    # The caller's value (a sessions prune flag) or session.retention_days.
     private_class_method def self.resolve_retention_days(val)
       return val.to_i if !val.nil? && val.to_s.strip != ""
-      cfg = begin Samagotchi::Config.get("session.retention_days") rescue nil end
-      return cfg.to_i if cfg && !cfg.to_s.strip.empty?
-      env = ENV["SAMAGOTCHI_SESSION_RETENTION_DAYS"]
-      return env.to_i if env && !env.strip.empty?
-      Session::DEFAULT_RETENTION_DAYS
+
+      Samagotchi::Config.get("session.retention_days").to_i
     end
 
     private_class_method def self.resolve_retention_max_count(val)
       return val.to_i if !val.nil? && val.to_s.strip != ""
-      cfg = begin Samagotchi::Config.get("session.max_count") rescue nil end
-      return cfg.to_i if cfg && !cfg.to_s.strip.empty?
-      env = ENV["SAMAGOTCHI_SESSION_MAX_COUNT"]
-      return env.to_i if env && !env.strip.empty?
-      Session::DEFAULT_MAX_COUNT
+
+      Samagotchi::Config.get("session.max_count").to_i
     end
 
+    # A comma list of statuses never pruned; "" keeps none.
     private_class_method def self.resolve_retention_keep_status(val)
-      raw = if !val.nil? && val.to_s.strip != ""
-              val.to_s
-            else
-              cfg = begin Samagotchi::Config.get("session.keep_status") rescue nil end
-              cfg && !cfg.to_s.strip.empty? ? cfg.to_s : (ENV["SAMAGOTCHI_SESSION_KEEP_STATUS"] || ENV["SAMAGOTCHI_SESSION_RETENTION_KEEP_STATUS"])
-            end
-      return Session::DEFAULT_KEEP_STATUS if raw.nil? || raw.strip.empty?
+      raw = !val.nil? && val.to_s.strip != "" ? val.to_s : Samagotchi::Config.get("session.keep_status").to_s
       raw.split(",").map(&:strip).reject(&:empty?)
     end