samagotchi 0.100.1 → 0.102.0

data/lib/samagotchi/session_commands.rb

@@ -16,6 +16,8 @@ require_relative "toolkit_command"
 require_relative "parent_answers_command"
 require_relative "title_command"
 require_relative "reasoning_history_command"
+require_relative "working_set_command"
+require_relative "recap_command"
 require_relative "guardrails/parent_policy"
 
 module Samagotchi
@@ -40,6 +42,8 @@ module Samagotchi
     PARENT_ANSWERS_COMMAND = ParentAnswersCommand::NAME
     TITLE_COMMAND = TitleCommand::NAME
     REASONING_HISTORY_COMMAND = ReasoningHistoryCommand::NAME
+    WORKING_SET_COMMAND = WorkingSetCommand::NAME
+    RECAP_COMMAND = RecapCommand::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
@@ -109,6 +113,11 @@ module Samagotchi
       registry.register(TOOLKIT_COMMAND, "show or change the tools this session declares (NAME, add TOOL, remove TOOL)",
                         id: :toolkit, mid_turn: show_mid_turn(TOOLKIT_COMMAND),
                         match: ->(text) { text.match?(%r{\A/toolkit(?:\s+.*)?\z}) }) { |text| toolkit(text) }
+      # The list reads only: mid-turn too; a drop waits for the turn's end
+      # (the next turn's first request is the first with it).
+      registry.register(WORKING_SET_COMMAND, "list the working set; drop or undrop an item (drop KEY, undrop KEY)",
+                        id: :working_set, mid_turn: show_mid_turn(WORKING_SET_COMMAND),
+                        match: ->(text) { text.match?(%r{\A/working-set(?:\s+.*)?\z}) }) { |text| working_set(text) }
       # Tighten-only from anyone; loosening is a user's at a UI (#run's user_ui:).
       registry.register(PARENT_ANSWERS_COMMAND, "show or set what a parent agent may answer here (hard|standard|soft|default; " \
                                                 "never looser than config.yml's)",
@@ -119,7 +128,14 @@ module Samagotchi
                         id: :title, anytime: true, match: ->(text) { text.match?(%r{\A/title(?:\s+.*)?\z}) }) { |text| title(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)
+      # /recap with words (on|off|default, or a slip: the usage) runs here:
+      # it toggles the idle job only, so it doesn't wait for a running turn.
+      # The bare /recap shows the recap: the UIs' own, under the same name
+      # (Registry#register); /help lists the name once, with this entry's
+      # description.
+      registry.register(RECAP_COMMAND, "show the session's recap (in a terminal); on|off|default sets this session's own",
+                        id: :recap_setting, anytime: true, match: ->(text) { text.match?(%r{\A/recap\s+\S}) }) { |text| recap_setting(text) }
+      registry.register(RECAP_COMMAND, "show the session's recap", local: true, match: ->(text) { text == RECAP_COMMAND })
       # Bare `exit` too; any case; --delete after it.
       registry.register("/exit", "leave (--delete also deletes the session)", local: true,
                                                                               match: exit_match("/?exit"))
@@ -230,7 +246,9 @@ module Samagotchi
     # own (marked by UI), each group by name.
     # @return [String]
     def help_listing
-      entries = @registry.entries.sort_by { |entry| [help_group(entry), entry.name] }
+      # A name with a UI's entry and the session's (/recap): listed once,
+      # as the session's (registered first).
+      entries = @registry.entries.uniq(&:name).sort_by { |entry| [help_group(entry), entry.name] }
       width = entries.map { |entry| self.class.display_name(entry).length }.max
       lines = entries.map do |entry|
         notes = []
@@ -527,6 +545,22 @@ module Samagotchi
       reply(output, status: status, changed: changed ? [:parent_answers] : [])
     end
 
+    # /working-set (WorkingSetCommand): an op changes the conversation
+    # (changed :messages: the worker saves it, the web reads it again), so
+    # a rollback past it would drop it silently (as !cmd), and the working
+    # set goes out again (held after the command's command_ran).
+    def working_set(text)
+      output, changed, status = WorkingSetCommand.new(engine: @engine, save: ->(_session) { save_session })
+                                                 .run(text.delete_prefix(WORKING_SET_COMMAND))
+      if changed
+        @turn_flow.note_conversation_changed
+        @engine.announce_working_set
+      end
+      reply(output, status: status, changed: changed ? [:messages] : [])
+    rescue ArgumentError => e
+      reply(e.message, status: :error)
+    end
+
     # /title (TitleCommand); :title in changed when it named the session or
     # cleared its name. A plain save: no setting moved, and it may run on
     # an anytime thread beside a turn.
@@ -535,6 +569,14 @@ module Samagotchi
       reply(output, status: status, changed: changed ? [:title] : [])
     end
 
+    # /recap on|off|default (RecapCommand); :recap in changed when this
+    # session's own recap.enabled moved. It doesn't save: its host does on
+    # a changed result (Worker#run_command, the REPL).
+    def recap_setting(text)
+      output, changed, status = RecapCommand.new(engine: @engine).run(text.delete_prefix(RECAP_COMMAND))
+      reply(output, status: status, changed: changed ? [:recap] : [])
+    end
+
     # A session setting changed (/llm-context, /thinking, /reasoning-history):
     # saved with its model.
     def save_setup(session)

data/lib/samagotchi/session_config.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "version"
+require_relative "config"
+
+module Samagotchi
+  # A session's own settings (chi --set, chi send --new --set, POST
+  # /api/sessions settings), kept as one value (Settings). Its core part:
+  # {key => value} for the core config keys a session may set
+  # (Config::Entry#session?), typed by their entry (Config.coerce!) and
+  # read through Config.get(key, session:) by the readers wired to it
+  # (RecapSetup). Its
+  # bundles part: {bundle => {key => value}}, string keys, scalar values
+  # (.typed). A bundle offers the keys a session may set in its manifest's
+  # session_settings: (recorded at install, InstalledBundle#session_settings);
+  # any other bundle or key is refused, so a typo isn't saved, and so is a
+  # value of another type than the manifest gives the key (session_settings:
+  # {cap: number}). The session keeps them (Session#settings, SessionSetup)
+  # and Plugin::Context#settings lays them over config.yml's bundles: <name>:.
+  module SessionConfig
+    # A refused --set (or request field): the message says why.
+    class Error < ArgumentError; end
+
+    # A bundle name (MemoryBundle::Manifest::BUNDLE_NAME) and a setting key.
+    BUNDLE = /\A[A-Za-z0-9][A-Za-z0-9_-]*\z/
+    KEY = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
+    # The values a setting may take.
+    SCALARS = [String, Integer, Float, TrueClass, FalseClass].freeze
+    REQUEST_SHAPE = "settings is an object of KEY or BUNDLE.KEY => scalar"
+    # What --set takes, as a malformed one is told.
+    FORMS = "KEY=VALUE or BUNDLE.KEY=VALUE"
+    # What .typed reads as a number: no leading zero, no _; a decimal may
+    # leave out either side of its point (.5, 5.) and take an exponent
+    # (1e1, 2.5e-3), which YAML 1.1 leaves as text.
+    INTEGER = /\A-?(?:0|[1-9]\d*)\z/
+    DECIMAL = /\A-?(?:(?:0|[1-9]\d*)(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?\z/
+    # YAML 1.1's booleans (config.yml's), any case.
+    TRUE_WORDS = %w[true yes on].freeze
+    FALSE_WORDS = %w[false no off].freeze
+    # The shipped bundles' sources (a stale record's hint reads them).
+    SHIPPED_DIR = File.expand_path("bundles", __dir__)
+
+    # A session's own settings, as one value: +core+ its core config keys
+    # ({key => value}, .normalize_core's shape), +bundles+ its bundle
+    # settings ({bundle => {key => value}}, .normalize's shape). Both
+    # frozen, string keys; the session file keeps +core+ under
+    # config_settings and +bundles+ under bundle_settings.
+    Settings = Data.define(:core, :bundles) do
+      def initialize(core: {}, bundles: {})
+        super(core: SessionConfig.normalize_core(core), bundles: SessionConfig.normalize(bundles))
+      end
+
+      # A Settings as given, nil as none (EMPTY).
+      # @param value [Settings, nil]
+      # @return [Settings]
+      # @raise [ArgumentError] anything else
+      def self.of(value)
+        return value if value.is_a?(Settings)
+        return Settings::EMPTY if value.nil?
+
+        raise ArgumentError, "session settings are a SessionConfig::Settings, not #{value.class}"
+      end
+
+      def empty? = core.empty? && bundles.empty?
+
+      # Both parts as --set names them: {"recap.enabled" => false,
+      # "cost-cap.cap" => 3} (/stats, chi sessions stats --format json).
+      # @return [Hash{String => Object}]
+      def flat
+        core.merge(bundles.flat_map { |bundle, values| values.map { |key, value| ["#{bundle}.#{key}", value] } }.to_h)
+      end
+
+      # "recap.enabled=false · cost-cap.cap=3", "" for none.
+      def text = SessionConfig.text(flat)
+    end
+
+    # The installed bundles a session may set settings of: +offered+ the
+    # keys of each bundle whose plugin loads ({name => keys}), +notes+ what
+    # a refusal adds for a bundle ({name => text}): why its plugin doesn't
+    # load, or how to refresh a record from before session_settings;
+    # +types+ the types its manifest gives keys ({name => {key => type}}).
+    Availability = Data.define(:offered, :notes, :types) do
+      def initialize(offered:, notes:, types: {}) = super
+    end
+
+    # What each type (MemoryBundle::Manifest::SESSION_SETTING_TYPES) takes,
+    # as a value .typed gives it, and how a refusal names it. A number may
+    # be off (false), as a bundle's own settings are turned off.
+    TYPES = {
+      "number" => [->(value) { (value.is_a?(Numeric) && value.finite?) || value == false }, "a number (or off)"],
+      "boolean" => [->(value) { [true, false].include?(value) }, "true or false"],
+      "string" => [->(value) { value.is_a?(String) }, "text"]
+    }.freeze
+
+    module_function
+
+    # --set's values as typed, in order: a later one of the same key wins.
+    # A name a core config entry has (recap.enabled), or one with no dot,
+    # is a core key (.core_value: a session-settable one, typed by its
+    # entry); any other is BUNDLE.KEY, its value .typed (a key +types+
+    # gives as string keeps its text as given, .value_for).
+    # @param args [Array<String>] "KEY=VALUE" or "BUNDLE.KEY=VALUE" each
+    # @param types [Hash{String => Hash{String => String}}] Availability#types
+    # @param bundles [Hash, nil] the offered keys an unknown dotless key's
+    #   refusal names (.offered by default)
+    # @return [Settings]
+    # @raise [Error] a value of another shape, a core key no session sets
+    def parse(args, types: {}, bundles: nil)
+      core = {}
+      given = {}
+      Array(args).each do |arg|
+        target, sep, raw = arg.to_s.partition("=")
+        raise Error, "--set takes #{FORMS}, not #{arg}" if sep.empty?
+
+        name = split(target, "--set #{arg}") { raise Error, "--set takes #{FORMS}, not #{arg}" }
+        raise Error, "--set #{arg}: give a value" if raw.strip.empty?
+
+        if name.is_a?(String)
+          core[name] = core_value(name, raw, flag: "--set", bundles: bundles)
+        else
+          bundle, key = name
+          (given[bundle] ||= {})[key] = value_for(raw, types.dig(bundle, key))
+        end
+      end
+      Settings.new(core: core, bundles: given)
+    end
+
+    # +target+ (the part before =) as a core key (a String) or [bundle,
+    # key]; yields when it is no name at all.
+    def split(target, where)
+      return target if Config.find_by_key(target)
+
+      bundle, *keys = target.split(".", -1)
+      yield if keys.empty? ? !KEY.match?(bundle.to_s) : !BUNDLE.match?(bundle.to_s) || keys.any? { |key| !KEY.match?(key) }
+      return target if keys.empty?
+      raise Error, "#{where}: one key under the bundle (BUNDLE.KEY), no nested path" if keys.size > 1
+
+      [bundle, keys.first]
+    end
+
+    # A core key's value: +key+ names a session-settable entry, and +raw+
+    # types as it (Config.coerce!) and passes its check:.
+    # @raise [Error] "FLAG KEY: why"
+    def core_value(key, raw, flag:, bundles: nil)
+      entry = Config.find_by_key(key)
+      raise Error, "#{flag} #{key}: #{unknown_core(key, bundles: bundles)}" unless entry
+      raise Error, "#{flag} #{key}: #{key} is not a session setting (#{settable_text})" unless entry.session?
+
+      value = begin
+        Config.coerce!(entry, raw)
+      rescue Error => e
+        raise Error, "#{flag} #{key}: #{e.message}"
+      end
+      if (takes = entry.check&.call(value))
+        raise Error, "#{flag} #{key}: #{key} takes #{takes}, not #{raw.to_s.inspect}"
+      end
+
+      value
+    end
+
+    # Why +key+ (no config entry) is no session setting, with the settable
+    # keys it is near; a dotless or non-core-section key also names the
+    # bundles that take --set (it may have meant one).
+    def unknown_core(key, bundles: nil)
+      near = Config.near_names(key, Config.session_entries.map(&:key))
+      hint = near.empty? ? settable_text : "did you mean #{near.join(" or ")}?"
+      hint = "#{hint}; #{takers(bundles || offered)}" unless core_section?(key.split(".").first)
+      "no session setting #{key} (#{hint})"
+    end
+
+    # "session settings: recap.enabled, recap.sentences"
+    def settable_text = "session settings: #{Config.session_entries.map(&:key).join(", ")}"
+
+    # Whether +name+ is a core config section (recap, guardrails).
+    def core_section?(name) = Config::ENTRIES.any? { |entry| entry.yaml_path.size > 1 && entry.section == name }
+
+    # +settings+ (a Settings, or its bundles part) when every bundle is
+    # installed and offers each key; a bundle that isn't installed but
+    # names a core section (recap.enable) is a core key no session sets.
+    # Its core part was checked as it was typed (.parse, .from_request).
+    # @param bundles [Hash{String => Array<String>}] the installed bundles'
+    #   offered keys (.offered)
+    # @param notes [Hash{String => String}] Availability#notes
+    # @param types [Hash{String => Hash{String => String}}] Availability#types:
+    #   a typed key's value must be of its type (TYPES)
+    # @param flag [String] what a refusal names ("--set", a request field)
+    # @return [Settings, Hash] +settings+
+    # @raise [Error]
+    def check!(settings, bundles: offered, notes: {}, types: {}, flag: "--set")
+      (settings.is_a?(Settings) ? settings.bundles : settings).each do |bundle, values|
+        keys = bundles[bundle]
+        note = notes[bundle]
+        values.each do |key, value|
+          where = "#{flag} #{bundle}.#{key}"
+          if keys.nil?
+            raise Error, "#{where}: #{unknown_core("#{bundle}.#{key}", bundles: bundles)}" if note.nil? && core_section?(bundle)
+
+            raise Error, "#{where}: #{note || "no installed bundle #{bundle} (#{takers(bundles)})"}"
+          end
+          raise Error, "#{where}: #{bundle} takes no session settings#{" #{note}" if note}" if keys.empty?
+          raise Error, "#{where}: #{bundle} takes #{keys.join(", ")}" unless keys.include?(key)
+
+          takes, what = TYPES[types.dig(bundle, key)]
+          raise Error, "#{where}: #{bundle} takes #{what} for #{key}, not #{value.inspect}" if takes && !takes.call(value)
+        end
+      end
+      settings
+    end
+
+    # --set's values parsed and checked (.parse, .check!) against the
+    # installed bundles (.availability).
+    # @return [Settings]
+    def from_flags(args, available: availability)
+      check!(parse(args, types: available.types, bundles: available.offered), bundles: available.offered, notes: available.notes, types: available.types)
+    end
+
+    # A value as --set (and a request's string) gives it: an integer
+    # ("3", "-1"), a decimal ("2.5", ".5", "1e1"), a boolean as config.yml's
+    # YAML reads one (true/yes/on, false/no/off, any case); any other string
+    # stays as given ("010", "0x10", "3:30", "y", "null"). A value that
+    # isn't a String (a JSON number or boolean) is kept.
+    def typed(value)
+      return value unless value.is_a?(String)
+      return Integer(value, 10) if INTEGER.match?(value)
+
+      if DECIMAL.match?(value)
+        number = Float(float_text(value))
+        # 1e400 is Infinity: no cap reaches it and JSON can't save it.
+        return number.finite? ? number : value
+      end
+
+      word = value.downcase
+      return true if TRUE_WORDS.include?(word)
+      return false if FALSE_WORDS.include?(word)
+
+      value
+    end
+
+    # A value for a key of +type+: a string key's text as given (--set
+    # b.name=yes stays "yes"), any other's .typed.
+    def value_for(value, type) = type == "string" ? value : typed(value)
+
+    # A decimal DECIMAL matches as Float reads it on every Ruby: a point
+    # with no digit after it ("5.", "5.e1") gets a 0, which Ruby 3.3's
+    # Float wants.
+    def float_text(value) = value.sub(/\.(?=e|\z)/i, ".0")
+
+    # POST /api/sessions settings: nil for none, else an object of names
+    # as --set gives them (KEY or BUNDLE.KEY) to scalars (a string typed as
+    # --set types it), checked like --set.
+    # @param bundles [Hash, nil] the offered keys (.availability's by default)
+    # @param types [Hash] their types, with +bundles+ (Availability#types)
+    # @return [Settings]
+    # @raise [Error]
+    def from_request(raw, bundles: nil, types: {})
+      return Settings::EMPTY if raw.nil?
+      raise Error, REQUEST_SHAPE unless raw.is_a?(Hash) && scalar_map?(raw)
+      return Settings::EMPTY if raw.empty?
+
+      available = bundles ? Availability.new(offered: bundles, notes: {}, types: types) : availability
+      core = {}
+      given = {}
+      raw.each do |target, value|
+        target = target.to_s
+        name = split(target, "settings #{target}") { raise Error, "settings takes KEY or BUNDLE.KEY names, not #{target.inspect}" }
+        raise Error, "settings #{target}: give a value" if value.is_a?(String) && value.strip.empty?
+
+        if name.is_a?(String)
+          core[name] = core_value(name, value, flag: "settings", bundles: available.offered)
+        else
+          bundle, key = name
+          (given[bundle] ||= {})[key] = value_for(value, available.types.dig(bundle, key))
+        end
+      end
+      check!(Settings.new(core: core, bundles: given), bundles: available.offered, notes: available.notes,
+                                                       types: available.types, flag: "settings")
+    end
+
+    # Each installed bundle's offered keys, by name (Availability#offered).
+    # @return [Hash{String => Array<String>}]
+    def offered(dir: nil) = availability(dir: dir).offered
+
+    # The installed bundles a session may set settings of: a record that
+    # doesn't read is left out, and so is one whose plugin doesn't load as
+    # chi's loader decides (Plugin::Loader#unloadable_reason: requires_chi,
+    # the file, its sha256), with a note saying why. A record with no
+    # session_settings whose shipped bundle lists some (installed before
+    # them) gets a note on refreshing it.
+    # @return [Availability]
+    def availability(dir: nil, shipped_dir: SHIPPED_DIR)
+      require_relative "memory_bundle/provenance"
+      require_relative "memory_bundle/manifest"
+      dir ||= MemoryBundle::Provenance.bundles_dir
+      offered = {}
+      notes = {}
+      types = {}
+      MemoryBundle::Provenance.each_installed(dir: dir) do |name, bundle|
+        next if bundle.error?
+
+        if (reason = unloadable(dir, name, bundle))
+          notes[name] = "#{name} is installed but its plugin doesn't load: #{reason}"
+          next
+        end
+        offered[name] = bundle.session_settings
+        types[name] = bundle.session_setting_types unless bundle.session_setting_types.empty?
+        if bundle.session_settings.empty? && shipped_settings?(shipped_dir, name)
+          notes[name] = "(run `chi update` or `chi bundle upgrade #{name}` to refresh it)"
+        end
+      end
+      Availability.new(offered: offered, notes: notes, types: types)
+    end
+
+    # A session file's value, read tolerantly: the bundles that map to
+    # settings, the scalar ones of those, string keys, frozen; {} for
+    # anything else.
+    # @return [Hash{String => Hash{String => Object}}]
+    def normalize(raw)
+      return {}.freeze unless raw.is_a?(Hash)
+
+      deep_freeze(raw.each_with_object({}) do |(bundle, values), acc|
+        next unless values.is_a?(Hash)
+
+        kept = values.each_with_object({}) do |(key, value), scalars|
+          scalars[key.to_s] = value if SCALARS.any? { |kind| value.is_a?(kind) }
+        end
+        acc[bundle.to_s] = kept unless kept.empty?
+      end)
+    end
+
+    # Settings#core read tolerantly: the session-settable keys
+    # (Config::Entry#session?) whose value types as their entry and passes
+    # its check:, typed, string keys, frozen; {} for anything else (a key
+    # that is no longer settable, a hand-edited value).
+    # @return [Hash{String => Object}]
+    def normalize_core(raw)
+      return {}.freeze unless raw.is_a?(Hash)
+
+      raw.each_with_object({}) do |(key, value), kept|
+        entry = Config.find_by_key(key.to_s)
+        next unless entry&.session? && SCALARS.any? { |kind| value.is_a?(kind) }
+
+        typed = begin
+          Config.coerce!(entry, value)
+        rescue Error
+          next
+        end
+        next if typed.nil? || entry.check&.call(typed)
+
+        kept[entry.key] = typed.frozen? ? typed : typed.dup.freeze
+      end.freeze
+    end
+
+    # "KEY=VALUE · KEY=VALUE" for {key => value} (Settings#flat), "" for none.
+    def text(flat) = flat.map { |key, value| "#{key}=#{value}" }.join(" · ")
+
+    # Why a bundle +name+ can't offer the session settings +keys+: one
+    # whose NAME.KEY is a session-settable core key (--set NAME.KEY sets
+    # chi's), nil when none clashes. The install refuses it and chi bundle
+    # check reports it (clash), in these words.
+    # @return [String, nil]
+    def clash(name, keys)
+      clashing = Array(keys).map { |key| "#{name}.#{key}" } & Config.session_entries.map(&:key)
+      return nil if clashing.empty?
+
+      "session_settings: #{clashing.join(", ")} #{clashing.size == 1 ? "is" : "are"} chi's own session " \
+        "setting#{"s" unless clashing.size == 1} (--set #{clashing.first}=… sets chi's); rename the setting or the bundle"
+    end
+
+    # Why +bundle+'s plugin doesn't load, as chi's loader decides it
+    # (Plugin::Loader.unloadable_reason), nil when it does or has none.
+    def unloadable(dir, name, bundle)
+      return nil unless bundle.plugin
+
+      require_relative "plugin/loader"
+      # +dir+, not Provenance#plugin_path's bundles_dir: a spec's records live elsewhere.
+      Plugin::Loader.unloadable_reason(File.join(dir, name, "plugin", bundle.plugin.file.to_s), bundle)
+    end
+
+    # Whether chi ships a bundle +name+ whose manifest lists session_settings.
+    def shipped_settings?(shipped_dir, name)
+      path = File.join(shipped_dir, name, "manifest.yml")
+      return false unless File.file?(path)
+
+      raw = YAML.safe_load_file(path)
+      listed = raw.is_a?(Hash) ? raw["session_settings"] : nil
+      (listed.is_a?(Array) || listed.is_a?(Hash)) && !listed.empty?
+    rescue Psych::Exception, SystemCallError
+      false
+    end
+
+    def scalar_map?(values)
+      values.is_a?(Hash) && values.values.all? { |value| SCALARS.any? { |kind| value.is_a?(kind) } }
+    end
+
+    def takers(bundles)
+      names = bundles.reject { |_, keys| keys.empty? }.keys.sort
+      names.empty? ? "no installed bundle takes --set" : "bundles that take --set: #{names.join(", ")}"
+    end
+
+    def deep_freeze(settings)
+      settings.to_h { |bundle, values| [bundle.dup.freeze, values.to_h { |k, v| [k.dup.freeze, v.frozen? ? v : v.dup.freeze] }.freeze] }.freeze
+    end
+
+    private_class_method :unloadable, :shipped_settings?, :scalar_map?, :takers, :deep_freeze, :split, :unknown_core,
+                         :settable_text, :core_section?
+
+    # No settings (built once the module's functions are defined).
+    Settings::EMPTY = Settings.new
+  end
+end

data/lib/samagotchi/session_setup.rb

@@ -4,7 +4,7 @@ require_relative "llm_context_override"
 require_relative "reasoning_history"
 require_relative "thinking"
 require_relative "toolkit"
-require_relative "bundle_session_settings"
+require_relative "session_config"
 
 module Samagotchi
   # A session's own settings that come before its model's, carried as one
@@ -16,9 +16,9 @@ module Samagotchi
   # +appended_prompt_files+ the absolute paths chi --append-system-prompt
   # named (their text goes into the system prompt; [] with none),
   # +toolkit+ a Toolkit or nil (SessionManager.spawn_session gives the
-  # session config's toolkit.default then), +bundle_settings+ the bundle
-  # settings chi --set gave ({bundle => {key => value}}, frozen; {} with
-  # none), which Plugin::Context#settings lays over config.yml's,
+  # session config's toolkit.default then), +settings+ the session's own
+  # settings chi --set gave (SessionConfig::Settings; its bundles part is
+  # what Plugin::Context#settings lays over config.yml's),
   # +parent_answers+ the session's own guardrails.parent_answers (a level
   # String, tighten-only: Guardrails::ParentPolicy.effective) or nil.
   #
@@ -27,17 +27,17 @@ module Samagotchi
   # without one (but the toolkit its delegate call named, and its parent's
   # parent_answers); a continue and a fork copy their session's (.of).
   SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit,
-                             :bundle_settings, :parent_answers) do
+                             :settings, :parent_answers) do
     def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil,
-                   bundle_settings: {}, parent_answers: nil)
+                   settings: nil, parent_answers: nil)
       super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
             appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit,
-            bundle_settings: BundleSessionSettings.normalize(bundle_settings), parent_answers: parent_answers&.to_s)
+            settings: SessionConfig::Settings.of(settings), parent_answers: parent_answers&.to_s)
     end
 
     def empty?
       llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil? &&
-        bundle_settings.empty? && parent_answers.nil?
+        settings.empty? && parent_answers.nil?
     end
 
     # A session's own setup, for a session that starts from it. Its
@@ -50,7 +50,7 @@ module Samagotchi
 
       new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
           appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit),
-          bundle_settings: session.bundle_settings, parent_answers: session.parent_answers)
+          settings: session.settings, parent_answers: session.parent_answers)
     end
   end
 end

data/lib/samagotchi/sessions_command.rb

@@ -39,7 +39,7 @@ module Samagotchi
         prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]
         clean [--dry-run] [--days N] [--all]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days
              --all: every session, not only test and scratch ones (by the age and count limits, as prune)
-        stats ID [--format text|json]   # a session's cost, tokens and progress, without running a model turn:
+        stats ID [--format text|json]   # a session's cost, tokens, progress and own settings, without running a model turn:
              a live worker's GET stats, else the snapshot its saved analytics.json rebuilds (never starts a worker)
       Defaults: days=14 keep=500 keep_status=none (config: session.retention_days, session.max_count, session.keep_status)
     TEXT
@@ -323,10 +323,14 @@ module Samagotchi
       end
 
       metrics, live, note = stats_snapshot_for(session)
+      # The session's own settings (chi --set), as --set names them.
+      settings = session.settings.flat
       if format == "json"
-        @stdout.puts JSON.generate({ session_id: session.id, status: session.status, live: live, metrics: metrics })
+        @stdout.puts JSON.generate({ session_id: session.id, status: session.status, live: live, metrics: metrics,
+                                     settings: settings })
       else
         @stdout.puts "#{session.id[0, 8]}  #{session.status.ljust(7)} #{session.model_name}"
+        metrics = metrics.merge(settings: settings) if metrics && !settings.empty?
         @stdout.puts TerminalUI::Formatting.format_session_metrics(metrics)
         @stdout.puts note if note
       end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -51,7 +51,7 @@ module Samagotchi
       #   session keeps its own
       # @param toolkit_flags [Array<String>] which of those were given, for
       #   the line an existing session's run prints (--set too)
-      # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
+      # @param settings [SessionConfig::Settings, nil] --set's values:
       #   a new session's setup carries them; an existing session keeps its own
       # @param parent_answers [String, nil] --parent-answers: a new session's
       #   own guardrails.parent_answers; an existing session keeps its own
@@ -64,12 +64,12 @@ module Samagotchi
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
               memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-              toolkit_flags: [], bundle_settings: {}, parent_answers: nil, state_dir: nil)
+              toolkit_flags: [], settings: nil, parent_answers: nil, state_dir: nil)
         state_dir ||= Session.default_state_dir
         client = connect(attach: attach, shared: shared, resume: resume, model: model, state_dir: state_dir,
                          memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
                          appended_prompt_files: appended_prompt_files, toolkit: toolkit, toolkit_flags: toolkit_flags,
-                         bundle_settings: bundle_settings, parent_answers: parent_answers)
+                         settings: settings, parent_answers: parent_answers)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
@@ -143,7 +143,7 @@ module Samagotchi
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
                   memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-                  toolkit_flags: [], bundle_settings: {}, parent_answers: nil, err: $stderr)
+                  toolkit_flags: [], settings: nil, parent_answers: nil, err: $stderr)
         sd = state_dir || Session.default_state_dir
         if attach || resume
           warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files,
@@ -165,7 +165,7 @@ module Samagotchi
                                                  setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
                                                                          thinking: Thinking.session_level(thinking),
                                                                          appended_prompt_files: appended_prompt_files,
-                                                                         toolkit: toolkit, bundle_settings: bundle_settings,
+                                                                         toolkit: toolkit, settings: settings,
                                                                          parent_answers: parent_answers))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -968,7 +968,8 @@ module Samagotchi
         return @screen.commit("(no recap: the worker did not answer)") unless answer
 
         @screen.commit(recap_command_text(enabled: answer["enabled"], saved: answer["saved"],
-                                          request: answer["request"], min_user_turns: answer["min_user_turns"]))
+                                          request: answer["request"], min_user_turns: answer["min_user_turns"],
+                                          session_off: answer["session_off"] == true))
       rescue SystemCallError, IOError
         @screen.commit("(no recap: the worker did not answer)")
       end