samagotchi 0.14.0 → 0.16.0

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

@@ -14,6 +14,7 @@ require_relative "llm/errors"
 require_relative "host_registry"
 require_relative "session"
 require_relative "owner_lock"
+require_relative "bridge/card_store"
 require_relative "engine"
 require_relative "guardrails/parent_approvals"
 require_relative "tools/memory"
@@ -223,6 +224,7 @@ module Samagotchi
         scratch: @scratch
       ))
       claim_session!(session.id) unless @owner_lock
+      keep_cards(session)
       # Saved at once, so a process killed before its first turn leaves a
       # file the sweep knows to delete.
       session.save if @scratch
@@ -345,6 +347,15 @@ module Samagotchi
       @surface.commit("Session #{session.id} was not archived (#{e.message}): chi sessions archive #{session.id}")
     end
 
+    # The session's cards.json, kept as a worker's Bridge keeps it (it owns
+    # the session as a worker would): this REPL's kept turns count on from
+    # the saved count, so a card an earlier worker showed stays that many
+    # turns back, and its own cards and notices are saved for the next.
+    def keep_cards(session)
+      path = File.join(Session.session_dir(session.id), Bridge::CardStore::FILE)
+      @cards_handle ||= @engine.subscribe(observer: Bridge::CardStore.new(path: path))
+    end
+
     # Take the session's OwnerLock for this process's lifetime: the TUI runs
     # its own Engine, so no worker may run the session meanwhile.
     # @raise [SessionBusy] when a worker or another TUI owns it

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/delegate_relay.rb

@@ -0,0 +1,216 @@
+# 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)
+      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,12 @@ 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). 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, 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/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):

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.14.0"
+  VERSION = "0.16.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -1252,6 +1252,13 @@ module Samagotchi
             filtered << { role: "steer", content: content, source: (m[:source] || m["source"]).to_s, step: steer_step(list, index) }
             next
           end
+          # A turn that ended with no answer (TurnNote.empty's marker): its
+          # empty steps (with ?parts=1) and the item the page draws its
+          # notice from; the note itself stays hidden.
+          if (marker = Samagotchi::TurnNote.empty_answer(m))
+            filtered.concat(empty_answer_items(marker, parts: parts, cwd: cwd))
+            next
+          end
           next if role == "system"
           next if role == "tool_response"
 
@@ -1269,6 +1276,10 @@ module Samagotchi
           # Merged into the running turn (Steer::INPUT_KIND): part of it,
           # read by step +step+.
           message.merge!(merged: true, step: steer_step(list, index)) if norm_role == "user" && Samagotchi::Steer.input?(m)
+          # The turn it started (Engine): the page pairs it with that turn's
+          # record by this, not by its place.
+          turn_id = m[:turn_id] || m["turn_id"]
+          message[:turn_id] = turn_id.to_s if norm_role == "user" && turn_id
           images = m[:images] || m["images"]
           message[:images] = Array(images).map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } if norm_role == "user" && images.is_a?(Array) && !images.empty?
           if norm_role == "assistant"
@@ -1289,6 +1300,19 @@ module Samagotchi
         []
       end
 
+      # A no-answer turn's marker as display items: each empty step that
+      # has something to show (its thinking) as a text-less assistant step
+      # (only with +parts+, as other text-less steps), then
+      # { role: "empty_answer", retries: }.
+      def empty_answer_items(marker, parts:, cwd:)
+        steps = parts ? Array(marker[:steps] || marker["steps"]) : []
+        items = steps.filter_map do |step|
+          did = step.is_a?(Hash) ? MessageParts.for_message(step, [], cwd: cwd) : nil
+          { role: "assistant", content: "", parts: did } if did
+        end
+        items << { role: "empty_answer", content: "", retries: (marker[:retries] || marker["retries"]).to_i }
+      end
+
       # The last turn failed and its prompt went back to the user: the
       # prompt (session.last_prompt) and why, for the page to show after the
       # conversation as it did live. nil otherwise.