samagotchi 0.29.0 → 0.31.0

data/lib/samagotchi/prompt_warmup.rb

@@ -20,9 +20,18 @@ module Samagotchi
   #   another slot (12 s);
   # - once the warm-up is done, nothing is pinned: the server finds the
   #   state itself, and pinning to a slot it has since cleared skips its
-  #   prompt cache (12 s again). #take_pin forgets the slot either way.
+  #   prompt cache (12 s again). #take_pin forgets the slot either way;
+  # - no warm-up when /slots says that slot is busy (Client#slot_status):
+  #   another session took it (a delegate child, often), and llama.cpp
+  #   defers a pinned request until the slot is free, so the warm-up and
+  #   then this session's next turn would wait out that generation. The
+  #   next request then goes unpinned, and the server's prompt cache
+  #   restores the state. When /slots can't say, the warm-up runs.
   class PromptWarmup
     MODES = %w[auto off].freeze
+    # Seconds #take_pin waits for the busy-slot check (Client#slot_status
+    # gives up within 3 s).
+    DECIDE_TIMEOUT = 3
 
     # Whether cache.warmup allows a warm-up (auto, the default; off, false,
     # no or 0 turn it off; anything else warns once and is auto).
@@ -52,8 +61,15 @@ module Samagotchi
     #   nothing to pin the next request to)
     # @return [Thread]
     def start(client:, prompt:, model:, slot:, images: [])
+      # Whether the warm-up went to its slot (true) or was skipped: the
+      # first value pushed is the answer.
+      sent = Queue.new
       thread = Thread.new do
         Thread.current.report_on_exception = false
+        busy = slot.is_a?(Integer) && client.slot_status(slot, model: model) == :busy
+        sent << !busy
+        next skip(slot) if busy
+
         result = client.warm_up(prompt, model: model, slot: slot, images: images)
         Log.info(:model, "warmup", slot: result&.slot, cached: result&.cache_n, prefilled: result&.prompt_n,
                                    prefill_ms: result&.prompt_ms, chars: prompt.length)
@@ -61,25 +77,34 @@ module Samagotchi
       rescue StandardError => e
         Log.warn(:model, "warmup_failed", error: e.class.name, msg: e.message.to_s[0, 200])
         nil
+      ensure
+        sent << false
       end
       @mutex.synchronize do
         @thread = thread
-        @state = { thread: thread, client: client, slot: slot }
+        @state = { thread: thread, client: client, slot: slot, sent: sent }
       end
       thread
     end
 
     # The slot the next request on +client+ must run on: the warm-up's,
-    # while it still runs there; nil otherwise (done, failed, unpinned, or
-    # another host). Called once per request; the first call forgets the
-    # warm-up, so no later request is ever pinned.
+    # while it still runs there; nil otherwise (done, failed, skipped,
+    # unpinned, or another host). Called once per request; the first call
+    # forgets the warm-up, so no later request is ever pinned. Waits for
+    # the busy-slot check (DECIDE_TIMEOUT at most).
     def take_pin(client)
       state = @mutex.synchronize { @state.tap { @state = nil } }
       return nil unless state && state[:slot].is_a?(Integer) && state[:client].equal?(client)
+      return nil unless state[:sent].pop(timeout: DECIDE_TIMEOUT)
 
       state[:thread].alive? ? state[:slot] : nil
     end
 
+    private def skip(slot)
+      Log.info(:model, "warmup_skipped", slot: slot, why: "slot busy")
+      nil
+    end
+
     # Whether a warm-up is running (specs, measurements).
     def running?
       thread = @mutex.synchronize { @thread }

data/lib/samagotchi/reply_wait.rb

@@ -41,8 +41,11 @@ module Samagotchi
     #   (user, hook, ctrl_c, manual)
     # @!attribute stopped_by [String, nil] the hook that canceled it
     #   (loop-guard)
+    # @!attribute session [Session, nil] the session as the look that
+    #   decided the outcome loaded it (a caller's next baseline); nil for
+    #   :canceled and :timeout
     Result = Struct.new(:status, :text, :file, :question, :outcome, :limit, :error_kind, :retryable, :cancel_reason,
-                        :stopped_by, keyword_init: true)
+                        :stopped_by, :session, keyword_init: true)
 
     module_function
 
@@ -78,14 +81,15 @@ module Samagotchi
         session = Session.load(id, state_dir: state_dir)
 
         if (reply = reply_past(id, state_dir: state_dir, cursor: cursor))
+          reply.session = settled(session, id, state_dir: state_dir)
           return reply
         end
 
         case session.status
         when Session::STATUS_ERROR
-          return Result.new(status: :error, text: session.last_prompt.to_s.strip)
+          return Result.new(status: :error, text: session.last_prompt.to_s.strip, session: session)
         when Session::STATUS_STOPPED
-          return Result.new(status: :stopped)
+          return Result.new(status: :stopped, session: session)
         end
 
         # Only a question a live worker holds waits for an answer (the
@@ -94,7 +98,7 @@ module Samagotchi
         pending = session.pending_question
         if pending && !(baseline && pending[:id] == baseline[:question_id]) &&
            session.waiting_question(live: SessionManager.worker_live?(id, state_dir: state_dir))
-          return Result.new(status: :waiting_for_answer, question: pending)
+          return Result.new(status: :waiting_for_answer, question: pending, session: session)
         end
 
         return Result.new(status: :canceled) if cancelled.call
@@ -107,14 +111,15 @@ module Samagotchi
           # file-delivered message its worker has not picked up yet.
           # 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) || no_reply(session, baseline)
+          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)
+            return Result.new(status: :worker_gone, session: session)
           end
         end
 
@@ -157,11 +162,37 @@ module Samagotchi
       last = session.last_turn.is_a?(Hash) ? session.last_turn : {}
       fresh = baseline.nil? || !baseline.key?(:last_turn) || (last["ended_at"] && last["ended_at"] != baseline[:last_turn])
       outcome = fresh ? last["outcome"] : nil
-      return Result.new(status: :no_reply, outcome: "exhausted", limit: last["limit"]) if fresh && last["exhausted"]
+      if fresh && last["exhausted"]
+        return Result.new(status: :no_reply, outcome: "exhausted", limit: last["limit"], session: session)
+      end
 
       text = outcome == "failed" ? failure_summary(session.messages) : nil
       why = fresh ? last.slice("error_kind", "retryable", "cancel_reason", "stopped_by").transform_keys(&:to_sym) : {}
-      Result.new(status: :no_reply, outcome: outcome, text: text, **why)
+      Result.new(status: :no_reply, outcome: outcome, text: text, session: session, **why)
+    end
+
+    SETTLE_SECONDS = 1.0
+
+    # The session after the turn that wrote a reply was saved. The worker
+    # writes the reply just before that save, so a look between the two
+    # loaded the session still running, with the turn before's last_turn: a
+    # baseline from it would read the reply's own turn as a later one that
+    # left no reply. Loads again (briefly) until it shows idle or its
+    # last_turn moved on; a session running a next turn by then has the
+    # reply's turn as its last_turn, which is right too.
+    def settled(session, id, state_dir:)
+      return session unless session.status == Session::STATUS_RUNNING
+
+      before = session.last_turn.is_a?(Hash) ? session.last_turn["ended_at"] : nil
+      deadline = monotonic + SETTLE_SECONDS
+      loop do
+        sleep(0.02)
+        fresh = Session.load(id, state_dir: state_dir)
+        ended = fresh.last_turn.is_a?(Hash) ? fresh.last_turn["ended_at"] : nil
+        return fresh if fresh.status != Session::STATUS_RUNNING || ended != before || monotonic > deadline
+      end
+    rescue ArgumentError
+      session
     end
 
     # The summary in the failed-turn note at the conversation's tail, nil

data/lib/samagotchi/send_command.rb

@@ -241,9 +241,10 @@ module Samagotchi
 
     # A worker session like the web start page's: saved as running with the
     # message before its worker spawns, so lists and the web show it at
-    # once. The full id, so a script can pass it on. Only the model's host
-    # is checked here (in spawn_session, as in the web): a wrong model id
-    # fails in the worker.
+    # once. The full id, so a script can pass it on. The model's host is
+    # checked here (in spawn_session, as in the web): an unknown one is
+    # refused before anything is spawned; an id the host's saved model list
+    # doesn't have starts with a warning on stderr.
     # @return [Integer] the exit status
     def run_new(prompt, options)
       images = !@images.empty?
@@ -264,6 +265,7 @@ module Samagotchi
         error_line("chi send: could not start a session: #{e.message}")
         return 1
       end
+      error_line("chi send: warning: #{session.model_warning}") if session.model_warning
       if through_worker
         return 1 unless deliver_new(session, prompt)
       else

data/lib/samagotchi/session.rb

@@ -30,6 +30,8 @@ module Samagotchi
     # resume removes it. A file from before the marker says "stopped" in
     # its status field, which reads the same.
     STOPPED_FILE = "stopped"
+    # The memory a delegate child starts with (Tools::Delegate::CHILD_MEMORIES).
+    DELEGATE_MEMORY = "system/delegated"
 
     SORT_KEYS = %w[created_at updated_at].freeze
     SORT_ORDERS = %w[asc desc].freeze
@@ -54,13 +56,18 @@ module Samagotchi
     # plugin forked it from (ctx.sessions.fork), else nil.
     # Set before the spawn and kept on respawns, like preloaded_memory_names.
     attr_accessor :parent_id
+    # Started by the `delegate` tool (a fork has a parent_id too, but isn't
+    # one): see #delegate?.
+    attr_writer :delegate
     # A `chi scratch` session: deleted when its REPL ends, and by the next
     # sweep (or `chi sessions clean`) when the process died first.
     attr_accessor :scratch
     # How the last turn ended, for the web's notifications (the hub sends
     # it in the summary): {"outcome" => "completed"|"failed"|"canceled",
     # "ended_at" => iso8601, "seconds" => Float, "origin" =>
-    # "client"|"reminder"|"delegate"}; nil before the first turn.
+    # "client"|"reminder"|"delegate"|"delegate_report"}; nil before the
+    # first turn. delegate_report: a turn a parent ran for its delegate
+    # children's reports (ChildReports).
     attr_accessor :last_turn
 
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
@@ -79,12 +86,17 @@ module Samagotchi
     # sets it); not saved.
     attr_accessor :seed_images_dropped
 
+    # The warning for a model id its host's saved list doesn't have
+    # (ModelProfile.model_warning; SessionManager.spawn_session sets it);
+    # not saved.
+    attr_accessor :model_warning
+
     def initialize(id:, mode:, model_name:, working_directory:, messages:, created_at:, updated_at:,
                    metadata_version: METADATA_VERSION, status: STATUS_IDLE, last_prompt: "",
                    first_preview: "", test_run: false, pending_question: nil,
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
-                   last_turn: nil, model_typed: nil)
+                   last_turn: nil, model_typed: nil, delegate: false)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -106,9 +118,20 @@ module Samagotchi
       @parent_id = parent_id&.to_s
       @scratch = !!scratch
       @last_turn = last_turn
+      @delegate = !!delegate
       @archived = false
     end
 
+    # A `delegate` child: its turns report to its parent (ChildReports). A
+    # child saved before the field is known by the memory every delegate
+    # starts with; a fork is neither.
+    def delegate?
+      return true if @delegate
+      return false unless @parent_id
+
+      @preloaded_memory_names.include?(DELEGATE_MEMORY)
+    end
+
     # The question this session waits on, as the lists show it: {id:, kind:}
     # with kind "question" (the model's), "approval", "hook" or "continue"
     # (the step-limit question, asked between turns); nil with
@@ -146,7 +169,7 @@ module Samagotchi
     #   seed); [] by default
     def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
                          preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
-                         scratch: false, model_typed: nil)
+                         scratch: false, model_typed: nil, delegate: false)
       now = Time.now.iso8601(3)
       resolved_test = if test_run.nil?
                         test_session_env?
@@ -169,7 +192,8 @@ module Samagotchi
         preloaded_memory_names: preloaded_memory_names,
         muted_memory_names: muted_memory_names,
         parent_id: parent_id,
-        scratch: scratch
+        scratch: scratch,
+        delegate: delegate
       )
     end
 
@@ -223,7 +247,8 @@ module Samagotchi
       "muted_memory_names" => [],
       "parent_id" => nil,
       "scratch" => false,
-      "last_turn" => nil
+      "last_turn" => nil,
+      "delegate" => false
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -341,6 +366,7 @@ module Samagotchi
                 when "messages" then @messages.map { |msg| scrub_utf8(stringify_message_keys(msg)) }
                 when "pending_question" then @pending_question && scrub_utf8(stringify_message_keys(@pending_question))
                 when "test_run" then !!@test_run
+                when "delegate" then @delegate
                 when "used_memory_names", "preloaded_memory_names", "muted_memory_names"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")

data/lib/samagotchi/session_inbox.rb

@@ -10,7 +10,8 @@ require_relative "session"
 module Samagotchi
   # A session directory's file inbox and outbox (see SessionManager for the
   # layout): input/ holds one JSON file per queued turn, notes/ the context
-  # notes a worker adds between turns, output/ one text file per reply.
+  # notes a worker adds between turns, output/ one text file per reply,
+  # children/ the rings of delegate children that have news (ChildReports).
   # Writers are any process (the web, chi send, chi note, send_note); the
   # worker claims input and notes by renaming them to *.processing.
   module SessionInbox
@@ -20,6 +21,8 @@ module Samagotchi
     NOTES_DIR  = "notes"
     NOTE_MAX_BYTES = 16 * 1024
     OUTPUT_DIR = "output"
+    # A delegate child's doorbell: "look at me", not the report itself.
+    CHILDREN_DIR = "children"
     # Input-file format this worker reads (JSON with the sender's ids and
     # images: refs), advertised in the Bridge sidecar so a chi from before
     # it (one that wrote plain .txt to a worker not advertising 2, or held
@@ -117,6 +120,36 @@ module Samagotchi
       nil
     end
 
+    # Ring a parent: a file naming the child and why. The caller makes sure
+    # the parent's session exists (no orphan dir for a deleted one).
+    # @param why [String] "turn_end", "question" or "crash"
+    # @return [String] the ring file's path
+    def self.write_ring(session_dir, child_id:, why:)
+      dir = File.join(session_dir, CHILDREN_DIR)
+      FileUtils.mkdir_p(dir)
+      path = File.join(dir, "#{Time.now.strftime("%Y%m%d%H%M%S%9N")}-#{child_id.to_s[0, 8]}.json")
+      AtomicFile.write(path, JSON.generate({ "child_id" => child_id, "why" => why, "at" => Time.now.iso8601(3) }))
+      path
+    end
+
+    # The rings waiting, oldest first.
+    def self.find_ring_files(session_dir)
+      dir = File.join(session_dir, CHILDREN_DIR)
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, "*.json")).sort_by { |p| File.basename(p) }
+    end
+
+    # @return [Hash, nil] {child_id:, why:, at:}, nil for a file that holds none
+    def self.read_ring(ring_file)
+      data = JSON.parse(File.read(ring_file))
+      return nil unless data.is_a?(Hash) && !data["child_id"].to_s.empty?
+
+      { child_id: data["child_id"].to_s, why: data["why"].to_s, at: data["at"] }
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
     def self.write_output(session_dir, response)
       output_dir = File.join(session_dir, OUTPUT_DIR)
       FileUtils.mkdir_p(output_dir)

data/lib/samagotchi/session_manager.rb

@@ -130,14 +130,20 @@ module Samagotchi
     # @param images_from [String, nil] the session dir the seed's images are in
     # @param title [String, nil] what the lists show before the first turn
     #   (the prompt's preview by default, else the seed's first user message)
-    # @return [Session] with #seed_images_dropped: refs whose file was gone
+    # @return [Session] with #seed_images_dropped: refs whose file was gone,
+    #   and #model_warning: an id its host's saved list doesn't have
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
-                           title: nil)
+                           title: nil, delegate: false)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
-      # alias is retargeted), with the name as typed beside it.
+      # alias is retargeted), with the name as typed beside it. A wrong host
+      # refuses here, before anything is saved or spawned; a model id the
+      # host's saved list doesn't have (ModelListStore) only warns
+      # (#model_warning on the session), as some hosts serve ids they don't
+      # list.
       typed = Samagotchi::ModelProfile.check_host!(Samagotchi::ModelProfile.required_model_name(model_name))
+      model_warning = Samagotchi::ModelProfile.model_warning(typed)
       ref = ConfigFile.model_ref(typed).ref
       session = Session.new_session(
         mode: mode,
@@ -147,8 +153,10 @@ module Samagotchi
         preloaded_memory_names: memories,
         muted_memory_names: muted_memories,
         parent_id: parent_id,
-        messages: messages
+        messages: messages,
+        delegate: delegate
       )
+      session.model_warning = model_warning
       # With no prompt there is no first turn to run (an attaching UI sends
       # the prompts), so the session starts idle.
       session.status = prompt.to_s.strip.empty? ? Session::STATUS_IDLE : Session::STATUS_RUNNING
@@ -455,6 +463,32 @@ module Samagotchi
       session
     end
 
+    # A delegate child rang a parent that has no worker (ChildRing): start
+    # one, which runs a turn for the report. Not for a parent that is gone,
+    # stopped, archived, a scratch session, or open in a chi REPL: the ring
+    # waits on disk for whoever runs it next (#resume_session itself would
+    # clear the stop). A stop landing between the check and the resume is
+    # a small window, left as is.
+    # @return [Symbol] :woken, or why not (:gone, :stopped, :archived,
+    #   :scratch, :owned)
+    def self.wake_for_report(session_id, state_dir: nil)
+      sd = state_dir || Session.default_state_dir
+      return :gone unless Session.exist?(session_id, state_dir: sd)
+      return :owned if session_owner(session_id, state_dir: sd)
+      return :stopped if Session.stopped_marker?(session_id, state_dir: sd)
+      return :archived if ArchiveStore.archived?(Session.session_dir(session_id, state_dir: sd))
+
+      session = Session.load(session_id, state_dir: sd)
+      return :stopped if session.status == Session::STATUS_STOPPED
+      return :scratch if session.scratch
+
+      resume_session(session_id, state_dir: sd)
+      Log.info(:worker, "delegate_woke_parent", parent: session_id[0, 8])
+      :woken
+    rescue OwnedByTUI
+      :owned
+    end
+
     # How long after a spawn a resume trusts that worker to take the
     # session, while it runs (and the session wasn't stopped since).
     WORKER_START_GRACE = 30.0
@@ -825,8 +859,10 @@ module Samagotchi
       # owner after its write and wakes one, or this finds its input.
       # A restart starts its successor here, on the newest chi installed
       # (worker_command), once this one's lock is free.
+      # Delegate reports that rang while it left wake one too.
       if result == :restart ||
-         (%i[idle_exit exit_requested].include?(result) && !SessionInbox.find_new_input_files(session_dir).empty?)
+         (%i[idle_exit exit_requested].include?(result) &&
+          (!SessionInbox.find_new_input_files(session_dir).empty? || worker.wake_due?))
         resume_session(session_id, state_dir: sd)
       elsif worker.discard?
         discard_left_session(session_id, state_dir: sd, default_model: worker.default_model)

data/lib/samagotchi/session_metrics.rb

@@ -481,9 +481,12 @@ module Samagotchi
           # A turn that failed mid-stream never saw its generation end:
           # what it got to still counts.
           close_generation if @turn.gen_open
-          # A call still running when the turn ends (a cancel, a failure)
-          # never completes: its record says so, as the count already has it.
-          @turn.tool_calls_by_id.each_value { |active| finish_tool_record(active, "canceled") }
+          # A call still running when the turn ends never completes: its
+          # record says so, as the count already has it. A cancel stopped it
+          # ("stopped", as ToolActivity names a call the Stop cut); a
+          # failure left it "canceled".
+          cut = status == "canceled" ? "stopped" : "canceled"
+          @turn.tool_calls_by_id.each_value { |active| finish_tool_record(active, cut) }
           @turn.tool_calls_by_id.clear
           finished_at = now
           record = {

data/lib/samagotchi/steer.rb

@@ -19,14 +19,22 @@ module Samagotchi
     INPUT_KIND = "input"
 
     # A drain item for an input line with its sender (source nil = the user).
-    # A plain String is still a valid item: the user's line.
-    Line = Data.define(:text, :source)
+    # A plain String is still a valid item: the user's line. +mark+: fields
+    # its input message carries ({turn_start: true, turn_id:} for the
+    # first message of a turn with no prompt, a delegate report's wake
+    # turn), nil for none.
+    Line = Data.define(:text, :source, :mark) do
+      def initialize(text:, source:, mark: nil) = super
+    end
 
     # The client ids whose input is not the user's own words. Literals, not
     # SendCommand::CLIENT_ID / Tools::Delegate::CLIENT_PREFIX, so this file
     # needs no requires (a spec pins them equal).
     CHI_SEND_CLIENT = "cli:send"
     DELEGATE_CLIENT_PREFIX = "delegate:"
+    # A delegate child's report (ChildReports::CLIENT_PREFIX).
+    CHILD_CLIENT_PREFIX = "child:"
+    DELEGATE_REPORT = "delegate_report"
     PLUGIN_CLIENT = "plugin"
 
     # What one drain brought: the merged user text (nil when none) and how
@@ -43,16 +51,22 @@ module Samagotchi
         list = inputs.map do |input|
           message = { role: "user", kind: INPUT_KIND }
           message[:source] = input[:source] if input[:source]
+          message.merge!(input[:mark]) if input[:mark]
           message.merge(content: input[:content])
         end
         list + steers.map { |steer| Steer.message(**steer) }
       end
 
       # The :pending_input_merged fields beside iteration and answer;
-      # steers: only when there are some, so plain merges stay as they were.
+      # steers: only when there are some, so plain merges stay as they were;
+      # reports: the delegate reports' text, one per report (a UI shows
+      # each as the child's, not as a merged message).
       def event_fields
         fields = { count: count, content: content }
         fields[:steers] = steers unless steers.empty?
+        reports = inputs.select { |input| input[:source] == DELEGATE_REPORT }
+                        .flat_map { |input| input[:content].split(/\n\n(?=session: )/) }
+        fields[:reports] = reports unless reports.empty?
         fields
       end
     end
@@ -68,6 +82,19 @@ module Samagotchi
       "plugin_send" => "sent by a plugin"
     }.freeze
     USER_HEADER = "[Steer #{SENDERS["user"]}, #{HEADER_TAIL}".freeze
+    # A source whose message is not a steer at all gets its own whole
+    # header line here instead of "[Steer <sender>, …]". A delegate
+    # child's report (ChildReports) is chi's news, not the user's: its
+    # wording was picked on small models (it keeps them on their own task
+    # mid-turn and off delegate_result; "Follow it" made one apply the
+    # child's fix unasked).
+    HEADERS = {
+      "delegate_report" => "[Delegate report, delivered by chi when your delegate session ended its turn; " \
+                           "not your user's message. Tell your user what it found or what went wrong, in your own " \
+                           "words; if you are in the middle of a task, include it in your reply and finish the task. " \
+                           "Don't call delegate_result for it; to retry or redirect that child, use delegate with " \
+                           "its session:.]"
+    }.freeze
 
     module_function
 
@@ -77,6 +104,7 @@ module Samagotchi
       id = client_id.to_s
       if id == CHI_SEND_CLIENT then "chi_send"
       elsif id.start_with?(DELEGATE_CLIENT_PREFIX) then "parent_agent"
+      elsif id.start_with?(CHILD_CLIENT_PREFIX) then DELEGATE_REPORT
       elsif id == PLUGIN_CLIENT then "plugin_send"
       end
     end
@@ -89,6 +117,8 @@ module Samagotchi
       return unless [KIND, INPUT_KIND].include?(kind)
 
       source = (message[:source] || message["source"]).to_s
+      return HEADERS[source] if HEADERS.key?(source)
+
       source = "user" if source.empty?
       sender = SENDERS[source] || (kind == KIND ? "from the #{source} plugin" : SENDERS["user"])
       "[Steer #{sender}, #{HEADER_TAIL}"
@@ -139,9 +169,11 @@ module Samagotchi
     end
 
     # A prompt that started a turn: not a steer, not input merged into a
-    # running turn. What the turns a page shows count.
+    # running turn, except the input a turn with no prompt starts with (a
+    # wake turn's delegate report, marked turn_start). What the turns a
+    # page shows count.
     def turn_prompt?(message)
-      prompt?(message) && !input?(message)
+      prompt?(message) && (!input?(message) || (message[:turn_start] || message["turn_start"]) == true)
     end
 
     # Call a loop's drain: +at_answer+ goes only to a drain that takes it
@@ -197,10 +229,10 @@ module Samagotchi
     def input_groups(lines)
       pairs = lines.filter_map do |line|
         text = (line.is_a?(Line) ? line.text : line).to_s.strip
-        [text, line.is_a?(Line) ? line.source : nil] unless text.empty?
+        [text, line.is_a?(Line) ? line.source : nil, line.is_a?(Line) ? line.mark : nil] unless text.empty?
       end
       pairs.chunk_while { |a, b| a[1] == b[1] }.map do |run|
-        { content: run.map(&:first).join("\n\n"), source: run.first[1] }
+        { content: run.map(&:first).join("\n\n"), source: run.first[1], mark: run.first[2] }.compact
       end
     end
   end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1041,7 +1041,7 @@ module Samagotchi
         render_join_notes(messages)
         return unless last_user
 
-        @screen.commit(prompt_line(nil, exchange[last_user][:content]))
+        @screen.commit(join_prompt_line(exchange[last_user]))
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
@@ -1224,7 +1224,8 @@ module Samagotchi
         if event[:prompt].nil?
           # A continue turn (after the offer's yes) has no prompt to show; a
           # reminder turn shows its reminders (:reminder_injected).
-          @screen.commit(prompt_line(origin[:client_id], "(continuing)")) unless reminder_origin?(origin)
+          # A turn run for delegate reports shows them as they merge.
+          @screen.commit(prompt_line(origin[:client_id], "(continuing)")) unless reminder_origin?(origin) || report_origin?(origin)
         elsif !(own?(origin[:client_id]) || @shown_enqueued.include?(origin[:enqueued_id]))
           @screen.commit(prompt_line(origin[:client_id], event[:prompt]))
         end
@@ -1267,6 +1268,7 @@ module Samagotchi
       end
 
       def reminder_origin?(origin) = origin[:client_id].to_s.start_with?("system:")
+      def report_origin?(origin) = origin[:client_id].to_s.start_with?(Steer::CHILD_CLIENT_PREFIX)
     end
   end
 end

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -186,7 +186,9 @@ module Samagotchi
       def render_merge(event)
         @view.finish_thinking_spinner
         @view.print_line(event[:answer]) unless event[:answer].to_s.strip.empty?
-        count = event[:count].to_i
+        reports = Array(event[:reports])
+        reports.each { |report| @view.print_line(@view.report_line(report)) }
+        count = event[:count].to_i - reports.size
         @view.print_line("(#{count} message#{"s" unless count == 1} merged into the running turn)") if count.positive?
         Array(event[:steers]).each { |steer| @view.print_line(@view.format_steer_line(source: steer[:source], text: steer[:text])) }
       end