samagotchi 0.15.0 → 0.17.0

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -63,7 +63,8 @@ module Samagotchi
         when :generation_chunk
           @view.generation_feedback_chunk(event)
         when :tool_call_started
-          @tool_started_at[tool_call_key(event)] = @clock.call
+          # A joined running call (a snapshot's replay) started elapsed_ms ago.
+          @tool_started_at[tool_call_key(event)] = @clock.call - (event[:elapsed_ms].to_f / 1000)
           @view.tool_call_feedback_started(event)
         when :tool_call_completed
           @view.clear_generation_retry
@@ -167,7 +168,12 @@ module Samagotchi
 
           @view.print_line(@view.format_tool_activity_line(activity))
         end
-        @view.print_line(summary[:output])
+        # 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)))
+        else
+          @view.print_line(summary[:output])
+        end
         @view.print_line("iteration limit reached") if summary[:resumable]
       end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -2,6 +2,7 @@
 
 require_relative "../served_model"
 require_relative "../image_store"
+require_relative "../turn_note"
 
 module Samagotchi
   class TerminalUI
@@ -44,6 +45,12 @@ module Samagotchi
         paint("↻ #{what}, asking again (#{event[:attempt]}/#{event[:of]})", 90)
       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)
+      end
+
       # "retrying (1/3 in 0.5s): Errno::ECONNREFUSED": the retry of all the
       # retries there will be (as the web counts), the wait before it, and
       # what failed (generation_retrying).

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -22,6 +22,9 @@ module Samagotchi
       end
 
       attr_reader :id, :question, :options, :header
+      # @return [String, nil] the parent's short id while this question waits
+      #   in its card too (the approval relay)
+      attr_reader :relayed_to
 
       # @param pending [Hash] Engine#pending_question (symbol or string keys)
       def initialize(pending)
@@ -30,6 +33,18 @@ module Samagotchi
         @preview = approval.is_a?(Hash) ? (approval[:preview] || approval["preview"]) : nil
         @id = field.(:id).to_s
         @question = field.(:question).to_s
+        # A delegate's approval relayed here: the delegate's own text is the
+        # question, who asks a dim line (#note).
+        relay = field.(:relay)
+        if relay.is_a?(Hash)
+          get = ->(key) { relay[key] || relay[key.to_s] }
+          chain = Array(get.(:chain)).map(&:to_s)
+          chain = [get.(:child_id).to_s[0, 8]] if chain.empty?
+          @delegate = chain.reverse.join(" → ")
+          @delegate_task = get.(:task).to_s
+          @question = get.(:asked).to_s unless get.(:asked).to_s.strip.empty?
+        end
+        self.relayed_to = field.(:relayed_to)
         @options = Array(field.(:options)).map { |v| v.to_s.strip }.reject(&:empty?)
         header = field.(:header).to_s.strip
         @header = header.empty? ? nil : header
@@ -42,6 +57,36 @@ module Samagotchi
       def free? = @free
       def approval? = @approval
 
+      # The relay mark (QuestionDesk#annotate's relayed_to: a Hash, or the
+      # short id), or nil when cleared.
+      def relayed_to=(value)
+        short = value.is_a?(Hash) ? (value[:parent_short] || value["parent_short"]) : value
+        @relayed_to = short.to_s.strip.empty? ? nil : short.to_s
+      end
+
+      # The dim line under the header: which delegate asks (and its task),
+      # or that this question waits in a parent too.
+      def note
+        if @delegate
+          task = @delegate_task.empty? ? "" : " · #{@delegate_task}"
+          return "  delegate #{@delegate}#{task}"
+        end
+        "  waiting in parent #{@relayed_to} too (answering here works)" if @relayed_to
+      end
+
+      # What a question closed with no answer here says: a relayed approval
+      # names where it went; else "(question cancelled)".
+      def closed_text(reason)
+        return "(question cancelled)" unless @delegate
+
+        case reason.to_s
+        when "answered_on_child" then "(answered in #{@delegate})"
+        when "child_gone" then "(#{@delegate}'s worker is gone)"
+        when "dismissed" then "(denied)"
+        else "(left open in #{@delegate})"
+        end
+      end
+
       # The widget as slot content, fitted to the rows it gets (QuestionSlot).
       # @return [QuestionSlot]
       def slot(paint: ->(text, _code) { text })
@@ -50,7 +95,7 @@ module Samagotchi
         QuestionSlot.new(header: approval? ? (header || "Approve tool call?") : header,
                          question: first.to_s, mark: mark, details: rest,
                          options: keys.zip(options).map { |key, label| QuestionSlot::Option.new(key, label) },
-                         hint: slot_hint, question_code: approval? ? 33 : 94, paint: paint)
+                         hint: slot_hint, question_code: approval? ? 33 : 94, paint: paint, note: note)
       end
 
       # The most diff lines #preview_lines prints; the web shows them all.
@@ -85,7 +130,8 @@ module Samagotchi
       # the question and what became of it.
       # @param outcome [String] the answer (#answer_text) or what closed it
       def summary(outcome, paint: ->(text, _code) { text })
-        "#{paint.("#{mark}#{question.lines.first.to_s.chomp}", approval? ? 33 : 94)} → #{outcome}"
+        who = @delegate ? "#{@delegate}: " : ""
+        "#{paint.("#{mark}#{who}#{question.lines.first.to_s.chomp}", approval? ? 33 : 94)} → #{outcome}"
       end
 
       # @param answer [Answer] an accepted one

data/lib/samagotchi/terminal_ui/question_slot.rb

@@ -38,9 +38,12 @@ module Samagotchi
       # @param mark [String] its prefix ("? ", "! ")
       # @param options [Array<Option>] key ("1", "yes") and label
       # @param paint [#call] (text, code) -> coloured text
+      # @param note [String, nil] a dim row under the header (a relayed
+      #   approval's delegate, or where else it waits); gives way with it
       def initialize(question:, mark:, options:, header: nil, details: [], hint: nil, question_code: 94,
-                     paint: ->(text, _code) { text })
+                     paint: ->(text, _code) { text }, note: nil)
         @header = header
+        @note = note
         @question = question.to_s
         @mark = mark
         @details = details
@@ -75,6 +78,7 @@ module Samagotchi
       def layout(width, hint:, details:, header:, folded:)
         rows = []
         rows << @paint.(@header, 1) if header && @header
+        rows << @paint.(@note, 2) if header && @note
         question_rows = wrap(@question, width, first: @mark, indent: " " * @mark.size)
         question_rows = question_rows.first(1) unless details
         rows.concat(question_rows.map { |row| @paint.(row, @question_code) })

data/lib/samagotchi/terminal_ui.rb

@@ -232,6 +232,10 @@ module Samagotchi
       @engine.session = session
       messages = messages_for(session)
 
+      # As typed at the prompt: a session command (/models, !ls) runs as
+      # the command, not as a turn.
+      return run_one_shot_command(session) if @prompt && @non_interactive && command_registry.command?(@prompt)
+
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
@@ -281,6 +285,22 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
+    # `chi -p "/models" --non-interactive`: the command's output; a refused
+    # one fails the run (bin/chi exits 1). The session is saved only when
+    # the command changed it.
+    # @return [Symbol, nil] :turn_failed when the command was refused
+    def run_one_shot_command(session)
+      line = @prompt.strip
+      result = begin
+        @commands.run(line)
+      rescue StandardError => e
+        SessionCommands::Result.new(status: :error, output: "#{line.split.first}: #{e.message}", changed: [])
+      end
+      @surface.commit(result.output) unless result.output.to_s.empty?
+      session.save unless Array(result.changed).empty?
+      :turn_failed if result.status == :error
+    end
+
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -1184,6 +1204,10 @@ module Samagotchi
 
     # A ? read of its own, off a terminal (specs, pipes): $stdin.gets.
     def read_choice_line(question_prompt)
+      # Off a terminal the ? prompt can't be taken back: at the input's end
+      # it would stay bare above the summary. eof? waits as gets would.
+      return nil if !$stdin.tty? && $stdin.eof?
+
       @surface.set_slot(:editor, [question_prompt])
       line = $stdin.gets
       # A pipe doesn't echo: the line completes the ? prompt here, once,

data/lib/samagotchi/tool_declarations.rb

@@ -326,7 +326,7 @@ module Samagotchi
       },
       {
         name: "delegate",
-        description: "Hand a task to a child chi session that runs in parallel in this folder and returns only its final reply (its trace stays out of this context). The child is a normal session: it shows in the lists as a child of this one and the user can attach to it. With session, send a follow-up to one of this session's children instead. Children keep running if this turn is canceled; delegate_result waits for them later. A child stays until stopped: once its work is done, stop it with execute `chi sessions stop ID` (a follow-up with session wakes it again).",
+        description: "Hand a task to a child chi session that runs in parallel in this folder and returns only its final reply (its trace stays out of this context). The child is a normal session: it shows in the lists as a child of this one and the user can attach to it. With session, send a follow-up to one of this session's children instead. A tool call the child needs approved goes to your user as one of your own approvals; you only see how it was answered, as a line in the result. Children keep running if this turn is canceled; delegate_result waits for them later. A child stays until stopped: once its work is done, stop it with execute `chi sessions stop ID` (a follow-up with session wakes it again).",
         parameters: {
           type: "object",
           properties: {
@@ -356,7 +356,7 @@ module Samagotchi
       },
       {
         name: "delegate_result",
-        description: "Wait for a delegated child session's next reply: the child named, or this session's newest running child. Returns early if the child waits for an approval or a question the user must answer.",
+        description: "Wait for a delegated child session's next reply: the child named, or this session's newest running child. Returns early if the child waits for a question the user must answer. A tool call the child needs approved goes to your user while this waits; the result says how it was answered.",
         parameters: {
           type: "object",
           properties: {

data/lib/samagotchi/tools/builtins.rb

@@ -105,12 +105,20 @@ module Samagotchi
       # What execute and task_create export into the commands they run: a
       # chi started there answers as a parent agent
       # (Guardrails::ParentApprovals.parent_process?), even under a PTY
-      # wrapper. The session's id, "chi" without one.
+      # wrapper. The session's id, "chi" without one. And the model the
+      # session runs on (SAMAGOTCHI_SESSION_MODEL, read live, so right after
+      # /model), which chi self reports; unset when unknown, so a value
+      # inherited from an outer session never passes for this one.
       def parent_env(kctx)
-        id = kctx.peers.respond_to?(:session_id) ? kctx.peers.session_id.to_s : ""
-        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id }
+        peers = kctx.peers
+        id = peers.respond_to?(:session_id) ? peers.session_id.to_s : ""
+        model = peers.respond_to?(:model_ref) ? peers.model_ref.to_s : ""
+        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
+          SESSION_MODEL_ENV => model.empty? ? nil : model }
       end
 
+      SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+
       # Stop flips the turn's controller, seen through the Engine's PeerView
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)

data/lib/samagotchi/tools/delegate_relay.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "../session"
+require_relative "../bridge_client"
+require_relative "../relay"
+require_relative "../guardrails/approval"
+require_relative "../log"
+
+module Samagotchi
+  # Loaded on first use (a require cycle otherwise; see delegate.rb).
+  autoload :SessionManager, File.expand_path("../session_manager", __dir__)
+
+  module Tools
+    # A child's approval, met by DelegateWait, reopened as the parent's own
+    # (the approval relay): the parent's user answers it in the UI they are
+    # in, the child takes the answer after asking the parent's Bridge for it
+    # (RelayVerifier), and the parent's model sees only the outcome line.
+    # Runs on the parent's turn thread, which blocks in the parent's
+    # question flow until the card is answered, dismissed, closed by its
+    # watch (the child answered first, or its worker went) or the turn is
+    # stopped.
+    module DelegateRelay
+      # How often the card's watch looks at the child.
+      WATCH_EVERY = 0.5
+
+      # How often a wait looks at the parent's other children (a full
+      # session listing) for approvals to relay.
+      OTHERS_EVERY = 2.0
+
+      # What happened to one relayed approval.
+      # @!attribute line [String] the outcome line for the tool result
+      # @!attribute stopped [Boolean] the parent's turn was stopped
+      Outcome = Struct.new(:line, :stopped, keyword_init: true)
+
+      module_function
+
+      # @param relay [#open_question, #relay_desk] Peers#relay
+      # @return [Boolean] a relay can take this question
+      def relayable?(relay, question)
+        !relay.nil? && question.is_a?(Hash) && question[:kind].to_s == Guardrails::Approval::KIND
+      end
+
+      # Relay the child's pending approval and wait until it settles.
+      # @param more [Integer] other delegates' approvals waiting behind it
+      # @return [Outcome]
+      def call(child_id, question, relay:, state_dir:, more: 0)
+        child = Session.load(child_id, state_dir: state_dir)
+        qid = question[:id].to_s
+        desk = relay.relay_desk
+        relay_id = desk.open(child_id: child_id, child_question_id: qid)
+        client = BridgeClient.discover(child_id, session_dir: Session.session_dir(child_id, state_dir: state_dir))
+        post(client, "opened", relay_id, qid)
+        Log.info(:turn, "relay_opened", child: child_id[0, 8], id: qid)
+
+        fields = Relay.card(child, question, relay_id: relay_id, more: more)
+        answer = relay.open_question(fields, watch: watch(child_id, qid, state_dir))
+        settle(answer, fields, client: client, desk: desk, relay_id: relay_id, qid: qid)
+      ensure
+        # A relay that failed before it settled closes, so the desk (which
+        # prunes only settled ones) keeps none open; a settled one stays.
+        desk&.close(relay_id) if relay_id
+      end
+
+      # Closes the card when the child's question is no longer pending (it
+      # was answered or cancelled there) or its worker is gone.
+      def watch(child_id, qid, state_dir)
+        lambda do
+          unless SessionManager.worker_live?(child_id, state_dir: state_dir)
+            next "child_gone"
+          end
+
+          pending = Session.load(child_id, state_dir: state_dir).pending_question
+          pending && pending[:id].to_s == qid ? nil : "answered_on_child"
+        rescue ArgumentError
+          "child_gone"
+        end
+      end
+
+      # Record the parent's answer, tell the child, and say what came of it.
+      def settle(answer, fields, client:, desk:, relay_id:, qid:)
+        what = what_text(fields[:approval])
+        if answer.is_a?(Hash) && answer[:error] == "cancelled"
+          desk.close(relay_id)
+          return closed(answer[:reason].to_s, what, client: client, relay_id: relay_id, qid: qid)
+        end
+
+        dismissed = !(answer.is_a?(Hash) && answer[:selected])
+        by = answer.is_a?(Hash) && answer[:by] == "parent_agent" ? "parent_agent" : "user"
+        desk.record(relay_id, selected_indices: dismissed ? [] : Array(answer[:selected_indices]),
+                              freeform: dismissed ? nil : answer[:freeform], dismissed: dismissed, by: by)
+        response = post(client, "answered", relay_id, qid)
+        Outcome.new(line: line(what, delivered(response, answer, fields, dismissed)), stopped: false)
+      end
+
+      def closed(reason, what, client:, relay_id:, qid:)
+        case reason
+        when "answered_on_child" then Outcome.new(line: line(what, "answered on the child"), stopped: false)
+        when "child_gone" then Outcome.new(line: line(what, "not delivered (the child's worker is gone)"), stopped: false)
+        else
+          # A Stop: the child's question stays open there.
+          post(client, "closed", relay_id, qid, reason: "stopped")
+          Outcome.new(line: line(what, "still open (your turn was stopped)"), stopped: true)
+        end
+      end
+
+      # The outcome of an answer the child was told about.
+      def delivered(response, answer, fields, dismissed)
+        return "not delivered (the child's worker is gone)" unless response
+
+        case response.status
+        when 200 then dismissed ? "dismissed (denied)" : verdict(answer, fields)
+        when 409 then "answered on the child"
+        when 403 then "refused by the child (a parent agent may not allow it); it waits for the user there"
+        else "not delivered (#{response.json&.fetch("error", nil) || response.status})"
+        end
+      end
+
+      # allowed once / allowed for its session / denied ("why")
+      def verdict(answer, fields)
+        scopes = Array(fields.dig(:approval, :scopes))
+        index = Array(answer[:selected_indices]).first
+        if index && index < scopes.size
+          return case scopes[index].to_s
+                 when "once" then "allowed once"
+                 when "session" then "allowed for the delegate's session"
+                 when "repo" then "allowed in this repo or directory"
+                 when "rule" then "allowed by rule #{fields.dig(:approval, :rule)}"
+                 else "allowed"
+                 end
+        end
+
+        why = answer[:freeform].to_s.strip
+        why.empty? ? "denied" : "denied (#{why.inspect})"
+      end
+
+      def line(what, outcome) = "approval relayed to your user: #{what} → #{outcome}"
+
+      # execute: git push origin main
+      def what_text(facts)
+        facts = facts.is_a?(Hash) ? facts : {}
+        tool = facts[:label] || facts[:tool] || "tool"
+        what = facts[:command] || Array(facts[:paths]).join(", ")
+        what = facts[:args].to_s if what.to_s.empty?
+        what.to_s.empty? ? tool.to_s : "#{tool}: #{what}"
+      end
+
+      # The parent's other running children, while it waits on one (D2):
+      # their approvals are relayed too, oldest first, one card at a time.
+      # Each outcome is kept for that child's next DelegateWait result
+      # (DelegateWait.relayed_outcomes). Every question is relayed once per
+      # wait.
+      class Others
+        # @param parent_id [String]
+        # @param except [String] the child waited on (its own approvals come
+        #   through ReplyWait)
+        # @param on_outcome [#call] (child_id, Outcome)
+        def initialize(parent_id:, except:, relay:, state_dir:, on_outcome:, every: OTHERS_EVERY)
+          @parent_id = parent_id
+          @except = except
+          @relay = relay
+          @state_dir = state_dir
+          @on_outcome = on_outcome
+          @every = every
+          @done = {}
+          @next_at = 0.0
+        end
+
+        # Relay the oldest waiting approval of another child, if any (a
+        # ReplyWait interject). Throttled to one look every +every+ s.
+        def poll
+          return if monotonic < @next_at
+
+          @next_at = monotonic + @every
+          waiting = self.waiting
+          return if waiting.empty?
+
+          child_id, question = waiting.first
+          @done[question[:id].to_s] = true
+          outcome = DelegateRelay.call(child_id, question, relay: @relay, state_dir: @state_dir, more: waiting.size - 1)
+          @on_outcome.call(child_id, outcome)
+          # The next one, if any, right after.
+          @next_at = 0.0
+        end
+
+        # Other children's approvals not yet relayed in this wait.
+        # @return [Integer]
+        def count = waiting.size
+
+        # @return [Array<Array(String, Hash)>] [child id, pending question],
+        #   oldest question first
+        def waiting
+          rows = SessionManager.children_of(@parent_id, state_dir: @state_dir).select do |row|
+            row[:id] != @except && row[:waiting] == Guardrails::Approval::KIND && !@done[row[:waiting_id].to_s]
+          end
+          rows.filter_map do |row|
+            pending = Session.load(row[:id], state_dir: @state_dir).pending_question
+            [row[:id], pending] if pending && pending[:id].to_s == row[:waiting_id].to_s
+          rescue ArgumentError
+            nil
+          end.sort_by { |_, pending| pending[:created_at].to_s }
+        end
+
+        private
+
+        def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      # @return [BridgeClient::Response, nil] nil when the child's worker
+      #   can't be reached
+      def post(client, action, relay_id, qid, **extra)
+        return nil unless client
+
+        client.relay(action: action, relay_id: relay_id, question_id: qid, **extra)
+      rescue SystemCallError, IOError => e
+        Log.info(:turn, "relay_post_failed", action: action, error: e.class.name)
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/delegate_wait.rb

@@ -5,6 +5,7 @@ require_relative "../reply_wait"
 require_relative "../parent_report"
 require_relative "output_guardrails"
 require_relative "peers"
+require_relative "delegate_relay"
 
 module Samagotchi
   module Tools
@@ -41,6 +42,13 @@ module Samagotchi
         @baselines ||= {}
       end
 
+      # @return [Hash{Array(String, String) => Array<String>}] [parent id,
+      #   child id] → outcome lines of that child's approvals relayed while
+      #   the parent waited on another child, for its next result
+      def relayed_outcomes
+        @relayed_outcomes ||= {}
+      end
+
       # @param child_id [String] the child's full id
       # @param peers [Peers] the parent (session_id, state_dir, cancelled?)
       # @param timeout [Integer] seconds
@@ -48,13 +56,73 @@ module Samagotchi
       # @param owner_grace [Numeric] seconds with no live worker before
       #   the child's worker counts as gone
       # @return [String] the tool result
+      #
+      # A child's approval, when this session can host a relay (Peers#relay),
+      # goes to this session's user as its own approval (DelegateRelay); the
+      # wait goes on after it settles, with the time it was open not counted
+      # against +timeout+, and the result gets one outcome line per relayed
+      # approval. Without a relay, and for the model's and hooks' questions,
+      # the question comes back to the model as before.
       def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL, owner_grace: OWNER_GRACE)
         sd = peers.state_dir || Session.default_state_dir
         key = [peers.session_id, child_id]
         cancelled = -> { peers.cancelled? }
-        wait = ReplyWait.call(child_id, state_dir: sd, cursor: seen[key], timeout: timeout.to_i,
-                                        poll_interval: poll_interval, cancelled: cancelled, baseline: baselines[key],
-                                        owner_grace: owner_grace)
+        relay = peers.respond_to?(:relay) ? peers.relay : nil
+        others = relay && others_for(peers.session_id, child_id, relay, sd)
+        baseline = baselines[key]
+        left = timeout.to_i
+        outcomes = relayed_outcomes.delete(key) || []
+        loop do
+          started = monotonic
+          wait = ReplyWait.call(child_id, state_dir: sd, cursor: seen[key], timeout: [left, 0].max,
+                                          poll_interval: poll_interval, cancelled: cancelled, baseline: baseline,
+                                          owner_grace: owner_grace, interject: others && -> { others.poll })
+          left -= monotonic - started
+          unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
+            outcomes.concat(relayed_outcomes.delete(key) || [])
+            return with_outcomes(finish(wait, child_id, key: key, timeout: timeout), outcomes)
+          end
+
+          outcome = DelegateRelay.call(child_id, wait.question, relay: relay, state_dir: sd, more: others&.count.to_i)
+          outcomes << outcome.line
+          return with_outcomes(canceled_result(child_id), outcomes) if outcome.stopped
+
+          # Wait on with the child as it is now: a turn that ends with no
+          # reply after the relay still ends the wait, and the relayed
+          # question isn't reported again.
+          baseline = ReplyWait.baseline_of(Session.load(child_id, state_dir: sd), question_id: wait.question[:id])
+        end
+      rescue ArgumentError => e
+        "Error: #{e.message}"
+      end
+
+      # The parent's other children whose approvals a wait relays too, their
+      # outcomes kept for their own next result.
+      def others_for(parent_id, child_id, relay, state_dir)
+        DelegateRelay::Others.new(parent_id: parent_id, except: child_id, relay: relay, state_dir: state_dir,
+                                  on_outcome: lambda { |other, outcome|
+                                    (relayed_outcomes[[parent_id, other]] ||= []) << outcome.line
+                                  })
+      end
+
+      # The relayed approvals' outcome lines, after the status line.
+      def with_outcomes(text, outcomes)
+        return text if outcomes.empty?
+
+        text.sub(/\A(session: [^\n]*\nstatus: [^\n]*\n)/) { "#{::Regexp.last_match(1)}#{outcomes.join("\n")}\n" }
+      end
+
+      def canceled_result(child_id)
+        result(child_id, "running", "wait canceled; the child keeps running; delegate_result #{child_id} waits again")
+      end
+
+      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # The tool result for how the wait ended.
+      # @param wait [ReplyWait::Result]
+      # @param key [Array(String, String)] [parent id, child id]
+      # @return [String]
+      def finish(wait, child_id, key:, timeout:)
         # The turn sent to is handed over: a later wait looks for a later one.
         baselines.delete(key) if %i[done no_reply].include?(wait.status)
         status = ParentReport.status(wait)
@@ -69,7 +137,7 @@ module Samagotchi
         when :waiting_for_answer
           result(child_id, status, waiting_text(child_id, wait.question))
         when :canceled
-          result(child_id, status, "wait canceled; the child keeps running; delegate_result #{child_id} waits again")
+          canceled_result(child_id)
         when :no_reply
           result(child_id, status, "#{no_reply_text(wait)}; its session shows what happened")
         when :worker_gone
@@ -78,8 +146,6 @@ module Samagotchi
         else
           timeout_result(child_id, timeout)
         end
-      rescue ArgumentError => e
-        "Error: #{e.message}"
       end
 
       # Point the cursor at the newest reply now, so only a later one counts

data/lib/samagotchi/tools/peers.rb

@@ -5,10 +5,13 @@ module Samagotchi
     # What list_sessions, send_note and the delegate tools know about the
     # asking session: its id (left out of the list, the note's sender), its
     # folder, where sessions live, and whether the running turn was
-    # canceled (a waiting tool returns on it). Engine hands KernelLoop one
-    # that follows its current session (Engine::PeerView); this plain one
-    # is for specs and a kernel without an Engine.
-    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, keyword_init: true) do
+    # canceled (a waiting tool returns on it), and the question flow a
+    # delegate's approval is relayed through (relay: nil when this session
+    # can't host one), and the model the session runs on (model_ref: the
+    # resolved ref, live after /model). Engine hands KernelLoop one that follows its current
+    # session (Engine::PeerView); this plain one is for specs and a kernel
+    # without an Engine.
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/task_runtime.rb

@@ -20,7 +20,7 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
-      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL].freeze
 
       module_function
 

data/lib/samagotchi/turn_note.rb

@@ -4,7 +4,7 @@ module Samagotchi
   # The one-line system note a turn leaves in the conversation when it ends
   # without an answer: failed before the model replied, cancelled, or over
   # with nothing visible. The UIs show these ends live (`turn failed …`, a
-  # cancel line, `(the model returned an empty answer)`), but the model saw
+  # cancel line, `no answer: …`), but the model saw
   # none of that on its next turn: the session held an unanswered user
   # message and no reason. A tail system message, like a reminder or a
   # context note, keeps the prompt cache and is hidden by the UIs (they
@@ -18,6 +18,7 @@ module Samagotchi
     TASKS_LISTED = 5
     TASK_COMMAND_CHARS = 60
     RETRY_NUDGE = :retry_nudge
+    EMPTY_ANSWER = :empty_answer
 
     module_function
 
@@ -69,8 +70,35 @@ module Samagotchi
       " Still running: #{listed.join(", ")}. Continue with task_wait <id> or stop with task_stop <id>."
     end
 
-    def empty
+    # The model reads the text only. The marker (EMPTY_ANSWER) is for the
+    # UIs, which draw the turn's notice and steps from it after a reload:
+    # +retries+ the empty-answer retries spent, +steps+ the empty
+    # generations as model messages (their thinking; the loops keep them out
+    # of the conversation, where they'd be empty assistant turns). Never
+    # sent: the payload builders send a system message's content, and the
+    # copies for hooks, plugins and the recap drop it (AnswerDisplay.strip).
+    def empty(retries: 0, steps: [])
+      marker = { retries: retries.to_i }
+      marker[:steps] = steps.map { |step| step.slice(:role, :content, :thinking) } unless steps.empty?
       message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
+        .merge(EMPTY_ANSWER => marker)
+    end
+
+    # The empty-answer marker of +entry+ (either key type), or nil.
+    def empty_answer(entry)
+      return nil unless note?(entry)
+
+      marker = entry[EMPTY_ANSWER] || entry[EMPTY_ANSWER.to_s]
+      marker.is_a?(Hash) ? marker : nil
+    end
+
+    # The notice every UI shows for a turn that ended with no answer:
+    # "no answer: the model returned nothing (after 1 retry)" (turn_events.js
+    # emptyAnswerLine words it the same).
+    def empty_answer_line(retries)
+      count = retries.to_i
+      after = count.positive? ? " (after #{count} #{count == 1 ? "retry" : "retries"})" : ""
+      "no answer: the model returned nothing#{after}"
     end
 
     # The hidden nudge before a retry of an empty answer (EmptyAnswerRetry):