samagotchi 0.3.0 → 0.5.0

data/lib/samagotchi/self_report.rb

@@ -7,6 +7,7 @@ require_relative "context_window"
 require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
+require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
 require_relative "tools/memory"
@@ -15,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
@@ -50,13 +54,29 @@ module Samagotchi
         ["api key", model ? api_key_for(model, env) : "-"],
         ["loop", model ? loop_for(model, env) : "-"],
         ["profile", model ? profile_for(model, env) : "-"],
+        ["thinking", model ? thinking_for(model, env) : "-"],
         ["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)
@@ -150,6 +170,15 @@ module Samagotchi
       end
     end
 
+    # The model's thinking level and where it came from (Thinking.resolve).
+    def thinking_for(model, env)
+      target = HostRegistry.new(env: env).resolve(model)
+      level, source = Thinking.resolve(target, models: ConfigFile.model_settings(env: env))
+      source ? "#{level} (#{source})" : level.to_s
+    rescue StandardError => e
+      "(unknown: #{e.message})"
+    end
+
     def host_for(model, env)
       entry, bare = HostRegistry.new(env: env).host_for_model(model)
       return "(no hosts configured)" unless entry
@@ -170,14 +199,17 @@ module Samagotchi
     end
 
     # The Chi Helper app's version against this chi's (read from its
-    # Info.plist; no process or Services checks: chi desktop status has those).
+    # Info.plist and launch file; no process or Services checks: chi desktop
+    # status has those). An older app is fine while its sources are unchanged.
     def desktop_summary(env)
       return "- (macOS only)" unless Desktop.supported?
 
-      version = Desktop::MacOS.new(env: env).app_version
+      helper = Desktop::MacOS.new(env: env)
+      version = helper.app_version
       return "not installed" unless version
+      return "#{version} (matches)" if version == VERSION
 
-      version == VERSION ? "#{version} (matches)" : "#{version} (chi is #{VERSION}: chi desktop upgrade)"
+      helper.stale? ? "#{version} (chi is #{VERSION}: chi update)" : "#{version} (up to date for chi #{VERSION})"
     end
 
     # "samagotchi-system 0.1.5 (shipped 0.1.5), other 1.0.0"

data/lib/samagotchi/send_command.rb

@@ -4,6 +4,10 @@ require_relative "session"
 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
@@ -19,16 +23,24 @@ module Samagotchi
     # No live worker this long while waiting: it died before it could mark
     # the session (a worker takes well under a second to start).
     WORKER_GONE_AFTER = 5
+    # The Bridge's cap on one turn's images (Bridge::MAX_TURN_IMAGES).
+    MAX_IMAGES = 20
 
     USAGE = <<~TEXT
-      Usage: chi send [-m TEXT] (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [-m TEXT]
-             chi send --wait [--timeout S] [-m TEXT] (--new | ID)
+      Usage: chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...
+             chi send --new [--dir DIR] [--model M] [-m TEXT] [--image PATH]...
+             chi send --wait [--timeout S] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --wait [--timeout S] ID
         Sends a message to each session, as if typed in it: a turn starts,
         or a running one picks it up. A stopped session's worker starts.
         -m TEXT     the message; stdin, when piped too, goes above it as a
                     quote (context); without -m, stdin is the message
+        --image PATH
+                    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: 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
@@ -46,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
@@ -65,6 +111,11 @@ module Samagotchi
       # With --wait stdout is the answer alone.
       @info = options[:wait] ? @stderr : @stdout
       prompt = compose(utf8(read_stdin), utf8(options[:message]))
+      # Before the wait-only case, which would drop the images.
+      if prompt.nil? && !options[:images].empty?
+        usage_error("--image needs a message: pass -m TEXT or pipe it in")
+        return 2
+      end
       return run_wait_only(options) if prompt.nil? && options[:wait] && !options[:new]
       unless prompt
         usage_error("no message: pass -m TEXT or pipe it in")
@@ -76,6 +127,7 @@ module Samagotchi
         @stderr.puts("chi send: #{e.message}")
         return 1
       end
+      return 2 unless ingest_images(options[:images])
 
       return run_new(prompt, options) if options[:new]
       return run_wait(prompt, options) if options[:wait]
@@ -91,12 +143,14 @@ module Samagotchi
         deliver(id, prompt)
       end
       results.all? ? 0 : 1
+    ensure
+      FileUtils.rm_rf(@image_dir) if @image_dir
     end
 
     private
 
     def parse
-      options = { ids: [] }
+      options = { ids: [], images: [] }
       until @argv.empty?
         arg = @argv.shift
         case arg
@@ -110,6 +164,8 @@ module Samagotchi
         when "--dir", "--model"
           options[arg.delete_prefix("--").to_sym] = @argv.shift or return usage_error("#{arg} needs a value")
         when /\A--(dir|model)=(.*)\z/m then options[Regexp.last_match(1).to_sym] = Regexp.last_match(2)
+        when "--image" then options[:images] << (@argv.shift or return usage_error("#{arg} needs a value"))
+        when /\A--image=(.*)\z/m then options[:images] << Regexp.last_match(1)
         when "--wait" then options[:wait] = true
         when "--timeout" then options[:timeout] = @argv.shift or return usage_error("#{arg} needs a value")
         when /\A--timeout=(.*)\z/ then options[:timeout] = Regexp.last_match(1)
@@ -127,6 +183,7 @@ module Samagotchi
         return usage_error("--timeout takes seconds") unless options[:timeout]&.positive?
       end
       return usage_error("--wait takes one session") if options[:wait] && options[:ids].uniq.size > 1
+      return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
       %i[dir model].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
@@ -180,21 +237,34 @@ module Samagotchi
 
     # A worker session like the web start page's: saved as running with the
     # message before its worker spawns, so lists and the web show it at
-    # once. The full id, so a script can pass it on. The model name isn't
-    # checked here (nor in the web): a wrong one fails in the worker.
+    # once. The full id, so a script can pass it on. Only the model's host
+    # is checked here (in spawn_session, as in the web): a wrong model id
+    # fails in the worker.
     # @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
-        session = SessionManager.spawn_session(prompt: prompt, working_directory: options[:dir],
-                                               model_name: options[:model], state_dir: @state_dir)
+        # With images the web's way: idle (the message names it in the
+        # lists), the images copied in, then the message as a turn.
+        start = images ? { prompt: nil, title: prompt } : { prompt: prompt }
+        session = SessionManager.spawn_session(**start, working_directory: options[:dir],
+                                                        model_name: options[:model], state_dir: @state_dir)
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1
       end
-      @info.puts("#{session.id}  started")
+      if images
+        return 1 unless deliver_new(session, prompt)
+      else
+        @info.puts("#{session.id}  started")
+      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
 
@@ -213,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])
@@ -232,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,
@@ -247,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]
@@ -263,27 +342,76 @@ 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
       0
     end
 
+    # A new idle session's first turn, with the images. Its worker's Bridge
+    # first: deliver_turn wakes a worker when none owns the session yet,
+    # and the spawned one takes its lock only once it runs.
+    # @return [Boolean] whether the message was queued
+    def deliver_new(session, prompt)
+      dir = Session.session_dir(session.id, state_dir: @state_dir)
+      result = nil
+      begin
+        refs = copy_images(dir)
+        if BridgeClient.wait_for(session.id, session_dir: dir, timeout: SessionManager::TURN_BRIDGE_WAIT)
+          result = SessionManager.deliver_turn(session.id, prompt: prompt, client_id: CLIENT_ID, images: refs,
+                                                           state_dir: @state_dir)
+        end
+      rescue StandardError => e
+        @info.puts("#{session.id}  failed: #{e.message}")
+        return false
+      end
+      # Kept, not deleted: it holds the images, and the message shows as
+      # its preview; the user can attach and send it again.
+      unless result
+        @info.puts("#{session.id}  failed: its worker did not start; the session is kept (chi --attach #{session.id})")
+        return false
+      end
+      unless result[:status] == :accepted
+        @info.puts("#{session.id}  failed: #{result.dig(:ack, "detail") || "could not queue it"}")
+        return false
+      end
+
+      @info.puts("#{session.id}  started#{with_images}")
+      true
+    end
+
     # @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
-      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, state_dir: @state_dir)
+      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
         @info.puts("#{short}  failed: #{result.dig(:ack, "detail") || "could not queue it"}")
         return false
       end
 
+      # A busy worker runs a message with images as its own next turn
+      # rather than merging it into the running one.
       note = if owner.nil? then " (started its worker)"
-             elsif running then " (the running turn picks it up)"
+             elsif running then refs.empty? ? " (the running turn picks it up)" : " (runs after the current turn)"
              end
-      @info.puts("#{short}  sent#{note}")
+      @info.puts("#{short}  sent#{with_images}#{note}")
       true
     rescue SessionManager::OwnedByTUI
       @info.puts("#{short}  refused: it is open in a chi REPL; messages need attached mode")
@@ -293,6 +421,51 @@ 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.
+    # @return [Boolean] false after the error line
+    def ingest_images(paths)
+      @images = []
+      return true if paths.empty?
+
+      @image_dir = Dir.mktmpdir("chi-send-images")
+      @images = paths.map { |path| ImageStore.ingest(@image_dir, path: path) }
+      true
+    rescue ImageStore::Error => e
+      error_line("chi send: #{e.message}")
+      false
+    end
+
+    # The images' files copied into a session dir, as the refs a turn takes.
+    def copy_images(session_dir)
+      @images.map do |ref|
+        ImageStore.copy_file(ref, from: @image_dir, to: session_dir)
+        { file: ref[:file], name: ref[:name] }
+      end
+    end
+
+    def with_images
+      case @images.size
+      when 0 then ""
+      when 1 then " with 1 image"
+      else " with #{@images.size} images"
+      end
+    end
+
     # The text as UTF-8 whatever the locale says: with no LANG/LC_* (an app
     # started from Finder, launchd) stdin reads as US-ASCII and ARGV as
     # binary. Invalid bytes become U+FFFD rather than an error.

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_commands.rb

@@ -15,8 +15,10 @@ module Samagotchi
   # the Engine and its TurnFlow; the host prints the result's output and
   # runs a continue turn when asked to (#run never runs a turn).
   #
-  # /stats, /recap and /exit are the UI's own: they are in the registry
-  # (local: for Tab and help) but #run never runs them.
+  # /stats, /recap, /exit, /quit, /archive and /detach are the terminal
+  # UIs' own: they are in the registry (local:) for Tab and help, and so
+  # both TUIs read the same words (Registry#lookup_local gives the entry,
+  # its id says what to do), but #run never runs them.
   class SessionCommands
     MODEL_COMMAND = "/model"
     MODELS_COMMAND = "/models"
@@ -30,6 +32,8 @@ module Samagotchi
     SHELL_BANG_PREFIX = "!"
     RESERVED_MODEL_ARGS = %w[clear default none off].freeze
     ALIAS_USAGE = "usage /model <model> --alias <name> [--default]"
+    # /exit --delete: delete the session on the way out.
+    EXIT_DELETE_FLAG = "--delete"
 
     # @!attribute status [Symbol] :ok, or :error when the line was refused
     # @!attribute output [String, nil] what to tell the user
@@ -66,13 +70,28 @@ module Samagotchi
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
-      registry.register("/exit", "leave (--delete also deletes the session)", local: true)
-      registry.register("/archive", "leave and archive the session: hidden from the lists, kept for good", local: true)
-      registry.register("/quit", "leave, like /exit", local: true, uis: [:attached])
-      registry.register("/detach", "leave and keep the worker running", local: true, uis: [:attached])
+      # Bare `exit` too; any case; --delete after it.
+      registry.register("/exit", "leave (--delete also deletes the session)", local: true,
+                                                                              match: exit_match("/?exit"))
+      registry.register("/quit", "leave, like /exit", id: :exit, local: true, match: exit_match("/quit"))
+      registry.register("/archive", "leave and archive the session: hidden from the lists, kept for good", local: true,
+                                                                                                          match: ->(text) { text.casecmp?("/archive") })
+      # The REPL owns its session: it answers /detach with a note, and doesn't offer it.
+      registry.register("/detach", "leave and keep the worker running", local: true, uis: [:attached],
+                                                                        match: ->(text) { text.casecmp?("/detach") })
       registry
     end
 
+    # @param word [String] the regexp source of the exit word
+    def self.exit_match(word)
+      pattern = /\A#{word}(?:\s+#{EXIT_DELETE_FLAG})?\z/i
+      ->(text) { text.match?(pattern) }
+    end
+    private_class_method :exit_match
+
+    # @return [Boolean] an exit line (/exit, /quit, exit) that deletes the session too
+    def self.delete_on_exit?(line) = line.to_s.split.last.to_s.casecmp?(EXIT_DELETE_FLAG)
+
     # The built-ins alone, for callers without an Engine (an attached TUI
     # before its snapshot names the session's commands, specs).
     # @return [Commands::Registry] frozen
@@ -277,15 +296,18 @@ module Samagotchi
     def model(text)
       output, switched = model_command(text)
       reply(output, changed: switched ? [:model] : [])
+    rescue ModelProfile::MissingModel => e
+      # A model qualified with an unknown host: nothing switched.
+      reply(e.message, status: :error)
     end
 
     # @return [Array(String, Boolean)] the message, and whether the model changed
     def model_command(input)
       suffix = input.delete_prefix(MODEL_COMMAND).strip
       if suffix.empty?
-        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}", false] if model_name == @default_model
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}", false] if model_name == @default_model
 
-        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}", false]
+        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}", false]
       end
 
       # Parse flags: --default and --alias <name> / --alias=<name> (tolerant order)
@@ -420,6 +442,14 @@ module Samagotchi
       ""
     end
 
+    # "; thinking: off (models: qwen)" when the model has a level set.
+    def thinking_note
+      summary = @engine.respond_to?(:thinking_summary) ? @engine.thinking_summary : nil
+      summary ? "; thinking: #{summary}" : ""
+    rescue StandardError
+      ""
+    end
+
     # " (default: x, profile=qwen36, name)": +extra+ and the prompt profile,
     # which a chat host's model doesn't have (its loop uses none); "" when
     # there is neither.