samagotchi 0.3.0 → 0.5.0

data/lib/samagotchi/config.rb

@@ -8,6 +8,9 @@ require "set"
 require_relative "log"
 
 module Samagotchi
+  # Parses the thinking: levels of host and model entries (it needs Config).
+  autoload :Thinking, File.expand_path("thinking", __dir__)
+
   # Unified configuration registry implementing the implicit convention:
   #   ENV    SAMAGOTCHI_ATTR            (UPPER + prefix + _ = nesting)
   #   YAML   attr: / nested: {param:}   (lower snake, dot = nesting, Option A leaf keeps _)
@@ -22,7 +25,7 @@ module Samagotchi
   # handled by ConfigFile (same file, below), which reads the *same* parsed YAML
   # through ConfigFile.read_yaml so the file is parsed once per change.
   module Config
-    Entry = Struct.new(:key, :yaml_path, :type, :default, :expose, :enum_values, :aliases, :yaml_aliases, keyword_init: true) do
+    Entry = Struct.new(:key, :yaml_path, :type, :default, :expose, :enum_values, :yaml_aliases, keyword_init: true) do
       def env_key
         "SAMAGOTCHI_" + yaml_path.map { |p| p.upcase }.join("_")
       end
@@ -80,7 +83,7 @@ module Samagotchi
 
       Entry.new(key: "session.retention_days",        yaml_path: %w[session retention_days],        type: :integer, default: 14,   expose: %i[env config cli]),
       Entry.new(key: "session.max_count",             yaml_path: %w[session max_count],             type: :integer, default: 500,  expose: %i[env config cli]),
-      Entry.new(key: "session.keep_status",           yaml_path: %w[session keep_status],           type: :string, default: "running", expose: %i[env config cli]),
+      Entry.new(key: "session.keep_status",           yaml_path: %w[session keep_status],           type: :string, default: "", expose: %i[env config cli]),
       Entry.new(key: "session.sweep_interval_hours",  yaml_path: %w[session sweep_interval_hours],  type: :integer, default: 24,   expose: %i[env config cli]),
       Entry.new(key: "session.idle_exit_minutes",     yaml_path: %w[session idle_exit_minutes],     type: :float,   default: 30.0, expose: %i[env config cli]),
       # Plain `chi` runs like `chi --shared` (bin/chi, LaunchMode); false, or --no-shared per run, keeps the plain REPL. No CLI flag: that would duplicate --shared.
@@ -105,9 +108,6 @@ module Samagotchi
       Entry.new(key: "log.level",                yaml_path: %w[log level],                type: :enum,   default: "info",           expose: %i[env config cli], enum_values: %w[debug info warn error]),
 
       Entry.new(key: "status.line",              yaml_path: %w[status line],              type: :string, default: "on",             expose: %i[env config cli]),
-      Entry.new(key: "status.width_mode",        yaml_path: %w[status width_mode],        type: :string, default: "terminal_cap",   expose: %i[env config cli]),
-      Entry.new(key: "status.max_width",         yaml_path: %w[status max_width],         type: :integer, default: 160,             expose: %i[env config cli]),
-      Entry.new(key: "status.fixed_width",       yaml_path: %w[status fixed_width],       type: :integer, default: 120,             expose: %i[env config cli]),
 
       Entry.new(key: "context.status",           yaml_path: %w[context status],           type: :bool,   default: true,             expose: %i[env config cli]),
       Entry.new(key: "context.window_tokens",    yaml_path: %w[context window_tokens],    type: :integer, default: nil,             expose: %i[env config cli]),
@@ -115,9 +115,12 @@ module Samagotchi
       Entry.new(key: "context.status_thresholds", yaml_path: %w[context status_thresholds],type: :string, default: "20,40,60,80",    expose: %i[env config cli]),
       Entry.new(key: "context.status_cadence",   yaml_path: %w[context status_cadence],   type: :integer, default: 0,               expose: %i[env config cli]),
 
-      Entry.new(key: "thinking.ui",              yaml_path: %w[thinking ui],              type: :string, default: nil,              expose: %i[env config cli]),
-      Entry.new(key: "thinking.render_interval", yaml_path: %w[thinking render_interval], type: :float,   default: 0.08,            expose: %i[env config cli]),
       Entry.new(key: "thinking.turn_preamble",   yaml_path: %w[thinking turn_preamble],   type: :bool,   default: true,             expose: %i[env config cli]),
+      # How much models think: off|low|medium|high|default, parsed by Thinking
+      # (a :string, since YAML reads an unquoted off as false). The CLI flag
+      # is bin/chi's own --thinking; models: and hosts: entries rank below
+      # the flag and the env, above config.yml's value.
+      Entry.new(key: "thinking.level",           yaml_path: %w[thinking level],           type: :string, default: "default",       expose: %i[env config]),
 
       Entry.new(key: "default.n_predict",        yaml_path: %w[default n_predict],        type: :integer, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "max_tool_output_chars",    yaml_path: %w[max_tool_output_chars],    type: :integer, default: 10_000,          expose: %i[env config cli]),
@@ -128,6 +131,10 @@ module Samagotchi
       # Asks again in the same turn after an empty answer (EmptyAnswerRetry);
       # 0 = off, capped at 3. No CLI flag: workers get no CLI args.
       Entry.new(key: "retry.empty_answer",       yaml_path: %w[retry empty_answer],       type: :integer, default: 1,               expose: %i[env config]),
+      # What `chi update` touches; its --no-gem/--no-bundles/--no-desktop turn one off for a run.
+      Entry.new(key: "update.gem",               yaml_path: %w[update gem],               type: :bool,    default: true,            expose: %i[env config]),
+      Entry.new(key: "update.bundles",           yaml_path: %w[update bundles],           type: :bool,    default: true,            expose: %i[env config]),
+      Entry.new(key: "update.desktop",           yaml_path: %w[update desktop],           type: :bool,    default: true,            expose: %i[env config]),
 
       Entry.new(key: "read.truncate_at_bytes",        yaml_path: %w[read truncate_at_bytes],        type: :integer, default: 65_536,   expose: %i[env config cli]),
       Entry.new(key: "read.preview_bytes",            yaml_path: %w[read preview_bytes],            type: :integer, default: 12_288,   expose: %i[env config cli]),
@@ -141,8 +148,8 @@ module Samagotchi
       Entry.new(key: "web.port",                 yaml_path: %w[web port],                 type: :integer, default: 4567,            expose: %i[env config cli]),
       Entry.new(key: "web.host",                 yaml_path: %w[web host],                 type: :string, default: "127.0.0.1",     expose: %i[env config cli]),
       Entry.new(key: "web.markdown",             yaml_path: %w[web markdown],             type: :bool,    default: false,           expose: %i[env config cli]),
-      # The page shows each turn as one block of generations (the live one at the bottom); false brings back the row of bubbles; ?view=turn|chat overrides it per page load.
-      Entry.new(key: "web.turn_view",            yaml_path: %w[web turn_view],            type: :bool,    default: true,           expose: %i[env config cli]),
+      # The page's view of a turn: turn (one block of generations, the live one at the bottom), stage (the running turn pinned above the composer) or chat (a row of bubbles); ?view= overrides it per page load.
+      Entry.new(key: "web.view",                 yaml_path: %w[web view],                 type: :enum,    default: "turn",         expose: %i[env config cli], enum_values: %w[turn stage chat]),
       # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
       Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli]),
 
@@ -162,33 +169,24 @@ module Samagotchi
     # Maps of named entries and the keys an entry may hold
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
-      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling enabled].freeze,
-      "models" => %w[profile vision sampling].freeze
+      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled].freeze,
+      "models" => %w[profile vision sampling thinking].freeze
     }.freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
-    # Removed settings that warn on their own (Engine.warn_removed_backend_setting).
-    REMOVED_KEYS = %w[backend].freeze
 
     # Fast lookup maps
     BY_KEY = ENTRIES.each_with_object({}) { |e, h| h[e.key] = e }.freeze
-    BY_ENV = ENTRIES.each_with_object({}) do |e, h|
-      h[e.env_key] = e
-      Array(e.aliases).each { |a| h[a] = e }
-    end.freeze
-    BY_CLI = ENTRIES.each_with_object({}) { |e, h| h[e.cli_flag] = e if e.cli_exposed? }.freeze
 
     class << self
-      def find_by_key(key)
-        BY_KEY[key.to_s]
-      end
-
-      def find_by_env(env_key)
-        BY_ENV[env_key.to_s]
+      # The +candidates+ within edit distance 2 of +probe+, closest first
+      # (the "did you mean" of an unknown key or host).
+      def near_names(probe, candidates)
+        candidates.uniq.map { |c| [levenshtein(probe, c), c] }.select { |d, _| d <= 2 }.sort.map(&:last)
       end
 
-      def find_by_cli(flag)
-        BY_CLI[flag.to_s]
+      def find_by_key(key)
+        BY_KEY[key.to_s]
       end
 
       def all_entries
@@ -306,26 +304,10 @@ module Samagotchi
       end
 
       # Lookup yaml_path in nested hash, accepting snake leaf, kebab alias and
-      # entry-specific yaml_aliases, then legacy flat UPPER keys (e.g.,
-      # SAMAGOTCHI_DEFAULT_MODEL) for transition: the nested key wins when a
-      # file has both (ConfigFile.load_global_env! warns about that).
+      # entry-specific yaml_aliases.
       def lookup_yaml(data, yaml_path)
         entry = ENTRIES.find { |e| e.yaml_path == yaml_path }
-        nested = lookup_nested(data, yaml_path, entry)
-        return nested unless nested.nil?
-
-        lookup_legacy(data, entry)
-      end
-
-      # The legacy flat key's value for +entry+, or nil.
-      def lookup_legacy(data, entry)
-        return nil unless entry && data.is_a?(Hash)
-
-        [entry.env_key, *Array(entry.aliases)].each do |key|
-          return data[key] if data.key?(key)
-          return data[key.to_sym] if data.key?(key.to_sym)
-        end
-        nil
+        lookup_nested(data, yaml_path, entry)
       end
 
       # The nested key's value for +yaml_path+, or nil.
@@ -364,21 +346,11 @@ module Samagotchi
         end
       end
 
-      # Convenience: load file_data from path + snapshot
-      def load_snapshot(path: nil, env: ENV, cli_overrides: {})
-        path ||= Samagotchi::ConfigFile.global_path(env: env) rescue nil
-        file_data = Samagotchi::ConfigFile.read_yaml(env: env, path: path) if path
-        snapshot(file_data: file_data, env: env, cli_overrides: cli_overrides)
-      end
-
-      # In-memory store for current process (populated after CLI parse)
-      def store
-        @store ||= load_snapshot
-      end
-
-      def reload!(path: nil, env: ENV, cli_overrides: {})
+      # Set this process's CLI settings (bin/chi, after it parsed the flags).
+      # Nothing is cached: #get resolves every call, reading config.yml
+      # again when it changed.
+      def reload!(cli_overrides: {})
         @cli_overrides = cli_overrides.dup
-        @store = load_snapshot(path: path, env: env, cli_overrides: cli_overrides)
       ensure
         # The log resolves its file and level from here.
         Samagotchi::Log.invalidate! if defined?(Samagotchi::Log)
@@ -388,10 +360,32 @@ module Samagotchi
         @cli_overrides ||= {}
       end
 
+      # This process's CLI settings as the env a spawned worker takes them
+      # from ({"SAMAGOTCHI_..." => "value"}): a worker gets no CLI args, and
+      # reads everything else from ENV and config.yml itself.
+      def cli_env
+        cli_overrides.each_with_object({}) do |(key, value), env|
+          entry = find_by_key(key) || ENTRIES.find { |e| e.cli_flag == key.to_s }
+          next unless entry&.env_exposed? && !value.nil?
+
+          env[entry.env_key] = value.to_s
+        end
+      end
+
       def get(key)
         get_with_origin(key).first
       end
 
+      # A timeout setting (server.open_timeout, server.read_timeout) in
+      # seconds, +given+ (a caller's own value) first; one that isn't
+      # positive (0, a word) is the key's default, on every kind of host.
+      def positive_seconds(key, given = nil)
+        value = (given.nil? ? get(key) : given).to_i
+        value.positive? ? value : find_by_key(key).default
+      rescue StandardError
+        find_by_key(key)&.default
+      end
+
       # [value, origin] for the live value #get returns; origin is one of
       # :cli, :env, :file, :default.
       def get_with_origin(key)
@@ -413,13 +407,13 @@ module Samagotchi
       # code doesn't read (with a "did you mean" when a known key is close).
       # Every config-exposed entry in ENTRIES is known as written; names under
       # the maps are the user's, and host/model entries may hold the keys
-      # their readers take. Legacy flat keys warn in ConfigFile.load_global_env!.
+      # their readers take.
       def validate_yaml_sections(data)
         return [] unless data.is_a?(Hash)
 
         data.flat_map do |key, value|
           key = key.to_s
-          if find_by_env(key)&.config_exposed? || FREE_FORM_MAPS.include?(key) || REMOVED_KEYS.include?(key)
+          if FREE_FORM_MAPS.include?(key)
             []
           elsif MAP_ENTRY_KEYS.key?(key)
             map_entry_problems(key, value)
@@ -454,7 +448,7 @@ module Samagotchi
       def key_problem(dotted)
         return nil if known_config_keys.include?(dotted)
 
-        entry = find_by_key(dotted) || find_by_env(dotted)
+        entry = find_by_key(dotted)
         if entry
           where = entry.cli_exposed? ? "#{entry.env_key} or #{entry.cli_flag}" : entry.env_key
           return "config: '#{dotted}' can't be set in config.yml; use #{where}"
@@ -462,7 +456,7 @@ module Samagotchi
 
         canonical = ENTRIES.select(&:config_exposed?).map(&:key) + known_sections.to_a +
                     SECTION_EXTRA_KEYS.flat_map { |s, leaves| leaves.map { |l| "#{s}.#{l}" } } + FREE_FORM_MAPS + MAP_ENTRY_KEYS.keys
-        # A legacy-looking flat key compares by its nested form.
+        # A flat SAMAGOTCHI_* key (the env name) compares by its nested form.
         probe = dotted.start_with?("SAMAGOTCHI_") ? dotted.delete_prefix("SAMAGOTCHI_").downcase : dotted
         unknown_key_message(dotted, probe, canonical)
       end
@@ -485,7 +479,7 @@ module Samagotchi
       # share its last segment, at most three.
       def unknown_key_message(key, probe, candidates, prefix: "")
         candidates = candidates.uniq
-        near = candidates.map { |c| [levenshtein(probe, c), c] }.select { |d, _| d <= 2 }.sort.map(&:last)
+        near = near_names(probe, candidates)
         close = (near + candidates.select { |c| c.split(".").last == probe.split(".").last }).uniq.first(3)
         hint = close.empty? ? "" : " (did you mean #{close.map { |c| "'#{prefix}#{c}'" }.join(' or ')}?)"
         "config: unknown key '#{key}'#{hint}"
@@ -513,7 +507,6 @@ module Samagotchi
     XDG_CONFIG_HOME_ENV = "XDG_CONFIG_HOME"
     CONFIG_DIR = "samagotchi"
     CONFIG_FILE = "config.yml"
-    DEFAULT_MODEL_KEY = "SAMAGOTCHI_DEFAULT_MODEL"
     MODEL_ALIASES_KEY = "model_aliases"
     MODELS_KEY = "models"
 
@@ -621,46 +614,18 @@ module Samagotchi
       end
     end
 
-    # New unified loader: delegates to Samagotchi::Config registry.
-    # Breaking: YAML now expects lower snake dotted paths (default.model)
-    # instead of UPPER scalar keys. For compatibility, UPPER keys are warned
-    # and ignored — env wins over file as before, now via registry precedence
-    # (CLI > ENV > file > default). Returns true if file existed.
-    def load_global_env!(env: ENV, path: global_path(env: env))
+    # Check config.yml once at start (warnings for keys the code doesn't
+    # read) and clear the CLI settings. Nothing is copied into ENV: every
+    # Config.get reads the file again when it changed, so a long-lived
+    # process (chi web) and the workers it spawns see edits, and a file
+    # value reports origin :file. Returns true if the file existed.
+    def load!(env: ENV, path: global_path(env: env))
       existed = File.file?(path)
       raw = read_yaml(env: env, path: path) || {}
       if existed
         Samagotchi::Config.validate_yaml_sections(raw).each { |w| Log.warn(:config, "config_key", echo: "Warning: #{w}") }
-        # Warn on legacy UPPER keys; the nested key wins when both are set.
-        # Any other flat key is unknown to validate_yaml_sections.
-        raw.each_key do |k|
-          entry = Samagotchi::Config.find_by_env(k)
-          next unless entry&.config_exposed?
-
-          if !Samagotchi::Config.lookup_nested(raw, entry.yaml_path, entry).nil?
-            nested = entry.yaml_path.join(".")
-            Log.warn(:config, "legacy_key", echo: "Warning: config: both '#{k}' and '#{nested}' are set; using '#{nested}', remove the flat key", key: k.to_s)
-          else
-            Log.warn(:config, "legacy_key", echo: "Warning: config key '#{k}' is legacy UPPER — use '#{entry.yaml_path.join('.')}'", key: k.to_s)
-          end
-        end
-      end
-      # For process-wide access, prime the Config store (so Config.get works)
-      Samagotchi::Config.reload!(path: path, env: env, cli_overrides: {})
-      # Keep ENV in sync for any code still reading ENV directly (transition).
-      # Only for keys that were actually present in file (not defaults) to
-      # avoid polluting ENV with defaults.
-      Samagotchi::Config.all_entries.each do |entry|
-        next unless entry.env_exposed?
-        # check if file actually contained this key (including legacy flat)
-        file_val = Samagotchi::Config.lookup_yaml(raw, entry.yaml_path)
-        file_val ||= raw[entry.env_key] if raw.key?(entry.env_key)
-        Array(entry.aliases).each { |a| file_val ||= raw[a] if raw.key?(a) }
-        next if file_val.nil?
-        val = Samagotchi::Config.store[entry.key]
-        next if val.nil?
-        env[entry.env_key] = val.to_s unless env.key?(entry.env_key)
       end
+      Samagotchi::Config.reload!(cli_overrides: {})
       existed
     end
 
@@ -726,6 +691,7 @@ module Samagotchi
           first_token_timeout = raw_cfg.key?("first_token_timeout") ? raw_cfg["first_token_timeout"] : raw_cfg[:first_token_timeout]
           vision = ConfigFile.vision_flag(raw_cfg.key?("vision") ? raw_cfg["vision"] : raw_cfg[:vision], "hosts entry '#{name}'")
           sampling = ConfigFile.sampling_map(raw_cfg.key?("sampling") ? raw_cfg["sampling"] : raw_cfg[:sampling], "hosts entry '#{name}'")
+          thinking = Thinking.level(raw_cfg.key?("thinking") ? raw_cfg["thinking"] : raw_cfg[:thinking], "hosts entry '#{name}'")
           unless first_token_timeout.nil? || (first_token_timeout.is_a?(Numeric) && !first_token_timeout.negative?)
             warn_once "Warning: hosts entry '#{name}': first_token_timeout must be seconds (0 = off); using the default"
             first_token_timeout = nil
@@ -789,19 +755,20 @@ module Samagotchi
                                   api: api_val&.to_sym, original_name: name, scheme: scheme,
                                   url: url.empty? ? nil : url, api_key_env: api_key_env.empty? ? nil : api_key_env,
                                   profile: profile.empty? ? nil : profile, first_token_timeout: first_token_timeout,
-                                  vision: vision, sampling: sampling }
+                                  vision: vision, sampling: sampling, thinking: thinking }
         end
       end
 
-      # If no hosts defined, synthesize "default" from SAMAGOTCHI_SERVER_HOST/PORT
+      # If no hosts defined, synthesize "default" from server.host/port/transport.
       if normalized.empty?
-        default_host = env.fetch("SAMAGOTCHI_SERVER_HOST", "localhost").to_s.strip
+        opts = { file_data: data, env: env, cli_overrides: Samagotchi::Config.cli_overrides }
+        default_host = Samagotchi::Config.resolve("server.host", **opts).to_s.strip
         default_host = "localhost" if default_host.empty?
-        default_port = env.fetch("SAMAGOTCHI_SERVER_PORT", "8080").to_s.strip
-        default_port = default_port.empty? ? 8080 : default_port.to_i
+        default_port = Samagotchi::Config.resolve("server.port", **opts).to_i
         default_port = 8080 if default_port <= 0 || default_port > 65535
-        transport_env = env.fetch("SAMAGOTCHI_SERVER_TRANSPORT", "").to_s.strip.downcase
-        transport_sym = VALID_TRANSPORTS_FOR_CONFIG.include?(transport_env) ? transport_env.to_sym : nil
+        transport_sym = Samagotchi::Config.resolve_with_origin("server.transport", **opts).then do |value, origin|
+          origin == :default ? nil : value.to_sym
+        end
         normalized["default"] = { name: "default", host: default_host, port: default_port, transport: transport_sym, original_name: "default" }
       end
       normalized
@@ -880,6 +847,26 @@ module Samagotchi
       [nil, value]
     end
 
+    # Hosted providers' names, which no local model family uses: as a
+    # prefix they always mean a host ("openai:gpt-4o"). "mistral" and
+    # "deepseek" are left out: Ollama has mistral:7b and deepseek-* tags.
+    PROVIDER_HOST_NAMES = %w[openrouter openai anthropic google gemini groq xai together fireworks].freeze
+
+    # The host a model ref names when that host isn't configured, or nil.
+    # A ':' in a model id is often a tag (qwen3:8b, org/model:Q4_K_M), so
+    # the prefix counts as a host only when it could be a host name and
+    # either the rest looks like a hosted provider's org/model id
+    # ("nosuch:anthropic/claude-sonnet-4"; Ollama-style tags never hold a
+    # '/') or the prefix is a provider's name (PROVIDER_HOST_NAMES).
+    def unknown_host_prefix(raw, hosts:)
+      prefix, rest = raw.to_s.strip.split(":", 2)
+      return nil if rest.to_s.strip.empty? || !prefix.match?(HOST_NAME_RE)
+      return nil unless rest.include?("/") || PROVIDER_HOST_NAMES.include?(prefix.downcase)
+
+      prefix = prefix.downcase
+      hosts.keys.map { |k| k.to_s.downcase }.include?(prefix) ? nil : prefix
+    end
+
     def hosts_json_for_env(env: ENV, path: global_path(env: env))
       hosts = hosts_config(env: env, path: path)
       # Only serialize if non-default or explicitly configured hosts:
@@ -892,7 +879,7 @@ module Samagotchi
         location = v[:url] ? { "url" => v[:url] } : { "host" => v[:host], "port" => v[:port] }
         location.merge("transport" => v[:transport]&.to_s, "api" => v[:api]&.to_s, "api_key_env" => v[:api_key_env],
                        "profile" => v[:profile], "first_token_timeout" => v[:first_token_timeout],
-                       "vision" => v[:vision], "sampling" => v[:sampling]).compact
+                       "vision" => v[:vision], "sampling" => v[:sampling], "thinking" => v[:thinking]&.to_s).compact
       end
       JSON.generate(simple)
     rescue StandardError
@@ -917,23 +904,18 @@ module Samagotchi
 
       raw_data = read_yaml(env: env, path: path) || {}
 
-      # Migrate to new dotted nested form: default.model (Option A)
       raw_data["default"] ||= {}
       if raw_data["default"].is_a?(Hash)
         raw_data["default"]["model"] = resolved
       else
         raw_data["default"] = { "model" => resolved }
       end
-      # Remove legacy UPPER key if present
-      raw_data.delete(DEFAULT_MODEL_KEY)
       FileUtils.mkdir_p(File.dirname(path))
       tmp = "#{path}.tmp"
       File.write(tmp, YAML.dump(raw_data))
       File.rename(tmp, path)
       clear_yaml_cache!(path)
-      env[DEFAULT_MODEL_KEY] = resolved
-      # Also sync new Config store if loaded
-      Samagotchi::Config.reload!(path: path, env: env, cli_overrides: {})
+      Samagotchi::Config.reload!(cli_overrides: Samagotchi::Config.cli_overrides)
       true
     end
 
@@ -976,6 +958,8 @@ module Samagotchi
         result[key][:vision] = vision unless vision.nil?
         sampling = sampling_map(v.key?("sampling") ? v["sampling"] : v[:sampling], "models: #{key}")
         result[key][:sampling] = sampling if sampling
+        thinking = Thinking.level(v.key?("thinking") ? v["thinking"] : v[:thinking], "models: #{key}")
+        result[key][:thinking] = thinking if thinking
       end
     rescue StandardError
       {}

data/lib/samagotchi/desktop/macos/App.swift

@@ -1,5 +1,6 @@
-// Chi Helper: the "Send to chi" Service opens the panel with the selection,
-// the hotkey with the clipboard. No Dock icon (LSUIElement); it stays
+// Chi Helper: the "Send to chi" Service opens the panel with the selection
+// (text, or images: files in Finder, a picture in Preview), the hotkey with
+// the clipboard (a screenshot too). No Dock icon (LSUIElement); it stays
 // running after the first launch. `ChiHelper --login on|off|status` (run
 // directly by chi desktop) manages the login item and exits.
 import AppKit
@@ -10,11 +11,12 @@ final class ServiceProvider: NSObject {
 
   // Info.plist NSServices: NSMessage = sendToChi.
   @objc func sendToChi(_ pboard: NSPasteboard, userData: String?, error: AutoreleasingUnsafeMutablePointer<NSString>) {
-    guard let text = pboard.string(forType: .string) else {
-      error.pointee = "No text in the selection" as NSString
+    let (text, images) = ImageIntake.read(pboard)
+    guard !text.isEmpty || !images.isEmpty else {
+      error.pointee = "No text or image in the selection" as NSString
       return
     }
-    app?.open(text: text)
+    app?.open(text: text, images: images)
   }
 }
 
@@ -28,6 +30,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
   func applicationDidFinishLaunching(_ notification: Notification) {
     provider.app = self
+    ImageIntake.sweep()
     NSApp.servicesProvider = provider
     NSUpdateDynamicServices()
     hotkey = Hotkey { [weak self] in self?.openFromClipboard() }
@@ -54,12 +57,13 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
   /// The hotkey doesn't activate us, so the frontmost app is the source.
   func openFromClipboard() {
-    open(text: NSPasteboard.general.string(forType: .string) ?? "")
+    let (text, images) = ImageIntake.read(NSPasteboard.general)
+    open(text: text, images: images)
   }
 
-  func open(text: String) {
+  func open(text: String, images: [PanelImage] = []) {
     let from = sourceApp
-    panel.show(text: text, source: from?.localizedName?.lowercased() ?? "desktop", returnTo: from)
+    panel.show(text: text, images: images, source: from?.localizedName?.lowercased() ?? "desktop", returnTo: from)
   }
 }
 

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -106,7 +106,9 @@ final class ChiRunner {
   /// Runs `chi <args>`, with stdin written from a background queue and
   /// stdout/stderr drained as they come (no pipe deadlock near the 16 KiB
   /// note cap). Calls back on the main queue.
-  func run(_ args: [String], stdin: Data? = nil, completion: @escaping (Result<ChiResult, ChiError>) -> Void) {
+  /// @param timeout this call's limit instead of the runner's
+  func run(_ args: [String], stdin: Data? = nil, timeout: TimeInterval? = nil,
+           completion: @escaping (Result<ChiResult, ChiError>) -> Void) {
     let config: LaunchConfig
     do { config = try loadLaunch() } catch let error as ChiError {
       completion(.failure(error)); return
@@ -161,7 +163,7 @@ final class ChiRunner {
         try? input.fileHandleForWriting.close()
       }
     }
-    DispatchQueue.global().asyncAfter(deadline: .now() + timeout) {
+    DispatchQueue.global().asyncAfter(deadline: .now() + (timeout ?? self.timeout)) {
       if process.isRunning {
         lock.lock(); timedOut = true; lock.unlock()
         process.terminate()

data/lib/samagotchi/desktop/macos/Images.swift

@@ -0,0 +1,113 @@
+// Images for the panel: what a pasteboard (the clipboard, the Service's,
+// a drop) carries, as files `chi send --image` can read. Image files are
+// passed as they are; image data (a ⌃⇧⌘4 screenshot, Preview, Safari's
+// Copy Image) is written to a temp file first, deleted after the send.
+import AppKit
+import UniformTypeIdentifiers
+
+/// The Bridge's cap on one turn's images.
+let maxImages = 20
+
+struct PanelImage: Identifiable, Equatable {
+  let id = UUID()
+  let url: URL
+  /// Written by the helper (image data), so the helper deletes it.
+  let temp: Bool
+  let thumbnail: NSImage?
+
+  var name: String { url.lastPathComponent }
+
+  init(url: URL, temp: Bool) {
+    self.url = url
+    self.temp = temp
+    thumbnail = NSImage(contentsOf: url)
+  }
+
+  static func == (a: PanelImage, b: PanelImage) -> Bool { a.id == b.id }
+}
+
+enum ImageIntake {
+  static let tempDir = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("chi-helper", isDirectory: true)
+
+  /// A pasteboard's content for the panel, in this order: image files
+  /// (Finder ⌘C, a Service on files) with no text; else its text, as before
+  /// (an office app's copy carries a picture of the cells too: the text
+  /// wins); else image data (png, then tiff). A non-image file is skipped.
+  static func read(_ pb: NSPasteboard) -> (text: String, images: [PanelImage]) {
+    let files = imageFiles(pb)
+    if !files.isEmpty { return ("", files) }
+    if let text = pb.string(forType: .string), !text.isEmpty { return (text, []) }
+    return ("", imageData(pb))
+  }
+
+  /// A drop adds images only: text dropped on the fields is theirs.
+  static func dropped(_ pb: NSPasteboard) -> [PanelImage] {
+    let files = imageFiles(pb)
+    return files.isEmpty ? imageData(pb) : files
+  }
+
+  static func imageFiles(_ pb: NSPasteboard) -> [PanelImage] {
+    let urls = pb.readObjects(forClasses: [NSURL.self], options: [.urlReadingFileURLsOnly: true]) as? [URL] ?? []
+    return urls.filter(isImage).prefix(maxImages).map { PanelImage(url: $0, temp: false) }
+  }
+
+  static func isImage(_ url: URL) -> Bool {
+    (try? url.resourceValues(forKeys: [.contentTypeKey]))?.contentType?.conforms(to: .image) == true
+  }
+
+  static func imageData(_ pb: NSPasteboard) -> [PanelImage] {
+    for (type, ext) in [(NSPasteboard.PasteboardType.png, "png"), (.tiff, "tiff")] {
+      guard let data = pb.data(forType: type) else { continue }
+      // A folder per image, so the name chi shows is "clipboard.png".
+      let dir = tempDir.appendingPathComponent(UUID().uuidString, isDirectory: true)
+      do {
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let url = dir.appendingPathComponent("clipboard.\(ext)")
+        try data.write(to: url)
+        return [PanelImage(url: url, temp: true)]
+      } catch {
+        return []
+      }
+    }
+    return []
+  }
+
+  static func delete(_ images: [PanelImage]) {
+    for image in images where image.temp {
+      try? FileManager.default.removeItem(at: image.url.deletingLastPathComponent())
+    }
+  }
+
+  /// At launch: what a helper that quit mid-send left.
+  static func sweep() {
+    try? FileManager.default.removeItem(at: tempDir)
+  }
+}
+
+/// The panel's background, taking dropped images anywhere on the panel.
+final class DropEffectView: NSVisualEffectView {
+  var onDrop: (([PanelImage]) -> Void)?
+
+  override init(frame: NSRect) {
+    super.init(frame: frame)
+    registerForDraggedTypes([.fileURL, .png, .tiff])
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+  override func draggingEntered(_ sender: NSDraggingInfo) -> NSDragOperation {
+    carriesImages(sender.draggingPasteboard) ? .copy : []
+  }
+
+  override func performDragOperation(_ sender: NSDraggingInfo) -> Bool {
+    let images = ImageIntake.dropped(sender.draggingPasteboard)
+    guard !images.isEmpty else { return false }
+    onDrop?(images)
+    return true
+  }
+
+  private func carriesImages(_ pb: NSPasteboard) -> Bool {
+    let urls = pb.readObjects(forClasses: [NSURL.self], options: [.urlReadingFileURLsOnly: true]) as? [URL] ?? []
+    return urls.contains(where: ImageIntake.isImage) || pb.availableType(from: [.png, .tiff]) != nil
+  }
+}

data/lib/samagotchi/desktop/macos/Info.plist.erb

@@ -33,6 +33,12 @@
       <key>NSSendTypes</key>
       <array>
         <string>public.utf8-plain-text</string>
+        <string>public.png</string>
+        <string>public.tiff</string>
+      </array>
+      <key>NSSendFileTypes</key>
+      <array>
+        <string>public.image</string>
       </array>
       <key>NSRequiredContext</key>
       <dict/>