samagotchi 0.124.0 → 0.126.0

data/lib/samagotchi/session_participants.rb

@@ -22,8 +22,10 @@ module Samagotchi
     end
 
     # Reads +session+'s sidecar again.
+    # A Verify fresh child reads its parent's (Session#participants_source_id):
+    # its requester's grant is there.
     def refresh!(session)
-      @session_id = session&.id
+      @session_id = source_id(session)
       @entries = read
       self
     end
@@ -44,7 +46,7 @@ module Samagotchi
     def entry_for(author, session: nil)
       return nil unless Steer.participant_author?(author)
 
-      refresh!(session) if session && session.id != @session_id
+      refresh!(session) if session && source_id(session) != @session_id
       id = Steer.participant_id(author)
       @entries.find { |e| e.id == id } || (@entries = read).find { |e| e.id == id }
     end
@@ -62,6 +64,12 @@ module Samagotchi
 
     private
 
+    def source_id(session)
+      return nil unless session
+
+      session.respond_to?(:participants_source_id) ? session.participants_source_id : session.id
+    end
+
     def read
       return [] if @session_id.to_s.empty?
 

data/lib/samagotchi/sessions_command.rb

@@ -34,7 +34,7 @@ module Samagotchi
              [--scope=all]: every project's sessions; by default only this git project's (all outside a repo)
              --archived: archived sessions too (marked [archived]; json: archived: true)
         stop ID...   # stop each session's worker (IDs or unique prefixes); chi --resume ID then starts a fresh one
-        restart ID...   # hand each session to a new worker on the newest chi installed; refused while a turn, question or reminder would be lost
+        restart ID...   # hand each session to a new worker on the newest chi installed; keeps its reminders; refused while a turn or question would be lost
         archive ID...   # hide sessions (and their delegates) from every list and keep them for good; unarchive ID... brings them back
         delete [--force] ID...   # delete sessions for good (IDs or unique prefixes); --force stops a live worker first
         prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]

data/lib/samagotchi/terminal_ui/attached_loop/composer.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "../../composer_route"
+require_relative "../../prompt_history"
+require_relative "../../session_commands"
+require_relative "../exit_lines"
+require_relative "../reline_seam"
+
+module Samagotchi
+  class TerminalUI
+    class AttachedLoop
+      # Input composition and Ctrl-C handling for the attached loop.
+      # Reads @client, @clock, @command_registry, @continue_offer, @exit_ask,
+      # @gaps, @link, @prefilled, @question, @queue, @queued_ids, @reader,
+      # @running, @screen; writes @prefilled, @last_idle_interrupt_at.
+      # Calls the loop helpers #answer_continue, #answer_exit_ask, #answer_question,
+      # #archive_after_turn, #command_registry, #detach, #echo_answer, #exit_and_archive,
+      # #exit_and_delete, #exit_worker, #gap_divider, #participant_commands, #persist_recent_history,
+      # #queue_input_prefill, #read_prompt_line, #send_command, #send_prompt,
+      # #show_recap, #show_stats, #submit_delivery, #unqueue_newest, #via, and
+      # #worker_down.
+      module Composer
+        private
+
+        # A divider above a typed line's echo (RelineSeam.echo_above, on the
+        # reader thread): a prompt typed after a quiet gap, at an idle prompt.
+        # It marks the activity, so the turn's start marks no second one.
+        def gap_above_echo(text)
+          return nil if @running
+
+          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
+
+        # @return [Symbol, nil] :detach to end the loop
+        def submit(line)
+          if @exit_ask
+            # The exit ask is open: this line answers it. Ctrl-D and /detach
+            # detach without stopping anything, the way its 1 does.
+            return detach(ExitLines.kept_line(@exit_ask, via: via, session_id: @client.session_id)) if line.nil? ||
+                                                                                                       command_registry.lookup_local(line.strip)&.id == :detach
+
+            return answer_exit_ask(line)
+          end
+
+          return detach("Detached; the session keeps running. Re-attach with: #{via.attach(@client.session_id)}") if line.nil?
+
+          text = line.strip
+          if @question
+            # /detach leaves the question open, as Ctrl-D does; any other
+            # line (/exit too) is read as the answer.
+            return submit(nil) if command_registry.lookup_local(text)&.id == :detach
+
+            return answer_question(text)
+          end
+
+          text, kept = split_prefilled(text)
+          submitted = submit_line(text)
+          # The removed text the command was typed after, back in the input
+          # (unless an /unqueue put its own there, or the loop ends). Set
+          # before the read restarts with it: the read's echo reads it.
+          if kept && submitted != :detach && @prefilled.nil?
+            @prefilled = kept
+            @prefilled = nil unless @reader&.prefill(kept)
+          end
+          submitted
+        end
+
+        # A line typed after an /unqueue's text (#unqueued) without clearing
+        # it, the text untouched and then a command ("fix it/unqueue"): the
+        # command alone, and the text to put back. Any other line as is.
+        # @return [Array(String, String|nil)]
+        def split_prefilled(text)
+          kept = @prefilled
+          @prefilled = nil
+          rest = command_after(text, kept)
+          rest ? [rest, kept] : [text, nil]
+        end
+
+        # The command typed after +kept+ (/unqueue's text) in +text+, or nil.
+        # @return [String, nil]
+        def command_after(text, kept)
+          return nil unless kept && text.length > kept.length && text.start_with?(kept)
+
+          rest = text[kept.length..].strip
+          route = ComposerRoute.call(rest, running: @running, registry: command_registry)
+          rest if route.choice || %i[local command usage].include?(route.kind)
+        end
+
+        # The read's echo (RelineSeam.echo_as, on the reader thread): the
+        # command alone when one is typed after /unqueue's text, as
+        # #split_prefilled runs it; nil echoes the line as typed.
+        def prefilled_echo(typed) = command_after(typed.strip, @prefilled)
+
+        # @return [Symbol, nil] :detach to end the loop
+        def submit_line(text)
+          # /cut TEXT and /queue TEXT are this UI's own deliveries, read before
+          # every command check (ComposerRoute; SessionCommands registers them
+          # for Tab and /help only). A plain line sends no delivery: it goes in
+          # at the running turn's next step, and never cuts.
+          route = ComposerRoute.call(text, running: @running, registry: command_registry)
+          return submit_delivery(route) if route.choice
+
+          # The terminal's own commands (SessionCommands registers them, the
+          # REPL reads the same words). Before the continue offer: the
+          # leaving ones are no answer to it.
+          local = route.local
+          return submit(nil) if local == :detach
+          return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
+          return archive_after_turn if local == :archive && (@running || !@queued_ids.empty?)
+          return exit_and_archive if local == :archive
+
+          if @continue_offer
+            return answer_continue(text) unless local || route.kind == :command
+
+            # Not an answer: the read left no echo, so show what ran.
+            echo_answer(text)
+          end
+          return if route.kind == :empty
+
+          if local == :stats
+            show_stats
+          elsif local == :recap
+            show_recap
+          elsif local == :unqueue
+            unqueue_newest
+          elsif %i[share participants].include?(local)
+            @screen.commit(participant_commands.run(text))
+          elsif route.kind == :command
+            # The history keeps !cmds, as the REPL's does (prompts: #send_prompt).
+            persist_recent_history(text) if PromptHistory.shell_line?(text)
+            send_command(text)
+          elsif route.kind == :typo
+            # A typo of a command (/modle) is not a prompt: say so, send nothing.
+            @screen.commit(route.reply)
+          else
+            send_prompt(text)
+          end
+          nil
+        end
+
+        # One read on the reader thread: the REPL's multiline read with Tab
+        # completion at the main prompt, a plain line for a question's choice
+        # or the continue offer's answer.
+        def read_input_line(prompt, prefill)
+          return $stdin.gets&.chomp unless $stdin.tty?
+          # A question's answer leaves only its summary line.
+          return RelineSeam.without_echo { Reline.readline(prompt, true) } if @question || @continue_offer
+
+          queue_input_prefill(prefill) if prefill
+          read_prompt_line(prompt)
+        end
+
+        # The attached TUI's commands, for Tab.
+        def slash_commands = command_registry.completions(:attached)
+
+        # @path and #memory candidates, as the link offers them
+        # (AttachLink#completions).
+        def build_project_path_completion_candidates(path_fragment)
+          @link.completions.paths ? super : []
+        end
+
+        def build_memory_completion_candidates(memory_fragment)
+          @link.completions.memories ? super : []
+        end
+
+        # The session's commands as its worker's snapshot names them (its
+        # plugins' too); the built-ins until one arrives, or from a worker too
+        # old to name them. An unknown /foo is a prompt, as in the REPL.
+        def command_registry = @command_registry || SessionCommands.builtin_registry
+
+        # Ctrl-C cancels the running turn (whoever started it). At an idle
+        # prompt it clears the line; on an empty one it says how to detach, and
+        # a second press within DETACH_WINDOW detaches (D4).
+        # @param pressed [Hash, nil] {text:, at:} from the read the press ended
+        #   (nil: pressed with no read open)
+        # @return [Symbol, nil] :detach
+        def interrupt(pressed = nil)
+          typed = pressed&.fetch(:text, nil).to_s
+          if @running
+            begin
+              @client.cancel(reason: "ctrl_c")
+            rescue SystemCallError, IOError => e
+              @screen.commit("could not cancel the turn (#{worker_down(e)})")
+            end
+            return nil
+          end
+          unless typed.strip.empty?
+            @last_idle_interrupt_at = nil
+            return nil
+          end
+
+          now = pressed&.fetch(:at, nil) || @clock.call
+          return submit(nil) if @last_idle_interrupt_at && now - @last_idle_interrupt_at <= DETACH_WINDOW
+
+          @last_idle_interrupt_at = now
+          @screen.commit(DETACH_HINT)
+          nil
+        end
+
+        # On the reader thread, from Reline's Ctrl-C: what the line held, and
+        # when. During a turn the press goes to the loop (it cancels the turn)
+        # and the read goes on with the typed text still in it, as in the REPL;
+        # otherwise it is noted for the Interrupt the LineReader queues next.
+        # @return [Boolean] true: handled, the read goes on; false: Reline ends
+        #   the read with Interrupt
+        def note_interrupted_line
+          pressed = { text: Reline.line_buffer.to_s, at: @clock.call }
+          if @running
+            @queue << [:interrupt, pressed]
+            return true
+          end
+
+          Thread.current[:interrupted_line] = pressed
+          false
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/attached_loop/exit_commands.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../exit_lines"
+
+module Samagotchi
+  class TerminalUI
+    class AttachedLoop
+      # Exit and archive commands for the attached loop.
+      # Reads @client, @client_id, @exit_ask, @link, @queued_ids, @running,
+      # @screen, @view; writes @archive_after_turn and @exit_ask.
+      # Calls the loop helpers #via and #detach.
+      module ExitCommands
+        private
+
+        # @return [Symbol] :detach
+        def detach(line)
+          @view.finish_thinking_spinner
+          @screen.commit(line)
+          :detach
+        end
+
+        # Detach, and ask the worker to exit now. The worker decides: it stays
+        # up while anything still needs it (a turn, queued input, a continue
+        # offer, another UI, reminders), and the line says which. When the only
+        # holds are ones the user can stop, it asks what to do with them instead
+        # of detaching (#answer_exit_ask).
+        # @return [Symbol, nil] :detach, or nil to stay at the prompt
+        def exit_worker
+          reply = @client.request_exit(client_id: @client_id)
+          holds = reply.status == 409 ? reply.json&.fetch("holds", nil) : nil
+          return detach(ExitLines.exit_line(reply, via: via, session_id: @client.session_id)) unless holds.is_a?(Array) && !holds.empty?
+
+          @exit_ask = holds
+          @screen.commit(ExitLines.ask_lines(holds))
+          nil
+        rescue SystemCallError, IOError => e
+          detach(ExitLines.exit_failed_line(e.message, via: via, session_id: @client.session_id))
+        end
+
+        # The answer to the exit ask.
+        # @return [Symbol, nil] :detach for 1 and 2, nil for 3 or a line the
+        #   ask doesn't understand
+        def answer_exit_ask(line)
+          choice = ExitLines::EXIT_ANSWERS[line.to_s.strip.downcase]
+          unless choice
+            @screen.commit("Say 1 (keep running), 2 (stop them and exit) or 3 (back to the session).")
+            return nil
+          end
+
+          holds = @exit_ask
+          @exit_ask = nil
+          case choice
+          when :keep then detach(ExitLines.kept_line(holds, via: via, session_id: @client.session_id))
+          when :stop then stop_and_exit
+          else
+            @screen.commit("(nothing stopped; the worker keeps running)")
+            nil
+          end
+        end
+
+        # 2: ask the worker to stop them all and exit.
+        # @return [Symbol] :detach
+        def stop_and_exit
+          reply = @client.request_exit(client_id: @client_id, stop: true)
+          detach(ExitLines.exit_line(reply, via: via, session_id: @client.session_id))
+        rescue SystemCallError, IOError => e
+          detach(ExitLines.exit_failed_line(e.message, via: via, session_id: @client.session_id))
+        end
+
+        # /exit --delete: the worker exits as for /exit, then the session is
+        # deleted. When the worker stays up (another UI, queued input, ...),
+        # nothing is deleted.
+        def exit_and_delete
+          reply = @client.request_exit(client_id: @client_id, delete: true)
+          id = @client.session_id
+          unless reply.status == 200
+            line = ExitLines.exit_line(reply, via: via, session_id: id)
+            return detach(line.sub("Detached; the session keeps running", "Detached; not deleted: the session keeps running")) if reply.status == 409
+
+            return detach("#{line} Not deleted.")
+          end
+          # An empty session: the worker deletes it as it leaves.
+          return detach(ExitLines::EMPTY_EXIT) if ExitLines.discards?(reply)
+
+          @link.delete_session
+          detach("Detached; deleted session #{id}.")
+        rescue SystemCallError, IOError => e
+          detach("#{ExitLines.exit_failed_line(e.message, via: via, session_id: id)} Not deleted.")
+        rescue SessionManager::DeleteRefused, SessionManager::OwnedByTUI, ArgumentError => e
+          detach("Detached; the worker is stopping, but session #{id} was not deleted (#{e.message}): " \
+                 "#{via.command("sessions delete #{id}")}")
+        end
+
+        # /archive during a turn (D2): it waits for the turn's end and the
+        # commands queued behind it (#archive_due?), then runs.
+        # @return [nil]
+        def archive_after_turn
+          @archive_after_turn = true
+          @screen.commit("(archives after this turn)")
+          nil
+        end
+
+        def archive_due? = @archive_after_turn && !@running && @queued_ids.empty?
+
+        # @return [Symbol] :detached
+        def archive_now
+          @archive_after_turn = false
+          exit_and_archive
+          :detached
+        end
+
+        # /archive: the worker is asked to exit as for /exit, then the session
+        # is archived. A worker staying up for another UI (or reminders) is
+        # stopped by the archive, as the web's archive stops it; a turn
+        # running, a queued prompt or an open continue offer refuses it
+        # (SessionManager.archive_session). An empty session: the worker
+        # deletes it as it leaves.
+        def exit_and_archive
+          # /archive can't ask about what still runs: a child the archive will
+          # stop is not worth a question here.
+          reply = @client.request_exit(client_id: @client_id, ask: false)
+          id = @client.session_id
+          return detach(ExitLines::EMPTY_EXIT) if reply.status == 200 && ExitLines.discards?(reply)
+          return detach("#{ExitLines.exit_line(reply, via: via, session_id: id)} Not archived.") unless [200, 409].include?(reply.status)
+
+          result = @link.archive_session
+          return detach("Detached; the session was empty, so it is discarded.") if result[:discarded].include?(id)
+
+          detach("Detached; archived session #{id}. #{via.command("sessions list --archived")} finds it.")
+        rescue SystemCallError, IOError => e
+          detach("#{ExitLines.exit_failed_line(e.message, via: via, session_id: id)} Not archived.")
+        rescue SessionManager::ArchiveRefused, SessionManager::OwnedByTUI, ArgumentError => e
+          detach("Detached; session #{id} was not archived (#{e.message}). Re-attach with: #{via.attach(id)}")
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/attached_loop/questions.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "../../client_id"
+require_relative "../exit_lines"
+require_relative "../../session_commands"
+require_relative "../question_prompt"
+
+module Samagotchi
+  class TerminalUI
+    class AttachedLoop
+      # Question and continue prompts for the attached loop.
+      # Reads @as_parent, @answered_ids, @client, @continue_offer, @offer_asked,
+      # @question, @reader, @screen, @set_aside, @view; writes @continue_answer,
+      # @continue_offer, @offer_asked, @previewed_id, @question, @question_pending,
+      # @set_aside, @unanswered.
+      # Calls the loop helpers #client_label, #detach, #own?, #paint, #send_command,
+      # #stale_worker, #sync_prompt, #via, and #worker_down.
+      module Questions
+        private
+
+        # The worker says what became of it (:continue_resolved); an invalid
+        # answer gets its error and the offer stays.
+        def answer_continue(text)
+          echo_answer(text) if TurnFlow.continue_decision(text).first == :invalid
+          @continue_answer = text.empty? ? "yes" : text
+          send_command(continue_line(text))
+          nil
+        end
+
+        # A bare answer at the continue prompt, as the REPL reads it (an empty
+        # one is yes).
+        def continue_line(text)
+          text.empty? ? SessionCommands::CONTINUE_COMMAND : "#{SessionCommands::CONTINUE_COMMAND} #{text}"
+        end
+
+        def offer_continue(event)
+          @continue_offer = { context: event[:context], no_interrupt: event[:no_interrupt] }
+          sync_prompt
+          sync_continue_slot
+        end
+
+        CONTINUE_DECISIONS = { "resume" => "yes", "abort" => "no", "abort_with_reason" => "no, with a reason",
+                               "refused" => "not continued: the participant may no longer run turns" }.freeze
+
+        # The offer's choices go; one line says what became of it. Another
+        # UI's answer shows as its command line (web> /continue yes) instead.
+        def continue_resolved(event)
+          @continue_offer = nil
+          # Asked as the step-limit question: its line says what became of it.
+          asked = @offer_asked
+          @offer_asked = false
+          sync_continue_slot
+          who = client_label(event[:client_id], "another UI")
+          outcome = if event[:decision] == "dropped"
+                      "(dropped: #{own?(event[:client_id]) ? "you" : who} sent a new prompt)"
+                    elsif event[:decision] == "refused"
+                      CONTINUE_DECISIONS["refused"]
+                    elsif own?(event[:client_id])
+                      @continue_answer || CONTINUE_DECISIONS.fetch(event[:decision].to_s, event[:decision].to_s)
+                    end
+          @continue_answer = nil
+          @screen.commit(QuestionSlot.continue_summary(outcome, paint: method(:paint))) if outcome && !asked
+          # Back to the > prompt: with the text a question set aside meanwhile
+          # (#close_question), else what the ? read holds.
+          set_aside = @set_aside
+          @set_aside = nil
+          set_aside ? sync_prompt(keep_text: false, prefill: set_aside) : sync_prompt
+        end
+
+        # The notes slot shows the offer's choices while it waits (a question
+        # has the slot while it is open).
+        def sync_continue_slot
+          return if @question || @offer_asked
+
+          if @continue_offer
+            @screen.set_slot(:notes, QuestionSlot.continue_offer(@continue_offer[:context], paint: method(:paint)))
+          else
+            @screen.clear_slot(:notes)
+          end
+        end
+
+        def unanswered_question(pending)
+          @unanswered = pending
+          detach("A question waits for an answer: #{via.attach(@client.session_id)}")
+          :unanswered
+        end
+
+        def prompt_text
+          return paint(QUESTION_PROMPT, 33) if @question || @continue_offer
+
+          paint(PROMPT, 92)
+        end
+
+        # Switch the open prompt to ? for the answer and show the choices in
+        # the notes slot, fitted to the terminal. Once the question closes,
+        # one line (the question and what became of it) stays.
+        def ask(pending)
+          return unless pending
+
+          @view.finish_thinking_spinner
+          # What was typed at the prompt waits for the question to close.
+          # Not over text already set aside (a question that closed while a
+          # continue offer waits): the ? read holds an answer then, if anything.
+          @set_aside = @reader&.typed_text.to_s.then { |typed| typed.empty? ? nil : typed } unless @question || @set_aside
+          @question = QuestionPrompt.new(pending)
+          @question_pending = pending
+          # The step-limit question stands for the continue offer's own slot
+          # until the offer is resolved.
+          @offer_asked = true if @question.continue?
+          # An edit's diff goes above, into the scrollback, once per question
+          # (a join gets it from the snapshot and may get the event too).
+          unless @previewed_id == @question.id
+            @previewed_id = @question.id
+            preview = @question.preview_lines(paint: method(:paint))
+            @screen.commit(preview.join("\n")) unless preview.empty?
+          end
+          # The prompt first, so the choices never show under the typed text.
+          sync_prompt(keep_text: false)
+          @screen.set_slot(:notes, @question.slot(paint: method(:paint)))
+        end
+
+        def answer_question(text)
+          # Enter alone at the step-limit question continues (it can't be
+          # dismissed), as at the continue prompt.
+          return dismiss_question if text.empty? && !@question.continue?
+
+          answer = @question.parse(text)
+          @screen.commit(answer.note) if answer.note
+          unless answer.ok?
+            echo_answer(text)
+            return @screen.commit(answer.error)
+          end
+
+          parent = @as_parent ? { client_id: ClientId::CLI_ANSWER } : {}
+          reply = @client.answer(id: @question.id, selected: answer.selected, freeform: answer.freeform, **parent)
+          case reply.status
+          when 200
+            @answered_ids << @question.id
+            close_question(@question.answer_text(answer))
+          when 409 then close_question("(already answered in another UI)")
+          when 408 then @screen.commit("could not answer (#{ExitLines::LATE})")
+          else
+            detail = reply.json&.fetch("detail", nil) || reply.json&.fetch("error", nil)
+            @screen.commit("could not answer (#{[reply.status, detail].compact.join(" ")})")
+          end
+          nil
+        rescue SystemCallError, IOError => e
+          @screen.commit("could not answer (#{worker_down(e)})")
+          nil
+        end
+
+        # An empty answer dismisses the question, as in the REPL: the tool
+        # returns unanswered (an approval: denied) and the turn goes on. The
+        # :question_cancelled every UI gets finds it already closed here.
+        def dismiss_question
+          reply = @client.dismiss_question(id: @question.id)
+          case reply.status
+          when 200 then close_question(@question.approval? ? "(denied)" : "(cancelled)")
+          when 409 then close_question("(question already closed in another UI)")
+          when 404 then @screen.commit("#{stale_worker("dismiss questions")}; Ctrl-C cancels the turn")
+          when 408 then @screen.commit("could not dismiss the question (#{ExitLines::LATE}); Ctrl-C cancels the turn")
+          else
+            # The question stays open (after a 404 too).
+            detail = reply.json&.fetch("error", nil)
+            @screen.commit("could not dismiss the question (#{[reply.status, detail].compact.join(" ")}); Ctrl-C cancels the turn")
+          end
+          nil
+        rescue SystemCallError, IOError => e
+          @screen.commit("could not dismiss the question (#{worker_down(e)}); Ctrl-C cancels the turn")
+          nil
+        end
+
+        # A line read at ? that isn't a (valid) answer: the read left no echo,
+        # so it shows above what it got.
+        def echo_answer(text) = @screen.commit("#{paint(QUESTION_PROMPT, 33)}#{text}")
+
+        def question_relayed(event)
+          return unless @question && @question.id == event[:id].to_s
+
+          @question.relayed_to = event[:relayed_to]
+          @screen.set_slot(:notes, @question.slot(paint: method(:paint)))
+        end
+
+        def question_answered(event)
+          return unless @question
+          return close_question(nil) if @answered_ids.include?(event[:id])
+
+          answer = event[:answer] || {}
+          picked = [*Array(answer[:selected]), answer[:freeform]].compact.join(", ")
+          close_question("#{picked.empty? ? "(answered)" : picked} (in another UI)")
+        end
+
+        # @param outcome [String, nil] what became of it, for the line that
+        #   stays in the scrollback (nil: none, it was closed already)
+        def close_question(outcome)
+          @screen.clear_slot(:notes)
+          @screen.commit(@question.summary(outcome, paint: method(:paint))) if outcome
+          @question = nil
+          # A continue offer still waiting keeps the ? prompt (the step-limit
+          # question closes before its offer resolves): the text set aside
+          # waits for the > prompt (#continue_resolved).
+          return sync_continue_slot if @continue_offer
+
+          set_aside = @set_aside
+          @set_aside = nil
+          sync_prompt(keep_text: false, prefill: set_aside)
+        end
+
+        # Restart the open read when its prompt no longer fits (a question or a
+        # continue offer opened or closed), first erasing the prompt Reline drew.
+        # What is typed there goes along (+keep_text+), or +prefill+ goes in.
+        def sync_prompt(keep_text: true, prefill: nil)
+          return unless @reader
+
+          @screen.synchronize do
+            next if @reader.current == prompt_text
+
+            @screen.clear_slot(:editor)
+            @reader.reprompt(keep_text: keep_text, prefill: prefill)
+          end
+        end
+      end
+    end
+  end
+end