samagotchi 0.101.0 → 0.102.0

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"

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)