samagotchi 0.155.0 → 0.156.0

data/lib/samagotchi/kernel_loop.rb

@@ -27,6 +27,8 @@ require_relative "tools/builtin_calls"
 require_relative "tools/tool_surface"
 require_relative "muted_memories"
 require_relative "tool_activity"
+require_relative "reprefill_meter"
+require_relative "tool_output_cut"
 require_relative "tool_runner"
 require_relative "tool_response"
 require_relative "tool_ids"
@@ -123,13 +125,12 @@ module Samagotchi
       # conversation (KernelLoop#forget_outputs).
       def forget_outputs(call) = @kernel.forget_outputs(call, @context)
 
-      # The turn's Tools::ToolSurface (TurnContext#surface), else one
-      # computed now from the kernel's tools (a bare kernel): what the tool
+      # The turn's Tools::ToolSurface (TurnContext#surface; a bare kernel's
+      # own context has one too, KernelLoop#own_context): what the tool
       # index's handlers (find_tools, call_tool) read.
-      def surface = Tools::ToolSurface.of(@context, @kernel.tools)
+      def surface = Tools::ToolSurface.of(@context)
     end
 
-    DEFAULT_MAX_TOOL_OUTPUT_CHARS = 10_000
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_LIMIT = 2
     # How much of a malformed generation's end the warning keeps.
     MALFORMED_TAIL_CHARS = 400
@@ -172,12 +173,16 @@ module Samagotchi
 
     # @param services [Services, nil] what the kernel holds of its Engine
     #   (Services.none by default: the built-in tools alone)
+    # @param reprefill [ReprefillMeter, nil] the re-prefill baseline its
+    #   requests count against (the Engine's, shared with its ChatLoop; its
+    #   own by default)
     # @param sleeper [#call, nil] waits the given seconds before a dropped
     #   stream's step is asked again (specs pass one that doesn't sleep)
-    def initialize(client: nil, profile: nil, model_name: nil, model_key: nil, services: nil, sleeper: nil)
+    def initialize(client: nil, profile: nil, model_name: nil, model_key: nil, services: nil, reprefill: nil, sleeper: nil)
       @client = client || Client.new
       @sleeper = sleeper || ->(seconds) { sleep(seconds) }
       @services = services || Services.none
+      @reprefill = reprefill || ReprefillMeter.new
       resolved_model_name = ModelProfile.required_model_name(model_name)
       # The context of the run in progress, else of the last run (#context):
       # a kernel that ran none has its own (no turn, no settings but its
@@ -193,11 +198,14 @@ module Samagotchi
     # @return [Services] what the kernel holds of its Engine (#attach)
     attr_reader :services
 
-    # Hand the kernel its Engine's services, all at once: the Engine does
-    # for a kernel it is given (specs) what KernelLoop.new does for its own.
+    # Hand the kernel its Engine's services, all at once, and its
+    # re-prefill meter (nil keeps the one it has): the Engine does for a
+    # kernel it is given (specs) what KernelLoop.new does for its own.
     # @param services [Services]
+    # @param reprefill [ReprefillMeter, nil]
     # @return [Services]
-    def attach(services)
+    def attach(services, reprefill: nil)
+      @reprefill = reprefill if reprefill
       @services = services
     end
 
@@ -288,16 +296,16 @@ module Samagotchi
     #   their thought blocks (#prepare_conversation), as within one run. nil:
     #   every earlier thought is stripped.
     # @param context [TurnContext] the run's turn (Engine#generate's); a
-    #   bare kernel's last (#context) by default. Its settings take the
+    #   bare kernel's own (#own_context) by default. Its settings take the
     #   run's model name: this run's own copy, never published.
     # @return [LLM::ModelResult] final visible response with continuation metadata
     def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil,
-            reasoning_since: nil, context: @context)
+            reasoning_since: nil, context: own_context)
       settings = context.settings || LLM::TurnSettings.none
       @context = context.with(settings: settings.with(model_name: completion_model_name(model_name)))
       @last_slot = nil
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
-                                  pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars),
+                                  pending_input: pending_input, cap: ToolOutputCut.max_chars(max_tool_output_chars),
                                   reasoning_since: reasoning_since)
 
       max_iterations.times do |iteration_index|
@@ -330,21 +338,6 @@ module Samagotchi
       @profile_source = resolution.label
     end
 
-    # Resolve the per-output character cap for the tool outputs the model
-    # gets back and the emitted tool call events.
-    #
-    # Precedence: an explicit override wins, then max_tool_output_chars
-    # (Config). A non-positive value falls back to
-    # DEFAULT_MAX_TOOL_OUTPUT_CHARS (there is intentionally no "unlimited" — live UIs get a
-    # bounded `output:` plus a truthful `output_truncated:` flag). The one
-    # exception is memory_read, which ToolRunner leaves out of this cap
-    # (memory.read_max_chars, 0: no fixed cap; a memory is read whole).
-    # Class-level so the chat loop resolves it the same way.
-    def self.resolve_output_char_cap(override)
-      parsed = (override || Samagotchi::Config.get("max_tool_output_chars")).to_i
-      parsed.positive? ? parsed : DEFAULT_MAX_TOOL_OUTPUT_CHARS
-    end
-
     private
 
     # ── One turn (#run) ────────────────────────────────────────────────────────
@@ -659,7 +652,7 @@ module Samagotchi
     def cache_fields(cache) = cache ? TokenUsage.cache_fields(**cache) : {}
 
     def reprefill_field(model, cache)
-      tokens = cache && reprefilled_tokens(model, prompt: cache[:prompt], cached: cache[:cached])
+      tokens = cache && @reprefill.tokens(model, client: @client, prompt: cache[:prompt], cached: cache[:cached])
       tokens ? { reprefill_tokens: tokens } : {}
     end
 
@@ -877,12 +870,6 @@ module Samagotchi
     # Coerce a value to boolean — handles true/false, nil, and string "true"/"false".
     def truthy?(val) = Tools::Builtins.truthy?(val)
 
-    # ── Output char cap resolution ─────────────────────────────────────────────
-
-    def resolve_output_char_cap(override)
-      self.class.resolve_output_char_cap(override)
-    end
-
     # One request, cancelled by +generation_controller+ (the turn's child)
     # when there is one.
     def request_generation(prompt, generation_controller:, cancel_controller:, **)
@@ -1005,14 +992,10 @@ module Samagotchi
     WARMUP_CUT = "chi-warmup-cut"
     private_constant :WARMUP_CUT
 
-    # What both loops send of the conversation (LLMContextView), under the
-    # turn's strategy (TurnSettings#llm_context, none without one), or the
-    # one given (the warm-up's, the next turn's): the prompt, the warm-up
-    # and the chat messages all format through it, so the warm-up warms
-    # the prompt the next turn sends.
-    def llm_context_view(llm_context = turn_settings&.llm_context)
-      LLMContextView.new(strategy: llm_context&.strategy || LLMContextView::NONE)
-    end
+    # What the native prompt and the warm-up send of the conversation
+    # (LLMContextView.for), under the turn's strategy or the one given (the
+    # warm-up's, the next turn's).
+    def llm_context_view(llm_context = turn_settings&.llm_context) = LLMContextView.for(llm_context)
 
     # The model's forget_outputs call (LLMContextForget) on the running
     # turn (the loop's llm_context_turn), under +context+'s strategy (the
@@ -1042,84 +1025,19 @@ module Samagotchi
     end
     private :pinned_ids
 
-    # Before each request of both loops (+moment+ :request; the warm-up
-    # too, on its own copy, as the next turn's first request) and at the
-    # end of a turn the model answered (:turn_end): the strategy's layers
-    # stage their edits on +conversation+ and the apply rule
-    # (LLMContextApply, llm_context.apply) saves the batch it lets through
-    # as applied, so the request about to be sent (or the next turn's
-    # first, and the warm-up) is the first with the stubs. +context+: the
-    # turn's ContextStatus (payoff applies in its top bucket; an applied
-    # batch rebases its estimate, ContextStatus#edited!). none changes
-    # nothing. Logged as llm_context_apply when a batch is applied, and
-    # shown to the user as a ✂ row (+emit+ takes the :llm_context_edited
-    # event, LLMContextNotice; the warm-up's own copy has none).
+    # The strategy's edits on +conversation+ (LLMContextApply.apply!), under
+    # the turn's strategy and model name by default: the native run's
+    # requests and turn end, the warm-up's copy, a forget_outputs call.
     # @return [LLMContextApply::Outcome]
-    # +model+: the run's model name, in the log line (the chat loop's own).
-    def apply_llm_context!(conversation, llm_context = turn_settings&.llm_context, moment: :request, context: nil,
-                           warmup: false, emit: nil, model: turn_settings&.model_name)
-      view = llm_context_view(llm_context)
-      return LLMContextApply::Outcome.none if view.none?
-
-      outcome = LLMContextApply.run!(conversation, layers: view.layers, rule: llm_context.apply, moment: moment,
-                                                   protect_steps: llm_context.protect_steps,
-                                                   top_bucket: context&.top_bucket? || false,
-                                                   changes: llm_context.stale_edits)
-      if outcome.applied?
-        # The prompt just shrank: the context estimate counts from it.
-        context&.edited!
-        unless warmup
-          log_llm_context(outcome, llm_context, moment, model)
-          emit_llm_context(emit, conversation, outcome, moment) if emit
-        end
-      end
-      outcome
-    end
-
-    def log_llm_context(outcome, llm_context, moment, model)
-      Log.info(:model, "llm_context_apply", rule: llm_context.apply, at: moment, why: outcome.why,
-                                            applied: outcome.applied.size, ids: outcome.applied.map(&:id).join(","),
-                                            staged: outcome.staged, freed: (outcome.freed_chars / TokenUsage::CHARS_PER_TOKEN).ceil,
-                                            tail: (outcome.tail_chars / TokenUsage::CHARS_PER_TOKEN).ceil,
-                                            model: model)
-    end
-    private :log_llm_context
-
-    # The batch's ✂ row; a row that can't be built never breaks the turn.
-    def emit_llm_context(emit, conversation, outcome, moment)
-      emit.call(LLMContextNotice.event(conversation, outcome, moment: moment))
-    rescue StandardError => e
-      Log.warn(:model, "llm_context_notice_failed", error: e.class.name, message: e.message)
-    end
-    private :emit_llm_context
-
-    # A request's re-prefilled tokens, for both loops: of the prompt the
-    # last request on +model+ through this client (the host) sent (this
-    # kernel's, any turn), what the server didn't reuse from its cache this
-    # time (that prompt less +cached+), so an LLM context edit's cache break
-    # shows, and so does anything else that rewrote the prompt's middle or
-    # lost the cache. nil under TokenUsage::REPREFILL_MIN_TOKENS (a cache
-    # block's rounding), for a server that reports no cached count (or 0: a
-    # cold cache isn't told from no cache), the first request, a model
-    # switch (another bare model, or the same one on another host: the
-    # Engine points #client at the new host's; SessionMetrics counts that
-    # prefill as the switch's), and the first request after a warm-up
-    # (#warmed_up!).
-    # @return [Integer, nil]
-    def reprefilled_tokens(model, prompt:, cached:)
-      previous = @reprefill_baseline
-      @reprefill_baseline = { model: model, client: @client, prompt: prompt.to_i } if prompt.to_i.positive?
-      return nil unless previous && previous[:model] == model && previous[:client].equal?(@client) && cached.to_i.positive?
-
-      tokens = previous[:prompt] - cached.to_i
-      tokens >= TokenUsage::REPREFILL_MIN_TOKENS ? tokens : nil
+    def apply_llm_context!(conversation, llm_context = turn_settings&.llm_context, model: turn_settings&.model_name, **)
+      LLMContextApply.apply!(conversation, llm_context, model: model, **)
     end
 
     # The Engine started a turn-end warm-up: it prefills the next prompt
     # off the clock, so the next request's cache counts are against it, not
-    # the last request (#reprefilled_tokens starts over).
+    # the last request (the re-prefill meter starts over, ReprefillMeter#reset!).
     def warmed_up!
-      @reprefill_baseline = nil
+      @reprefill.reset!
     end
 
     # Public wrapper so other loops (e.g. the chat loop) can strip
@@ -1212,21 +1130,28 @@ module Samagotchi
     # first (see Samagotchi::LLM::NativeToolNormalizer); dispatch itself never
     # parses provider text. +context+: the call's turn (TurnContext: its
     # ToolSurface, the handler's ToolContext); a bare kernel's own
-    # (#context) by default.
-    def dispatch_tool_call(call, context = @context)
+    # (#own_context) by default.
+    def dispatch_tool_call(call, context = own_context)
       dispatch(call, context)
     end
 
+    # The context a bare kernel (no Engine: a spec, a bench) runs in when
+    # given none: #context, with a Tools::ToolSurface built now from the
+    # kernel's tools when it has none (Tools::ToolSurface.bare). An
+    # Engine's turn always hands its own down (Engine#generate's surface).
+    # @return [TurnContext]
+    def own_context = Tools::ToolSurface.bare(@context, tools)
+
     private
 
     # The call runs on the entry the turn's surface gives it
     # (Tools::ToolSurface#entry_for: a call_tool-reached one only while the
     # toolkit reaches it that way, a reachable one by its name on a host
     # that loads tools); without one it gets ToolSurface#unknown_tool_error.
-    # A context without a surface (a bare kernel) computes one now.
+    # A context without a surface raises Tools::MissingSurface.
     def dispatch(call, context)
       model = context.settings&.model_name
-      surface = Tools::ToolSurface.of(context, tools)
+      surface = Tools::ToolSurface.of(context)
       entry = surface.entry_for(call)
       unless entry
         result = surface.unknown_tool_error(call[:name], via: call[:via])
@@ -1271,10 +1196,10 @@ module Samagotchi
     rescue StandardError => e
       dump_log("tool_error", e.message, model: context.settings&.model_name, tool: call[:name], error: e.class.name)
       result = "Error: #{e.message}"
-      {
-        output: "[#{call[:name]}] #{result}",
-        activity: ToolActivity.tool_activity_event(call[:name], call, result, registry: tools, surface: surface)
-      }
+      # No surface (Tools::MissingSurface from ToolSurface.of): no row either,
+      # it would read the surface again.
+      activity = surface && ToolActivity.tool_activity_event(call[:name], call, result, registry: tools, surface: surface)
+      { output: "[#{call[:name]}] #{result}", activity: activity }
     end
   end
 end

data/lib/samagotchi/llm/anthropic_wire.rb

@@ -4,7 +4,7 @@ require "digest"
 require "json"
 require_relative "../log"
 require_relative "utf8_scrub"
-require_relative "../tools/tool_index"
+require_relative "../tools/index_hint"
 
 module Samagotchi
   module LLM
@@ -278,7 +278,7 @@ module Samagotchi
       # don't change; only this wire says it).
       def loaded_text(text, names)
         line = "Loaded: #{names.join(", ")}. #{LOADED_HINT}"
-        text = text.sub("#{Tools::ToolIndex::CALL_HINT}\n\n", "")
+        text = text.sub("#{Tools::IndexHint::CALL_HINT}\n\n", "")
         blank?(text) ? line : "#{line}\n\n#{text}"
       end
 

data/lib/samagotchi/llm/chat_loop.rb

@@ -20,6 +20,7 @@ require_relative "../cut_policy"
 require_relative "../context_status"
 require_relative "../context_window"
 require_relative "../context_note"
+require_relative "../tool_output_cut"
 require_relative "../tool_runner"
 require_relative "../tool_response"
 require_relative "../tool_ids"
@@ -27,7 +28,10 @@ require_relative "../tool_declarations"
 require_relative "../tools/tool_surface"
 require_relative "../tool_loads"
 require_relative "../vision_context"
+require_relative "../llm_context_apply"
+require_relative "../llm_context_view"
 require_relative "../log"
+require_relative "../reprefill_meter"
 require_relative "../empty_answer_retry"
 require_relative "../steer"
 require_relative "../reasoning_history"
@@ -66,6 +70,12 @@ module Samagotchi
       # The session every request is for; Engine sets it with the adapter.
       # Goes out as a Session-Id header (OpenAIChat#chat).
       attr_accessor :session_id
+      # The effective model's host's client (EffectiveModel#client): what
+      # #context_window probes on a local host (a llama.cpp /props) and what
+      # a request's re-prefill is counted against. Engine sets it with the
+      # adapter (Engine#backend_for, under its chat backend mutex, from any
+      # thread a model switch runs on); nil until then (no probe).
+      attr_accessor :client
       # The last counted request's chars per token
       # (ContextStatus#counted_chars_per_token), carried to the next turn's
       # tracker: its first estimate counts the tool schemas the chars leave
@@ -73,6 +83,9 @@ module Samagotchi
       attr_accessor :counted_chars_per_token
 
       # @param kernel [KernelLoop] tool dispatch, thought stripping, hooks
+      # @param reprefill [ReprefillMeter, nil] the re-prefill baseline its
+      #   requests count against (the Engine's, shared with its KernelLoop;
+      #   its own by default)
       # @param adapter [OpenAIChat, nil] the host to talk to; Engine sets it
       #   per turn for the effective model's host
       # @param stable_length [#call, nil] text → the length of the system
@@ -81,8 +94,9 @@ module Samagotchi
       #   stream's step is asked again (specs pass one that doesn't sleep)
       # @param context [TurnContext, nil] the turn its helpers read before any
       #   #complete (a bench building wire messages); a run's replaces it
-      def initialize(kernel:, adapter: nil, stable_length: nil, sleeper: nil, context: nil)
+      def initialize(kernel:, reprefill: nil, adapter: nil, stable_length: nil, sleeper: nil, context: nil)
         @kernel = kernel
+        @reprefill = reprefill || ReprefillMeter.new
         @turn_context = context
         @adapter = adapter
         @stable_length = stable_length
@@ -106,7 +120,7 @@ module Samagotchi
         @turn_context = context if context
         conversation = Array(messages).map(&:dup)
         Run.new(self, conversation, on_stream_event, cancel_controller, model_name, pending_input, start: reasoning_since)
-           .call(max_iterations: max_iterations || 1, cap: KernelLoop.resolve_output_char_cap(max_tool_output_chars))
+           .call(max_iterations: max_iterations || 1, cap: ToolOutputCut.max_chars(max_tool_output_chars))
       rescue StandardError, Interrupt => e
         # A failure, or a Ctrl-C (its calls answered: ToolResponse.run_batch),
         # carries the conversation so far for the Engine to keep.
@@ -137,10 +151,9 @@ module Samagotchi
       # (ToolSurface#deferred_for).
       def deferred_tools(conversation) = surface.deferred_for(conversation)
 
-      # The turn's ToolSurface (#turn_context's), else one computed now from
-      # the kernel's tools (a bare loop).
+      # The turn's ToolSurface (#turn_context's).
       # @return [Tools::ToolSurface]
-      def surface = Tools::ToolSurface.of(turn_context, tools)
+      def surface = Tools::ToolSurface.of(turn_context)
 
       # Whether the adapter takes tools it doesn't declare up front for
       # +model+ (AnthropicMessages#loads_tools?); OpenAIChat doesn't.
@@ -159,9 +172,12 @@ module Samagotchi
 
       # The TurnContext of the run in progress, else of the last run
       # (#complete's context:); before any, the one it was built with, else a
-      # context of the kernel's own settings (a bare loop). Read on the turn's thread only.
+      # context of the kernel's own settings and a surface of its tools
+      # built now (a bare loop, Tools::ToolSurface.bare). Read on the turn's thread only.
       # @return [TurnContext]
-      def turn_context = @turn_context || TurnContext.none(settings: @kernel.turn_settings)
+      def turn_context
+        @turn_context || Tools::ToolSurface.bare(TurnContext.none(settings: @kernel.turn_settings), tools)
+      end
 
       # The turn's LLM::TurnSettings (#turn_context's).
       def settings = turn_context.settings
@@ -173,16 +189,17 @@ module Samagotchi
       # when none was resolved.
       def llm_context = settings&.llm_context
 
-      # KernelLoop#reprefilled_tokens, the kernel's request history.
-      def reprefilled_tokens(model, **) = @kernel.reprefilled_tokens(model, **)
+      # The request's re-prefilled tokens on the loop's meter, against this
+      # loop's host (#client): ReprefillMeter#tokens.
+      def reprefilled_tokens(model, **) = @reprefill.tokens(model, client: @client, **)
 
-      # The kernel's LLMContextView under the turn's strategy.
-      def llm_context_view = @kernel.llm_context_view(llm_context)
+      # The LLMContextView under the turn's strategy (LLMContextView.for).
+      def llm_context_view = LLMContextView.for(llm_context)
 
       # The strategy's own edits before a request and at turn end
-      # (KernelLoop#apply_llm_context!), under the turn's strategy.
+      # (LLMContextApply.apply!), under the turn's strategy and model name.
       def apply_llm_context!(conversation, **)
-        @kernel.apply_llm_context!(conversation, llm_context, model: settings&.model_name, **)
+        LLMContextApply.apply!(conversation, llm_context, model: settings&.model_name, **)
       end
 
       # The running turn, for forget_outputs (KernelLoop#llm_context_turn).
@@ -398,14 +415,13 @@ module Samagotchi
         @tool_runner ||= ToolRunner.new(@kernel, window: ->(run_settings) { context_window(run_settings&.model_name, run_settings) })
       end
 
-      # The window for +model+: the kernel's client probes the server it
-      # points at (Engine keeps it on the effective model's host; a local
-      # llama.cpp answers /props), then the host's model list, the model's
+      # The window for +model+: the loop's client (#client) probes the server
+      # it points at (a local llama.cpp answers /props), then the host's model list, the model's
       # or host's window_tokens, config, env and the default. A remote
       # provider has no /props to probe. +run_settings+: the LLM::TurnSettings
       # whose window_setting counts (the turn's by default).
       def context_window(model, run_settings = settings)
-        client = @adapter.remote? ? nil : @kernel.client
+        client = @adapter.remote? ? nil : @client
         ContextWindow.resolve(client: client, model: model, adapter: @adapter, setting: run_settings&.window_setting)
       rescue StandardError
         nil
@@ -897,7 +913,7 @@ module Samagotchi
           count
         end
 
-        # The request's re-prefilled tokens (KernelLoop#reprefilled_tokens).
+        # The request's re-prefilled tokens (ChatLoop#reprefilled_tokens).
         def reprefill_field(usage)
           return {} unless usage&.source == :server
 

data/lib/samagotchi/llm/native_backend.rb

@@ -27,7 +27,7 @@ module Samagotchi
           max_tool_output_chars: max_tool_output_chars,
           pending_input: pending_input,
           reasoning_since: reasoning_since,
-          context: context || @kernel.context
+          context: context || @kernel.own_context
         )
       end
     end

data/lib/samagotchi/llm_context_apply.rb

@@ -4,8 +4,14 @@ require "time"
 require_relative "llm_context_edit"
 require_relative "llm_context_stale"
 require_relative "llm_context_view"
+require_relative "log"
+require_relative "token_usage"
 
 module Samagotchi
+  # The ✂ row's builder (#apply!), loaded on first use: the test kit loads
+  # this file (through the strategy) and never emits a row.
+  autoload :LLMContextNotice, File.expand_path("llm_context_notice", __dir__)
+
   # When a layer's edits reach the prompt: the apply rule
   # (llm_context.apply, LLMContextStrategy). Every edit breaks the prompt
   # cache from the earliest entry it changes, so the edits due at one point
@@ -59,6 +65,53 @@ module Samagotchi
 
     module_function
 
+    # Before each request of both loops (+moment+ :request; the warm-up
+    # too, on its own copy, as the next turn's first request) and at the
+    # end of a turn the model answered (:turn_end): +llm_context+'s layers
+    # (LLMContextStrategy::Resolved, the turn's) stage their edits on
+    # +conversation+ and its apply rule (#run!) saves the batch it lets
+    # through as applied, so the request about to be sent (or the next
+    # turn's first, and the warm-up) is the first with the stubs.
+    # +context+: the turn's ContextStatus (payoff applies in its top bucket;
+    # an applied batch rebases its estimate, ContextStatus#edited!). none
+    # changes nothing. Logged as llm_context_apply when a batch is applied
+    # (+model+: the run's model name, in the line), and shown to the user as
+    # a ✂ row (+emit+ takes the :llm_context_edited event, LLMContextNotice;
+    # the warm-up's own copy, +warmup+, has neither).
+    # @return [Outcome]
+    def apply!(conversation, llm_context, moment: :request, context: nil, warmup: false, emit: nil, model: nil)
+      view = LLMContextView.for(llm_context)
+      return Outcome.none if view.none?
+
+      outcome = run!(conversation, layers: view.layers, rule: llm_context.apply, moment: moment,
+                                   protect_steps: llm_context.protect_steps, top_bucket: context&.top_bucket? || false,
+                                   changes: llm_context.stale_edits)
+      if outcome.applied?
+        # The prompt just shrank: the context estimate counts from it.
+        context&.edited!
+        unless warmup
+          log_applied(outcome, llm_context, moment, model)
+          emit_applied(emit, conversation, outcome, moment) if emit
+        end
+      end
+      outcome
+    end
+
+    def log_applied(outcome, llm_context, moment, model)
+      Log.info(:model, "llm_context_apply", rule: llm_context.apply, at: moment, why: outcome.why,
+                                            applied: outcome.applied.size, ids: outcome.applied.map(&:id).join(","),
+                                            staged: outcome.staged, freed: (outcome.freed_chars / TokenUsage::CHARS_PER_TOKEN).ceil,
+                                            tail: (outcome.tail_chars / TokenUsage::CHARS_PER_TOKEN).ceil,
+                                            model: model)
+    end
+
+    # The batch's ✂ row; a row that can't be built never breaks the turn.
+    def emit_applied(emit, conversation, outcome, moment)
+      emit.call(LLMContextNotice.event(conversation, outcome, moment: moment))
+    rescue StandardError => e
+      Log.warn(:model, "llm_context_notice_failed", error: e.class.name, message: e.message)
+    end
+
     # Stages what +layers+ find on +conversation+ and applies what +rule+
     # lets through at +moment+.
     # @param top_bucket [Boolean] the context is in the top ContextStatus bucket
@@ -160,6 +213,6 @@ module Samagotchi
       end
     end
 
-    private_class_method :stage, :choose, :measure, :saved_staged
+    private_class_method :stage, :choose, :measure, :saved_staged, :log_applied, :emit_applied
   end
 end

data/lib/samagotchi/llm_context_notice.rb

@@ -7,7 +7,7 @@ require_relative "token_usage"
 module Samagotchi
   # The ✂ row a turn gets for a batch of LLM context edits the apply rule
   # let through (LLMContextApply::Outcome#applied?): the :llm_context_edited
-  # event both loops emit (KernelLoop#apply_llm_context!, its +emit+), at a
+  # event both loops emit (LLMContextApply.apply!, its +emit+), at a
   # request (+moment+ :request; a forget_outputs call's batch too) or at the
   # end of a turn (:turn_end); never for the warm-up, a held or a staged
   # batch, or a restore (the forget_outputs row says it). The web and the

data/lib/samagotchi/llm_context_strategy.rb

@@ -35,11 +35,9 @@ module Samagotchi
     LAYERS = %i[stale forget].freeze
     # The layers a turn can run under so far.
     BUILT = %i[stale forget].freeze
-    # The sentence forget_outputs' description carries (global only):
-    # the plan's D7 line, adapted from CLM's steering example.
+    # The sentence forget_outputs' description carries (global only; its
+    # default is Config::DEFAULT_LLM_CONTEXT_POLICY).
     POLICY_SETTING = "llm_context.policy"
-    DEFAULT_POLICY = "Tidy at subtask boundaries: once a subtask is done, forget its tool outputs and note what it " \
-                     "established; keep anything you'll still edit against."
 
     APPLY_SETTING = "llm_context.apply"
     APPLY_KEY = "llm_context_apply"
@@ -174,7 +172,7 @@ module Samagotchi
     # The strategy for +target+'s turn.
     # @param target [HostRegistry::ModelTarget, nil]
     # @param names [Array<String>] HostRegistry#lookup_names
-    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
     # @param session [Array<Symbol>, nil] the session's own layers ([]: none)
     # @param session_apply [Symbol, nil] the session's own apply rule
     # @param session_budget [Integer, nil] the session's own budget (0: off)
@@ -187,7 +185,7 @@ module Samagotchi
     # #resolve, with where each value came from.
     # @return [Explained]
     def explain(target, names:, models: nil, session: nil, session_apply: nil, session_budget: nil)
-      models ||= ConfigFile.model_settings
+      models ||= ModelSettings.all
       layers, source, where = layers_for(target, names, models, session)
       apply, apply_origin = apply_for(target, names, models, session_apply)
       budget, budget_origin = budget_for(target, names, models, session_budget)
@@ -236,7 +234,7 @@ module Samagotchi
     def budget_for(target, names, models, session_budget)
       return [session_budget.positive? ? session_budget : nil, SESSION_ORIGIN] unless session_budget.nil?
 
-      if (setting = ConfigFile.model_setting(names, :llm_context_budget_tokens, models: models))
+      if (setting = ModelSettings.find(names, :llm_context_budget_tokens, models: models))
         return [setting.value, Origin.new(source: :model_setting, where: "models: #{setting.key}")]
       end
 
@@ -249,7 +247,7 @@ module Samagotchi
     def layers_for(target, names, models, session)
       return [session, :session, SESSION_ORIGIN.where] if session
 
-      if (setting = ConfigFile.model_setting(names, :llm_context_strategy, models: models))
+      if (setting = ModelSettings.find(names, :llm_context_strategy, models: models))
         return [setting.value, :model_setting, "models: #{setting.key}"]
       end
 
@@ -263,7 +261,7 @@ module Samagotchi
     def apply_for(target, names, models, session_apply)
       return [session_apply, SESSION_ORIGIN] if session_apply
 
-      if (setting = ConfigFile.model_setting(names, :llm_context_apply, models: models))
+      if (setting = ModelSettings.find(names, :llm_context_apply, models: models))
         return [setting.value, Origin.new(source: :model_setting, where: "models: #{setting.key}")]
       end
 

data/lib/samagotchi/llm_context_view.rb

@@ -73,6 +73,15 @@ module Samagotchi
       end
     end
 
+    # The view under +llm_context+'s strategy (LLMContextStrategy::Resolved,
+    # a turn's TurnSettings#llm_context), none without one: what both loops
+    # format the conversation through, so the warm-up warms the prompt the
+    # next turn sends.
+    # @return [LLMContextView]
+    def self.for(llm_context)
+      new(strategy: llm_context&.strategy || NONE)
+    end
+
     # @param strategy [Symbol, Array<Symbol>] :none, or the layers
     def initialize(strategy: NONE)
       @layers = strategy == NONE ? [] : Array(strategy).map(&:to_sym) & LAYERS

data/lib/samagotchi/model_price.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "config"
+
 module Samagotchi
   # A model's price on a host (hosts.<name>.models.<id>.price), in USD per
   # 1M tokens: what a generation's cost is estimated from when the provider
@@ -13,7 +15,7 @@ module Samagotchi
     def self.parse(raw, where)
       return nil if raw.nil?
 
-      values = raw.is_a?(Hash) ? raw.transform_keys(&:to_s).slice(*ModelPrice::KEYS) : nil
+      values = raw.is_a?(Hash) ? raw.transform_keys(&:to_s).slice(*Config::MODEL_PRICE_KEYS) : nil
       valid = values && values.key?("input") && values.key?("output") &&
               # YAML's .inf and .nan are Floats too: an infinite price
               # isn't one, and NaN poisons the sums.
@@ -26,12 +28,7 @@ module Samagotchi
           cache_write: values.fetch("cache_write", values["input"]), output: values["output"])
     end
 
-    # config.rb requires model_price through host_model, so config is
-    # required here only when a warning needs it.
-    def self.warn_once(message)
-      require_relative "config"
-      ConfigFile.warn_once(message)
-    end
+    def self.warn_once(message) = ConfigFile.warn_once(message)
     private_class_method :warn_once
 
     # The cost rule, one place for a turn's generation (SessionMetrics) and
@@ -63,7 +60,4 @@ module Samagotchi
        (completion_tokens * output)) / 1e6
     end
   end
-
-  # The keys a price may hold (config validation checks them too).
-  ModelPrice::KEYS = %w[input cache_read cache_write output].freeze
 end