samagotchi 0.63.0 → 0.65.0

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"
@@ -259,13 +260,17 @@ module Samagotchi
           take_session_state(event[:session_state_snapshot] || {})
           return render_snapshot(event[:snapshot] || {}, reset: event[:type] == :reset)
         when :turn_enqueued then show_enqueued(event)
-        when :turn_started then start_turn(event)
+        when :turn_started
+          @status.take_event(event)
+          start_turn(event)
         when :turn_completed
+          @status.take_event(event)
           complete_turn(event)
           refresh_children
           own_turn_ended(event)
         # The renderer says how it ended (the REPL's words too).
         when :turn_canceled, :turn_failed
+          @status.take_event(event)
           @renderer.call(event)
           end_turn
           refresh_children
@@ -387,61 +392,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 +617,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 +725,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 +770,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
@@ -1219,7 +1243,7 @@ module Samagotchi
         # 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"]))
+          @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
@@ -1359,6 +1383,8 @@ module Samagotchi
       def render_current_turn(turn)
         @running = !turn.nil?
         @joined_mid_turn = @running
+        # A turn running at the join: the status row's steer hint.
+        @status.update(running: @running)
         return unless turn
 
         continues = turn[:prompt].nil?
@@ -1411,7 +1437,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/event_renderer.rb

@@ -179,7 +179,8 @@ module Samagotchi
         end
         # No answer: chi's muted notice, never an empty answer line.
         if summary[:empty_answer]
-          @view.print_line(@view.format_empty_answer_line(summary.dig(:empty_answer, :retries)))
+          empty = summary[:empty_answer]
+          @view.print_line(@view.format_empty_answer_line(empty[:retries], empty[:refusal]))
         else
           @view.print_line(summary[:output])
         end

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.
@@ -152,9 +135,10 @@ module Samagotchi
       end
 
       # "no answer: the model returned nothing (after 1 retry)", dim like the
-      # retry row: a turn that ended with no answer (TurnNote.empty_answer_line).
-      def format_empty_answer_line(retries)
-        paint(TurnNote.empty_answer_line(retries), 90)
+      # retry row: a turn that ended with no answer, or "no answer: refused
+      # by the provider (cyber)" for a +refusal+ (TurnNote.empty_answer_line).
+      def format_empty_answer_line(retries, refusal = nil)
+        paint(TurnNote.empty_answer_line(retries, refusal: refusal), 90)
       end
 
       # "↻ retrying (503) in 4.0s, 2/5": the live status while the provider
@@ -363,7 +347,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/status_row.rb

@@ -28,7 +28,15 @@ module Samagotchi
       #   preloaded             its --memory list (shown until a turn
       #                         records them as used)
       #   muted                 its --mute list
-      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted].freeze
+      #   running               a turn runs: the row trails STEER_HINT
+      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted running].freeze
+
+      # The tail while a turn runs: where a typed line goes (the next step)
+      # and the two other choices. Dropped whole first when the row is cut.
+      STEER_HINT = " · typing goes in at the next step (/cut, /queue)"
+
+      # The turn events that end a turn (the hint goes).
+      TURN_END_EVENTS = %i[turn_completed turn_canceled turn_failed].freeze
 
       # @param surface [Surface] with #columns
       def initialize(surface)
@@ -77,13 +85,16 @@ module Samagotchi
 
       # Take what a turn event says about the row (the Engine's events in
       # the REPL, the Bridge's in attached mode): ctx, the memories used,
-      # the model the server served. Other events change nothing.
+      # the model the server served, whether a turn runs (the steer
+      # hint). Other events change nothing.
       def take_event(event)
         case event[:type]
         when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
           update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]
+        when :turn_started then update(running: true)
+        when *TURN_END_EVENTS then update(running: false)
         end
       end
 
@@ -119,11 +130,21 @@ module Samagotchi
                     status_context_text(estimate: @values[:context]),
                     status_memory_text(Array(@values[:used_memories]) | Array(@values[:preloaded]), MEMORY_LIMIT),
                     status_memory_text(@values[:muted], MEMORY_LIMIT, label: "muted")].reject(&:empty?)
-        status_rows(segments, width)
+        status_rows(with_steer_hint(segments, width), width)
       end
 
       private
 
+      # +segments+ with STEER_HINT after the last while a turn runs, when
+      # the whole row fits +width+ with it: on a narrow terminal the hint
+      # goes first, whole, before anything else is cut.
+      def with_steer_hint(segments, width)
+        return segments unless @values[:running] && segments.any?
+        return segments if "status> #{segments.join(" | ")}#{STEER_HINT}".length > width
+
+        segments[0..-2] + ["#{segments.last}#{STEER_HINT}"]
+      end
+
       # `⑂ 2 running · 1 waiting`, the counts there are; "" with neither (no
       # children, or all ended). Not "not reported": a REPL parent is never
       # given its children's replies (no wakes there), and a worker moves

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)

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -10,9 +10,14 @@ module Samagotchi
     # What a parent was already told about one delegate child: the newest
     # reply it was given (+reply_file+, ReplyWait's cursor) and the child as
     # it was then (+messages+, +question_id+, +last_turn+: ReplyWait's
-    # baseline). nil +messages+ means no baseline.
-    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages) do
-      def self.empty = new(reply_file: nil, last_turn: nil, question_id: nil, messages: nil)
+    # baseline). nil +messages+ means no baseline. +turn+: the enqueued_id
+    # of the child's turn the last follow-up went to (Delegate.follow_up),
+    # whose own reply a wait takes (ReplyWait's turn:); nil once that turn
+    # was reported, or when unknown (a new child, an older worker).
+    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn) do
+      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil) = super
+
+      def self.empty = new
 
       # @param baseline [Hash, nil] ReplyWait.baseline_of's
       def with_baseline(baseline)
@@ -93,7 +98,7 @@ module Samagotchi
         return DelegateCursor.empty unless data.is_a?(Hash)
 
         DelegateCursor.new(reply_file: data["reply_file"], last_turn: data["last_turn"],
-                           question_id: data["question_id"], messages: data["messages"])
+                           question_id: data["question_id"], messages: data["messages"], turn: data["turn"])
       end
 
       def path(parent_id, state_dir:)