samagotchi 0.153.0 → 0.154.0

data/lib/samagotchi/engine/questions.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class Engine
+    # Ask-user-question: the model's question (its :question_asked hooks),
+    # and opening, posting, answering and cancelling questions
+    # (QuestionDesk, forwarded). Reads @question_desk, @hooks, @kernel,
+    # @session.
+    module QuestionsPart
+      # ── 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
+    end
+  end
+end

data/lib/samagotchi/engine/recap.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class Engine
+    # The idle recap (IdleRecap) and the shared idle scheduler: the recap job
+    # rebuilt under the bound session's own recap values, /recap's override,
+    # the saved recap. Writes @recap, @recap_awaiting_continue; reads
+    # @recap_built_for, @idle_scheduler, @session.
+    module RecapPart
+      # 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
+
+      # @return [IdleRecap, nil] the idle recap detector, or nil when disabled
+      attr_reader :recap
+
+      # Whether a continue offer waits (the Worker's or the one-shot'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 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.
+      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. SessionManager workers call it so reminders can
+      # trigger turns; a one-shot never starts it and polls nothing.
+      def start_idle
+        @idle_scheduler&.start
+        self
+      end
+
+      # Stop the shared idle scheduler (a worker as it leaves). +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
+    end
+  end
+end

data/lib/samagotchi/engine/session.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class Engine
+    # The bound session and its prompt: #session= (its recap, metrics and
+    # memories), its state dir, the relay's view, and the system prompt with
+    # the memory names it holds. Writes @session, @session_state_dir,
+    # @running_turn_messages; reads @prompt_builder, @metrics, @used_memories,
+    # @question_desk, @state_dir.
+    module SessionPart
+      # @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
+
+      # 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
+
+      # 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 (a one-shot).
+      attr_writer :running_turn_messages
+
+      # 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 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 worker and the one-shot
+      # do, before the first turn, so the messages API and recap see it)
+      def session=(session)
+        @session = session
+        # One session per worker or one-shot 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
+        # one-shot'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
+    end
+  end
+end

data/lib/samagotchi/engine/side_requests.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class Engine
+    # Side requests: a plugin's ctx.ask_model and Check this on their own
+    # IdleClient, their usage in the session's side line, and System 1's
+    # recording of judged asks. Writes @side_client/@side_client_key (under
+    # @side_client_mutex); reads @metrics, @session, @host_registry.
+    module SideRequestsPart
+      # Count one side request (a recap, a plugin's ctx.ask_model: IdleClient's
+      # on_usage) in the session's side line, apart from its turns' totals.
+      # 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
+
+      private
+
+      # +client+ (nil for none) saving its asks as +judgment+'s runs. Anything
+      # going wrong here leaves the client as it was: a run is never worth a
+      # judgment.
+      #
+      # A scratch session's asks aren't saved; a participant's turn is never
+      # judged, so it never comes here.
+      # @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
+
+      # 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
+
+      # 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
+    end
+  end
+end

data/lib/samagotchi/engine/steering.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class Engine
+    # The running turn as other threads see it: steering into it (now or
+    # at the next turn), the drains, the cut, the activity clock and the
+    # cancel. Reads @turn_state and @steer_cut; writes nothing of its own.
+    module SteeringPart
+      # 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 [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
+    end
+  end
+end