samagotchi 0.155.0 → 0.157.0

data/lib/samagotchi/effective_model.rb

@@ -4,6 +4,7 @@ require_relative "host_registry"
 require_relative "log"
 require_relative "context_window"
 require_relative "llm_context_strategy"
+require_relative "model_lookup"
 require_relative "model_profile"
 require_relative "reasoning_history"
 require_relative "sampling_settings"
@@ -22,7 +23,8 @@ module Samagotchi
 
   # The effective model resolved once (HostRegistry#resolve: its host and
   # client, the id sent) with the names its models: entry may be under
-  # (HostRegistry#lookup_names), and its settings read from them. An
+  # (HostRegistry#lookup_names), and its settings read from them through
+  # one ModelLookup (every layer's input, with the registry's env). An
   # immutable snapshot built per read, never kept across reads: config.yml,
   # a model listing (which may move a bare id to another host) and another
   # process's saved lists all change what a resolve gives without any
@@ -32,14 +34,17 @@ module Samagotchi
   # Engine has always given (Unresolved); building one raises as
   # HostRegistry#resolve does (SessionModelSettings#model_setting gives the
   # fallback then).
-  EffectiveModel = Data.define(:registry, :name, :typed, :target, :names) do
+  EffectiveModel = Data.define(:registry, :name, :typed, :target, :names, :lookup) do
     # @param registry [HostRegistry]
     # @param choice [ModelChoice]
+    # @param models [Hash{String => ModelSettings}, nil] one models: map for
+    #   many models (a picker); ModelSettings.all at each read by default
     # @raise what HostRegistry#resolve raises
-    def self.of(registry, choice)
+    def self.of(registry, choice, models: nil)
       target = registry.resolve(choice.name)
-      new(registry: registry, name: choice.name, typed: choice.typed, target: target,
-          names: registry.lookup_names(choice.typed, resolved: choice.name, target: target))
+      names = registry.lookup_names(choice.typed, resolved: choice.name, target: target)
+      new(registry: registry, name: choice.name, typed: choice.typed, target: target, names: names,
+          lookup: ModelLookup.for(target, names: names, models: models, env: registry.env))
     end
 
     # A saved session's model (no worker): its model name, the default when
@@ -50,6 +55,34 @@ module Samagotchi
       of(registry, ModelChoice.new(name: name, typed: session.model_typed || name))
     end
 
+    # A saved session's LLM context strategy, apply rule and budget, each
+    # with where it came from (LLMContextStrategy::Explained#summary), as
+    # its worker would resolve them; nil when they can't be (an unreadable
+    # config, a model that resolves nowhere). From config and the registry
+    # only: no network, no model call. What a session page, a session
+    # list's ctx % and a spawn-time check all read.
+    # @param session [Session, nil]
+    # @param registry [HostRegistry, nil] the hosts to resolve against;
+    #   HostRegistry.current by default
+    # @return [Hash, nil] Explained#summary, symbol keys
+    def self.session_llm_context(session, registry: nil)
+      return nil if session.nil?
+
+      own = session.llm_context
+      of_session(session, registry: registry || HostRegistry.current).llm_context_explained(own&.resolve_args || {})&.summary(own)
+    rescue StandardError # degrade-ok: a saved session's model that resolves nowhere has no budget to show; the readers log their own
+      nil
+    end
+
+    # The budget a saved session's turns run under
+    # (.session_llm_context's :budget_tokens), nil when it is off or can't
+    # be resolved. What a session list's ctx % counts against, so a saved
+    # session's fill reads as the live meter.
+    # @return [Integer, nil]
+    def self.session_budget(session, registry: nil)
+      session_llm_context(session, registry: registry)&.fetch(:budget_tokens, nil)
+    end
+
     def entry = target.entry
     def client = target.client
     def bare = target.bare_model
@@ -63,21 +96,21 @@ module Samagotchi
 
     # The configured request parameters (hosts: and models: sampling).
     def sampling
-      SamplingSettings.for(target, names: names)
+      SamplingSettings.for(lookup)
     rescue StandardError => e
       unresolved(:sampling_unresolved, e, SamplingSettings::EMPTY)
     end
 
     # "temperature=0.6 (hosts.work)", nil when none.
     def sampling_summary
-      SamplingSettings.summary(target, names: names)
+      SamplingSettings.summary(lookup)
     rescue StandardError => e
       unresolved(:sampling_unresolved, e, nil)
     end
 
     # The thinking level (Thinking.resolve), the session's +own+ first.
     def thinking(own:)
-      Thinking.resolve(target, names: names, session: own).first
+      Thinking.resolve(lookup, session: own).first
     rescue StandardError => e
       unresolved(:thinking_unresolved, e, Thinking::DEFAULT)
     end
@@ -85,23 +118,25 @@ module Samagotchi
     # The thinking level with where it came from (SettingExplained), nil
     # when it can't be resolved.
     def thinking_explained(own:)
-      Thinking.explain(target, names: names, session: own)
+      Thinking.explain(lookup, session: own)
     rescue StandardError => e
       unresolved(:thinking_unresolved, e, nil)
     end
 
     # What a thinking level change costs the prompt cache
     # (Thinking.cache_cost); the block gives the prompt profile, asked only
-    # on a native host. Raises.
+    # on a native host; a local chat host's is the one its name says. Raises.
     # @return [Symbol]
     def thinking_cache_cost(&)
-      Thinking.cache_cost(target, profile: entry&.chat? ? nil : yield&.name)
+      return Thinking.cache_cost(target, inferred: ModelProfile.inferred_profile_name(bare)) if entry&.chat?
+
+      Thinking.cache_cost(target, profile: yield&.name)
     end
 
     # The reasoning_history level (ReasoningHistory.resolve), the session's
     # +own+ first.
     def reasoning_history(own:)
-      ReasoningHistory.resolve(target, names: names, session: own).first
+      ReasoningHistory.resolve(lookup, session: own).first
     rescue StandardError => e
       unresolved(:reasoning_history_unresolved, e, ReasoningHistory::DEFAULT)
     end
@@ -112,7 +147,7 @@ module Samagotchi
     def reasoning_history_explained(own:, native: false)
       return nil unless native || entry&.chat?
 
-      ReasoningHistory.explain(target, names: names, session: own)
+      ReasoningHistory.explain(lookup, session: own)
     rescue StandardError => e
       unresolved(:reasoning_history_unresolved, e, nil)
     end
@@ -122,7 +157,7 @@ module Samagotchi
     def reasoning_history_summary(own:)
       return nil unless entry&.chat?
 
-      level, source = ReasoningHistory.resolve(target, names: names, session: own)
+      level, source = ReasoningHistory.resolve(lookup, session: own)
       source ? ReasoningHistory.label(level, source) : nil
     rescue StandardError => e
       unresolved(:reasoning_history_unresolved, e, nil)
@@ -139,7 +174,7 @@ module Samagotchi
     # [seconds, source] a cut waits for thinking (SteerCutAfter.resolve);
     # the global and its name when it can't be resolved.
     def steer_cut_after_explained
-      SteerCutAfter.resolve(target, names: names)
+      SteerCutAfter.resolve(lookup)
     rescue StandardError => e
       unresolved(:steer_cut_after_unresolved, e, [SteerCut.cut_after, "steer.cut_after"])
     end
@@ -148,7 +183,7 @@ module Samagotchi
     # (LLMContextStrategy.explain) under the session's +args+
     # (LLMContextOverride#resolve_args), nil when it can't be resolved.
     def llm_context_explained(args)
-      LLMContextStrategy.explain(target, names: names, **args)
+      LLMContextStrategy.explain(lookup, **args)
     rescue StandardError => e
       unresolved(:llm_context_unresolved, e, nil)
     end
@@ -156,14 +191,14 @@ module Samagotchi
     # The LLM context layers its turns run under; [] when they can't be
     # resolved.
     def llm_context_layers(args)
-      LLMContextStrategy.resolve(target, names: names, **args).active_layers
+      LLMContextStrategy.resolve(lookup, **args).active_layers
     rescue StandardError => e
       unresolved(:llm_context_unresolved, e, [])
     end
 
     # models:/hosts: window_tokens (ContextWindow.setting), nil when unset.
     def window_setting
-      ContextWindow.setting(target, names: names)
+      ContextWindow.setting(lookup)
     rescue StandardError => e
       unresolved(:window_unresolved, e, nil)
     end
@@ -171,7 +206,7 @@ module Samagotchi
     # The window config.yml gives this model or its host
     # (ContextWindow.setting), never asking a server: a session loaded on
     # it (Engine#session=, before a worker's Bridge serves). nil when none.
-    def configured_context_window = ContextWindow.setting(target, names: names)
+    def configured_context_window = ContextWindow.setting(lookup)
 
     # The window as its loop would see it (ChatLoop#context_window: a remote
     # chat host has no /props, only its model list); nil when it can't be
@@ -183,7 +218,7 @@ module Samagotchi
         adapter = registry.adapter_for(entry)
         client = nil if adapter.remote?
       end
-      ContextWindow.resolve(client: client, model: bare, adapter: adapter, setting: ContextWindow.setting(target, names: names))
+      ContextWindow.resolve(client: client, model: bare, adapter: adapter, setting: ContextWindow.setting(lookup))
     rescue StandardError => e
       unresolved(:window_unresolved, e, nil)
     end
@@ -232,7 +267,7 @@ module Samagotchi
 
     # Whether it sees images (VisionSupport.for) under +profile+.
     def vision_support(profile)
-      VisionSupport.for(target, profile: profile, adapter: vision_adapter, names: names)
+      VisionSupport.for(lookup, profile: profile, adapter: vision_adapter)
     end
 
     # A chat host's adapter (what it says of images), nil on a native host.
@@ -246,7 +281,7 @@ module Samagotchi
     # Not cached here. Raises.
     # @return [ModelProfile::Resolution]
     def profile_resolution
-      ModelProfile.resolve(names: names, entry: entry, client: client, bare_model: bare)
+      ModelProfile.resolve(names: names, entry: entry, client: client, bare_model: bare, models: lookup.models)
     end
 
     # See Unresolved.fallback.

data/lib/samagotchi/engine/context_judge.rb

@@ -5,7 +5,7 @@ module Samagotchi
     # The attached-context candidate judge (TurnStages::ContextJudge,
     # forwarded): prepare_turn starts its pass, run_turn's ensure shows the
     # cards it held, and a plugin's late candidate asks it. Reads
-    # @context_judge, @side_judgments, @host_registry.
+    # @context_judge, @side_judgments, @host_registry, @turn_state, @session.
     module ContextJudgePart
       private
 
@@ -13,19 +13,27 @@ module Samagotchi
       attr_reader :context_judge
 
       # A late proposal no owner prompt mentions (Plugin::Host
-      # #candidate_proposed): TurnStages::ContextJudge#late_candidates.
-      def judge_late_candidates = @context_judge.late_candidates
+      # #candidate_proposed, maybe while the plugins load, before a session
+      # or the event log is there): TurnStages::ContextJudge#late_candidates
+      # on the session the Engine is on (none, or a review session: nothing,
+      # before anything else is read), the owner's prompts so far, the
+      # recorder and the sessions dir, all read now on the caller's thread.
+      def judge_late_candidates
+        session = @session
+        return if session.nil? || session.review?
 
-      # The stage over this Engine's side asks and its session (built in
+        @context_judge.late_candidates(session, messages: plugin_messages, recorder: system_one_recorder,
+                                                state_dir: session_state_dir)
+      end
+
+      # The stage over this Engine's side asks (built in
       # #build_tools_and_plugins, before the plugins load: one may propose a
-      # candidate as it loads).
+      # candidate as it loads). Its two callables are the asks thread's late
+      # reads: the session the Engine is on and where a card goes, both as
+      # an answer comes.
       def build_context_judge
-        TurnStages::ContextJudge.new(
-          side_judgments: @side_judgments, host_registry: @host_registry, state_dir: -> { session_state_dir },
-          recording: ->(client, judgment, session, mode:) { system_one_recording(client, judgment, session, mode: mode) },
-          session: -> { session }, messages: -> { plugin_messages }, turn_running: -> { turn_running? },
-          show_card: ->(**card) { show_card(**card) }
-        )
+        TurnStages::ContextJudge.new(side_judgments: @side_judgments, host_registry: @host_registry, turn_state: @turn_state,
+                                     show_card: ->(**card) { show_card(**card) }, current_session: -> { @session })
       end
     end
   end

data/lib/samagotchi/engine/messages.rb

@@ -46,7 +46,7 @@ module Samagotchi
                      from_cwd: note[:from_cwd], text: note[:text], context_source: note[:context_source],
                      created_at: note[:created_at], objectives: entry }.compact)
           announce_objectives(session) if entry
-          @objectives_stage.note(session, note)
+          @objectives_stage.note(session, note, recorder: system_one_recorder, state_dir: session_state_dir)
           message
         end
       end

data/lib/samagotchi/engine/models.rb

@@ -228,13 +228,16 @@ module Samagotchi
       private
 
       # Pick the loop for +model+ (EffectiveModel); the chat loop is pointed
-      # at its host's adapter (one per host, kept for its cached model list).
+      # at its host's adapter (one per host, kept for its cached model list)
+      # and client (the window probe, the re-prefill's host).
       def backend_for(model)
         return @native_backend unless model.chat?
 
         @chat_backend_mutex.synchronize do
-          @chat_backend ||= LLM::ChatLoop.new(kernel: @kernel, stable_length: ->(text) { @prompt_builder.stable_length(text) })
+          @chat_backend ||= LLM::ChatLoop.new(kernel: @kernel, reprefill: @reprefill,
+                                              stable_length: ->(text) { @prompt_builder.stable_length(text) })
           @chat_backend.adapter = @host_registry.adapter_for(model.entry)
+          @chat_backend.client = model.client
           @chat_backend.session_id = session&.id
           @chat_backend
         end

data/lib/samagotchi/engine/objectives.rb

@@ -9,8 +9,22 @@ module Samagotchi
     # @host_registry, @session.
     module ObjectivesPart
       # The session's objectives as the page draws them, when that differs
-      # from the last announced (TurnStages::Objectives#announce).
-      def announce_objectives(session = @session) = @objectives_stage.announce(session)
+      # from the last announced (TurnStages::Objectives#announce), from any
+      # thread: end_turn's step, a command, Check this's thread, a note,
+      # a rollback. Under the event lock, which guards the last view: the
+      # sessions dir and the running turn's conversation read there, the
+      # event announced in the same step. It only informs: a failure is
+      # logged, never raised.
+      def announce_objectives(session = @session)
+        return unless session
+
+        synchronize_events do
+          event = @objectives_stage.announce(session, state_dir: session_state_dir, running: live_conversation)
+          announce(event) if event
+        end
+      rescue StandardError => e
+        Log.warn(:turn, "objectives_announce_failed", error: e.class.name, msg: e.message)
+      end
 
       # Check this (ObjectivesCheck)'s one side request. Its usage is in the
       # session's side line. Raises as ctx.ask_model's request does.
@@ -32,16 +46,20 @@ module Samagotchi
       # The objectives' stage (TurnStages::Objectives).
       attr_reader :objectives_stage
 
-      # The stage over this Engine's side asks and its event lock (built in
-      # #initialize, once the host registry is).
+      # However +turn+ ended (run_turn's ensure, after the turn flag is
+      # released): a completed turn's proposal cards shown
+      # (TurnStages::Objectives#finally). A card that fails is logged.
+      def show_objective_proposals(turn)
+        @objectives_stage.finally(turn).each { |card| show_card(**card) }
+      rescue StandardError => e
+        Log.warn(:turn, "objectives_proposal_failed", error: e.class.name, msg: e.message)
+      end
+
+      # The stage over this Engine's side asks (built in #initialize, once
+      # the host registry is). Each call takes its values: the recorder,
+      # the sessions dir, the running conversation.
       def build_objectives_stage
-        TurnStages::Objectives.new(
-          side_judgments: @side_judgments, host_registry: @host_registry, state_dir: -> { session_state_dir },
-          recording: ->(client, judgment, session, mode:) { system_one_recording(client, judgment, session, mode: mode) },
-          runs: -> { system_one_runs }, synchronize: ->(&block) { synchronize_events(&block) },
-          announce: ->(event) { announce(event) }, running: -> { live_conversation },
-          show_card: ->(**card) { show_card(**card) }
-        )
+        TurnStages::Objectives.new(side_judgments: @side_judgments, host_registry: @host_registry)
       end
     end
   end

data/lib/samagotchi/engine/plugins.rb

@@ -60,7 +60,7 @@ module Samagotchi
           prompt_sections: @prompt_sections,
           prompt_changed: -> { prompt_changed! },
           judgments: @judgments,
-          hook_failed: ->(hook, failed) { @hook_routes.plugin_hook_failed(hook, failed) }
+          hook_failed: ->(hook, failed, effect: :log) { @hook_routes.plugin_hook_failed(hook, failed, effect: effect) }
         )
         # What plugins show while they load (an MCP server that didn't
         # start) waits for the first turn, beside the load warnings: no UI

data/lib/samagotchi/engine/recap.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../recap_place"
+
 module Samagotchi
   class Engine
     # The idle recap (IdleRecap) and the shared idle scheduler: the recap job
@@ -96,9 +98,10 @@ module Samagotchi
         @recap ? @recap.request_now : :off
       end
 
-      # The recap saved with the current session (recap.json), and how many
-      # user turns came after it (0: it is current).
-      # @return [Hash, nil] {text:, covered:, turns_since:, created_at:}
+      # The recap saved with the current session (recap.json), how many
+      # user turns came after it (0: it is current), and the stamp of the
+      # last turn it covers (RecapPlace: where a page puts it; nil, the count).
+      # @return [Hash, nil] {text:, covered:, turns_since:, opening_id:, created_at:}
       def saved_recap
         state = @recap&.state
         return nil unless state
@@ -106,7 +109,8 @@ module Samagotchi
         messages = @session&.messages || []
         covered = state[:covered].to_i
         turns_since = Array(messages).drop(covered).count { |m| Steer.turn_opening?(m) }
-        { text: state[:text], covered: covered, turns_since: turns_since, created_at: state[:created_at] }
+        { text: state[:text], covered: covered, turns_since: turns_since, opening_id: RecapPlace.opening_id(messages, covered),
+          created_at: state[:created_at] }
       end
 
       # Start the shared idle scheduler (reminders + optional recap). The recap

data/lib/samagotchi/engine/side_requests.rb

@@ -6,6 +6,7 @@ module Samagotchi
     # IdleClient, their usage in the session's side line, and System 1's
     # recording of judged asks. Writes @side_client/@side_client_key (under
     # @side_client_mutex); reads @metrics, @session, @host_registry.
+    # The recorder (SystemOne::Recorder) is the turn stages' recording seam.
     module SideRequestsPart
       # Count one side request (a recap, a plugin's ctx.ask_model: IdleClient's
       # on_usage) in the session's side line, apart from its turns' totals.
@@ -52,24 +53,33 @@ module Samagotchi
 
       private
 
-      # +client+ (nil for none) saving its asks as +judgment+'s runs. Anything
-      # going wrong here leaves the client as it was: a run is never worth a
-      # judgment.
-      #
-      # A scratch session's asks aren't saved; a participant's turn is never
-      # judged, so it never comes here.
+      # +client+ (nil for none) saving its asks as +judgment+'s runs
+      # (SystemOne::Recorder#wrap, over a recorder built now): the
+      # guardrails' System 1 client. No client or a scratch session: the
+      # client as it is, with nothing read (no recorder built).
       # @param mode [String, nil] the use's mode, for its runs (Recording.wrap)
       def system_one_recording(client, judgment, session, mode: nil)
         return client if client.nil? || session&.scratch
 
-        context = SystemOne::Recording::Context.of(session, session_model: session && effective_model_name)
-        SystemOne::Recording.wrap(client, judgment: judgment, runs: system_one_runs, context: context, recorded_mode: mode)
-      rescue StandardError => e
-        Log.warn(:system_one, "system_one_recording_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-        client
+        system_one_recorder.wrap(client, judgment, session, mode: mode)
       end
       private :system_one_recording
 
+      # What a turn stage saves its System 1 asks with (SystemOne::Recorder):
+      # this Engine's runs and the model it names now, read at this call and
+      # never kept, so each stage call sees the model as it is then (an
+      # outgoing ask after a before_turn hook's switch, the new one). Never
+      # raises: on a failure, SystemOne::Recorder::NONE (no runs, the plain
+      # client), said once per failure as before.
+      # @return [SystemOne::Recorder]
+      def system_one_recorder
+        SystemOne::Recorder.new(runs: system_one_runs, session_model: effective_model_name)
+      rescue StandardError => e
+        SystemOne::Recorder.failed(e)
+        SystemOne::Recorder::NONE
+      end
+      private :system_one_recorder
+
       # Where this Engine's runs are saved; read each time, as the settings are.
       def system_one_runs = SystemOne::Runs.for_sessions_dir(session_state_dir)
       private :system_one_runs

data/lib/samagotchi/engine/toolkit.rb

@@ -22,10 +22,14 @@ module Samagotchi
       # turn's staged tool sets and its toolkit apply.
       def publish_tools! = @toolkit_binding.publish!
 
+      # That published Registry (ToolkitBinding#published): what a reader
+      # off the turn thread (/toolkit) reads of the tools.
+      def published_tools = @toolkit_binding.published
+
       # The tools this session registered (Tools::Registry), declared or not.
       attr_reader :tools
 
-      public :tools, :toolkit_kits, :resolved_toolkit, :toolkit_explained, :toolkit_summary
+      public :tools, :published_tools, :toolkit_kits, :resolved_toolkit, :toolkit_explained, :toolkit_summary
 
       # A plugin's ctx.load_tools: stage the reachable tools +names+ names
       # (Tools::ToolIndex#deferred_name, on the published Registry) that the
@@ -35,7 +39,7 @@ module Samagotchi
       # @return [Array<String>] the wire names staged
       def load_tools(names, bundle)
         added = ToolLoads.added(@session&.messages)
-        published = @toolkit_binding.published
+        published = published_tools
         surface = Tools::ToolSurface.for(published)
         wanted = names.filter_map do |name|
           wire = @tool_index.deferred_name(name, surface)
@@ -97,14 +101,11 @@ module Samagotchi
       public :warm_toolkit_suggestion!
 
       # The stage over this Engine's side asks, binding and tools (built in
-      # #build_tools_and_plugins, before the plugins load).
+      # #build_tools_and_plugins, before the plugins load). Its turn's start
+      # takes the recorder (#system_one_recorder) per call.
       def build_toolkit_suggestion
-        TurnStages::ToolkitSuggestion.new(
-          side_judgments: @side_judgments, host_registry: @host_registry, toolkit_binding: @toolkit_binding,
-          tools: @tools, state_dir: -> { session_state_dir },
-          recording: ->(client, judgment, session, mode:) { system_one_recording(client, judgment, session, mode: mode) },
-          runs: -> { system_one_runs }
-        )
+        TurnStages::ToolkitSuggestion.new(side_judgments: @side_judgments, host_registry: @host_registry,
+                                          toolkit_binding: @toolkit_binding, tools: @tools)
       end
       private :build_toolkit_suggestion
     end

data/lib/samagotchi/engine/turn_end.rb

@@ -117,7 +117,7 @@ module Samagotchi
         # a display version of the answer (AnswerDisplay) and event[:refs]
         # for refs on it (AnswerRefs).
         session = turn.session
-        @objectives_stage.outgoing(turn, result) unless canceled || result.exhausted?
+        @objectives_stage.outgoing(turn, result, recorder: system_one_recorder) unless canceled || result.exhausted?
         display = AnswerDisplay.new(session.messages)
         refs = AnswerRefs.new(session.messages, cwd: session.working_directory)
         after_turn = { type: :after_turn, status: canceled ? "canceled" : "completed",

data/lib/samagotchi/engine/turn_helpers.rb

@@ -7,7 +7,7 @@ module Samagotchi
     # with, the used memories it publishes, and the turn-end warm-up of the
     # next one (TurnStages::Warmup, built here). Writes @next_turn_waiting;
     # reads @model_settings, @kernel, @prompt_warmup, @thinking_notices,
-    # @turn_state, @turn_warmup.
+    # @turn_state, @reminder_queue, @turn_warmup.
     module TurnHelpersPart
       # The turn's settings for the kernel (LLM::TurnSettings): vision,
       # sampling and thinking, the thinking resolved before the hooks run.
@@ -40,13 +40,13 @@ module Samagotchi
       private :turn_warmup
 
       # The stage over the kernel and the Engine's PromptWarmup (built in
-      # #initialize, once the kernel is).
+      # #initialize, once the kernel and the reminder queue are). Its one
+      # callable is the system prompt, built late (side effects); the
+      # host's probe goes with each call (#next_turn_waiting, set after).
       def build_turn_warmup
-        TurnStages::Warmup.new(
-          prompt_warmup: @prompt_warmup, kernel: @kernel, turn_state: @turn_state, model_settings: @model_settings,
-          model: -> { effective_model }, system_prompt: ->(model) { system_prompt(model) },
-          reminders_due: -> { reminders_due? }, next_turn_waiting: -> { next_turn_waiting&.call }
-        )
+        TurnStages::Warmup.new(prompt_warmup: @prompt_warmup, kernel: @kernel, turn_state: @turn_state,
+                               model_settings: @model_settings, reminder_queue: @reminder_queue,
+                               system_prompt: ->(model) { system_prompt(model) })
       end
       private :build_turn_warmup
 

data/lib/samagotchi/engine/verify.rb

@@ -11,7 +11,7 @@ module Samagotchi
       # The anchors' stage (TurnStages::VerifyAnchors).
       attr_reader :verify_anchors
 
-      def build_verify_anchors = TurnStages::VerifyAnchors.new(state_dir: -> { session_state_dir })
+      def build_verify_anchors = TurnStages::VerifyAnchors.new
     end
   end
 end