samagotchi 0.54.0 → 0.56.0

data/lib/samagotchi/reasoning_history.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "setting_explained"
+
+module Samagotchi
+  # Which of its own reasoning a chat host's model gets back
+  # (LLM::ChatLoop sends it as reasoning_content on its earlier replies):
+  #
+  #   turn  the running turn's replies only (the tool-call rounds since the
+  #         last user message); what Qwen's, Gemma 4's and DeepSeek's
+  #         templates and the hosted APIs expect
+  #   drop  none
+  #   all   every reply that has reasoning, earlier turns too (a direct
+  #         DeepSeek API with tools wants this)
+  #
+  # Order (#resolve): the session's own level (/reasoning-history), then
+  # SAMAGOTCHI_REASONING_HISTORY, models.<key>.reasoning_history,
+  # hosts.<name>.reasoning_history, then turn. Native hosts ignore it:
+  # KernelLoop keeps the running turn's reasoning on its own.
+  module ReasoningHistory
+    LEVELS = %i[drop turn all].freeze
+    DEFAULT = :turn
+    KEY = "reasoning_history"
+    ENV_NAME = "SAMAGOTCHI_REASONING_HISTORY"
+    # The source a session's own level reads as.
+    SESSION_SOURCE = "session"
+    # The word that unsets a session's own level.
+    UNSET = "default"
+
+    module_function
+
+    # A session's own level from its file or a command word: :drop, :turn
+    # or :all (an explicit turn is the session's own too); nil for anything
+    # else, default included. 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)
+      return nil unless value.is_a?(String)
+
+      level = value.strip.downcase.to_sym
+      LEVELS.include?(level) ? level : nil
+    end
+
+    # A configured value as a level; nil when unset or not a level (that
+    # warns once, naming +where+).
+    # @return [Symbol, nil]
+    def level(value, where)
+      return nil if value.nil?
+
+      text = value.to_s.strip.downcase
+      return text.to_sym if LEVELS.include?(text.to_sym)
+
+      ConfigFile.warn_once "Warning: #{where}: #{KEY} must be one of #{LEVELS.join(", ")}; ignored"
+      nil
+    end
+
+    # The level for +target+ and where it came from ("session",
+    # "SAMAGOTCHI_REASONING_HISTORY", "models: qwen", "hosts.work"; nil for
+    # the default).
+    # @param target [HostRegistry::ModelTarget]
+    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
+    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param session [Symbol, nil] the session's own level (Session#reasoning_history)
+    # @return [Array(Symbol, String|nil)]
+    def resolve(target, names:, models: nil, session: nil)
+      return [session, SESSION_SOURCE] if session
+
+      env = env_level
+      return [env, ENV_NAME] if env
+
+      models ||= begin
+        ConfigFile.model_settings
+      rescue StandardError
+        {}
+      end
+      setting = ConfigFile.model_setting(names, :reasoning_history, models: models)
+      return [setting.value, "models: #{setting.key}"] if setting
+
+      host = target.entry&.reasoning_history
+      return [host, "hosts.#{target.entry.name}"] if host
+
+      [DEFAULT, nil]
+    end
+
+    # #resolve, as a SettingExplained with the session's own level beside it.
+    # @return [SettingExplained]
+    def explain(target, names:, models: nil, session: nil)
+      level, source = resolve(target, names: names, models: models, session: session)
+      SettingExplained.new(level: level, source: source, own: session)
+    end
+
+    # What changing the level from +from+ to +to+ costs +target+'s prompt
+    # cache, at a turn boundary (a change waits for the turn's end):
+    #   :history  to or from all on a chat host, with an earlier model entry
+    #             that has thinking: every earlier reply from there gains or
+    #             loses its reasoning_content, so a server that renders it
+    #             (hosted APIs; llama.cpp's default) reads the conversation
+    #             again from the first earlier thought;
+    #   nil       drop <-> turn (a turn's first request carries no reasoning
+    #             under either), no change, nothing thought yet, or a
+    #             native host (it ignores the level).
+    # @param conversation [Array<Hash>] the session's messages
+    # @return [Symbol, nil]
+    def cache_cost(from, to, target:, conversation:)
+      return nil unless target.entry&.chat?
+      return nil if from == to || ![from, to].include?(:all)
+
+      earlier_thought?(conversation) ? :history : nil
+    end
+
+    # Whether +conversation+ has a model entry with thinking (what all
+    # sends back as reasoning_content; LLM::ChatLoop#thought?).
+    def earlier_thought?(conversation)
+      Array(conversation).any? do |entry|
+        entry[:role].to_s == "model" && entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?
+      end
+    end
+
+    # "drop (models: qwen)", "turn (default)".
+    def label(level, source) = "#{level} (#{source || "default"})"
+
+    # SAMAGOTCHI_REASONING_HISTORY as a level, nil when unset or unknown.
+    def env_level
+      raw, origin = Config.get_with_origin(KEY)
+      origin == :env ? level(raw, ENV_NAME) : nil
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/samagotchi/reasoning_history_command.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "cache_confirm"
+require_relative "reasoning_history"
+
+module Samagotchi
+  # /reasoning-history, the session's own reasoning_history level
+  # (Session#reasoning_history): with no argument, the level the next turn
+  # runs under and where it came from; `/reasoning-history drop|turn|all`
+  # sets the session's own (an explicit turn too), `/reasoning-history
+  # default` unsets it (the session follows SAMAGOTCHI_REASONING_HISTORY,
+  # the model, its host, then turn). A change takes effect at the next
+  # turn's start; a native host ignores the level (its loop keeps the
+  # running turn's reasoning), but the session keeps it for a chat model.
+  # A change that rewrites the earlier replies asks first (CacheConfirm);
+  # --yes (or -y) applies it.
+  class ReasoningHistoryCommand
+    NAME = "/reasoning-history"
+    USAGE = "usage: #{NAME} [#{(ReasoningHistory::LEVELS + [ReasoningHistory::UNSET]).join("|")}]".freeze
+    NATIVE_NOTE = "  (ignored on this host: the native loop keeps the running turn's reasoning)"
+    # ReasoningHistory.cache_cost's; nil (no cost) says nothing.
+    COST_NOTES = {
+      history: "Earlier replies gain or lose their reasoning: the server reads the conversation again " \
+               "from the first earlier thought."
+    }.freeze
+
+    # @param engine [Engine] #reasoning_history_explained,
+    #   #reasoning_history_override(=), #session, #chat_model?,
+    #   #reasoning_history_cache_cost, #history?
+    # @param save [#call] saves the session after a change
+    def initialize(engine:, save:)
+      @engine = engine
+      @save = save
+    end
+
+    # @param args [String] what follows /reasoning-history (--yes anywhere)
+    # @param confirm [Boolean] ask before a costly change (CacheConfirm);
+    #   false applies it at once
+    # @return [Array(String, Boolean, CacheConfirm::Confirm|nil)] the reply,
+    #   whether the level changed, and the confirm it asks for (nothing
+    #   changed then)
+    # @raise [ArgumentError] a word that isn't a level (with USAGE)
+    def run(args, confirm: true)
+      word, yes = CacheConfirm.split(args)
+      return [listing(explained), false, nil] if word.empty?
+
+      level = ReasoningHistory.session_level(word)
+      raise ArgumentError, "unknown reasoning history level #{word}\n#{USAGE}" unless level || word == ReasoningHistory::UNSET
+
+      session = @engine.session or raise ArgumentError, "no session yet"
+      before = explained
+      ask = confirm && !yes ? ask(before, level, word) : nil
+      return ask if ask
+
+      @engine.reasoning_history_override = level
+      @save.call(session)
+      after = explained
+      [[listing(after), *notes(before, after)].join("\n"), true, nil]
+    end
+
+    # The level, where it came from, and what the session sets itself.
+    def listing(explained)
+      return "reasoning history: can't be resolved for this model" unless explained
+
+      lines = ["reasoning history: #{explained.label}"]
+      unless explained.own
+        lines << "  this session's own: none (follows #{ReasoningHistory::ENV_NAME}, the model, its host, then turn)"
+      end
+      lines << NATIVE_NOTE unless chat?
+      lines.join("\n")
+    end
+
+    private
+
+    # Resolved on any host: a native one ignores it, but /reasoning-history
+    # still shows what a chat model would get.
+    def explained(own: @engine.reasoning_history_override)
+      @engine.reasoning_history_explained(native: true, own: own)
+    end
+
+    # The reply that asks before a costly change, nil when it needn't.
+    def ask(before, own, word)
+      would = explained(own: own)
+      return nil unless before && would
+
+      cost = @engine.reasoning_history_cache_cost(before.level, would.level)
+      return nil unless CacheConfirm.needed?(cost: cost, history: @engine.history?, changed: would.level != before.level)
+
+      step = CacheConfirm.confirm(NAME, word)
+      [[listing(before), "Switching to #{would.level} restarts the prompt cache: #{COST_NOTES[cost]}", step.text].join("\n"), false, step]
+    end
+
+    def chat?
+      @engine.chat_model?
+    rescue StandardError
+      false
+    end
+
+    def notes(before, after)
+      return [] unless before && after
+      return ["(no change to what the next turn runs under)"] if before.level == after.level
+
+      cost = @engine.reasoning_history_cache_cost(before.level, after.level)
+      ["From the next turn's start (a running turn keeps its own).", COST_NOTES[cost]].compact
+    end
+  end
+end

data/lib/samagotchi/self_report.rb

@@ -13,6 +13,7 @@ require_relative "model_overlay"
 require_relative "model_notes"
 require_relative "prompt_note"
 require_relative "thinking"
+require_relative "reasoning_history"
 require_relative "served_model"
 require_relative "host_registry"
 require_relative "llm/http"
@@ -67,6 +68,7 @@ module Samagotchi
         ["loop", model ? loop_for(model, env) : "-"],
         ["profile", model ? profile_for(model, env) : "-"],
         ["thinking", model ? thinking_for(model, env) : "-"],
+        ["reasoning history", model ? reasoning_history_for(model, env) : "-"],
         ["served model", model ? served_model_for(model, env) : "-"],
         ["context window", context_window(env, model)],
         ["bundles", bundles_summary],
@@ -154,6 +156,8 @@ module Samagotchi
     PARENT_SESSION_ENV = "SAMAGOTCHI_PARENT_SESSION"
     # The session's own thinking level, beside its model (Builtins.parent_env).
     SESSION_THINKING_ENV = "SAMAGOTCHI_SESSION_THINKING"
+    # The session's own reasoning_history level (Builtins.parent_env).
+    SESSION_REASONING_HISTORY_ENV = "SAMAGOTCHI_SESSION_REASONING_HISTORY"
 
     # The model of the session this chi self runs in (its execute exports
     # SAMAGOTCHI_SESSION_MODEL, the resolved ref, live after /model); nil
@@ -369,6 +373,23 @@ module Samagotchi
       "(unknown: #{e.message})"
     end
 
+    # Which of its reasoning the model gets back and where that came from
+    # (ReasoningHistory.resolve); in a session's commands its own level
+    # first (SAMAGOTCHI_SESSION_REASONING_HISTORY); a native host keeps the
+    # running turn's on its own.
+    def reasoning_history_for(model, env)
+      registry = HostRegistry.new(env: env)
+      target = registry.resolve(model)
+      return "native loop: the running turn's, always" unless target.entry&.chat?
+
+      session = session_model(env) ? ReasoningHistory.session_level(env[SESSION_REASONING_HISTORY_ENV]) : nil
+      level, source = ReasoningHistory.resolve(target, names: registry.lookup_names(model, target: target),
+                                                       models: ConfigFile.model_settings(env: env), session: session)
+      ReasoningHistory.label(level, source)
+    rescue StandardError => e
+      "(unknown: #{e.message})"
+    end
+
     def host_for(model, env)
       target = HostRegistry.new(env: env).resolve(model)
       entry = target.entry

data/lib/samagotchi/session.rb

@@ -137,6 +137,23 @@ module Samagotchi
     # read; nil when there is neither.
     def thinking_file = @thinking&.to_s || @thinking_unread
 
+    # The session's own reasoning_history level (:drop, :turn, :all), before
+    # SAMAGOTCHI_REASONING_HISTORY and the model's (ReasoningHistory.resolve);
+    # nil when it has none. Saved and carried like #thinking.
+    attr_reader :reasoning_history
+
+    # @param value [Symbol, String, nil] a value that isn't a level reads
+    #   as nil and is saved back as written, until the session sets its own
+    def reasoning_history=(value)
+      @reasoning_history = ReasoningHistory.session_level(value)
+      unread = @reasoning_history.nil? && value.is_a?(String) && !value.strip.casecmp?(ReasoningHistory::UNSET)
+      @reasoning_history_unread = unread ? value : nil
+    end
+
+    # The session file's "reasoning_history": the level, else a value it
+    # couldn't read; nil when there is neither.
+    def reasoning_history_file = @reasoning_history&.to_s || @reasoning_history_unread
+
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
     # left), e.g. "loop-guard"; nil when it ended otherwise.
     def stopped_by
@@ -165,7 +182,7 @@ module Samagotchi
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
-                   continues: nil, thinking: nil)
+                   continues: nil, thinking: nil, reasoning_history: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -192,6 +209,7 @@ module Samagotchi
       @continues = continues&.to_s
       self.llm_context = llm_context
       self.thinking = thinking
+      self.reasoning_history = reasoning_history
       @archived = false
     end
 
@@ -270,6 +288,7 @@ module Samagotchi
         delegate: delegate,
         llm_context: setup.llm_context,
         thinking: setup.thinking,
+        reasoning_history: setup.reasoning_history,
         continues: continues
       )
     end
@@ -331,7 +350,8 @@ module Samagotchi
       "delegate" => false,
       "llm_context" => nil,
       "continues" => nil,
-      "thinking" => nil
+      "thinking" => nil,
+      "reasoning_history" => nil
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -453,6 +473,7 @@ module Samagotchi
                 when "delegate" then @delegate
                 when "llm_context" then llm_context_file
                 when "thinking" then thinking_file
+                when "reasoning_history" then reasoning_history_file
                 when "prompt_notes" then @prompt_notes.map(&:to_file)
                 when "last_turn" then @last_turn&.to_file
                 when "used_memory_names", "preloaded_memory_names", "muted_memory_names"

data/lib/samagotchi/session_commands.rb

@@ -12,6 +12,7 @@ require_relative "tools/peers"
 require_relative "commands/registry"
 require_relative "llm_context_command"
 require_relative "thinking_command"
+require_relative "reasoning_history_command"
 
 module Samagotchi
   # The session commands a REPL and a session worker both run: /model,
@@ -31,6 +32,7 @@ module Samagotchi
     HELP_COMMAND = "/help"
     LLM_CONTEXT_COMMAND = LLMContextCommand::NAME
     THINKING_COMMAND = ThinkingCommand::NAME
+    REASONING_HISTORY_COMMAND = ReasoningHistoryCommand::NAME
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
     MODELS_PER_HOST = 20
@@ -44,6 +46,10 @@ module Samagotchi
     # /help's note per listed mid_turn (the web's command list says the same).
     MID_TURN_NOTES = { "anytime" => "mid-turn too", "depends" => "show: mid-turn too" }.freeze
 
+    # The commands that ask before a change that restarts the prompt cache
+    # (CacheConfirm): #run passes them its confirm flag.
+    CONFIRMING = %i[thinking reasoning_history].freeze
+
     # @!attribute status [Symbol] :ok, or :error when the line was refused
     # @!attribute output [String, nil] what to tell the user
     # @!attribute changed [Array<Symbol>] :messages and/or :model
@@ -52,7 +58,9 @@ module Samagotchi
     # @!attribute shell [Boolean] output is a !cmd's own output
     # @!attribute decision [Symbol, nil] an answer to the continue offer:
     #   :resume, :abort, :abort_with_reason or :invalid
-    Result = Struct.new(:status, :output, :changed, :model_name, :resume, :shell, :decision, keyword_init: true)
+    # @!attribute confirm [CacheConfirm::Confirm, nil] a costly change asks
+    #   first (nothing changed): the line that applies it
+    Result = Struct.new(:status, :output, :changed, :model_name, :resume, :shell, :decision, :confirm, keyword_init: true)
 
     # Puts the built-in commands into +registry+, in lookup order (!rollback
     # before !cmd): the ones #run runs, then the UIs' own (local: Tab and
@@ -92,6 +100,9 @@ module Samagotchi
                         id: :llm_context, mid_turn: show_mid_turn(LLM_CONTEXT_COMMAND), match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
       registry.register(THINKING_COMMAND, "show or set this session's thinking level (off|low|medium|high|default)",
                         id: :thinking, mid_turn: show_mid_turn(THINKING_COMMAND), match: ->(text) { text.match?(%r{\A/thinking(?:\s+.*)?\z}) }) { |text| thinking(text) }
+      registry.register(REASONING_HISTORY_COMMAND, "show or set which of its reasoning this session's model gets back (drop|turn|all|default)",
+                        id: :reasoning_history, mid_turn: show_mid_turn(REASONING_HISTORY_COMMAND),
+                        match: ->(text) { text.match?(%r{\A/reasoning-history(?:\s+.*)?\z}) }) { |text| reasoning_history(text) }
       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)
@@ -231,13 +242,20 @@ module Samagotchi
     # How help and errors name an entry (the shell's "!" is "!<cmd>").
     def self.display_name(entry) = entry.name == SHELL_BANG_PREFIX ? "#{SHELL_BANG_PREFIX}<cmd>" : entry.name
 
+    # @param confirm [Boolean] a costly /thinking or /reasoning-history
+    #   change asks first (CacheConfirm): true for a person at a web tab or
+    #   a TUI; false applies it at once (chi send, a delegate, a plugin,
+    #   chi -p)
     # @return [Result, nil] nil when +line+ is not one of these commands
-    def run(line)
+    def run(line, confirm: true)
       text = line.to_s.strip
       entry = @registry.lookup(text)
       return nil unless entry&.handler
       return run_bundle_command(entry, text) unless entry.source == "core"
 
+      # The two that may ask take the flag; the rest never ask.
+      return send(entry.id, text, confirm: confirm) if CONFIRMING.include?(entry.id)
+
       instance_exec(text, &entry.handler)
     end
 
@@ -283,8 +301,9 @@ module Samagotchi
       entry.source == "core" ? 0 : 1
     end
 
-    def reply(output, status: :ok, changed: [])
-      Result.new(status: status, output: output, changed: changed, model_name: model_name, resume: false, shell: false)
+    def reply(output, status: :ok, changed: [], confirm: nil)
+      Result.new(status: status, output: output, changed: changed, model_name: model_name, resume: false, shell: false,
+                 confirm: confirm)
     end
 
     # Explicit escape hatch after a Ctrl-C: discard the salvaged partial
@@ -427,15 +446,27 @@ module Samagotchi
 
     # /thinking (ThinkingCommand); :thinking in changed when it set the
     # session's level.
-    def thinking(text)
-      output, changed = ThinkingCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
-                                       .run(text.delete_prefix(THINKING_COMMAND))
-      reply(output, changed: changed ? [:thinking] : [])
+    def thinking(text, confirm: true)
+      output, changed, ask = ThinkingCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
+                                            .run(text.delete_prefix(THINKING_COMMAND), confirm: confirm)
+      reply(output, changed: changed ? [:thinking] : [], confirm: ask)
+    rescue ArgumentError => e
+      reply(e.message, status: :error)
+    end
+
+    # /reasoning-history (ReasoningHistoryCommand); :reasoning_history in
+    # changed when it set the session's level.
+    def reasoning_history(text, confirm: true)
+      output, changed, ask = ReasoningHistoryCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
+                                                    .run(text.delete_prefix(REASONING_HISTORY_COMMAND),
+                                                         confirm: confirm)
+      reply(output, changed: changed ? [:reasoning_history] : [], confirm: ask)
     rescue ArgumentError => e
       reply(e.message, status: :error)
     end
 
-    # A session setting changed (/llm-context, /thinking): saved with its model.
+    # A session setting changed (/llm-context, /thinking, /reasoning-history):
+    # saved with its model.
     def save_setup(session)
       @engine.store_model!(session)
       @save.call(session)
@@ -453,9 +484,9 @@ module Samagotchi
     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}#{thinking_note}#{notes_note}", false] if model_name == @engine.model_ref_for(@default_model)
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if model_name == @engine.model_ref_for(@default_model)
 
-        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{notes_note}", false]
+        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false]
       end
 
       # Parse flags: --default and --alias <name> / --alias=<name> (tolerant order)
@@ -516,7 +547,7 @@ module Samagotchi
 
         key = alias_name.strip.downcase
         warn_prefix = previous ? "warning: overwriting alias '#{key}' (#{previous} -> #{model_name}); " : ""
-        base = persist_default ? "runtime model set to #{model_name}#{model_note} and default updated#{thinking_note}" : "runtime model set to #{model_name}#{model_note}#{thinking_note}"
+        base = persist_default ? "runtime model set to #{model_name}#{model_note} and default updated#{thinking_note}#{reasoning_history_note}" : "runtime model set to #{model_name}#{model_note}#{thinking_note}#{reasoning_history_note}"
         ["#{warn_prefix}#{base}; alias '#{key}' -> '#{model_name}' persisted", true]
       else
         return ["--default requires a model name: usage /model --default <name> or /model <name> [--default]", false] if arg.empty?
@@ -525,14 +556,14 @@ module Samagotchi
           return ["--default cannot be combined with clear/default/none/off", false] if persist_default
 
           switch_model(@default_model)
-          return ["runtime model reset to #{model_name}#{model_note}#{thinking_note}#{notes_note}", true]
+          return ["runtime model reset to #{model_name}#{model_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", true]
         end
 
         switch_model(arg, persist_default: persist_default)
         if persist_default
-          ["runtime model set to #{model_name}#{model_note} and default updated#{thinking_note}#{notes_note}", true]
+          ["runtime model set to #{model_name}#{model_note} and default updated#{thinking_note}#{reasoning_history_note}#{notes_note}", true]
         else
-          ["runtime model set to #{model_name}#{model_note}#{thinking_note}#{notes_note}", true]
+          ["runtime model set to #{model_name}#{model_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", true]
         end
       end
     end
@@ -592,6 +623,15 @@ module Samagotchi
       ""
     end
 
+    # "; reasoning history: drop (models: qwen)" when the chat model has a
+    # level set.
+    def reasoning_history_note
+      summary = @engine.reasoning_history_summary
+      summary ? "; reasoning history: #{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.

data/lib/samagotchi/session_manager.rb

@@ -272,7 +272,8 @@ module Samagotchi
 
     GUARDRAILS_ENV_PREFIX = "SAMAGOTCHI_GUARDRAILS_"
     # Tools::Builtins.parent_env's (Tools::TaskRuntime::MARKER_ENV_KEYS).
-    SESSION_MARKER_ENV = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING].freeze
+    SESSION_MARKER_ENV = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING
+                            SAMAGOTCHI_SESSION_REASONING_HISTORY].freeze
 
     # List all sessions, reading status from persisted session.json files.
     # +project_root+: only that project's sessions (nil: every session).

data/lib/samagotchi/session_setup.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "llm_context_override"
+require_relative "reasoning_history"
 require_relative "thinking"
 
 module Samagotchi
@@ -8,15 +9,16 @@ module Samagotchi
   # value on the paths that spawn a session from a whole setup
   # (SessionManager.spawn_session, a continue, a plugin's fork, the web's
   # create, chi send --new): +llm_context+ is an LLMContextOverride or nil,
-  # +thinking+ a level Symbol (Thinking.session_level) or nil.
+  # +thinking+ a level Symbol (Thinking.session_level) or nil,
+  # +reasoning_history+ a level Symbol (ReasoningHistory.session_level) or nil.
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
   # without one; a continue and a fork copy their session's (.of).
-  SessionSetup = Data.define(:llm_context, :thinking) do
-    def initialize(llm_context: nil, thinking: nil) = super
+  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history) do
+    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil) = super
 
-    def empty? = llm_context.nil? && thinking.nil?
+    def empty? = llm_context.nil? && thinking.nil? && reasoning_history.nil?
 
     # A session's own setup, for a session that starts from it.
     # @param session [Session, nil]
@@ -24,7 +26,7 @@ module Samagotchi
     def self.of(session)
       return new if session.nil?
 
-      new(llm_context: session.llm_context, thinking: session.thinking)
+      new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history)
     end
   end
 end

data/lib/samagotchi/setting_explained.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A session setting's level and where it came from (Thinking.explain,
+  # ReasoningHistory.explain): +source+ is "session",
+  # "SAMAGOTCHI_THINKING_LEVEL", "models: qwen", "hosts.work" and the like,
+  # nil for the default; +own+ is the session's own level, nil without one.
+  # What the commands, /model, /stats, the snapshots and the web read.
+  # (LLMContextStrategy::Explained is a different shape: three values,
+  # each with its own origin.)
+  SettingExplained = 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
+end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -54,7 +54,8 @@ module Samagotchi
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
-        commands << "#{ThinkingCommand::NAME} #{thinking}" if (attach || resume) && thinking
+        # --yes: typing the flag is the choice (no confirm step).
+        commands << "#{ThinkingCommand::NAME} #{thinking} --yes" if (attach || resume) && thinking
         first_command = commands.size > 1 ? commands : commands.first
         surface = open_surface
         attached = AttachedLoop.new(client: client, screen: surface, client_id: "tui:#{Process.pid}", first_prompt: prompt,

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -633,6 +633,7 @@ module Samagotchi
         else
           @screen.commit("#{paint("model>", 36)} #{output}")
         end
+        prefill_confirm(event)
         return unless event[:model_name]
 
         # After the output, so the status row changes with the line saying why.
@@ -640,6 +641,16 @@ module Samagotchi
         @status.update(model: event[:model_name], default_model: default_model_name, served: served)
       end
 
+      # Our change that asks first (CacheConfirm) puts its --yes line in the
+      # input: Enter applies it. Another client's question is its own.
+      def prefill_confirm(event)
+        return unless own?(event[:client_id])
+
+        confirm = event[:confirm]
+        line = confirm.is_a?(Hash) ? confirm[:line] || confirm["line"] : nil
+        @reader&.prefill(line.to_s) if line
+      end
+
       # Our command the worker couldn't run yet goes back into the prompt, for
       # Enter once the turn ends (not the launch's --model: that ends the launch).
       def put_back_busy_command(event)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -598,8 +598,11 @@ 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])
+        thinking = setting_stats_text(snapshot[:thinking])
         lines << "thinking:         #{thinking}" if thinking
+        # A chat host's only: a native one ignores it (the summary is nil).
+        history = setting_stats_text(snapshot[:reasoning_history])
+        lines << "reasoning history: #{history}" if history
         if snapshot[:served_model]
           asked = snapshot[:served_model_for]
           differs = !snapshot[:served_expected_by] && ServedModel.differs?(asked, snapshot[:served_model])
@@ -641,10 +644,10 @@ 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)
+      # "low (session)", "default" for /stats (SettingExplained#summary:
+      # thinking, reasoning_history; symbol or string keys, the attached
+      # TUI's come as JSON); nil without one.
+      def setting_stats_text(summary)
         return nil unless summary.is_a?(Hash)
 
         level = summary[:level] || summary["level"]