samagotchi 0.81.0 → 0.83.0

data/lib/samagotchi/send_command.rb

@@ -43,7 +43,7 @@ module Samagotchi
              chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
-             chi send --wait [--timeout S] [--format json] ID
+             chi send --wait [--timeout S] [--format json] [--turn T] ID
         Sends a message to each session, as if typed in it: a turn starts,
         or a running one takes it at its next step. A stopped session's
         worker starts.
@@ -91,7 +91,10 @@ module Samagotchi
                     the web). With no message (no -m, nothing piped)
                     nothing is sent: it waits for the session's next
                     reply, a running turn's too (after exit 3, 4 or 130,
-                    wait again this way)
+                    wait again this way). To an idle session whose last
+                    turn already ended, that ended turn is the answer:
+                    its reply, or its end when it left none. --turn T
+                    waits for that running, queued or last-ended turn
         --cut       ask the running turn to cut the generation it is
                     streaming and take the message now (a generation that
                     has streamed only thinking for steer.cut_after; else
@@ -108,10 +111,12 @@ module Samagotchi
                     than queueing (it would steer; restart it)
         --timeout S (--wait) give up after S seconds, exit 4 (the turn
                     goes on); default no limit
+        --turn T    (--wait, no message) wait for this turn id, from the
+                    JSON's turn_id; not with -m
         --format json
                     (--wait) one JSON object on stdout, whatever the end:
                     status answered (text), question (question,
-                    answer_with), running, or failed, canceled,
+                    answer_with), turn_id when known, running, or failed, canceled,
                     limit, no_answer, error, worker_gone, stopped,
                     command (detail); with --cut or --queue also
                     delivery (what the worker applied: next_step, cut,
@@ -142,6 +147,7 @@ module Samagotchi
       f.switch "--queue"
       f.value "--timeout"
       f.value "--format"
+      f.value "--turn"
       # Starting a turn in every live session at once is too easy to do
       # by accident.
       f.refuse "--all", "there is no --all: name the sessions"
@@ -204,6 +210,7 @@ module Samagotchi
       prompt = compose(utf8(read_stdin), utf8(options[:message]))
       # Before the wait-only case, which would drop the images.
       return usage_error("--image needs a message: pass -m TEXT or pipe it in") if prompt.nil? && !options[:images].empty?
+      return usage_error("--turn cannot be used with a message") if options[:turn] && prompt
       return run_wait_only(options) if prompt.nil? && options[:wait] && !options[:new]
 
       # The next link of a chain may start idle, waiting for its first message.
@@ -268,6 +275,8 @@ module Samagotchi
         options[:timeout] = Float(options[:timeout], exception: false)
         return usage_error("--timeout takes seconds") unless options[:timeout]&.positive?
       end
+      return usage_error("--turn needs --wait") if options[:turn] && !options[:wait]
+      return usage_error("--turn is only for waiting without a message") if options[:turn] && (options[:new] || options[:queue] || options[:cut])
       return usage_error("--wait takes one session") if options[:wait] && options[:ids].uniq.size > 1
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
@@ -388,7 +397,7 @@ module Samagotchi
       return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
-                                 timeout: options[:timeout])
+                                 timeout: options[:timeout], report_turn_id: @sent_enqueued_id)
     end
 
     # The model the new session will run, for the images check: --model
@@ -450,6 +459,9 @@ module Samagotchi
 
       cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
       baseline = baseline_of(session)
+      running_turn = if session.status == Session::STATUS_RUNNING
+                       ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
+                     end
       return 1 unless deliver(id, prompt)
       return report_command(id) if @sent_command
 
@@ -457,7 +469,15 @@ module Samagotchi
       # running at the check ended before it went in (an idle worker's ack
       # says next_step, and the file still runs as that turn).
       turn = @queue ? @sent_enqueued_id : nil
-      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?)
+      report_turn_id = if @queue
+                         turn
+                       elsif session.status == Session::STATUS_RUNNING
+                         running_turn
+                       else
+                         @sent_enqueued_id
+                       end
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?,
+                          report_turn_id: report_turn_id)
     end
 
     # --wait with no message: the session's next reply, sending nothing,
@@ -468,16 +488,33 @@ module Samagotchi
     # waits for whatever wakes one (the web, chi send) rather than calling
     # it gone. The turn running now, or the one whose continue offer
     # stands, is the one waited for (ReplyWait.own_turn): its reply, not a
-    # turn's queued behind it; with none known, the next reply.
+    # turn's queued behind it; with none known, the next reply. An idle
+    # session whose last turn already ended (no question standing) went
+    # idle in the gap between waits: that turn's end is the answer — its
+    # reply, or its no-reply outcome — so the wait returns it at once
+    # (ReplyWait's ended_before:) instead of timing out "running" again.
     # @return [Integer] the exit status
     def run_wait_only(options)
       id = resolve(options[:ids].first) or return 1
       session = Session.load(id, state_dir: @state_dir)
+      session_dir = Session.session_dir(id, state_dir: @state_dir)
+      requested_turn = options[:turn]&.to_s
+      if requested_turn && !ReplyWait.known_turn?(session, session_dir: session_dir, turn: requested_turn)
+        error_line("chi send: turn #{requested_turn} is not a running, queued, or last ended turn")
+        return 1
+      end
       live = session.status == Session::STATUS_RUNNING || SessionManager.session_owner(id, state_dir: @state_dir)
-      turn = ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
+      turn = requested_turn || ReplyWait.own_turn(session, session_dir: session_dir)
+      # The gate for the settled case: idle, a turn ended (last_turn), no
+      # question standing (a continue offer waits for its answer).
+      settled = session.status == Session::STATUS_IDLE && session.last_turn && session.pending_question.nil?
+      ended_before = requested_turn ? session.last_turn&.enqueued_id == requested_turn : settled
+      report_turn_id = turn
+      report_turn_id ||= session.last_turn&.enqueued_id if settled
       wait_for_reply(id, cursor: ReplyWait.newest_reply(id, state_dir: @state_dir),
                          baseline: baseline_of(session).merge(messages: nil),
-                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil, turn: turn)
+                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil,
+                         turn: turn, ended_before: ended_before, report_turn_id: report_turn_id)
     end
 
     # The session as it was before the message went in (ReplyWait's
@@ -514,6 +551,8 @@ module Samagotchi
         return false
       end
 
+      ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
       @sent_command = command_ack?(result[:ack])
       @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true

data/lib/samagotchi/session_metrics/cost.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class SessionMetrics
+    # The session's spend so far (SessionMetrics#cost, what a bundle's
+    # ctx.cost reads), in USD: +reported+ by providers (usage.cost) and
+    # +estimated+ from configured prices (ModelPrice.estimate: a generation
+    # is one or the other, never both), each the main loop's and the side
+    # requests' together; +side+ is the side requests' share of the total
+    # (recap, /btw, ask_model). +known+ is false while generations or side
+    # requests ran but none was reported or priced: a cap can't be enforced
+    # on such a session. A session with some priced and some unpriced
+    # generations reads known (the unpriced ones count 0).
+    # Bundles use its methods only, never this constant's name.
+    Cost = Data.define(:reported, :estimated, :side, :known) do
+      def self.zero = new(reported: 0.0, estimated: 0.0, side: 0.0, known: true)
+
+      # @param totals [Totals] the session's sums, the running turn folded in
+      # @param side [SideTotals]
+      # @return [Cost]
+      def self.of(totals, side)
+        side_reported = side.cost_sum.to_f
+        side_estimated = side.cost_estimate_sum.to_f
+        reported = totals.cost_sum.to_f + side_reported
+        estimated = totals.cost_estimate_sum.to_f + side_estimated
+        ran = (totals.prompt_sum + totals.completion_sum).positive? || side.requests.positive?
+        new(reported: reported, estimated: estimated, side: side_reported + side_estimated,
+            known: !ran || reported.positive? || estimated.positive?)
+      end
+
+      # @return [Float] reported + estimated, side requests included
+      def total = reported + estimated
+
+      def known? = known
+    end
+  end
+end

data/lib/samagotchi/session_metrics/side_totals.rb

@@ -31,14 +31,21 @@ module Samagotchi
         return zero unless hash.is_a?(Hash)
 
         hash = hash.transform_keys(&:to_s)
-        kinds = hash["by_kind"].is_a?(Hash) ? hash["by_kind"] : {}
-        new(**COUNTS.to_h { |key| [key, count(hash[key.to_s])] }, cost_sum: cost(hash["cost_sum"]),
-                                                                  cost_estimate_sum: number(hash["cost_estimate_sum"]),
-                                                                  by_kind: kinds.each_with_object({}) do |(kind, row), rows|
-                                                                    row = row.is_a?(Hash) ? row.transform_keys(&:to_s) : {}
-                                                                    rows[kind.to_s] = { requests: count(row["requests"]), cost_sum: cost(row["cost_sum"]),
-                                                                                        cost_estimate_sum: number(row["cost_estimate_sum"]) }.freeze
-                                                                  end.freeze)
+        new(
+          **COUNTS.to_h { |key| [key, count(hash[key.to_s])] },
+          cost_sum: cost(hash["cost_sum"]),
+          cost_estimate_sum: number(hash["cost_estimate_sum"]),
+          by_kind: saved_kinds(hash["by_kind"])
+        )
+      end
+
+      def self.saved_kinds(hash)
+        kinds = hash.is_a?(Hash) ? hash : {}
+        kinds.each_with_object({}) do |(kind, row), rows|
+          row = row.is_a?(Hash) ? row.transform_keys(&:to_s) : {}
+          rows[kind.to_s] = { requests: count(row["requests"]), cost_sum: cost(row["cost_sum"]),
+                              cost_estimate_sum: number(row["cost_estimate_sum"]) }.freeze
+        end.freeze
       end
 
       # These totals with one side request counted in.
@@ -87,7 +94,7 @@ module Samagotchi
 
       def self.cost(value) = value.is_a?(Numeric) ? value : nil
 
-      private_class_method :count, :number, :cost
+      private_class_method :count, :number, :cost, :saved_kinds
 
       private
 

data/lib/samagotchi/session_metrics.rb

@@ -12,6 +12,7 @@ require_relative "model_price"
 require_relative "session"
 require_relative "session_metrics/totals"
 require_relative "session_metrics/model_segment"
+require_relative "session_metrics/cost"
 require_relative "session_metrics/side_totals"
 require_relative "side_usage"
 
@@ -351,6 +352,9 @@ module Samagotchi
       end
     end
 
+    # @return [String, nil] the session id #persist writes under
+    def session_id = @mutex.synchronize { @session_id }
+
     # Count one side request (a recap, a plugin's ctx.ask_model) in the
     # side block, apart from the turns' totals. Safe from any thread.
     # @param usage [SideUsage]
@@ -362,6 +366,14 @@ module Samagotchi
       end
     end
 
+    # The session's spend now (ctx.cost): its turns' sums with the running
+    # turn's finished generations folded in, and its side requests.
+    # Safe from any thread.
+    # @return [Cost]
+    def cost
+      @mutex.synchronize { Cost.of(@totals.with_running(@turn), @side) }
+    end
+
     # Event sink. Safe to call from any thread; errors are isolated by the
     # caller (SessionObserver / TerminalUI) but we still guard internally.
     # @param event [Hash]

data/lib/samagotchi/testing/boundary.rb

@@ -9,6 +9,8 @@ module Samagotchi
     # why: the APIs to design before that bundle could leave chi's repo
     # (spec/samagotchi/testing/boundary_spec.rb keeps both exact).
     module Boundary
+      LIB_DIR = File.expand_path("../..", __dir__)
+
       # A name a bundle may use, and the file that defines it (a require of
       # it is fine too). A name allows itself, its methods (".x") and what
       # it holds ("::X"); one ending in a method or constant allows only that.
@@ -124,6 +126,8 @@ module Samagotchi
       REFERENCE = /\bSamagotchi(?:::[A-Z]\w*)+(?:\.[a-z_]\w*[?!]?)?/
       # A require of one of chi's files.
       REQUIRE = %r{\brequire\s*\(?\s*["'](samagotchi(?:/[\w/]+)?)["']}
+      # A relative require that may leave the bundle.
+      REQUIRE_RELATIVE = /\brequire_relative\s*\(?\s*["']([^"']+)["']/
 
       # One reference outside ALLOWED, in a file of the bundle.
       Finding = Data.define(:reference, :file)
@@ -140,11 +144,22 @@ module Samagotchi
           text = File.read(path)
           refs = text.scan(REFERENCE).reject { |name| allowed?(name) }
           refs += text.scan(REQUIRE).flatten.reject { |file| ALLOWED_REQUIRES.include?(file) }.map { |file| %(require "#{file}") }
+          refs += text.scan(REQUIRE_RELATIVE).flatten.filter_map do |relative|
+            target = File.expand_path(relative, File.dirname(path))
+            next unless within?(target, LIB_DIR) && !within?(target, File.expand_path(dir))
+
+            %(require_relative "#{relative}")
+          end
           file = path.delete_prefix("#{File.expand_path(dir)}/")
           refs.uniq.map { |reference| Finding.new(reference: reference, file: file) }
         end
       end
 
+      def within?(path, dir)
+        path == dir || path.start_with?("#{dir}#{File::SEPARATOR}")
+      end
+      private_class_method :within?
+
       # Whether a bundle may use +name+ ("Samagotchi::X::Y", maybe ".method").
       def allowed?(name)
         ALLOWED.any? do |entry|

data/lib/samagotchi/testing/bundle.rb

@@ -26,12 +26,17 @@ module Samagotchi
     class HookFailed < StandardError
       # @return [Hooks::Failure]
       attr_reader :failure
-
-      def initialize(failure)
-        @failure = failure
-        error = failure.error
-        super("#{failure.hook} raised on #{failure.event}: #{error.class}: #{error.message}")
-        set_backtrace(error.backtrace) if error.backtrace
+      # @return [Array<Hooks::Failure>]
+      attr_reader :failures
+
+      def initialize(failures)
+        @failures = failures.dup.freeze
+        @failure = @failures.first
+        super(@failures.map do |failure|
+          error = failure.error
+          "#{failure.hook} raised on #{failure.event}: #{error.class}: #{error.message}"
+        end.join("; "))
+        set_backtrace(@failure.error.backtrace) if @failure.error.backtrace
       end
 
       def cause = @failure.error
@@ -142,7 +147,7 @@ module Samagotchi
             @plugin = built
           end
         end
-        @hooks_namespace = Hooks::BundleLoader.namespace_for(@name).const_set(:"KitHooks#{object_id}", Module.new)
+        @hooks_namespace = Module.new
         @manifest.hooks.each do |basename, hook|
           next if hook.event.empty?
 
@@ -168,6 +173,27 @@ module Samagotchi
         payload
       end
 
+      # Build the before_tool_call payload from the real Gate, without firing
+      # this bundle's hooks.
+      # @param call [Hash] the parsed tool call
+      # @param iteration [Integer]
+      # @param params [String] the call's one-line preview
+      # @param context [Guardrails::Context, nil]
+      # @param verdict [Verdict, nil]
+      # @return [Hash]
+      def before_tool_call_event(call, params:, iteration: 1, context: nil, verdict: nil)
+        context ||= Guardrails::Context.new(cwd: @recorder[:cwd], session_id: @recorder[:session_id],
+                                            interface: @recorder[:frontend])
+        dispatched = nil
+        capture = Hooks::Registry.new
+        capture.register(:before_tool_call) { |event| dispatched = event.dup }
+        gate = Guardrails::Gate.new(-> { capture }, context_lookup: -> { context }, tools_lookup: -> { tools })
+        gate.evaluate(call, iteration: iteration, params: params, verdict: verdict || Verdict.new(call: call))
+        raise ArgumentError, "guardrails did not dispatch a before_tool_call event for #{call[:name].inspect}" unless dispatched
+
+        dispatched.slice(:type, :iteration, :call, :params, :blocked, :block_reason, :guardrail, :context, :targets)
+      end
+
       # One tool call through a real Guardrails::Gate: the before_tool_call
       # hooks vote on a Testing::Verdict (pass +verdict+ to start from one,
       # another voter's deny in it), with the context and targets the Gate
@@ -331,8 +357,8 @@ module Samagotchi
         result = Hooks.capture_failures(failures, &)
         if @lenient
           @errors.concat(failures)
-        elsif (first = failures.first)
-          raise HookFailed, first
+        elsif failures.any?
+          raise HookFailed, failures
         end
         result
       end

data/lib/samagotchi/testing/host.rb

@@ -2,6 +2,7 @@
 
 require_relative "../cancellation_controller"
 require_relative "../plugin/context"
+require_relative "../session_metrics/cost"
 require_relative "recorder"
 
 module Samagotchi
@@ -48,9 +49,33 @@ module Samagotchi
           toolkit: -> { recorder[:toolkit] },
           declared_tools: -> { recorder[:declared_tools] || tool_names.call },
           use_toolkit: ->(name) { recorder.use_toolkit(name, toolkits.call) },
-          cancel_controller: ->(handler: false) { recorder[:cancelled] ? stopped : nil }
+          cancel_controller: ->(handler: false) { recorder[:cancelled] ? stopped : nil },
+          cost: -> { cost(recorder[:cost]) }
         )
       end
+
+      # The parts a test may give bundle.set(cost: {...}).
+      COST_PARTS = %i[reported estimated side known].freeze
+
+      # The SessionMetrics::Cost ctx.cost returns for the recorder's +cost+
+      # value (Recorder::DEFAULTS).
+      # @return [SessionMetrics::Cost]
+      def cost(value)
+        value = value.call while value.respond_to?(:call)
+        case value
+        when nil then SessionMetrics::Cost.zero
+        when SessionMetrics::Cost then value
+        when Numeric then SessionMetrics::Cost.zero.with(reported: value.to_f)
+        when Hash
+          unknown = value.keys.map(&:to_sym) - COST_PARTS
+          raise ArgumentError, "unknown cost parts: #{unknown.join(", ")}" unless unknown.empty?
+
+          parts = value.transform_keys(&:to_sym)
+          SessionMetrics::Cost.new(reported: parts.fetch(:reported, 0).to_f, estimated: parts.fetch(:estimated, 0).to_f,
+                                   side: parts.fetch(:side, 0).to_f, known: parts.fetch(:known, true))
+        else raise ArgumentError, "cost: a number, a Hash or a callable, not #{value.inspect}"
+        end
+      end
     end
 
     # The hook runtime (Hooks::Runtime: event[:notify] and the other

data/lib/samagotchi/testing/recorder.rb

@@ -32,7 +32,10 @@ module Samagotchi
       DEFAULTS = {
         session_id: "test-session", cwd: nil, messages: [], messages_partial: false, model_name: "test:model",
         model_key: "model", toolkit: "full", declared_tools: nil, frontend: :worker, scratch: false, setup: nil,
-        prompt_files: [], cancelled: false, state_dir: nil, running: true, toolkit_staged: true
+        prompt_files: [], cancelled: false, state_dir: nil, running: true, toolkit_staged: true,
+        # ctx.cost: nil (zero), a Float (reported USD), a Hash of the parts
+        # (reported:, estimated:, side:, known:) or a callable giving one.
+        cost: nil
       }.freeze
 
       attr_reader :notices, :cards, :steers, :stops, :questions, :model_requests, :toolkit_uses, :answers,

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -14,8 +14,9 @@ module Samagotchi
     # of the child's turn the last follow-up went to (Delegate.follow_up),
     # whose own reply a wait takes (ReplyWait's turn:); nil once that turn
     # was reported, or when unknown (a new child, an older worker).
-    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn) do
-      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil) = super
+    #   +report_claim+: a report reserved until the parent's turn is settled.
+    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn, :report_claim) do
+      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil, report_claim: nil) = super
 
       def self.empty = new
 
@@ -33,6 +34,13 @@ module Samagotchi
       end
 
       def to_json_hash = to_h.transform_keys(&:to_s).compact
+
+      def self.from_json_hash(data)
+        return empty unless data.is_a?(Hash)
+
+        new(reply_file: data["reply_file"], last_turn: data["last_turn"], question_id: data["question_id"],
+            messages: data["messages"], turn: data["turn"], report_claim: data["report_claim"])
+      end
     end
 
     # The parent's cursors, one per child, in <parent dir>/delegates.json, so
@@ -68,6 +76,40 @@ module Samagotchi
         end
       end
 
+      # Reserve a report only if the cursor read to build it is still current.
+      # @return [DelegateCursor, nil] the reserved cursor, or nil if another path moved it
+      def claim_report(parent_id, child_id, expected:, claim:, state_dir:)
+        locked(parent_id, state_dir: state_dir) do
+          all = read(parent_id, state_dir: state_dir)
+          cursor = get_from(all, child_id)
+          next nil unless cursor == expected
+
+          claimed = cursor.with(report_claim: claim)
+          all[child_id] = claimed.to_json_hash
+          write(parent_id, all, state_dir: state_dir)
+          claimed
+        end
+      end
+
+      # A new owner can retry reports left reserved by a worker that exited
+      # before committing or releasing its turn. No cursor file means no
+      # claims: the lock would create the session dir and its lock file, so
+      # an empty session would no longer count as empty.
+      def clear_report_claims(parent_id, state_dir:)
+        return unless File.exist?(path(parent_id, state_dir: state_dir))
+
+        locked(parent_id, state_dir: state_dir) do
+          all = read(parent_id, state_dir: state_dir)
+          changed = false
+          all.each_value do |data|
+            next unless data.is_a?(Hash)
+
+            changed = true if data.delete("report_claim")
+          end
+          write(parent_id, all, state_dir: state_dir) if changed
+        end
+      end
+
       # Add the cursors of +entries+ (child id → cursor fields, as #read
       # gives them) that the parent has none for; one it has is kept.
       # @return [Array<String>] the child ids added
@@ -94,11 +136,7 @@ module Samagotchi
       end
 
       def get_from(all, child_id)
-        data = all[child_id]
-        return DelegateCursor.empty unless data.is_a?(Hash)
-
-        DelegateCursor.new(reply_file: data["reply_file"], last_turn: data["last_turn"],
-                           question_id: data["question_id"], messages: data["messages"], turn: data["turn"])
+        DelegateCursor.from_json_hash(all[child_id])
       end
 
       def path(parent_id, state_dir:)

data/lib/samagotchi/tools/delegate_wait.rb

@@ -24,6 +24,7 @@ module Samagotchi
     # the wait's first look (a fast failure) still ends it. The cursors are
     # on disk (DelegateCursors), so a respawned worker doesn't repeat a reply.
     module DelegateWait
+      Advance = Data.define(:cursor, :already_reported)
       TIMEOUT_DEFAULT = 600
       POLL_INTERVAL = 0.5
       # Seconds with no worker before the child counts as gone: as long as
@@ -66,6 +67,11 @@ module Samagotchi
         reports = reports_mode(peers)
         others = relay && others_for(peers.session_id, child_id, relay, sd)
         cursor = DelegateCursors.get(peers.session_id, child_id, state_dir: sd)
+        report_claim = cursor.report_claim
+        if report_claim
+          cursor = DelegateCursor.from_json_hash(report_claim["cursor"]).with(report_claim: report_claim)
+        end
+
         baseline = cursor.baseline
         left = timeout.to_i
         outcomes = relayed_outcomes.delete(key) || []
@@ -78,7 +84,13 @@ module Samagotchi
           left -= monotonic - started
           unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
             outcomes.concat(relayed_outcomes.delete(key) || [])
-            advance(peers.session_id, child_id, wait, state_dir: sd)
+            movement = advance(peers.session_id, child_id, wait, state_dir: sd)
+            if movement&.already_reported
+              file = movement.cursor.report_claim&.fetch("file", nil) || wait.file
+              return already_reported_result(child_id, file, state_dir: sd)
+            end
+            return already_reported_result(child_id, report_claim["file"], state_dir: sd) if report_claim && wait.status == :timeout
+
             text = with_outcomes(finish(wait, child_id, timeout: timeout, reports: reports), outcomes)
             return RefText.wrap(text, reply_path(child_id, wait, state_dir: sd))
           end
@@ -159,15 +171,37 @@ module Samagotchi
       # was reported; a question keeps it. Nothing moves on a timeout or a
       # cancel.
       # @param wait [ReplyWait::Result]
-      # @return [DelegateCursor, nil] the new cursor
+      # @return [Advance, nil] the cursor and whether another path reported it
       def advance(parent_id, child_id, wait, state_dir:)
         return nil unless REPORTED.include?(wait.status) && wait.session
 
-        DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |cursor|
-          cursor = cursor.with(reply_file: wait.file) if wait.status == :done
-          cursor = cursor.with(turn: nil) unless wait.status == :waiting_for_answer
-          cursor.with_baseline(ReplyWait.baseline_of(wait.session))
+        already_reported = false
+        cursor = DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |current|
+          if (current.report_claim && current.report_claim["file"] == wait.file) ||
+             (wait.status == :done && current.reply_file == wait.file)
+            already_reported = true
+            next current
+          end
+
+          current = current.with(reply_file: wait.file) if wait.status == :done
+          current = current.with(turn: nil) unless wait.status == :waiting_for_answer
+          current.with_baseline(ReplyWait.baseline_of(wait.session))
         end
+        Advance.new(cursor: cursor, already_reported: already_reported)
+      end
+
+      def already_reported_result(child_id, file, state_dir:)
+        path = if file.to_s.empty?
+                 nil
+               else
+                 File.join(ReplyWait.reply_dir(child_id, state_dir: state_dir), file)
+               end
+        text = if path
+                 "session: #{child_id}\nstatus: reported\nThe reply was already reported to this session (file: #{File.basename(file)})."
+               else
+                 "session: #{child_id}\nstatus: reported\nThe child's latest status was already reported to this session."
+               end
+        RefText.wrap(text, path)
       end
 
       # The tool result for how the wait ended.

data/lib/samagotchi/version.rb

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

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

@@ -1143,10 +1143,12 @@ function updateSessionTitle() {
 }
 
 // The stage takes a running turn's rows (its extras); else the history.
+// @return true when the stage took +el+ (it scrolls it into its view itself)
 function appendToHistory(el) {
   // (The stage's place first moves a turn still sliding away into the history.)
-  if (turnDom.place?.(el)) return;
+  if (turnDom.place?.(el)) return true;
   appendAboveLiveTiming(historyEl, el, liveTurn.timing.el);
+  return false;
 }
 
 // A turn-end re-read's timing (?tail=1&recent=1: the newest turn's records

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

@@ -26,7 +26,8 @@ import { plainText } from "./plain_line.js";
 
 // @param sessionId () => the open session's id (answers go there)
 // @param clientId this tab's id in the session's events
-// @param place (card) puts a new card at the end of the history
+// @param place (card) puts a new card at the end of the history; true: the
+//   stage took it (it brings the card into its view itself, eased)
 // @param isNearBottom () => whether the history follows its end
 // @param scrollToEnd () scrolls the history to its end
 // @param removeHintIfEmpty () drops the history's placeholder hint
@@ -200,10 +201,10 @@ export function createQuestionCards({
 
     // Read before the card makes the history taller.
     const follow = isNearBottom();
-    place(card);
+    const staged = place(card) === true;
     questionEl = card;
     if (follow) scrollToEnd();
-    focusWhenIdle(card, pq.id);
+    focusWhenIdle(card, pq.id, { staged });
   }
 
   function isPlainEnter(e) {
@@ -213,7 +214,10 @@ export function createQuestionCards({
   // A new card takes the focus while nobody is typing: the focus is on
   // the page or an empty composer. Checked after the caller is done, so a
   // card drawn already answered (the history replay) never takes it.
-  function focusWhenIdle(card, id) {
+  // +staged+: the stage holds the card and scrolls to it once it has grown
+  // for it (eased): the focus doesn't scroll, or the stage would snap to the
+  // card before its room eases in.
+  function focusWhenIdle(card, id, { staged = false } = {}) {
     queueMicrotask(() => {
       if (questionEl !== card || String(pending?.id) !== String(id)) return;
       const prompt = doc.getElementById?.("prompt");
@@ -221,7 +225,8 @@ export function createQuestionCards({
       const idle = !active || active === doc.body || (active === prompt && !prompt.value);
       if (!idle || (prompt && prompt.value)) return;
       const target = card.querySelector(".question-option input") || card.querySelector(".question-freeform");
-      target?.focus();
+      if (staged) target?.focus({ preventScroll: true });
+      else target?.focus();
     });
   }