samagotchi 0.50.0 → 0.52.0

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -5,6 +5,7 @@ require_relative "../served_model"
 require_relative "../image_store"
 require_relative "../turn_note"
 require_relative "../steer"
+require_relative "../steer_cut"
 require_relative "../memory_bundle/index_size"
 require_relative "../prompt_note"
 
@@ -31,13 +32,17 @@ module Samagotchi
 
       # What a tool line says the call did: the model's description of a
       # command (": List the specs") in place of its cut params, else the
-      # params, dim.
+      # params, dim; then, dim, the name the model called it by when that was
+      # an alias's (" (called as bash)").
       def tool_params_suffix(activity)
         description = activity[:description].to_s.strip
-        return ": #{description}" unless description.empty?
-
         params = activity[:params].to_s.strip
-        params.empty? ? "" : " #{paint(params, 90)}"
+        suffix = if !description.empty? then ": #{description}"
+                 elsif !params.empty? then " #{paint(params, 90)}"
+                 else ""
+                 end
+        called_as = activity[:called_as].to_s
+        called_as.empty? ? suffix : "#{suffix}#{paint(" (called as #{called_as})", 90)}"
       end
 
       # Green ok, yellow stopped (a wait the user's Stop ended), red the rest.
@@ -91,6 +96,49 @@ module Samagotchi
         paint("↪ cut in for #{STEER_CUT_FOR.fetch(event[:source].to_s, "your message")}", 90)
       end
 
+      # What a line submitted at the open prompt says became of it: a plain
+      # line goes in at the running turn's next step boundary (nothing cuts
+      # unless the message asked for it), /cut's cutting now or once the
+      # thinking passes steer.cut_after, and /queue's waiting for the end.
+      # Both TUIs and chi send --cut print the same words
+      # (SteerCut#cut_for_steer's answer).
+      NEXT_STEP_NOTE = "(goes in at the next step)"
+      CUT_NOW_NOTE = "(cut in now)"
+      CUT_WAITS_NOTE = "(cuts in once the thinking passes %d s)"
+      CUT_OFF_NOTE = "(cutting is off; goes in at the next step)"
+      STEER_CHOICE_USAGE = "(/cut and /queue need a message: /cut TEXT, /queue TEXT)"
+      # The UIs' own words for a delivery, listed for Tab and /help only
+      # (a local: entry, so no command or bundle may use the names).
+      CUT_COMMAND = "/cut"
+      QUEUE_COMMAND = "/queue"
+      # The word, then any whitespace and the text (as the registry's
+      # entries match them, so a line Tab or /help knows is never a prompt).
+      STEER_CHOICE = /\A(#{CUT_COMMAND}|#{QUEUE_COMMAND})(?:\s+(.*))?\z/m
+
+      # @param outcome [Symbol] SteerCut#cut_for_steer's answer: :now, :waits or :off
+      # @return [String] the dim line to show for a /cut
+      def self.steer_cut_note(outcome)
+        case outcome
+        when :now then CUT_NOW_NOTE
+        when :waits then format(CUT_WAITS_NOTE, SteerCut.cut_after)
+        else CUT_OFF_NOTE
+        end
+      end
+
+      # The same words, for a UI that includes the module.
+      def steer_cut_note(outcome) = Formatting.steer_cut_note(outcome)
+
+      # The choice a mid-turn line carries, as [:cut, "TEXT"] or
+      # [:queue, "TEXT"]; nil for any other line. The text is "" when the
+      # line named the choice without one.
+      # @param line [String, nil]
+      # @return [Array(Symbol, String), nil]
+      def steer_choice(line)
+        match = STEER_CHOICE.match(line.to_s.strip) or return nil
+
+        [match[1] == CUT_COMMAND ? :cut : :queue, match[2].to_s.strip]
+      end
+
       # "✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid
       # off)": a batch of LLM context edits went in (LLMContextNotice builds
       # the line; the web prints the same), dim like the retry row.
@@ -516,6 +564,10 @@ module Samagotchi
           by_tool = snapshot[:tool_calls_by_tool].sort_by { |_k, v| -v }
           lines << "  by tool:        #{by_tool.map { |k, v| "#{k}=#{v}" }.join(", ")}"
         end
+        unless snapshot[:tool_calls_aliased].to_a.empty?
+          aliased = snapshot[:tool_calls_aliased].sort_by { |_k, v| -v }
+          lines << "  called as:      #{aliased.map { |k, v| "#{k}=#{v}" }.join(", ")}"
+        end
         lines << "iterations:       #{snapshot[:iterations_total]}"
         # Summed over every request: each prompt is sent in full again.
         lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})" \
@@ -544,6 +596,8 @@ module Samagotchi
         lines << "model notes:      #{notes}" unless notes.empty?
         llm_context = llm_context_stats_text(snapshot[:llm_context])
         lines << "llm context:      #{llm_context}" if llm_context
+        thinking = thinking_stats_text(snapshot[:thinking])
+        lines << "thinking:         #{thinking}" if thinking
         if snapshot[:served_model]
           asked = snapshot[:served_model_for]
           differs = !snapshot[:served_expected_by] && ServedModel.differs?(asked, snapshot[:served_model])
@@ -583,6 +637,17 @@ module Samagotchi
           "budget #{budget} (#{get.call(:budget_where)})"
       end
 
+      # "low (session)", "default" for /stats (Thinking::Explained#summary;
+      # symbol or string keys, the attached TUI's come as JSON); nil
+      # without one.
+      def thinking_stats_text(summary)
+        return nil unless summary.is_a?(Hash)
+
+        level = summary[:level] || summary["level"]
+        source = summary[:source] || summary["source"]
+        source ? "#{level} (#{source})" : level
+      end
+
       # ", cached 4864 (93%), cache writes 312, re-prefilled 2100, reasoning
       # 212" for the tokens line; the counts a server didn't report are left
       # out (re-prefilled: SessionMetrics' reprefill_sum).

data/lib/samagotchi/terminal_ui.rb

@@ -90,9 +90,12 @@ module Samagotchi
     #   however the REPL ends, saves no memories and writes no recap
     # @param llm_context [Hash{Symbol => String}] --llm-context* as typed
     #   (LLMContextOverride.update): set on the new or resumed session
+    # @param thinking [String, nil] --thinking as typed: the new or resumed
+    #   session's own level (default unsets it)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
-                   spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {})
+                   spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil)
       @scratch        = scratch
+      @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
       @default_model_name = ModelProfile.required_model_name(nil)
@@ -246,8 +249,10 @@ module Samagotchi
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.
-      unless @llm_context_words.empty?
-        session.llm_context = LLMContextOverride.update(session.llm_context, @llm_context_words)
+      # --thinking: the session's own level, saved at once on a resumed one.
+      unless @llm_context_words.empty? && @thinking_word.nil?
+        session.llm_context = LLMContextOverride.update(session.llm_context, @llm_context_words) unless @llm_context_words.empty?
+        session.thinking = Thinking.session_level(@thinking_word) if @thinking_word
         session.save if @resume_session
       end
       claim_session!(session.id) unless @owner_lock
@@ -752,6 +757,14 @@ module Samagotchi
     def run_input_line(session, input)
       return if input.empty?
 
+      # /cut TEXT and /queue TEXT are deliveries only while a turn runs; at
+      # the prompt both run the text as a normal turn, as their usage says.
+      if (choice = steer_choice(input))
+        return @surface.commit(STEER_CHOICE_USAGE) if choice.last.empty?
+
+        input = choice.last
+      end
+
       # /model, /models, !rollback, !cmd, /continue (shared with workers);
       # an anytime command's cards print as it shows them (btw's
       # "thinking…" before the answer).
@@ -1083,6 +1096,10 @@ module Samagotchi
     # plugin's /btw, /model alone) starts now on its own thread; one that
     # runs after the turn (/model X, !cmd) waits in the queue, in arrival
     # order with the other lines that wait; others go back in the prompt.
+    #
+    # A plain line goes in at the running turn's next step boundary and
+    # never cuts; /cut TEXT asks for a cut, /queue TEXT waits for the turn
+    # to end and runs as a turn of its own.
     # @return [Boolean, :back] whether the turn took it, :back to put it back
     def steer_line(line)
       local = local_command(line) unless line.nil?
@@ -1091,6 +1108,12 @@ module Samagotchi
       return detach_note if local == :detach
       return false if @active_cancel_controller&.cancelled?
 
+      # Before every command check: /cut and /queue are the UIs' own words
+      # for a delivery (they are listed for Tab and /help, never run).
+      if (choice = steer_choice(line))
+        return submit_steer_choice(*choice)
+      end
+
       policy = command_registry.mid_turn(line)
       return start_anytime_command(line) if policy == :anytime
       return command_queued(line) if policy == :queue
@@ -1108,12 +1131,37 @@ module Samagotchi
       # Behind a command that waits for the turn's end, a line waits too.
       return wait_for_turn_end(line) if @command_waits
 
-      epoch = @engine.input_epoch
       @pending_input_queue.push(line.strip)
-      # The user's line cuts a generation that has streamed only thinking
-      # for long (steer.cut_after), now or once it has: the model starts the
-      # step again with it.
-      @engine.cut_for_steer(nil, epoch: epoch)
+      @surface.commit(NEXT_STEP_NOTE)
+      true
+    end
+
+    # /cut TEXT and /queue TEXT during a turn, which the REPL would
+    # otherwise read as prompts (SessionCommands registers them for Tab and
+    # help only). A cut asks the engine to cut the generation only thinking
+    # too long; a queue waits for the turn's end (the REPL's own after-turn
+    # list). Empty text gets the usage line. A line with images never steers
+    # (as a plain one doesn't).
+    # @return [Boolean] whether the turn took it
+    def submit_steer_choice(choice, text)
+      if text.empty?
+        @surface.commit(STEER_CHOICE_USAGE)
+        return true
+      end
+      return image_line_waits(text) if ImageInput.extract(text).any?
+
+      # A /queue waits for the turn's end; a /cut behind a command that
+      # already waits there goes after it too.
+      if choice == :queue || @command_waits
+        @surface.commit(COMMAND_QUEUED)
+        return wait_for_turn_end(text)
+      end
+
+      epoch = @engine.input_epoch
+      @pending_input_queue.push(text)
+      # With no session running the cut is :off; the text still waits for
+      # the running turn's next step.
+      @surface.commit(steer_cut_note(@engine.cut_for_steer(nil, epoch: epoch)))
       true
     end
 

data/lib/samagotchi/thinking.rb

@@ -10,7 +10,9 @@ module Samagotchi
   #   low, medium, high   the effort a chat host is asked for
   #   default  chi sends nothing: the provider's or template's own default
   #
-  # Order (#resolve): --thinking / SAMAGOTCHI_THINKING_LEVEL, then
+  # Order (#resolve): the session's own level (/thinking, chi --thinking at
+  # start, chi send --new --thinking, the web), then the process default
+  # (chi web --thinking / SAMAGOTCHI_THINKING_LEVEL), then
   # models.<key>.thinking, hosts.<name>.thinking, thinking.level in
   # config.yml, then default.
   module Thinking
@@ -33,8 +35,39 @@ module Samagotchi
     # anything there (low/medium/high have no native knob).
     Native = Data.define(:system_token, :prefill, :honoured)
 
+    # The source a session's own level reads as.
+    SESSION_SOURCE = "session"
+
+    # A level and where it came from (#explain): +source+ is "session",
+    # "--thinking", "SAMAGOTCHI_THINKING_LEVEL", "models: qwen",
+    # "hosts.work" or "thinking.level", nil for the default; +own+ is the
+    # session's own level, nil without one. What /thinking, /model,
+    # /stats, the snapshots and the web read.
+    Explained = Data.define(:level, :source, :own) do
+      # "low (session)", "default" with no source.
+      def label = source ? "#{level} (#{source})" : level.to_s
+
+      # The plain form the snapshots, the worker's command_ran event and
+      # the web read.
+      # @return [Hash] symbol keys
+      def summary = { level: level.to_s, source: source, own: own&.to_s }
+    end
+
     module_function
 
+    # A session's own level from its file or a command word: :off, :low,
+    # :medium or :high; nil for anything else, default included (unset:
+    # the session follows the process default and the model). Never warns:
+    # a session file keeps a value it can't read as written.
+    # @return [Symbol, nil]
+    def session_level(value)
+      return value if LEVELS.include?(value) && value != DEFAULT
+      return nil unless value.is_a?(String)
+
+      level = value.strip.downcase.to_sym
+      LEVELS.include?(level) && level != DEFAULT ? level : nil
+    end
+
     # A configured value as a level; nil when unset or not a level (that
     # warns once, naming +where+). YAML reads an unquoted `off` as false,
     # which is :off; true (`on`) isn't a level.
@@ -51,13 +84,17 @@ module Samagotchi
       nil
     end
 
-    # The level for +target+ and where it came from ("--thinking",
-    # "models: qwen", "hosts.work", "thinking.level"; nil for the default).
+    # The level for +target+ and where it came from ("session",
+    # "--thinking", "models: qwen", "hosts.work", "thinking.level"; nil for
+    # the default).
     # @param target [HostRegistry::ModelTarget]
     # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
-    # @param models [Hash, nil] ConfigFile.model_settings (specs)
+    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param session [Symbol, nil] the session's own level (Session#thinking)
     # @return [Array(Symbol, String|nil)]
-    def resolve(target, names:, models: nil)
+    def resolve(target, names:, models: nil, session: nil)
+      return [session, SESSION_SOURCE] if session
+
       global, origin = global_level
       return [global, origin == :cli ? "--thinking" : "SAMAGOTCHI_THINKING_LEVEL"] if global && %i[cli env].include?(origin)
 
@@ -66,8 +103,8 @@ module Samagotchi
       rescue StandardError
         {}
       end
-      key, value = ConfigFile.model_setting(names, :thinking, models: models)
-      return [value, "models: #{key}"] if key
+      setting = ConfigFile.model_setting(names, :thinking, models: models)
+      return [setting.value, "models: #{setting.key}"] if setting
 
       host = target.entry.thinking
       return [host, "hosts.#{target.entry.name}"] if host
@@ -76,6 +113,13 @@ module Samagotchi
       [DEFAULT, nil]
     end
 
+    # #resolve, as an Explained with the session's own level beside it.
+    # @return [Explained]
+    def explain(target, names:, models: nil, session: nil)
+      level, source = resolve(target, names: names, models: models, session: session)
+      Explained.new(level: level, source: source, own: session)
+    end
+
     # thinking.level as a level and its origin (:cli, :env, :file), or nil.
     def global_level
       raw, origin = Config.get_with_origin("thinking.level")
@@ -88,6 +132,22 @@ module Samagotchi
       nil
     end
 
+    # What a level change costs the prompt cache on +target+ (/thinking's
+    # note; a confirm step may ask before the costly ones):
+    #   :full      the native Gemma 4 prompt starts with <|think|>, so the
+    #              whole prompt is read again;
+    #   :provider  a chat host gets other request fields: a local llama.cpp
+    #              or Splash server keeps its cache, a hosted API may not;
+    #   :tail      native Qwen and the rest: only the tail changes.
+    # @param target [HostRegistry::ModelTarget]
+    # @param profile [String, nil] the native prompt profile's name
+    # @return [Symbol]
+    def cache_cost(target, profile: nil)
+      return :provider if target.entry&.chat?
+
+      profile == "gemma4" ? :full : :tail
+    end
+
     # Request fields for an OpenAI-style chat host. off sends both switches
     # (the template's enable_thinking and the OpenAI-style reasoning_effort
     # "none"): llama.cpp, Splash and OpenRouter each honour one of them.

data/lib/samagotchi/thinking_command.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "thinking"
+
+module Samagotchi
+  # /thinking, the session's own thinking level (Session#thinking): with no
+  # argument, the level the next turn runs at and where it came from;
+  # `/thinking off|low|medium|high` sets the session's own, `/thinking
+  # default` unsets it (the session follows the process default, the
+  # model, its host, then thinking.level). A change takes effect at the
+  # next turn's start (the REPL and the worker run it between turns), and
+  # the reply says what it costs the prompt cache (Thinking.cache_cost).
+  class ThinkingCommand
+    NAME = "/thinking"
+    SETTABLE = (Thinking::LEVELS - [Thinking::DEFAULT]).freeze
+    USAGE = "usage: #{NAME} [#{Thinking::LEVELS.join("|")}]".freeze
+
+    COST_NOTES = {
+      full: "On this model the whole prompt is read again (Gemma's <|think|> starts it).",
+      provider: "The request's thinking fields change: a local llama.cpp or Splash server keeps its cache; " \
+                "hosted APIs (OpenRouter → Claude, OpenAI) may restart theirs.",
+      tail: "Only the prompt's tail changes: the cache keeps the rest."
+    }.freeze
+
+    # @param engine [Engine] #thinking_explained, #thinking_override(=),
+    #   #session, #thinking_cache_cost
+    # @param save [#call] saves the session after a change
+    def initialize(engine:, save:)
+      @engine = engine
+      @save = save
+    end
+
+    # @param args [String] what follows /thinking
+    # @return [Array(String, Boolean)] the reply and whether the level changed
+    # @raise [ArgumentError] a word that isn't a level (with USAGE)
+    def run(args)
+      word = args.to_s.strip.downcase
+      return [listing(@engine.thinking_explained), false] if word.empty?
+
+      level = word.to_sym
+      raise ArgumentError, "unknown thinking level #{word}\n#{USAGE}" unless Thinking::LEVELS.include?(level)
+
+      session = @engine.session or raise ArgumentError, "no session yet"
+      before = @engine.thinking_explained
+      @engine.thinking_override = SETTABLE.include?(level) ? level : nil
+      @save.call(session)
+      after = @engine.thinking_explained
+      [[listing(after), *notes(before, after)].join("\n"), true]
+    end
+
+    # The level, where it came from, and what the session sets itself.
+    def listing(explained)
+      return "thinking: can't be resolved for this model" unless explained
+
+      lines = ["thinking: #{explained.label}"]
+      unless explained.own
+        lines << "  this session's own: none (follows chi web --thinking / SAMAGOTCHI_THINKING_LEVEL, the model, " \
+                 "its host, then thinking.level)"
+      end
+      lines.join("\n")
+    end
+
+    private
+
+    def notes(before, after)
+      return [] unless before && after
+      return ["(no change to what the next turn runs under)"] if before.level == after.level
+
+      ["From the next turn's start (a running turn keeps its own).", COST_NOTES[@engine.thinking_cache_cost]].compact
+    end
+  end
+end

data/lib/samagotchi/tool_activity.rb

@@ -47,6 +47,9 @@ module Samagotchi
       }
       title = tool_title(tool_name, call, cwd: cwd)
       event[:title] = title if title
+      # The name the model used when an alias ran a built-in (called_as: "bash"
+      # for an execute), for a UI that shows it.
+      event[:called_as] = call[:called_as] if call.is_a?(Hash) && call[:called_as]
       # The model's own words for a command, which the TUI's tool line
       # shows in place of the cut params.
       description = command_description(tool_name, call)

data/lib/samagotchi/tool_runner.rb

@@ -57,6 +57,8 @@ module Samagotchi
       # The worker runs in its session's working directory.
       title = ToolActivity.tool_title(call[:name], call, cwd: Dir.pwd)
       started[:title] = title if title
+      # The name the model called it by when that was an alias's (bash).
+      started[:called_as] = call[:called_as] if call[:called_as]
       # The full command for a richer UI (params stays cut at 80).
       view = ToolView.for(call[:name], call)&.to_h
       started[:view] = view if view

data/lib/samagotchi/tools/builtin_calls.rb

@@ -56,6 +56,13 @@ module Samagotchi
         "forget_outputs" => { content: "note", also: %w[note], verbatim: %w[ids keep restore] }
       }.freeze
 
+      # A name the model uses for a built-in, mapped to that built-in (a model
+      # that keeps calling `bash` with execute's arguments; before this such a
+      # call died as an unknown tool). It only takes effect when the
+      # arguments really are the target's shape; the call then carries
+      # called_as: with the model's own spelling.
+      ALIASES = { "bash" => "execute" }.freeze
+
       # One built-in's mapping, resolved from its schema and OVERRIDES.
       Row = Data.define(:name, :content_keys, :path_key, :fields, :aliases, :verbatim, :fallback, :fallback_key,
                         :options) do
@@ -109,6 +116,14 @@ module Samagotchi
       def build(name, args, raw: nil)
         name = name.to_s
         args = args.is_a?(Hash) ? args.transform_keys(&:to_s) : {}
+        # An alias runs its target (bash → execute); the row is the target's,
+        # and the call keeps the model's own spelling on called_as:.
+        # Not the target's shape (a String main argument, only its keys) and
+        # the alias doesn't take: the call passes through as an unknown tool.
+        if (target = ALIASES[name.downcase])
+          return aliasable?(row(target), args) ? aliased(name, target, args, raw) : passthrough(name, args, raw)
+        end
+
         row = row(name)
         return passthrough(name, args, raw) unless row
 
@@ -120,6 +135,24 @@ module Samagotchi
         call
       end
 
+      # An execute-shaped call the model spelled +name+: built as its +target+,
+      # tagged with the model's spelling for the activity event and the log.
+      def aliased(name, target, args, raw)
+        call = build(target, args, raw: raw)
+        call[:called_as] = name
+        call
+      end
+
+      # The alias gate: a String main argument, and every key one the target's
+      # schema knows (its aliases included). More, or differently shaped, the
+      # call is the model's own and passes through as an unknown tool.
+      def aliasable?(row, args)
+        return false unless row
+
+        row.content_keys.map { |key| value(row, args, key) }.any?(String) &&
+          (args.keys - (row.content_keys + [row.path_key].compact + row.fields + row.aliases.keys)).empty?
+      end
+
       def content_value(row, args)
         found = row.content_keys.lazy.map { |key| value(row, args, key) }.find { |v| !v.nil? }
         found.nil? ? "" : found.to_s

data/lib/samagotchi/tools/builtins.rb

@@ -119,15 +119,19 @@ 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. A
+      # inherited from an outer session never passes for this one. So too
+      # the session's own thinking level (SAMAGOTCHI_SESSION_THINKING, unset
+      # without one), which chi self puts first. 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 : ""
+        thinking = peers.respond_to?(:thinking) ? peers.thinking&.to_s : nil
         { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
-          SESSION_MODEL_ENV => model.empty? ? nil : model }.merge(cli_model_unset(env))
+          SESSION_MODEL_ENV => model.empty? ? nil : model,
+          SESSION_THINKING_ENV => thinking }.merge(cli_model_unset(env))
       end
 
       # The unsets that keep a `chi --model X` worker's default from passing
@@ -139,6 +143,7 @@ module Samagotchi
       end
 
       SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+      SESSION_THINKING_ENV = "SAMAGOTCHI_SESSION_THINKING"
 
       # 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).

data/lib/samagotchi/tools/peers.rb

@@ -8,10 +8,11 @@ module Samagotchi
     # canceled (a waiting tool returns on it), and the question flow a
     # delegate's approval is relayed through (relay: nil when this session
     # can't host one), and the model the session runs on (model_ref: the
-    # resolved ref, live after /model). Engine hands KernelLoop one that follows its current
+    # resolved ref, live after /model), and the session's own thinking level
+    # (thinking: nil without one). Engine hands KernelLoop one that follows its current
     # session (Engine::PeerView); this plain one is for specs and a kernel
     # without an Engine.
-    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, keyword_init: true) do
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/task_runtime.rb

@@ -22,7 +22,7 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
-      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING].freeze
       # task_wait and task_get add it to a task the user stopped (the web's
       # stop-task button), so the model doesn't rerun the job.
       # A record whose pid isn't a process group chi started (missing, 0, 1,

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -24,7 +24,7 @@ module Samagotchi
     # @param target [HostRegistry::ModelTarget]
     # @param profile [ModelProfile, nil] the model's prompt profile (native)
     # @param adapter [LLM::OpenAIChat, nil] the chat host's adapter
-    # @param models [Hash, nil] ConfigFile.model_settings (specs)
+    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
     # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
     # @return [Answer]
     def self.for(target, names:, profile: nil, adapter: nil, models: nil)
@@ -51,8 +51,9 @@ module Samagotchi
       rescue StandardError
         {}
       end
-      key, value = ConfigFile.model_setting(names, :vision, models: models)
-      return Answer.new(value: value, reason: value ? nil : "models: #{key} sets vision: false") if key
+      if (setting = ConfigFile.model_setting(names, :vision, models: models))
+        return Answer.new(value: setting.value, reason: setting.value ? nil : "models: #{setting.key} sets vision: false")
+      end
       return nil if entry.vision.nil?
 
       Answer.new(value: entry.vision, reason: entry.vision ? nil : "hosts.#{entry.name} sets vision: false")