samagotchi 0.103.0 → 0.104.0

data/lib/samagotchi/terminal_ui/attach_link.rb

@@ -49,6 +49,8 @@ module Samagotchi
 
       # The session's metrics for /stats, nil when the worker did not answer.
       # @return [Hash, nil] string keys
+      # @raise [IOError] the session's machine couldn't be asked (a remote's
+      #   Unreachable: the loop shows its message)
       def stats_metrics = raise(NotImplementedError)
 
       # Store a prompt's @path images where the worker reads them.
@@ -99,6 +101,14 @@ module Samagotchi
       # How the commands the TUI prints are spelled.
       # @return [ChiInvocation]
       def via = raise(NotImplementedError)
+
+      # Why the session's machine couldn't be asked the last time (for the
+      # stream's closing line), nil when there is nothing more to say.
+      # @return [String, nil]
+      def failure = raise(NotImplementedError)
+
+      # The attach is over (AttachLauncher.run): let go of what it held.
+      def close = raise(NotImplementedError)
     end
   end
 end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -335,10 +335,13 @@ module Samagotchi
           @status.take_event(event)
           @renderer.call(event)
         when :worker_changed then switch_worker(event)
+        # A stream through chi web (never a Bridge here): a reconnect failed,
+        # and the next frame came.
+        when :stream_retrying then @screen.commit("(lost the connection to #{via.remote || "the worker"}; reconnecting…)")
+        when :stream_resumed then @screen.commit("(reconnected)")
         when :stream_closed
           @view.finish_thinking_spinner
-          @screen.commit("Lost the session's worker (#{event[:reason]}). " \
-                             "Resume it with: #{via.command("--shared --resume #{@client.session_id}")}")
+          @screen.commit(closed_line(event[:reason].to_s))
           return :closed
         else @renderer.call(event)
         end
@@ -358,24 +361,47 @@ module Samagotchi
       def via = @link.via
 
       # The session's live worker for the stream to follow (EventStream's
-      # rediscover): nil while there is none yet, :gone once no worker is
-      # coming (AttachLink#live_worker). The reason isn't passed on: the
-      # stream closes as "unreachable", the words a stopped session has
-      # always had here.
-      def live_worker
-        found, _reason = @link.live_worker
-        found
-      end
+      # rediscover), with its reason (AttachLink#live_worker's pair): the
+      # stream's closing event carries the last one (#closed_line).
+      def live_worker = @link.live_worker
 
       # The stream moved to a new worker (a restart): requests go there too.
       def switch_worker(event)
         @client = @link.switched(event)
         @worker_changed = true
+        # The new worker's machine may name another default model.
+        @default_model_name = nil
         @view.finish_thinking_spinner
-        Log.info(:attached, "worker_changed", port: AttachLink.event_port(event))
+        Log.info(:attached, "worker_changed", port: AttachLink.event_port(event), epoch: event[:epoch])
         nil
       end
 
+      # The stream ended for good: why, and what brings the session back.
+      def closed_line(reason)
+        id = @client.session_id
+        return remote_closed_line(reason, id) if via.remote?
+
+        # Here a stopped session has always read as unreachable.
+        reason = "unreachable" if reason == "stopped"
+        "Lost the session's worker (#{reason}). Resume it with: #{via.command("--shared --resume #{id}")}"
+      end
+
+      # Each reason in its own words (the remote's name, its chi web's
+      # failure as AttachLink#failure gave it).
+      def remote_closed_line(reason, id)
+        name = via.remote
+        failure = @link.failure
+        case reason
+        when "stopped" then "The session was stopped on #{name}. Resume it with: #{via.resume(id)}"
+        when "auth_failed", "too_old" then "Lost the session: #{failure || reason}"
+        when "worker_gone" then "The session's worker on #{name} is gone. Resume it with: #{via.resume(id)}"
+        when "unknown_session" then "The session is gone from #{name} (deleted)."
+        else
+          cause = failure&.sub(/\Aremote \S+ \([^)]*\): /, "")
+          "Lost the connection to #{name}#{" (#{cause})" if cause}. Re-attach with: #{via.attach(id)}"
+        end
+      end
+
       def next_item(queue)
         queue.pop
       rescue Interrupt
@@ -404,6 +430,31 @@ module Samagotchi
           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).
+        @prefilled = kept if kept && submitted != :detach && @prefilled.nil? && @reader&.prefill(kept)
+        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
+        return [text, 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)
+        command = route.choice || %i[local command usage].include?(route.kind)
+        command ? [rest, kept] : [text, nil]
+      end
+
+      # @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
@@ -460,8 +511,9 @@ module Samagotchi
         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.
-        send_prompt(route.text, delivery: route.delivery)
+        # 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
 
@@ -634,6 +686,9 @@ module Samagotchi
       # Why a Bridge request raised, for the line that says what didn't go
       # through: a stopped (or wedged) worker times out, a gone one refuses.
       def worker_down(error)
+        # Through chi web: the message names the remote and what failed.
+        return error.message if via.remote?
+
         head, detail = error.message.split(" - ", 2)
         return "worker not answering: #{(detail || head).sub(/\Abridge \S+: /, "")}" if error.is_a?(Errno::ETIMEDOUT)
 
@@ -685,7 +740,9 @@ module Samagotchi
         @screen.commit("removed: #{first_line_clip(prompt)}")
         return if @wait_at_eof || prompt.strip.empty?
 
-        @screen.commit("(the removed message is in the input history: ↑)") unless @reader&.prefill(prompt)
+        return @prefilled = prompt.strip if @reader&.prefill(prompt)
+
+        @screen.commit("(the removed message is in the input history: ↑)")
       end
 
       def first_line_clip(text, max = 60)
@@ -807,11 +864,13 @@ module Samagotchi
       # 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.
+      # 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)
+      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.
@@ -838,7 +897,8 @@ module Samagotchi
         @client_id
       end
 
-      def send_prompt(text, delivery: nil)
+      # @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?
@@ -854,7 +914,7 @@ module Samagotchi
           @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)
+          note = sent_note(reply.json, delivery: delivery, images: images, running: running, choice: choice)
           @screen.commit(note) if note
           return
         end
@@ -938,6 +998,9 @@ module Samagotchi
       def show_stats
         metrics = @link.stats_metrics
         @screen.commit(metrics ? format_session_metrics(EventRenderer.deep_symbolize_keys(metrics)) : "(no metrics: the worker did not answer)")
+      rescue SystemCallError, IOError => e
+        # Through chi web: the message names the remote and what failed.
+        @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
@@ -980,8 +1043,8 @@ module Samagotchi
         @screen.commit(recap_command_text(enabled: answer["enabled"], saved: answer["saved"],
                                           request: answer["request"], min_user_turns: answer["min_user_turns"],
                                           session_off: answer["session_off"] == true))
-      rescue SystemCallError, IOError
-        @screen.commit("(no recap: the worker did not answer)")
+      rescue SystemCallError, IOError => e
+        @screen.commit("(no recap: #{via.remote? ? e.message : "the worker did not answer"})")
       end
 
       def prompt_text

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -118,6 +118,9 @@ module Samagotchi
       CUT_OFF_NOTE = "(cutting is off; goes in at the next step)"
       # A bare /cut or /queue (ComposerRoute's :usage).
       STEER_CHOICE_USAGE = "(/cut and /queue need a message: /cut TEXT, /queue TEXT)"
+      # A /cut TEXT or /queue TEXT with no turn running: the text is sent
+      # at once, a normal turn (ComposerRoute routes it on as a line).
+      STEER_CHOICE_IDLE = "(nothing is running: sent now)"
 
       # @param outcome [Symbol] SteerCut#cut_for_steer's answer: :now, :waits or :off
       # @param after [Integer, nil] the run's cut wait (the model's own
@@ -559,11 +562,20 @@ module Samagotchi
         "#{label}: #{visible.join(", ")}#{suffix}"
       end
 
+      # +text+ cut to +width+ with an ellipsis, at a word (or a " | "
+      # between segments) when one ends in the second half, so the row never
+      # stops mid-word (a plain surface prints it as is).
       def cap_preview_text(text, width)
         return "" if width <= 0
 
         value = text.to_s
-        value.length > width ? value[0, width] : value
+        return value if value.length <= width
+        return value[0, width] if width < 2
+
+        cut = value[0, width - 1]
+        space = cut.rindex(" ")
+        cut = cut[0, space] if space && space >= width / 2
+        "#{cut.sub(/[\s,;:|·-]+\z/, "")}…"
       end
 
       public

data/lib/samagotchi/terminal_ui/local_link.rb

@@ -117,6 +117,11 @@ module Samagotchi
 
       def via = ChiInvocation::HERE
 
+      # The closing line says it all (unreachable, unknown_session).
+      def failure = nil
+
+      def close = nil
+
       private
 
       def session_dir = Session.session_dir(@client.session_id, state_dir: @state_dir)

data/lib/samagotchi/terminal_ui/remote_connector.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "../session_access"
+require_relative "../session_access/remote"
+require_relative "../session_access/http_transport"
+require_relative "../owner_lock"
+require_relative "../launch_mode"
+require_relative "attach_launcher"
+require_relative "remote_link"
+
+module Samagotchi
+  class TerminalUI
+    # AttachLauncher.run's connector for a session on another machine: POST
+    # …/wake through that machine's chi web (the live worker, else one
+    # started there) and the RemoteLink the attached loop runs on. Its
+    # failures are AttachLauncher::Error, in the words chi web sent (the
+    # exceptions' own: one condition, one message).
+    class RemoteConnector
+      # @param remote [SessionAccess::Remote]
+      # @param session_id [String] resolved there already
+      # @param hostname [String] this machine's, for #client_id
+      # @param err [IO] where the wait for a leaving worker is said
+      def initialize(remote, session_id:, hostname: Socket.gethostname, err: $stderr)
+        @remote = remote
+        @session_id = session_id
+        @hostname = hostname
+        @err = err
+      end
+
+      # A worker there still leaving (its recap on leave) is said here
+      # (LaunchMode::RECAP_WAIT, as a local attach says it) and waited for
+      # by the wake, whose read then allows for that wait too.
+      # @return [RemoteLink]
+      # @raise [AttachLauncher::Error]
+      def connect
+        woke = @remote.attach_wake(@session_id, wait: AttachLauncher::BRIDGE_WAIT, read_timeout: wake_read_timeout)
+        RemoteLink.new(remote: @remote, session_id: @session_id, woke: woke)
+      rescue SessionManager::OwnedByTUI, SessionAccess::Refused, SessionAccess::RemoteFailed, ArgumentError => e
+        raise AttachLauncher::Error, e.message
+      end
+
+      # Seconds past the transport's read timeout a wake may take beyond its
+      # leave and Bridge waits there.
+      WAKE_READ_SLACK = 15.0
+
+      # nil (the transport's) unless the worker there is leaving: then its
+      # leave's budget left, OwnerLock::LEAVE_MARGIN, the Bridge wait and
+      # some slack, at least the transport's.
+      def wake_read_timeout
+        state = @remote.attach_worker(@session_id)
+        return nil unless state.leaving
+
+        @err.puts(LaunchMode::RECAP_WAIT)
+        budget = state.leave_seconds.to_f + OwnerLock::LEAVE_MARGIN + AttachLauncher::BRIDGE_WAIT + WAKE_READ_SLACK
+        [budget, SessionAccess::HTTPTransport::READ_TIMEOUT].max
+      end
+
+      # tui:PID@HOST (P4-D6): an interactive, human client for the UIs
+      # there (ClientId), with the machine it types on (its short name).
+      def self.client_id(hostname = Socket.gethostname) = "tui:#{Process.pid}@#{hostname.to_s.split(".").first}"
+
+      def client_id = RemoteConnector.client_id(@hostname)
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/remote_link.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+require_relative "attach_link"
+require_relative "../session_access"
+require_relative "../session_access/remote"
+require_relative "../session_access/web_bridge_client"
+require_relative "../children_status"
+require_relative "../image_store"
+require_relative "../delivery"
+require_relative "../session_inbox"
+require_relative "../log"
+
+module Samagotchi
+  class TerminalUI
+    # The AttachLink of a session on another machine (chi --remote NAME
+    # --attach ID), reached through that machine's chi web: one
+    # SessionAccess::WebBridgeClient for the whole attach (a new worker
+    # changes its worker_key, never the object), the worker's features from
+    # the wake and GET …/worker, and that machine's default model, newest
+    # chi and parent strategy. What stays this machine's: the prompt
+    # history, the run flags' baselines, the @path files (ingested here,
+    # uploaded there).
+    class RemoteLink
+      include AttachLink
+
+      # The registry ids (SessionCommands' local: true, :attached) the
+      # attached loop runs remotely as it does here: its own leaving, the
+      # deliveries, the dequeue route, and the exit, archive, stats and
+      # recap through chi web's routes.
+      HANDLED_COMMANDS = %i[detach cut queue unqueue exit archive stats recap].freeze
+
+      # About a minute of reconnects (P4-D5); a Bridge here keeps
+      # EventStream::REDISCOVER_DELAYS.
+      RECONNECT_DELAYS = [0.25, 0.5, 1.0, 2.0, 2.0, 3.0, 5.0, 5.0, 5.0, 5.0, 10.0, 10.0, 10.0].freeze
+      # How long chi web must answer "no live worker" (not stopped) before
+      # the reconnect wakes one (P4-D9): a restart's new worker comes
+      # sooner, so it isn't raced.
+      WAKE_AFTER = 3.0
+      # The wake's wait for a woken worker's Bridge (AttachLauncher's).
+      WAKE_WAIT = 10.0
+
+      attr_reader :client
+
+      # @param remote [SessionAccess::Remote]
+      # @param session_id [String]
+      # @param woke [SessionAccess::WakeReply] the launch's wake
+      # @param clock [#call] monotonic seconds
+      def initialize(remote:, session_id:, woke:, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        @remote = remote
+        @woke = woke
+        @features = Array(woke.worker&.fetch("features", nil))
+        @client = remote.attach_client(session_id, worker: woke.worker || {})
+        @clock = clock
+        @no_worker_since = nil
+        @woken_once = false
+        @failure = nil
+        @default_model = woke.default_model
+        @last_records = nil
+      end
+
+      # GET …/worker, with the reason when there is none: [client, nil]
+      # (its key updated in place: EventStream sees a move when it
+      # changed), [nil, reason] to retry, [:gone, reason] to stop. A worker
+      # chi web says isn't live and isn't stopped is woken once per
+      # outage, after WAKE_AFTER (P4-D9).
+      def live_worker
+        state = @remote.attach_worker(session_id)
+        return [:gone, "stopped"] if state.stopped
+        return follow(state.worker) if state.live
+
+        wake_once || [nil, "worker_gone"]
+      rescue SessionAccess::AuthRefused, SessionAccess::RemoteTooOld => e
+        @failure = e.message
+        [:gone, e.is_a?(SessionAccess::AuthRefused) ? "auth_failed" : "too_old"]
+      rescue SessionAccess::RemoteFailed => e
+        @failure = e.message
+        [nil, "unreachable"]
+      rescue ArgumentError
+        [:gone, "unknown_session"]
+      rescue StandardError => e
+        Log.debug(:attached, "rediscover_failed", error: e.class.name, message: e.message)
+        @failure = e.message
+        [nil, "unreachable"]
+      end
+
+      # Still the same client (its key moved already: the stream's epoch
+      # watch, or #live_worker); the new worker's features read again.
+      def switched(event)
+        epoch = event[:epoch] || event["epoch"]
+        @client.worker_key = epoch if epoch
+        refresh_features
+        @client
+      end
+
+      def queues? = @features.include?(Delivery::QUEUE_FEATURE)
+
+      def unqueues? = @features.include?(SessionInbox::UNQUEUE_FEATURE)
+
+      # Each @path image ingested here (converted and downscaled as chi send
+      # does), then uploaded into the session there.
+      def ingest_images(paths)
+        refs = paths.map { |path| ImageStore.ingest(image_dir, path: path) }
+        @remote.upload_images(session_id, refs, from: image_dir)
+      rescue SessionAccess::Refused => e
+        raise ImageStore::Error, e.message
+      rescue SessionAccess::RemoteFailed => e
+        raise SessionAccess::WebBridgeClient::Unreachable, e.message
+      end
+
+      # A turn's saved records there (GET …/turns/:turn_id/records): [] and
+      # nil when they can't be read, as for an older session. A join asks
+      # for the tool records, then the turn record, of the same turn: one
+      # read gives both, so the second takes what the first read.
+      def saved_tool_records(turn_id)
+        @last_records = [turn_id, turn_records(turn_id)]
+        Array(@last_records[1]&.fetch("tool_records", nil))
+      end
+
+      def saved_turn_record(turn_id)
+        read = @last_records&.first == turn_id ? @last_records[1] : turn_records(turn_id)
+        @last_records = nil
+        record = read&.fetch("turn_record", nil)
+        record.is_a?(Hash) ? record : nil
+      end
+
+      # The delegates' counts there (GET …/children/counts); none when they
+      # can't be read (the status row keeps no children segment).
+      def children_counts
+        json = @client.children_counts
+        ChildrenStatus::Counts.new(running: json["running"].to_i, waiting: json["waiting"].to_i,
+                                   unreported: json["unreported"].to_i)
+      rescue StandardError => e
+        Log.debug(:attached, "children_counts_failed", error: e.class.name, message: e.message)
+        ChildrenStatus::Counts.none
+      end
+
+      # GET …/stats (nil when the worker didn't give them).
+      # @raise [SessionAccess::WebBridgeClient::Unreachable] chi web couldn't
+      #   be asked, or has no worker for it: the loop says why
+      def stats_metrics = @client.stats
+
+      # /exit --delete, once the worker let go: DELETE …?force=true there
+      # (SessionManager.delete_session's refusals, raised from chi web's
+      # fields).
+      def delete_session
+        @remote.delete(session_id, force: true)
+      rescue SessionAccess::RemoteFailed => e
+        raise SessionAccess::WebBridgeClient::Unreachable, e.message
+      end
+
+      # /archive: POST …/archive there ({discarded: […]}, as
+      # SessionManager.archive_session's).
+      def archive_session
+        @remote.archive(session_id)
+      rescue SessionAccess::RemoteFailed => e
+        raise SessionAccess::WebBridgeClient::Unreachable, e.message
+      end
+
+      # That machine's newest chi (the wake's).
+      def installed_version = @woke.installed
+
+      # That machine's config's default model: the wake's, then the newest
+      # worker read's (a restart may come with another config).
+      def default_model_name = @default_model
+
+      # Read again now (a parent's report at the end of a run), the wake's
+      # when chi web can't be asked.
+      def parent_strategy
+        @remote.attach_worker(session_id).strategy
+      rescue StandardError
+        @woke.strategy
+      end
+
+      # / commands and this machine's @path files (images are ingested here);
+      # no memory names: they would be this machine's (P4-D11).
+      def completions = Completions.new(paths: true, memories: false)
+
+      def reconnect_delays = RECONNECT_DELAYS
+
+      def via = @remote.invocation
+
+      # Why chi web couldn't be asked, the last time it couldn't (its
+      # message: the remote's label and the cause), for the closing line.
+      attr_reader :failure
+
+      # The images' scratch dir goes with the attach.
+      def close
+        FileUtils.rm_rf(@image_dir) if @image_dir
+        @image_dir = nil
+      end
+
+      private
+
+      def session_id = @client.session_id
+
+      def image_dir = @image_dir ||= Dir.mktmpdir("chi-attach-images")
+
+      def follow(worker)
+        @no_worker_since = nil
+        @woken_once = false
+        @features = Array(worker&.fetch("features", nil))
+        key = worker && (worker["epoch"] || worker["started_at"])
+        @client.worker_key = key if key
+        [@client, nil]
+      end
+
+      # nil while chi web hasn't said "no worker" for WAKE_AFTER yet, or
+      # once this outage's wake was made (or failed).
+      def wake_once
+        now = @clock.call
+        @no_worker_since ||= now
+        return nil if @woken_once || now - @no_worker_since < WAKE_AFTER
+
+        @woken_once = true
+        woke = @remote.attach_wake(session_id, wait: WAKE_WAIT)
+        follow(woke.worker)
+      rescue SessionAccess::Refused, SessionManager::OwnedByTUI => e
+        @failure = e.message
+        nil
+      end
+
+      # nil without a turn id (an older session's prompt) or when chi web
+      # can't give them (a join reads them within JOIN_READ_TIMEOUT).
+      def turn_records(turn_id)
+        return nil if turn_id.to_s.empty?
+
+        json = @client.turn_records(turn_id)
+        json.is_a?(Hash) ? json : nil
+      rescue StandardError => e
+        Log.debug(:attached, "turn_records_failed", error: e.class.name, message: e.message)
+        nil
+      end
+
+      def refresh_features
+        state = @remote.attach_worker(session_id)
+        @features = Array(state.worker&.fetch("features", nil)) if state.live
+        @default_model = state.default_model if state.default_model
+      rescue StandardError => e
+        Log.debug(:attached, "worker_features_failed", error: e.class.name, message: e.message)
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/version_lines.rb

@@ -20,6 +20,7 @@ module Samagotchi
       # @return [String, nil] one "chi> ..." line, or nil when all is current
       def at_attach(worker:, installed:, session_id:, terminal: VERSION, via: ChiInvocation::HERE)
         return nil if worker.to_s.empty?
+        return across_machines(worker: worker, installed: installed, session_id: session_id, terminal: terminal, via: via) if via.remote?
 
         newest = [installed, terminal].select { |v| Gem::Version.correct?(v.to_s) && !v.to_s.empty? }
                                       .max_by { |v| Gem::Version.new(v) }
@@ -41,6 +42,28 @@ module Samagotchi
         end
       end
 
+      # A remote attach (P4-D10): the worker and +installed+ are that
+      # machine's, the terminal this one's, so each is advised where it
+      # runs: the worker older than that machine's newest moves with chi
+      # --remote NAME sessions restart; this terminal older than the newer
+      # of the two updates here.
+      # @return [String, nil]
+      def across_machines(worker:, installed:, session_id:, terminal:, via:)
+        there = [installed, worker].select { |v| Gem::Version.correct?(v.to_s) && !v.to_s.empty? }
+                                   .max_by { |v| Gem::Version.new(v) }
+        worker_old = InstalledVersions.newer?(installed, worker)
+        terminal_old = InstalledVersions.newer?(there, terminal)
+        return nil unless worker_old || terminal_old
+
+        lines = []
+        if worker_old
+          lines << "the session's worker runs chi #{worker}; #{via.remote} has #{installed} installed: " \
+                   "#{via.command("sessions restart #{session_id.to_s[0, 8]}")}"
+        end
+        lines << "#{worker_old ? "This" : "this"} terminal runs chi #{terminal} (#{via.remote} has #{there}): chi update here" if terminal_old
+        "chi> #{lines.join(". ")}"
+      end
+
       # After the stream moved to a new worker (a restart).
       def restarted(worker)
         worker.to_s.empty? ? "chi> the session's worker restarted" : "chi> the session's worker restarted on chi #{worker}"

data/lib/samagotchi/terminal_ui.rb

@@ -867,7 +867,10 @@ module Samagotchi
       route = ComposerRoute.call(input, running: false, registry: command_registry)
       return @surface.commit(STEER_CHOICE_USAGE) if route.kind == :usage
 
-      input = route.text if route.choice
+      if route.choice
+        input = route.text
+        @surface.commit(STEER_CHOICE_IDLE)
+      end
 
       # /model, /models, !rollback, !cmd, /continue (shared with workers);
       # an anytime command's cards print as it shows them (btw's