samagotchi 0.50.0 → 0.52.0

data/lib/samagotchi/plugin/sessions.rb

@@ -32,7 +32,7 @@ module Samagotchi
       # Start a child session from +messages+ (usually ctx.messages plus
       # more). With no prompt the child waits idle for the user; with one it
       # runs it as its first turn, and counts against session.max_children.
-      # It keeps this session's own llm_context values (Session#llm_context).
+      # It keeps this session's own setup (SessionSetup: its llm_context values).
       # Each image a message names is copied into the child, or dropped with
       # a note in its message when its file is gone.
       # @param messages [Array<Hash>] the child's conversation to start with
@@ -54,7 +54,7 @@ module Samagotchi
           prompt: prompt, working_directory: @host.cwd.call || Dir.pwd, model_name: @host.model_name&.call,
           parent_id: parent_id, messages: Array(messages).map { |message| unfrozen(message) }, title: title,
           images_from: Session.session_dir(parent_id, state_dir: state_dir), state_dir: state_dir,
-          llm_context: @host.llm_context&.call
+          setup: @host.setup&.call || SessionSetup.new
         )
         child.id
       end

data/lib/samagotchi/queued_command.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Samagotchi
+  # A session command on its way from the Bridge (POST /command, a command
+  # sent as a message, the worker's own Bridge#queue_command) to the
+  # worker's command queue. +card+: a card's action (the step-limit
+  # question's answer), whose line the UIs leave out. The worker adds
+  # where it waits (Worker#on_command): +mid_turn+ (the policy it got:
+  # :queue, :refuse, :loop), +after_seq+ (the event count then, so a
+  # turn's end knows it came before) and +after_file+ (the input file it
+  # runs after, a basename).
+  QueuedCommand = Data.define(:command_id, :client_id, :line, :card, :mid_turn, :after_seq, :after_file) do
+    def initialize(command_id:, line:, client_id: nil, card: false, mid_turn: nil, after_seq: nil, after_file: nil) = super
+
+    # A new command with a fresh id.
+    def self.mint(line, client_id: nil, card: false)
+      new(command_id: SecureRandom.uuid, client_id: client_id, line: line, card: card ? true : false)
+    end
+
+    # The fields its command_queued and command_ran name: card only when
+    # it is a card's.
+    # @return [Hash]
+    def event_fields
+      fields = { command_id: command_id, client_id: client_id, line: line }
+      fields[:card] = true if card
+      fields
+    end
+
+    # Whether it waits for the running turn's end (its line was shown at
+    # its command_queued).
+    def waits_for_turn_end? = mid_turn == :queue
+  end
+end

data/lib/samagotchi/reminder_store.rb

@@ -104,21 +104,6 @@ module Samagotchi
       end
     end
 
-    # Mark a reminder as fired — resets its next_fire_at to now + interval.
-    # Called by Engine after a due reminder has been delivered.
-    # @param name [String] the reminder name
-    def mark_fired(name)
-      name = name.to_s.strip
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      @mutex.synchronize do
-        r = @reminders[name]
-        if r
-          r[:last_fire_at] = now
-          r[:next_fire_at] = now + (r[:interval_minutes] * 60)
-        end
-      end
-    end
-
     # Mark multiple reminders as fired — resets each next_fire_at to now + interval.
     # Called by Engine after injecting multiple due reminders (batch operation).
     # Thread-safe, single lock acquisition.
@@ -137,18 +122,6 @@ module Samagotchi
       end
     end
 
-    # Get the description of a due reminder (for injection into the system prompt).
-    # Called by Engine during run_turn. Thread-safe.
-    # @param name [String] the reminder name
-    # @return [String, nil] the description, or nil if not found
-    def get_description(name)
-      name = name.to_s.strip
-      @mutex.synchronize do
-        r = @reminders[name]
-        r[:description] if r
-      end
-    end
-
     # Clear all reminders.
     # Called when the session ends or the engine is reset.
     def clear_all

data/lib/samagotchi/reply_wait.rb

@@ -61,7 +61,7 @@ module Samagotchi
     #   idle again ends the wait even if it was never seen running, and a
     #   question already pending then is not the answer's. A nil
     #   messages: skips the count. last_turn: (the session's
-    #   last_turn["ended_at"] then, maybe nil) ends the wait on any turn
+    #   last_turn.ended_at then, maybe nil) ends the wait on any turn
     #   that ended since, idle again, however fast it ran (a failure after
     #   a failure replaces the note and leaves the count as it was), and
     #   with it the count isn't used: a note between turns grows it too.
@@ -141,8 +141,7 @@ module Samagotchi
     # ended, so a turn that ends before the first look still ends the wait.
     # @return [Hash]
     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 }
+      { messages: session.messages.size, question_id: question_id, last_turn: session.last_turn&.ended_at }
     end
 
     # An idle session whose turn ended after the baseline was taken: its
@@ -155,7 +154,7 @@ module Samagotchi
       return false unless baseline
 
       if baseline.key?(:last_turn)
-        ended = session.last_turn.is_a?(Hash) ? session.last_turn["ended_at"] : nil
+        ended = session.last_turn&.ended_at
         return !ended.nil? && ended != baseline[:last_turn]
       end
       !!(baseline[:messages] && session.messages.size > baseline[:messages])
@@ -164,15 +163,14 @@ module Samagotchi
     # @return [Result] :no_reply with the outcome the session's last_turn
     #   records, when it is the turn waited for
     def no_reply(session, baseline)
-      last = session.last_turn.is_a?(Hash) ? session.last_turn : {}
-      fresh = baseline.nil? || !baseline.key?(:last_turn) || (last["ended_at"] && last["ended_at"] != baseline[:last_turn])
-      outcome = fresh ? last["outcome"] : nil
-      if fresh && last["exhausted"]
-        return Result.new(status: :no_reply, outcome: "exhausted", limit: last["limit"], session: session)
-      end
+      last = session.last_turn || LastTurn.new
+      fresh = baseline.nil? || !baseline.key?(:last_turn) || (last.ended_at && last.ended_at != baseline[:last_turn])
+      outcome = fresh ? last.outcome : nil
+      return Result.new(status: :no_reply, outcome: "exhausted", limit: last.limit, session: session) if fresh && last.exhausted
 
       text = outcome == "failed" ? TurnNote.failure_summary(session.messages) : nil
-      why = fresh ? last.slice("error_kind", "retryable", "cancel_reason", "stopped_by", "kept_steps").transform_keys(&:to_sym) : {}
+      # Every stop fact the turn has: Result takes them by name.
+      why = fresh ? last.stop_facts : {}
       Result.new(status: :no_reply, outcome: outcome, text: text, session: session, **why)
     end
 
@@ -188,12 +186,12 @@ module Samagotchi
     def settled(session, id, state_dir:)
       return session unless session.status == Session::STATUS_RUNNING
 
-      before = session.last_turn.is_a?(Hash) ? session.last_turn["ended_at"] : nil
+      before = session.last_turn&.ended_at
       deadline = monotonic + SETTLE_SECONDS
       loop do
         sleep(0.02)
         fresh = Session.load(id, state_dir: state_dir)
-        ended = fresh.last_turn.is_a?(Hash) ? fresh.last_turn["ended_at"] : nil
+        ended = fresh.last_turn&.ended_at
         return fresh if fresh.status != Session::STATUS_RUNNING || ended != before || monotonic > deadline
       end
     rescue ArgumentError

data/lib/samagotchi/sampling_settings.rb

@@ -13,7 +13,7 @@ module Samagotchi
 
     # @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)
     # @return [Hash] frozen, symbol keys; may be empty
     def self.for(target, names:, models: nil)
       resolve(target, names, models).first
@@ -44,11 +44,11 @@ module Samagotchi
         {}
       end
       host = target.entry.sampling || EMPTY
-      key, model = ConfigFile.model_setting(names, :sampling, models: models)
+      model = ConfigFile.model_setting(names, :sampling, models: models)
       sources = []
       sources << "hosts.#{target.entry.name}" unless host.empty?
-      sources << "models: #{key}" if key
-      [host.merge(model || EMPTY).freeze, sources]
+      sources << "models: #{model.key}" if model
+      [host.merge(model&.value || EMPTY).freeze, sources]
     end
 
     private_class_method :resolve

data/lib/samagotchi/self_report.rb

@@ -145,13 +145,15 @@ module Samagotchi
       return nil unless window
       return [window.tokens, "hosts.#{target.entry.name}"] if window.source == :host_setting
 
-      [window.tokens, "models: #{ConfigFile.model_setting(names, :window_tokens, models: models).first}"]
+      [window.tokens, "models: #{ConfigFile.model_setting(names, :window_tokens, models: models).key}"]
     rescue StandardError
       nil
     end
 
     SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
     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 model of the session this chi self runs in (its execute exports
     # SAMAGOTCHI_SESSION_MODEL, the resolved ref, live after /model); nil
@@ -355,13 +357,14 @@ module Samagotchi
       end
     end
 
-    # The model's thinking level and where it came from (Thinking.resolve).
+    # The model's thinking level and where it came from (Thinking.resolve);
+    # in a session's commands its own level first (SAMAGOTCHI_SESSION_THINKING).
     def thinking_for(model, env)
       registry = HostRegistry.new(env: env)
       target = registry.resolve(model)
-      level, source = Thinking.resolve(target, names: registry.lookup_names(model, target: target),
-                                               models: ConfigFile.model_settings(env: env))
-      source ? "#{level} (#{source})" : level.to_s
+      session = session_model(env) ? Thinking.session_level(env[SESSION_THINKING_ENV]) : nil
+      Thinking.explain(target, names: registry.lookup_names(model, target: target),
+                               models: ConfigFile.model_settings(env: env), session: session).label
     rescue StandardError => e
       "(unknown: #{e.message})"
     end

data/lib/samagotchi/send_command.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "client_id"
+require_relative "delivery"
+require_relative "terminal_ui/formatting"
 require_relative "session"
 require_relative "session_commands"
 require_relative "session_inbox"
@@ -32,15 +34,18 @@ module Samagotchi
     CLIENT_ID = ClientId::CLI_SEND
     # The cap on one turn's images the Bridge checks.
     MAX_IMAGES = ImageStore::MAX_TURN_REFS
+    # A cut's outcomes in the Bridge's ack (SteerCut#cut_for_steer).
+    CUT_OUTCOMES = %w[now waits off].freeze
 
     USAGE = <<~TEXT
-      Usage: chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [-m TEXT] [--image PATH]...
+      Usage: chi send [-m TEXT] [--image PATH]... [--cut] (ID|PREFIX)...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --wait [--timeout S] [--format json] 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.
+        or a running one takes it at its next step. A stopped session's
+        worker starts.
         A session command (/model x, !cmd) runs as the command; --wait
         then has no reply to wait for (exit 0, status command).
         -m TEXT     the message; stdin, when piped too, goes above it as a
@@ -57,16 +62,20 @@ module Samagotchi
                     the current one
         --continues ID
                     (--new) start the next link of that session's chain:
-                    in its folder, on its model and LLM context, with a
-                    note carrying its recap; it is archived. last:ID
-                    names the chain's latest link. Without -m the new
-                    session waits idle. Refused for a session continued
-                    already (naming the next link) or with delegates
-                    still open
+                    in its folder, on its model, LLM context and
+                    thinking level, with a note carrying its recap; it
+                    is archived. last:ID names the chain's latest link.
+                    Without -m the new session waits idle. Refused for a
+                    session continued already (naming the next link) or
+                    with delegates still open
         --model M   (--new) its model; default the configured one
         --llm-context LAYERS, --llm-context-apply RULE, --llm-context-budget N
                     (--new) its own LLM context strategy (none, stale,forget),
                     apply rule and budget (64k, off), as chi takes them
+        --thinking LEVEL
+                    (--new) its own thinking level (off, low, medium,
+                    high; default: none of its own), above a process
+                    default such as SAMAGOTCHI_THINKING_LEVEL
         --wait      wait for the answer and print it (one session); the
                     other lines go to stderr. Exit 3: it waits for an
                     answer from you: the question, its options and the
@@ -75,6 +84,14 @@ module Samagotchi
                     nothing is sent: it waits for the session's next
                     reply, a running turn's too (after exit 3, 4 or 130,
                     wait again this way)
+        --cut       ask the running turn to cut the generation it is
+                    streaming and take the message now (a generation that
+                    has streamed only thinking for steer.cut_after; else
+                    the message waits for the thinking to pass it). A
+                    message without --cut goes in at the running turn's
+                    next step and cuts nothing. To an idle session it
+                    sends normally. Refused with --wait into a running
+                    turn (the steer's turn is the running one)
         --timeout S (--wait) give up after S seconds, exit 4 (the turn
                     goes on); default no limit
         --format json
@@ -82,7 +99,8 @@ module Samagotchi
                     status answered (text), question (question,
                     answer_with), running, or failed, canceled,
                     limit, no_answer, error, worker_gone, stopped,
-                    command (detail)
+                    command (detail); with --cut also delivery (what
+                    the worker applied) and cut (now, waits, off)
         Exit with --wait: 0 answered, 1 failed or gone, 2 usage, 3 a
         question waits, 4 still running (--timeout), 130 Ctrl-C.
         Only sessions on this machine. Answers show in the attached TUI
@@ -99,8 +117,10 @@ module Samagotchi
       f.value "--llm-context", key: :llm_strategy
       f.value "--llm-context-apply", key: :llm_apply
       f.value "--llm-context-budget", key: :llm_budget
+      f.value "--thinking"
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
+      f.switch "--cut"
       f.value "--timeout"
       f.value "--format"
       # Starting a turn in every live session at once is too easy to do
@@ -160,6 +180,7 @@ module Samagotchi
     def run_parsed(options)
       # With --wait stdout is the answer alone.
       @info = options[:wait] ? @stderr : @stdout
+      @cut = options[:cut] == true
       prompt = compose(utf8(read_stdin), utf8(options[:message]))
       # Before the wait-only case, which would drop the images.
       return usage_error("--image needs a message: pass -m TEXT or pipe it in") if prompt.nil? && !options[:images].empty?
@@ -229,7 +250,7 @@ module Samagotchi
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
 
-      %i[dir model continues].each { |key| return usage_error("--#{key} needs --new") if options[key] }
+      %i[dir model continues thinking].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
 
@@ -246,9 +267,9 @@ module Samagotchi
 
       if options[:continues]
         taken = [("--dir" if options[:dir]), ("--model" if options[:model])] +
-                LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] }
+                LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] } + [("--thinking" if options[:thinking])]
         unless taken.compact.empty?
-          return usage_error("--continues takes the previous session's folder, model and LLM context; " \
+          return usage_error("--continues takes the previous session's folder, model, LLM context and thinking level; " \
                              "leave out #{taken.compact.join(", ")}")
         end
       end
@@ -260,6 +281,15 @@ module Samagotchi
         return usage_error(e.message)
       end
 
+      if options[:thinking]
+        word = options[:thinking].strip.downcase
+        unless Thinking::LEVELS.map(&:to_s).include?(word)
+          return usage_error("--thinking takes #{Thinking::LEVELS.join(", ")}, not #{options[:thinking]}")
+        end
+
+        options[:thinking] = Thinking.session_level(word)
+      end
+
       if options[:dir]
         options[:dir] = File.expand_path(options[:dir])
         return usage_error("no folder #{options[:dir]}") unless File.directory?(options[:dir])
@@ -304,7 +334,9 @@ module Samagotchi
                     SessionManager.continue_session(options[:continues], **start, state_dir: @state_dir)
                   else
                     SessionManager.spawn_session(**start, working_directory: options[:dir],
-                                                          model_name: options[:model], llm_context: options[:llm_context],
+                                                          model_name: options[:model],
+                                                          setup: SessionSetup.new(llm_context: options[:llm_context],
+                                                                                  thinking: options[:thinking]),
                                                           state_dir: @state_dir)
                   end
       rescue SessionManager::ContinueRefused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
@@ -527,7 +559,11 @@ module Samagotchi
       owner = SessionManager.session_owner(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)
+      # --cut asks the running turn for a cut; to an idle session it is an
+      # ordinary message (there is nothing to cut).
+      delivery = @cut && running ? Delivery::CUT : nil
+      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir,
+                                               delivery: delivery)
       unless result[:status] == :accepted
         @info.puts("#{short}  failed: #{result.dig(:ack, "detail") || "could not queue it"}")
         return false
@@ -539,12 +575,12 @@ module Samagotchi
         return true
       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 refs.empty? ? " (the running turn picks it up)" : " (runs after the current turn)"
-             end
-      @info.puts("#{short}  sent#{with_images}#{note}")
+      ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      # What the worker applied, for --format json: its ack's delivery
+      # (next_step for an idle session) and a cut's outcome.
+      @sent_delivery = ack["delivery"] || delivery
+      @sent_cut = ack["cut"]
+      @info.puts("#{short}  sent#{with_images}#{delivery_note(ack, delivery: delivery, running: running, owner: owner)}")
       true
     rescue SessionManager::OwnedByTUI
       @info.puts("#{short}  refused: it is open in a chi REPL; messages need attached mode")
@@ -554,6 +590,41 @@ module Samagotchi
       false
     end
 
+    # What the line says became of the message: a plain one goes in at the
+    # running turn's next step (nothing cuts by default); a --cut one names
+    # the outcome from the ack (now, waits, off); images keep their own
+    # wording; an idle session's turn simply runs.
+    # @param ack [Hash] the Bridge's 202 body ({} for the input file)
+    # @return [String] "" or " (...)"
+    def delivery_note(ack, delivery:, running:, owner:)
+      return " (started its worker)" if owner.nil?
+      return "" unless running
+
+      # A busy worker runs a message with images as its own next turn
+      # rather than merging it into the running one.
+      return " (runs after the current turn)" unless @images.empty?
+
+      # The TUIs' words for a cut's outcome. No outcome: a plain message,
+      # or the input file (the Bridge went away), which the next step's
+      # drain takes.
+      outcome = Delivery.cut?(delivery) ? ack["cut"].to_s : ""
+      return " (goes in at the running turn's next step)" unless CUT_OUTCOMES.include?(outcome)
+
+      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym)}"
+    end
+
+    # More keys for --format json, with --cut only (the line is unchanged
+    # otherwise): the delivery the worker applied (next_step to an idle
+    # session) and a cut's outcome (now, waits, off). In P1 --cut --wait is
+    # refused for a running turn, so the json line says next_step.
+    def report_extra
+      return {} unless @cut
+
+      extra = { delivery: @sent_delivery || Delivery::NEXT_STEP }
+      extra[:cut] = @sent_cut if @sent_cut
+      extra
+    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, typed: nil)

data/lib/samagotchi/session.rb

@@ -6,7 +6,9 @@ require "securerandom"
 require "time"
 require_relative "atomic_file"
 require_relative "context_note"
+require_relative "last_turn"
 require_relative "llm_context_override"
+require_relative "session_setup"
 require_relative "prompt_note"
 
 require_relative "paths"
@@ -86,14 +88,16 @@ module Samagotchi
     # A `chi scratch` session: deleted when its REPL ends, and by the next
     # sweep (or `chi sessions clean`) when the process died first.
     attr_accessor :scratch
-    # How the last turn ended, for the web's notifications (the hub sends
-    # it in the summary): {"outcome" => "completed"|"failed"|"canceled",
-    # "ended_at" => iso8601, "seconds" => Float, "origin" =>
-    # "client"|"reminder"|"delegate"|"delegate_report"|"context"}; nil
-    # before the first turn. delegate_report: a turn a parent ran for its
-    # delegate children's reports (ChildReports); context: one an attached
-    # context source's change started (Worker).
-    attr_accessor :last_turn
+    # How the last turn ended (LastTurn), for a parent's wait (ReplyWait)
+    # and the web's notifications (the hub sends it in the summary); nil
+    # before the first turn.
+    attr_reader :last_turn
+
+    # @param value [LastTurn, Hash, nil] a file's Hash is read
+    #   (LastTurn.from_file)
+    def last_turn=(value)
+      @last_turn = LastTurn.from_file(value)
+    end
     # The session's own llm_context values (LLMContextOverride: strategy,
     # apply rule, budget), before the model's; nil when it has none.
     # Saved, so a --resume and a respawned worker keep them; a plugin's
@@ -115,13 +119,28 @@ module Samagotchi
       saved.empty? ? nil : saved
     end
 
+    # The session's own thinking level (:off, :low, :medium, :high), before
+    # the process default and the model's (Thinking.resolve); nil when it
+    # has none. Saved, so a --resume, a respawned worker and a continue keep
+    # it; a plugin's fork copies it, a delegate child starts without.
+    attr_reader :thinking
+
+    # @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 thinking=(value)
+      @thinking = Thinking.session_level(value)
+      unread = @thinking.nil? && value.is_a?(String) && !value.strip.casecmp?(Thinking::DEFAULT.to_s)
+      @thinking_unread = unread ? value : nil
+    end
+
+    # The session file's "thinking": the level, else a value it couldn't
+    # read; nil when there is neither.
+    def thinking_file = @thinking&.to_s || @thinking_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. Both strings
-    # and symbols are read (the file's keys are strings).
+    # left), e.g. "loop-guard"; nil when it ended otherwise.
     def stopped_by
-      return nil unless @last_turn.is_a?(Hash)
-
-      (@last_turn["stopped_by"] || @last_turn[:stopped_by])&.to_s
+      @last_turn&.stopped_by&.to_s
     end
     # Archived (ArchiveStore): hidden from the lists. Set by .list (with
     # include_archived); not saved in session.json.
@@ -146,7 +165,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)
+                   continues: nil, thinking: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -168,10 +187,11 @@ module Samagotchi
       @project_root = project_root
       @parent_id = parent_id&.to_s
       @scratch = !!scratch
-      @last_turn = last_turn
+      self.last_turn = last_turn
       @delegate = !!delegate
       @continues = continues&.to_s
       self.llm_context = llm_context
+      self.thinking = thinking
       @archived = false
     end
 
@@ -220,9 +240,10 @@ module Samagotchi
     # Build a new, unsaved session.
     # @param messages [Array<Hash>] a conversation to start from (a fork's
     #   seed); [] by default
+    # @param setup [SessionSetup] the session's own settings (none by default)
     def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
                          preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
-                         scratch: false, model_typed: nil, delegate: false, llm_context: nil, continues: nil)
+                         scratch: false, model_typed: nil, delegate: false, setup: SessionSetup.new, continues: nil)
       now = Time.now.iso8601(3)
       resolved_test = if test_run.nil?
                         test_session_env?
@@ -247,7 +268,8 @@ module Samagotchi
         parent_id: parent_id,
         scratch: scratch,
         delegate: delegate,
-        llm_context: llm_context,
+        llm_context: setup.llm_context,
+        thinking: setup.thinking,
         continues: continues
       )
     end
@@ -281,7 +303,8 @@ module Samagotchi
     # value for a file without it (REQUIRED for the ones it must have).
     # .from_h and #to_h both go by this table; messages and
     # pending_question change key type on the way (symbols in memory,
-    # strings on disk).
+    # strings on disk); last_turn and prompt_notes are value objects in
+    # memory (LastTurn, PromptNote).
     FIELDS = {
       "metadata_version" => 1,
       "id" => REQUIRED,
@@ -307,7 +330,8 @@ module Samagotchi
       "last_turn" => nil,
       "delegate" => false,
       "llm_context" => nil,
-      "continues" => nil
+      "continues" => nil,
+      "thinking" => nil
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -428,7 +452,9 @@ module Samagotchi
                 when "test_run" then !!@test_run
                 when "delegate" then @delegate
                 when "llm_context" then llm_context_file
+                when "thinking" then thinking_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"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")
@@ -522,11 +548,6 @@ module Samagotchi
       File.join(state_dir, "#{check_id!(session_id)}#{FILE_EXT}")
     end
 
-    # Default sessions directory path.
-    def self.default_sessions_dir
-      default_state_dir
-    end
-
     # XDG-aware sessions directory.
     def self.default_state_dir(env: ENV)
       File.join(Paths.state_home(env: env), STATE_SUBDIR)