samagotchi 0.38.0 → 0.40.0

data/lib/samagotchi/config.rb

@@ -9,6 +9,7 @@ require_relative "config_text_edit"
 require_relative "log"
 require_relative "model_ref"
 require_relative "paths"
+require_relative "llm_context_strategy"
 
 module Samagotchi
   # Parses the thinking: levels of host and model entries (it needs Config).
@@ -154,6 +155,24 @@ module Samagotchi
       # 10 minutes, within session.max_wakes); false: it waits as a note for the next turn.
       Entry.new(key: "context.wake",             yaml_path: %w[context wake],             type: :bool,   default: true,             expose: %i[env config cli]),
 
+      # What the model is sent of the conversation (LLMContextStrategy, LLMContextView): none, or a list of layers
+      # (stale, forget; "|"-separated or a YAML list); forget (the model's forget_outputs) is experimental.
+      # models.<key>.llm_context_strategy and hosts.<name>.llm_context_strategy come first.
+      Entry.new(key: "llm_context.strategy",     yaml_path: %w[llm_context strategy],     type: :string, default: "none",           expose: %i[env config]),
+      # When a layer's edits reach the prompt (LLMContextApply): payoff, next_request or turn_end;
+      # models.<key>.llm_context_apply and hosts.<name>.llm_context_apply come first.
+      Entry.new(key: "llm_context.apply",        yaml_path: %w[llm_context apply],        type: :string, default: "payoff",         expose: %i[env config]),
+      # Whether an edit or write of a file makes its earlier reads stale too (opt-in, experimental).
+      Entry.new(key: "llm_context.stale_edits",  yaml_path: %w[llm_context stale_edits],  type: :bool,   default: false,            expose: %i[env config]),
+      # The steps (tool batches) back whose edited files' reads stale never stubs.
+      Entry.new(key: "llm_context.protect_steps", yaml_path: %w[llm_context protect_steps], type: :integer, default: 3,             expose: %i[env config]),
+      # A soft context budget in tokens: the context status bands (and the forget layer's offers) count against it
+      # instead of the window; unset or 0: off. models.<key>.llm_context_budget_tokens and
+      # hosts.<name>.llm_context_budget_tokens come first.
+      Entry.new(key: "llm_context.budget_tokens", yaml_path: %w[llm_context budget_tokens], type: :integer, default: nil,          expose: %i[env config]),
+      # The policy sentence forget_outputs' description carries (the forget layer); blank: none.
+      Entry.new(key: "llm_context.policy",       yaml_path: %w[llm_context policy],       type: :string, default: LLMContextStrategy::DEFAULT_POLICY, expose: %i[env config]),
+
       Entry.new(key: "thinking.turn_preamble",   yaml_path: %w[thinking turn_preamble],   type: :bool,   default: true,             expose: %i[env config cli]),
       # How much models think: off|low|medium|high|default, parsed by Thinking
       # (a :string, since YAML reads an unquoted off as false). The CLI flag
@@ -241,8 +260,9 @@ module Samagotchi
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
       "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled
-                    remote window_tokens].freeze,
-      "models" => %w[profile vision sampling thinking window_tokens].freeze
+                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens].freeze,
+      "models" => %w[profile vision sampling thinking window_tokens llm_context_strategy llm_context_apply
+                     llm_context_budget_tokens].freeze
     }.freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
@@ -826,6 +846,12 @@ module Samagotchi
                                             "hosts entry '#{name}'")
           sampling = ConfigFile.sampling_map(raw_cfg.key?("sampling") ? raw_cfg["sampling"] : raw_cfg[:sampling], "hosts entry '#{name}'")
           thinking = Thinking.level(raw_cfg.key?("thinking") ? raw_cfg["thinking"] : raw_cfg[:thinking], "hosts entry '#{name}'")
+          llm_context = LLMContextStrategy.parse(raw_cfg.key?(LLMContextStrategy::KEY) ? raw_cfg[LLMContextStrategy::KEY] : raw_cfg[:llm_context_strategy],
+                                                 "hosts entry '#{name}'")
+          llm_context_apply = LLMContextStrategy.parse_apply(raw_cfg.key?(LLMContextStrategy::APPLY_KEY) ? raw_cfg[LLMContextStrategy::APPLY_KEY] : raw_cfg[:llm_context_apply],
+                                                             "hosts entry '#{name}'")
+          llm_context_budget = LLMContextStrategy.parse_budget(raw_cfg.key?(LLMContextStrategy::BUDGET_KEY) ? raw_cfg[LLMContextStrategy::BUDGET_KEY] : raw_cfg[:llm_context_budget_tokens],
+                                                               "hosts entry '#{name}'")
           unless first_token_timeout.nil? || (first_token_timeout.is_a?(Numeric) && !first_token_timeout.negative?)
             warn_once "Warning: hosts entry '#{name}': first_token_timeout must be seconds (0 = off); using the default"
             first_token_timeout = nil
@@ -890,7 +916,8 @@ module Samagotchi
                                   url: url.empty? ? nil : url, api_key_env: api_key_env.empty? ? nil : api_key_env,
                                   profile: profile.empty? ? nil : profile, first_token_timeout: first_token_timeout,
                                   vision: vision, sampling: sampling, thinking: thinking, remote: remote,
-                                  window_tokens: window }
+                                  window_tokens: window, llm_context_strategy: llm_context,
+                                  llm_context_apply: llm_context_apply, llm_context_budget_tokens: llm_context_budget }
         end
       end
 
@@ -1037,7 +1064,10 @@ module Samagotchi
         location.merge("transport" => v[:transport]&.to_s, "api" => v[:api]&.to_s, "api_key_env" => v[:api_key_env],
                        "profile" => v[:profile], "first_token_timeout" => v[:first_token_timeout],
                        "vision" => v[:vision], "sampling" => v[:sampling], "thinking" => v[:thinking]&.to_s,
-                       "remote" => v[:remote], "window_tokens" => v[:window_tokens]).compact
+                       "remote" => v[:remote], "window_tokens" => v[:window_tokens],
+                       "llm_context_strategy" => v[:llm_context_strategy]&.map(&:to_s),
+                       "llm_context_apply" => v[:llm_context_apply]&.to_s,
+                       "llm_context_budget_tokens" => v[:llm_context_budget_tokens]).compact
       end
       # Disabled hosts travel as just that, so a worker refuses "box:x"
       # the way its parent does instead of sending it to the default host.
@@ -1129,6 +1159,15 @@ module Samagotchi
         result[key][:thinking] = thinking if thinking
         window = window_tokens(v.key?("window_tokens") ? v["window_tokens"] : v[:window_tokens], "models: #{key}")
         result[key][:window_tokens] = window if window
+        layers = LLMContextStrategy.parse(v.key?(LLMContextStrategy::KEY) ? v[LLMContextStrategy::KEY] : v[:llm_context_strategy],
+                                          "models: #{key}")
+        result[key][:llm_context_strategy] = layers if layers
+        apply = LLMContextStrategy.parse_apply(v.key?(LLMContextStrategy::APPLY_KEY) ? v[LLMContextStrategy::APPLY_KEY] : v[:llm_context_apply],
+                                               "models: #{key}")
+        result[key][:llm_context_apply] = apply if apply
+        budget = LLMContextStrategy.parse_budget(v.key?(LLMContextStrategy::BUDGET_KEY) ? v[LLMContextStrategy::BUDGET_KEY] : v[:llm_context_budget_tokens],
+                                                 "models: #{key}")
+        result[key][:llm_context_budget_tokens] = budget if budget
       end
     rescue StandardError
       {}

data/lib/samagotchi/context_note.rb

@@ -64,9 +64,13 @@ module Samagotchi
     # (a note that arrived before the first turn, a turn note left by a
     # failed first turn) stays and the prompt goes before it.
     def with_system_head(messages, system_message)
-      first = messages.first
-      replace = first && fetch(first, :role).to_s == "system" && fetch(first, :kind).to_s.empty?
-      [system_message] + (replace ? messages.drop(1) : messages)
+      [system_message] + (system_head?(messages.first) ? messages.drop(1) : messages)
+    end
+
+    # A system prompt at a conversation's head: a system message of no kind
+    # (#with_system_head replaces it).
+    def system_head?(message)
+      message.is_a?(Hash) && fetch(message, :role).to_s == "system" && fetch(message, :kind).to_s.empty?
     end
 
     def clock(created_at)

data/lib/samagotchi/context_status.rb

@@ -19,6 +19,26 @@ module Samagotchi
   #
   # The context.* settings are read once, when the tracker is built (one per
   # run, so a changed setting counts from the next turn).
+  #
+  # The turn's LLM context strategy (LLMContextStrategy::Resolved) may set
+  # a soft budget (llm_context.budget_tokens): the buckets then count
+  # against it instead of the window (the smaller of the two).
+  #
+  # Under the forget layer the model's lines offer forget_outputs in
+  # tiers, never "forget now" (the spike: told to free context, models
+  # forget nearly everything), each with a "~N/M tokens" readout:
+  # - the first bucket with guidance, below the top two: the readout alone
+  #   (CLM: how-to at low pressure triggers wholesale deletion);
+  # - the one under the top: finish the unit of work in flight, then tidy
+  #   once;
+  # - the top, or over the budget: compact settled outputs now, keep what
+  #   will still be edited against, don't wipe.
+  # When: at a turn's first request (the turn before it answered, its
+  # outputs are settled), on a rise as ever, and again when the last line
+  # was the readout alone (a mid-turn rise) or the context is over the
+  # budget (every turn then). Mid-turn only the top tier offers; a lower
+  # rise gets the readout alone (the layout check: pushed mid-task, models
+  # forget at the base rate).
   class ContextStatus
     STATUS_PREFIX = "CONTEXT_STATUS"
     # The model's own line about its context (a tail system message, kind
@@ -62,19 +82,35 @@ module Samagotchi
     # The bucket of the last status line +conversation+ holds: the model's
     # own line, or a legacy session's injected telemetry.
     def self.last_bucket(conversation)
+      content = last_line(conversation)
+      match = content&.match(/\bbucket=([a-z0-9_]+)/)
+      match && match[1]
+    end
+
+    # The text of the last status line +conversation+ holds, nil for none.
+    def self.last_line(conversation)
       message = conversation.reverse.find do |entry|
         content = entry[:content].to_s
         entry[:role] == "system" && content.start_with?(STATUS_PREFIX, LINE_PREFIX)
       end
-      return nil unless message
-
-      match = message[:content].match(/\bbucket=([a-z0-9_]+)/)
-      match && match[1]
+      message && message[:content].to_s
     end
 
+    # What a forget-layer line names when it offers the tool.
+    OFFER_TOOL = "forget_outputs"
+    # The forget layer's tiers' words (#forget_line).
+    TIDY = "Finish the unit of work in flight, then tidy once with #{OFFER_TOOL}: settled outputs, with a note " \
+           "that carries what they established."
+    COMPACT = "Compact settled outputs now with #{OFFER_TOOL}: keep what you'll still edit against; don't wipe."
+
     # @param conversation [Array<Hash>] the turn's conversation so far (its
     #   last status line's bucket is where rises count from)
-    def initialize(conversation: [])
+    # @param llm_context [LLMContextStrategy::Resolved, nil] the turn's
+    #   strategy (its budget)
+    def initialize(conversation: [], llm_context: nil)
+      @budget = llm_context&.budget_tokens
+      @forget = llm_context&.forget? || false
+      @offered = self.class.last_line(conversation).to_s.include?(OFFER_TOOL)
       @enabled = self.class.enabled?
       chars_per_token = Config.get("context.chars_per_token").to_f
       @chars_per_token = chars_per_token.positive? ? chars_per_token : DEFAULT_CHARS_PER_TOKEN
@@ -85,6 +121,7 @@ module Samagotchi
       @last_bucket = self.class.last_bucket(conversation)
       @server_usage = nil
       @counted = nil
+      @edited = false
       @display = nil
       @guidance = nil
     end
@@ -95,6 +132,12 @@ module Samagotchi
 
     def enabled? = @enabled
 
+    # The status line's value is in the top configured bucket (the apply
+    # rule's payoff applies staged edits there at once).
+    def top_bucket?
+      !@display.nil? && bucket_rank(@display[:bucket]) == @thresholds.size
+    end
+
     # Before a request: estimate the usage of a prompt of +prompt_chars+
     # against +window+ (this request's ContextWindow::Resolved) and update
     # the status line's value. A rise into a bucket that asks the model for
@@ -114,12 +157,25 @@ module Samagotchi
       emit = emit?(bucket: bucket, iteration_index: iteration_index)
       previous_bucket = @last_bucket
       @last_bucket = bucket
+      line = if @forget
+               forget_line(usage, bucket, previous_bucket, iteration_index)
+             elsif guidance_due?(previous_bucket, bucket)
+               guidance_message(usage: usage, bucket: bucket)
+             end
+      @guidance = line if line
       return nil unless emit
 
-      @guidance = guidance_message(usage: usage, bucket: bucket) if guidance_due?(previous_bucket, bucket)
       { status: status_message(usage: usage, bucket: bucket), usage: usage, bucket: bucket, source: usage[:source] }
     end
 
+    # An LLM context edit was applied (LLMContextApply): the prompt is
+    # shorter than the one the server's count was for. Until the next
+    # count the estimate takes what the prompt lost off that count too,
+    # instead of holding it (a shorter prompt counts as trimmed otherwise).
+    def edited!
+      @edited = true
+    end
+
     # @return [Hash, nil] the model's line from the last #observe (once)
     def take_guidance
       line = @guidance
@@ -145,6 +201,7 @@ module Samagotchi
       return unless usage
 
       @counted = { chars: prompt_chars, image_tokens: image_tokens }
+      @edited = false
       value = display_for(used_tokens: usage[:total_tokens], window_tokens: usage[:context_window_tokens] || window&.tokens)
       @display = value if value
     end
@@ -155,7 +212,7 @@ module Samagotchi
       return nil unless @enabled
       return nil unless ContextWindow.positive_integer?(used_tokens) && ContextWindow.positive_integer?(window_tokens)
 
-      pct = (used_tokens.to_f / window_tokens) * 100.0
+      pct = (used_tokens.to_f / counted_against(window_tokens)) * 100.0
       { est_pct: pct, bucket: bucket_for(pct) }
     end
 
@@ -171,11 +228,11 @@ module Samagotchi
       window_source = :server if server_usage && server_usage[:context_window_tokens]
 
       if server_usage && server_usage[:prompt_tokens]
-        window_tokens = server_usage[:context_window_tokens] || window.tokens
-        used_tokens = server_usage[:prompt_tokens] + appended_tokens(prompt_chars, image_tokens, counted)
+        window_tokens = counted_against(server_usage[:context_window_tokens] || window.tokens)
+        used_tokens = [server_usage[:prompt_tokens] + appended_tokens(prompt_chars, image_tokens, counted), 0].max
         source = "server"
       else
-        window_tokens = window.tokens
+        window_tokens = counted_against(window.tokens)
         used_tokens = (prompt_chars / @chars_per_token).ceil + image_tokens
         source = "estimate"
       end
@@ -192,11 +249,19 @@ module Samagotchi
 
     private
 
-    # The estimate for what the prompt added since the +counted+ one.
+    # What the buckets count against: the window, or the budget when one is
+    # set and smaller.
+    def counted_against(window_tokens)
+      @budget ? [@budget, window_tokens].min : window_tokens
+    end
+
+    # The estimate for what the prompt added since the +counted+ one;
+    # after an edit (#edited!) what it lost too, as a negative.
     def appended_tokens(prompt_chars, image_tokens, counted)
       return 0 unless counted
 
       chars = prompt_chars - counted[:chars]
+      return -(-chars / @chars_per_token).ceil if @edited && chars.negative?
       return 0 unless chars.positive?
 
       (chars / @chars_per_token).ceil + [image_tokens - counted[:image_tokens].to_i, 0].max
@@ -230,6 +295,42 @@ module Samagotchi
       bucket_changed || cadence_due
     end
 
+    # The forget layer's line for this request, or nil (the tiers and when
+    # they come: the class comment).
+    def forget_line(usage, bucket, previous, iteration_index)
+      over = over_budget?(usage)
+      tier = over ? :compact : tier_for(bucket)
+      return nil unless tier
+
+      rise = guidance_due?(previous, bucket)
+      if iteration_index.zero?
+        return nil unless rise || over || (tier != :info && !@offered)
+      else
+        return nil unless rise
+
+        tier = :info unless tier == :compact
+      end
+      @offered = tier != :info
+      readout = "~#{k(usage[:estimated_used_tokens])}/#{k(usage[:window_tokens])} tokens in use"
+      readout += ", over the budget" if over
+      words = { info: nil, tidy: TIDY, compact: COMPACT }.fetch(tier)
+      { role: "system", kind: LINE_KIND, content: "#{LINE_PREFIX}#{readout} (bucket=#{bucket}).#{" #{words}" if words}]" }
+    end
+
+    # :info, :tidy or :compact for a bucket with guidance (the top one
+    # compacts, the one under it tidies, lower ones inform); nil below.
+    def tier_for(bucket)
+      rank = bucket_rank(bucket)
+      return nil if rank < GUIDANCE_FROM_RANK
+      return :compact if rank == @thresholds.size
+
+      rank == @thresholds.size - 1 ? :tidy : :info
+    end
+
+    def over_budget?(usage) = !@budget.nil? && usage[:estimated_used_tokens] >= @budget
+
+    def k(tokens) = tokens >= 1000 ? "#{(tokens / 1000.0).round}k" : tokens.to_s
+
     def guidance_message(usage:, bucket:)
       how = usage[:source].to_s == "server" ? "as the server reports" : "estimated"
       { role: "system", kind: LINE_KIND,

data/lib/samagotchi/engine.rb

@@ -176,7 +176,8 @@ module Samagotchi
       # The tools this session offers (the prompts' declarations and the
       # kernel's dispatch): the built-ins, per Engine. execute.description
       # off: execute offers no description parameter.
-      @tools = Tools::Builtins.registry(command_description: Config.get("execute.description") != false)
+      @tools = Tools::Builtins.registry(command_description: Config.get("execute.description") != false,
+                                        policy: Config.get(LLMContextStrategy::POLICY_SETTING))
       if @scratch
         # A scratch session's children would outlive it, and so would a
         # note it left in a peer; its memories would too (write and edit
@@ -930,11 +931,13 @@ module Samagotchi
 
     # The status line's ctx from the saved context, for a worker that has run
     # no turn yet (it woke after an idle exit): nil when either count is
-    # unknown or context.status is off.
+    # unknown or context.status is off. Counted as the turns count it:
+    # against the effective model's llm_context budget when it has one.
     def saved_context_status(context)
       return nil unless context
 
-      ContextStatus.new.display_for(used_tokens: context[:used_tokens], window_tokens: context[:window_tokens])
+      ContextStatus.new(llm_context: turn_llm_context)
+                   .display_for(used_tokens: context[:used_tokens], window_tokens: context[:window_tokens])
     end
 
     # The effective model is on a chat host (api: openai), whose loop uses
@@ -1410,9 +1413,19 @@ module Samagotchi
       target ||= @host_registry.resolve(@effective_model_name)
       chat = target.entry.chat?
       level = chat ? nil : thinking_level(target)
-      @prompt_builder.build(chat: chat, thinking: level)
+      @prompt_builder.build(chat: chat, thinking: level, layers: llm_context_layers(target))
     end
 
+    # The LLM context layers +target+'s turns run under: the native prompt
+    # declares the tools they add (forget_outputs under forget), so a
+    # model switch may change the tool list. [] under none.
+    def llm_context_layers(target)
+      LLMContextStrategy.resolve(target, names: model_lookup_names(target)).active_layers
+    rescue StandardError
+      []
+    end
+    private :llm_context_layers
+
     # The base prompt (specs, plugins' declarations).
     def assist_system_prompt(chat: false, thinking: nil)
       @prompt_builder.base(chat: chat, thinking: thinking)
@@ -1727,7 +1740,7 @@ module Samagotchi
       @turn_thinking = [thinking_level(thinking_target), thinking_target]
       announce_thinking_level(*@turn_thinking)
       LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil,
-                            window_setting: nil)
+                            window_setting: nil, llm_context: nil)
     end
     private :turn_settings
 
@@ -1754,11 +1767,14 @@ module Samagotchi
       return if reminders_due? || @turn_state.carried_steers? || @next_turn_waiting&.call
 
       messages = ContextNote.with_system_head(turn.session.messages.dup, { role: "system", content: system_prompt(target) })
-      prompt, images = @kernel.warmup_prompt(messages)
+      # Under the next turn's strategy (a /model switch may have changed it);
+      # the last turn's when it can't be resolved.
+      prompt, images = @kernel.warmup_prompt(messages, llm_context: turn_llm_context || @kernel.turn_settings&.llm_context)
       return unless prompt
 
-      @prompt_warmup.start(client: client, prompt: prompt, model: @kernel.turn_settings.model_name,
-                           slot: @kernel.last_slot, images: images)
+      started = @prompt_warmup.start(client: client, prompt: prompt, model: @kernel.turn_settings.model_name,
+                                     slot: @kernel.last_slot, images: images)
+      @kernel.warmed_up! if started
     rescue StandardError => e
       Log.warn(:model, "warmup_skipped", error: e.class.name, msg: e.message.to_s[0, 200])
     end
@@ -1816,7 +1832,8 @@ module Samagotchi
       # The turn's settings, set once here. The chat loop dispatches tools
       # through the kernel without its #run: tag those dumps with this
       # turn's model, not the last native one.
-      @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend, window_setting: turn_window_setting)
+      @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend, window_setting: turn_window_setting,
+                                                 llm_context: turn_llm_context)
 
       turn.limit = @no_interrupt ? IterationLimit.for(no_interrupt: true) : max_iterations || IterationLimit.for
       backend.complete(
@@ -2512,6 +2529,16 @@ module Samagotchi
       nil
     end
 
+    # The effective model's LLM context strategy (models:/hosts:
+    # llm_context_strategy, else llm_context.strategy), read per turn as
+    # the window is.
+    def turn_llm_context
+      target = @host_registry.resolve(@effective_model_name)
+      LLMContextStrategy.resolve(target, names: model_lookup_names(target))
+    rescue StandardError
+      nil
+    end
+
     # See #served_model. A report for another name (before a /model switch)
     # doesn't count. Without a target, no probe. A remote chat host has no
     # /props: nil until a turn.

data/lib/samagotchi/guardrails/targets.rb

@@ -23,7 +23,7 @@ module Samagotchi
       PATH_TOOLS = %w[write edit read memory_write].freeze
 
       # chi's own tools, by name, whether this session has them or not.
-      CORE_TOOLS = ToolDeclarations::TOOL_SCHEMAS.map { |schema| schema[:name] }.freeze
+      CORE_TOOLS = ToolDeclarations::BUILTIN_SCHEMAS.map { |schema| schema[:name] }.freeze
 
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
@@ -149,11 +149,23 @@ module Samagotchi
                 end
         return name unless whose
 
-        Log.warn(:plugins, "plugin_acts_as_dropped", tool: entry.name, acts_as: name,
-                                                     msg: "#{entry.name} targets: acts_as #{name} dropped: it is #{whose}")
+        if first_drop?(registry, entry.name, name)
+          Log.warn(:plugins, "plugin_acts_as_dropped", tool: entry.name, acts_as: name,
+                                                       msg: "#{entry.name} targets: acts_as #{name} dropped: it is #{whose}")
+        end
         nil
       end
 
+      # The drops logged, per registry (a session's): each tool's acts_as
+      # once, not at every call (targets run several times a call).
+      DROPS_LOGGED = ObjectSpace::WeakKeyMap.new
+      DROPS_LOCK = Mutex.new
+
+      def self.first_drop?(registry, tool, acts_as)
+        DROPS_LOCK.synchronize { !(DROPS_LOGGED[registry] ||= Set.new).add?([tool, acts_as]).nil? }
+      end
+      private_class_method :first_drop?
+
       # The longest label: the question takes from targets:.
       LABEL_CHARS = 80
 

data/lib/samagotchi/host_registry.rb

@@ -36,10 +36,13 @@ module Samagotchi
     # sampling: the configured request parameters (SamplingSettings), nil when unset;
     # thinking: the configured level (Thinking), nil when unset;
     # remote: the configured true/false (#remote?), nil when unset;
-    # window_tokens: the configured context window (ContextWindow.setting), nil when unset.
+    # window_tokens: the configured context window (ContextWindow.setting), nil when unset;
+    # llm_context_strategy: the configured layers (LLMContextStrategy), nil when unset;
+    # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
+    # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset.
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           keyword_init: true) do
+                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.
       def chat? = api == :openai
@@ -99,7 +102,9 @@ module Samagotchi
                               api: cfg[:api]&.to_sym, scheme: cfg[:scheme], url: cfg[:url], api_key_env: cfg[:api_key_env],
                               profile: cfg[:profile], first_token_timeout: cfg[:first_token_timeout],
                               vision: cfg[:vision], sampling: cfg[:sampling], thinking: cfg[:thinking],
-                              remote: cfg[:remote], window_tokens: cfg[:window_tokens])
+                              remote: cfg[:remote], window_tokens: cfg[:window_tokens],
+                              llm_context_strategy: cfg[:llm_context_strategy], llm_context_apply: cfg[:llm_context_apply],
+                              llm_context_budget_tokens: cfg[:llm_context_budget_tokens])
         entry.client = Client.new(host: cfg[:host], port: cfg[:port], transport: transport, scheme: cfg[:scheme],
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
                                   api_key_env: entry.api_key_env, env: env)