samagotchi 0.153.0 → 0.154.0

data/lib/samagotchi/engine.rb

@@ -17,7 +17,7 @@ require_relative "turn_endings"
 require_relative "turn_origin"
 require_relative "revise_anchor"
 require_relative "verify_anchor"
-require_relative "web/participant_view"
+require_relative "redact"
 require_relative "verdict"
 require_relative "model_profile"
 require_relative "effective_model"
@@ -108,6 +108,26 @@ require_relative "prompt_warmup"
 require_relative "working_set"
 require_relative "participants_watch"
 require_relative "session_participants"
+require_relative "engine/steering"
+require_relative "engine/side_requests"
+require_relative "engine/recap"
+require_relative "engine/models"
+require_relative "engine/model_settings"
+require_relative "engine/events"
+require_relative "engine/cards"
+require_relative "engine/objectives"
+require_relative "engine/messages"
+require_relative "engine/plugins"
+require_relative "engine/hooks"
+require_relative "engine/guardrails"
+require_relative "engine/participants"
+require_relative "engine/session"
+require_relative "engine/verify"
+require_relative "engine/questions"
+require_relative "engine/toolkit"
+require_relative "engine/context_judge"
+require_relative "engine/turn_helpers"
+require_relative "engine/turn_end"
 
 module Samagotchi
   # Engine owns the core agent logic: system prompt construction, tool
@@ -115,7 +135,36 @@ module Samagotchi
   #
   # It exposes an event-based API (`on_event`) so that any UI can run
   # turns without coupling to terminal rendering.
+  #
+  # This file keeps the wiring (initialize, the build_* methods, the
+  # kernel) and the turn skeleton (run_turn, begin_turn, prepare_turn's
+  # ordered steps, generate, end_turn) and shutdown. The rest is in parts
+  # by concern: lib/samagotchi/engine/<concern>.rb holds module
+  # Engine::<Concern>Part (the Part suffix keeps a part's name off the
+  # Samagotchi constants Engine's code names bare: Toolkit, Objectives…),
+  # included here; they share Engine's ivars.
   class Engine
+    include SteeringPart
+    include SideRequestsPart
+    include RecapPart
+    include ModelsPart
+    include ModelSettingsPart
+    include EventsPart
+    include CardsPart
+    include ObjectivesPart
+    include MessagesPart
+    include PluginsPart
+    include HooksPart
+    include GuardrailsPart
+    include ParticipantsPart
+    include SessionPart
+    include VerifyPart
+    include QuestionsPart
+    include ToolkitPart
+    include ContextJudgePart
+    include TurnHelpersPart
+    include TurnEndPart
+
     # Raised by #answer_question when the question it targets is no longer
     # open (never asked, superseded, already answered or cancelled). A subclass
     # of ArgumentError for existing callers; transports map it to 409 Conflict.
@@ -182,7 +231,7 @@ module Samagotchi
       @host_registry = host_registry || HostRegistry.new
       # A model given here (a worker's session model) is the one it runs,
       # so its host is checked; the config default is only checked once it
-      # is used (the REPL checks the model it starts on, #switch_model!).
+      # is used (the one-shot checks the model it starts on, #switch_model!).
       @default_model_name = ModelProfile.required_model_name(model_name)
       ModelProfile.check_host!(model_name, hosts: @host_registry.entries) unless model_name.to_s.strip.empty?
       # The model choice and the profile resolved for it, under one mutex.
@@ -274,9 +323,8 @@ module Samagotchi
       end
       # The idle subsystems' (session recap + reminders) inactivity clock
       # starts now, after the plugins loaded. `record_activity` is the
-      # single seam every UI calls (run_turn itself, the REPL on keystrokes
-      # and after a reminder turn), so the idle layer's clock is identical
-      # across UIs.
+      # single seam every host calls (run_turn itself, the worker after a
+      # reminder turn), so the idle layer's clock is identical across hosts.
       @turn_state.restart_clock!
       @side_client_mutex = Mutex.new
       # Kept for a rebuild under a bound session's own recap values.
@@ -364,7 +412,7 @@ module Samagotchi
     # The persistent observers of every turn's events.
     def subscribe_session_observers
       # The metrics collector is a persistent observer so every run_turn event
-      # (the REPL, -p/--non-interactive/--resume and SessionManager workers)
+      # (a -p --non-interactive one-shot and SessionManager workers)
       # feeds it automatically.
       @session_observer.subscribe(observer: @metrics)
       # And the event trail in the debug log (`turn` records).
@@ -572,330 +620,11 @@ module Samagotchi
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    # The backend for the next turn: the loop the effective model's host speaks.
-    def backend(model = effective_model)
-      backend_for(model)
-    end
-
-    # Record that activity happened (user input or a completed turn): the
-    # idle jobs' seam (TurnState#record_activity). Each call advances both
-    # the last-activity timestamp and the activity sequence.
-    # @param now [Float, nil] injectable monotonic time (defaults to now)
-    def record_activity(now = nil)
-      @turn_state.record_activity(now)
-    end
-
-    # @return [Float] monotonic seconds of the last recorded activity
-    def last_activity_at
-      @turn_state.last_activity_at
-    end
-
-    # @return [Integer] monotonically-increasing activity counter (advanced by
-    #   #record_activity; lets the idle detector summarize once per idle window)
-    def activity_seq
-      @turn_state.activity_seq
-    end
-
-    # @return [Boolean] true while a turn is in flight (the idle jobs never
-    #   fire, nor render, while the model is generating)
-    def turn_running?
-      @turn_state.running?
-    end
-
-    # Put +text+ into the running turn, as a UI's steering does: it joins the
-    # conversation at the loop's next iteration boundary as its own user
-    # message (kind: "steer", source:). Callable from any thread; never
-    # blocks. With no turn running it does nothing (it never starts one).
-    # True means queued, not merged: at the after-answer boundary, and when
-    # the turn ends first, it is dropped (logged).
-    # @return [Boolean] whether it was queued
-    def steer(text, source:)
-      @turn_state.steer(text, source: source)
-    end
-
-    # A message for the running turn from +source+ cuts the generation
-    # streaming only thinking (SteerCut#cut_for_steer). Call it after the
-    # message is queued, with the #input_epoch read before queueing it.
-    # @return [Boolean] whether a generation was cut now
-    def cut_for_steer(source, epoch: nil) = @steer_cut.cut_for_steer(source, epoch: epoch)
-
-    # The drains that took input so far: read it before queueing a message
-    # for #cut_for_steer.
-    def input_epoch = @steer_cut.input_epoch
-
-    # The running generation's phase (SteerCut#generation_snapshot): what
-    # Bridge#snapshot puts in current_turn.generation.
-    def generation_snapshot = @steer_cut.generation_snapshot
-
-    # Like #steer, for the turn that begins next (a continue turn answered
-    # with a text): it joins that turn at its first boundary. Callable from
-    # any thread; a turn that never begins keeps it for the next one, unless
-    # #drop_carried_steers drops it.
-    # @return [Boolean] whether it was queued (false: blank)
-    def steer_next_turn(text, source:)
-      @turn_state.steer_next_turn(text, source: source)
-    end
-
-    # Drop the #steer_next_turn steers no turn began with (the continue turn
-    # failed before it began), logged; a no-op once a turn took them.
-    def drop_carried_steers
-      log_dropped_steers(@turn_state.drop_carried_steers, "not_begun")
-    end
-
-    # The drain a turn's loop gets: the caller's lines (a UI's steering; nil
-    # in a --non-interactive run) and the plugin steers. At the after-answer
-    # boundary the steers are dropped: the model answered, and a nudge would
-    # only restart the turn. The steer part fails on its own, never taking
-    # the user's lines with it. Items are a String (a user line), a
-    # Steer::Line (a worker's input line with its sender) or a steer Hash.
-    def turn_drain(pending_input)
-      lambda do |at_answer: false|
-        lines = pending_input ? Array(pending_input.call) : []
-        # The input went to the model: a message that waited to cut is in.
-        @steer_cut.delivered! unless lines.empty?
-        lines + take_steers(at_answer)
-      end
-    end
-    private :turn_drain
-
-    def take_steers(drop)
-      steers = @turn_state.take_steers
-      return steers unless drop
-
-      log_dropped_steers(steers, "answered")
-      []
-    rescue StandardError => e
-      Log.warn(:turn, "take_steers_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      []
-    end
-    private :take_steers
-
-    def log_dropped_steers(steers, why)
-      steers.each { |steer| Log.info(:turn, "steer_dropped", source: steer[:source], why: why, chars: steer[:text].length) }
-    end
-    private :log_dropped_steers
-
-    # @return [Array<String>] reminder names queued for a synthetic REPL turn
-    def due_reminder_names
-      @reminder_queue.pending_names
-    end
-
-    # Queue reminder names for a synthetic REPL turn (IdleReminders callback).
-    def note_due_reminders(names)
-      @reminder_queue.note_pending(names)
-    end
-
-    def clear_due_reminder_names!
-      @reminder_queue.clear_pending!
-    end
-
-    # @return [CancellationController, nil] active turn's cancellation controller
-    def active_cancel_controller
-      @turn_state.controller
-    end
-
-    # Whether a message a person sent waits for the running turn's next
-    # boundary (run_turn's input_waiting: probe): a task_wait or delegate wait
-    # returns on it, an execute hands its command over early
-    # (PeerView#input_waiting?). False outside a turn, for a turn given no
-    # probe, and when the probe raises (warned once a turn; the tool never
-    # fails for it).
-    def input_waiting?
-      probe = @turn_state.input_waiting
-      !!probe&.call
-    rescue StandardError => e
-      Log.warn(:turn, "input_waiting_failed", error: e.class.name, msg: e.message) if @turn_state.input_waiting_failed!
-      false
-    end
-
-    # Cancel the currently running turn, if any.
-    # @param reason [Symbol] cancellation reason
-    # @return [Boolean] whether a cancellation was triggered
-    def cancel_current_turn!(reason = :manual)
-      @turn_state.cancel!(reason)
-    end
-
-    # Snapshot the current session messages as a JSON string for the idle
-    # recap. The array is never mutated in place (a turn or a note replaces
-    # it), so the reference read here is a consistent snapshot; a dup'd
-    # copy is serialized. Never mutates session.messages.
-    # @return [String] JSON array of the messages
-    def messages_json_for_recap
-      snapshot = @session&.messages
-      return "[]" if snapshot.nil?
-
-      JSON.generate(AnswerDisplay.strip_all(snapshot).map(&:dup))
-    end
-
-    # Emit a :recap_ready event (additive slot) carrying the generated recap
-    # and the generation id an observer uses to reject an invalidated recap.
-    # +covered+ counts the session messages it summarizes; +created_at+ is
-    # the saved recap's (UTC ISO; the UIs show its local time).
-    def emit_recap(recap:, generation:, covered: nil, created_at: nil)
-      event = { type: :recap_ready, recap: recap, generation: generation, covered: covered }
-      event[:created_at] = created_at if created_at
-      @session_observer.notify(event)
-    end
-
-    # 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.
-    # Folded and announced as :side_usage under the event lock, so the side
-    # blocks reach the UIs in fold order (the lock order event lock →
-    # metrics mutex is the existing one); then, between turns, saved to
-    # analytics.json (a running turn's end or checkpoint saves it), unless
-    # the session is gone (no session file: a late recap thread must not
-    # recreate a deleted session's folder; the folder itself may not exist
-    # yet before a first turn). Safe from any thread: the recap's, a
-    # plugin's, the turn's.
-    # A side request counts against the participant who caused it
-    # (#side_author), its usage's own author when it names one.
-    # @param usage [SideUsage]
-    # @return [void]
-    def note_side_usage(usage)
-      usage = usage.with(author: side_author(usage.kind)) if usage.author.nil?
-      synchronize_events do
-        block = @metrics.add_side(usage)
-        @session_observer.notify(type: :side_usage, kind: usage.kind, side: block)
-      end
-      sid = @metrics.session_id
-      return if sid.nil? || turn_running?
-      return unless File.exist?(Session.session_file(sid, state_dir: session_state_dir))
-
-      @metrics.persist(state_dir: session_state_dir)
-    end
-
-    # Who caused a side request of +kind+ now: the running turn's author (a
-    # plugin's ctx.ask_model in it), the last turn's for the idle recap
-    # (it recaps that turn); nil, the owner's, for anything else (an owner
-    # command's ask_model between turns).
-    # @return [String, nil]
-    def side_author(kind)
-      # Check this is only ever the owner's, whichever turn runs as it ends.
-      return nil if kind.to_s == ObjectivesCheck::SOURCE
-      return nil unless turn_running? || kind.to_s == RECAP_SIDE_KIND
-
-      @guardrail_wiring.turn_author
-    end
-
     RECAP_SIDE_KIND = "recap"
 
-    # The running turn's author when a participant wrote it, else nil
-    # (ctx.turn_author, the hooks' author).
-    # @return [String, nil]
-    def turn_author = turn_running? ? @guardrail_wiring.turn_author : nil
-
     # @return [SessionMetrics] the per-session analytics collector
     attr_reader :metrics
 
-    # The model as given (maybe an alias; HostRegistry#resolve applies it).
-    def effective_model_name = @model_binding.choice.name
-
-    # The model as typed at start or at the last /model.
-    def typed_model_name = @model_binding.choice.typed
-
-    # The resolved ref a session stores for the effective model (ModelRef#ref:
-    # the alias applied, "host:id" when it names a host).
-    def effective_model_ref
-      model_ref_for(effective_model_name)
-    end
-
-    # The effective model as the system prompt names it (SystemPrompt::ModelIdentity):
-    # the ref, its host, the overlay key and, for a local llama.cpp host
-    # only, the model its /props names when that differs. Never a new
-    # request: only the /props answer profile resolution already cached.
-    def model_identity
-      model = effective_model
-      entry = model.entry
-      host = entry && "host #{entry.name}, #{entry.url || "#{entry.host}:#{entry.port}"}"
-      SystemPrompt::ModelIdentity.new(ref: model.ref, host: host, key: @model_binding.model_key,
-                                      served: model.prompt_served, fallback_key: @model_binding.fallback_model_key)
-    end
-
-    # The model notes for the effective model (ModelNotes): matched on its
-    # bare id and key, the session's mutes left out.
-    # @return [Array<ModelNotes::Note>]
-    def model_notes
-      ModelNotes.for(name: guardrail_model_name, key: @model_binding.model_key, fallback_key: @model_binding.fallback_model_key,
-                     muted: @muted_memory_names)
-    end
-
-    # The model notes the session's prompt carried at its last build
-    # (Session#prompt_notes): a resumed session's or a woken worker's saved
-    # ones until this process builds its prompt; a fresh session (no build
-    # yet, no messages) has none saved, so the effective model's prompt
-    # would load them: the notes #model_notes names, as without a session.
-    # The three readers (/model, /stats, the web) share this.
-    # @return [Array<PromptNote>]
-    def prompt_notes
-      return model_notes.map { |note| PromptNote.from_note(note) } unless @session
-
-      saved = @session.prompt_notes
-      return saved.dup if !@prompt_builder.prompt_notes.nil? || !saved.empty? || @session.messages.to_a.any?
-
-      model_notes.map { |note| PromptNote.from_note(note) }
-    rescue StandardError => e
-      Log.warn(:model, "prompt_notes_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      []
-    end
-
-    # Records +notes+ (ModelNotes::Note) on the session as the ones its
-    # prompt carries; saved with it.
-    def record_prompt_notes(notes)
-      @session.prompt_notes = Array(notes).map { |note| PromptNote.from_note(note) } if @session && notes
-    end
-    private :record_prompt_notes
-
-    # A failed turn's one line (the error's #summary). A host's failure
-    # under an alias says what the alias became (HostRegistry#alias_note):
-    # "host main" alone doesn't tell --model splash's user it was splash.
-    # @return [String]
-    def failure_summary(error)
-      summary = error.respond_to?(:summary) ? error.summary : error.message
-      return summary unless error.is_a?(LLM::ProviderError) && error.host
-
-      note = @host_registry.alias_note(effective_model_name)
-      note && note.end_with?("on host #{error.host}") ? "#{summary} (#{note})" : summary
-    rescue StandardError => e
-      EffectiveModel::Unresolved.fallback(:alias_note_failed, effective_model_name, e, summary)
-    end
-
-    # +name+'s resolved ref (ModelRef#ref).
-    def model_ref_for(name)
-      @host_registry.model_ref(name).ref
-    end
-
-    # The ref #switch_model! would switch +model_name+ to, checked the way it
-    # checks one (UnknownHost, MissingModel), without switching.
-    # @return [String]
-    def model_switch_ref(model_name)
-      model_ref_for(ModelProfile.check_host!(ModelProfile.required_model_name(model_name), hosts: @host_registry.entries))
-    end
-
-    # Writes the effective model to +session+: the resolved ref, and the
-    # name as typed when that differs (model_typed: an alias, for the
-    # models: lookup after a resume).
-    def store_model!(session)
-      ref = effective_model_ref
-      session.model_name = ref
-      typed = typed_model_name
-      session.model_typed = typed.to_s == ref ? nil : typed
-      session
-    end
-
-    # The effective model's key (ModelOverlay.key_for its bare name): memory
-    # overlays, guardrail rules' models:.
-    # @return [String, nil]
-    def model_key = @model_binding.model_key
-
-    # The prompt profile for the effective model (see #profile_resolution).
-    # @return [ModelProfile]
-    def profile = profile_resolution.profile
-
-    # Which profile the effective model gets and where that came from,
-    # kept with the model choice it was resolved for
-    # (ModelBinding#profile_resolution).
-    # @return [ModelProfile::Resolution]
-    def profile_resolution = @model_binding.profile_resolution
     attr_reader :default_model_name, :host_registry, :client
 
     # @return [Commands::Registry] the commands this session runs: the
@@ -905,55 +634,6 @@ module Samagotchi
     # @return [PeerSources] the sources the peer bundles declared
     attr_reader :peer_sources
 
-    # The model id sent for +full_ref+ (its alias applied, the host prefix off).
-    def bare_model_name(full_ref)
-      @host_registry.bare_name(full_ref)
-    end
-
-    # The memory overlay keys follow the model sent (ModelBinding#sync_model_key!).
-    def sync_model_key! = @model_binding.sync_model_key!
-    private :sync_model_key!
-
-    # The effective model's bare name for the guardrails' models: rules;
-    # nil without a model name.
-    def guardrail_model_name
-      model = effective_model_name
-      name = model && bare_model_name(model)
-      name.to_s.strip.empty? ? nil : name
-    end
-
-    # Point the kernel (and a chat backend) at the effective model's host
-    # (after /model, --model, resume).
-    def sync_kernel_client!(model = effective_model)
-      @client = model.client
-      @kernel.client = model.client if @kernel.client != model.client
-      backend_for(model)
-    end
-
-    # Subscribe a persistent observer to engine events.
-    #
-    # Unlike the turn-scoped `on_event:` sink, a subscribed observer keeps
-    # receiving events across every `run_turn` call on this Engine. Each
-    # delivery carries a locally-monotonic `event_seq`. The returned handle can
-    # be used to unsubscribe later.
-    # @param observer [#call] receives event hashes (with `event_seq:` merged in)
-    # @return [Samagotchi::SessionObserver::SubscribedObserver] handle to unsubscribe
-    def subscribe(observer:)
-      @session_observer.subscribe(observer: observer)
-    end
-
-    # Unsubscribe a previously-registered observer.
-    # @param handle [Samagotchi::SessionObserver::SubscribedObserver]
-    # @return [Boolean] whether the observer was removed (nil/unknown never raises)
-    def unsubscribe(handle:)
-      @session_observer.unsubscribe(handle: handle)
-    end
-
-    # @return [Integer] total engine events emitted so far (locally monotonic)
-    def event_count
-      @session_observer.event_count
-    end
-
     # Event types #announce accepts: facts about the session's input queue,
     # a failed turn's prompt handed back and the continue offer, which live
     # UIs need in the event log, emitted outside any turn's stream; a
@@ -963,217 +643,6 @@ module Samagotchi
                              plugin_init_started plugin_init_finished working_set_updated participants_changed
                              verdict_recorded objectives_updated].freeze
 
-    # Put a transport-level event into the ordered event log. Unlike turn
-    # events it reaches only persistent observers (no turn sink, no memory
-    # capture).
-    # @param event [Hash] with :type in ANNOUNCEABLE_EVENTS
-    # @raise [ArgumentError] for any other type
-    def announce(event)
-      unless ANNOUNCEABLE_EVENTS.include?(event[:type])
-        raise ArgumentError, "cannot announce #{event[:type].inspect} (allowed: #{ANNOUNCEABLE_EVENTS.join(", ")})"
-      end
-
-      @session_observer.notify(event)
-    end
-
-    # Run the block with the event log held: no event is numbered or
-    # delivered meanwhile, and events the block emits keep their order.
-    def synchronize_events(&)
-      @session_observer.synchronize(&)
-    end
-
-    # The working set's :working_set_updated, announced between turns
-    # (after a command changed what the next request sends), when it
-    # differs from the last one emitted (#emit_working_set). Under the
-    # event lock, so it is ordered with the change's own events.
-    def announce_working_set(session = @session)
-      return unless session
-
-      synchronize_events { emit_working_set(nil, session, session.messages) }
-    end
-
-    # The session's objectives as the page draws them (Objectives.view), when
-    # that differs from the last announced: after an edit (its file written,
-    # pending), once a list note is in, at a turn's end (its moves) and after
-    # a rollback. A session with no list announces nothing. It only informs:
-    # a failure is logged, never the turn's.
-    def announce_objectives(session = @session)
-      return unless session
-
-      synchronize_events do
-        view = Objectives.view(session.id, session.messages, state_dir: session_state_dir, running: live_conversation&.dup)
-        next if view.nil? || view == @objectives_announced
-
-        @objectives_announced = view
-        announce({ type: :objectives_updated, session_id: session.id, **view })
-      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.
-    # @param request [Array<Hash>] chat messages
-    # @param model [String, nil] a configured model; nil: the session's
-    # @return [String] the answer
-    def ask_objective_check(request, model:)
-      ask_side_model(request, timeout: ObjectivesCheck::TIMEOUT_SECONDS, max_tokens: ObjectivesCheck::MAX_TOKENS,
-                              cancel_controller: nil, model: model, source: ObjectivesCheck::SOURCE)
-    end
-
-    # A change the model proposes (the objectives tool), kept until the turn
-    # is over, as #context_choice's cards are: a card shown then is a quiet one, between turns, with its Apply kept
-    # over a restart (CardStore), not a running turn's that says it waits on the
-    # user. The same change twice in a turn is one card.
-    # @return [Boolean] false past Objectives::PROPOSALS_PER_TURN
-    def propose_objective(proposal)
-      @objective_proposals_mutex.synchronize do
-        next true if @objective_proposals.any? { |p| p.line == proposal.line }
-        next false if @objective_proposals.size >= Objectives::PROPOSALS_PER_TURN
-
-        @objective_proposals << proposal
-        true
-      end
-    end
-
-    def show_objective_proposals
-      drain_objective_proposals.each do |proposal|
-        id = "objectives-#{SecureRandom.hex(4)}"
-        show_card(source: Objectives::SOURCE, id: id, title: proposal.title, body: proposal.body,
-                  actions: [{ label: "Apply", command: proposal.action_line(id) },
-                            { label: "Dismiss", command: "/objectives --card #{id} dismiss" }])
-      end
-    rescue StandardError => e
-      Log.warn(:turn, "objectives_proposal_failed", error: e.class.name, msg: e.message)
-    end
-    private :show_objective_proposals
-
-    # A turn that did not complete (canceled, failed) takes its proposals
-    # off the buffer without showing them: their Apply card would sit after a
-    # turn whose `objectives propose` call is not in the history (a rollback
-    # after Ctrl-C drops it), and leaving them in the buffer would show them
-    # at the end of the next turn.
-    def discard_objective_proposals(turn)
-      dropped = drain_objective_proposals
-      Log.info(:turn, "objectives_proposals_dropped", count: dropped.size, outcome: turn.outcome.to_s) unless dropped.empty?
-    end
-    private :discard_objective_proposals
-
-    def drain_objective_proposals
-      @objective_proposals_mutex.synchronize { @objective_proposals.slice!(0..) }
-    end
-    private :drain_objective_proposals
-
-    # The strategy the working set is built under now, as LLMContextView
-    # takes it: the running turn's, else the next turn's (#emit_working_set).
-    # /working-set's ops act under it.
-    # @return [Symbol, Array<Symbol>]
-    def working_set_strategy
-      working_set_llm_context&.strategy || LLMContextView::NONE
-    end
-
-    # Replace the current session's conversation, between turns (a
-    # /working-set op's copy: #clone_messages, then its edits).
-    # @param messages [Array<Hash>]
-    # @return [Array<Hash>] the session's messages
-    def replace_messages(messages)
-      raise ArgumentError, "no current session" unless @session
-
-      replace_session_messages(@session, messages)
-    end
-
-    # Add a context note to the session's conversation, between turns: a
-    # tail system message the next turn sees, announced as :context_added.
-    # The array is replaced, not mutated, and the append and the event
-    # happen under the event lock, so a joining UI sees both or neither.
-    # The caller saves the session.
-    # @param note [Hash] SessionInbox.read_note's shape
-    # @return [Hash, nil] the message, or nil when the conversation already
-    #   holds this note (a note file re-read after a crash)
-    def add_context_note(session, note)
-      synchronize_events do
-        next nil if Array(session.messages).any? { |m| m[:note_id] == note[:note_id] }
-
-        message = ContextNote.message(**note)
-        entry = note[:objectives] && Objectives.entry(note[:objectives], before: Objectives.build(session.messages))
-        replace_session_messages(session, Array(session.messages) + [message])
-        announce({ type: :context_added, session_id: session.id, note_id: note[:note_id], source: note[:source],
-                   label: ContextNote.label_of(message), from_session: note[:from_session],
-                   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_audit.note(session, note)
-        message
-      end
-    end
-
-    # ── Cards ───────────────────────────────────────────────────────────────
-
-    # Show a card in every UI (docs/plugins.md, Cards): {type: :card, id:,
-    # source:, title:, body:, level:, actions: [{label:, command:}], in_turn:}.
-    # Where it goes (held while the plugins load, an anytime command's, an
-    # init task's, a turn event, else announced) is EventRoutes#route's,
-    # marked in_turn: (CARD_MARKS). A card with the id of an earlier one
-    # replaces it (btw's "thinking…" → the answer).
-    # @param source [String] who shows it (a bundle's name)
-    # @param actions [Array<Hash>] {label:, command:}; a command is a line
-    #   the session runs, as typed (D3)
-    # @return [String] the card's id
-    # @raise [ArgumentError] a card without a title, or a bad action
-    def show_card(source:, title:, body: "", actions: [], level: :info, id: nil)
-      card = Plugin::Card.build(source: source, title: title, body: body, actions: actions, level: level, id: id)
-      command = Thread.current[running_command_key]
-      card[:command] = command if command
-      @event_routes.route(card, **EventRoutes::CARD_MARKS)
-      card[:id]
-    end
-
-    # Run an anytime command's block (D8): the cards and notices it shows on
-    # this thread are announced at once, marked anytime: true, and are
-    # never a running turn's events. They belong to the command, not the
-    # turn, and a UI shows them after the command's own line (a web
-    # command bubble drawn at its command_queued), even mid-turn.
-    # @return the block's value
-    def running_anytime
-      key = :"samagotchi_anytime_#{object_id}"
-      outer = Thread.current[key]
-      Thread.current[key] = true
-      yield
-    ensure
-      Thread.current[key] = outer
-    end
-
-    # Run a session command's dispatch: a card shown on this thread says
-    # it's that command's (:card's command:), for a reload that no longer has
-    # the command's line above it (Bridge::CardStore). A thread of its own
-    # isn't the command, nor a card shown after it.
-    # @param name [String] the command, "/short"
-    # @return the block's value
-    def running_command(name)
-      outer = Thread.current[running_command_key]
-      Thread.current[running_command_key] = name
-      yield
-    ensure
-      Thread.current[running_command_key] = outer
-    end
-
-    # Whether an anytime command (/btw) still runs on its thread.
-    def anytime_running?
-      @lifecycle_mutex.synchronize { @anytime_threads.any?(&:alive?) }
-    end
-
-    # Start an anytime command on its own thread (D8), one #shutdown waits
-    # for, so its command_ran is announced before the process leaves.
-    # @return [Thread]
-    def spawn_anytime(&)
-      thread = Thread.new(&)
-      @lifecycle_mutex.synchronize do
-        @anytime_threads.select!(&:alive?)
-        @anytime_threads << thread
-      end
-      thread
-    end
-
     # ── Plugin init tasks (chi.init) ──────────────────────────────────────
 
     # A plugin's slow setup (docs/plugins.md, Init tasks): PluginTasks.
@@ -1181,63 +650,6 @@ module Samagotchi
     INIT_TASK_TIMEOUT = PluginTasks::INIT_TASK_TIMEOUT
     INIT_WAIT_POLL = PluginTasks::INIT_WAIT_POLL
 
-    # Add a plugin's init task (Plugin::Api#init at commit); it starts with
-    # #start_init_tasks!.
-    def add_init_task(bundle:, label:, plugin_label:, provides_tools:, quiet:, timeout:, failed: nil, &)
-      @plugin_tasks.add(bundle: bundle, label: label, plugin_label: plugin_label, provides_tools: provides_tools,
-                        quiet: quiet, timeout: timeout, failed: failed, &)
-    end
-
-    # Start the init tasks not started yet, each on its own thread
-    # (PluginTasks#start!).
-    def start_init_tasks!
-      @plugin_tasks.start!
-    end
-
-    # The running init tasks a UI shows (not the quiet ones), for a UI that
-    # joins while they run (Bridge#snapshot, with the event log held).
-    # @return [Array<Hash>] {bundle:, id:, label:}
-    def init_tasks
-      @plugin_tasks.running
-    end
-
-    # Wait for the running init tasks that provide tools (PluginTasks#await).
-    # @return [Boolean] whether it waited
-    def await_init_tasks(controller = nil, on_event = nil)
-      @plugin_tasks.await(controller, on_event)
-    end
-
-    # The init task this thread runs, or nil.
-    def current_init_task = @plugin_tasks.current
-    private :current_init_task
-
-    # ── Load events ───────────────────────────────────────────────────────
-
-    # Announce what failed to load and what plugins showed while loading,
-    # once, as soon as the owner can show it (the worker's Bridge is up, the
-    # REPL renders events): the guardrail and plugin warnings, an orphaned
-    # project memory folder (label: "memory", MemoryOrphans), then the
-    # held notices (between_turns) and cards (in_turn: false, so late
-    # joiners get them). Without this call the first turn announces them
-    # (#announce_guardrail_failures).
-    def announce_load_events!
-      synchronize_events do
-        next if @guardrail_failures_announced
-
-        @guardrail_failures_announced = true
-        message = @guardrail_failures.message
-        announce({ type: :guardrail_warning, message: message }) if message
-        plugins = @plugin_failures.message
-        announce({ type: :guardrail_warning, message: plugins, label: "plugins" }) if plugins
-        memory = MemoryOrphans.message
-        announce({ type: :guardrail_warning, message: memory, label: "memory" }) if memory
-        @extension_load.held_events.each do |event|
-          announce(event[:type] == :card ? event.merge(in_turn: false) : event.merge(between_turns: true))
-        end
-      end
-      nil
-    end
-
     # How long #shutdown waits for the running anytime commands, in all.
     SHUTDOWN_JOIN_SECONDS = 3.0
     # How long #shutdown waits for the running side judgments (System 1
@@ -1245,8 +657,8 @@ module Samagotchi
     # after its turn), in all; a slower ask goes unlogged.
     SIDE_JUDGMENTS_JOIN_SECONDS = 1.0
 
-    # The REPL or the session's worker is leaving (/exit, an idle exit, a
-    # crash, TERM): stop the idle jobs, give the running anytime commands
+    # The session's worker (or a one-shot run) is leaving (/exit, an idle
+    # exit, a crash, TERM): stop the idle jobs, give the running anytime commands
     # up to +join_timeout+ seconds to finish (their command_ran is
     # announced), then stop the plugins' services, newest first. Once;
     # later calls do nothing.
@@ -1279,474 +691,9 @@ module Samagotchi
       self
     end
 
-    def anytime_thread? = Thread.current[:"samagotchi_anytime_#{object_id}"] == true
-    private :anytime_thread?
-
-    def announce_anytime(event)
-      event = event.merge(anytime: true)
-      announce(event)
-      event
-    end
-    private :announce_anytime
-
-    # Run the block holding back the cards and between-turns notices it
-    # announces on this thread, so the caller announces them after its own
-    # event (a worker's command: its command_ran first, as the REPL prints
-    # the command's output before its cards).
-    # @return [Array(Object, Array<Hash>)] the block's value and the held events
-    def holding_announcements
-      key = :"samagotchi_held_#{object_id}"
-      outer = Thread.current[key]
-      Thread.current[key] = []
-      value = yield
-      [value, Thread.current[key]]
-    ensure
-      Thread.current[key] = outer
-    end
-
-    # Announce +event+ now, or keep it for #holding_announcements' caller.
-    def announce_or_hold(event)
-      held = Thread.current[:"samagotchi_held_#{object_id}"]
-      held ? held << event : announce(event)
-    end
-    private :announce_or_hold
-
-    # ── Model switching ────────────────────────────────────────────────────────
-
-    # @param typed [String, nil] the name the model was typed as when
-    #   +model_name+ is a stored ref (a resumed session's model_typed)
-    # @return [String] the resolved ref the session stores (ModelRef#ref)
-    def switch_model!(model_name, persist_default: false, typed: nil)
-      # The alias is applied where the model is resolved (HostRegistry#resolve),
-      # once; checked here: an unknown host, an alias naming another host.
-      resolved = ModelProfile.check_host!(ModelProfile.required_model_name(model_name), hosts: @host_registry.entries)
-      choice = ModelChoice.new(name: resolved, typed: typed.to_s.strip.empty? ? model_name : typed.to_s.strip)
-      @model_binding.switch!(choice)
-      sync_model_key!
-      @prompt_builder.reset!
-      # The notes the new model's prompt loads at its next build, so /model,
-      # /stats and the web name them before the next turn does.
-      record_prompt_notes(model_notes) if @session
-      sync_kernel_client!
-      @client.invalidate_context_window!
-      @metrics.forget_model_reports!
-      # The last turn's ctx % was the old model's window's
-      # (#announce_switched_context! sends the new one's).
-      @last_context_status = nil
-      ref = effective_model_ref
-      if persist_default
-        ConfigFile.write_default_model!(ref)
-        @default_model_name = ref
-      end
-      ref
-    end
-
-    # After /model: how full the context is on the new model's window,
-    # before its first turn: the last turn's count (the old model's
-    # tokenizer's, replaced at the next generation) against the new model's
-    # window (EffectiveModel#context_window, ContextWindow.resolve: the
-    # running server first, one /props GET that a remote chat host is
-    # spared; else the host's cached model list; else the configured
-    # window) and the
-    # session's budget. Sent as a :context_status event (the web's ctx
-    # meter, the attached TUI's status row) with context_window_tokens, and
-    # kept for a client that joins later (#session_state_snapshot; the
-    # window in the metrics' context too, which a page counts from). A window
-    # that can't be resolved sends usage nil: the UIs clear the % until the
-    # next generation. Nothing before the session's first counted turn.
-    # +configured_only+: the configured window only, never asking a server
-    # (EffectiveModel#configured_context_window): a loaded session's (#session=).
-    # @return [Hash, nil] the event sent
-    def announce_switched_context!(configured_only: false)
-      used = @metrics.snapshot.dig(:context, :used_tokens)
-      return nil unless used.is_a?(Integer)
-
-      model = effective_model
-      window = configured_only ? model.configured_context_window : current_context_window(model)
-      display = window && saved_context_status({ used_tokens: used, window_tokens: window.tokens })
-      @last_context_status = display&.dup
-      @metrics.note_context_window(window.tokens, window.source) if window
-      usage = display && { estimated_pct: display[:est_pct], estimated_used_tokens: used, window_tokens: window.tokens,
-                           window_source: window.source.to_s, source: "switch" }
-      event = { type: :context_status, usage: usage, bucket: display&.dig(:bucket),
-                context_window_tokens: window&.tokens, context_window_source: window&.source&.to_s }
-      @session_observer.notify(event)
-      event
-    rescue StandardError => e
-      Log.warn(:model, "switched_context_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      nil
-    end
-
-    # ── Hooks API ──────────────────────────────────────────────────────────────
-
-    # Register a hook callback for a named lifecycle event.
-    #
-    # Hooks are turn-scoped: they are automatically cleared after each
-    # `run_turn` call so that a single turn's hooks do not leak into the next.
-    #
-    # A hook that raises tells the user once, as a bundle's does
-    # (HookRoutes#plugin_hook_failed); the registry logs each failure and goes on.
-    #
-    # @param name [Symbol] one of the hook names (see Hooks module)
-    # @param block [Proc] receives an event hash (may mutate in place)
-    # @return [void]
-    def register_hook(name, &block)
-      return @hooks.register(name) unless block
-
-      @hooks.register(name) do |event|
-        yield(event)
-      rescue StandardError => e
-        @hook_routes.plugin_hook_failed("#{Hooks::Registry::TURN_HOOK_LABEL} (#{name})", "#{e.class}: #{e.message}")
-        raise
-      end
-    end
-
-    # Unregister a previously registered hook.
-    # @param name [Symbol]
-    # @return [Boolean] true if it was removed, false if not found
-    def unregister_hook(name)
-      @hooks.unregister(name)
-    end
-
-    # Clear all registered hooks. Called automatically at the end of each
-    # `run_turn` to keep hooks turn-scoped.
-    # @return [void]
-    def clear_hooks
-      @hooks.clear_all
-    end
-
-    # ── Reminders API ────────────────────────────────────────────────────────────
-    #
-    # Each turn injects the reminders due then (#turn_messages,
-    # ReminderQueue#inject!). Between turns the idle tick (IdleReminders)
-    # finds them due and its callback queues their names
-    # (#note_due_reminders); the worker and the REPL run a reminder turn
-    # (a continue turn) for them.
-
-    # @return [Boolean] whether any reminder is due now (the store's view,
-    #   which a turn would inject), regardless of the queued names
-    def reminders_due?
-      @reminder_queue.due?
-    end
-
-    # @return [ReminderStore] the reminder store for inspection
-    attr_reader :reminder_store
-
-    # The metrics for /stats, which may make one short /props GET
-    # (EngineSnapshots#stats_snapshot).
-    # @return [Hash] @metrics.snapshot, filled in
-    def stats_snapshot = @engine_snapshots.stats_snapshot
-
-    # ── The session's model settings (SessionModelSettings) ──────────────────
-
-    # The session's own thinking, reasoning_history and llm_context values
-    # over the effective model's, the summaries /model and /stats show, and
-    # the saved context's status: SessionModelSettings' (resolved on every
-    # read); these forward.
-    def saved_context_status(context, model: :current) = @model_settings.saved_context_status(context, model: model)
-    def llm_context_explained(own: :session) = @model_settings.llm_context_explained(own: own)
-    def llm_context_summary = @model_settings.llm_context_summary
-    def llm_context_override = @model_settings.llm_context_override
-    def chat_model? = @model_settings.chat_model?
-    def sampling_summary = @model_settings.sampling_summary
-    def thinking_summary = @model_settings.thinking_summary
-    def steer_cut_after_explained = @model_settings.steer_cut_after_explained
-    def steer_cut_after = @model_settings.steer_cut_after
-    def steer_cut_summary = @model_settings.steer_cut_summary
-    def thinking_explained(own: thinking_override) = @model_settings.thinking_explained(own: own)
-    def reasoning_history_summary = @model_settings.reasoning_history_summary
-    def reasoning_history_cache_cost(from, to) = @model_settings.reasoning_history_cache_cost(from, to)
-    def reasoning_history_override = @model_settings.reasoning_history_override
-    def thinking_override = @model_settings.thinking_override
-    def served_expected_by(served) = @model_settings.served_expected_by(served)
-    def served_expected?(served) = @model_settings.served_expected?(served)
-
-    def reasoning_history_explained(native: false, own: reasoning_history_override)
-      @model_settings.reasoning_history_explained(native: native, own: own)
-    end
-
-    # Set the session's own reasoning_history or thinking level (nil unsets
-    # it): SessionModelSettings'. The caller saves the session.
-    # @raise [ArgumentError] with no session yet
-    def reasoning_history_override=(level)
-      @model_settings.reasoning_history_override = level
-    end
-
-    def thinking_override=(level)
-      @model_settings.thinking_override = level
-    end
-
-    # Set the session's own llm_context values (an empty override unsets
-    # them); the next turn's start resolves them, never a running one (its
-    # TurnSettings are fixed). The caller saves the session.
-    # @raise [ArgumentError] with no session yet
-    def llm_context_override=(override)
-      raise ArgumentError, "no session yet" unless @session
-
-      SessionSetting::LLM_CONTEXT.set(@session, override)
-      # The status a later client reads counts against the new budget.
-      @last_context_status = saved_context_status(@metrics.snapshot[:context]) || @last_context_status if @last_context_status
-    end
-
-    # Whether the session has a model reply (a cache to restart at all).
-    def history?
-      Array(@session&.messages).any? { |entry| entry[:role].to_s == "model" }
-    end
-
-    # The latest known context size used by a request, for a cache-restart
-    # confirmation; nil before any request reports a count.
-    # @return [Integer, nil]
-    def cache_restart_tokens
-      used = @metrics.snapshot.dig(:context, :used_tokens)
-      used if used.is_a?(Integer)
-    end
-
-    # Whether a cache restart can invalidate preserved thinking blocks.
-    def cache_restart_anthropic?
-      effective_model.entry&.api.to_s == "anthropic"
-    end
-
-    # What a thinking level change costs the effective model's prompt
-    # cache (Thinking.cache_cost): :full, :provider or :tail.
-    # @return [Symbol]
-    def thinking_cache_cost
-      effective_model.thinking_cache_cost { profile }
-    end
-
-    # The model the server serves for the current model, and the name asked
-    # for: what the last generation of that name reported, else llama.cpp's
-    # model_alias (/props, one short cached probe; not with probe: false),
-    # else [nil, nil].
-    # @return [Array(String, String), Array(nil, nil)]
-    def served_model(probe: true)
-      @engine_snapshots.served_model_for(@metrics.served_report, model: probe ? effective_model : nil)
-    end
-
-    # Read-only snapshot of the engine's view of the current session plus the
-    # live event sequence; cheap, never probes, never raises
-    # (EngineSnapshots#session_state_snapshot has its keys).
-    # @return [Hash]
-    def session_state_snapshot = @engine_snapshots.session_state_snapshot
-
-    # @return [Array<String>] deduped used memory names (thread-safe copy)
-    def used_memory_names
-      @used_memories.names
-    end
-
-    # @return [Array<String>] the memories hidden from this session (normalized names)
-    def muted_memory_names
-      @muted_memory_names.dup
-    end
-
-    # @return [Array<String>] the names the session preloads (config baseline
-    #   + --memory, minus mutes), known before the prompt is built, unlike
-    #   #activated_memory_names
-    def preloaded_memory_names
-      @prompt_builder.preloaded_memory_names
-    end
-
-    # ── Guardrails ─────────────────────────────────────────────────────────────
-
-    # Who can answer an approval: :repl, :worker or :non_interactive (the
-    # default, so a bare Engine denies instead of waiting for nobody). Set
-    # by the host (TerminalUI, Worker).
-    def interface
-      @guardrail_wiring.interface
-    end
-
-    def interface=(value)
-      @guardrail_wiring.interface = value
-    end
-
-    # Where the approval store lives: beside Session's state dir
-    # ($XDG_STATE_HOME/samagotchi/guardrails/). A Worker with its own state
-    # dir passes it.
-    # Where sessions live (a session's images/ are under it); a worker sets
-    # its own.
-    attr_writer :session_state_dir
-
-    # The metrics load the session's saved records from its state dir, once.
-    def bind_metrics(session)
-      return unless session&.id
-
-      @metrics.state_dir = session_state_dir
-      @metrics.session_id = session.id
-    end
-
-    def session_state_dir = @session_state_dir || Session.default_state_dir
-
-    # Whether a participant's pair turn must stop, read before each of its
-    # generations (#guard_participant_spend): author ("p:<id>") → why (their
-    # link ended, or they passed their cap), nil while it may go on. The
-    # Worker sets it (Worker#participant_turn_stop); without one (the REPL)
-    # nothing is checked mid-turn.
-    attr_writer :participant_stop
-
     # What a participant turn's stop is attributed to (HookRoutes#stop_turn).
     PARTICIPANTS_HOOK = "participants"
 
-    # Before each generation (KernelLoop#generation_guard): a pair turn whose
-    # participant's link ended, or whose spend (Engine#metrics: their
-    # finished turns, this one's finished generations, their side requests)
-    # passed their cap, stops on the plugins' stop path (cost-cap's,
-    # work-cap's), with its notice. A generation's own cost is known only
-    # once it ends, so a turn can pass the cap by its last generation. The
-    # turn-start check is the Worker's (Worker#participant_refusal); a
-    # review turn only reads, and keeps to it.
-    def guard_participant_spend
-      author = turn_author
-      return if author.nil? || @participant_stop.nil?
-      return unless @guardrail_wiring.turn_mode == ParticipantMode::PAIR
-
-      reason = @participant_stop.call(author) or return
-      hook_stop_turn(reason, PARTICIPANTS_HOOK)
-    end
-    private :guard_participant_spend
-
-    # The running turn's metrics so far, saved as a turn a worker died in
-    # would leave them (SessionMetrics#persist's running_turn): a worker's
-    # turn checkpoint (TurnCheckpoint) calls it when it writes.
-    # @return [Boolean] whether they were saved
-    def checkpoint_metrics = @metrics.persist(state_dir: session_state_dir, running_turn: true)
-
-    # What a Bridge adds to a plugin's ctx.messages while a turn runs (the
-    # turn so far, as messages); nil without a Bridge (the REPL).
-    attr_writer :running_turn_messages
-
-    def guardrail_state_dir=(state_dir)
-      # Also where list_sessions and send_note look for other sessions.
-      @state_dir = state_dir
-      @guardrail_wiring.state_dir = state_dir
-    end
-
-    # The YAML rules, read again when a file changed (GuardrailWiring#rules).
-    # @return [Guardrails::Rules]
-    def guardrail_rules
-      @guardrail_wiring.rules
-    end
-
-    # @return [Guardrails::LoadFailures]
-    attr_reader :guardrail_failures
-
-    # @return [Guardrails::Approvals]
-    def guardrail_approvals
-      @guardrail_wiring.approvals
-    end
-
-    # @return [Guardrails::LoadFailures] the plugins that failed to load
-    attr_reader :plugin_failures
-
-    # Once per Engine, on its first turn: what failed to load, so every UI
-    # (REPL, attached TUI, web) shows it: the guardrails, then the plugins
-    # (label: "plugins"; the UIs say guardrails without one), an orphaned
-    # project memory folder (label: "memory"), then the notices and cards plugins showed as they loaded.
-    def announce_guardrail_failures(on_event)
-      return if @guardrail_failures_announced
-
-      @guardrail_failures_announced = true
-      message = @guardrail_failures.message
-      emit_event(on_event, { type: :guardrail_warning, message: message }) if message
-      plugins = @plugin_failures.message
-      emit_event(on_event, { type: :guardrail_warning, message: plugins, label: "plugins" }) if plugins
-      memory = MemoryOrphans.message
-      emit_event(on_event, { type: :guardrail_warning, message: memory, label: "memory" }) if memory
-      @extension_load.held_events.each { |event| emit_event(on_event, event) }
-    end
-    private :announce_guardrail_failures
-
-    # The warning the first turn announced (nil before it, or with nothing
-    # failed), for a UI that joins later (Bridge#snapshot).
-    def guardrail_warning
-      @guardrail_failures.message if @guardrail_failures_announced
-    end
-
-    # The plugins' load warning the first turn announced, likewise, and what
-    # their failed chi.on handlers told (HookRoutes#plugin_hook_failed).
-    def plugin_warning
-      loaded = @plugin_failures.message if @guardrail_failures_announced
-      [loaded, @hook_routes.hook_failures_message].compact.join("; ").then { |text| text unless text.empty? }
-    end
-
-    # Ask the user to approve a call the gate voted `ask` on
-    # (GuardrailWiring#request_approval).
-    # @param verdict [Guardrails::Verdict]
-    # @return [Guardrails::Verdict]
-    def request_approval(verdict)
-      @guardrail_wiring.request_approval(verdict)
-    end
-
-    # The conversation as a hook may read it: a frozen array of copied
-    # messages, so a hook cannot change what the turn sends or stores.
-    def hook_messages(messages)
-      AnswerDisplay.strip_all(messages).map(&:dup).freeze
-    end
-    private :hook_messages
-
-    # How the turn ended, on the session (Session#last_turn): the caller's
-    # save puts it in the file the session hub watches. Public for the
-    # Worker's turn that failed before it began (no #end_turn ran).
-    # @param limit [Integer, nil] the turn ran out of iterations at this
-    #   limit: "exhausted" => true, "limit" => N, so a wait with nobody to
-    #   answer the continue offer says so (ReplyWait, ParentReport "limit")
-    # @param origin [TurnOrigin] the turn's (TurnOrigin::NONE for no sender)
-    # @param event [Hash] the turn's end event (#stop_facts)
-    def record_last_turn(session, outcome, seconds, origin, event, limit: nil)
-      enqueued_id = origin.enqueued_id
-      session.last_turn = LastTurn.new(outcome: outcome, ended_at: Time.now.iso8601(3), seconds: seconds.round(1),
-                                       origin: origin.source, exhausted: limit ? true : nil, limit: limit,
-                                       enqueued_id: enqueued_id.to_s.empty? ? nil : enqueued_id.to_s,
-                                       author: origin.participant_author,
-                                       **stop_facts(event))
-    end
-
-    # A participant joined (invited) or left (revoked, expired) since the
-    # last look: :participants_changed to the observers (ParticipantsWatch;
-    # the worker looks on its idle tick). The first look announces nobody.
-    # @return [ParticipantsWatch::Change, nil]
-    def announce_participants
-      change = @participants_watch.changes or return nil
-
-      announce(change.to_event)
-      change
-    end
-
-    # Reads the session's participants at a turn's start; the first to join,
-    # the first invited to act (a pair participant: the line's words) and
-    # the last to leave rebuild the system prompt (its participants line),
-    # once each: a turn in between sends the same prefix.
-    def refresh_participants!(session)
-      line = @participants.refresh!(session).prompt_mode(session)
-      return if line == @participants_line
-
-      @participants_line = line
-      @prompt_builder.reset!
-    end
-    private :refresh_participants!
-
-    # The author fields a message +author+ wrote carries (Steer.author_fields:
-    # author:, and author_name: from participants.json), {} for the owner.
-    # The worker's drain names a participant's merged lines with it, and
-    # its running save a participant's prompt.
-    # @param author [String, nil] a turn's or a line's author (TurnOrigin#author)
-    # @param session [Session, nil] the session it is for (the turn's)
-    def author_fields(author, session: @session)
-      return {} unless Steer.participant_author?(author)
-
-      Steer.author_fields(author, @participants.name_for(author, session: session))
-    end
-
-    # A participant's opening message keeps the rules it was delivered under
-    # (ParticipantMode), stamped before any request carries it, so its header
-    # never changes when the session's mode does.
-    def participant_mode_fields(author)
-      mode = Steer.participant_author?(author) && @guardrail_wiring.turn_mode
-      mode ? { participant_mode: mode.to_s } : {}
-    end
-
-    # Why a turn stopped (TurnEndings#stop_facts).
-    def stop_facts(event) = @turn_endings.stop_facts(event)
-    private :stop_facts
-
     # How every turn ends (completed, canceled, failed): the session gets
     # what the turn kept, goes idle and records the ending, and the end
     # event is announced, as one step of the event log (a snapshot taken
@@ -1786,223 +733,8 @@ module Samagotchi
     end
     private :end_turn
 
-    # The turn's anchors, stamped on its opening message (the prompt, or a
-    # wake turn's note) in the messages it keeps: display metadata, never
-    # in the prompt (LLM::ChatLoop#plain keeps them, no wire sends them).
-    # A Verify turn's claim however it ended; a Revise turn's draft only
-    # once it completed with an answer (#revision_target). Returns the
-    # stamped ReviseAnchor (the end event's revises), or nil.
-    def stamp_opening(messages, turn, outcome)
-      return unless messages.is_a?(Array)
-
-      revises = revision_target(messages, turn, outcome)
-      fields = { verify: turn.verify&.to_h, revises: revises&.to_h }.compact
-      return if fields.empty?
-
-      opening = messages.reverse.find do |message|
-        Steer.turn_prompt?(message) && (message[:turn_id] || message["turn_id"]).to_s == turn.id
-      end
-      return unless opening
-
-      opening.merge!(fields)
-      revises
-    end
-    private :stamp_opening
-
-    # The turn a Revise turn revised (D6: "this turn revised that one"):
-    # only a completed turn with an answer (AnswerTail) has revised
-    # anything. A draft no prompt in the messages carries is no target (a
-    # stale page, a rolled-back turn); one a stamped turn already revised
-    # is re-targeted to its stack's top, the newest version, which the
-    # person meant ("this draft").
-    def revision_target(messages, turn, outcome)
-      return unless turn.revises && outcome == "completed"
-
-      slice = AnswerTail.turn_slice(messages, turn.id)
-      return unless slice&.any? { |message| AnswerTail.answer?(message) }
-
-      target = turn.revises.turn_id
-      seen = [turn.id]
-      until seen.include?(target)
-        return reject_revise_anchor(turn.revises, :turn_missing) unless AnswerTail.turn_slice(messages, target)
-
-        seen << target
-        newer = messages.reverse.find do |message|
-          Steer.turn_prompt?(message) && ReviseAnchor.from(message[:revises] || message["revises"])&.turn_id == target
-        end
-        return ReviseAnchor.new(turn_id: target) unless newer
-
-        target = (newer[:turn_id] || newer["turn_id"]).to_s
-      end
-      reject_revise_anchor(turn.revises, :cycle)
-    end
-    private :revision_target
-
-    def reject_revise_anchor(anchor, reason)
-      Log.warn(:turn, "revise_anchor_rejected", turn_id: anchor.turn_id, reason:)
-      nil
-    end
-    private :reject_revise_anchor
-
-    def verified_anchor(session, anchor)
-      return unless anchor
-
-      source = verify_anchor_source_session(session, anchor)
-      return unless source
-
-      turn = AnswerTail.turn_slice(Array(source.messages), anchor.turn_id)
-      return reject_verify_anchor(anchor, :turn_missing) unless turn
-
-      reply = turn.reverse.find { |message| AnswerTail.answer?(message) }
-      return reject_verify_anchor(anchor, :reply_missing) unless reply
-
-      quote_text = verify_comparison_text(anchor.quote)
-      quoted = !quote_text.empty? && verify_quote_in?(quote_text, (reply[:content] || reply["content"]).to_s, source)
-      return reject_verify_anchor(anchor, :quote_missing) unless quoted
-
-      anchor
-    end
-    private :verified_anchor
-
-    # Whether +quote_text+ is in +answer+ as the model wrote it, or as the
-    # pages show it: a page quotes its own text, which reads the session's
-    # folder relative, the home folder as ~ and a secret shape as
-    # [redacted] (a participant's page gets it so, ParticipantView::Redact;
-    # the owner's page rewrites its quote the same way, claim_link.js
-    # normalizeClaim, so claim links match both pages). +source+ is the
-    # session whose folder that is.
-    def verify_quote_in?(quote_text, answer, source)
-      return true if verify_comparison_text(answer).include?(quote_text)
-
-      viewer = Web::ParticipantView::Viewer.new(cwd: source.working_directory)
-      verify_comparison_text(Web::ParticipantView::Redact.text(answer, viewer)).include?(quote_text)
-    end
-    private :verify_quote_in?
-
-    def verify_anchor_source_session(session, anchor)
-      return session unless session.verify_fresh
-
-      fresh = session.verify_fresh
-      return reject_verify_anchor(anchor, :fresh_anchor_mismatch) unless fresh.anchor == anchor
-      return reject_verify_anchor(anchor, :fresh_parent_missing) unless session.parent_id
-
-      Session.load(session.parent_id, state_dir: session_state_dir)
-    rescue ArgumentError, SystemCallError, IOError => e
-      Log.warn(:turn, "verify_anchor_rejected", turn_id: anchor.turn_id, reason: :source_session_unavailable,
-                                                 error: e.class.name)
-      nil
-    end
-    private :verify_anchor_source_session
-
-    def verify_comparison_text(text)
-      OutputFormatter.strip_markup(text)
-                    .gsub(/!\[([^\]]*)\]\([^)]+\)/, '\1')
-                    .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-                    .gsub(/^[ \t]*(?:\#{1,6}[ \t]+|>[ \t]?|[-+*][ \t]+|\d+[.)][ \t]+)/, "")
-                    .gsub(/(\*\*|__|~~|`+)(.+?)\1/m, '\2')
-                    .gsub(/(?<!\w)\*(\S(?:.*?\S)?)\*(?!\w)/m, '\1')
-                    .gsub(/(?<!\w)_(\S(?:.*?\S)?)_(?!\w)/m, '\1')
-                    .tr("|", " ") # a table row's cells; the page copies them without the pipes
-                    .gsub(/\s+/, " ")
-                    .strip
-    end
-    private :verify_comparison_text
-
-    def reject_verify_anchor(anchor, reason)
-      Log.warn(:turn, "verify_anchor_rejected", turn_id: anchor.turn_id, reason:)
-      nil
-    end
-    private :reject_verify_anchor
-
-    def record_verdict(turn, outcome)
-      return unless outcome == "completed" && turn.verify
-
-      answer = AnswerTail.find(turn.session.messages, turn_id: turn.id)
-      parsed = Verdict.parse(answer && (answer[:content] || answer["content"]))
-      return unless parsed
-
-      record = { anchor: turn.verify.to_h, verdict: parsed.verdict, reason: parsed.reason,
-                 by: turn.origin.author, check_turn_id: turn.id, at: Time.now.iso8601(3) }
-      turn.session.verdicts = turn.session.verdicts + [record]
-      record
-    end
-    private :record_verdict
-
-    def save_quietly(session)
-      session.save(state_dir: session_state_dir)
-    rescue StandardError => e
-      Log.warn(:turn, "turn_end_save_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      nil
-    end
-    private :save_quietly
-
-    # Keep what the after_turn hooks presented as the answer's `display`
-    # and the refs they attached as its `display_refs` (AnswerRefs, one
-    # replace for both), and tell the observers (:answer_display, the
-    # display or nil, and how many refs), after the turn_completed they
-    # already had: the web re-reads the answer then. A turn_completed
-    # with display_pending (after_turn hooks were about to run) always gets
-    # one, `display: nil` when nothing was presented, so the web holds the
-    # answer's pop until then and never swaps it after. Terminals are not
-    # sinks of it; they printed the answer already. The session is saved by
-    # the caller, as after every turn.
-    def store_answer_display(session, display, refs, pending: false)
-      synchronize_events do
-        # A plugin that kept event[:refs] and calls it later gets nil: the
-        # list is stored now (and the turn is over on every path).
-        refs.close!
-        messages = Array(session.messages)
-        changed = display.changed? && messages.last.equal?(display.target)
-        added = refs.added? && messages.last.equal?(refs.target)
-        if changed || added
-          merged = messages.last.dup
-          merged[AnswerDisplay::KEY] = display.text if changed
-          merged[AnswerRefs::KEY] = refs.to_a if added
-          replace_session_messages(session, messages[0...-1] + [merged])
-          event = { type: :answer_display, display: changed ? display.text : nil }
-          event[:refs] = refs.count if added
-          @session_observer.notify(event)
-        elsif pending
-          @session_observer.notify({ type: :answer_display, display: nil })
-        end
-      end
-    end
-    private :store_answer_display
-
-    # ── The hook runtime (HookRoutes) ───────────────────────────────────────
-
-    # What a hook (Hooks::Runtime) and a plugin (Plugin::Host) can do beyond
-    # reading its event, routed to the UIs by HookRoutes; these forward.
-    def hook_runtime = @hook_routes.runtime
-    private :hook_runtime
-
-    def hook_source(hook) = @hook_routes.source(hook)
-    private :hook_source
-
-    # What a notice may stand in for (hook_notify's fallback_for:).
-    NOTICE_FALLBACKS = HookRoutes::NOTICE_FALLBACKS
-
-    # One line to the user (:hook_notice), HookRoutes#notify.
-    def hook_notify(text, level, hook, fallback_for: nil, extra: {})
-      @hook_routes.notify(text, level, hook, fallback_for: fallback_for, extra: extra)
-    end
-    private :hook_notify
-
-    def guardrail_notify(message) = @hook_routes.guardrail_notify(message)
-    private :guardrail_notify
-
-    # @param question [HookQuestion]
-    # @return [Hash, nil] {selected:, freeform:, selected_indices:}
-    def hook_ask_user(question) = @hook_routes.ask_user(question)
-    private :hook_ask_user
-
-    # @return [Boolean] true when a running turn was cancelled now
-    def hook_stop_turn(reason, hook) = @hook_routes.stop_turn(reason, hook)
-    private :hook_stop_turn
-
-    # @return [Boolean] true when a streaming generation was cut now
-    def hook_stop_generation(reason, hook) = @hook_routes.stop_generation(reason, hook)
-    private :hook_stop_generation
+    # What a notice may stand in for (hook_notify's fallback_for:).
+    NOTICE_FALLBACKS = HookRoutes::NOTICE_FALLBACKS
 
     # Where cards and notices go (see #initialize for when). Each lookup
     # calls the Engine method the routes used before EventRoutes, at use.
@@ -2032,192 +764,6 @@ module Samagotchi
     end
     private :build_hook_routes
 
-    # ── Ask-user-question (structured qualification) ──────────────────────────
-
-    # @return [PendingQuestion, nil] the question pending now
-    def pending_question
-      @question_desk.pending
-    end
-
-    # Ask the model's question (ask_user_question): the kernel's
-    # question_handler, called on the turn thread with the payload
-    # Tools::AskUserQuestion.validate made (QuestionDesk#request), after
-    # the :question_asked hooks (QuestionAsked) gave the step its refs; a
-    # --non-interactive run has no one to ask, so they don't fire there.
-    # @param payload [Hash] {question:, options:, header:, multi_select:, allow_freeform:}
-    # @return [String] normalized answer JSON
-    def request_question(payload)
-      payload = question_asked(QuestionAsked::KIND_QUESTION, payload) unless interface == :non_interactive
-      @question_desk.request(payload)
-    end
-
-    # The :question_asked hooks for a question of the model's about to
-    # open: the fields with the asking step's refs (QuestionAsked.fire).
-    # @return [Hash]
-    def question_asked(kind, fields)
-      QuestionAsked.fire(hooks: @hooks, conversation: live_conversation, kind: kind, fields: fields,
-                         cwd: @session&.working_directory, synchronize: ->(&block) { synchronize_events(&block) },
-                         visible: ->(content) { question_step_text(content) })
-    end
-    private :question_asked
-
-    # A step's text as the asking slot shows it: the native loop's raw
-    # response without its thoughts and tool-call bodies (a chat step has
-    # neither), then the markup's tokens (OutputFormatter.strip_markup).
-    def question_step_text(content)
-      parser = @kernel.parser
-      OutputFormatter.strip_markup(parser.strip_tool_calls(parser.strip_thought(content)))
-    end
-    private :question_step_text
-
-    # Open a question for the UIs and wait for its answer
-    # (QuestionDesk#open_question: BLOCKS until answered or cancelled).
-    # @param fields [Hash] question:, options:, header:, multi_select:, allow_freeform:, …
-    #   (as a Hash or as keywords)
-    # @param watch [#call, nil] closes the question with the reason it returns
-    # @return [QuestionAnswer, Hash, String] the answer, or {error:, …}, or a
-    #   sync handler's text
-    def open_question(fields = nil, watch: nil, **more)
-      @question_desk.open_question({ **fields.to_h, **more }, watch: watch)
-    end
-
-    # Publish a standing question that blocks nobody (QuestionDesk#post: a
-    # worker's step-limit question).
-    # @return [PendingQuestion, nil] the pending question, nil while another is open
-    def post_question(fields, on_answer:, on_superseded_close: nil)
-      @question_desk.post(fields, on_answer: on_answer, on_superseded_close: on_superseded_close)
-    end
-
-    # Withdraw the standing question (QuestionDesk#withdraw).
-    # @return [Boolean]
-    def withdraw_question(reason, id: nil)
-      @question_desk.withdraw(reason, id: id)
-    end
-
-    # Answer the pending question (called from UI thread; QuestionDesk#answer).
-    # @return [QuestionAnswer]
-    def answer_question(id:, selected:, freeform: nil, client_id: nil, parent_agent: nil)
-      @question_desk.answer(id: id, selected: selected, freeform: freeform, client_id: client_id,
-                            parent_agent: parent_agent)
-    end
-
-    # Mark the pending question as relayed, or clear the mark
-    # (QuestionDesk#annotate).
-    # @return [Boolean]
-    def annotate_question(id, relayed_to:, reason: nil)
-      @question_desk.annotate(id, relayed_to: relayed_to, reason: reason)
-    end
-
-    def set_question_sync_handler(&block)
-      @question_desk.sync_handler = block
-    end
-
-    # Cancel the pending question (QuestionDesk#cancel).
-    # @return [Boolean] whether it was cancelled
-    # @raise [QuestionDesk::NotDismissable] +id+ names a standing question
-    def cancel_question(reason = "user", id: nil)
-      @question_desk.cancel(reason, id: id)
-    end
-
-    # The system prompt for a target's loop (default: the effective model's):
-    # the chat loop's leaves out the raw-prompt tool text, since its tools go
-    # as schemas. Built once per loop (and again after a model switch) so the
-    # prompt prefix, and the server's KV cache for it, stay stable.
-    # @param model [EffectiveModel, nil]
-    # @return [String]
-    # The native prompt depends on the thinking level too (Gemma's token):
-    # a level change builds it again. A build that
-    # misses the cache names the model and the level through its own
-    # lambdas (#model_identity, #turn_thinking), which resolve again.
-    def system_prompt(model = nil)
-      model ||= effective_model
-      chat = model.chat?
-      level = chat ? nil : @model_settings.thinking_level(model)
-      prompt = @prompt_builder.build(chat: chat, thinking: level, layers: model.llm_context_layers(@model_settings.llm_context_session_args))
-      # The memory indexes this prompt holds: /stats, the snapshot, analytics.json.
-      @metrics.memory_index = @prompt_builder.memory_index
-      # The model notes it carries: the session records them (/stats, /model, the web).
-      record_prompt_notes(@prompt_builder.prompt_notes)
-      prompt
-    end
-
-    # The base prompt (specs, plugins' declarations).
-    def assist_system_prompt(chat: false)
-      @prompt_builder.base(chat: chat)
-    end
-
-    # The --memory names activated while building the prompt; the TerminalUI
-    # mirrors them into its status line.
-    def activated_memory_names
-      @prompt_builder.activated_memory_names
-    end
-
-    # @return [Session] current session (Engine owns create/resume)
-    attr_reader :session
-
-    # This worker's relays of its delegates' approvals (memory only).
-    # @return [RelayDesk]
-    attr_reader :relay_desk
-
-    # The relay's view of this Engine, or nil when it can't host a relay: a
-    # worker's Engine only (its Bridge is what a child verifies against;
-    # --non-interactive has no one to ask), never with a REPL's sync
-    # handler (no wait loop, no watch).
-    # @return [RelayPeer, nil]
-    def relay_peer
-      return nil unless interface == :worker && !@question_desk.sync_handler?
-
-      RelayPeer.new(self)
-    end
-
-    # @return [String] the state dir holding this Engine's sessions
-    def peer_state_dir = @state_dir
-
-    # Set the current session outside a turn (the REPL does, before its first
-    # turn, so the messages API and recap see it)
-    def session=(session)
-      @session = session
-      # One session per REPL/worker process: its records carry this sid.
-      Log.session_id = session.id if session&.id
-      # Its own recap values (chi --set recap.enabled=false) rebuild the job.
-      rebuild_recap!
-      # A woken worker's /stats and status line count the turns before it.
-      bind_metrics(session)
-      @used_memories.absorb(session)
-      # Loaded on another model than its last turn ran on (a --resume'd
-      # REPL's --model, a worker woken after a /model with no turn since):
-      # the saved ctx % was that model's window's. Drop it and count it as
-      # /model does, on a configured window only: this runs before a
-      # worker's Bridge serves, so no /props GET or model list here (a slow
-      # or hung host would hold up the worker's start). No configured
-      # window: no % (ctx ?) until the first generation reports one.
-      return unless model_switched_since_last_turn?
-
-      @metrics.forget_model_reports!
-      announce_switched_context!(configured_only: true)
-    end
-
-    # Whether the last turn that named its model ran on another one than
-    # the effective model; false before any (or when the ref can't be told).
-    def model_switched_since_last_turn?
-      last = @metrics.last_model_ref
-      !last.nil? && last != effective_model_ref
-    rescue StandardError => e
-      Log.warn(:model, "switch_check_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      false
-    end
-    private :model_switched_since_last_turn?
-
-    # @return [IdleRecap, nil] the idle recap detector, or nil when disabled
-    attr_reader :recap
-
-    # Whether a continue offer waits (the Worker's or the REPL's TurnFlow),
-    # for the recap job: this one and any rebuilt one (IdleRecap#awaiting_continue=).
-    def recap_awaiting_continue=(callable)
-      @recap_awaiting_continue = callable
-      @recap&.awaiting_continue = callable
-    end
-
     # The idle recap job (RecapSetup.build) under the current session's own
     # recap values, which it records.
     # @return [IdleRecap, nil]
@@ -2232,95 +778,6 @@ module Samagotchi
     end
     private :build_recap
 
-    # The bound session's own recap.* values ({} for none).
-    def session_recap_values
-      (@session&.settings&.core || {}).select { |key, _| key.start_with?("recap.") }
-    end
-    private :session_recap_values
-
-    # A new recap job when the bound session's own recap values differ from
-    # the ones the current job was built under (none at start): the old one
-    # is dropped (an attempt in flight goes stale) and the scheduler swaps
-    # it, keeping its one thread. Binding the same session again changes
-    # nothing (the REPL binds it twice).
-    def rebuild_recap!
-      return if session_recap_values == @recap_built_for
-
-      old = @recap
-      old&.invalidate!
-      @recap = build_recap
-      @idle_scheduler&.replace_job(old, @recap)
-    end
-
-    # /recap on|off|default: the bound session's own recap.enabled (true,
-    # false; nil removes it, so config.yml's applies again), and the recap
-    # job rebuilt under it at once. It doesn't save: the command says
-    # changed: [:recap] and its host saves (Worker#run_command).
-    # @param enabled [Boolean, nil]
-    # @raise [ArgumentError] no session is bound
-    def recap_override=(enabled)
-      raise ArgumentError, "no session" unless @session
-
-      core = @session.settings.core.dup
-      enabled.nil? ? core.delete(RECAP_ENABLED_KEY) : core[RECAP_ENABLED_KEY] = enabled
-      @session.settings = @session.settings.with(core: core)
-      rebuild_recap!
-    end
-
-    # The bound session's own recap.enabled (/recap on|off, --set), or nil.
-    # @return [Boolean, nil]
-    def recap_override = @session&.settings&.core&.fetch(RECAP_ENABLED_KEY, nil)
-
-    # Write the recap now, before the session is left (IdleRecap#write_now).
-    # @return [String, nil] the recap written, nil when none was (recap off,
-    #   nothing new, an error, the timeout)
-    def write_recap_now(on_start: nil)
-      @recap&.write_now(on_start: on_start)
-    end
-
-    # The longest #write_recap_now waits (recap.timeout), nil when no recap
-    # is set up.
-    # @return [Float, nil]
-    def recap_timeout = @recap&.timeout
-
-    # Ask for a recap now (/recap), without waiting for the idle window.
-    # @return [Symbol] IdleRecap#request_now's answer, or :off
-    def request_recap
-      @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:}
-    def saved_recap
-      state = @recap&.state
-      return nil unless state
-
-      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] }
-    end
-
-    # Start the shared idle scheduler (reminders + optional recap). The recap
-    # job is only registered when recap is configured; the reminders job is
-    # always present. TerminalUI calls this before the REPL and SessionManager
-    # workers call it so reminders can trigger turns; one-shot/worker paths
-    # that never start it poll nothing.
-    def start_idle
-      @idle_scheduler&.start
-      self
-    end
-
-    # Stop the shared idle scheduler (TerminalUI calls this when the REPL
-    # exits). +join+: wait for a tick under way (IdleScheduler#stop); a
-    # caller holding #synchronize_events passes false, since a recap's emit
-    # in that tick waits for the same lock.
-    def stop_idle(join: true)
-      @idle_scheduler&.stop(join: join)
-      self
-    end
-
     # One turn's values, for #run_turn and its endings. Per turn and
     # single-threaded: the cross-thread turn state (the cancel slot, the
     # sink, steers) stays on the Engine.
@@ -2462,7 +919,7 @@ module Samagotchi
 
         # Keep what the turn got to (the prompt plus the loop's completed
         # tool iterations) like a cancel does, and save it: a worker exits
-        # after a failed turn. The REPL still rolls back to its checkpoint.
+        # after a failed turn.
         end_turn(turn, "failed", save: true) { |seconds| [failed_messages(turn, e), failed_event(e, seconds)] }
         raise
       ensure
@@ -2497,7 +954,7 @@ module Samagotchi
       # or a plugin's card from another thread never sees a running turn
       # without them. The idle recap detector does not fire (or render an
       # invalidated recap) while the model is working. A hook's notice goes
-      # where the turn's events go (the REPL renders only its sink; a
+      # where the turn's events go (a one-shot prints only its sink; a
       # worker's observers carry it to the bridge).
       @turn_state.begin!(controller: effective_controller, sink: on_event, input_waiting: input_waiting)
       # Drop a recap already in flight: the turn makes it stale.
@@ -2602,90 +1059,6 @@ module Samagotchi
     end
     private :prepare_turn
 
-    # A turn stopped before the model was asked (#prepare_turn returned
-    # false): canceled with nothing kept, like a Ctrl-C there; the result
-    # has no conversation, so a UI's checkpoint stands.
-    def stopped_before_model(turn)
-      reason = turn.controller.reason
-      end_turn(turn, "canceled") do |seconds|
-        [nil, { type: :turn_canceled, cancellation_reason: reason, cancelled_by: cancelled_by(turn),
-                duration_ms: (seconds * 1000).round }]
-      end
-      LLM::ModelResult.new(text: "", canceled: true, cancellation_reason: reason)
-    end
-    private :stopped_before_model
-
-    # Who stopped a turn a hook stopped or cut (the controller's detail: the
-    # bundle, or the hook's label), for the UIs' "stopped by loop-guard";
-    # nil for any other cancel.
-    def cancelled_by(turn) = turn.controller.stopped_by
-    private :cancelled_by
-
-    # The turn's settings for the kernel (LLM::TurnSettings): vision,
-    # sampling and thinking, the thinking resolved before the hooks run.
-    # The model name is added in #generate, after the hooks that may switch
-    # the model.
-    # One resolve for all of them: nothing runs between them that could
-    # change what a resolve gives.
-    def turn_settings(session)
-      model = effective_model
-      vision = turn_vision(session, model)
-      sampling = model.sampling
-      level = @model_settings.thinking_level(model)
-      @thinking_notices.turn_started(level, model.target)
-      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: level,
-                            reasoning_history: @model_settings.reasoning_history_level(model), model_name: nil,
-                            window_setting: nil, llm_context: nil, price: nil)
-    end
-    private :turn_settings
-
-    # @return [PromptWarmup] the turn-end warm-up (specs, measurements)
-    attr_reader :prompt_warmup
-
-    # A caller's check that the next turn starts at once (input queued for
-    # it: a worker's inbox) or that none follows (a one-shot run): no
-    # warm-up then. nil: neither.
-    attr_accessor :next_turn_waiting
-
-    # After a completed turn, prefill the next turn's prompt up to its user
-    # message while the user reads (PromptWarmup, cache.warmup). Only on a
-    # local llama.cpp host on the native loop, and not when the next turn's
-    # start differs anyway or starts at once: a reminder due, a continue
-    # offer (the turn ran out of steps), a carried steer or queued input.
-    # Never fails the turn.
-    def warm_up_next_turn(turn, result)
-      return if result.canceled? || result.resumable?
-
-      model = effective_model
-      client = model.client
-      return unless warmup_target?(model, client)
-      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(model) })
-      # 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: @model_settings.turn_llm_context || @kernel.turn_settings&.llm_context)
-      return unless prompt
-
-      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
-    private :warm_up_next_turn
-
-    # Never a paid or remote host (cache.warmup auto means local only), nor
-    # the chat loop (Splash keeps its own cache; llama.cpp's chat path is
-    # not measured), nor a client that can't warm up (a spec's stub).
-    def warmup_target?(model, client)
-      return false if model.chat? || model.entry.remote?
-      return false unless client.respond_to?(:warm_up)
-
-      PromptWarmup.enabled?
-    end
-    private :warmup_target?
-
     # The messages the turn sends: the history under the system head, due
     # reminders, the prompt. turn.messages is set first and grown in place,
     # so a Ctrl-C or a failure meanwhile keeps what is there.
@@ -2767,250 +1140,6 @@ module Samagotchi
     end
     private :generate
 
-    # The ref (host:model, as asked) a turn's generations ran on: the model
-    # #generate resolved, after the before_turn hooks (which may switch it).
-    # SessionMetrics keys its per-model segments on it. nil when it can't be
-    # named (the turn's record then has none).
-    def generation_model_ref(model)
-      model.ref
-    rescue StandardError => e
-      Log.warn(:turn, "model_ref_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      nil
-    end
-    private :generation_model_ref
-
-    # A step-limit Continue's resume_from, when it is inside the messages the
-    # run gets (a wrong one only drops reasoning: it is ignored, logged).
-    # Entries before it never move between the turns (#turn_messages adds
-    # at the tail, and the system head is replaced in place).
-    def resumed_run_start(turn, run_start)
-      start = turn.resume_from
-      return nil if start.nil?
-      return start if start.is_a?(Integer) && start.between?(0, run_start)
-
-      Log.warn(:turn, "resume_start_invalid", resume_from: start, length: run_start)
-      nil
-    end
-    private :resumed_run_start
-
-    # The turn's LLM context strategy and where it came from, in the turn
-    # log: when it runs a layer, or the session set it (none too).
-    def log_llm_context(explained)
-      return unless explained
-      return if explained.resolved.active_layers.empty? && explained.strategy.source != :session
-
-      summary = explained.summary
-      Log.info(:turn, "llm_context", **summary.slice(:strategy, :strategy_source, :apply, :apply_source, :budget_tokens,
-                                                     :budget_source).compact)
-    end
-    private :log_llm_context
-
-    def publish_used_memories(session, on_event)
-      # Persist deduped used memories onto the session for Web + reload.
-      begin
-        session.used_memory_names = used_memory_names
-      rescue StandardError => e
-        Log.warn(:memory, "used_memories_store_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      end
-      # Notify live observers of the updated memory list (so yellow bar refreshes
-      # even without a tool_call event if the preload was the only addition).
-      # Only emit when there is something to report to avoid noisy event_count drift.
-      return unless used_memory_names.any?
-
-      begin
-        emit_event(on_event, { type: :used_memories_updated, used_memory_names: used_memory_names })
-      rescue StandardError => e
-        Log.warn(:memory, "used_memories_emit_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      end
-    end
-    private :publish_used_memories
-
-    # The normal ending (an answer, an empty answer, a Stop, the iteration
-    # limit), then the after-turn hooks.
-    def complete_turn(turn, result)
-      canceled = result.canceled?
-      # after_turn hooks run below and may present the answer (the web
-      # holds its pop until it knows).
-      display_pending = !canceled && @hooks.any?(:after_turn)
-      end_turn(turn, canceled ? "canceled" : "completed", exhausted: !canceled && result.exhausted?) do |seconds|
-        kept = kept_messages(turn, result, seconds)
-        if canceled
-          [kept, { type: :turn_canceled, cancellation_reason: result.cancellation_reason, cancelled_by: cancelled_by(turn),
-                   duration_ms: (seconds * 1000).round }]
-        else
-          # For a client that attaches later (session_state_snapshot).
-          @last_context_status = result.context_status.dup if result.context_status
-          [kept, { type: :turn_completed, result: result, turn_summary: turn_summary(result),
-                   display_pending: display_pending }]
-        end
-      end
-
-      # Fire :after_turn hook (an answer or a Stop; an Interrupt or a failure
-      # ends the turn in #run_turn without it), with a read-only
-      # copy of the conversation the turn stored, event[:answer] (the answer's
-      # text: the native loop's stored message still holds its thought),
-      # event[:present] for
-      # a display version of the answer (AnswerDisplay) and event[:refs]
-      # for refs on it (AnswerRefs).
-      session = turn.session
-      audit_objectives_outgoing(turn, result) 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",
-                     messages: hook_messages(session.messages),
-                     answer: (result.text unless canceled || result.exhausted?) }
-      after_turn[:present] = display.presenter(after_turn)
-      after_turn[:refs] = refs.adder(after_turn)
-      @hooks.fire(:after_turn, after_turn)
-      store_answer_display(session, display, refs, pending: display_pending)
-
-      # Fire :session_end after the turn (turn-level lifecycle), as :after_turn
-      @hooks.fire(:session_end, { type: :session_end, session_id: session.id })
-    end
-    private :complete_turn
-
-    # What each turn ending keeps and announces is TurnEndings'
-    # (#build_turn_endings); these forward to it.
-    def kept_messages(turn, result, seconds) = @turn_endings.kept_messages(turn, result, seconds)
-    private :kept_messages
-    def ctrl_c_messages(turn, interrupt, seconds) = @turn_endings.ctrl_c_messages(turn, interrupt, seconds)
-    private :ctrl_c_messages
-    def loop_conversation(error) = @turn_endings.loop_conversation(error)
-    private :loop_conversation
-    def failed_messages(turn, error) = @turn_endings.failed_messages(turn, error)
-    private :failed_messages
-    def failed_event(error, seconds) = @turn_endings.failed_event(error, seconds)
-    private :failed_event
-
-    # However the turn ended (#run_turn's ensure): the turn flag off, the
-    # probe cancel restored, the cancel controller, sink and steers cleared
-    # (a steer left is logged as dropped), activity recorded, the
-    # turn-scoped hooks cleared.
-    def release_turn(probe_cancel_before)
-      # A completed turn is activity: release the turn flag and advance the
-      # shared inactivity clock so the idle recap detector (shared with the REPL)
-      # treats the just-finished turn as activity and re-arms its window.
-      left = @turn_state.finish!
-      @steer_cut.finished!
-      Client.swap_probe_cancel(probe_cancel_before)
-      # The next turn's window and served model are asked again: the cache
-      # (this host's, process-wide) is dropped here, at the turn's end,
-      # rather than at its start, so what this turn read (the profile's own
-      # probe included) is not asked for a second time within the turn. A
-      # restart with another -c between turns is still noticed: the next
-      # turn's first probe goes to the server.
-      @client.invalidate_context_window!
-      log_dropped_steers(left, "turn_ended")
-      record_activity
-      # Clear hooks so they remain turn-scoped and never leak into the next turn.
-      clear_hooks
-    end
-    private :release_turn
-
-    # [refs, nil] for a turn's images, or [[], error] when one can't be used
-    # (the turn then fails right after :turn_started).
-    def turn_image_refs(session, images)
-      return [[], nil] if Array(images).empty?
-
-      [ImageStore.resolve_all(Session.session_dir(session.id, state_dir: session_state_dir), images), nil]
-    rescue ImageStore::Error => e
-      [[], e]
-    end
-
-    # The turn's VisionContext: the session's images folder, and whether the
-    # effective model can see images, asked only when a request carries one.
-    def turn_vision(session, model = effective_model)
-      VisionContext.new(session_dir: Session.session_dir(session.id, state_dir: session_state_dir),
-                        capability: -> { model.vision_support(profile) })
-    end
-
-    # The effective model's sampling and thinking level as the next turn
-    # reads them (SessionModelSettings).
-    def turn_sampling = @model_settings.turn_sampling
-    def turn_thinking = @model_settings.turn_thinking
-
-    # A model known not to see images fails a turn with images up front.
-    def refuse_images!(vision)
-      return if vision.sendable?
-
-      host = effective_model.host_name
-      raise LLM::VisionUnsupported.new("#{host}: #{vision.refusal_reason}", host: host)
-    end
-
-    # JSON-safe digest of a finished turn for renderers (TurnEndings#turn_summary).
-    # @param result [LLM::ModelResult]
-    # @return [Hash]
-    def turn_summary(result) = @turn_endings.turn_summary(result)
-
-    # ── Session messages API ───────────────────────────────────────────────
-    #
-    # Out-of-turn edits to the current session's conversation (`!cmd` output,
-    # rollback after Ctrl-C). Each replaces the array rather than mutating it,
-    # so the recap's lock-free snapshot never sees a half-applied edit.
-
-    # The answer a UI shows last (AnswerTail), a copy of that one message
-    # only: walked back from the end, never a #messages_checkpoint of the
-    # whole conversation (the Bridge's GET tail). +turn_id+: that turn's
-    # answer (AnswerTail.find); unknown or nil: the newest.
-    # @return [Hash, nil]
-    def last_answer_message(turn_id: nil)
-      AnswerTail.find(@session&.messages, turn_id: turn_id)&.dup
-    end
-
-    # @return [Array<Hash>] a copy of the current session's messages to hand
-    #   back to #rollback_to later
-    def messages_checkpoint
-      clone_messages(@session&.messages)
-    end
-
-    # The running turn's conversation as its loop builds it (both loops
-    # register it on the kernel's llm_context_turn): the same array the loop
-    # appends to, not a copy, so read it on the turn's thread (the pending
-    # input drain, at an iteration boundary: TurnCheckpoint), or from another
-    # only as a dup, read only (/objectives). nil when no
-    # turn runs (llm_context_turn is never cleared, and still holds the
-    # last turn's then).
-    # @return [Array<Hash>, nil]
-    def live_conversation
-      return nil unless turn_running? && @kernel.respond_to?(:llm_context_turn)
-
-      @kernel.llm_context_turn&.conversation
-    end
-
-    # Append messages to the current session's conversation.
-    # @param messages [Array<Hash>]
-    # @return [Array<Hash>] the session's messages
-    def append_messages(messages)
-      raise ArgumentError, "no current session" unless @session
-
-      replace_session_messages(@session, Array(@session.messages) + clone_messages(messages))
-    end
-
-    # Restore the current session's conversation to a #messages_checkpoint.
-    # Between turns the working set is announced when that changed it (a
-    # !rollback or a canceled continue dropping the turn's tool calls, the
-    # set emptied too), so the page doesn't keep the dropped items until
-    # the next request.
-    # @param checkpoint [Array<Hash>]
-    # @return [Array<Hash>] the session's messages
-    def rollback_to(checkpoint)
-      raise ArgumentError, "no current session" unless @session
-
-      messages = replace_session_messages(@session, clone_messages(checkpoint))
-      unless turn_running?
-        announce_working_set
-        announce_objectives
-      end
-      messages
-    end
-
-    # Clone a messages array (shallow dup of each element).
-    # @param messages [Array<Hash>]
-    # @return [Array<Hash>]
-    def clone_messages(messages)
-      Array(messages).map(&:dup)
-    end
-
     private
 
     def running_command_key = :"samagotchi_command_#{object_id}"
@@ -3027,365 +1156,10 @@ module Samagotchi
       session.messages = messages
     end
 
-    # 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).
-    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.adapter = @host_registry.adapter_for(model.entry)
-        @chat_backend.session_id = session&.id
-        @chat_backend
-      end
-    end
-
-    def load_plugins
-      host = plugin_host
-      registries = Plugin::Registries.new(
-        commands: @command_registry, tools: @tools, hooks: @hooks,
-        context_for: lambda { |bundle, settings, label|
-          Plugin::Context.new(bundle: bundle, label: label, settings: settings, host: host)
-        },
-        tools_changed: -> { tools_changed! },
-        services: @services,
-        stage_tools: ->(bundle, specs, context) { stage_tools(bundle, specs, context) },
-        init: lambda { |bundle, label, plugin_label, provides_tools:, quiet:, timeout:, failed: nil, &block|
-          add_init_task(bundle: bundle, label: label, plugin_label: plugin_label, provides_tools: provides_tools,
-                        quiet: quiet, timeout: timeout, failed: failed, &block)
-        },
-        toolkits: @toolkit_binding.plugin_kits,
-        tool_index: @tool_index,
-        peer_sources: @peer_sources,
-        prompt_sections: @prompt_sections,
-        prompt_changed: -> { prompt_changed! },
-        judgments: @judgments,
-        hook_failed: ->(hook, failed) { @hook_routes.plugin_hook_failed(hook, failed) }
-      )
-      # What plugins show while they load (an MCP server that didn't
-      # start) waits for the first turn, beside the load warnings: no UI
-      # is there yet, and the Engine isn't built.
-      @extension_load.load_plugins(registries, failures: @plugin_failures) do
-        warn_undeclared_judgments
-        warn_bundle_settings
-      end
-    end
-
-    # config.yml bundles: names and keys that do nothing (BundleSettingsCheck),
-    # held like the judgments' line, for the same reason. Logged by every
-    # Engine; shown by the first to find them (BundleSettingsCheck.unshown).
-    def warn_bundle_settings
-      lines = BundleSettingsCheck.warnings(@extension_load.bundle_settings)
-      lines.each { |line| Log.warn(:config, "bundle_setting_unknown", msg: line) }
-      BundleSettingsCheck.unshown(lines).each { |line| hook_notify(line, :warn, "config") }
-    end
-    private :warn_bundle_settings
-
-    # Held with the plugins' own notices, so every UI gets it: a worker's
-    # stderr goes nowhere.
-    def warn_undeclared_judgments
-      @judgments.undeclared.each do |name|
-        Log.warn(:config, "judgment_undeclared", judgment: name)
-        hook_notify("system_one.judgments.#{name}: no loaded bundle declares it, so it does nothing", :warn, "config")
-      end
-    end
-    private :warn_undeclared_judgments
-
-    # Keep a plugin's new tool set (chi.replace_tools, from any thread)
-    # for the turn thread (PluginTasks#stage_tools).
-    def stage_tools(bundle, specs, context)
-      @plugin_tasks.stage_tools(bundle, specs, context)
-    end
-    private :stage_tools
-
-    # Apply the staged tool sets, on the turn thread, before the turn's
-    # system prompt is built (PluginTasks#apply_staged_tools!). A changed
-    # set may change the chi group the search tool's description counts
-    # (a plugin tool the toolkit leaves out).
-    # @return [Boolean] whether the tools changed
-    def apply_staged_tools!
-      changed = @plugin_tasks.apply_staged_tools!
-      @tool_index.refresh! if changed
-      changed
-    end
-    public :apply_staged_tools!
-
-    # The session's toolkit (ToolkitBinding): the kits, what its next turn
-    # declares, ctx.use_toolkit and the turn-start apply.
-    def toolkit_kits(errors = []) = @toolkit_binding.kits(errors)
-    def resolved_toolkit(session, errors = []) = @toolkit_binding.resolved(session, errors)
-    def toolkit_explained(toolkit = nil) = @toolkit_binding.explained(toolkit)
-    def toolkit_summary = @toolkit_binding.summary
-
-    # The tools this session registered (Tools::Registry), declared or not.
-    attr_reader :tools
-
-    public :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) that the session neither declares
-    # nor loaded with an earlier tool change, for bundle +bundle+. A name
-    # that names no tool at all is logged; a declared or removed one is
-    # skipped quietly.
-    # @return [Array<String>] the wire names staged
-    def load_tools(names, bundle)
-      added = ToolLoads.added(@session&.messages)
-      wanted = names.filter_map do |name|
-        wire = @tool_index.deferred_name(name)
-        Log.info(:plugins, "load_tools_skipped", bundle: bundle, tool: name) unless wire || @tools.key?(name)
-        wire
-      end
-      @tool_loads.stage(wanted - added, by: bundle)
-    end
-    public :load_tools
-
-    # The staged tool loads, appended to +turn+'s messages (after its user
-    # message, or the trailing results and notes of a turn with none) as
-    # one ToolLoads entry per bundle, when the turn's host takes tool
-    # changes (ChatLoop#tool_changes?). Elsewhere they are dropped, logged.
-    # A conversation that ends with a reply keeps them staged (a system
-    # change must follow a user turn).
-    def append_tool_loads(turn)
-      return unless @tool_loads.any?
-      return if turn.messages.last&.dig(:role).to_s == "model"
-
-      model = effective_model
-      host = backend(model)
-      staged = @tool_loads.take
-      added = ToolLoads.added(turn.messages)
-      unless host.respond_to?(:tool_changes?) && host.tool_changes?(bare_model_name(model.name))
-        Log.info(:plugins, "tool_loads_not_sent", tools: staged.values.flatten.join(","), model: model.name.to_s)
-        return
-      end
-
-      staged.each do |bundle, names|
-        names -= added
-        next if names.empty?
-
-        turn.messages << ToolLoads.entry(names, by: bundle)
-        hook_notify("tools loaded: #{names.join(", ")}", :info, bundle)
-      end
-    end
-    private :append_tool_loads
-
-    # A plugin's ctx.use_toolkit (ToolkitBinding#use).
-    # @return [Boolean] whether it was staged
-    # @raise [ArgumentError] an unknown toolkit
-    def use_toolkit(name) = @toolkit_binding.use(name)
-    public :use_toolkit
-
-    # At a turn's start (ToolkitBinding#apply!).
-    # @return [Boolean] whether the declared tools changed
-    def apply_toolkit!(session, on_event = nil) = @toolkit_binding.apply!(session, on_event)
-    private :apply_toolkit!
-
-    # Start the toolkit classifier after :turn_started, for audit and on
-    # mode alike (one eligibility, one snapshot, one thread). All session
-    # and tool-registry reads happen here; the thread receives only this
-    # snapshot. Audit never blocks: the thread logs its line. On mode
-    # returns the ask's Pending, which the turn joins before apply_toolkit!
-    # (#settle_toolkit_suggestion), with the turn's controller as the
-    # request's cancel controller.
-    # @return [ToolkitSuggest::Pending, nil] nil unless the turn joins an ask
-    def start_toolkit_suggestion(turn)
-      mode = Config.get("toolkit.suggest.mode").to_s
-      return if mode == "off"
-
-      joined = mode == "on"
-      session = turn.session
-      default = Toolkit.of(session.toolkit)
-      log = toolkit_suggestion_log
-      # The predicate checks the session first; the kits (memory kits are
-      # read from disk) and the log (read whole) only when it gets there.
-      kits = nil
-      candidates = nil
-      return unless ToolkitSuggest.eligible?(
-        session: session, prompt: turn.prompt, author: turn.origin.author,
-        candidate_count: lambda {
-          kits = @toolkit_binding.kits
-          candidates = ToolkitSuggest.candidates(kits, default_name: default.name)
-          candidates.size
-        },
-        last_suggestion: -> { ToolkitSuggest.last_suggestion(log, session.id) },
-        defer_turns: Config.get("toolkit.suggest.defer_turns"),
-        defer_tokens: Config.get("toolkit.suggest.defer_tokens")
-      )
-
-      # One ask at a time: an eligible turn while the last one still runs
-      # goes unasked, and says so.
-      if @side_judgments.in_flight?(:toolkit)
-        Log.info(:toolkit, "toolkit_suggest_in_flight_skipped", session_id: session.id)
-        return
-      end
-
-      client = system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit),
-                                    ToolkitSuggest::JUDGMENT, session, mode: Config.get("toolkit.suggest.mode").to_s)
-      return unless client
-
-      # The warm-up's only value is the cache: the real ask never queues
-      # behind it.
-      stop_toolkit_warmup
-
-      # Rules, not tool lists: this runs before await_init_tasks and
-      # apply_staged_tools!, so a first turn's plugin/MCP tools aren't
-      # registered yet; the report expands the rules (ToolkitSuggest.rules).
-      snapshots = candidates.map do |kit|
-        ToolkitSuggest::Candidate.new(name: kit.name.dup.freeze, description: kit.description.dup.freeze,
-                                      rules: ToolkitSuggest.rules(Toolkit.resolve_kit(kit.name, kits)))
-      end.freeze
-      default_snapshot = ToolkitSuggest::Candidate.new(name: default.name.dup.freeze, description: nil,
-                                                       rules: ToolkitSuggest.rules(default.resolve(kits)))
-      registered = @tools.entries(toolkit: nil).reject { |entry| entry.source == Tools::ToolIndex::SOURCE }
-      core_tools, plugin_tools = registered.partition(&:core?).map { |entries| entries.map { |entry| entry.name.dup.freeze }.freeze }
-      state = ToolkitSuggest.question(
-        default: default, kits: kits, project: File.basename(session.project_root.to_s),
-        prompt: turn.prompt
-      ).last
-      snapshot = ToolkitSuggest::Snapshot.new(
-        session_id: session.id.dup.freeze, turn_number: ToolkitSuggest.turn_number(session.messages),
-        default: default_snapshot, candidates: snapshots, core_tools: core_tools, plugin_tools: plugin_tools,
-        state: { project: state[:project].dup.freeze, prompt: state[:prompt].dup.freeze }.freeze
-      )
-      threshold = Config.get("toolkit.suggest.threshold")
-      runs = session.scratch ? nil : system_one_runs
-      pending = ToolkitSuggest::Pending.new(log: log, joined: joined,
-                                            acted: runs && ->(judged, did) { runs.acted(judged.fields[:run_id], did) },
-                                            timeout_seconds: SystemOne::Client.configured_timeout_ms / 1000.0)
-      # On mode: cut by a Stop while the turn waits (Pending#wait), not
-      # by one after it went on; audit's ask is never cut.
-      controller = joined ? pending.cancel_controller : nil
-      @side_judgments.start(:toolkit, warn: ToolkitSuggest.method(:warn), finish: pending.method(:finish)) do
-        ToolkitSuggest.judge(client: client, snapshot: snapshot, threshold: threshold,
-                             cancel_controller: controller)
-      end
-      joined ? pending : nil
-    rescue StandardError => e
-      ToolkitSuggest.warn(e)
-      nil
-    end
-    private :start_toolkit_suggestion
-
-    # On mode, before apply_toolkit!: wait for the ask (#start_toolkit_
-    # suggestion) up to System 1's timeout from its start, or until a Stop,
-    # and put the session on a candidate picked with confidence ≥ threshold
-    # (ToolkitBinding#suggest: origin suggested, saved, the notice). Any
-    # other outcome (the default, below threshold, undecided, no judgment,
-    # a timeout, a Stop) leaves the session on its default. Nothing here
-    # sends a request; prepare_turn's cancel check ends a stopped turn. A
-    # Stop wins over an answer already in (Pending#wait checks it first).
-    def settle_toolkit_suggestion(turn, pending)
-      return if pending.nil?
-
-      outcome, judged = pending.wait(turn.controller)
-      if outcome == :timeout
-        # The session starts on its default without a word otherwise: a
-        # slow System 1 host (a local one) is the usual cause.
-        timeout_ms = SystemOne::Client.configured_timeout_ms
-        Log.warn(:toolkit, "toolkit_suggest_timeout", session_id: turn.session.id, timeout_ms: timeout_ms,
-                                                      reason: "System 1 gave no answer within system_one.timeout_ms")
-        @toolkit_binding.fell_back(turn.session, "System 1 took over #{timeout_ms} ms")
-        return
-      end
-      unless outcome == :answered
-        Log.info(:toolkit, "toolkit_suggest_#{outcome}", session_id: turn.session.id)
-        return
-      end
-      return if judged.nil?
-
-      pending.record(toolkit_suggestion_outcome(turn.session, judged))
-    rescue StandardError => e
-      ToolkitSuggest.warn(e)
-      pending&.record("failed")
-    end
-    private :settle_toolkit_suggestion
-
-    # What the turn does with an answered ask, as the log line's did:
-    # suggested (switched), chosen (the toolkit isn't the default any
-    # more), unavailable (the kit is gone), defer or default.
-    def toolkit_suggestion_outcome(session, judged)
-      case judged.would
-      when "suggested"
-        return "chosen" unless session.toolkit_origin == "default"
-        return "unavailable" unless @toolkit_binding.kits.key?(judged.suggestion.kit)
-
-        switched = @toolkit_binding.suggest(session, judged.suggestion.kit, confidence: judged.suggestion.confidence,
-                                                                            deferred: ToolkitSuggest.model_reply?(session.messages))
-        switched ? "suggested" : "chosen"
-      when "defer" then "defer"
-      when "no_judgment"
-        # System 1 failed (its own warn) or answered nothing usable.
-        @toolkit_binding.fell_back(session, "System 1 gave no answer")
-        "default"
-      else "default"
-      end
-    end
-    private :toolkit_suggestion_outcome
-
-    # On mode, as an idle worker starts (Worker#start_background): one ask
-    # with the real question and a stand-in prompt, on its own thread,
-    # never logged and never waited for, so System 1's server has the
-    # question's prefix cached for the first prompt. Only for a session a
-    # first prompt could be asked for: origin default, no model reply, not
-    # a delegate child or a review session, at least two candidates; and
-    # not when the worker starts on a first prompt (that ask comes at once).
-    def warm_toolkit_suggestion!
-      return unless Config.get("toolkit.suggest.mode").to_s == "on"
-
-      session = @session
-      return if session.nil? || session.toolkit_origin != "default" || session.delegate? || session.review?
-      return if ToolkitSuggest.model_reply?(session.messages) || !session.last_prompt.to_s.strip.empty?
-
-      default = Toolkit.of(session.toolkit)
-      kits = @toolkit_binding.kits
-      return if ToolkitSuggest.candidates(kits, default_name: default.name).size < 2
-
-      client = SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit)
-      return unless client
-
-      project = File.basename(session.project_root.to_s)
-      @toolkit_warmup_thread = Thread.new do
-        ToolkitSuggest.warm(client: client, default: default, kits: kits, project: project)
-      end
-    rescue StandardError => e
-      ToolkitSuggest.warn(e)
-      nil
-    end
-    public :warm_toolkit_suggestion!
-
-    # A still-running warm-up, stopped: a real ask (or the worker leaving)
-    # doesn't wait behind it.
-    def stop_toolkit_warmup
-      @toolkit_warmup_thread&.kill
-      @toolkit_warmup_thread = nil
-    end
-    private :stop_toolkit_warmup
-
-    def toolkit_suggestion_log
-      SideJudgments.log(ToolkitSuggest.log_path(session_state_dir), tag: :toolkit, event: "toolkit_suggest_log_failed")
-    end
-    private :toolkit_suggestion_log
-
-    # +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.
-    # @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
-    end
-    private :system_one_recording
-
     # Bundles' judgments (chi.judgment), on this Engine's Runs and side asks.
     # A judgment's own host and model are for bundles only: core's clients
-    # above never pass them (D2, JudgmentSettings).
+    # (#system_one_recording's, engine/side_requests.rb) never pass them (D2,
+    # JudgmentSettings).
     def build_judgments
       SystemOne::Judgments.new(
         client_for: lambda { |_name, settings|
@@ -3400,165 +1174,6 @@ module Samagotchi
     end
     private :build_judgments
 
-    # 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
-
-    # The candidate judge (ContextJudge) at an owner turn's start, after
-    # the toolkit's ask settled: the session's candidates' status changes
-    # are logged (ContextCandidatesLog#look) and, unless
-    # context.candidates.mode is off, the proposed candidates due an ask
-    # are asked about the owner's prompts so far, this one included. Never
-    # a participant's turn, a review session or a Continue (no new prompt).
-    def start_context_judge(turn)
-      session = turn.session
-      return unless turn.prompt.is_a?(String) && OwnerPrompt.turn?(session: session, author: turn.origin.author)
-
-      context_judge_pass(session, ContextCandidates.owner_texts(session.messages) + [turn.prompt], phase: "turn")
-    end
-    private :start_context_judge
-
-    # System 1 on the objectives, in audit (ObjectivesAudit): the owner's turns
-    # only, and for a message a person's: a reminder's or a delegate's prompt isn't one.
-    def audit_objectives_incoming(turn)
-      return unless turn.prompt.is_a?(String) && turn.origin.human? && OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
-
-      objectives_audit.incoming(turn.session, turn.prompt)
-    end
-    private :audit_objectives_incoming
-
-    def audit_objectives_outgoing(turn, result)
-      return unless OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
-
-      objectives_audit.outgoing(turn.session, result.text)
-    end
-    private :audit_objectives_outgoing
-
-    # With saving off nothing would come of an ask, so none is made.
-    def objectives_audit
-      @objectives_audit ||= ObjectivesAudit.new(
-        side: @side_judgments, state_dir: -> { session_state_dir },
-        client_for: lambda do |judgment, session|
-          next nil unless system_one_runs.on?
-
-          system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: ObjectivesAudit::MODE, tag: :system_one),
-                               judgment, session)
-        end
-      )
-    end
-    private :objectives_audit
-
-    # A late proposal no owner prompt mentions (Plugin::Host
-    # #candidate_proposed: github-pr's init task runs beside the first
-    # turn): judged on the owner's prompts so far, the running turn's too.
-    def judge_late_candidates
-      session = @session
-      return if session.nil? || session.review?
-
-      texts = ContextCandidates.owner_texts(plugin_messages)
-      context_judge_pass(session, texts, phase: "late") unless texts.empty?
-    end
-    private :judge_late_candidates
-
-    # One look at +session+'s candidates; the asks go to SideJudgments'
-    # :context kind, one thread asking each due candidate in turn.
-    def context_judge_pass(session, texts, phase:)
-      return if session.id.nil? || session.scratch
-
-      rows = ContextCandidates.with_status(session.id, project_root: session.project_root, state_dir: session_state_dir)
-      return if rows.empty?
-
-      log = ContextCandidatesLog.log_for(session_state_dir)
-      records = ContextCandidatesLog.records_for(log, session.id)
-      ContextCandidatesLog.look(log, session.id, rows, records) if phase == "turn"
-      settings = ContextJudge::Settings.from_config
-      return if settings.mode == "off"
-
-      jobs = ContextJudge.jobs(rows, records, session_id: session.id, texts: texts, settings: settings, phase: phase,
-                                              parent_attached: context_parent_attached(session))
-      return if jobs.empty?
-
-      client = system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :context),
-                                    ContextJudge::JUDGMENT, session, mode: settings.mode)
-      return unless client
-
-      start_context_asks(client, jobs, log, settings, context_choice(session, log, settings))
-    rescue StandardError => e
-      ContextJudge.warn(e)
-    end
-    private :context_judge_pass
-
-    # @return [Thread, nil] the asks' thread, nil when none started
-    def start_context_asks(client, jobs, log, settings, choice)
-      if @side_judgments.in_flight?(:context)
-        Log.info(:context, "context_judge_in_flight_skipped", session_id: jobs.first.session_id)
-        return nil
-      end
-
-      @side_judgments.start(:context, warn: ContextJudge.method(:warn)) do
-        jobs.each { |job| choice.call(job, ContextJudge.ask(client: client, job: job, log: log, settings: settings)) }
-      end
-    end
-    private :start_context_asks
-
-    # What an answer does on the asks' thread (ContextCandidateChoice
-    # #after_judged: on mode attaches or cards; audit nothing). Taken on
-    # the caller's thread. The attach only writes the session's folder: its
-    # note comes with the next between-turn delivery, never into a running
-    # turn. A card shows only while this Engine is still on that session,
-    # and not in a running turn (it isn't the turn's: no "waiting for you"
-    # on it), but once it has ended.
-    # @return [#call] (job, fields)
-    def context_choice(session, log, settings)
-      session_id = session.id
-      project_root = session.project_root
-      state_dir = session_state_dir
-      show = lambda do |**card|
-        current = @session
-        next nil unless current.nil? || current.id == session_id
-
-        @context_cards_mutex.synchronize do
-          next @context_cards_after_turn << card if turn_running?
-
-          show_card(**card)
-        end
-      end
-      lambda do |job, fields|
-        ContextCandidateChoice.after_judged(job: job, fields: fields, settings: settings, project_root: project_root,
-                                            state_dir: state_dir, log: log, show_card: show)
-      end
-    end
-    private :context_choice
-
-    # The cards #context_choice held while a turn ran (#run_turn's ensure,
-    # after the turn flag is released).
-    def show_context_cards_after_turn
-      cards = @context_cards_mutex.synchronize { @context_cards_after_turn.slice!(0..) }
-      cards.each { |card| show_card(**card) }
-    rescue StandardError => e
-      ContextJudge.warn(e)
-    end
-    private :show_context_cards_after_turn
-
-    # A delegate child's parent's sources, by title (else name): the
-    # judge's started_from. nil for any other session (a chi send --new
-    # session has no parent; a fork isn't a delegate).
-    def context_parent_attached(session)
-      return nil unless session.delegate? && session.parent_id
-
-      parent_root = if Session.exist?(session.parent_id, state_dir: session_state_dir)
-                      Session.load(session.parent_id, state_dir: session_state_dir).project_root
-                    else
-                      session.project_root
-                    end
-      ContextSources.attached(session.parent_id, project_root: parent_root, state_dir: session_state_dir)
-                    .map { |attached| attached.source.title || attached.name }
-    rescue StandardError => e
-      Log.warn(:context, "context_parent_attached_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-      []
-    end
-    private :context_parent_attached
-
     # The session's toolkit (see #initialize for when).
     def build_toolkit_binding
       ToolkitBinding.new(
@@ -3574,160 +1189,6 @@ module Samagotchi
     end
     private :build_toolkit_binding
 
-    # The tools changed (a plugin's chi.tools_changed!): the system prompts,
-    # which declare them, are built again on the next turn.
-    def tools_changed!
-      prompt_changed!
-    end
-
-    # A plugin's prompt section would give other text now
-    # (chi.prompt_changed!): the system prompts are built again at their
-    # next build (the next turn's start; a running turn keeps the prompt it
-    # started with). One cache restart: the plugin's command asked first
-    # (Plugin::Context#cache_confirm).
-    def prompt_changed!
-      @prompt_builder&.reset!
-    end
-    public :prompt_changed!
-
-    # What a Plugin::Context reads and calls: the session now, and the
-    # hook runtime's notify and ask_user.
-    def plugin_host
-      Plugin::Host.new(
-        session_id: -> { @session&.id },
-        cwd: -> { @session&.working_directory },
-        messages: -> { plugin_messages },
-        messages_partial: -> { turn_running? && @running_turn_messages.nil? },
-        turn_running: -> { turn_running? },
-        notify: ->(text, level, label, fallback_for: nil) { hook_notify(text, level, label, fallback_for: fallback_for) },
-        ask_user: ->(question) { hook_ask_user(question) },
-        # An init task's is its own (a Ctrl-C ends a turn, not the task).
-        cancelled: lambda {
-          (task = current_init_task) ? task.cancelled? : active_cancel_controller&.cancelled?
-        },
-        card: ->(**card) { show_card(**card) },
-        steer: ->(text, label) { steer(text, source: hook_source(label)) },
-        stop_turn: ->(reason, label) { hook_stop_turn(reason, label) },
-        stop_generation: ->(reason, label) { hook_stop_generation(reason, label) },
-        toolkit: -> { @toolkit_binding.name },
-        declared_tools: -> { toolkit_explained.declared.map(&:name) },
-        use_toolkit: ->(name) { use_toolkit(name) },
-        load_tools: ->(names, bundle) { load_tools(names, bundle) },
-        cancel_controller: ->(handler: false) { plugin_cancel_controller(handler: handler) },
-        ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:, model: nil, source: nil|
-          ask_side_model(request, timeout: timeout, max_tokens: max_tokens, cancel_controller: cancel_controller,
-                                  model: model, source: source)
-        },
-        model_name: -> { effective_model_ref },
-        model_key: -> { @model_binding.model_key },
-        # The names a models: map looks the model up under; [] when it doesn't resolve.
-        model_names: lambda do
-          effective_model.names
-        rescue StandardError
-          []
-        end,
-        state_dir: -> { session_state_dir },
-        scratch: -> { @scratch },
-        setup: -> { SessionSetup.of(@session) },
-        # The files whose text the built system prompt holds; [] until a
-        # build and after a rebuild that drops them (SystemPrompt#prompt_files
-        # returns [] itself: the || keeps a nil builder safe).
-        prompt_files: -> { @prompt_builder&.prompt_files || [] },
-        frontend: -> { interface },
-        cost: -> { @metrics.cost },
-        usage: -> { @metrics.usage },
-        turn_author: -> { turn_author },
-        # A plugin's prompt section is in the stable part: a full re-read.
-        cache_confirm: ->(line, changed) { CacheConfirm.ask(line: line, cost: :full, changed: changed, engine: self) },
-        candidate_proposed: ->(_candidate) { judge_late_candidates },
-        judgments: -> { @judgments }
-      )
-    end
-
-    # The controller a plugin's ctx.http call without cancel: stops with
-    # (docs/plugins.md): an init task's own, else the running turn's for the
-    # turn's own work until the turn has ended (TurnState#own_controller); nil
-    # for an anytime command, a service or a thread of the plugin's.
-    def plugin_cancel_controller(handler:)
-      (task = current_init_task) ? task.cancel : @turn_state.own_controller(handler: handler)
-    end
-    private :plugin_cancel_controller
-
-    # A plugin's ctx.messages: the conversation without the system prompt
-    # (the REPL's starts with it, a worker's new session doesn't), and,
-    # while a turn runs, the turn so far from the Bridge (plan O1). Read
-    # with the event log held, so a turn is in exactly one of the two.
-    def plugin_messages
-      synchronize_events do
-        messages = AnswerDisplay.strip_all(messages_checkpoint)
-        first = messages.first
-        messages = messages.drop(1) if first && first[:role].to_s == "system" && first[:kind].to_s.empty?
-        running = turn_running? && @running_turn_messages ? Array(@running_turn_messages.call) : []
-        messages + running
-      end
-    end
-    private :plugin_messages
-
-    # ctx.ask_model's request: the session's current model on its host, as
-    # a turn resolves them (a /model switch counts), or a configured +model+
-    # (a host:id ref, an alias, a bare id one of a host's models), through its own
-    # IdleClient, so it shares nothing with the turn's backend. The client
-    # is kept while the target and timeout stay (what it learned, e.g. a
-    # refused thinking-off, holds for the next request); the session's id
-    # goes with the request. Its usage counts in the session's side line
-    # (#note_side_usage) under +source+, the asking bundle's name.
-    # @return [String] the answer
-    def ask_side_model(request, timeout:, max_tokens:, cancel_controller:, model: nil, source: nil)
-      target = model.nil? ? session_model_recap_target : configured_side_target(model)
-      client = side_model_client(target, timeout)
-      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      answer = client.ask(request, max_tokens: max_tokens, cancel_controller: cancel_controller, session_id: @session&.id,
-                                   kind: source.to_s.empty? ? "ask" : source.to_s, on_usage: method(:note_side_usage))
-      Log.info(:plugins, "ask_model", model: target.label, answer_model: answer.model, chars: answer.text.length,
-                                      ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
-      answer.text
-    end
-    private :ask_side_model
-
-    # The target of ctx.ask_model(model:): +model+ as a turn resolves it,
-    # once it is known to name something configured. IdleTarget.of_model
-    # never raises (an unknown host falls to the default host, an unknown id
-    # to the default entry), so a typo would silently ask another model.
-    # @raise [ArgumentError] +model+ names no configured host and is no
-    #   host's model (cached, declared or saved lists; nothing is asked)
-    def configured_side_target(model)
-      ref = @host_registry.model_ref(model)
-      unless ref.host_name || ref.alias_name || @host_registry.hosts_with_model(ref.id).any?
-        raise ArgumentError, "ask_model: unknown model #{model.to_s.inspect} (use a configured host:id, an alias, " \
-                             "or a model id one of your hosts lists)"
-      end
-
-      IdleTarget.of_model(@host_registry, model)
-    end
-    private :configured_side_target
-
-    # The IdleClient for +target+ at +timeout+: the last one when both are
-    # the same, else a new one.
-    def side_model_client(target, timeout)
-      @side_client_mutex.synchronize do
-        key = [target, timeout]
-        unless @side_client && @side_client_key == key
-          @side_client = IdleClient.for(target, timeout: timeout)
-          @side_client_key = key
-        end
-        @side_client
-      end
-    end
-    private :side_model_client
-
-    # The session's current model as a recap target: its host's OpenAI API
-    # (native llama.cpp hosts serve /v1/chat/completions too), key variable
-    # and bare model name, as a turn resolves them.
-    # @return [IdleTarget]
-    def session_model_recap_target
-      IdleTarget.of_model(@host_registry, effective_model_name)
-    end
-
     # Build the idle reminders job. Always created (reminders are opt-in
     # via the agent calling register_reminder). The shared IdleScheduler
     # polls it and triggers synthetic turns when reminders are due.
@@ -3743,50 +1204,5 @@ module Samagotchi
         callback: @auto_turn_callback
       )
     end
-
-    # ── Event helpers ──────────────────────────────────────────────────────────
-
-    # The stream handler, the working set and the event fan-out are
-    # EventFanout's (#build_event_fanout); these forward to it.
-    def build_stream_event_handler(...) = @event_fanout.build_stream_event_handler(...)
-    def emit_working_set(...) = @event_fanout.emit_working_set(...)
-    private :emit_working_set
-    def working_set_llm_context = @event_fanout.working_set_llm_context
-    private :working_set_llm_context
-    def with_generation_report(event) = @event_fanout.with_generation_report(event)
-    private :with_generation_report
-    def stream_watch(cancel_controller) = @event_fanout.stream_watch(cancel_controller)
-    private :stream_watch
-    def emit_event(on_event, event) = @event_fanout.emit_event(on_event, event)
-
-    # The effective model's window_tokens and price, read per turn
-    # (SessionModelSettings).
-    def turn_window_setting = @model_settings.turn_window_setting
-    def turn_price = @model_settings.turn_price
-
-    # The snapshots' helpers are EngineSnapshots' (#build_engine_snapshots);
-    # these forward to it.
-    def served_model_for(...) = @engine_snapshots.served_model_for(...)
-    def kit_prompt_stats = @engine_snapshots.kit_prompt_stats
-
-    # The window as +model+'s loop would see it (EffectiveModel#context_window).
-    def current_context_window(model) = model.context_window
-
-    # +settings+' chips (EngineSnapshots#setting_chips).
-    def setting_chips(settings, model) = @engine_snapshots.setting_chips(settings, model)
-
-    # The effective model now, resolved on each call, never kept
-    # (SessionModelSettings#effective_model). Raises as HostRegistry#resolve does.
-    # @return [EffectiveModel]
-    def effective_model(choice = @model_binding.choice) = @model_settings.effective_model(choice)
-
-    # ── Prompt profile ─────────────────────────────────────────────────────────
-
-    # The profile's resolve, keep, apply and retry are ModelBinding's
-    # (#build_model_binding); these forward to it.
-    def resolve_profile(choice) = @model_binding.resolve_profile(choice)
-    def store_profile(choice, resolution) = @model_binding.store_profile(choice, resolution)
-    def apply_profile(resolution) = @model_binding.apply_profile(resolution)
-    def refresh_profile! = @model_binding.refresh_profile!
   end
 end