samagotchi 0.124.0 → 0.126.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -13,6 +13,13 @@ require_relative "input_support"
 require_relative "image_input"
 require_relative "line_reader"
 require_relative "question_prompt"
+require_relative "join_replay"
+require_relative "exit_lines"
+require_relative "attached_loop/exit_commands"
+require_relative "attached_loop/questions"
+require_relative "attached_loop/queueing"
+require_relative "attached_loop/composer"
+require_relative "attached_loop/sending"
 require_relative "reline_seam"
 require_relative "version_lines"
 require_relative "gap_clock"
@@ -48,49 +55,16 @@ module Samagotchi
     class AttachedLoop
       include Formatting
       include InputSupport
+      include ExitCommands
+      include Questions
+      include Queueing
+      include Composer
+      include Sending
 
       PROMPT = "> "
       # A second Ctrl-C at an empty idle prompt within this many seconds detaches.
       DETACH_WINDOW = 2.0
       DETACH_HINT = "Ctrl-D to detach, /exit stops the worker"
-      # Why a request the Bridge read after its deadline didn't go through.
-      LATE = "worker not answering in time"
-      # An exit the worker agreed to in an empty session. Said before it has
-      # left: it checks again once it lets go, and a note or prompt arriving
-      # first keeps the session (SessionManager.discard_left_session).
-      EMPTY_WORDS = "the session is empty: it will be discarded if nothing arrives before its worker stops."
-      EMPTY_EXIT = "Detached; #{EMPTY_WORDS}"
-      # Why the worker stayed up after /exit, by the reason it gave.
-      HELD_REASONS = {
-        "turn_running" => "a turn is running", "input_queued" => "prompts are queued",
-        "continue_offered" => "a continue offer is pending", "client_connected" => "another UI is attached",
-        "reminders" => "reminders are set", "starting" => "the worker is still starting",
-        "background_tasks" => "background tasks it started are still running",
-        "delegates" => "delegates of this session are still running"
-      }.freeze
-      # How to end a background task that holds the worker up (an older
-      # worker's 409 has no hint of its own).
-      TASK_STOP_HINT = "stop one with the web's stop-task button or by asking for task_stop"
-      # The /exit ask, when every hold is one the user can stop: what still
-      # runs, then the three answers. Each kind, singular and plural.
-      EXIT_HOLD_WORDS = {
-        "reminders" => %w[reminder reminders],
-        "background_tasks" => ["background task", "background tasks"],
-        "delegates" => %w[delegate delegates]
-      }.freeze
-      # The 200's +stopped+ keys, by the kind the ask lists them under.
-      STOPPED_KEYS = { "reminders" => "reminders", "tasks" => "background_tasks", "delegates" => "delegates" }.freeze
-      EXIT_ASK_OPTIONS = ["Keep running in the background (detach)", "Stop them and exit", "Back to the session"].freeze
-      # How the ask reads an answer.
-      EXIT_ANSWERS = {
-        "1" => :keep, "keep" => :keep, "detach" => :keep, "background" => :keep,
-        "2" => :stop, "stop" => :stop, "exit" => :stop,
-        "3" => :back, "back" => :back, "stay" => :back
-      }.freeze
-      # How much of the last answer a join shows.
-      JOIN_ANSWER_LINES = 12
-      JOIN_ANSWER_CHARS = 1200
-
       attr_reader :client_id
 
       # @return [String, nil] the model the worker's turns run on, as the
@@ -175,6 +149,7 @@ module Samagotchi
         @clock = clock
         # The session's last activity, for the gap dividers (GapClock).
         @gaps = GapClock.new(now: now)
+        @join_replay = JoinReplay.new(screen: @screen, view: @view, link: @link, gaps: @gaps, renderer: @renderer)
         @last_idle_interrupt_at = nil
         @next_input_prefill = nil
         # Prompts this run sent, by enqueued_id: only those come back into
@@ -409,19 +384,6 @@ module Samagotchi
         @screen.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 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
-
       # The newest chi installed, looked at once, at the join.
       def installed_version
         @link.installed_version
@@ -493,387 +455,6 @@ module Samagotchi
         nil
       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(kept_line(@exit_ask)) 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
-
-      # /cut TEXT and /queue TEXT (+route+ has a choice). During a turn the
-      # text goes with its delivery: a cut, or queued to run as a turn of
-      # its own after this one. A worker that doesn't queue (its sidecar
-      # names no "delivery" feature) would steer a queue, so it is not sent.
-      # At the prompt both send the text as typed, a normal turn: no local
-      # word or typo check (the worker's Bridge runs a session command as
-      # the command).
-      # @param route [ComposerRoute::Route]
-      # @return [nil]
-      def submit_delivery(route)
-        return @screen.commit(STEER_CHOICE_USAGE) if route.kind == :usage
-        return @screen.commit(queue_needs_newer_worker) if Delivery.queue?(route.delivery) && !worker_queues?
-
-        # To an idle session it is an ordinary prompt: no delivery to send,
-        # and its ack says it was sent now (#sent_note).
-        send_prompt(route.text, delivery: route.delivery, choice: route.choice)
-        nil
-      end
-
-      # Whether the attached worker runs delivery: queue (its sidecar names
-      # Delivery::QUEUE_FEATURE). No sidecar to read: true, its Bridge
-      # answers (a P0-P2 worker refuses a queue: #send_prompt).
-      def worker_queues? = @link.queues?
-
-      # @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(exit_line(reply)) unless holds.is_a?(Array) && !holds.empty?
-
-        @exit_ask = holds
-        @screen.commit(ask_lines(holds))
-        nil
-      rescue SystemCallError, IOError => e
-        detach(exit_failed_line(e.message))
-      end
-
-      # The ask: what still runs, then the three answers.
-      def ask_lines(holds)
-        lines = holds.map do |hold|
-          items = Array(hold["items"])
-          singular, plural = hold_words(hold["kind"])
-          "  • #{items.size} #{items.size == 1 ? singular : plural}: #{items.map { |item| item_word(item, hold["kind"]) }.join(", ")}"
-        end
-        lines += EXIT_ASK_OPTIONS.each_with_index.map { |option, index| "  #{index + 1}. #{option}" }
-        (["This session still has:"] + lines).join("\n")
-      end
-
-      # One entry of a hold: the command or name, with its detail in
-      # brackets; a delegate leads with its short id and its title in quotes.
-      def item_word(item, kind)
-        label = item["label"].to_s
-        label = "#{item["id"].to_s[0, 8]} \"#{label}\"" if kind == "delegates"
-        detail = item["detail"].to_s
-        detail.empty? ? label : "#{label} (#{detail})"
-      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 = 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(kept_line(holds))
-        when :stop then stop_and_exit
-        else
-          @screen.commit("(nothing stopped; the worker keeps running)")
-          nil
-        end
-      end
-
-      # 1: detach, everything left running.
-      def kept_line(holds)
-        "Detached; the session keeps running (#{hold_words_list(holds)}). " \
-          "Re-attach with: #{via.attach(@client.session_id)}"
-      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(exit_line(reply))
-      rescue SystemCallError, IOError => e
-        detach(exit_failed_line(e.message))
-      end
-
-      # "2 reminders, 1 background task, 1 delegate" from the ask's holds.
-      def hold_words_list(holds)
-        holds.map do |hold|
-          items = Array(hold["items"])
-          singular, plural = hold_words(hold["kind"])
-          "#{items.size} #{items.size == 1 ? singular : plural}"
-        end.join(", ")
-      end
-
-      def hold_words(kind) = EXIT_HOLD_WORDS.fetch(kind.to_s, [kind.to_s, kind.to_s])
-
-      # What a stop-all exit stopped: "stopped 2 reminders (api_health, git
-      # push), 1 background task (rails s)"; nil when it stopped nothing.
-      def stopped_words(stopped)
-        return nil unless stopped.is_a?(Hash)
-
-        parts = STOPPED_KEYS.filter_map do |key, kind|
-          names = Array(stopped[key])
-          next if names.empty?
-
-          singular, plural = hold_words(kind)
-          "#{names.size} #{names.size == 1 ? singular : plural} (#{names.join(", ")})"
-        end
-        parts.empty? ? nil : "stopped #{parts.join(", ")}"
-      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 = exit_line(reply)
-          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(EMPTY_EXIT) if discards?(reply)
-
-        @link.delete_session
-        detach("Detached; deleted session #{id}.")
-      rescue SystemCallError, IOError => e
-        detach("#{exit_failed_line(e.message)} 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(EMPTY_EXIT) if reply.status == 200 && discards?(reply)
-        return detach("#{exit_line(reply)} 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("#{exit_failed_line(e.message)} 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
-
-      def exit_line(reply)
-        id = @client.session_id
-        error = reply.json&.fetch("error", nil)
-        case reply.status
-        when 200
-          stopped = stopped_words(reply.json&.fetch("stopped", nil))
-          return EMPTY_EXIT if discards?(reply) && stopped.nil?
-          return "Detached; #{stopped}. #{EMPTY_WORDS.capitalize}" if discards?(reply)
-
-          "Detached; #{stopped || "the session's worker is stopping"}. Resume with: #{via.resume(id)}"
-        when 409
-          reason = reply.json&.fetch("reason", nil).to_s
-          "Detached; the session keeps running (#{held_words(reason, reply.json&.fetch("tasks", nil))}). " \
-            "Re-attach with: #{via.attach(id)}"
-        when 0 then exit_failed_line("no reply")
-        when 408 then exit_failed_line(LATE)
-        else
-          # A worker from before the route answers the Bridge's plain 404.
-          if error == "not_found"
-            return "Detached; this worker runs an older chi and can't be stopped from here: #{via.command("sessions stop #{id}")}"
-          end
-
-          exit_failed_line([reply.status, reply.json&.fetch("detail", nil) || error].compact.join(" "))
-        end
-      end
-
-      # Why the worker stayed up; the background tasks it waits for by
-      # their short id and command (a finish wake's, D3), and how to stop one.
-      def held_words(reason, tasks)
-        words = HELD_REASONS.fetch(reason, reason)
-        listed = Array(tasks).filter_map { |t| "#{Tools::TaskRecord.short_id(t["id"])} (#{t["command"]})" if t.is_a?(Hash) }
-        listed.empty? ? words : "#{words}: #{listed.join(", ")}; #{TASK_STOP_HINT}"
-      end
-
-      # An older worker leaves the field out.
-      def discards?(reply) = reply.json&.fetch("discard", nil) == true
-
-      def exit_failed_line(why)
-        "Detached (could not ask the worker to stop: #{why}). Re-attach with: #{via.attach(@client.session_id)}"
-      end
-
-      # 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
-
-      # The worker runs it and every UI renders its :command_ran, this one
-      # too, so nothing waits here.
-      def send_command(line)
-        reply = @client.post_command(line: line, client_id: client_id_for(line))
-        if reply.status == 202
-          # Input from a pipe ends once its output is in (#command_ran).
-          command_id = reply.json&.fetch("command_id", nil)
-          @open_ids << command_id if command_id && @wait_at_eof
-          return
-        end
-        return @screen.commit(stale_worker("run commands")) if reply.status == 404
-
-        name = older_worker_command(reply, line)
-        return @screen.commit(stale_worker("run #{name}")) if name
-        return @screen.commit("could not run the command (#{LATE})") if too_late?(reply)
-
-        detail = reply.json&.fetch("detail", nil) || reply.json&.fetch("error", nil)
-        @screen.commit("could not run the command (#{[reply.status, detail].compact.join(" ")})")
-      rescue SystemCallError, IOError => e
-        @screen.commit("could not run the command (#{worker_down(e)})")
-      end
-
       # A request the Bridge read after its deadline and dropped
       # (BridgeClient::DEADLINE_SHARE): it didn't go through.
       def too_late?(reply) = reply.status == 408 && reply.json&.fetch("error", nil) == "deadline_passed"
@@ -890,316 +471,6 @@ module Samagotchi
         "worker unreachable: #{head.downcase}"
       end
 
-      QUEUED_NOTE = "(queued: runs after this turn)"
-      QUEUE_RUNS_NOW = "(the turn had ended: runs as the next turn)"
-      NOTHING_QUEUED = "(nothing queued: /queue TEXT queues a message for after the running turn)"
-      UNQUEUE_REFUSED = { "already_started" => "(not removed: it already started)",
-                          "unknown_enqueued_id" => "(not removed: it is already gone)",
-                          "not_queued" => "(not removed: it goes in at the next step)" }.freeze
-
-      # /queue to a worker from before queueing, which would steer it.
-      def queue_needs_newer_worker
-        "(/queue needs a newer worker: restart it with #{via.command("sessions restart")}, then send again)"
-      end
-
-      def unqueue_needs_newer_worker = "(/unqueue needs a newer worker: restart it with #{via.command("sessions restart")})"
-
-      # /unqueue: take back the newest prompt this run queued for after the
-      # turn, before it runs (POST turn/dequeue). Its :turn_dequeued comes
-      # to every UI; here the reply says what became of it. A worker whose
-      # sidecar lacks "unqueue" is not asked.
-      def unqueue_newest
-        return @screen.commit(unqueue_needs_newer_worker) unless worker_unqueues?
-
-        id = @my_queued.last
-        return @screen.commit(NOTHING_QUEUED) unless id
-
-        reply = @client.dequeue(enqueued_id: id, client_id: @client_id)
-        error = reply.json&.fetch("error", nil)
-        return @screen.commit(unqueue_needs_newer_worker) if reply.status == 404 && error == "not_found"
-
-        # Removed, started or gone: no longer this run's to take back.
-        @my_queued.delete(id) if [200, 404, 409].include?(reply.status)
-        return unqueued(reply.json&.fetch("prompt", nil).to_s) if reply.status == 200
-
-        @screen.commit(UNQUEUE_REFUSED[error] || "could not remove the queued message (#{[reply.status, error].compact.join(" ")})")
-      rescue SystemCallError, IOError => e
-        @screen.commit("could not remove the queued message (#{worker_down(e)})")
-      end
-
-      # The removal's line, and its text back in the input to change and
-      # send again (as a failed turn's prompt comes back, #restore_prompt):
-      # not over typed text, and not for lines from a pipe. Its images are
-      # not put back.
-      def unqueued(prompt)
-        @screen.commit("removed: #{first_line_clip(prompt)}")
-        return if @wait_at_eof || prompt.strip.empty?
-
-        # Set before the read restarts with it: the read's echo reads it.
-        @prefilled = prompt.strip
-        return if @reader&.prefill(prompt)
-
-        @prefilled = nil
-        @screen.commit("(the removed message is in the input history: ↑)")
-      end
-
-      def first_line_clip(text, max = 60)
-        line = text.to_s.strip.lines.first.to_s.strip
-        line.length > max ? "#{line[0, max]}…" : line
-      end
-
-      # Whether the attached worker takes queued messages back (its sidecar
-      # names SessionInbox::UNQUEUE_FEATURE). No sidecar to read: true, its Bridge
-      # answers (an older one's 404 not_found says so).
-      def worker_unqueues? = @link.unqueues?
-
-      # A command queued for after the running turn (command_queued with
-      # waits): its line now (another client's) and a note; its command_ran
-      # has no line again (queued: true).
-      def command_waits(event)
-        @queued_ids << event[:command_id]
-        if own?(event[:client_id])
-          first = event[:command_id] == @first_command_id
-          return @screen.commit(first ? first_command_queued : QUEUED_NOTE)
-        end
-
-        @screen.commit("#{prompt_line(event[:client_id], event[:line])} #{QUEUED_NOTE}")
-      end
-
-      def first_command_queued
-        "(#{first_command_flag} queued: applies after the running turn)"
-      end
-
-      def command_ran(event)
-        @open_ids.delete(event[:command_id])
-        @queued_ids.delete(event[:command_id])
-        unless own?(event[:client_id]) || event[:anytime] || event[:card] || event[:queued]
-          @screen.commit(prompt_line(event[:client_id], event[:line]))
-        end
-        output = event[:output].to_s
-        if output.empty?
-          nil
-        elsif %w[busy dropped].include?(event[:status]) || PromptHistory.shell_line?(event[:line])
-          @screen.commit(output)
-          put_back_busy_command(event) if event[:status] == "busy"
-        else
-          @screen.commit("#{paint("model>", 36)} #{output}")
-        end
-        prefill_confirm(event)
-        # /title from any client: the row's title follows.
-        @status.update(title: event[:title]) if Array(event[:changed]).include?("title")
-        return unless event[:model_name]
-
-        # After the output, so the status row changes with the line saying why.
-        served = @status[:model] == event[:model_name] ? @status[:served] : nil
-        @status.update(model: event[:model_name], default_model: default_model_name, served: served)
-      end
-
-      # Our change that asks first (CacheConfirm) puts its --yes line in the
-      # input: Enter applies it. Another client's question is its own.
-      def prefill_confirm(event)
-        return unless own?(event[:client_id])
-
-        confirm = event[:confirm]
-        line = confirm.is_a?(Hash) ? confirm[:line] || confirm["line"] : nil
-        @reader&.prefill(line.to_s) if line
-      end
-
-      # Our command the worker couldn't run yet goes back into the prompt, for
-      # Enter once the turn ends (not the launch's --model: that ends the launch).
-      def put_back_busy_command(event)
-        return unless own?(event[:client_id]) && event[:command_id] != @first_command_id
-
-        @screen.commit("(the command is in the input history: ↑)") unless @reader&.prefill(event[:line].to_s)
-      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
-
-      # What a prompt's 202 says became of it, or nil when there is nothing
-      # to say: the dim line both TUIs print for a delivery. A plain line
-      # for a running turn goes in at its next step; a cut's outcome comes
-      # from the ack (the worker knows whether cutting is on for its model);
-      # a queued one waits for the turn's end (the ack says queue).
-      # An idle session's prompt simply runs, and a prompt with images runs
-      # as its own next turn (never merging mid-turn), so nothing is said;
-      # one typed as /cut or /queue says it was sent now (+choice+).
-      # @param ack [Hash, nil] the Bridge's 202 body
-      # @param delivery [String, nil] what was asked for
-      # @return [String, nil]
-      def sent_note(ack, delivery: nil, images: [], running: false, choice: nil)
-        return STEER_CHOICE_IDLE if choice && !running
-        return nil unless running && ack.is_a?(Hash)
-        # The Bridge acks queue only while a turn ran at enqueue; a /queue
-        # it acks next_step found the turn over: it is the next turn.
-        return QUEUED_NOTE if ack["delivery"] == Delivery::QUEUE
-        return QUEUE_RUNS_NOW if Delivery.queue?(delivery)
-        return nil unless images.empty?
-
-        return NEXT_STEP_NOTE unless delivery == Delivery::CUT
-
-        steer_cut_note(ack["cut"].to_s.to_sym, ack["cut_after"])
-      end
-
-      # The client id +line+ goes with, as a command (#send_command) or as a
-      # message the Bridge may run as one (#send_prompt: /cut and /queue
-      # text). A parent agent's /continue yes and /parent-answers go as chi
-      # answer's: the worker holds the first to guardrails.parent_answers and
-      # never takes the second as a user's loosening. The command is the
-      # registry's own match (the worker's), not a pattern of ours.
-      def client_id_for(line)
-        return @client_id unless @as_parent
-        return ClientId::CLI_ANSWER if TurnFlow.continue_yes?(line)
-        return ClientId::CLI_ANSWER if command_registry.lookup(line)&.id == :parent_answers
-
-        @client_id
-      end
-
-      # @param choice [Symbol, nil] :cut or :queue when typed with that word
-      def send_prompt(text, delivery: nil, choice: nil)
-        persist_recent_history(text)
-        images = attach_images(text)
-        return own_prompt_failed if images.nil?
-
-        running = @running
-        # Off a live region (no echo seam) the divider comes here; after
-        # #gap_above_echo it marks none.
-        mark_activity
-        options = { prompt: text, client_id: client_id_for(text) }
-        options[:no_interrupt] = true if @no_interrupt
-        options[:images] = images unless images.empty?
-        options[:delivery] = delivery if delivery
-        reply = @client.post_turn(**options)
-        if reply.status == 202
-          enqueued_id = reply.json&.fetch("enqueued_id", nil)
-          @sent_ids << enqueued_id if enqueued_id
-          @open_ids << enqueued_id if enqueued_id && @wait_at_eof
-          @my_queued << enqueued_id if enqueued_id && reply.json&.fetch("delivery", nil) == Delivery::QUEUE
-          note = sent_note(reply.json, delivery: delivery, images: images, running: running, choice: choice)
-          @screen.commit(note) if note
-          return
-        end
-
-        own_prompt_failed
-
-        detail = reply.json&.fetch("error", nil)
-        # Read after its deadline and dropped (BridgeClient::DEADLINE_SHARE).
-        return @screen.commit("could not send the prompt (#{LATE})") if detail == "deadline_passed"
-        # A worker from 0.51 to 0.63 refuses a queue (nothing was sent).
-        return @screen.commit(queue_needs_newer_worker) if detail == "delivery_unavailable"
-
-        @screen.commit("could not send the prompt (#{[reply.status, detail].compact.join(" ")})")
-      rescue SystemCallError, IOError => e
-        own_prompt_failed
-        @screen.commit("could not send the prompt (#{worker_down(e)})")
-      end
-
-      # Whether the input's end must wait: the -p prompt isn't sent yet, a
-      # prompt this run sent hasn't had its turn, or its turn's after_turn
-      # hooks still run (their notices, source-links' sources:, come next).
-      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty? || @display_pending == true
-
-      # A turn ended: this run's prompt (and ours merged into it) had its turn.
-      def own_turn_ended(event)
-        return unless @wait_at_eof
-
-        id = origin_of(event[:origin]).enqueued_id
-        ours = @open_ids.include?(id) || !@merged_ids.empty?
-        @own_failed = true if ours && event[:type] == :turn_failed
-        @own_empty = true if ours && event[:type] == :turn_completed && event.dig(:turn_summary, :empty_answer)
-        # The worker sends answer_display once its after_turn hooks ran.
-        @display_pending = true if ours && event[:type] == :turn_completed && event[:display_pending]
-        @open_ids.delete(id)
-        @open_ids.subtract(@merged_ids)
-        @merged_ids.clear
-      end
-
-      # Ours merged into the running turn: they end with it.
-      def merged_own_prompts(event)
-        Array(event[:origins]).each do |value|
-          origin = origin_of(value)
-          id = origin.enqueued_id
-          @merged_ids << id if own?(origin.client_id) && @open_ids.include?(id)
-        end
-        nil
-      end
-
-      def own_prompt_failed
-        @own_failed = true if @wait_at_eof
-        nil
-      end
-
-      # The input ended and nothing of ours is left to wait for.
-      def end_of_input
-        detach("Detached; the session keeps running. Re-attach with: #{via.attach(@client.session_id)}") if @input_ended
-        return :turn_failed if @own_failed
-
-        @own_empty ? :empty_answer : :detached
-      end
-
-      def unanswered_question(pending)
-        @unanswered = pending
-        detach("A question waits for an answer: #{via.attach(@client.session_id)}")
-        :unanswered
-      end
-
-      # The prompt's `@path` images, stored where the worker reads them
-      # (AttachLink#ingest_images: the session's images/ here) and sent as
-      # refs: the Bridge never takes a path. nil (after a line saying why)
-      # when one can't be.
-      def attach_images(text)
-        paths = ImageInput.extract(text)
-        return [] if paths.empty?
-
-        @link.ingest_images(paths.map { |image| image[:path] })
-      rescue ImageStore::Error => e
-        @screen.commit("could not attach the image: #{e.message}")
-        nil
-      end
-
       # /share and /participants: chi share for this session, where it is.
       def participant_commands
         @participant_commands ||= ParticipantCommands.new(access: @link.session_access, session_id: @client.session_id,
@@ -1214,36 +485,6 @@ module Samagotchi
         @screen.commit("(no metrics: #{via.remote? ? e.message : "the worker did not answer"})")
       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
-
       # The saved recap, and a new one asked for at once (it arrives as
       # :recap_ready), with the REPL's words.
       def show_recap
@@ -1258,95 +499,6 @@ module Samagotchi
         @screen.commit("(no recap: #{via.remote? ? e.message : "the worker did not answer"})")
       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 (#{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 (#{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}")
-
       # The name of this chi's own command +line+ when the worker answered it
       # unknown_command (it runs an older chi without it), else nil.
       def older_worker_command(reply, line)
@@ -1374,100 +526,6 @@ module Samagotchi
         end
       end
 
-      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
-
-      # 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
-
       def render_snapshot(snapshot, reset:)
         @view.finish_thinking_spinner
         queued = Array(snapshot[:queued])
@@ -1488,8 +546,7 @@ module Samagotchi
           # The recap first: what the session was about, then where it stopped.
           saved = snapshot[:saved_recap]
           @screen.commit(recap_block(saved[:text], turns_since: saved[:turns_since], at: saved[:created_at])) if saved && !saved[:text].to_s.strip.empty?
-          render_join_header(Array(snapshot[:messages]))
-          render_join_gap(snapshot, saved)
+          @join_replay.render_join(snapshot, saved)
           @screen.commit("guardrails> #{snapshot[:guardrail_warning]}") if snapshot[:guardrail_warning]
           @screen.commit("plugins> #{snapshot[:plugin_warning]}") if snapshot[:plugin_warning]
           version_line = VersionLines.at_attach(worker: snapshot[:chi_version], installed: installed_version,
@@ -1501,7 +558,7 @@ module Samagotchi
         end
         Array(snapshot[:init_tasks]).each { |task| @view.init_started(task) }
         cards = Array(snapshot[:cards])
-        render_snapshot_cards(cards.reject { |card| card[:current] }, joining: !reset)
+        @join_replay.render_snapshot_cards(cards.reject { |card| card[:current] }, joining: !reset)
         offer = snapshot[:continue_offer]
         had_offer = !@continue_offer.nil?
         @continue_offer = offer && { context: offer[:context], no_interrupt: offer[:no_interrupt] }
@@ -1512,7 +569,7 @@ module Samagotchi
         render_current_turn(snapshot[:current_turn])
         # A question between turns (the step-limit one) belongs to no turn.
         ask(snapshot[:pending_question]) if snapshot[:current_turn].nil? && snapshot[:pending_question]
-        render_snapshot_cards(cards.select { |card| card[:current] }, joining: !reset)
+        @join_replay.render_snapshot_cards(cards.select { |card| card[:current] }, joining: !reset)
         queued.each do |entry|
           next if own?(entry[:client_id])
 
@@ -1533,270 +590,6 @@ module Samagotchi
         nil
       end
 
-      # --model (or --llm-context, --thinking) on a resumed session: run it in its
-      # worker before the first prompt goes; its :command_ran decides
-      # (#first_command_ran), and sends the next one.
-      # @return [Symbol, nil] :failed when the worker didn't take it
-      def send_first_command
-        line = @first_commands.shift
-        @first_command_line = line
-        reply = @client.post_command(line: line, client_id: @client_id)
-        if reply.status == 202
-          @first_command_id = reply.json&.fetch("command_id", nil)
-          return nil if @first_command_id
-        end
-
-        why =
-          if reply.status == 404 then stale_worker("run commands")
-          elsif (name = older_worker_command(reply, line)) then stale_worker("run #{name}")
-          elsif too_late?(reply) then LATE
-          else "the worker answered #{reply.status}"
-          end
-        @screen.commit("#{first_command_failed}: #{why}")
-        :failed
-      rescue SystemCallError, IOError => e
-        @screen.commit("#{first_command_failed}: #{worker_down(e)}")
-        :failed
-      end
-
-      # @return [Symbol, nil] :failed unless the command went through
-      def first_command_ran(event)
-        @first_command_id = nil
-        if event[:status] == "ok"
-          return send_first_command unless @first_commands.empty?
-
-          send_first_prompt
-          return nil
-        end
-
-        @screen.commit("#{first_command_failed}: #{event[:output]}")
-        :failed
-      end
-
-      def first_command_failed
-        flag = first_command_flag
-        flag == "--model" ? "could not switch to the --model" : "could not set the #{flag}"
-      end
-
-      # The launch flag the first command came from: "/model X" is --model,
-      # "/llm-context …" --llm-context, "/thinking X --yes" --thinking.
-      def first_command_flag
-        "--#{@first_command_line.to_s[%r{\A/([\w-]+)}, 1]}"
-      end
-
-      # After the join, so it lands below what the session already had. Our
-      # own prompts are never echoed from events (a typed one stays on screen),
-      # so it is shown here as if typed.
-      def send_first_prompt
-        text = @first_prompt.to_s.strip
-        @first_prompt = nil
-        return if text.empty?
-
-        @screen.commit("#{paint(PROMPT, 92)}#{text}")
-        # As if typed: a session command runs as the command; a typo of one
-        # gets the hint, not a turn.
-        if command_registry.command?(text)
-          send_command(text)
-        elsif (hint = command_registry.unknown_command_hint(text))
-          @screen.commit(hint)
-        else
-          send_prompt(text)
-        end
-      end
-
-      # Where the session's last activity was: its newest stamped entry,
-      # else its saved recap's time. A gap ago (and no turn running): one
-      # line after the join block says when.
-      def render_join_gap(snapshot, saved)
-        @gaps.seed(snapshot[:messages], fallback: saved&.dig(:created_at))
-        return if snapshot[:current_turn]
-
-        line = @gaps.join_line
-        @screen.commit(gap_divider(line)) if line
-      end
-
-      def render_join_header(messages)
-        exchange = messages.select { |m| %w[user model assistant].include?(m[:role].to_s) }
-        # The id stays findable: the detach line and chi sessions list show it.
-        Log.session_id = @client.session_id
-        Log.info(:attached, "joined", session: @client.session_id, messages: exchange.size,
-                                      notes: messages.count { |m| ContextNote.note?(m) })
-        last_user = exchange.rindex { |m| Steer.prompt?(m) }
-        render_join_notes(messages)
-        return unless last_user
-
-        @screen.commit(join_prompt_line(exchange[last_user]))
-        # An image-only turn's text names its images already.
-        unless ImageRef.placeholder_only?(exchange[last_user][:content])
-          Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
-        end
-        from = messages.index { |m| m.equal?(exchange[last_user]) }
-        render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
-        record = @link.saved_turn_record(exchange[last_user][:turn_id] || exchange[last_user]["turn_id"])
-        failed = join_failed_record(record)
-        # A turn that ended with no answer: its notice, as live.
-        empty = messages.drop(from + 1).filter_map { |m| TurnNote.empty_answer(m) }.last
-        if empty
-          @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"], empty[:refusal] || empty["refusal"]))
-        elsif failed
-          # A failed turn whose steps stayed: the line the live view left,
-          # and no step text as if it were the answer (the web keeps a
-          # failed turn's texts as steps too).
-          failure = failed["failure"]
-          @screen.commit(@view.turn_failed_line(failure["summary"] || failure["message"], failed["duration_ms"]))
-          @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) if failure["kept_steps"]
-        elsif record && record["status"] == "canceled"
-          # A canceled turn (a Stop, Ctrl-C): its line, as live, and no
-          # text it streamed before the cancel as if it were the answer.
-          @screen.commit(@view.turn_canceled_line(record["cancellation_reason"], record["duration_ms"], by: record["cancelled_by"]))
-          @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) unless record["continue"]
-        else
-          # The saved answer is raw: the latest keeps its thinking, and one may
-          # be only a tool call.
-          answer = exchange[(last_user + 1)..].reverse_each
-                                             .map { |m| OutputFormatter.strip_markup(m[:content]) }
-                                             .find { |text| !text.empty? }
-          @screen.commit(last_lines(answer)) if answer
-        end
-        render_join_notes(messages, after_exchange: true)
-      end
-
-      # What the last exchange did, as the live turn drew it: each saved
-      # call's tool row (action, params, status from its result, and its
-      # duration from +durations+, the turn's saved tool records) and a
-      # plugin's steer where it came. The step texts stay out, as live (the
-      # ticker's).
-      def render_join_steps(messages, from, durations: [])
-        records = durations.dup
-        messages.each_with_index.drop(from + 1).each do |m, i|
-          if Steer.steer?(m)
-            @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
-          elsif %w[model assistant].include?(m[:role].to_s)
-            responses = messages.drop(i + 1).take_while { |r| r[:role].to_s == "tool_response" }
-            Array(MessageParts.for_message(m, responses)&.dig(:tools)).each do |part|
-              record = join_record(records, part)
-              duration = record&.dig("duration_ms")
-              @screen.commit(join_tool_line(part, duration_ms: duration.is_a?(Numeric) ? duration : nil,
-                                                  saved_status: record&.dig("status"),
-                                                  auto_allowed: record&.dig("guardrail")))
-            end
-          end
-        end
-      end
-
-      # The prompt's turn's saved tool records (AttachLink: SessionMetrics,
-      # in this machine's state dir, as #attach_images): none for a prompt
-      # with no turn id (an older session) or a session with no analytics.
-      def join_tool_records(prompt)
-        @link.saved_tool_records(prompt[:turn_id] || prompt["turn_id"])
-      end
-
-      # The turn's saved +record+ when it failed with the fields its line is
-      # made of (SessionMetrics#failure_fields), else nil: a completed or
-      # older turn — or one saved before the failure field — draws its
-      # answer as before (a canceled one its line).
-      def join_failed_record(record)
-        return nil unless record && record["status"] == "failed" && record["failure"].is_a?(Hash)
-
-        failure = record["failure"]
-        return nil if failure["summary"].to_s.empty? && failure["message"].to_s.empty?
-
-        record
-      end
-
-      # The saved record of +part+'s call (its duration and status): the
-      # next record of its tool, in call order, consumed with the ones it
-      # skipped. By tool and order, not by iteration: an empty retry spends
-      # an iteration that left no message (as the web's timing.js
-      # takeRecord). nil for a call that left none: it never finished, or a
-      # worker before turn ids saved it.
-      def join_record(records, part)
-        return nil if part[:output].nil?
-
-        at = records.index { |r| r["tool"].to_s == part[:tool].to_s }
-        return nil unless at
-
-        records.shift(at + 1).last
-      end
-
-      # A saved call's row; "no result" for a call the turn never answered
-      # (it ended first). Its status is the saved record's, as live and the
-      # web's reload (a guardrail's "blocked" is no error), else read from
-      # its result (a guardrail's deny text reads blocked too). A record that
-      # System 1 allowed once (+auto_allowed+, its saved {rule, p}) says so,
-      # as the live row does.
-      def join_tool_line(part, duration_ms: nil, saved_status: nil, auto_allowed: nil)
-        output = part[:output]
-        command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
-        text = ToolActivity.saved_result_text(output) unless output.nil?
-        status = if output.nil?
-                   "no result"
-                 elsif !saved_status.to_s.empty?
-                   saved_status.to_s
-                 elsif ToolActivity.guardrail_denied?(text)
-                   "blocked"
-                 else
-                   ToolActivity.tool_activity_status(text, part[:tool], command: command)
-                 end
-        activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
-                     params: part[:params], status: status,
-                     description: ToolView.description_title(part[:view] || {}) }
-        "#{format_tool_activity_line(activity, duration_ms: duration_ms)}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}" \
-          "#{auto_allowed_suffix(auto_allowed)}"
-      end
-
-      # The live row's System 1 suffix for a saved record's {rule, p}.
-      def auto_allowed_suffix(saved)
-        return "" unless saved.is_a?(Hash)
-
-        format_tool_guardrail_suffix({ decided_by: "system one", p: saved["p"] || saved[:p] })
-      end
-
-      # The context notes that came since the last prompt (all of them in a
-      # session with none), after the exchange the header shows.
-      def render_join_notes(messages, after_exchange: false)
-        last_user = messages.rindex { |m| Steer.prompt?(m) }
-        return if after_exchange != !last_user.nil?
-
-        messages[(last_user ? last_user + 1 : 0)..].select { |m| ContextNote.note?(m) }.each do |m|
-          @screen.commit(context_note_line(ContextNote.label_of(m), ContextNote.text_of(m)))
-        end
-      end
-
-      # The end of a long answer; the whole of it is in the session.
-      def last_lines(text)
-        lines = text.split("\n", -1)
-        if lines.size > JOIN_ANSWER_LINES
-          text = "(… #{lines.size - JOIN_ANSWER_LINES} earlier lines)\n#{lines.last(JOIN_ANSWER_LINES).join("\n")}"
-        end
-        return text if text.length <= JOIN_ANSWER_CHARS
-
-        "(… earlier text)\n…#{text[-JOIN_ANSWER_CHARS..]}"
-      end
-
-      # The snapshot's cards and between-turns notices (Bridge CardStore):
-      # on join the ones since the last turn (and the running turn's), as
-      # the join header shows the last exchange; on a resync only cards not
-      # shown here yet, and not the ones an earlier worker saved (a resync
-      # onto a new worker: earlier turns, not news). A turn's own rows (notices, retries) are left out:
-      # the running turn's come with its parts, and the join shows no older
-      # turn's steps.
-      def render_snapshot_cards(entries, joining:)
-        entries.each do |entry|
-          case entry[:type].to_s
-          when "hook_notice"
-            next if entry[:in_turn]
-
-            @screen.commit(EventRenderer.hook_notice_line(entry)) if joining && entry[:turns_since].to_i.zero?
-          when "card"
-            next unless joining ? entry[:turns_since].to_i.zero? : !entry[:earlier] && !@renderer.card_shown?(entry[:id])
-
-            @renderer.render_card(entry, updated: entry[:updated] == true)
-          end
-        end
-      end
-
       def render_current_turn(turn)
         @running = !turn.nil?
         @joined_mid_turn = @running
@@ -1852,36 +645,6 @@ module Samagotchi
                                             images: event[:images], diff: event[:diff] }))
       end
 
-      def show_enqueued(event)
-        return if own?(event[:client_id])
-
-        # Another client's prompt shows here, before its turn starts.
-        mark_activity
-        @shown_enqueued << event[:enqueued_id]
-        line = prompt_line(event[:client_id], event[:prompt], **author_of(event[:author]))
-        @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)
-      end
-
-      # A queued prompt was taken back before it ran (the web's ×, /unqueue
-      # in a terminal). One of this run's (wait_at_eof) will have no turn:
-      # it ends the wait, as a failed one does. Another client's shown
-      # line says so.
-      def turn_dequeued(event)
-        id = event[:enqueued_id]
-        @my_queued.delete(id)
-        if @open_ids.delete?(id)
-          if own?(event[:client_id])
-            @own_empty = true
-            @screen.commit("(removed before it ran)")
-          else
-            @own_failed = true
-            @screen.commit("(your queued message was removed before it ran)")
-          end
-        elsif @shown_enqueued.delete?(id)
-          @screen.commit("(a queued message was removed)")
-        end
-      end
-
       def start_turn(event)
         @running = true
         @joined_mid_turn = false