samagotchi 0.63.0 → 0.64.0

data/lib/samagotchi/session_manager.rb

@@ -205,8 +205,9 @@ module Samagotchi
     # child inherits this process's ENV and reads config.yml itself (as it
     # is when the worker starts); opts[:env] adds to it (merged, not
     # replaced) what it can't read there: this `chi`'s CLI settings
-    # (Config.cli_env), the hosts and the absolute log file. It unsets
-    # SAMAGOTCHI_GUARDRAILS_* and the session markers (SESSION_MARKER_ENV).
+    # (Config.cli_env) and the absolute log file. It unsets
+    # SAMAGOTCHI_GUARDRAILS_*, the session markers (SESSION_MARKER_ENV) and
+    # SAMAGOTCHI_HOSTS_JSON (HOSTS_JSON_ENV).
     # XDG_CONFIG_HOME passes: whoever starts or
     # wakes the worker picks which config.yml it reads (docs/guardrails.md).
     private_class_method def self.spawn_options(session)
@@ -223,14 +224,12 @@ module Samagotchi
         Log.warn(:worker, "cwd_gone", sid: session.id, dir: dir, cwd: Dir.pwd)
       end
       child_env = {}
-      # Propagate hosts config for multi-host routing
-      begin
-        require_relative "config"
-        hosts_json = ConfigFile.hosts_json_for_env
-        child_env["SAMAGOTCHI_HOSTS_JSON"] = hosts_json if hosts_json && !hosts_json.strip.empty?
-      rescue StandardError
-        nil
-      end
+      # The worker reads config.yml's hosts: as it starts, like every other
+      # setting: a host added or changed after this process (a parent
+      # worker, `chi web`) started reaches it. Unset, not just left out: a
+      # worker an older chi started still has one, and its delegates would
+      # inherit its start-time hosts.
+      child_env[HOSTS_JSON_ENV] = nil
       # A worker gets no CLI args: --model, --thinking, --log-level and the
       # other flags this chi was started with.
       child_env.merge!(Config.cli_env)
@@ -694,7 +693,7 @@ module Samagotchi
     # so a resume right after spawns a fresh worker instead of finding the
     # dying one.
     # A turn still running is canceled first (STOP_CANCEL_WAIT), as the
-    # web's Cancel does: its worker saves it. The TERM stops (and saves)
+    # web's Cancel does, with reason STOP_CANCEL_REASON: its worker saves it. The TERM stops (and saves)
     # what still runs (WorkerSignals), with a short grace after the marker.
     # @return [Boolean, nil] with +wait+: whether the owner was gone in time
     # @raise [OwnedByTUI] when the interactive TUI owns the session
@@ -714,7 +713,14 @@ module Samagotchi
       wait_for_owner_release(session_id, timeout: wait, state_dir: sd) if wait
     end
 
+    # ConfigFile.hosts_config's override of config.yml's hosts:, which no
+    # spawned worker inherits (spawn_options).
+    HOSTS_JSON_ENV = "SAMAGOTCHI_HOSTS_JSON"
+
     STOP_CANCEL_WAIT = 3.0
+    # The cancel reason of a turn a session stop cancels (Bridge::CANCEL_REASONS):
+    # not the user's Stop, which only ends the turn ("user").
+    STOP_CANCEL_REASON = "session_stopped"
 
     # Cancel the session's running turn over its Bridge and wait (up to
     # STOP_CANCEL_WAIT) for the worker to save it. Best effort: without a
@@ -723,7 +729,7 @@ module Samagotchi
       return unless Session.load(session_id, state_dir: state_dir).status == Session::STATUS_RUNNING
 
       client = BridgeClient.discover(session_id, session_dir: Session.session_dir(session_id, state_dir: state_dir))
-      return unless client && client.cancel(reason: "user").status == 202
+      return unless client && client.cancel(reason: STOP_CANCEL_REASON).status == 202
 
       BridgeClient.poll(STOP_CANCEL_WAIT) do
         Session.load(session_id, state_dir: state_dir).status != Session::STATUS_RUNNING
@@ -1167,9 +1173,12 @@ module Samagotchi
     #   the session's sidecar, waiting TURN_BRIDGE_WAIT for a new worker's
     # @return [Hash] {status: :accepted, ack: Hash} (the Bridge's reply, or
     #   {status:, enqueued_id:, session_id:} for a file), {status: :refused,
-    #   code:, ack:} when the Bridge refused the images, {status: :timeout,
-    #   ack:} when it took the request but never answered (no file then), or
-    #   {status: :failed} when the input file couldn't be written
+    #   code:, ack:} when the Bridge refused the request (any 4xx with an
+    #   error: bad images, a delivery it doesn't run) or a queue would reach
+    #   a worker that doesn't queue (no file then: it would steer),
+    #   {status: :timeout, ack:} when it took the request but never answered
+    #   (no file then), or {status: :failed} when the input file couldn't be
+    #   written
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, state_dir: nil, manager: self,
@@ -1178,20 +1187,28 @@ module Samagotchi
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir)
       if (client = bridge.call)
+        # A worker from before queueing (no "delivery" feature) ignores the
+        # field or refuses it; either way a file would steer the running turn.
+        return queue_unavailable if Delivery.queue?(delivery) && !worker_queues?(session_dir)
+
         begin
           options = { prompt: prompt, client_id: client_id }
           options[:images] = images unless images.empty?
-          # An old worker ignores the field: it cuts anyway (its own default)
-          # and its file never carries a queue, so a queue would steer there.
+          # An old worker ignores the field: it cuts anyway (its own default).
           options[:delivery] = delivery unless Delivery.next_step?(delivery)
           reply = client.post_turn(**options)
           ack = reply.json
           return { status: :accepted, ack: ack } if reply.status == 202 && ack.is_a?(Hash)
-          if ack.is_a?(Hash) && ack["error"] == "bad_images"
-            return { status: :refused, code: reply.status, ack: ack }
-          end
           # Read after its deadline and dropped: a file would run it after all.
           return turn_timeout if ack.is_a?(Hash) && ack["error"] == "deadline_passed"
+          # Any other 4xx with an error is a refusal (bad images, a delivery
+          # it doesn't run, a client bug): a file would bypass it, and a
+          # refused queue would steer. A 413 (a body over the Bridge's
+          # limit, a big piped chi send) and a 5xx keep the file fallback
+          # below, which carries the delivery (a queue too).
+          if (400..499).cover?(reply.status) && reply.status != 413 && ack.is_a?(Hash) && ack["error"]
+            return { status: :refused, code: reply.status, ack: ack }
+          end
         rescue Errno::ETIMEDOUT
           # The Bridge drops a turn it reads after the request's deadline
           # (BridgeClient#post_turn), so a worker that wakes later won't run
@@ -1222,6 +1239,18 @@ module Samagotchi
       { status: :accepted, ack: { status: "accepted", enqueued_id: enqueued_id, session_id: session_id } }
     end
 
+    # Whether the session's live worker runs delivery: queue (its sidecar
+    # names the feature). No sidecar to read (the client came from a stand-in,
+    # or it went between the wait and here): true, the post finds out.
+    private_class_method def self.worker_queues?(session_dir)
+      sidecar = WorkerSidecar.read(session_dir)
+      sidecar.nil? || sidecar.features.include?(Delivery::QUEUE_FEATURE)
+    end
+
+    private_class_method def self.queue_unavailable
+      { status: :refused, code: 409, ack: Delivery::QUEUE_UNAVAILABLE }
+    end
+
     private_class_method def self.turn_timeout
       { status: :timeout, ack: { "error" => "worker_timeout",
                                  "detail" => "the session's worker did not answer, so the message was not sent" } }

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../client_id"
+require_relative "../composer_route"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "../prompt_history"
@@ -387,61 +388,72 @@ module Samagotchi
         end
 
         # /cut TEXT and /queue TEXT are this UI's own deliveries, read before
-        # every command check (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.
-        if (choice = steer_choice(text))
-          return submit_delivery(*choice)
-        end
+        # 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 = command_registry.lookup_local(text)&.id
+        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 || command_registry.command?(text)
+          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 text.empty?
+        return if route.kind == :empty
 
         if local == :stats
           show_stats
         elsif local == :recap
           show_recap
-        elsif command_registry.command?(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 (hint = command_registry.unknown_command_hint(text))
+        elsif route.kind == :typo
           # A typo of a command (/modle) is not a prompt: say so, send nothing.
-          @screen.commit(hint)
+          @screen.commit(route.reply)
         else
           send_prompt(text)
         end
         nil
       end
 
-      # /cut TEXT and /queue TEXT while a turn runs. Only /cut goes in P1:
-      # the worker's drain doesn't skip queued files yet, so a queued
-      # message would steer the running turn; /queue says so and sends
-      # nothing. At the prompt both run the text as a normal turn.
+      # /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(choice, text)
-        return @screen.commit(STEER_CHOICE_USAGE) if text.empty?
-        return @screen.commit(QUEUE_UNAVAILABLE) if choice == :queue && @running
+      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.
-        send_prompt(text, delivery: @running ? Delivery::CUT : nil)
+        send_prompt(route.text, delivery: route.delivery)
         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?
+        sidecar = WorkerSidecar.read(Session.session_dir(@client.session_id, state_dir: @state_dir))
+        sidecar.nil? || sidecar.features.include?(Delivery::QUEUE_FEATURE)
+      end
+
       # @return [Symbol] :detach
       def detach(line)
         @view.finish_thinking_spinner
@@ -601,9 +613,9 @@ module Samagotchi
       end
 
       QUEUED_NOTE = "(queued: runs after this turn)"
-      # /queue needs a worker whose drain skips queued input files (P3):
-      # until then a queued message would steer the running turn.
-      QUEUE_UNAVAILABLE = "(/queue isn't available in an attached session yet)"
+      QUEUE_RUNS_NOW = "(the turn had ended: runs as the next turn)"
+      # /queue to a worker from before queueing, which would steer it.
+      QUEUE_NEEDS_NEWER_WORKER = "(/queue needs a newer worker: restart it with chi sessions restart, then send again)"
 
       # A command queued for after the running turn (command_queued with
       # waits): its line now (another client's) and a note; its command_ran
@@ -709,14 +721,20 @@ module Samagotchi
       # 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).
+      # 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.
       # @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)
-        return nil unless running && images.empty? && ack.is_a?(Hash)
+        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
 
@@ -748,6 +766,8 @@ module Samagotchi
         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
@@ -1411,7 +1431,8 @@ module Samagotchi
         return if own?(event[:client_id])
 
         @shown_enqueued << event[:enqueued_id]
-        @screen.commit(prompt_line(event[:client_id], event[:prompt]))
+        line = prompt_line(event[:client_id], event[:prompt])
+        @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)
       end
 
       def start_turn(event)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -108,14 +108,8 @@ module Samagotchi
       CUT_NOW_NOTE = "(cut in now)"
       CUT_WAITS_NOTE = "(cuts in once the thinking passes %d s)"
       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)"
-      # The UIs' own words for a delivery, listed for Tab and /help only
-      # (a local: entry, so no command or bundle may use the names).
-      CUT_COMMAND = "/cut"
-      QUEUE_COMMAND = "/queue"
-      # The word, then any whitespace and the text (as the registry's
-      # entries match them, so a line Tab or /help knows is never a prompt).
-      STEER_CHOICE = /\A(#{CUT_COMMAND}|#{QUEUE_COMMAND})(?:\s+(.*))?\z/m
 
       # @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
@@ -133,17 +127,6 @@ module Samagotchi
       # The same words, for a UI that includes the module.
       def steer_cut_note(outcome, after = nil) = Formatting.steer_cut_note(outcome, after)
 
-      # The choice a mid-turn line carries, as [:cut, "TEXT"] or
-      # [:queue, "TEXT"]; nil for any other line. The text is "" when the
-      # line named the choice without one.
-      # @param line [String, nil]
-      # @return [Array(Symbol, String), nil]
-      def steer_choice(line)
-        match = STEER_CHOICE.match(line.to_s.strip) or return nil
-
-        [match[1] == CUT_COMMAND ? :cut : :queue, match[2].to_s.strip]
-      end
-
       # "✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid
       # off)": a batch of LLM context edits went in (LLMContextNotice builds
       # the line; the web prints the same), dim like the retry row.
@@ -363,7 +346,8 @@ module Samagotchi
 
       # A cancel's reason as the UIs name it (anything else as it is);
       # spec/shared/labels_matrix.json pins it for both.
-      CANCEL_REASONS = { "ctrl_c" => "Ctrl-C", "user" => "stopped", "hook" => "by a hook", "worker_stopped" => "worker stopped" }.freeze
+      CANCEL_REASONS = { "ctrl_c" => "Ctrl-C", "user" => "stopped", "hook" => "by a hook", "worker_stopped" => "worker stopped",
+                         "session_stopped" => "session stopped" }.freeze
       # A canceled turn's mark: a stop someone chose (Ctrl-C, Stop, a hook),
       # not an error's ✕ (timing.js STOP_MARK; the labels matrix pins it).
       STOP_MARK = "■"

data/lib/samagotchi/terminal_ui.rb

@@ -25,6 +25,7 @@ require_relative "tools/memory"
 require_relative "output_formatter"
 require_relative "turn_flow"
 require_relative "session_commands"
+require_relative "composer_route"
 require_relative "terminal_ui/attached_view"
 require_relative "terminal_ui/between_turns"
 require_relative "terminal_ui/event_renderer"
@@ -296,11 +297,11 @@ module Samagotchi
 
       if @prompt && @non_interactive
         # A /cut TEXT / /queue TEXT prompt runs its text as the turn's
-        # prompt, the same as the idle REPL does (Formatting#steer_choice);
+        # prompt, the same as the idle REPL does (ComposerRoute.steer_choice);
         # a bare /cut / /queue (no text) is refused above as a UI command,
         # so only the text here. The images are the text's, not the words'.
         one_shot_prompt =
-          if (choice = steer_choice(@prompt)) && !choice.last.empty?
+          if (choice = ComposerRoute.steer_choice(@prompt)) && !choice.last.empty?
             choice.last
           else
             @prompt
@@ -834,34 +835,35 @@ module Samagotchi
       return if input.empty?
 
       # /cut TEXT and /queue TEXT are deliveries only while a turn runs; at
-      # the prompt both run the text as a normal turn, as their usage says.
-      if (choice = steer_choice(input))
-        return @surface.commit(STEER_CHOICE_USAGE) if choice.last.empty?
+      # the prompt both run the text as a normal turn, as their usage says
+      # (the route is the text's).
+      route = ComposerRoute.call(input, running: false, registry: command_registry)
+      return @surface.commit(STEER_CHOICE_USAGE) if route.kind == :usage
 
-        input = choice.last
-      end
+      input = route.text if route.choice
 
       # /model, /models, !rollback, !cmd, /continue (shared with workers);
       # an anytime command's cards print as it shows them (btw's
       # "thinking…" before the answer). Piped input has nobody to answer a
       # confirm (the next line is already written): a costly /thinking or
       # /reasoning-history applies at once.
-      confirm = !piped_input?
-      command = if command_registry.anytime?(input)
-                  @engine.running_anytime { @commands.run(input, confirm: confirm) }
-                else
-                  @commands.run(input, confirm: confirm)
-                end
-      if command
-        show_command_result(command)
-        persist_recent_history(input) if command.shell
-        return
-      end
-      return if show_local_command(input)
-
+      case route.kind
+      when :command
+        confirm = !piped_input?
+        command = if command_registry.anytime?(input)
+                    @engine.running_anytime { @commands.run(input, confirm: confirm) }
+                  else
+                    @commands.run(input, confirm: confirm)
+                  end
+        if command
+          show_command_result(command)
+          persist_recent_history(input) if command.shell
+          return
+        end
+      when :local then return if show_local_command(input)
       # A typo of a command (/modle) is not a prompt: say so, send nothing.
-      hint = command_registry.unknown_command_hint(input)
-      return @surface.commit(hint) if hint
+      when :typo then return @surface.commit(route.reply)
+      end
 
       @turn_flow.before_prompt_turn
       persist_recent_history(input)
@@ -1164,29 +1166,42 @@ module Samagotchi
     #
     # A command that waits for the turn's end (/model X, !cmd) and every line
     # after it wait in @after_turn, in the order typed (D1), with the image
-    # lines (which never steer): once the turn ends they come back after the
-    # steering it didn't merge (typed before them), ahead of anything sent
-    # after Ctrl-C.
+    # lines (which never steer) and /queue's: once the turn ends they come
+    # back with the steering it didn't merge, in the order sent (each line
+    # the turn takes gets the next @input_seq), ahead of anything sent after
+    # Ctrl-C.
     def with_steering(&)
       return yield unless @repl_input
 
       @after_turn = []
       @command_waits = false
-      @repl_input.during_turn(method(:steer_line), leftovers: -> { @pending_input_queue.drain + lines_after_turn }, &)
+      @input_seq = 0
+      @repl_input.during_turn(method(:steer_line), leftovers: -> { leftover_lines }, &)
+    end
+
+    # The turn's leftovers in send order: steering it didn't merge and the
+    # lines that waited for its end.
+    def leftover_lines
+      (@pending_input_queue.drain_entries + lines_after_turn).sort_by { |seq, _| seq || 0 }.map(&:last)
     end
 
-    # The lines that waited for the turn's end, taken from @after_turn. After
-    # a canceled or failed turn (Ctrl-C raises through here; a failure too)
-    # a !cmd among them is dropped (D4): running it would close the
-    # !rollback the turn left.
+    # The next line's place in send order (#leftover_lines).
+    def next_input_seq
+      @input_seq = (@input_seq || 0) + 1
+    end
+
+    # The [seq, line] entries that waited for the turn's end, taken from
+    # @after_turn. After a canceled or failed turn (Ctrl-C raises through
+    # here; a failure too) a !cmd among them is dropped (D4): running it
+    # would close the !rollback the turn left.
     def lines_after_turn
-      lines = @after_turn.slice!(0..)
+      entries = @after_turn.slice!(0..)
       ended = if @active_cancel_controller&.cancelled? || $!.is_a?(Interrupt) then "canceled"
               elsif $! then "failed"
               end
-      return lines unless ended
+      return entries unless ended
 
-      lines.reject do |line|
+      entries.reject do |_seq, line|
         next false unless command_registry.lookup(line)&.id == :shell
 
         @surface.commit("turn #{ended}: #{line.strip} not run; send it again")
@@ -1207,28 +1222,32 @@ module Samagotchi
     # to end and runs as a turn of its own.
     # @return [Boolean, :back] whether the turn took it, :back to put it back
     def steer_line(line)
-      local = local_command(line) unless line.nil?
+      route = ComposerRoute.call(line, running: true, registry: command_registry) unless line.nil?
+      local = route&.local
       return exit_after_turn(delete: SessionCommands.delete_on_exit?(line)) if line.nil? || local == :exit
       return archive_after_turn if local == :archive
       return detach_note if local == :detach
       return false if @active_cancel_controller&.cancelled?
 
-      # Before every command check: /cut and /queue are the UIs' own words
-      # for a delivery (they are listed for Tab and /help, never run).
-      if (choice = steer_choice(line))
-        return submit_steer_choice(*choice)
+      case route.kind
+      # Before every command check (ComposerRoute): /cut and /queue are the
+      # UIs' own words for a delivery (listed for Tab and /help, never run).
+      when :usage
+        @surface.commit(STEER_CHOICE_USAGE)
+        return true
+      when :deliver then return submit_steer_choice(route.delivery, route.text)
+      when :command
+        policy = command_registry.mid_turn(line)
+        return start_anytime_command(line) if policy == :anytime
+        return command_queued(line) if policy == :queue
       end
-
-      policy = command_registry.mid_turn(line)
-      return start_anytime_command(line) if policy == :anytime
-      return command_queued(line) if policy == :queue
       # A command, never steering text.
-      return command_during_turn(line) if local || command_registry.command?(line)
-      return true if line.strip.empty?
+      return command_during_turn(line) if %i[local command].include?(route.kind)
+      return true if route.kind == :empty
 
       # A typo of a command (/modle) is not steering text: say so, take it.
-      if (hint = command_registry.unknown_command_hint(line))
-        @surface.commit(hint)
+      if route.kind == :typo
+        @surface.commit(route.reply)
         return true
       end
       # Steering merges text only: a line with images runs as the next turn.
@@ -1236,7 +1255,7 @@ module Samagotchi
       # Behind a command that waits for the turn's end, a line waits too.
       return wait_for_turn_end(line) if @command_waits
 
-      @pending_input_queue.push(line.strip)
+      @pending_input_queue.push(route.text, seq: next_input_seq)
       @surface.commit(NEXT_STEP_NOTE)
       true
     end
@@ -1245,25 +1264,21 @@ module Samagotchi
     # otherwise read as prompts (SessionCommands registers them for Tab and
     # help only). A cut asks the engine to cut the generation only thinking
     # too long; a queue waits for the turn's end (the REPL's own after-turn
-    # list). Empty text gets the usage line. A line with images never steers
-    # (as a plain one doesn't).
+    # list). A line with images never steers (as a plain one doesn't).
+    # @param delivery [String] Delivery::CUT or Delivery::QUEUE (ComposerRoute)
     # @return [Boolean] whether the turn took it
-    def submit_steer_choice(choice, text)
-      if text.empty?
-        @surface.commit(STEER_CHOICE_USAGE)
-        return true
-      end
+    def submit_steer_choice(delivery, text)
       return image_line_waits(text) if ImageInput.extract(text).any?
 
       # A /queue waits for the turn's end; a /cut behind a command that
       # already waits there goes after it too.
-      if choice == :queue || @command_waits
+      if Delivery.queue?(delivery) || @command_waits
         @surface.commit(COMMAND_QUEUED)
         return wait_for_turn_end(text)
       end
 
       epoch = @engine.input_epoch
-      @pending_input_queue.push(text)
+      @pending_input_queue.push(text, seq: next_input_seq)
       # With no session running the cut is :off; the text still waits for
       # the running turn's next step.
       @surface.commit(steer_cut_note(@engine.cut_for_steer(nil, epoch: epoch), @engine.steer_cut_after))
@@ -1278,7 +1293,7 @@ module Samagotchi
     # +line+ runs once the turn has ended, in the order typed (#with_steering).
     # @return [true] the turn took it
     def wait_for_turn_end(line)
-      @after_turn << line
+      @after_turn << [next_input_seq, line]
       true
     end
 

data/lib/samagotchi/tool_activity.rb

@@ -211,14 +211,14 @@ module Samagotchi
     # "stopped" for a
     # task_wait the user's Stop ended (the task itself runs on), for one
     # whose task was stopped (the stop-task button, or the model's task_stop),
-    # and for a command the user's Stop (or a signal to chi) killed or kept
-    # from starting: a cancel, not a failure (its text still starts "Error:"
-    # for the model).
+    # and for a command the user's Stop (or a signal to chi, a session stop)
+    # killed or kept from starting: a cancel, not a failure (its text still
+    # starts "Error:" for the model).
     def tool_activity_status(result, tool_name = nil, command: nil)
       text = result.to_s
-      return "stopped" if [Tools::Execute::NOT_RUN_ON_STOP, Tools::Execute::NOT_RUN_ON_SIGNAL].include?(text)
+      return "stopped" if [Tools::Execute::NOT_RUN_ON_STOP, *Tools::Execute::NOT_RUN.values].include?(text)
       if tool_name == Tools::Execute::NAME &&
-         text.start_with?(Tools::Execute::STOPPED_BY_USER, Tools::Execute::STOPPED_BY_SIGNAL)
+         text.start_with?(Tools::Execute::STOPPED_BY_USER, *Tools::Execute::STOPPED_BY.values)
         return "stopped"
       end
       return "error" if text.start_with?("Error:")

data/lib/samagotchi/tools/delegate.rb

@@ -203,7 +203,9 @@ module Samagotchi
         delivered = SessionManager.deliver_turn(id, prompt: task, client_id: "#{ClientId::DELEGATE_PREFIX}#{parent.id[0, 8]}",
                                                     state_dir: state_dir)
         case delivered[:status]
-        when :accepted then id
+        when :accepted
+          DelegateWait.mark_turn(parent.id, id, follow_up_turn(id, delivered[:ack], state_dir: state_dir), state_dir: state_dir)
+          id
         when :refused then "Error: session #{id[0, 8]} refused the message (#{delivered.dig(:ack, "error")})"
         when :timeout then "Error: the worker of session #{id[0, 8]} did not answer in time, so the message was not sent"
         else "Error: the message to session #{id[0, 8]} could not be written"
@@ -215,6 +217,31 @@ module Samagotchi
       end
       private_class_method :follow_up
 
+      # The child's turn a delivered follow-up joins, for the wait
+      # (DelegateCursor#turn): the running turn's (its checkpoint mark), the
+      # follow-up merging into it; else the ack's enqueued_id, the follow-up
+      # running as a turn of its own. Only from a worker that names
+      # turn_ids; nil otherwise, or when the running turn has no id (a
+      # delegate's first turn): the wait takes the next reply.
+      # A follow-up steered into a turn that ended before it merged runs as
+      # its own turn, yet the wait is on the ended one (LOW, as before).
+      # One the child's idle look missed being merged into a turn starting
+      # then never runs as its own: ReplyWait falls back to that turn's
+      # reply (merged_elsewhere?).
+      # @return [String, nil]
+      def self.follow_up_turn(id, ack, state_dir:)
+        return nil unless ReplyWait.turn_ids?(Session.session_dir(id, state_dir: state_dir))
+
+        child = Session.load(id, state_dir: state_dir)
+        return child.interrupted_turn&.enqueued_id if child.status == Session::STATUS_RUNNING
+
+        enqueued_id = ack.is_a?(Hash) ? (ack["enqueued_id"] || ack[:enqueued_id]) : nil
+        enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
+      rescue ArgumentError
+        nil
+      end
+      private_class_method :follow_up_turn
+
       # The model as typed (spawn_session stores its resolved ref), else the
       # parent's. No existence check here: spawn_session checks the host
       # (check_host!, its UnknownHost comes back as this tool's Error: line)