samagotchi 0.15.0 → 0.16.0

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.15.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"
 
@@ -1293,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.

data/lib/samagotchi/web/public/app.js

@@ -21,7 +21,7 @@ import { emptySessionState } from "./session_state.js";
 import { createModelPicker } from "./model_picker.js";
 import { chipName, chipsHtml, imageFiles, restoredChips, thumbsHtml, turnRefs, turnText } from "./images.js";
 import { escapeHtml, noteHtml, normalize, steerRowHtml, userBodyHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy } from "./format.js";
-import { createTurnView, turnHistoryHtml } from "./turn_view.js";
+import { EMPTY_ANSWER_CLASS, createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { createStageView } from "./stage_view.js";
 import { appendQuote } from "./annotations.js";
 import { parsePresets } from "./annotate_presets.js";
@@ -44,7 +44,7 @@ import {
   appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, normalizeTiming, turnTimingText,
 } from "./timing.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, emptyRetryLine, hookNoticeLabel, initWaitLine, isCommandLine, isOwn, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isCommandLine, isOwn, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -776,6 +776,9 @@ function renderSessionView(data) {
   // A question the worker is blocked on (also after a reload).
   if (data.pending_question && data.pending_question.id && data.pending_question.status === "pending") {
     questionCards.renderQuestion(data.pending_question);
+    // The turn's replay drew it as asked; the snapshot knows whether it is
+    // relayed to the parent now.
+    questionCards.markRelayed(data.pending_question.id, data.pending_question.relayed_to || null);
   }
   // A turn ran out of iterations and waits for a yes or no.
   if (data.continue_offer) questionCards.renderContinue(data.continue_offer);
@@ -897,12 +900,25 @@ function addEndBubble(text) {
   if (!turnDom.holds?.()) historyEl.scrollTop = historyEl.scrollHeight;
 }
 
+// The notice of a turn that ended with no answer (turn_summary.empty_answer),
+// as a reload draws it (turn_view.js EMPTY_ANSWER_CLASS).
+function emptyAnswerEl(emptyAnswer) {
+  const el = document.createElement("div");
+  el.className = EMPTY_ANSWER_CLASS;
+  el.textContent = emptyAnswerLine(emptyAnswer);
+  return el;
+}
+
 // Everything a turn's end (completed, canceled, failed) closes: then its
 // end line (+endText+, the cancel or failed line), then the step cards that
 // left the collapsed block (card.js leavesBlock), where a reload puts them.
-function endTurnView(kind, endText = null) {
+function endTurnView(kind, endText = null, { emptyAnswer = null } = {}) {
   setTurnRunning(false);
-  const kept = turnDom.turnEnded({ kind }) || [];
+  // A completed turn with no answer: its notice where the answer goes
+  // (the turn view places it), else after the turn; before the timing.
+  const endNote = emptyAnswer ? emptyAnswerEl(emptyAnswer) : null;
+  const kept = turnDom.turnEnded({ kind, endNote, emptyAnswer: !!emptyAnswer }) || [];
+  if (endNote && !endNote.isConnected) appendToHistory(endNote);
   finishLiveTurnTiming(null, { canceled: kind === "canceled" });
   if (endText) addEndBubble(endText);
   if (kept.length) {
@@ -1203,7 +1219,7 @@ function reloadedTurnEls(before) {
 // What goes after a reloaded turn's own rows and cards: its answer, else
 // its timing line; null when it has neither.
 function turnAnswerEl(turnEls) {
-  return turnEls.filter((el) => el.matches(".bubble.output")).pop() || turnEls.find((el) => el.matches(".turn-timing")) || null;
+  return turnEls.filter((el) => el.matches(".bubble.output, .empty-answer")).pop() || turnEls.find((el) => el.matches(".turn-timing")) || null;
 }
 
 // A finished turn's question (the snapshot's cards keep it with its
@@ -1526,7 +1542,7 @@ const streamHandlers = {
     startLiveTurnTiming(data.started_at);
   }),
   turn_completed: async (data) => {
-    endTurnView("completed");
+    endTurnView("completed", null, { emptyAnswer: data.turn_summary?.empty_answer || null });
     const out = turnOutput(data);
     if (out) appendChunk(out);
     // after_turn hooks are running and may present the answer: its
@@ -1643,6 +1659,8 @@ const streamHandlers = {
   question_answered: (data) => {
     questionCards.resolveQuestion(data.id, { answer: data.answer });
   },
+  // A delegate's question relayed to its parent's card, or no longer.
+  question_relay: (data) => questionCards.markRelayed(data.id, data.relayed_to),
   question_cancelled: (data) => {
     questionCards.resolveQuestion(data.id, { cancelled: true, reason: data.reason });
   },

data/lib/samagotchi/web/public/index.html

@@ -253,6 +253,11 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .bubble.question.approval.answered.denied .question-result{color:var(--danger)}
 .bubble.question.approval.answered.denied .question-option.selected{border-color:var(--danger)}
 .approval-details{margin-bottom:8px;font-size:13px;color:var(--text-2)}
+.approval-delegate{font-size:12px;color:var(--text-muted);margin-bottom:4px;overflow-wrap:anywhere}
+.approval-delegate a{color:var(--text);font-weight:600}
+.question-relayed{font-size:12px;color:var(--text-muted);margin-bottom:6px}
+.question-relayed.hidden{display:none}
+.question-relayed a{color:var(--text);font-weight:600}
 .approval-tool{font-weight:700;color:var(--text);margin-bottom:4px}
 .approval-what{margin:0 0 6px;padding:8px 10px;background:var(--bg-inset);border:1px solid var(--warn-border);border-radius:6px;white-space:pre-wrap;word-break:break-all;color:var(--warn-bright);font-size:12.5px}
 .approval-where,.approval-why{font-size:12px;color:var(--text-muted);word-break:break-all}
@@ -429,6 +434,7 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .turn-stage[data-phase="answered"]{border-left-color:var(--ok)}
 .turn-stage[data-phase="canceled"],.turn-stage[data-phase="waiting for you"]{border-left-color:var(--warn)}
 .turn-stage[data-phase="failed"]{border-left-color:var(--danger)}
+.turn-stage[data-phase="no answer"]{border-left-color:var(--warn)}
 .turn-stage.enter{animation:ts-rise .35s cubic-bezier(.3,.7,.2,1)}
 @keyframes ts-rise{from{opacity:0;transform:translateY(14px)}}
 .turn-stage.leaving{transition:height .4s cubic-bezier(.3,.7,.2,1),opacity .3s ease;opacity:0}
@@ -441,6 +447,7 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .turn-stage[data-phase="answered"] .ts-mark,.turn-stage[data-phase="answered"] .ts-phase{color:var(--ok)}
 .turn-stage[data-phase="canceled"] .ts-mark,.turn-stage[data-phase="canceled"] .ts-phase,.turn-stage[data-phase="waiting for you"] .ts-phase{color:var(--warn-text)}
 .turn-stage[data-phase="failed"] .ts-mark,.turn-stage[data-phase="failed"] .ts-phase{color:var(--danger-text)}
+.turn-stage[data-phase="no answer"] .ts-mark,.turn-stage[data-phase="no answer"] .ts-phase{color:var(--text-muted)}
 .turn-stage[data-phase="waiting for you"] .ts-mark{background:var(--warn)}
 .ts-phase{color:var(--accent);font-weight:600}
 .ts-timing{min-width:0;overflow:hidden;text-overflow:ellipsis}

data/lib/samagotchi/web/public/notify.js

@@ -30,16 +30,25 @@ export function waitingOn(summary) {
   return null;
 }
 
+// How long a delegated child's new approval waits before it notifies: its
+// parent relays it within a poll or two when it waits on the child, and
+// then the parent's card notifies instead (one bell, not two).
+export const RELAY_HOLD_MS = 1500;
+
 // What changed between two summaries of one session that needs the user.
 // @param prev the summary held before (null for a session not seen yet)
 // @param next the new summary
 // @return null | {reason: "question"|"approval"|"card"|"failed"|"done", sessionId, key}
-//   key names this one event, the same in every tab (the Notification tag)
+//   key names this one event, the same in every tab (the Notification tag);
+//   holdMs, when there, delays it (a delegated child's approval)
 export function attentionFor(prev, next) {
   if (!next || !next.id) return null;
   const q = next.pending_question;
   if (q && q.id && q.id !== prev?.pending_question?.id) {
-    return { reason: questionReason(q), sessionId: next.id, key: `${next.id}:${q.id}` };
+    // Relayed to the parent already: the parent's card notifies.
+    if (q.relayed_to) return null;
+    const attention = { reason: questionReason(q), sessionId: next.id, key: `${next.id}:${q.id}` };
+    return next.parent_id && q.kind === "approval" ? { ...attention, holdMs: RELAY_HOLD_MS } : attention;
   }
   const card = next.pending_card;
   if (card && card.id && card.id !== prev?.pending_card?.id) {
@@ -74,7 +83,9 @@ const cardKey = (sessionId, cardId) => `${sessionId}:card:${cardId}`;
 export function closedKeys(prev, next) {
   const keys = [];
   const q = prev?.pending_question;
-  if (q && q.id && next?.pending_question?.id !== q.id) keys.push(`${prev.id}:${q.id}`);
+  const nq = next?.pending_question;
+  // Gone, or relayed to the parent (its card notifies and badges instead).
+  if (q && q.id && (nq?.id !== q.id || (nq.relayed_to && !q.relayed_to))) keys.push(`${prev.id}:${q.id}`);
   const card = prev?.pending_card;
   if (card && card.id && next?.pending_card?.id !== card.id) keys.push(cardKey(prev.id, card.id));
   return keys;
@@ -178,10 +189,12 @@ export function createNotifyGate({ channel = null, holdMs = NOTIFY_HOLD_MS, onSe
     },
     // A new attention in a tab behind: +deliver+ (notify, badge) unless
     // another tab has it in front. @return whether it may still be delivered
+    // An attention's own holdMs (a delegated child's approval) holds it
+    // longer, alone too.
     offer(attention, deliver) {
       const key = attention.key;
       if (seen.has(key)) return false;
-      if (!channel) {
+      if (!channel && !attention.holdMs) {
         deliver();
         return true;
       }
@@ -189,7 +202,7 @@ export function createNotifyGate({ channel = null, holdMs = NOTIFY_HOLD_MS, onSe
       pending.set(key, schedule(() => {
         pending.delete(key);
         if (!seen.has(key)) deliver();
-      }, holdMs));
+      }, Math.max(holdMs, attention.holdMs || 0)));
       return true;
     },
     // Closed before its hold was up (a question answered at once).