samagotchi 0.152.0 → 0.154.0

data/lib/samagotchi/terminal_ui.rb

@@ -2,18 +2,13 @@
 
 require "json"
 require "fileutils"
-require "io/console"
-require "reline"
 
 require_relative "client_id"
 require_relative "iteration_limit"
 require_relative "model_profile"
-require_relative "turn_note"
 require_relative "turn_checkpoint"
 require_relative "config"
 require_relative "context_candidates"
-require_relative "context_note"
-require_relative "cancellation_controller"
 require_relative "llm/errors"
 require_relative "host_registry"
 require_relative "session"
@@ -21,26 +16,15 @@ require_relative "owner_lock"
 require_relative "bridge/card_store"
 require_relative "bridge/pending_card"
 require_relative "engine"
-require_relative "guardrails/parent_approvals"
-require_relative "tools/memory"
-require_relative "output_formatter"
 require_relative "turn_flow"
 require_relative "session_commands"
 require_relative "composer_route"
-require_relative "terminal_ui/attached_view"
-require_relative "terminal_ui/between_turns"
-require_relative "terminal_ui/event_renderer"
+require_relative "degrade"
 require_relative "terminal_ui/formatting"
-require_relative "terminal_ui/gap_clock"
-require_relative "terminal_ui/input_support"
 require_relative "terminal_ui/image_input"
 require_relative "terminal_ui/plain_surface"
-require_relative "terminal_ui/live_region"
 require_relative "terminal_ui/one_shot_sink"
 require_relative "terminal_ui/question_prompt"
-require_relative "terminal_ui/repl_input"
-require_relative "terminal_ui/status_row"
-require_relative "children_status"
 require_relative "log"
 
 module Samagotchi
@@ -48,56 +32,34 @@ module Samagotchi
   # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
-  # The in-process terminal front end (`chi --no-shared`, `chi scratch`,
-  # --verbose, --non-interactive): it owns one session and its Engine, runs
-  # an optional -p prompt (--non-interactive: that one turn and out), then the REPL,
-  # where the user types, the model answers and tools run inline. The
-  # attached terminal (a worker's session) is TerminalUI::AttachedLoop.
+  # The one-shot host: `chi -p TEXT --non-interactive` (`chi scratch`'s and
+  # `--resume ID`'s too) runs that one turn in this process, its answer
+  # alone on stdout, and exits. It owns the session for the turn (an
+  # OwnerLock of kind "tui") and its Engine. Every interactive terminal is
+  # the attached one (TerminalUI::AttachLauncher, AttachedLoop), a client
+  # of the session's worker; the namespace keeps the terminal's parts.
   class TerminalUI
     include Formatting
-    include InputSupport
 
-    SCRATCH_ARCHIVE_REFUSED = "a scratch session is deleted when you leave; nothing to archive"
-    # The prompt while a question waits for its answer (its choices are in
-    # the notes slot).
-    QUESTION_PROMPT = "? "
-    REMINDER_PENDING_POLL_INTERVAL = 0.5
-    # What a command sent during a turn gets, as from a worker (Worker::BUSY_OUTPUT).
-    COMMAND_BUSY = "busy: wait for the turn to end"
-    ROLLBACK_BUSY = "busy: Ctrl-C the turn first, then !rollback"
-    # A command typed during a turn that runs after it (/model X, !cmd).
-    COMMAND_QUEUED = "(queued: runs after this turn)"
-    # /detach is the attached terminal's; the REPL owns its session.
-    REPL_DETACH_NOTE = "(not attached: this session runs in this terminal; /exit ends it)"
-    # /unqueue is the attached terminal's (its worker's queued input files).
-    REPL_UNQUEUE_NOTE = "(/unqueue is the attached terminal's; here a line queued with /queue TEXT runs after the turn)"
-    # A participant's turns run on the session's worker, which an attached
-    # terminal has and this REPL doesn't.
-    REPL_SHARE_NOTE = "(/share and /participants are the attached terminal's: a participant's turns run on the " \
-                      "session's worker; chi share does the same from a shell)"
-    IMAGE_LINE_WAITS = "(a line with images runs as the next turn)"
-
-    # Raised when another process (a `chi web` worker or another chi) owns the
-    # session this TUI was asked to run.
+    # Raised when another process (a worker or another chi) owns the session
+    # this run was asked to use.
     class SessionBusy < StandardError; end
     # --resume with an id that has no saved session.
     class SessionNotFound < StandardError; end
 
-    # What prints between turns (cards, notices, init lines, an idle recap):
-    # announced on other threads, printed at the open prompt.
-    # @return [BetweenTurns]
-    attr_reader :between_turns
-    # The session's Engine: the REPL drives it inline (#run_engine_turn).
+    EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
+
+    # The session's Engine.
     # @return [Engine]
     attr_reader :engine
 
-    # ── System prompts (delegated to Engine) ─────────────────────────────────
     def self.system_prompt_for(profile)
       Engine.system_prompt_for(profile)
     end
 
+    # @param prompt [String, nil] the turn's prompt (-p); nil: nothing runs
     # @param scratch [Boolean] `chi scratch`: a new session that is deleted
-    #   however the REPL ends, saves no memories and writes no recap
+    #   however the run ends, saves no memories and writes no recap
     # @param llm_context [Hash{Symbol => String}] --llm-context* as typed
     #   (LLMContextOverride.update): set on the new or resumed session
     # @param thinking [String, nil] --thinking as typed: the new or resumed
@@ -114,10 +76,10 @@ module Samagotchi
     # @param parent_answers [String, nil] --parent-answers: a new session's
     #   own guardrails.parent_answers; a resumed one keeps its own (named in
     #   +toolkit_flags+ then)
-    def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
-                   spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], settings: nil, parent_answers: nil,
-                   now: -> { MessageTime.now })
+    # @param surface [#commit, nil] where the answer goes (stdout by default)
+    def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, model_name: nil,
+                   memories: [], muted_memories: [], surface: nil, scratch: false, llm_context: {}, thinking: nil,
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], settings: nil, parent_answers: nil)
       @scratch        = scratch
       @parent_answers = parent_answers
       @toolkit        = toolkit
@@ -135,7 +97,7 @@ module Samagotchi
       @host_registry.client_override = client if client
       @client = @host_registry.resolve(@effective_model_name).client
       # Own the session before loading it, so a worker can't write a turn
-      # between the load and the lock that this TUI would later save over.
+      # between the load and the lock that this run would later save over.
       # An unknown id is refused before the claim, which would leave an
       # empty session dir behind.
       if session_id && !Session.exist?(session_id)
@@ -165,8 +127,6 @@ module Samagotchi
       # The model it starts on names a configured host (a bad default.model
       # doesn't matter when --model or the session picks another).
       ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
-      @no_default_input = no_default_input
-      @non_interactive = non_interactive
       # --memory and --mute, with a resumed session's own lists first: a
       # session started attached with mutes keeps them here.
       @requested_memories = Array(memories)
@@ -177,36 +137,14 @@ module Samagotchi
         @muted_memory_names = (@resume_session.muted_memory_names + @muted_memory_names).uniq
         @appended_prompt_files = (@resume_session.appended_prompt_files + @appended_prompt_files).uniq
       end
-      # Every terminal write goes through the surface. The REPL swaps in a
-      # live region when the terminal can show one (#assist_loop), unless it
-      # was given a surface to draw on.
       @surface = surface || PlainSurface.new
-      @surface_given = !surface.nil?
-      # The turn view is the attached TUI's, and so is the status row; both
-      # move to the live region with the surface (#use_surface). A
-      # spinner_tick_interval of nil: no ticker thread, and a spinner_clock
-      # fixes the frames (specs that compare exact frames).
-      view_options = { tick_interval: spinner_tick_interval }
-      view_options[:clock] = spinner_clock if spinner_clock
-      @view = AttachedView.new(@surface, **view_options)
-      @status_row = StatusRow.new(@surface)
-      @renderer = EventRenderer.new(@view)
-      # Cards, notices and a recap announced between turns, printed by the
-      # main thread at the open prompt (#poll_input_with_reminder_check).
-      # The session's last activity, for the gap dividers (+now+: the wall
-      # clock, a Time).
-      @gaps = GapClock.new(now: now)
-      @between_turns = BetweenTurns.new(surface: @surface, view: @view, renderer: @renderer,
-                                        turn_running: -> { @engine.turn_running? }, quiet: @non_interactive,
-                                        gaps: @gaps)
-      @render_event = ->(event) { handle_stream_event(event) }
       @engine = Engine.new(
         client: client,
         host_registry: @host_registry,
         profile: profile,
         session_id: session_id,
-        no_interrupt: no_interrupt,
-        # nil: the config default, unchecked here (the model the REPL starts
+        no_interrupt: true,
+        # nil: the config default, unchecked here (the model the run starts
         # on is checked above, and --model may make the default moot). With
         # no default, the model it runs (the switch below is then skipped).
         model_name: no_default ? @effective_model_name : nil,
@@ -214,30 +152,13 @@ module Samagotchi
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         appended_prompt_files: @appended_prompt_files,
-        scratch: scratch,
-        reminders: {
-          callback: lambda { |due_names|
-            # When a reminder is due, queue a synthetic turn that
-            # run_assist_loop checks before read_input. The synthetic turn
-            # uses an empty prompt so the agent can see
-            # [SYSTEM: REMINDERS DUE <local time>] and act on them.
-            @engine.note_due_reminders(due_names)
-          }
-        }
+        scratch: scratch
       )
-      # -p without --non-interactive drops into the REPL, which can answer
-      # an approval; --non-interactive can't, so an approval there denies.
-      @engine.interface = @non_interactive ? :non_interactive : :repl
-      # A --non-interactive run exits after its turn: no turn-end warm-up.
-      @engine.next_turn_waiting = -> { true } if @non_interactive
-      # A warm-up never pays off while a line typed ahead at the open prompt
-      # (or a left-over steer) already forms the next turn: only prefill when
-      # the prompt is empty. The REPL-only check composes with the one above.
-      next_waiting = @engine.next_turn_waiting
-      @engine.next_turn_waiting = -> { @repl_input&.waiting_input? || next_waiting&.call }
+      # No one is there to answer: an approval denies.
+      @engine.interface = :non_interactive
+      # The run exits after its turn: no turn-end warm-up.
+      @engine.next_turn_waiting = -> { true }
       @turn_flow = TurnFlow.new(engine: @engine)
-      # A recap written while a continue offer waits says the turn stopped
-      # unfinished. (Answering at the prompt is typing: activity already.)
       @engine.recap_awaiting_continue = -> { @turn_flow.awaiting_continue? }
       @commands = SessionCommands.new(engine: @engine, turn_flow: @turn_flow, default_model: @default_model_name,
                                       registry: @engine.command_registry)
@@ -245,48 +166,26 @@ module Samagotchi
       # kernel profile) without persisting the default. Skipped when there's
       # no config default (the Engine was built on the session model).
       @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if !no_default && @effective_model_name != @default_model_name
-      # Render an idle session-recap via the cursor-safe background writer; the
-      # detector itself is Engine-owned (see Engine#recap) and opt-in.
-      @recap_handle = @engine.subscribe(observer: ->(event) { @between_turns.take_recap(event) })
-      @question_handle = @engine.subscribe(observer: ->(event) { handle_question_event(event) })
-      @card_handle = @engine.subscribe(observer: ->(event) { @between_turns.observe(event) })
-      # The REPL renders events from here on: the load warnings and notices
-      # now (at the first prompt), and the plugins' slow setup in the
-      # background. A --non-interactive run leaves both to its turn.
-      unless @non_interactive
-        @engine.announce_load_events!
-        @engine.start_init_tasks!
-      end
-      # Synchronous TUI handler for in-turn ask_user_question: the turn thread IS the
-      # REPL thread (run_engine_turn runs Engine#run_turn inline), so we must render
-      # and collect input on the SAME thread without parking on a second thread.
+      # ask_user_question in the turn: no one can answer it here.
       @engine.set_question_sync_handler do |pending|
-        # render_question_widget records the choice via Engine#answer_question,
-        # which Engine.request_question reads back once this handler returns.
-        render_question_widget(pending)
+        dismiss_unaskable_question(QuestionPrompt.new(pending))
         nil
       end
     end
 
-    # Single dispatch for all entrypoints (interactive REPL, --prompt,
-    # --non-interactive, --resume). Builds the working session and its seed
-    # messages once, runs a single prompt turn when -p/--prompt is given
-    # (auto-executing it, then saving), then either exits when there is no
-    # follow-up REPL (--non-interactive) or drops into the REPL carrying the
-    # post-turn conversation.
-    # @return [Symbol, nil] :turn_failed when lines came from a pipe and a
-    #   turn failed, :empty_answer when a -p --non-interactive turn ended
-    #   with no answer, :iteration_limit when the iteration limit cut that
-    #   turn short (bin/chi exits 1 on all three), :interrupted when Ctrl-C
-    #   cancelled that turn (bin/chi exits 130)
+    # Run the -p prompt as one turn (a session command as that command),
+    # then return; with no prompt, nothing (no session is made).
+    # @return [Symbol, nil] :turn_failed when the turn failed or the command
+    #   was refused, :empty_answer when the turn ended with no answer,
+    #   :iteration_limit when the iteration limit cut it short (bin/chi exits
+    #   1 on all three), :interrupted when Ctrl-C cancelled it (bin/chi
+    #   exits 130)
     def run
-      # --non-interactive with no --prompt is a harmless no-op exit: build
-      # nothing and return (no transient session, no banner).
-      return if @non_interactive && @prompt.nil?
-      # A UI-only command (/stats, /exit …) isn't run without the REPL, and
-      # isn't a prompt either: refused as chi send refuses it, before any
-      # session is made (bin/chi exits 1).
-      return refuse_one_shot_ui_command if @non_interactive && SessionCommands.ui_only_entry(@prompt)
+      return if @prompt.nil?
+      # A UI-only command (/stats, /exit …) isn't run without a terminal,
+      # and isn't a prompt either: refused as chi send refuses it, before
+      # any session is made (bin/chi exits 1).
+      return refuse_one_shot_ui_command if SessionCommands.ui_only_entry(@prompt)
 
       session = @resume_session || @engine.store_model!(Session.new_session(
         mode: "assist",
@@ -310,85 +209,20 @@ module Samagotchi
       warn_toolkit_flags_ignored(session) if @resume_session
       claim_session!(session.id) unless @owner_lock
       # A turn a worker died in (TurnCheckpoint): ended as canceled, with its
-      # note, before this REPL's first turn appends after it.
+      # note, before this run's turn appends after it.
       session.save if @resume_session && TurnCheckpoint.settle(session, session_dir: Session.session_dir(session.id))
       keep_cards(session)
-      # Saved at once, so a process killed before its first turn leaves a
-      # file the sweep knows to delete.
+      # Saved at once, so a process killed before its turn leaves a file
+      # the sweep knows to delete.
       session.save if @scratch
       # Attach before building the prompt so it can name the session id.
       @engine.session = session
-      messages = messages_for(session)
-
-      # As typed at the prompt: a session command (/models, !ls) runs as
-      # the command, not as a turn.
-      return run_one_shot_command(session) if @prompt && @non_interactive && command_registry.command?(@prompt)
-
-      if @prompt && @non_interactive
-        # A /cut TEXT / /queue TEXT prompt runs its text as the turn's
-        # prompt, the same as the idle REPL does (ComposerRoute.steer_choice);
-        # a bare /cut / /queue (no text) is refused above as a UI command,
-        # so only the text here. The images are the text's, not the words'.
-        one_shot_prompt =
-          if (choice = ComposerRoute.steer_choice(@prompt)) && !choice.last.empty?
-            choice.last
-          else
-            @prompt
-          end
-        # Headless / CI mode: run directly without TTY rendering.
-        ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
-        # Retry lines and hook notices on stderr; stdout gets the answer below.
-        sink = OneShotSink.new
-        save_before_first_turn(session)
-        attach_mentioned_context(session, one_shot_prompt)
-        max_iterations = IterationLimit.for(no_interrupt: true)
-        begin
-          result = @engine.run_turn(
-            session,
-            one_shot_prompt,
-            on_event: sink,
-            max_iterations: max_iterations,
-            cancel_controller: nil,
-            images: ImageInput.extract(one_shot_prompt)
-          )
-        rescue LLM::ProviderError, ImageStore::Error => e
-          return one_shot_failed(session, e)
-        rescue Interrupt
-          return one_shot_interrupted(session)
-        end
-        # No answer (the empty-answer retries used up): no text, or the chat
-        # loop's placeholder (LLM::ModelResult#empty_answer?).
-        if result.empty_answer?
-          # Nothing to print: say so on stderr and fail (bin/chi exits 1),
-          # so a script that pipes the answer doesn't take the silence for one.
-          session.save
-          warn EMPTY_ANSWER_ERROR
-          sink.flush
-          return :empty_answer
-        end
-        @surface.commit(result.output)
-        session.save
-        # The after_turn hooks' notices, after the answer as the REPL shows them.
-        sink.flush
-        # The limit cut the turn short: what came so far is no answer, so say
-        # so and fail (bin/chi exits 1), as the REPL's "iteration limit
-        # reached" line does there.
-        return one_shot_exhausted(session, max_iterations) if result.resumable?
+      banner_for(session)
 
-        return
-      end
+      # A session command (/models, !ls) runs as the command, not as a turn.
+      return run_one_shot_command(session) if command_registry.command?(@prompt)
 
-      assist_loop(session: session, messages: messages)
-      # After the idle layer has stopped: nothing writes the session now.
-      case exit_action
-      when :scratch then nil # deleted below, however the REPL ended
-      when :delete then delete_after_exit(session)
-      when :discard then discard_after_exit(session)
-      when :archive then archive_after_exit(session)
-      else keep_after_exit(session)
-      end
-      # Lines from a pipe (`chi -p X </dev/null`): a failed turn fails the run.
-      :turn_failed if @piped_turn_failed
+      run_one_shot_turn(session)
     ensure
       # However it ends (the early returns too; the Engine was built in
       # #initialize): the anytime commands finish, the plugins' services
@@ -397,18 +231,64 @@ module Samagotchi
       # below anyway; the others stay).
       clear_pending_card
       @engine&.shutdown
-      # A scratch session goes on every way out: /exit, Ctrl-D, an error,
+      # A scratch session goes on every way out: the turn's end, an error,
       # SIGTERM or SIGHUP (Ruby raises those here). Only kill -9 leaves it
       # to the sweep.
-      delete_scratch(session, quiet: @non_interactive || !$!.nil?) if @scratch && session
+      delete_scratch(session) if @scratch && session
     end
 
-    EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
+    private
+
+    def command_registry = @commands.registry
+
+    # The turn: its answer on stdout, the retry lines and hook notices on
+    # stderr (OneShotSink).
+    def run_one_shot_turn(session)
+      # A /cut TEXT / /queue TEXT prompt runs its text as the turn's prompt,
+      # as an idle attached terminal does (ComposerRoute.steer_choice); a
+      # bare /cut / /queue (no text) is refused above as a UI command, so
+      # only the text here. The images are the text's, not the words'.
+      prompt =
+        if (choice = ComposerRoute.steer_choice(@prompt)) && !choice.last.empty?
+          choice.last
+        else
+          @prompt
+        end
+      ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
+      sink = OneShotSink.new
+      save_before_first_turn(session)
+      attach_mentioned_context(session, prompt)
+      max_iterations = IterationLimit.for(no_interrupt: true)
+      begin
+        result = @engine.run_turn(session, prompt, on_event: sink, max_iterations: max_iterations,
+                                                   cancel_controller: nil, images: ImageInput.extract(prompt))
+      rescue LLM::ProviderError, ImageStore::Error => e
+        return one_shot_failed(session, e)
+      rescue Interrupt
+        return one_shot_interrupted(session)
+      end
+      # No answer (the empty-answer retries used up): no text, or the chat
+      # loop's placeholder (LLM::ModelResult#empty_answer?).
+      if result.empty_answer?
+        # Nothing to print: say so on stderr and fail (bin/chi exits 1),
+        # so a script that pipes the answer doesn't take the silence for one.
+        session.save
+        warn EMPTY_ANSWER_ERROR
+        sink.flush
+        return :empty_answer
+      end
+      @surface.commit(result.output)
+      session.save
+      # The after_turn hooks' notices, after the answer.
+      sink.flush
+      # The limit cut the turn short: what came so far is no answer, so say
+      # so and fail (bin/chi exits 1).
+      one_shot_exhausted(session, max_iterations) if result.resumable?
+    end
 
-    # The session is over for this process (its exits and the ensure below):
+    # The session is over for this process (its exits and #run's ensure):
     # nothing will resolve the open card any more, so its pending_card.json
-    # goes (the Engine's TURN_END would clear it, but the REPL may end
-    # mid-turn).
+    # goes.
     def clear_pending_card
       return unless @pending_card_handle
 
@@ -416,9 +296,9 @@ module Samagotchi
       @pending_card_handle = nil
     end
 
-    # A -p --non-interactive turn that failed (bin/chi exits 1): the error,
-    # then how to go on. The Engine saved the failed turn with its prompt,
-    # so the session is kept and `chi --resume` takes it up again.
+    # A turn that failed (bin/chi exits 1): the error, then how to go on.
+    # The Engine saved the failed turn with its prompt, so the session is
+    # kept and `chi --resume` takes it up again.
     # @return [Symbol] :turn_failed
     def one_shot_failed(session, error)
       warn "Error: #{@engine.failure_summary(error)}"
@@ -428,8 +308,8 @@ module Samagotchi
       :turn_failed
     end
 
-    # A -p --non-interactive turn the iteration limit cut short: a line on
-    # stderr, with how to go on unless the session goes with this run.
+    # A turn the iteration limit cut short: a line on stderr, with how to go
+    # on unless the session goes with this run.
     # @return [Symbol] :iteration_limit
     def one_shot_exhausted(session, max_iterations)
       line = "chi: the iteration limit (#{max_iterations}) was reached before the turn finished"
@@ -447,7 +327,7 @@ module Samagotchi
       line = @prompt.strip
       result = begin
         @commands.run(line, confirm: false)
-      rescue StandardError => e
+      rescue StandardError => e # degrade-ok: the command's error is its output, and the run fails
         SessionCommands::Result.new(status: :error, output: "#{line.split.first}: #{e.message}", changed: [])
       end
       @surface.commit(result.output) unless result.output.to_s.empty?
@@ -463,10 +343,10 @@ module Samagotchi
       :turn_failed
     end
 
-    # Ctrl-C in a -p --non-interactive turn: the Engine kept the prompt and
-    # a cancel note in the session (it saves only a failed turn), so save
-    # it here: `chi --resume` takes it up again. A scratch session goes in
-    # #run's ensure, so there is nothing to keep.
+    # Ctrl-C in the turn: the Engine kept the prompt and a cancel note in
+    # the session (it saves only a failed turn), so save it here: `chi
+    # --resume` takes it up again. A scratch session goes in #run's ensure,
+    # so there is nothing to keep.
     # @return [Symbol] :interrupted
     def one_shot_interrupted(session)
       return :interrupted if @scratch
@@ -476,77 +356,20 @@ module Samagotchi
       :interrupted
     end
 
-    # Delete the scratch session, the last thing the REPL does. Quiet after
-    # a one-shot or on the way out of an error or a signal.
-    def delete_scratch(session, quiet:)
+    # Delete the scratch session, the last thing the run does.
+    def delete_scratch(session)
       @owner_lock&.release
       @owner_lock = nil
       SessionManager.delete_session(session.id)
-      @surface.commit("Scratch session deleted.") unless quiet
-    rescue StandardError => e
+    rescue StandardError => e # degrade-ok: the line says how to delete it by hand
       warn "Scratch session #{session.id} was not deleted (#{e.message}): chi sessions delete #{session.id}"
     end
 
-    # The session stays: the recap first, then the resume line, last.
-    def keep_after_exit(session)
-      recap_after_exit
-      @surface.commit("\nContinue session: chi --resume #{session.id}")
-    end
-
-    # The recap for coming back: written before the REPL ends (it has to
-    # wait, same process), when there is something new to recap. Ctrl-C
-    # gives up on it.
-    def recap_after_exit
-      @engine.write_recap_now(on_start: -> { @surface.commit("writing a recap…") })
-    rescue Interrupt
-      nil
-    end
-
-    # Nothing happened in the session (SessionManager.discardable?). The
-    # REPL saves only after a turn and keeps /model in its Engine, so a
-    # session never saved is judged from memory, and one on another model
-    # than the default (/model, --model) is kept.
-    def discard_on_exit?(session)
-      SessionManager.discardable?(session.id, default_model: @default_model_name, model_name: @effective_model_name,
-                                              used_memory_names: @engine.used_memory_names, unsaved: session)
-    end
-
-    # A session left empty: give it up and delete it, one quiet line.
-    def discard_after_exit(session)
-      @owner_lock&.release
-      @owner_lock = nil
-      SessionManager.delete_session(session.id)
-      @surface.commit("The session was empty, so it is discarded.")
-    rescue SessionManager::DeleteRefused, SessionManager::OwnedByTUI, ArgumentError, SystemCallError => e
-      @surface.commit("Continue session: chi --resume #{session.id} (the empty session was not discarded: #{e.message})")
-    end
-
-    # /exit --delete: give up the session, then delete it for good.
-    def delete_after_exit(session)
-      @owner_lock&.release
-      @owner_lock = nil
-      SessionManager.delete_session(session.id)
-      @surface.commit("Deleted session #{session.id}.")
-    rescue SessionManager::DeleteRefused, SessionManager::OwnedByTUI, ArgumentError, SystemCallError => e
-      @surface.commit("Session #{session.id} was not deleted (#{e.message}): chi sessions delete #{session.id}")
-    end
-
-    # /archive: give up the session, then archive it (hidden from the lists,
-    # kept for good). An empty one is discarded instead (#discard_on_exit?).
-    def archive_after_exit(session)
-      @owner_lock&.release
-      @owner_lock = nil
-      SessionManager.archive_session(session.id)
-      @surface.commit("Archived session #{session.id}. chi sessions list --archived finds it.")
-    rescue SessionManager::ArchiveRefused, SessionManager::OwnedByTUI, ArgumentError, SystemCallError => e
-      @surface.commit("Session #{session.id} was not archived (#{e.message}): chi sessions archive #{session.id}")
-    end
-
     # The session's cards.json and pending_card.json, kept as a worker's
-    # Bridge keeps them (it owns the session as a worker would): this REPL's
-    # turns go on the same turn log, so a card an earlier worker showed keeps its
-    # place above the turns after it, and its own cards and notices are saved
-    # for the next; an open card with actions is on disk, where
+    # Bridge keeps them (it owns the session as a worker would): this run's
+    # turn goes on the same turn log, so a card an earlier worker showed keeps
+    # its place above the turns after it, and its own cards and notices are
+    # saved for the next; an open card with actions is on disk, where
     # `chi web`'s session hub reads it to mark the session as waiting.
     def keep_cards(session)
       path = File.join(Session.session_dir(session.id), Bridge::CardStore::FILE)
@@ -555,9 +378,7 @@ module Samagotchi
     end
 
     # A card a worker that died left isn't open: the file goes before the
-    # observer takes over, as Bridge#start does. Subscribed once: the REPL
-    # keeps one session, and a second observer would fold every card twice
-    # and clear the file at the first turn's end.
+    # observer takes over, as Bridge#start does.
     def keep_pending_card(session)
       return if @pending_card_handle
 
@@ -566,20 +387,20 @@ module Samagotchi
       @pending_card_handle = @engine.subscribe(observer: pending)
     end
 
-    # A question the session's last owner saved and died with (a worker's,
-    # or another REPL's): this TUI owns the session now, so nobody waits on
-    # it. Dropped and saved, as the worker does (Worker#drop_dead_question).
+    # A question the session's last owner saved and died with (a worker's):
+    # this run owns the session now, so nobody waits on it. Dropped and
+    # saved, as the worker does (Worker#drop_dead_question).
     def drop_dead_question(session)
       id = session.drop_dead_question
       return unless id
 
-      Log.info(:repl, "dead_question_dropped", id: id)
+      Log.info(:turn, "dead_question_dropped", id: id)
       session.save
     end
 
-    # Take the session's OwnerLock for this process's lifetime: the TUI runs
+    # Take the session's OwnerLock for this process's lifetime: the run has
     # its own Engine, so no worker may run the session meanwhile.
-    # @raise [SessionBusy] when a worker or another TUI owns it
+    # @raise [SessionBusy] when a worker or another chi owns it
     def claim_session!(session_id)
       session_dir = Session.session_dir(session_id)
       @owner_lock = OwnerLock.acquire(session_dir, kind: "tui", wait: 1.0)
@@ -591,428 +412,29 @@ module Samagotchi
                          "Close it there first."
     end
 
-    # Build the seed messages for the working session.
-    #
-    # Resumed sessions keep their prior conversation (only the system-prompt
-    # slot is replaced); fresh sessions start with just the system prompt.
-    # Prints a one-line banner so the user sees which session they're in.
-    def messages_for(session)
-      system_message = { role: "system", content: seed_system_prompt }
+    # Which session this is, and a resumed one's recap, before the turn: on
+    # stderr, as stdout is the answer's alone (a script or a parent agent
+    # reads it).
+    def banner_for(session)
       if @resume_session
-        messages = ContextNote.with_system_head(session.messages.dup, system_message)
         banner("Resumed session: #{session.id}")
         saved = @engine.saved_recap
         banner(recap_block(saved[:text], turns_since: saved[:turns_since], at: saved[:created_at])) if saved
-        # The first prompt after a quiet gap has its divider.
-        @gaps.seed(session.messages, fallback: saved&.dig(:created_at))
       elsif @scratch
-        messages = [system_message]
         banner("Scratch session: nothing is kept, it is deleted when you leave.")
       else
-        messages = [system_message]
         banner("Session: #{session.id}")
       end
-      messages
     end
 
-    # A line about the session, not the answer: on stderr in a
-    # --non-interactive run, whose stdout is the answer's alone (a script
-    # or a parent agent reads it), and before the turn, so it comes first.
     def banner(text)
-      return @surface.commit(text) unless @non_interactive
-
       $stderr.puts(text)
       $stderr.flush
     end
 
-    # Interactive REPL loop. Session seed + messages are built by #run and
-    # threaded in here (so --prompt / --resume share one code path). The
-    # session's conversation is the single working copy: turns go through
-    # Engine#run_turn and out-of-turn edits through Engine's messages API.
-    # The checkpoint and continue state live in @turn_flow (shared with
-    # session workers). The session is persisted at the end of every turn.
-    def run_assist_loop(session:, messages:)
-      session.messages = messages
-      @engine.session = session
-      # Steering: lines submitted at the open prompt during a turn
-      # (#steer_line), merged by the kernel (#drain_steering).
-      @pending_input_queue = PendingInputQueue.new
-      open_repl_input
-
-      loop do
-        if @exit_after_turn
-          # Ctrl-D or exit came during a turn: the lines sent before it still
-          # run (all queued: the prompt closed at Ctrl-D), then the REPL ends.
-          input = queued_line
-          break if input.nil?
-        else
-          # Drain any pending ask_user_question first — it has priority over reminders and
-          # must be rendered on the REPL thread (turn thread is parked on Engine Monitor).
-          drain_pending_question?
-
-          # A due reminder runs its turn now, with the prompt open (on a
-          # terminal): the turn's output commits above it and whatever is typed
-          # there stays.
-          unless @engine.due_reminder_names.empty?
-            run_reminder_turn(session)
-            @turn_flow.after_reminder_turn
-            next
-          end
-          input = @prompt
-          @prompt = nil if input
-          if input.nil?
-            input = poll_input_with_reminder_check(awaiting_continue: @turn_flow.awaiting_continue?)
-            # A reminder fell due: run it at the top, with the prompt still open.
-            next if input == :due
-          end
-        end
-        break if input.nil?
-
-        local = local_command(input)
-        if local == :exit
-          @delete_on_exit ||= SessionCommands.delete_on_exit?(input)
-          break
-        end
-        if local == :archive
-          next @surface.commit(SCRATCH_ARCHIVE_REFUSED) if @scratch
-
-          @archive_on_exit = true
-          break
-        end
-        # Not an answer to a continue offer either.
-        next detach_note if local == :detach
-
-        # /stats and /recap run; the offer stays open. So does a session
-        # command (one queued during the turn: /model X, !cmd); /continue
-        # answers it.
-        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local) && !offer_leaves_open?(input)
-          answer_continue_offer(session, input)
-        else
-          # The ? read left no echo: show what ran.
-          @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{input}") if @turn_flow.awaiting_continue?
-          run_input_line(session, input)
-        end
-      end
-
-      close_repl_input
-      @discard_on_exit = !@delete_on_exit && discard_on_exit?(session)
-    end
-
-    # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
-    # Engine#run_turn, rendering via @renderer.
-    # @param images [Array<Hash>] the prompt's `@path` images ({path:})
-    def run_engine_turn(session, prompt, continue: false, max_iterations: IterationLimit.for, images: [], resumed: false, resume_from: nil)
-      cancellation_controller = CancellationController.new
-      @active_cancel_controller = cancellation_controller
-      @renderer.begin_turn
-      # The row shows the turn's model (a -p turn runs before any read).
-      refresh_status_row
-      # A prompt the user typed brings an archived session back to the lists.
-      ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir) if prompt && !continue
-      save_before_first_turn(session)
-      attach_mentioned_context(session, prompt) if prompt && !continue
-      with_steering do
-        @engine.run_turn(
-          session,
-          prompt,
-          on_event: @render_event,
-          max_iterations: max_iterations,
-          cancel_controller: cancellation_controller,
-          pending_input: method(:drain_steering),
-          # A steering line waits (#steer_line): a running task_wait ends for it.
-          input_waiting: -> { !@pending_input_queue.empty? },
-          continue: continue,
-          images: images,
-          resumed: resumed,
-          resume_from: resume_from
-        )
-      end
-    rescue Interrupt
-      # Engine kept the prompt in the session and emitted :turn_canceled
-      # (the renderer's line).
-      cancellation_controller&.cancel!(:ctrl_c)
-      cancelled_result_from(session.messages, reason: :ctrl_c)
-    ensure
-      @active_cancel_controller = nil
-      @view.finish_thinking_spinner
-      # The turn's end is the last activity.
-      @gaps.touch
-    end
-
-    # How the REPL leaves its session once the loop ended (#run): :scratch
-    # (deleted however it ends), :delete (/exit --delete), :discard (left
-    # empty), :archive (/archive) or :keep.
-    def exit_action
-      if @scratch then :scratch
-      elsif @delete_on_exit then :delete
-      elsif @discard_on_exit then :discard
-      elsif @archive_on_exit then :archive
-      else :keep
-      end
-    end
-
-    # The toolkit flags are a new session's: a resumed one keeps its own
-    # toolkit (as attached mode says it, AttachLauncher).
-    def warn_toolkit_flags_ignored(session)
-      return if @toolkit_flags.empty?
-
-      names = @toolkit_flags.size > 1 ? "#{@toolkit_flags[0..-2].join(", ")} and #{@toolkit_flags.last}" : @toolkit_flags.first
-      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id} keeps its own)"
-    end
-    private :warn_toolkit_flags_ignored
-
-    private
-
-    # Interactive REPL loop. Session seed + messages are built by #run and
-    # threaded in here (so --prompt / --resume share one code path). The
-    # working session is persisted at the end of every turn.
-    def assist_loop(session:, messages:)
-      load_persistent_history
-
-      # queue_default_input self-guards on @resume_session, so calling it
-      # unconditionally preserves the original fresh-session prefill behavior.
-      # Skip the default input prefill when a user-provided --prompt was used —
-      # the explicit prompt means the user is in command and shouldn't see the
-      # default input ("Please " etc.) on the next REPL prompt.
-      queue_default_input if @prompt.nil?
-
-      # The idle layer (reminders + optional recap) is Engine-owned; start the
-      # shared scheduler for this REPL and stop it on exit. with_activity_hook
-      # resets the shared inactivity clock when a prompt opens and on each key.
-      with_live_region do
-        with_interrupt_arbiter do
-          @engine.start_idle
-          with_activity_hook do
-            run_assist_loop(session: session, messages: messages)
-          ensure
-            @engine.stop_idle
-          end
-        end
-      end
-    end
-
-    # Ctrl-C while a Reline read owns stdin: Reline's INT trap catches it, so
-    # the REPL hears of it through RelineSeam. A running turn is cancelled and
-    # the prompt stays as typed; with no turn running it is Reline's Ctrl-C.
-    # (With no read open, Ctrl-C stays an Interrupt on the turn's thread.)
-    def with_interrupt_arbiter
-      return yield unless RelineSeam.supported?
-
-      RelineSeam.install
-      previous = RelineSeam.interrupt_handler
-      RelineSeam.interrupt_handler = method(:cancel_turn_from_prompt)
-      begin
-        yield
-      ensure
-        RelineSeam.interrupt_handler = previous
-      end
-    end
-
-    # @return [Boolean] a running turn was cancelled
-    def cancel_turn_from_prompt
-      controller = @active_cancel_controller
-      return false unless controller
-
-      controller.cancel!(:ctrl_c)
-      true
-    end
-
-    # Draw the REPL on a live region (a Screen, with Reline's prompt in it)
-    # when the terminal can show one; plain output otherwise, or on the
-    # surface the UI was given.
-    def with_live_region
-      screen = LiveRegion.open unless @surface_given
-      return yield unless screen
-
-      plain = @surface
-      use_surface(screen)
-      begin
-        yield
-      ensure
-        # Nothing may draw on the screen once it is closed: the view moves
-        # off it, then its ticker ends.
-        use_surface(plain)
-        @view.stop
-        LiveRegion.close(screen)
-      end
-    end
-
-    def use_surface(surface)
-      @surface = surface
-      @view.surface = surface
-      @status_row.surface = surface
-      @between_turns.surface = surface
-    end
-
-    # An answer at the ? prompt of a continue offer. A valid one closes the
-    # offer's choices and leaves one line; an invalid one gets its error.
-    # Whether +input+ is a session command that runs past a continue offer,
-    # leaving it open: any but /continue (the worker's S2).
-    def offer_leaves_open?(input)
-      entry = command_registry.lookup(input)
-      !entry.nil? && entry.id != :continue
-    end
-
-    def answer_continue_offer(session, input)
-      answer = @commands.continue_answer(input, as_parent: as_parent?)
-      if answer.decision == :invalid
-        # The read left no echo: the line shows above its error.
-        @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{input}")
-      else
-        sync_continue_slot(false)
-        @surface.commit(QuestionSlot.continue_summary(input.to_s.strip.empty? ? "yes" : input.to_s.strip, paint: method(:paint)))
-      end
-      return show_command_result(answer) unless answer.resume
-
-      # The run the offer's turn started: the Continue keeps its reasoning.
-      resume_from = @turn_flow.resume_from
-      @turn_flow.before_continue_turn
-      begin
-        result = run_engine_turn(session, nil, continue: true, resumed: true, resume_from: resume_from)
-      rescue LLM::ProviderError
-        # The renderer showed the failure (:turn_failed).
-        @surface.commit(turn_end_hint("continue prompt preserved"))
-        return
-      end
-      finish_turn(session, result, continue: true)
-    end
-
-    # A line at the main prompt: a command, or a prompt for a turn.
-    def run_input_line(session, input)
-      return if input.empty?
-
-      # /cut TEXT and /queue TEXT are deliveries only while a turn runs; at
-      # the prompt both run the text as a normal turn, as their usage says
-      # (the route is the text's).
-      route = ComposerRoute.call(input, running: false, registry: command_registry)
-      return @surface.commit(STEER_CHOICE_USAGE) if route.kind == :usage
-
-      if route.choice
-        input = route.text
-        @surface.commit(STEER_CHOICE_IDLE)
-      end
-
-      # /model, /models, !rollback, !cmd, /continue (shared with workers);
-      # an anytime command's cards print as it shows them (btw's
-      # "thinking…" before the answer). Piped input has nobody to answer a
-      # confirm (the next line is already written): a costly /thinking or
-      # /reasoning-history applies at once.
-      case route.kind
-      when :command
-        confirm = !piped_input?
-        command = if command_registry.anytime?(input)
-                    @engine.running_anytime { @commands.run(input, confirm: confirm) }
-                  else
-                    # A parent's /continue yes is held to guardrails.parent_answers;
-                    # only a person here (not piped, no agent marker) loosens
-                    # /parent-answers.
-                    parent = as_parent?
-                    @commands.run(input, confirm: confirm, as_parent: parent && TurnFlow.continue_yes?(input), user_ui: !parent)
-                  end
-        if command
-          show_command_result(command)
-          refresh_status_row(clear_unknown_context: true) if command.changed.include?(:model)
-          refresh_status_row if command.changed.include?(:title)
-          # /recap and /title don't save themselves (a worker saves a changed command).
-          save_session(session) if command.changed.intersect?(%i[recap title])
-          persist_recent_history(input) if command.shell
-          return
-        end
-      when :local then return if show_local_command(input)
-      # A typo of a command (/modle) is not a prompt: say so, send nothing.
-      when :typo then return @surface.commit(route.reply)
-      end
-
-      @turn_flow.before_prompt_turn
-      persist_recent_history(input)
-      # Off a live region (no echo seam) the divider comes here; after
-      # #gap_above_echo it marks none.
-      mark_activity
-      begin
-        # Engine#run_turn injects due reminders as a tail message, appends
-        # the prompt, and renders through @renderer via on_event.
-        result = run_engine_turn(session, input, images: ImageInput.extract(input))
-      rescue LLM::ProviderError, ImageStore::Error => e
-        # Engine closed the turn (:turn_failed), which the renderer showed.
-        # An @path image that can't be used fails the turn the same way.
-        # The model reads why on its next turn. An image that couldn't be
-        # used, or that the host refused, never reached it: no note for that
-        # (a first turn refused that way leaves the session empty, as before).
-        note = e.is_a?(LLM::ProviderError) && !e.is_a?(LLM::VisionUnsupported)
-        # A turn that got somewhere stays (the renderer said so, and that
-        # !rollback erases it), as the Engine saved it: no prompt goes back.
-        kept = @turn_flow.prompt_turn_failed(error: e, note: note) == :kept
-        # The Engine saved the failed turn; the file follows the rollback.
-        save_session(session) if note || kept
-        if piped_input?
-          # Nobody can edit a restored prompt, and Reline would hand it back
-          # as the next line: the turn would run again and again. It failed;
-          # the exit status says so.
-          @piped_turn_failed = true
-        elsif !kept
-          @surface.commit(turn_end_hint(restore_prompt_for_retry(input)))
-        end
-        return
-      end
-      finish_turn(session, result, continue: false)
-    end
-
-    # After a prompt or continue turn: TurnFlow keeps the checkpoint and the
-    # continue offer; the REPL saves and tells the user.
-    def finish_turn(session, result, continue:)
-      if result.canceled?
-        outcome = @turn_flow.after_turn(result, continue: continue)
-        # A cancelled continue is back where it started, the offer still open.
-        return if outcome == :continue_cancelled
-
-        # Ctrl-C on a fresh turn. The kernel salvaged completed tool calls
-        # and the partial assistant reply (marked [interrupted]) into
-        # result.conversation, so progress is preserved by default — the
-        # user's next message continues from it. !rollback restores the
-        # pre-turn checkpoint for an explicit full discard (the renderer's
-        # hint under :turn_canceled says so).
-        save_session(session) if result.conversation.is_a?(Array)
-        return
-      end
-
-      # The REPL keeps the kernel's conversation as-is (no [No response]
-      # placeholder), so /continue resumes from the tool results; the
-      # answer keeps what the after_turn hooks stored on it.
-      session.messages = with_answer_display(result.conversation, session.messages)
-      @turn_flow.after_turn(result, continue: continue)
-      save_session(session)
-    end
-
-    # The answer's display keys (Engine#store_answer_display put them on the
-    # session's last message) carried onto +conversation+'s last message,
-    # when that is the same answer; +conversation+ as it is otherwise.
-    ANSWER_DISPLAY_KEYS = [AnswerDisplay::KEY, AnswerRefs::KEY].freeze
-    private_constant :ANSWER_DISPLAY_KEYS
-
-    def with_answer_display(conversation, stored)
-      answer = Array(conversation).last
-      kept = Array(stored).last
-      return conversation unless answer.is_a?(Hash) && kept.is_a?(Hash) && message_field(answer, :role).to_s == "model"
-      return conversation unless message_field(kept, :role).to_s == "model" &&
-                                 message_field(kept, :content) == message_field(answer, :content)
-
-      extra = ANSWER_DISPLAY_KEYS.each_with_object({}) do |key, found|
-        value = message_field(kept, key)
-        found[key] = value unless value.nil?
-      end
-      extra.empty? ? conversation : conversation[0...-1] + [answer.merge(extra)]
-    end
-
-    def message_field(message, key) = message.key?(key) ? message[key] : message[key.to_s]
-
-    def save_session(session)
-      @engine.store_model!(session)
-      session.save
-    end
-
     # A fresh session reaches the disk before its first turn: a tool in that
     # turn reads it from there (delegate loads its parent to start a child,
-    # "Session not found" otherwise). Later turns find it saved already.
+    # "Session not found" otherwise).
     def save_before_first_turn(session)
       session.save unless Session.exist?(session.id)
     end
@@ -1026,695 +448,28 @@ module Samagotchi
     rescue Interrupt
       nil
     rescue StandardError => e
-      Log.warn(:context, "candidates_repl_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-    end
-
-    # A !cmd shows its own output; everything else is the model> line. A
-    # change that asks first (CacheConfirm) puts its --yes line in the next
-    # input: Enter applies it.
-    def show_command_result(result)
-      if result.shell
-        @surface.commit(result.output)
-        @surface.commit("")
-      elsif !result.output.nil?
-        @surface.commit("\nmodel> #{result.output}")
-      end
-      queue_input_prefill(result.confirm.line) if result.confirm && !piped_input?
-      sync_model_mirrors if result.changed.include?(:model)
-    end
-
-    # The status line and the next session save read these.
-    def sync_model_mirrors
-      @effective_model_name = @engine.effective_model_name
-      @default_model_name = @commands.default_model
-    end
-
-    # Engine's built-once system prompt (the one run_turn sends).
-    def seed_system_prompt = @engine.system_prompt
-
-    def read_input(awaiting_continue:)
-      refresh_status_row
-
-      if awaiting_continue
-        sync_continue_slot(true)
-        input = Reline.readline(paint(QUESTION_PROMPT, 33), true)
-        return nil if input.nil?
-
-        return input.strip
-      end
-
-      read_prompt_line(paint("> ", 92))
-    rescue Interrupt
-      nil
-    end
-
-    # The synthetic turn for due reminders (Engine#run_turn injects them as
-    # a tail message). The hints row says which, while it runs.
-    def run_reminder_turn(session)
-      names = @engine.due_reminder_names
-      @engine.clear_due_reminder_names!
-      # A normal turn may already have injected them (a stale latch): no
-      # empty synthetic turn then (it duplicated output).
-      return unless @engine.reminders_due?
-
-      # A pending continue offer goes, as for a new prompt (the worker's rule).
-      if @turn_flow.before_reminder_turn
-        sync_continue_slot(false)
-        @surface.commit(QuestionSlot.continue_summary("(dropped: a reminder ran)", paint: method(:paint)))
-      end
-      mark_activity
-      @surface.commit(reminder_line(names))
-      hint = "#{reminder_line(names)} · Ctrl-C cancels it"
-      @surface.set_slot(:hints, [color_output? ? paint(hint, 90) : hint])
-      result = nil
-      begin
-        result = run_engine_turn(session, nil, continue: true)
-        @prompt = nil
-      rescue LLM::ProviderError
-        nil # the renderer showed the failure; back to the prompt
-      ensure
-        @surface.clear_slot(:hints)
-      end
-      canceled = result&.canceled?
-      if result && !canceled
-        session.messages = with_answer_display(result.conversation, session.messages) if result.conversation.is_a?(Array)
-        @engine.store_model!(session)
-        session.save
-      end
-      # The synthetic turn is activity: the next reminder waits a full
-      # interval (without it they fired back to back).
-      @engine.record_activity
-    end
-
-    # The next line from the prompt, or :due when a reminder falls due first.
-    # On a terminal the prompt stays open the whole session (#open_repl_input):
-    # a reminder turn runs with it (and anything typed in it) still there, and
-    # a line submitted meanwhile comes next. Ctrl-C during a turn reaches
-    # #cancel_turn_from_prompt.
-    def poll_input_with_reminder_check(awaiting_continue:)
-      return :due unless @engine.due_reminder_names.empty?
-
-      # Specs and pipes: a plain blocking read.
-      unless @repl_input
-        @between_turns.flush_cards
-        return read_input(awaiting_continue: awaiting_continue)
-      end
-
-      if @idle_status_due
-        @idle_status_due = false
-        refresh_status_row
-      end
-      sync_continue_slot(awaiting_continue)
-      @repl_input.sync_prompt
-      loop do
-        @between_turns.flush_recap
-        @between_turns.flush_cards
-        kind, line = @repl_input.pop(timeout: REMINDER_PENDING_POLL_INTERVAL)
-        if kind
-          # What the line does may change the status (/model, a turn).
-          @idle_status_due = true
-          # Ctrl-C at an idle prompt ends the REPL, as Ctrl-D does.
-          return kind == :line ? line : nil
-        end
-        return :due unless @engine.due_reminder_names.empty?
-      end
-    end
-
-    # On a terminal: one read for the whole session, on a LineReader.
-    def open_repl_input
-      return unless STDIN.tty? && $stdin.tty?
-
-      @idle_status_due = false
-      refresh_status_row
-      @repl_input = ReplInput.new(prompt: method(:repl_prompt_text), read: method(:read_repl_line), surface: @surface).start
-    end
-
-    def close_repl_input
-      @repl_input&.stop
-      @repl_input = nil
-    end
-
-    # The main prompt, or ? when a continue offer waits and no turn runs.
-    def repl_prompt_text
-      return paint("> ", 92) if @active_cancel_controller || !@turn_flow.awaiting_continue?
-
-      paint(QUESTION_PROMPT, 33)
-    end
-
-    # The notes slot shows a continue offer's choices while it waits.
-    def sync_continue_slot(shown)
-      if shown
-        return if @continue_slot
-
-        @continue_slot = true
-        @surface.set_slot(:notes, QuestionSlot.continue_offer(@turn_flow.offer&.dig(:context), paint: method(:paint)))
-      elsif @continue_slot
-        @continue_slot = false
-        @surface.clear_slot(:notes)
-      end
-    end
-
-    # One read on the reader thread (ReplInput): the multiline read with Tab
-    # completion at the main prompt, a plain line for the continue offer and
-    # a question's ? prompt. +prefill+ is typed in first.
-    def read_repl_line(prompt, prefill)
-      queue_input_prefill(prefill) if prefill
-      return RelineSeam.echo_above(method(:gap_above_echo)) { read_prompt_line(prompt) } if prompt == paint("> ", 92)
-
-      read = -> { with_next_input_prefill { Reline.readline(prompt, true) }&.strip }
-      # A question's answer leaves only its summary line.
-      prompt == paint(QUESTION_PROMPT, 33) ? RelineSeam.without_echo(&read) : read.call
-    end
-
-    # Activity starts now: a gap's divider first when one passed since the
-    # last (none while a turn runs: a steer is no gap; none in a
-    # --non-interactive run, whose stdout is the answer's alone).
-    def mark_activity
-      line = @gaps.divider(quiet: @non_interactive || @engine.turn_running?)
-      @surface.commit(gap_divider(line)) if line
-    end
-
-    # The divider above a typed line's echo (RelineSeam.echo_above, on the
-    # reader thread): a prompt typed at the idle prompt after a quiet gap.
-    # It marks the activity, so #run_input_line marks none.
-    def gap_above_echo(text)
-      return nil if @engine.turn_running? || @turn_flow.awaiting_continue?
-
-      route = ComposerRoute.call(text.to_s.strip, running: false, registry: command_registry)
-      return nil unless %i[prompt deliver].include?(route.kind)
-
-      line = @gaps.divider
-      line && gap_divider(line)
-    end
-
-    # Lines come from a pipe or a file (`chi -p X </dev/null`, `echo … | chi`),
-    # not a terminal: no prompt is restored for a retry.
-    def piped_input? = !$stdin.tty?
-
-    # A failed prompt goes back into the input for a retry.
-    # @return [String] what the failed-turn line says about it
-    def restore_prompt_for_retry(input)
-      unless @repl_input
-        queue_input_prefill(input)
-        return "prompt restored for retry"
-      end
-      @repl_input.prefill(input) ? "prompt restored for retry" : "the failed prompt is in the input history (↑)"
-    end
-
-    # The id of the terminal's own command +input+ is (:exit, :archive,
-    # :detach, :stats, :recap; SessionCommands registers them), or nil.
-    def local_command(input) = command_registry.lookup_local(input)&.id
-
-    # /stats and /recap, which show and change nothing (at the prompt, a
-    # continue offer's ? prompt, or during a turn).
-    # @return [Boolean] whether +input+ was one
-    def show_local_command(input)
-      case local_command(input)
-      when :stats then @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
-      when :recap then @surface.commit("\nmodel> #{handle_recap_command}")
-      when :unqueue then @surface.commit(REPL_UNQUEUE_NOTE)
-      when :share, :participants then @surface.commit(REPL_SHARE_NOTE)
-      else return false
-      end
-      true
-    end
-
-    # /recap: the saved recap, and a new one asked for at once when the
-    # chat moved on (it prints when it arrives, BetweenTurns#flush_recap).
-    def handle_recap_command
-      recap = @engine.recap
-      return recap_command_text(enabled: false, session_off: @engine.recap_override == false) unless recap
-
-      saved = @engine.saved_recap
-      request = @engine.turn_running? ? :busy : @engine.request_recap
-      recap_command_text(enabled: true, saved: saved, request: request, min_user_turns: recap.min_user_turns)
-    end
-
-    # A resumed session doesn't get the default input either.
-    def default_input_wanted? = !@resume_session && !@no_default_input
-
-    def clone_messages(messages)
-      Array(messages).map(&:dup)
-    end
-
-    # While a turn runs, a line submitted at the open prompt steers it: it
-    # merges at the next iteration boundary (Kernel), and one that comes after
-    # the last runs as the next turn. Reminder turns too.
-    #
-    # A command that waits for the turn's end (/model X, !cmd) and every line
-    # after it wait in @after_turn, in the order typed (D1), with the image
-    # lines (which never steer) and /queue's: once the turn ends they come
-    # back with the steering it didn't merge, in the order sent (each line
-    # the turn takes gets the next @input_seq), ahead of anything sent after
-    # Ctrl-C.
-    def with_steering(&)
-      return yield unless @repl_input
-
-      @after_turn = []
-      @command_waits = false
-      @input_seq = 0
-      @repl_input.during_turn(method(:steer_line), leftovers: -> { leftover_lines }, &)
-    end
-
-    # The turn's leftovers in send order: steering it didn't merge and the
-    # lines that waited for its end.
-    def leftover_lines
-      (@pending_input_queue.drain_entries + lines_after_turn).sort_by { |seq, _| seq || 0 }.map(&:last)
-    end
-
-    # The next line's place in send order (#leftover_lines).
-    def next_input_seq
-      @input_seq = (@input_seq || 0) + 1
-    end
-
-    # The [seq, line] entries that waited for the turn's end, taken from
-    # @after_turn. After a canceled or failed turn (Ctrl-C raises through
-    # here; a failure too) a !cmd among them is dropped (D4): running it
-    # would close the !rollback the turn left.
-    def lines_after_turn
-      entries = @after_turn.slice!(0..)
-      ended = if @active_cancel_controller&.cancelled? || $!.is_a?(Interrupt) then "canceled"
-              elsif $! then "failed"
-              end
-      return entries unless ended
-
-      entries.reject do |_seq, line|
-        next false unless command_registry.lookup(line)&.id == :shell
-
-        @surface.commit("turn #{ended}: #{line.strip} not run; send it again")
-        true
-      end
-    end
-
-    # On the reader thread, from ReplInput: takes a line for the running turn.
-    # A line sent after Ctrl-C waits for the next turn (the kernel would not
-    # merge it into the cancelled one). Ctrl-D or exit ends the REPL after
-    # the turn. /stats and /recap run now, an anytime command (/help, a
-    # plugin's /btw, /model alone) starts now on its own thread; one that
-    # runs after the turn (/model X, !cmd) waits in the queue, in arrival
-    # order with the other lines that wait; others go back in the prompt.
-    #
-    # A plain line goes in at the running turn's next step boundary and
-    # never cuts; /cut TEXT asks for a cut, /queue TEXT waits for the turn
-    # to end and runs as a turn of its own.
-    # @return [Boolean, :back] whether the turn took it, :back to put it back
-    def steer_line(line)
-      route = ComposerRoute.call(line, running: true, registry: command_registry) unless line.nil?
-      local = route&.local
-      return exit_after_turn(delete: SessionCommands.delete_on_exit?(line)) if line.nil? || local == :exit
-      return archive_after_turn if local == :archive
-      return detach_note if local == :detach
-      return false if @active_cancel_controller&.cancelled?
-
-      case route.kind
-      # Before every command check (ComposerRoute): /cut and /queue are the
-      # UIs' own words for a delivery (listed for Tab and /help, never run).
-      when :usage
-        @surface.commit(STEER_CHOICE_USAGE)
-        return true
-      when :deliver then return submit_steer_choice(route.delivery, route.text)
-      when :command
-        policy = command_registry.mid_turn(line)
-        return start_anytime_command(line) if policy == :anytime
-        return command_queued(line) if policy == :queue
-      end
-      # A command, never steering text.
-      return command_during_turn(line) if %i[local command].include?(route.kind)
-      return true if route.kind == :empty
-
-      # A typo of a command (/modle) is not steering text: say so, take it.
-      if route.kind == :typo
-        @surface.commit(route.reply)
-        return true
-      end
-      # Steering merges text only: a line with images runs as the next turn.
-      return image_line_waits(line) if ImageInput.extract(line).any?
-      # Behind a command that waits for the turn's end, a line waits too.
-      return wait_for_turn_end(line) if @command_waits
-
-      @pending_input_queue.push(route.text, seq: next_input_seq)
-      @surface.commit(NEXT_STEP_NOTE)
-      true
-    end
-
-    # /cut TEXT and /queue TEXT during a turn, which the REPL would
-    # otherwise read as prompts (SessionCommands registers them for Tab and
-    # help only). A cut asks the engine to cut the generation only thinking
-    # too long; a queue waits for the turn's end (the REPL's own after-turn
-    # list). A line with images never steers (as a plain one doesn't).
-    # @param delivery [String] Delivery::CUT or Delivery::QUEUE (ComposerRoute)
-    # @return [Boolean] whether the turn took it
-    def submit_steer_choice(delivery, text)
-      return image_line_waits(text) if ImageInput.extract(text).any?
-
-      # A /queue waits for the turn's end; a /cut behind a command that
-      # already waits there goes after it too.
-      if Delivery.queue?(delivery) || @command_waits
-        @surface.commit(COMMAND_QUEUED)
-        return wait_for_turn_end(text)
-      end
-
-      epoch = @engine.input_epoch
-      @pending_input_queue.push(text, seq: next_input_seq)
-      # With no session running the cut is :off; the text still waits for
-      # the running turn's next step.
-      @surface.commit(steer_cut_note(@engine.cut_for_steer(nil, epoch: epoch), @engine.steer_cut_after))
-      true
-    end
-
-    def image_line_waits(line)
-      @surface.commit(IMAGE_LINE_WAITS)
-      wait_for_turn_end(line)
-    end
-
-    # +line+ runs once the turn has ended, in the order typed (#with_steering).
-    # @return [true] the turn took it
-    def wait_for_turn_end(line)
-      @after_turn << [next_input_seq, line]
-      true
-    end
-
-    def detach_note
-      @surface.commit(REPL_DETACH_NOTE)
-      true
-    end
-
-    # /archive during a turn (D2): the REPL leaves and archives once the
-    # turn and the lines queued behind it (S5) ran, as /exit does.
-    # @return [true]
-    def archive_after_turn
-      return @surface.commit(SCRATCH_ARCHIVE_REFUSED).then { true } if @scratch
-
-      @exit_after_turn = true
-      @archive_on_exit = true
-      @surface.commit("(archives after this turn; Ctrl-C cancels it)")
-      true
-    end
-
-    def exit_after_turn(delete: false)
-      @exit_after_turn = true
-      @delete_on_exit = true if delete
-      @surface.commit(delete ? "(exits after this turn and deletes the session; Ctrl-C cancels the turn)" : "(exits after this turn; Ctrl-C cancels it)")
-      true
-    end
-
-    # A line already queued (none waits for input), or nil.
-    def queued_line
-      kind, line = @repl_input&.pop(timeout: 0)
-      kind == :line ? line : nil
-    end
-
-    # @return [true, :back]
-    def command_during_turn(line)
-      return true if show_local_command(line)
-
-      @surface.commit(command_registry.lookup(line)&.id == :rollback ? ROLLBACK_BUSY : COMMAND_BUSY)
-      :back
-    end
-
-    # @return [true] it waits for the turn's end (#wait_for_turn_end)
-    def command_queued(line)
-      @surface.commit(COMMAND_QUEUED)
-      @command_waits = true
-      wait_for_turn_end(line)
-    end
-
-    # D8: an anytime command runs on its own thread while the turn goes on
-    # (it reads copies, and shows things through its ctx). What it prints
-    # while the turn runs goes above the live region now, its cards as it
-    # shows them (BetweenTurns#observe); once the turn has ended it waits for
-    # the prompt's flush.
-    # @return [true]
-    def start_anytime_command(line)
-      @engine.spawn_anytime do
-        output = @engine.running_anytime { @commands.run(line) }&.output
-        @between_turns.show_or_keep({ type: :command_output, text: "\nmodel> #{output}" }) unless output.nil?
-      rescue StandardError => e
-        @between_turns.keep({ type: :command_output, text: "\nmodel> #{line.split.first}: #{e.message}" })
-      end
-      true
-    end
-
-    # The kernel's drain at an iteration boundary: queued lines, sent as
-    # typed and saved in the history.
-    def drain_steering
-      @pending_input_queue.drain.map do |line|
-        persist_recent_history(line)
-        line
-      end
-    end
-
-    # The REPL's on_event sink for Engine#run_turn: render one event, after
-    # taking what the status row shows from it (as AttachedLoop does from the
-    # Bridge's). Engine swallows on_event errors to protect the turn, so log
-    # ours instead.
-    def handle_stream_event(event)
-      @status_row.take_event(event)
-      @renderer.call(event)
-    rescue StandardError => e
-      Log.error(:repl, "render_failed", echo: "[render] #{event[:type]}: #{e.class}: #{e.message}", event_type: event[:type].to_s, error: e.class.name)
-    end
-
-    def cancelled_result_from(messages, reason:)
-      LLM::ModelResult.new(text: "", conversation: clone_messages(messages), canceled: true, cancellation_reason: reason)
-    end
-
-    # The status row under the prompt, from the Engine's state (what a
-    # worker hands an attached TUI when it joins): drawn when it changed.
-    def refresh_status_row(clear_unknown_context: false)
-      state = @engine.session_state_snapshot.merge(model_name: @effective_model_name)
-      @status_row.take_state(state, default_model: @default_model_name)
-      @status_row.update(context: nil) if clear_unknown_context && state.key?(:context_status) && state[:context_status].nil?
-      refresh_children_status
-    end
-
-    # The status row's children segment: this session's delegates, read
-    # from their files (ChildrenStatus.counts) wherever the row is drawn
-    # again. Not read with status.line off; a failed read keeps the row.
-    def refresh_children_status
-      id = @engine.session&.id
-      return unless id && @status_row.enabled?
-
-      @status_row.update(children: ChildrenStatus.counts(id, state_dir: @engine.peer_state_dir || Session.default_state_dir))
-    rescue StandardError => e
-      Log.debug(:repl, "children_counts_failed", error: e.class.name)
-    end
-
-    # Reset the Engine's shared inactivity clock when a prompt opens (a
-    # Reline.pre_input_hook) and on each key typed (RelineSeam.key_handler). This is the
-    # single seam the Engine-owned idle recap detector reads, so the idle clock
-    # is identical for the REPL and any other Engine-backed UI. Chains onto any
-    # previously-installed hook (e.g. the input prefill hook).
-    def with_activity_hook
-      previous_hook = Reline.pre_input_hook
-      previous_key_handler = RelineSeam.key_handler
-      Reline.pre_input_hook = proc do
-        @engine.record_activity
-        previous_hook.call if previous_hook
-      end
-      # Typing is activity too: a reminder waits while you type.
-      RelineSeam.key_handler = -> { @engine.record_activity }
-      yield
-    ensure
-      Reline.pre_input_hook = previous_hook
-      RelineSeam.key_handler = previous_key_handler
-    end
-
-    # ── Ask-user-question adapter (generic TUI renderer) ─────────────────────
-
-    # Non-blocking observer: the turn thread emits :question_requested; we stash
-    # it so the REPL thread (the only one that may touch Reline) can drain it
-    # at the top of run_assist_loop without racing the completion.
-    def handle_question_event(event)
-      return unless event.is_a?(Hash)
-
-      type = event[:type] || event["type"]
-      return unless type.to_s == "question_requested"
-
-      pq = event[:pending_question] || event["pending_question"]
-      return unless pq
-
-      @pending_question_event = pq
-    rescue StandardError
-      nil
-    end
-
-    # Called from REPL thread (run_assist_loop top) — renders widget, blocks
-    # until user selects, then answers via Engine#answer_question which wakes
-    # the parked turn thread.
-    def drain_pending_question?
-      pq = @pending_question_event
-      # Also check Engine's persisted pending (covers resume)
-      pq ||= @engine.pending_question&.to_h
-      return false unless pq
-
-      # If the pending no longer matches the engine's current pending (stale
-      # event after sync handler already answered and cleared), discard.
-      current = @engine.pending_question
-      if current && (pq[:id] || pq["id"]).to_s != current.id.to_s
-        @pending_question_event = nil
-        return false
-      end
-      if current.nil? && @pending_question_event
-        # Stale stash where engine already cleared (sync path completed)
-        @pending_question_event = nil
-        return false
-      end
-
-      @pending_question_event = nil
-      result = render_question_widget(pq)
-      return false unless result
-
-      # result is already answered via Engine#answer_question in render_question_widget
-      true
-    rescue StandardError => e
-      Log.warn(:repl, "question_drain_failed", echo: "[ask_user_question] drain failed: #{e.class}: #{e.message}", error: e.class.name)
-      false
+      Log.warn(:context, "candidates_one_shot_failed", error: e.class.name, msg: e.message.to_s[0, 200])
     end
 
-    # The choices wait in the notes slot, laid out for the rows it gets, and
-    # the answer is a line at the ? prompt. Once the question closes, one
-    # line (the question and what became of it) stays in the scrollback.
-    def render_question_widget(pending)
-      prompt = QuestionPrompt.new(pending)
-
-      # The activity row goes while the question waits.
-      @view.finish_thinking_spinner
-      return dismiss_unaskable_question(prompt) if @non_interactive
-
-      # An edit's diff goes above the slot, into the scrollback.
-      preview = prompt.preview_lines(paint: method(:paint))
-      @surface.commit(preview.join("\n")) unless preview.empty?
-      choices = prompt.slot(paint: method(:paint))
-
-      question_prompt = paint(QUESTION_PROMPT, 33)
-      unless @repl_input
-        @surface.set_slot(:notes, choices)
-        return answer_question_widget(prompt) { read_choice_line(question_prompt) }
-      end
+    # The toolkit flags are a new session's: a resumed one keeps its own
+    # toolkit (as attached mode says it, AttachLauncher).
+    def warn_toolkit_flags_ignored(session)
+      return if @toolkit_flags.empty?
 
-      # On a terminal the prompt is open (a turn runs with it): it turns into
-      # the ? prompt for the answer. Only a line submitted there answers,
-      # never one typed before the question came. The choices show once the
-      # typed text is out of the prompt.
-      @repl_input.ask(question_prompt) do |answers|
-        @surface.set_slot(:notes, choices)
-        answer_question_widget(prompt) { take_open_prompt_answer(answers) }
-      end
-    ensure
-      @surface.clear_slot(:notes)
+      names = @toolkit_flags.size > 1 ? "#{@toolkit_flags[0..-2].join(", ")} and #{@toolkit_flags.last}" : @toolkit_flags.first
+      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id} keeps its own)"
     end
 
-    # --non-interactive has no one to ask (as for an approval or a hook's
-    # question there): the question is dismissed at once, as an empty answer
-    # would be, and the model finishes its reply. Never a read of stdin: a
-    # pipe its writer keeps open would block it forever. Its one line goes to
-    # stderr (#banner): stdout is the answer's alone. The model is told no
-    # one could answer (QuestionDesk::UNANSWERABLE_NOTE), not that the user
-    # dismissed it.
+    # No one is here to ask (as for an approval or a hook's question): the
+    # question is dismissed at once, as an empty answer would be, and the
+    # model finishes its reply. Never a read of stdin: a pipe its writer
+    # keeps open would block it forever. Its one line goes to stderr. The
+    # model is told no one could answer (QuestionDesk::UNANSWERABLE_NOTE),
+    # not that the user dismissed it.
     def dismiss_unaskable_question(prompt)
-      @engine.cancel_question(QuestionDesk::UNANSWERABLE_REASON) rescue nil
+      Degrade.call(:turn, "question_dismiss_failed") { @engine.cancel_question(QuestionDesk::UNANSWERABLE_REASON) }
       banner(prompt.summary(QuestionPrompt::UNANSWERABLE_TEXT, paint: method(:paint)))
       false
     end
-
-    # Loop until a valid selection or a cancel. The block reads one answer:
-    # a line, nil (Ctrl-D, or Ctrl-C with no turn), or :canceled (the turn
-    # was cancelled).
-    def answer_question_widget(prompt)
-      loop do
-        @choice_echoed = false
-        raw = begin
-          yield
-        rescue Interrupt
-          nil
-        end
-        raw = raw.to_s.strip unless raw.nil? || raw == :canceled
-        if raw.nil? || raw == :canceled || raw.empty?
-          # Empty, EOF / Ctrl-D / Ctrl-C -> cancel (an approval: denied)
-          @engine.cancel_question("user") rescue nil
-          outcome = if raw == :canceled then "(turn cancelled)"
-                    elsif prompt.approval? then "(denied)"
-                    else "(cancelled)"
-                    end
-          close_question_widget(prompt, outcome)
-          return false
-        end
-
-        answer = prompt.parse(raw)
-        @surface.commit(answer.note) if answer.note
-        unless answer.ok?
-          # The read left no echo: the line shows above its error.
-          echo_choice(raw)
-          @surface.commit(answer.error)
-          next
-        end
-
-        begin
-          parent = as_parent? ? { client_id: ClientId::CLI_ANSWER } : {}
-          @engine.answer_question(id: prompt.id, selected: answer.selected, freeform: answer.freeform, **parent)
-          close_question_widget(prompt, prompt.answer_text(answer))
-          return true
-        rescue QuestionDesk::Refused => e
-          # A parent's pick its strategy doesn't let through
-          # (Guardrails::ParentPolicy): the question stays open for a deny
-          # (or the end of the input).
-          echo_choice(raw)
-          @surface.commit(e.detail(typed: true))
-          next
-        rescue ArgumentError => e
-          @surface.commit("Invalid: #{e.message}. Try again.")
-          next
-        rescue StandardError => e
-          close_question_widget(prompt, "(error: #{e.message})")
-          return false
-        end
-      end
-    end
-
-    # Whether the answers typed here are a parent agent's (piped stdin, an
-    # agent marker): QuestionDesk holds them to Guardrails::ParentPolicy.
-    def as_parent?
-      Guardrails::ParentApprovals.parent_process?
-    end
-
-    def close_question_widget(prompt, outcome)
-      @surface.clear_slot(:notes)
-      @surface.commit(prompt.summary(outcome, paint: method(:paint)))
-    end
-
-    # A ? read of its own, off a terminal (specs, pipes): $stdin.gets.
-    def read_choice_line(question_prompt)
-      # Off a terminal the ? prompt can't be taken back: at the input's end
-      # it would stay bare above the summary. eof? waits as gets would.
-      return nil if !$stdin.tty? && $stdin.eof?
-
-      @surface.set_slot(:editor, [question_prompt])
-      line = $stdin.gets
-      # A pipe doesn't echo: the line completes the ? prompt here, once,
-      # and the widget doesn't echo it again (#echo_choice).
-      unless $stdin.tty?
-        @surface.commit(line.to_s.chomp)
-        @choice_echoed = true
-      end
-      line
-    end
-
-    # The answer line above its error, unless its read echoed it already.
-    def echo_choice(raw)
-      @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{raw}") unless @choice_echoed
-    end
-
-    # The next line submitted at the open prompt (?), nil for Ctrl-D
-    # or a Ctrl-C with no turn running, or :canceled when Ctrl-C cancels the
-    # running turn first (the read goes on; the question closes).
-    def take_open_prompt_answer(answers)
-      controller = @active_cancel_controller
-      loop do
-        kind, line = answers.pop(timeout: REMINDER_PENDING_POLL_INTERVAL)
-        return kind == :line ? line : nil if kind
-        return :canceled if controller&.cancelled?
-      end
-    end
   end
 end