samagotchi 0.92.0 → 0.94.0

data/lib/samagotchi/reply_wait.rb

@@ -5,6 +5,7 @@ require_relative "turn_note"
 require_relative "session_inbox"
 require_relative "turn_checkpoint"
 require_relative "worker_sidecar"
+require_relative "reply_wait/poll"
 
 module Samagotchi
   # Loaded on first use: this autoload keeps SessionManager and its ~80
@@ -65,6 +66,31 @@ module Samagotchi
     Result = Struct.new(:status, :text, :file, :question, :outcome, :limit, :error_kind, :retryable, :cancel_reason,
                         :stopped_by, :kept_steps, :session, :turn_id, :origin, keyword_init: true)
 
+    # The session as it was before a message went in (call's baseline:,
+    # #baseline_of): its message count, the question pending then, and when
+    # its last turn ended (+last_turn+, last_turn.ended_at, maybe nil).
+    # Every turn's end records last_turn as it goes idle (Engine#end_turn),
+    # so +last_turn+ alone says whether a turn ended since: messages also
+    # grow between turns (a new worker's context note, a chi note) with no
+    # turn run. +messages+ is kept for a delegate's cursor (DelegateCursor:
+    # nil there means no baseline taken).
+    Baseline = Data.define(:messages, :question_id, :last_turn) do
+      def initialize(messages: nil, question_id: nil, last_turn: nil) = super
+
+      # Whether +session+'s last turn ended since: its last_turn moved on.
+      def turn_ended_since?(session)
+        ended = session.last_turn&.ended_at
+        !ended.nil? && ended != last_turn
+      end
+
+      # Whether +ended_at+ is the end of the turn that was last at the
+      # baseline (a turn that ended before it).
+      def ended_at?(ended_at) = ended_at == last_turn
+
+      # Whether +question_id+ was pending at the baseline (not the answer's).
+      def question?(question_id) = question_id == self.question_id
+    end
+
     module_function
 
     # @param id [String] the session's full id
@@ -73,16 +99,11 @@ module Samagotchi
     # @param timeout [Numeric, nil] seconds; nil waits with no limit
     # @param poll_interval [Float]
     # @param cancelled [#call] true stops the wait (:canceled)
-    # @param baseline [Hash, nil] {messages:, question_id:} as the session
-    #   was before the message went in. With it, a turn that grew the
-    #   messages (a failed, canceled or empty one leaves its note) and went
-    #   idle again ends the wait even if it was never seen running, and a
-    #   question already pending then is not the answer's. A nil
-    #   messages: skips the count. last_turn: (the session's
-    #   last_turn.ended_at then, maybe nil) ends the wait on any turn
-    #   that ended since, idle again, however fast it ran (a failure after
-    #   a failure replaces the note and leaves the count as it was), and
-    #   with it the count isn't used: a note between turns grows it too.
+    # @param baseline [Baseline, nil] the session as it was before the
+    #   message went in (#baseline_of). With it, any turn that ended since
+    #   (its last_turn moved on) and went idle again ends the wait, even if
+    #   it was never seen running, however fast it ran, and a question
+    #   already pending then is not the answer's.
     # @param owner_grace [Numeric, nil] seconds with no live worker before
     #   :worker_gone (one that died before its rescue leaves it running)
     # @param interject [#call, nil] called once a poll, before the sleep
@@ -116,187 +137,22 @@ module Samagotchi
     # @raise [ArgumentError] no such session
     def call(id, state_dir:, cursor:, timeout: nil, poll_interval: POLL_INTERVAL, cancelled: -> { false },
              baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false, ended_before: false)
-      deadline = timeout && (monotonic + timeout.to_f)
-      seen_running = false
-      gone_since = nil
-      turn = turn.to_s.empty? ? nil : turn.to_s
-      session_dir = Session.session_dir(id, state_dir: state_dir) if turn
-      # Whether the turn's input file has been taken (latched): looked at
-      # before each load, so a running session seen after it is that turn
-      # or a later one, never the turn that ran when the message was sent.
-      claimed = false
-      # Its input runs a turn of its own (a queue, images: +queued+, or seen
-      # waiting as one): never merged into another turn.
-      own_turn_input = queued
-      # The turn was seen running (its mark's id), and last_turn's ended_at
-      # then: a later end that isn't its is a turn after it.
-      seen_own = false
-      own_base = nil
-
-      loop do
-        if turn && !claimed
-          waiting = SessionInbox.waiting_input(session_dir, turn)
-          own_turn_input ||= waiting == :turn_end
-          claimed = waiting.nil?
-        end
-        session = Session.load(id, state_dir: state_dir)
-        # Taken back before it ran (POST turn/dequeue): no turn will come.
-        if turn && claimed && !seen_own && SessionInbox.removed?(session_dir, turn)
-          return Result.new(status: :no_reply, outcome: "removed", session: session)
-        end
-
-        if turn && !seen_own && session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == turn
-          seen_own = true
-          own_base = session.last_turn&.ended_at
-        end
-        # Taken but never run as a turn of its own: a running turn's drain
-        # merged it as a steer, so that turn's reply (or question) is its
-        # answer. Waited for as the next reply past the cursor, as without
-        # turn:, never as a turn that will not come.
-        if turn && claimed && !seen_own && !own_turn_input && merged_elsewhere?(session, turn, baseline, session_dir)
-          turn = nil
-          seen_running = session.status == Session::STATUS_RUNNING
-        end
-
-        if (reply = turn ? reply_for_turn(id, state_dir: state_dir, turn: turn) : reply_past(id, state_dir: state_dir, cursor: cursor))
-          reply.session = settled(session, id, state_dir: state_dir)
-          return reply
-        end
-        # Its worker died in it and the next one settled it, or an input
-        # command finished without a turn. After the reply check: a worker
-        # killed between writing the reply and its idle save left the reply.
-        if turn && (settled = TurnCheckpoint.settled_turn(session_dir, turn))
-          return Result.new(status: :no_reply, outcome: settled.outcome, session: session, origin: settled.origin,
-                            **settled.stop_facts)
-        end
-
-        case session.status
-        when Session::STATUS_ERROR
-          return Result.new(status: :error, text: session.last_prompt.to_s.strip, session: session)
-        when Session::STATUS_STOPPED
-          return Result.new(status: :stopped, session: session)
-        end
-
-        # Only a question a live worker holds waits for an answer (the
-        # lists' rule): one a dead worker left waits for no one, and a chi
-        # REPL's is answered there.
-        pending = session.pending_question
-        if pending && !(baseline && pending.id == baseline[:question_id]) &&
-           (turn.nil? || own_question?(session, turn, claimed)) &&
-           session.waiting_question(live: SessionManager.worker_live?(id, state_dir: state_dir))
-          return Result.new(status: :waiting_for_answer, question: pending, session: session)
-        end
-
-        return Result.new(status: :canceled) if cancelled.call
-
-        # The turn that ended before this wait (ended_before: chi send
-        # --wait with no message, on a session that went idle in the gap
-        # between waits): its last_turn still stands, the session is idle,
-        # so its end is the answer, not a wait that times out "running"
-        # again. Its reply file sorts at the cursor (the newest), not past
-        # it: it is the turn's when it is at least as new as the turn's
-        # end (the worker writes it after recording the ended_at), else the
-        # turn left no reply and an earlier turn's file is not its.
-        if ended_before && turn.nil? && session.status == Session::STATUS_IDLE &&
-           (ended = session.last_turn&.ended_at) && !ended.to_s.empty? &&
-           baseline && ended == baseline[:last_turn]
-          file = newest_reply(id, state_dir: state_dir)
-          path = File.join(reply_dir(id, state_dir: state_dir), file) if file
-          if file && reply_is_turns?(path, ended)
-            reply = Result.new(status: :done, text: File.read(path), file: file)
-            reply.session = settled(session, id, state_dir: state_dir)
-            return reply
-          end
-
-          return no_reply(session, baseline, fresh: true)
-        end
-
-        if ended_before && turn && session.last_turn&.enqueued_id == turn &&
-           !(session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == turn) &&
-           (ended = session.last_turn&.ended_at) && !ended.to_s.empty? &&
-           baseline && ended == baseline[:last_turn]
-          # The turn-specific reply lookup above already found its file, if
-          # one exists. Without it, don't use the newest file as a fallback:
-          # it could belong to another turn.
-          return no_reply(session, baseline, fresh: true)
-        end
-
-        if turn
-          # Only the turn's own end: the session runs another turn when the
-          # wait starts, and that one's end is not the answer. A last_turn
-          # with its id is its end, even with a next queued turn running
-          # by now (the look between the two missed the idle).
-          # Only an end after the baseline: a continue offer answered from
-          # idle leaves the exhausted turn's last_turn, with the same id,
-          # until the continue turn (or a Stop) records its own.
-          if session.last_turn&.enqueued_id == turn && ended_since_baseline?(session, baseline)
-            return reply_for_turn(id, state_dir: state_dir, turn: turn)&.tap { |r| r.session = session } ||
-                   no_reply(session, baseline, fresh: true)
-          end
-          # Seen running, and now another turn runs or a later turn ended
-          # while last_turn (looked at first) isn't its: lost (its worker
-          # died), or it ended with no reply and a next turn ran and ended
-          # between two looks. Waiting on would sit through those turns.
-          return Result.new(status: :no_reply, session: session) if seen_own && past_own?(session, turn, own_base)
-        elsif session.status == Session::STATUS_RUNNING
-          seen_running = true
-        elsif (seen_running && !baseline&.key?(:last_turn)) || turn_ended_since?(session, baseline)
-          # It ran and is idle again with no new reply: canceled, failed or
-          # empty. Before it was ever seen running, idle means a
-          # file-delivered message its worker has not picked up yet. With
-          # the baseline's last_turn only a turn that ended since counts:
-          # a session left running by a worker that died goes idle when the
-          # next worker settles that turn (TurnCheckpoint.settle), before
-          # the sent message's turn runs.
-          # The worker writes the reply before its idle save, so the read
-          # above has it; one more look costs nothing should that change.
-          return reply_past(id, state_dir: state_dir, cursor: cursor)&.tap { |r| r.session = session } ||
-                 no_reply(session, baseline)
-        end
-
-        if owner_grace
-          if SessionManager.session_owner(id, state_dir: state_dir)
-            gone_since = nil
-          elsif monotonic - (gone_since ||= monotonic) > owner_grace
-            return Result.new(status: :worker_gone, session: session)
-          end
-        end
-
-        return Result.new(status: :timeout) if deadline && monotonic > deadline
-
-        if interject
-          started = monotonic
-          interject.call
-          deadline += monotonic - started if deadline
-          next if cancelled.call
-        end
-        sleep(poll_interval)
-      end
+      Poll.new(id, state_dir: state_dir, cursor: cursor, timeout: timeout, poll_interval: poll_interval,
+                   cancelled: cancelled, baseline: baseline, owner_grace: owner_grace, interject: interject, turn: turn,
+                   queued: queued, ended_before: ended_before).run
     end
 
     # The session as it was before a message went in (call's baseline:):
     # its messages, the question pending then, and when its last turn
     # ended, so a turn that ends before the first look still ends the wait.
-    # @return [Hash]
+    # @return [Baseline]
     def baseline_of(session, question_id: session.pending_question&.id)
-      { messages: session.messages.size, question_id: question_id, last_turn: session.last_turn&.ended_at }
+      Baseline.new(messages: session.messages.size, question_id: question_id, last_turn: session.last_turn&.ended_at)
     end
 
-    # An idle session whose turn ended after the baseline was taken: its
-    # last_turn moved on. Every turn's end records last_turn as it goes
-    # idle (Engine#end_turn), so with one in the baseline that alone
-    # decides: messages also grow between turns (a new worker's context
-    # note, a chi note) with no turn run. A baseline without it falls back
-    # to the count (a turn's note).
-    def turn_ended_since?(session, baseline)
-      return false unless baseline
-
-      if baseline.key?(:last_turn)
-        ended = session.last_turn&.ended_at
-        return !ended.nil? && ended != baseline[:last_turn]
-      end
-      !!(baseline[:messages] && session.messages.size > baseline[:messages])
-    end
+    # A session whose turn ended after the baseline was taken (Baseline#
+    # turn_ended_since?); false with no baseline.
+    def turn_ended_since?(session, baseline) = baseline ? baseline.turn_ended_since?(session) : false
 
     # The turn a caller that sent nothing means (chi answer, chi send --wait
     # with no message): the one running now (its checkpoint mark's
@@ -354,20 +210,21 @@ module Samagotchi
       !ended && claimed
     end
 
-    # The turn's end, after the baseline was taken (with no baseline, or
-    # one without last_turn, any).
+    # The turn's end, after the baseline was taken (with no baseline, any).
     def ended_since_baseline?(session, baseline)
-      return true unless baseline&.key?(:last_turn)
+      return true unless baseline
 
-      session.last_turn&.ended_at != baseline[:last_turn]
+      !baseline.ended_at?(session.last_turn&.ended_at)
     end
 
     # A turn: wait's taken input ran in another turn (a steer its drain
     # merged): that turn runs (its mark has another id, or none from a
     # worker that writes ids), or, idle, a turn not its ended since the
-    # baseline. last_turn or a reply file being its own is never that.
+    # baseline. last_turn or a reply file being its own is never that, nor
+    # an input with a tombstone (a removal's, written before its claim).
     def merged_elsewhere?(session, turn, baseline, session_dir)
       return false if session.last_turn&.enqueued_id == turn || SessionInbox.reply_for(session_dir, turn)
+      return false if SessionInbox.removed?(session_dir, turn)
 
       if session.status == Session::STATUS_RUNNING
         running_id = session.interrupted_turn&.enqueued_id
@@ -375,7 +232,7 @@ module Samagotchi
 
         return turn_ids?(session_dir)
       end
-      baseline&.key?(:last_turn) ? turn_ended_since?(session, baseline) : false
+      turn_ended_since?(session, baseline)
     end
 
     # A turn seen running (+own_base+: last_turn's ended_at then) is past:
@@ -406,7 +263,7 @@ module Samagotchi
     #   records, when it is the turn waited for
     def no_reply(session, baseline, fresh: nil)
       last = session.last_turn || LastTurn.new
-      fresh = baseline.nil? || !baseline.key?(:last_turn) || (last.ended_at && last.ended_at != baseline[:last_turn]) if fresh.nil?
+      fresh = baseline.nil? || (last.ended_at && !baseline.ended_at?(last.ended_at)) if fresh.nil?
       outcome = fresh ? last.outcome : nil
       return Result.new(status: :no_reply, outcome: "exhausted", limit: last.limit, session: session) if fresh && last.exhausted
 

data/lib/samagotchi/send_command/parent_gate.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../session"
+require_relative "../session_chain"
+require_relative "../session_commands"
+require_relative "../parent_answers_command"
+require_relative "../turn_flow"
+require_relative "../guardrails/parent_approvals"
+require_relative "../guardrails/parent_policy"
+
+module Samagotchi
+  class SendCommand
+    # What a parent agent's line may do, checked before chi send sends it
+    # (before a --new session is created too), against each target's own
+    # parent_answers: a --new session's --parent-answers, a --continues
+    # link's previous session's (the link keeps it), each id's.
+    #
+    # A parent agent's /continue yes is chi answer --option Continue by
+    # another route: held to guardrails.parent_answers tightened by each
+    # target's own (#continue_refusal), and sent marked as chi answer's
+    # (SendCommand#client_id_for) so the worker checks it again. A
+    # /parent-answers line never loosens a target's own value (#loosens?):
+    # only a user at a UI does, and the worker refuses it too. Tightening
+    # goes.
+    class ParentGate
+      # @param options [Hash] chi send's parsed options (:new, :continues,
+      #   :parent_answers, :ids)
+      def initialize(options, state_dir:)
+        @options = options
+        @state_dir = state_dir
+      end
+
+      # A /continue yes (or bare /continue) from a parent agent's process.
+      def self.parent_continue?(prompt) = TurnFlow.continue_yes?(prompt) && Guardrails::ParentApprovals.parent_process?
+
+      # @return [String, nil] the first target's refusal of a parent's
+      #   /continue yes; nil for any other line, or when none refuses
+      def continue_refusal(prompt)
+        return nil unless self.class.parent_continue?(prompt)
+
+        target_values.each do |value|
+          strategy = Guardrails::ParentPolicy.effective(value)
+          refusal = Guardrails::ParentPolicy.continue_refusal(strategy: strategy)
+          return refusal if refusal
+        end
+        nil
+      end
+
+      # Whether +prompt+ is a /parent-answers line that loosens a target's
+      # own value.
+      def loosens?(prompt)
+        SessionCommands.builtin_registry.lookup(prompt)&.id == :parent_answers &&
+          target_values.any? { |value| ParentAnswersCommand.loosens?(prompt, value) }
+      end
+
+      private
+
+      # The targets' own parent_answers values. An id that doesn't resolve
+      # is skipped (SendCommand#resolve reports it later); none left is
+      # config.yml's alone ([nil]).
+      def target_values
+        @target_values ||= if @options[:new] && !@options[:continues]
+                             [@options[:parent_answers]]
+                           else
+                             sessions = if @options[:new]
+                                          [target_session { SessionChain.resolve(@options[:continues], state_dir: @state_dir) }]
+                                        else
+                                          @options[:ids].map { |given| target_session { Session.resolve_id(given, state_dir: @state_dir) } }
+                                        end
+                             values = sessions.compact.map(&:parent_answers)
+                             values.empty? ? [nil] : values
+                           end
+      end
+
+      # The session the block's id names, or nil when there is none.
+      def target_session
+        Session.load(yield, state_dir: @state_dir)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/send_command/wait_target.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../reply_wait"
+require_relative "../session"
+
+module Samagotchi
+  class SendCommand
+    # Which turn chi send --wait waits for and names in its report:
+    # ReplyWait's +turn+ (an enqueued_id; nil: the next reply), +queued+
+    # and +ended_before+, and ParentWait's +report_turn_id+ (the turn_id
+    # of the --format json line). Each run path builds it its way.
+    WaitTarget = Data.define(:turn, :report_turn_id, :queued, :ended_before) do
+      def initialize(turn: nil, report_turn_id: nil, queued: false, ended_before: false) = super
+
+      # A --new session's first message. A file-delivered one's own turn
+      # (its id also names the outcome of a session command that runs no
+      # turn); through the Bridge, the next reply.
+      # @param delivered [SessionManager::DeliverResult, nil] nil when the
+      #   message started the session itself (no delivery)
+      def self.first_message(delivered)
+        return new unless delivered
+
+        new(turn: delivered.file? ? delivered.enqueued_id : nil, report_turn_id: delivered.enqueued_id)
+      end
+
+      # A message to an existing session. --queue: its own turn, the ack's
+      # id, also when the turn running at the check ended before it went in
+      # (an idle worker's ack says next_step, and the file still runs as
+      # that turn). A file fallback's id names its turn too. Otherwise the
+      # next reply, reported as the turn that was running when it went in
+      # (+running_turn+, ReplyWait.own_turn), or as its own on an idle one.
+      # @param running [Boolean] the session was running when it went in
+      def self.message(delivered, queue:, running:, running_turn:)
+        turn = delivered.enqueued_id if queue || delivered.file?
+        report = if queue then turn
+                 elsif running then running_turn
+                 else delivered.enqueued_id
+                 end
+        new(turn: turn, report_turn_id: report, queued: queue && !turn.nil?)
+      end
+
+      # --wait with no message: --turn's (+requested+), or the turn running
+      # now or whose continue offer stands (ReplyWait.own_turn). Settled
+      # (idle, a turn ended, no question standing: a continue offer waits
+      # for its answer), its last turn's end is the answer (ended_before);
+      # with --turn, when that turn is the last one.
+      def self.wait_only(session, session_dir:, requested:)
+        turn = requested || ReplyWait.own_turn(session, session_dir: session_dir)
+        settled = session.status == Session::STATUS_IDLE && !session.last_turn.nil? && session.pending_question.nil?
+        ended_before = requested ? session.last_turn&.enqueued_id == requested : settled
+        new(turn: turn, report_turn_id: turn || (session.last_turn&.enqueued_id if settled), ended_before: ended_before)
+      end
+    end
+  end
+end

data/lib/samagotchi/send_command.rb

@@ -23,6 +23,8 @@ require_relative "vision_support"
 require_relative "cli/command"
 require_relative "cli/flags"
 require_relative "cli/parent_wait"
+require_relative "send_command/parent_gate"
+require_relative "send_command/wait_target"
 
 module Samagotchi
   # `chi send`: put text into sessions as the user's message, the same as
@@ -252,19 +254,14 @@ module Samagotchi
         return refuse_local_command(local, options)
       end
 
-      # A parent agent's /continue yes is chi answer --option Continue by
-      # another route: held to guardrails.parent_answers (tightened by each
-      # target's own) here, and marked as chi answer's (#client_id_for) so
-      # the worker checks it again.
-      if prompt && parent_continue?(prompt) && (refusal = continue_refusal_for(options))
+      # A parent agent's /continue yes held to guardrails.parent_answers,
+      # and a /parent-answers that loosens: refused before anything is sent.
+      gate = ParentGate.new(options, state_dir: @state_dir)
+      if prompt && (refusal = gate.continue_refusal(prompt))
         @stderr.puts("chi send: #{refusal}")
         return CLI::Exit::FAILED
       end
-      # chi send never loosens a session's own parent_answers (only a user
-      # at a UI does: the worker refuses it too); refused before anything
-      # is sent. Tightening goes.
-      if prompt && SessionCommands.builtin_registry.lookup(prompt)&.id == :parent_answers &&
-         target_parent_answers(options).any? { |value| ParentAnswersCommand.loosens?(prompt, value) }
+      if prompt && gate.loosens?(prompt)
         error_line("chi send: refused: #{ParentAnswersCommand::REFUSED}")
         return CLI::Exit::FAILED
       end
@@ -365,11 +362,12 @@ module Samagotchi
         options[:thinking] = Thinking.session_level(word)
       end
       if options[:parent_answers]
-        word = options[:parent_answers].strip.downcase
-        levels = Guardrails::ParentPolicy::ORDER
-        return usage_error("--parent-answers takes #{levels.join(", ")}, not #{options[:parent_answers]}") unless levels.include?(word)
+        level = Guardrails::ParentPolicy.parse_level(options[:parent_answers])
+        unless Guardrails::ParentPolicy::ORDER.include?(level)
+          return usage_error("--parent-answers takes #{Guardrails::ParentPolicy::ORDER.join(", ")}, not #{options[:parent_answers]}")
+        end
 
-        options[:parent_answers] = word
+        options[:parent_answers] = level
       end
       toolkit = Toolkit.from_flags(name: options[:toolkit], add: options[:tools], remove: options[:no_tools])
       options[:toolkit_value] = toolkit if toolkit
@@ -453,8 +451,7 @@ module Samagotchi
       return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
-                                 timeout: options[:timeout], turn: @sent_input_file ? @sent_enqueued_id : nil,
-                                 report_turn_id: @sent_enqueued_id)
+                                 timeout: options[:timeout], **WaitTarget.first_message(@delivered).to_h)
     end
 
     # The model the new session will run, for the images check: --model
@@ -526,29 +523,15 @@ module Samagotchi
       return 1 unless deliver(id, prompt)
       return report_command(id) if @sent_command
 
-      # The ack's id names the queued message's turn, also when the turn
-      # running at the check ended before it went in (an idle worker's ack
-      # says next_step, and the file still runs as that turn).
-      # A file fallback has no delivery field; use its id to see terminal
-      # outcomes for commands that finish without starting a turn.
-      turn = @sent_enqueued_id if @queue || @sent_input_file
-      report_turn_id = if @queue
-                         turn
-                       elsif session.status == Session::STATUS_RUNNING
-                         running_turn
-                       else
-                         @sent_enqueued_id
-                       end
-      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn,
-                          queued: @queue && !turn.nil?,
-                          report_turn_id: report_turn_id)
+      target = WaitTarget.message(@delivered, queue: @queue, running: session.status == Session::STATUS_RUNNING,
+                                              running_turn: running_turn)
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], **target.to_h)
     end
 
     # --wait with no message: the session's next reply, sending nothing,
     # so an agent can go back to waiting after exit 3 or 130. A running
     # turn is fine here (nothing joins its queue); a question pending now
-    # was already reported. No message count: a note landing between turns
-    # grows the messages without a turn. An idle session with no worker
+    # was already reported. An idle session with no worker
     # waits for whatever wakes one (the web, chi send) rather than calling
     # it gone. The turn running now, or the one whose continue offer
     # stands, is the one waited for (ReplyWait.own_turn): its reply, not a
@@ -568,17 +551,10 @@ module Samagotchi
         return 1
       end
       live = session.status == Session::STATUS_RUNNING || SessionManager.session_owner(id, state_dir: @state_dir)
-      turn = requested_turn || ReplyWait.own_turn(session, session_dir: session_dir)
-      # The gate for the settled case: idle, a turn ended (last_turn), no
-      # question standing (a continue offer waits for its answer).
-      settled = session.status == Session::STATUS_IDLE && session.last_turn && session.pending_question.nil?
-      ended_before = requested_turn ? session.last_turn&.enqueued_id == requested_turn : settled
-      report_turn_id = turn
-      report_turn_id ||= session.last_turn&.enqueued_id if settled
+      target = WaitTarget.wait_only(session, session_dir: session_dir, requested: requested_turn)
       wait_for_reply(id, cursor: ReplyWait.newest_reply(id, state_dir: @state_dir),
-                         baseline: baseline_of(session).merge(messages: nil),
-                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil,
-                         turn: turn, ended_before: ended_before, report_turn_id: report_turn_id)
+                         baseline: baseline_of(session),
+                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil, **target.to_h)
     end
 
     # The session as it was before the message went in (ReplyWait's
@@ -610,66 +586,22 @@ module Samagotchi
         @info.puts("#{session.id}  failed: its worker did not start; the session is kept (chi --attach #{session.id})")
         return false
       end
-      unless result[:status] == :accepted
-        @info.puts("#{session.id}  failed: #{result.dig(:ack, "detail") || "could not queue it"}")
+      unless result.accepted?
+        @info.puts("#{session.id}  failed: #{result.detail || "could not queue it"}")
         return false
       end
 
-      ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
-      @sent_input_file = !ack.key?("delivery")
-      @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
-      @sent_command = command_ack?(result[:ack])
+      @delivered = result
+      @sent_command = result.command?
       @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true
     end
 
     SENT_COMMAND = "sent as a session command"
 
-    # Whether the worker took the message as a session command (a POST
-    # /turn whose line is one answers with its command_id).
-    def command_ack?(ack) = ack.is_a?(Hash) && !ack["command_id"].to_s.empty?
-
     # chi send's client id, or chi answer's for a parent agent's /continue
     # yes (the worker holds that to its guardrails.parent_answers).
-    def client_id_for(prompt) = parent_continue?(prompt) ? ClientId::CLI_ANSWER : CLIENT_ID
-
-    # The first refusal of a parent's /continue yes among the targets, each
-    # by config.yml tightened by its own parent_answers; nil when none
-    # refuses.
-    def continue_refusal_for(options)
-      target_parent_answers(options).each do |value|
-        strategy = Guardrails::ParentPolicy.effective(value)
-        refusal = Guardrails::ParentPolicy.continue_refusal(strategy: strategy)
-        return refusal if refusal
-      end
-      nil
-    end
-
-    # The targets' own parent_answers values: a --new session's
-    # --parent-answers, a --continues link's previous session's (the link
-    # keeps it), each id's. An id that doesn't resolve is skipped (#resolve
-    # reports it later); none left is config.yml's alone ([nil]).
-    def target_parent_answers(options)
-      return [options[:parent_answers]] if options[:new] && !options[:continues]
-
-      sessions = if options[:new]
-                   [target_session { SessionChain.resolve(options[:continues], state_dir: @state_dir) }]
-                 else
-                   options[:ids].map { |given| target_session { Session.resolve_id(given, state_dir: @state_dir) } }
-                 end
-      values = sessions.compact.map(&:parent_answers)
-      values.empty? ? [nil] : values
-    end
-
-    # The session the block's id names, or nil when there is none.
-    def target_session
-      Session.load(yield, state_dir: @state_dir)
-    rescue ArgumentError
-      nil
-    end
-
-    # A /continue yes (or bare /continue) from a parent agent's process.
-    def parent_continue?(prompt) = TurnFlow.continue_yes?(prompt) && Guardrails::ParentApprovals.parent_process?
+    def client_id_for(prompt) = ParentGate.parent_continue?(prompt) ? ClientId::CLI_ANSWER : CLIENT_ID
 
     # Whether +text+ may be a session command, which only its worker knows
     # (a bundle's too).
@@ -740,26 +672,25 @@ module Samagotchi
                  end
       result = SessionManager.deliver_turn(id, prompt: prompt, client_id: client_id_for(prompt), images: refs, state_dir: @state_dir,
                                                delivery: delivery)
-      unless result[:status] == :accepted
+      unless result.accepted?
         # A worker older than queueing would steer it: refused, not sent.
-        word = result.dig(:ack, "error") == Delivery::QUEUE_UNAVAILABLE["error"] ? "refused" : "failed"
-        @info.puts("#{short}  #{word}: #{result.dig(:ack, "detail") || "could not queue it"}")
+        word = result.error == Delivery::QUEUE_UNAVAILABLE["error"] ? "refused" : "failed"
+        @info.puts("#{short}  #{word}: #{result.detail || "could not queue it"}")
         return false
       end
 
-      @sent_command = command_ack?(result[:ack])
+      @sent_command = result.command?
       if @sent_command
         @info.puts("#{short}  #{SENT_COMMAND}")
         return true
       end
 
-      ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
-      @sent_input_file = !ack.key?("delivery")
+      ack = result.ack
+      @delivered = result
       # What the worker applied, for --format json: its ack's delivery
       # (next_step for an idle session) and a cut's outcome.
       @sent_delivery = ack["delivery"] || delivery
       @sent_cut = ack["cut"]
-      @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
       @info.puts("#{short}  sent#{with_images}#{delivery_note(ack, delivery: delivery, running: running, owner: owner)}")
       true
     rescue SessionManager::OwnedByTUI