samagotchi 0.100.1 → 0.102.0

data/lib/samagotchi/llm_context_edit.rb

@@ -14,17 +14,21 @@ module Samagotchi
   # are replaced, never changed in place (.store), or an edit would reach
   # a checkpoint it was rolled back from.
   #
-  # kind: :stale (chi saw a later read or edit supersede it) or :forget
-  # (the model forgot it, its note keeping the finding); note: what the
-  # stub says; by: who made it ("chi", the model); staged_at/applied_at:
+  # kind: :stale (chi saw a later read or edit supersede it), :forget
+  # (the model forgot it, its note keeping the finding) or :drop (the user
+  # dropped it from the working set: WorkingSetSteer; sent whatever the
+  # strategy, LLMContextView#sends?); note: what the
+  # stub says; by: who made it ("chi", the model, "user"); staged_at/applied_at:
   # ISO 8601 times, applied_at nil while it waits to reach the prompt;
   # keep: the output's lines a forget keeps ([[first, last], …], as the
   # model named them; saved only when there are some), sent under the
   # stub; keep_offset: what those numbers are past the output's own lines
   # (a ranged read's start_line - 1: a read's keep names file lines; saved
-  # only when not 0).
-  LLMContextEdit = Data.define(:id, :kind, :note, :by, :staged_at, :applied_at, :keep, :keep_offset) do
-    def initialize(keep: [], keep_offset: 0, **fields) = super
+  # only when not 0); was: a drop's, the edit the output held before it
+  # (its saved Hash: an applied forget sent whole under none, a staged
+  # one, a stale stub), which an undrop puts back (one edit per id).
+  LLMContextEdit = Data.define(:id, :kind, :note, :by, :staged_at, :applied_at, :keep, :keep_offset, :was) do
+    def initialize(keep: [], keep_offset: 0, was: nil, **fields) = super
 
     def applied? = !applied_at.nil?
 
@@ -33,19 +37,27 @@ module Samagotchi
     # What the model reads instead of the output, after the output's
     # "[name]" lead.
     def stub
-      kind == :forget ? "(forgotten) #{note}" : note.to_s
+      case kind
+      when :forget then "(forgotten) #{note}"
+      when :drop then LLMContextEdit::DROP_STUB
+      else note.to_s
+      end
     end
 
     # The saved form, without the id (it is the key).
     def to_h
       saved = { "kind" => kind.to_s, "note" => note, "by" => by, "staged_at" => staged_at, "applied_at" => applied_at }
       saved = saved.merge("keep" => keep) if keep?
-      keep_offset.zero? ? saved : saved.merge("keep_offset" => keep_offset)
+      saved = saved.merge("keep_offset" => keep_offset) unless keep_offset.zero?
+      was ? saved.merge("was" => was) : saved
     end
   end
 
   class LLMContextEdit
-    KINDS = %i[stale forget].freeze
+    KINDS = %i[stale forget drop].freeze
+    # A user's drop is sent whatever the strategy (no layer names it).
+    DROP = :drop
+    DROP_STUB = "(dropped by the user) — read it again if the task needs it"
 
     # +hash+ as saved (string or symbol keys), or nil for one of no known
     # kind.
@@ -58,7 +70,8 @@ module Samagotchi
 
       new(id: id.to_s, kind: kind, note: field.call(:note).to_s, by: field.call(:by), staged_at: field.call(:staged_at),
           applied_at: field.call(:applied_at), keep: ranges(field.call(:keep)),
-          keep_offset: field.call(:keep_offset).is_a?(Integer) ? [field.call(:keep_offset), 0].max : 0)
+          keep_offset: field.call(:keep_offset).is_a?(Integer) ? [field.call(:keep_offset), 0].max : 0,
+          was: field.call(:was).is_a?(Hash) ? field.call(:was) : nil)
     end
 
     # Saved keep ranges as [[first, last], …]: pairs of positive Integers,
@@ -87,6 +100,15 @@ module Samagotchi
       entry
     end
 
+    # Whether +entry+ holds a saved drop (applied or not): the cheap check
+    # LLMContextView#messages makes under none.
+    def self.drop_on?(entry)
+      saved = entry[:edits]
+      saved.is_a?(Hash) && saved.each_value.any? do |hash|
+        hash.is_a?(Hash) && (hash["kind"] || hash[:kind]).to_s == "drop"
+      end
+    end
+
     # The edits saved on +entry+, by id.
     # @return [Hash{String => LLMContextEdit}]
     def self.on(entry)

data/lib/samagotchi/llm_context_forget.rb

@@ -9,6 +9,7 @@ require_relative "llm_context_stale"
 require_relative "llm_context_apply"
 require_relative "llm_context_view"
 require_relative "tools/forget_outputs"
+require_relative "working_set_steer"
 
 module Samagotchi
   # The forget layer (LLMContextStrategy :forget, experimental): the
@@ -33,7 +34,9 @@ module Samagotchi
   #   read (CLM's lesson);
   # - a keep that holds all of the output, an output too small for a stub
   #   to free anything (SMALL), an output already stubbed or forgotten, an
-  #   id nothing in context has.
+  #   id nothing in context has;
+  # - an output the user dropped (WorkingSetSteer): neither forgotten nor
+  #   restored by the model, in WorkingSetSteer::Refused's words.
   # A read is never restored: reading the file again is its restore, and
   # the file may have changed.
   module LLMContextForget
@@ -123,7 +126,10 @@ module Samagotchi
     # the model's latest outputs.
     def refusal(conversation, output, keep, last, protect_steps, kept_reads)
       return "no output with that id in context (ids look like t42)" unless output
-      return "already forgotten or stubbed" if LLMContextEdit.on(conversation[output.index]).key?(output.ref.id)
+
+      held = LLMContextEdit.on(conversation[output.index])[output.ref.id]
+      return WorkingSetSteer::Refused.text(:dropped) if held&.kind == LLMContextEdit::DROP
+      return "already forgotten or stubbed" if held
       if protect_steps.positive? && output.step >= last - protect_steps
         return "from your last #{protect_steps} step#{"s" unless protect_steps == 1}; you may still need it, forget it later"
       end
@@ -172,7 +178,10 @@ module Samagotchi
       ids.each do |id|
         output = outputs[id]
         edit = output && LLMContextEdit.on(conversation[output.index])[id]
-        if edit.nil? || edit.kind != :forget
+        if edit&.kind == LLMContextEdit::DROP
+          # The user's: only the user takes it back (/working-set undrop).
+          refused[id] = WorkingSetSteer::Refused.text(:dropped)
+        elsif edit.nil? || edit.kind != :forget
           refused[id] = "not forgotten"
         elsif output.read? && edit.applied?
           refused[id] = "a read: read the file again instead (it may have changed)"

data/lib/samagotchi/llm_context_view.rb

@@ -5,6 +5,7 @@ require_relative "tool_response"
 require_relative "tool_ids"
 require_relative "llm_context_edit"
 require_relative "llm_context_stale"
+require_relative "llm_context_strategy"
 
 module Samagotchi
   # What the model is sent of the stored conversation: the one step
@@ -15,11 +16,14 @@ module Samagotchi
   #
   # Under +none+ (the default) nothing changes: #messages returns the
   # conversation it was given, the same Array of the same entries, so the
-  # prompt is byte for byte what it was before the view existed.
+  # prompt is byte for byte what it was before the view existed. The one
+  # exception is the user's layer: an applied :drop (WorkingSetSteer, the
+  # working set's drop) is sent as its stub under every strategy, none
+  # too; a conversation without one is still returned as it is.
   #
-  # Under a strategy of layers (:stale, :forget), each applied edit saved
-  # on a tool_response entry (LLMContextEdit) whose kind is one of the
-  # layers sends that run's output as its stub. The entry stays where it
+  # Under a strategy of layers (:stale, :forget), each edit saved on a
+  # tool_response entry (LLMContextEdit) that #sends? (applied, and its
+  # kind one of the layers) sends that run's output as its stub. The entry stays where it
   # is, with its role and tool_call_id, so a call keeps its response and
   # the image plan (which indexes by entry) lines up. A stub keeps the
   # output's "[name]" lead (Gemma's prompt writes response:NAME from it),
@@ -44,7 +48,10 @@ module Samagotchi
   # (re-reading the file is a read's restore).
   class LLMContextView
     NONE = :none
-    LAYERS = LLMContextEdit::KINDS
+    # The strategy's layers (LLMContextStrategy::LAYERS), not the edit
+    # kinds (LLMContextEdit::KINDS): a kind no strategy names never
+    # becomes a layer, whatever a caller passes as the strategy.
+    LAYERS = LLMContextStrategy::LAYERS
 
     # @return [Array<Symbol>] the layers; empty under none
     attr_reader :layers
@@ -78,7 +85,7 @@ module Samagotchi
     # @param conversation [Array<Hash>] the stored entries, in order
     # @return [Array<Hash>] the entries to format
     def messages(conversation)
-      return conversation if none?
+      return conversation if none? && conversation.none? { |entry| LLMContextEdit.drop_on?(entry) }
 
       group = Group.new
       group.paired = forget? ? LLMContextStale.paired_runs(conversation).to_set { |run| run.ref.id } : Set.new
@@ -87,6 +94,11 @@ module Samagotchi
 
     def forget? = layers.include?(:forget)
 
+    # Whether +edit+ (an LLMContextEdit) is sent: the one rule for which
+    # edits the view applies, applied and of one of the layers, or the
+    # user's drop (always on: no strategy names it).
+    def sends?(edit) = edit.applied? && (edit.kind == LLMContextEdit::DROP || layers.include?(edit.kind))
+
     # The forget whose stub carries the note the next forgotten output of
     # the same call points to: its first id and its note, author and stamp.
     # +paired+: the ids of the runs that pair with their calls.
@@ -100,7 +112,7 @@ module Samagotchi
     def edited(conversation, entry, index, group)
       return entry unless entry[:role].to_s == "tool_response"
 
-      edits = LLMContextEdit.on(entry).select { |_id, edit| edit.applied? && layers.include?(edit.kind) }
+      edits = LLMContextEdit.on(entry).select { |_id, edit| sends?(edit) }
       return entry if edits.empty? && !forget?
 
       refs = ToolIds.refs_at(conversation, index)

data/lib/samagotchi/memory_bundle/installer.rb

@@ -259,6 +259,8 @@ module Samagotchi
         @source_owned = prepared.owned
         @source_commit = prepared.commit
         @manifest = Manifest.read(dir: @bundle_dir)
+        clash = @manifest.session_settings_clash
+        raise InstallError, clash if clash
       rescue SourceNormalizer::UnknownSourceError => e
         raise InstallError, "Source normalization failed: #{e.message}"
       rescue Manifest::ValidationError => e

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -93,6 +93,17 @@ module Samagotchi
         @session_setting_types = self.class.parse_session_setting_types(raw["session_settings"])
       end
 
+      # Why the install refuses this bundle's session_settings: a key whose
+      # NAME.KEY is chi's own session setting (SessionConfig.clash, the
+      # words chi bundle check reports too), nil when none clashes.
+      # @return [String, nil]
+      def session_settings_clash
+        return nil if @session_settings.empty?
+
+        require_relative "../session_config"
+        SessionConfig.clash(@name, @session_settings)
+      end
+
       # A profile: it installs the bundles in includes instead of files.
       def meta?
         !@includes.empty?
@@ -171,11 +182,11 @@ module Samagotchi
         File.write(File.join(dir, "manifest.yml"), YAML.dump(manifest))
       end
 
-      # A setting key a session may set (BundleSessionSettings::KEY).
+      # A setting key a session may set (SessionConfig::KEY).
       SESSION_SETTING = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
 
       # The types a session setting may be given (session_settings: {key:
-      # type}), checked by BundleSessionSettings.check!: number (or off),
+      # type}), checked by SessionConfig.check!: number (or off),
       # boolean, string; any (or a list's key) takes every scalar.
       SESSION_SETTING_TYPES = %w[number boolean string any].freeze
 

data/lib/samagotchi/message_parts.rb

@@ -187,6 +187,9 @@ module Samagotchi
       mark[:staged] = true unless edit.applied?
       if edit.kind == :stale
         mark[:note] = edit.note[/superseded by .*\z/] || edit.note
+      elsif edit.kind == LLMContextEdit::DROP
+        # The user's: no note, no grouping (a forget's key is its note).
+        mark[:by] = edit.by
       else
         key = [edit.note, edit.by, edit.staged_at]
         if first.key?(key)
@@ -201,12 +204,14 @@ module Samagotchi
       mark
     end
 
-    # +output+'s ✂ mark (+marks+ by +id+); an applied stale stub says
-    # what it frees: its output, ~chars/4.
+    # +output+'s ✂ mark (+marks+ by +id+); an applied stale stub or a
+    # user's drop says what it frees: its output, ~chars/4.
+    WHOLE_STUBS = %w[stale drop].freeze
+
     def mark_of(id, marks, output)
       mark = marks[id]
       return nil unless mark
-      return mark unless mark[:kind] == "stale" && !mark[:staged] && output
+      return mark unless WHOLE_STUBS.include?(mark[:kind]) && !mark[:staged] && output
 
       mark.merge(tokens: (output.length / TokenUsage::CHARS_PER_TOKEN).ceil)
     end

data/lib/samagotchi/plugin/context.rb

@@ -104,7 +104,7 @@ module Samagotchi
 
       # config.yml `bundles: <bundle>:` with the session's own values for
       # the bundle laid over it (chi --set BUNDLE.KEY=VALUE, through the
-      # Host's setup: SessionSetup#bundle_settings), string keys, frozen.
+      # Host's setup: SessionSetup#settings's bundles), string keys, frozen.
       # Plugin init and chi.ctx run before the session is bound: with no
       # session id yet it is the config alone, and it is built again once
       # per session id (the session's values never change after it starts).
@@ -473,7 +473,7 @@ module Samagotchi
       # The session's own values for this bundle ({} without any; nil when
       # the Host couldn't tell them, so #settings can retry).
       def session_values(id)
-        values = @host.setup&.call&.bundle_settings
+        values = @host.setup&.call&.settings&.bundles
         values.is_a?(Hash) ? values.fetch(@bundle, {}) : {}
       rescue StandardError => e
         unless (@session_settings_unread ||= {}).key?(id)

data/lib/samagotchi/prompt.rb

@@ -27,7 +27,7 @@ module Samagotchi
   #   - Generation cue: <|im_start|>assistant\n
   module Prompt
     # Tail system messages whose text isn't the harness's own.
-    ESCAPED_KINDS = %w[note turn_note context].freeze
+    ESCAPED_KINDS = %w[note turn_note context working_set].freeze
 
     # @param messages [Array<Hash>] each element has :role and :content.
     #   Recognised roles: "system", "user", "model", "tool_response".

data/lib/samagotchi/recap_command.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Samagotchi
+  # /recap on|off|default, the setting form of /recap (the bare /recap,
+  # which shows the recap, is the UIs' own): this session's own
+  # recap.enabled (Engine#recap_override=), the same value
+  # `chi --set recap.enabled=…` saves, applied at once (the idle recap job
+  # is rebuilt or dropped). `default` removes it, and config.yml (or env)
+  # decides again. The session's value beats config.yml's: `/recap on`
+  # turns it on under `recap: false` too. It doesn't save: its host does
+  # on the reply's changed: [:recap] (Worker#run_command).
+  class RecapCommand
+    NAME = "/recap"
+    CHOICES = { "on" => true, "off" => false, "default" => nil }.freeze
+    USAGE = "usage: #{NAME} [on|off|default]".freeze
+
+    # @param engine [Engine] #session, #recap_override=, #recap
+    def initialize(engine:)
+      @engine = engine
+    end
+
+    # @param args [String] what follows /recap
+    # @return [Array(String, Boolean, Symbol)] the reply, whether this
+    #   session's recap setting changed, and :ok or :error
+    def run(args)
+      word = args.to_s.strip.downcase
+      return [USAGE, false, :error] unless CHOICES.key?(word)
+      return ["no session yet", false, :error] unless @engine.session
+
+      value = CHOICES.fetch(word)
+      changed = @engine.recap_override != value
+      @engine.recap_override = value if changed
+      [status_line(value), changed, :ok]
+    end
+
+    # "recap: off (this session; config.yml: on)", "recap: on (config.yml)".
+    # @param own [Boolean, nil] the session's own value, nil for none
+    def status_line(own)
+      from_config = self.class.config_status
+      line = if own.nil?
+               "recap: #{word(from_config[:on])} (#{from_config[:source]})"
+             else
+               "recap: #{word(own)} (this session; #{from_config[:source]}: #{word(from_config[:on])})"
+             end
+      # On by its own word, yet no job: a pinned recap host or model that
+      # doesn't resolve (warned in the log), or an embedder's recap: false.
+      on = own.nil? ? from_config[:on] : own
+      on && @engine.recap.nil? ? "#{line}; no recap is written: its host or model doesn't resolve (see the log)" : line
+    end
+
+    # Whether the recap is on without the session's own value: off by a
+    # scalar `recap: false`, `recap: {enabled: false}` or
+    # SAMAGOTCHI_RECAP_ENABLED=false (ConfigFile.recap_config sees all
+    # three), else on (the default).
+    # @return [Hash] {on: Boolean, source: "config.yml" or "env"}
+    def self.config_status
+      on = ConfigFile.recap_config != false
+      _value, origin = Config.get_with_origin("recap.enabled")
+      { on: on, source: origin == :env ? "env" : "config.yml" }
+    end
+
+    private
+
+    def word(enabled) = enabled ? "on" : "off"
+  end
+end

data/lib/samagotchi/recap_setup.rb

@@ -7,8 +7,10 @@ require_relative "idle_target"
 require_relative "recap_store"
 
 module Samagotchi
-  # Builds (or disables) an Engine's idle recap job from the `recap:` kwarg
-  # and the Config registry. Init-only: the Engine keeps the job it returns.
+  # Builds (or disables) an Engine's idle recap job from the `recap:` kwarg,
+  # the session's own settings and the Config registry. The Engine builds
+  # one at start, and again when it binds a session whose own recap values
+  # differ (Engine#session=).
   module RecapSetup
     # Build (or disable) the idle recap job. On by default: with no recap
     # host or model configured it asks the session's current model on its
@@ -18,9 +20,10 @@ module Samagotchi
     # --model goes; an incomplete one warns and leaves recap off.
     #
     # Single precedence path: explicit `recap:` kwarg > Config registry
-    # (CLI > ENV > file > default). An explicit disable (`recap: false` as
-    # the kwarg or in the config file, `recap: {enabled: false}`, or
-    # SAMAGOTCHI_RECAP_ENABLED=false) always wins.
+    # (session > CLI > ENV > file > default). An explicit disable
+    # (`recap: false` as the kwarg or in the config file, `recap: {enabled:
+    # false}`, or SAMAGOTCHI_RECAP_ENABLED=false) wins, but over a session's
+    # own recap.enabled (chi --set recap.enabled=true) only as the kwarg.
     #
     # @param recap          [Hash, false, nil] the Engine's `recap:` kwarg
     # @param engine         [Engine] the recap job's engine
@@ -28,13 +31,22 @@ module Samagotchi
     # @param session_target [#call] → the session's current model as a recap target
     # @param session_id     [#call] → String, nil
     # @param state_dir      [#call] → String
+    # @param session_config [#call] → the session's own core settings
+    #   (SessionConfig::Settings#core), read once here
     # @return [IdleRecap, nil]
-    def self.build(recap, engine:, host_registry:, session_target:, session_id:, state_dir:)
+    def self.build(recap, engine:, host_registry:, session_target:, session_id:, state_dir:, session_config: -> { {} })
       return nil if recap == false
-      # The REPL and a worker pass nothing: the config is read here alone
-      # (a scalar `recap: false` is only seen this way).
-      return nil if recap.nil? && ConfigFile.recap_config == false
-      return nil if Samagotchi::Config.get("recap.enabled") == false
+
+      session = session_config.call || {}
+      # The session's own recap.enabled replaces both checks below.
+      if session.key?("recap.enabled")
+        return nil unless session["recap.enabled"]
+      else
+        # The REPL and a worker pass nothing: the config is read here alone
+        # (a scalar `recap: false` is only seen this way).
+        return nil if recap.nil? && ConfigFile.recap_config == false
+        return nil if Samagotchi::Config.get("recap.enabled") == false
+      end
 
       # An explicit kwarg (a spec, an embedder) over the registry.
       kwarg_config = recap.is_a?(Hash) ? recap : {}
@@ -64,7 +76,7 @@ module Samagotchi
         inactivity: recap_number_setting(kwarg_config, :inactivity, "recap.inactivity", IdleRecap::DEFAULT_INACTIVITY_SECONDS, :float),
         min_user_turns: recap_number_setting(kwarg_config, :min_user_turns, "recap.min_user_turns", IdleRecap::DEFAULT_MIN_USER_TURNS, :int),
         timeout: recap_number_setting(kwarg_config, :timeout, "recap.timeout", IdleRecap::DEFAULT_TIMEOUT_SECONDS, :float),
-        sentences: recap_sentences(string_config(kwarg_config, :sentences) || registry_string("recap.sentences")),
+        sentences: recap_sentences(string_config(kwarg_config, :sentences) || registry_string("recap.sentences", session: session)),
         store: RecapStore.new(session_id_lookup: -> { session_id.call }, state_dir_lookup: -> { state_dir.call }),
         session_id: -> { session_id.call },
         on_usage: ->(usage) { engine.note_side_usage(usage) }
@@ -108,9 +120,10 @@ module Samagotchi
     end
     private_class_method :recap_sentences
 
-    # Read a scalar recap setting via the Config registry (ENV > file > default).
-    def self.registry_string(key)
-      value = Samagotchi::Config.get(key)
+    # Read a scalar recap setting via the Config registry (session > CLI >
+    # ENV > file > default).
+    def self.registry_string(key, session: nil)
+      value = Samagotchi::Config.get(key, session: session)
       value = value.to_s.strip
       value.empty? ? nil : value
     rescue StandardError

data/lib/samagotchi/send_command.rb

@@ -8,7 +8,7 @@ require_relative "session_commands"
 require_relative "parent_answers_command"
 require_relative "session_inbox"
 require_relative "session_manager"
-require_relative "bundle_session_settings"
+require_relative "session_config"
 require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
@@ -46,7 +46,7 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [--set BUNDLE.KEY=VALUE]... [--parent-answers LEVEL] [-m TEXT] [--image PATH]...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [--set KEY=VALUE]... [--parent-answers LEVEL] [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
@@ -92,12 +92,15 @@ module Samagotchi
                     (full, lean, child, a config or bundle one; default
                     config's toolkit.default), and tools declared on top
                     of it or left out (repeatable, a comma list too)
-        --set BUNDLE.KEY=VALUE
-                    (--new) a bundle setting for this session, over
-                    config.yml's bundles: (repeatable; a key its bundle's
-                    manifest lists in session_settings:; numbers (3,
-                    .5) and booleans (true, off, no) are typed, the
-                    rest is text: --set cost-cap.cap=3)
+        --set KEY=VALUE
+                    (--new) a setting for this session, as chi --set:
+                    a core key a session may set (recap.enabled,
+                    recap.sentences), typed by it, or BUNDLE.KEY over
+                    config.yml's bundles: (a key its bundle's manifest
+                    lists in session_settings:; numbers (3, .5) and
+                    booleans (true, off, no) are typed, the rest is
+                    text); repeatable: --set recap.enabled=false,
+                    --set cost-cap.cap=3
         --parent-answers LEVEL
                     (--new) what a parent agent may answer on its
                     questions: hard, standard or soft, only stricter than
@@ -372,8 +375,8 @@ module Samagotchi
       toolkit = Toolkit.from_flags(name: options[:toolkit], add: options[:tools], remove: options[:no_tools])
       options[:toolkit_value] = toolkit if toolkit
       begin
-        options[:bundle_settings] = BundleSessionSettings.from_flags(options[:sets]) unless Array(options[:sets]).empty?
-      rescue BundleSessionSettings::Error => e
+        options[:settings] = SessionConfig.from_flags(options[:sets]) unless Array(options[:sets]).empty?
+      rescue SessionConfig::Error => e
         return usage_error(e.message)
       end
 
@@ -426,7 +429,7 @@ module Samagotchi
                                                           setup: SessionSetup.new(llm_context: options[:llm_context],
                                                                                   thinking: options[:thinking],
                                                                                   toolkit: options[:toolkit_value],
-                                                                                  bundle_settings: options[:bundle_settings] || {},
+                                                                                  settings: options[:settings],
                                                                                   parent_answers: options[:parent_answers]),
                                                           state_dir: @state_dir)
                   end

data/lib/samagotchi/session.rb

@@ -213,16 +213,19 @@ module Samagotchi
       @toolkit = value.is_a?(Toolkit) ? value : Toolkit.from_file(value)
     end
 
-    # The session's own bundle settings (chi --set BUNDLE.KEY=VALUE):
-    # {bundle => {key => value}}, frozen, {} for none and for a session from
-    # before them. Given when it was created and never changed; a respawn,
-    # a continue and a fork keep them (SessionSetup.of), a delegate child
-    # doesn't. Plugin::Context#settings lays them over config.yml's.
-    attr_reader :bundle_settings
+    # The session's own settings (chi --set), a SessionConfig::Settings:
+    # empty for none and for a session from before them. Its core part
+    # ({key => value}: recap.enabled) is the file's config_settings, its
+    # bundles part ({bundle => {key => value}}) the file's bundle_settings.
+    # Given when it was created; a respawn, a continue and a fork keep them
+    # (SessionSetup.of), a delegate child doesn't. Plugin::Context#settings
+    # lays the bundles part over config.yml's; the core part goes first in
+    # Config.get(key, session:) (RecapSetup).
+    attr_reader :settings
 
-    # @param value [Hash, nil] the session file's form too
-    def bundle_settings=(value)
-      @bundle_settings = BundleSessionSettings.normalize(value)
+    # @param value [SessionConfig::Settings, nil]
+    def settings=(value)
+      @settings = SessionConfig::Settings.of(value)
     end
 
     # The session's own guardrails.parent_answers (hard|standard|soft), nil
@@ -280,7 +283,7 @@ module Samagotchi
                    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, reasoning_history: nil, appended_prompt_files: [],
-                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil, parent_answers: nil, title: nil)
+                   toolkit: nil, settings: nil, interrupted_turn: nil, parent_answers: nil, title: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -311,7 +314,7 @@ module Samagotchi
       self.reasoning_history = reasoning_history
       self.appended_prompt_files = appended_prompt_files
       self.toolkit = toolkit
-      self.bundle_settings = bundle_settings
+      self.settings = settings
       self.parent_answers = parent_answers
       self.interrupted_turn = interrupted_turn
       @turn_checkpoint = nil
@@ -410,7 +413,7 @@ module Samagotchi
         reasoning_history: setup.reasoning_history,
         appended_prompt_files: setup.appended_prompt_files,
         toolkit: setup.toolkit,
-        bundle_settings: setup.bundle_settings,
+        settings: setup.settings,
         parent_answers: setup.parent_answers,
         continues: continues
       )
@@ -479,6 +482,7 @@ module Samagotchi
       "appended_prompt_files" => [],
       "toolkit" => nil,
       "bundle_settings" => {},
+      "config_settings" => {},
       "interrupted_turn" => nil,
       "parent_answers" => nil
     }.freeze
@@ -490,6 +494,7 @@ module Samagotchi
       attrs = FIELDS.to_h do |key, default|
         [key.to_sym, default.equal?(REQUIRED) ? data.fetch(key) : data.fetch(key, default)]
       end
+      attrs[:settings] = SessionConfig::Settings.new(core: attrs.delete(:config_settings), bundles: attrs.delete(:bundle_settings))
       attrs[:messages] = messages ? Array(attrs[:messages]).map { |msg| symbolize_message_keys(msg) } : []
       new(**attrs)
     end
@@ -618,6 +623,8 @@ module Samagotchi
                 when "thinking" then thinking_file
                 when "reasoning_history" then reasoning_history_file
                 when "toolkit" then @toolkit&.to_file
+                when "bundle_settings" then @settings.bundles
+                when "config_settings" then @settings.core
                 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", "appended_prompt_files"