samagotchi 0.155.0 → 0.157.0

data/lib/samagotchi/system_one/recorder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../log"
+require_relative "recording"
+require_relative "runs"
+
+module Samagotchi
+  module SystemOne
+    # What a turn stage needs to save its System 1 asks as runs: the
+    # Engine's Runs and the session's model as the Engine names it now.
+    # Engine#system_one_recorder builds one fresh at each stage call (never
+    # kept: an outgoing ask after a before_turn hook's model switch names
+    # the new model), on the caller's thread; the stage keeps it only for
+    # that call. NONE is what a stage gets when the Engine couldn't build
+    # one: no runs, every client as it was.
+    #
+    # +runs+ [Runs, nil] where the runs go (Runs#on? false: system_one.runs
+    #   off); nil: NONE
+    # +session_model+ [String, nil] Engine#effective_model_name at the call
+    Recorder = Data.define(:runs, :session_model) do
+      # +client+ (nil for none) saving its asks as +judgment+'s runs. Anything
+      # going wrong here leaves the client as it was: a run is never worth a
+      # judgment. A scratch session's asks aren't saved; a participant's
+      # turn is never judged, so it never comes here.
+      # @param mode [String, nil] the use's mode, for its runs (Recording.wrap)
+      def wrap(client, judgment, session, mode: nil)
+        return client if client.nil? || runs.nil? || session&.scratch
+
+        context = Recording::Context.of(session, session_model: session && session_model)
+        Recording.wrap(client, judgment: judgment, runs: runs, context: context, recorded_mode: mode)
+      rescue StandardError => e
+        Recorder.failed(e)
+        client
+      end
+
+      # Whether runs are saved (an ask whose only use is its run is made
+      # only then: ObjectivesAudit).
+      def saving? = !runs.nil? && runs.on?
+
+      # The one warn for a recording that can't be set up.
+      def self.failed(error)
+        Samagotchi::Log.warn(:system_one, "system_one_recording_failed", error: error.class.name, msg: error.message.to_s[0, 200])
+      end
+    end
+
+    # No recording: the plain client, no runs.
+    Recorder::NONE = Recorder.new(runs: nil, session_model: nil)
+  end
+end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -613,39 +613,19 @@ module Samagotchi
                                         lane = :writing
           when :generation_chunk
             tail, lane = event[:thinking].to_s.empty? ? [event[:text], :writing] : [event[:thinking], :thinking]
-          when :tool_call_started
-            running_tool = event[:tool]
-            @renderer.call(event)
-          when :tool_call_completed
-            running_tool = nil
-            replay_tool_completed(event)
-          when :merged_input then @screen.commit("input> #{event[:content]}")
-          when :reminder_injected then @screen.commit(reminder_line(event[:reminders]))
-          # The turn's start (its images), a plugin's steer, and its rows (a
-          # hook's notice, a retry's line), as they were drawn live.
-          # Questions are left out: the pending one is asked after the
-          # replay, answered ones showed no line.
+          # The turn's start (its images), as it was drawn live.
           when :turn_started then @renderer.call(without_named_images(event, turn[:prompt]))
-          when :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
-            @renderer.call(event)
+          # Its rows, as a drawn turn's (JoinReplay#replay_row).
+          else
+            running_tool = event[:tool] if event[:type] == :tool_call_started
+            running_tool = nil if event[:type] == :tool_call_completed
+            @join_replay.replay_row(event)
           end
         end
         @view.resume(tail: tail, lane: lane, tool: running_tool, parts: turn[:parts])
         ask(turn[:pending_question]) if turn[:pending_question]
       end
 
-      # A finished tool call of the joined turn: the live row (action,
-      # duration). A snapshot from an older worker has no action: its row
-      # names the tool only.
-      def replay_tool_completed(event)
-        return @renderer.call({ duration_ms: nil }.merge(event)) if event.dig(:activity, :action)
-
-        activity = EventRenderer.described(event) || {}
-        @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
-                                            description: activity[:description], output_truncated: event[:output_truncated],
-                                            images: event[:images], diff: event[:diff] }))
-      end
-
       def start_turn(event)
         @running = true
         @joined_mid_turn = false

data/lib/samagotchi/terminal_ui/exit_lines.rb

@@ -14,7 +14,7 @@ module Samagotchi
       LATE = "worker not answering in time"
       # An exit the worker agreed to in an empty session. Said before it has
       # left: it checks again once it lets go, and a note or prompt arriving
-      # first keeps the session (SessionManager.discard_left_session).
+      # first keeps the session (WorkerBoot.discard_left_session).
       EMPTY_WORDS = "the session is empty: it will be discarded if nothing arrives before its worker stops."
       EMPTY_EXIT = "Detached; #{EMPTY_WORDS}"
       # Why the worker stayed up after /exit, by the reason it gave.

data/lib/samagotchi/terminal_ui/join_replay.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../bridge/turn_accumulator"
 require_relative "../context_note"
 require_relative "../image_store"
 require_relative "../log"
@@ -31,11 +32,32 @@ module Samagotchi
         @renderer = renderer
       end
 
+      # A snapshot's last_turn_drawing (Bridge#snapshot: the last exchange's
+      # turn as live drew it) draws that turn's rows; without one (an older
+      # worker, a turn before drawings) they are rebuilt from the messages.
       def render_join(snapshot, saved)
-        render_join_header(Array(snapshot[:messages]))
+        render_join_header(Array(snapshot[:messages]), drawing: snapshot[:last_turn_drawing])
         render_join_gap(snapshot, saved)
       end
 
+      # One replayed event of a turn's rows (TurnAccumulator.replay_events),
+      # as live drew it: a joined running turn's (AttachedLoop#render_current_turn)
+      # and a drawn finished one's (#render_drawn_turn). Its tool rows with
+      # their action and duration, merged input, reminders, a plugin's steer,
+      # a hook's notice, a retry's, a steer cut's and a ✂ row's line. The
+      # step text, the turn's start and questions are the caller's (the
+      # pending one is asked after the replay, answered ones showed no line).
+      def replay_row(event)
+        case event[:type]
+        when :tool_call_started then @renderer.call(event)
+        when :tool_call_completed then replay_tool_completed(event)
+        when :merged_input then @screen.commit("input> #{event[:content]}")
+        when :reminder_injected then @screen.commit(reminder_line(event[:reminders]))
+        when :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
+          @renderer.call(event)
+        end
+      end
+
       # The snapshot's cards and between-turns notices (Bridge CardStore):
       # on join the ones since the last turn (and the running turn's), as
       # the join header shows the last exchange; on a resync only cards not
@@ -60,6 +82,18 @@ module Samagotchi
 
       private
 
+      # A finished tool call: the live row (action, duration: none when the
+      # part has none, never the replay's own clock). A snapshot from an
+      # older worker has no action: its row names the tool only.
+      def replay_tool_completed(event)
+        return @renderer.call({ duration_ms: nil }.merge(event)) if event.dig(:activity, :action)
+
+        activity = EventRenderer.described(event) || {}
+        @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
+                                            description: activity[:description], output_truncated: event[:output_truncated],
+                                            images: event[:images], diff: event[:diff] }))
+      end
+
       # Where the session's last activity was: its newest stamped entry,
       # else its saved recap's time. A gap ago (and no turn running): one
       # line after the join block says when.
@@ -71,7 +105,7 @@ module Samagotchi
         @screen.commit(gap_divider(line)) if line
       end
 
-      def render_join_header(messages)
+      def render_join_header(messages, drawing: nil)
         exchange = messages.select { |m| %w[user model assistant].include?(m[:role].to_s) }
         # The id stays findable: the detach line and chi sessions list show it.
         Log.session_id = @link.client.session_id
@@ -89,6 +123,11 @@ module Samagotchi
         unless ImageRef.placeholder_only?(exchange[last_user][:content])
           Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         end
+        if (drawn = drawn_turn(drawing, exchange[last_user]))
+          render_drawn_turn(*drawn, exchange[(last_user + 1)..])
+          return render_join_notes(messages, from, after_exchange: true)
+        end
+
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
         record = @link.saved_turn_record(exchange[last_user][:turn_id] || exchange[last_user]["turn_id"])
         failed = join_failed_record(record)
@@ -109,16 +148,55 @@ module Samagotchi
           @screen.commit(@view.turn_canceled_line(record["cancellation_reason"], record["duration_ms"], by: record["cancelled_by"]))
           @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) unless record["continue"]
         else
-          # The saved answer is raw: the latest keeps its thinking, and one may
-          # be only a tool call.
-          answer = exchange[(last_user + 1)..].reverse_each
-                                             .map { |m| OutputFormatter.strip_markup(m[:content]) }
-                                             .find { |text| !text.empty? }
-          @screen.commit(last_lines(answer)) if answer
+          render_join_answer(exchange[(last_user + 1)..])
         end
         render_join_notes(messages, from, after_exchange: true)
       end
 
+      # The last answer of the messages after the prompt (+after+). The saved
+      # answer is raw: the latest keeps its thinking, and one may be only a
+      # tool call.
+      def render_join_answer(after)
+        answer = after.reverse_each.map { |m| OutputFormatter.strip_markup(m[:content]) }.find { |text| !text.empty? }
+        @screen.commit(last_lines(answer)) if answer
+      end
+
+      # The snapshot's drawing as [turn, end event] when it is +prompt+'s
+      # turn (a Continue's or a reminder's drawing isn't the prompt's: the
+      # rows are rebuilt), else nil.
+      def drawn_turn(drawing, prompt)
+        return nil unless drawing.is_a?(Hash) && drawing[:drawing].is_a?(Hash) && drawing[:end].is_a?(Hash)
+
+        turn = Bridge::TurnAccumulator.from_wire(drawing[:drawing])
+        id = prompt[:turn_id] || prompt["turn_id"]
+        return nil unless id && turn[:turn_id].to_s == id.to_s
+
+        [turn, EventRenderer.symbolize(Bridge::TurnAccumulator.from_wire(drawing[:end]))]
+      end
+
+      # The last turn from its drawing, through the renderer as live drew it
+      # (the running turn's join path, AttachedLoop#render_current_turn): its
+      # rows with their status and duration, a retry's line, a hook's notice,
+      # steers, merged input and reminders; no step text (the live ticker's)
+      # and no cards (the snapshot's cards are drawn after). Then its end: a
+      # cancel's or a failure's line from the end event, else the empty
+      # answer's notice or the saved answer (+after+, the messages after the
+      # prompt).
+      def render_drawn_turn(turn, ending, after)
+        Bridge::TurnAccumulator.replay_events(turn).each do |event|
+          # The prompt line named its images already.
+          event[:type] == :turn_started ? @renderer.call(event.except(:images)) : replay_row(event)
+        end
+        case ending[:type]
+        when :turn_canceled, :turn_failed then @renderer.call(ending)
+        else
+          empty = ending.dig(:turn_summary, :empty_answer)
+          empty ? @screen.commit(format_empty_answer_line(empty[:retries], empty[:refusal])) : render_join_answer(after)
+        end
+        # A call the turn never answered left the tool slot running.
+        @view.finish_thinking_spinner
+      end
+
       # What the last exchange did, as the live turn drew it: each saved
       # call's tool row (action, params, status from its result, and its
       # duration from +durations+, the turn's saved tool records) and a

data/lib/samagotchi/terminal_ui/local_link.rb

@@ -112,13 +112,13 @@ module Samagotchi
       # no turn id (an older session) or a session with no analytics.
       def saved_tool_records(turn_id)
         SessionMetrics.saved_tool_records(session_dir, turn_id)
-      rescue Session::InvalidId
+      rescue SessionPaths::InvalidId
         []
       end
 
       def saved_turn_record(turn_id)
         SessionMetrics.saved_turn_record(session_dir, turn_id)
-      rescue Session::InvalidId
+      rescue SessionPaths::InvalidId
         nil
       end
 

data/lib/samagotchi/terminal_ui.rb

@@ -44,8 +44,6 @@ module Samagotchi
     # Raised when another process (a worker or another chi) owns the session
     # this run was asked to use.
     class SessionBusy < StandardError; end
-    # --resume with an id that has no saved session.
-    class SessionNotFound < StandardError; end
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
@@ -92,7 +90,9 @@ module Samagotchi
       # As typed: the Engine applies an alias where it resolves the model.
       flag_model_name = model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(model_name)
       @effective_model_name = flag_model_name || @default_model_name
-      @host_registry = host_registry || Samagotchi::HostRegistry.new
+      # Taken once (as the Engine's); a client (specs) goes on a registry of
+      # its own, never the shared one.
+      @host_registry = host_registry || (client ? Samagotchi::HostRegistry.new : Samagotchi::HostRegistry.current)
       # An injected client (specs) stands in for every host's client.
       @host_registry.client_override = client if client
       @client = @host_registry.resolve(@effective_model_name).client
@@ -100,9 +100,7 @@ module Samagotchi
       # between the load and the lock that this run would later save over.
       # An unknown id is refused before the claim, which would leave an
       # empty session dir behind.
-      if session_id && !Session.exist?(session_id)
-        raise SessionNotFound, "Session not found: #{session_id}"
-      end
+      raise Session::NotFound, session_id if session_id && !Session.exist?(session_id)
 
       claim_session!(session_id) if session_id
       @resume_session = session_id ? Session.load(session_id) : nil
@@ -434,7 +432,7 @@ module Samagotchi
 
     # A fresh session reaches the disk before its first turn: a tool in that
     # turn reads it from there (delegate loads its parent to start a child,
-    # "Session not found" otherwise).
+    # "no session …" otherwise).
     def save_before_first_turn(session)
       session.save unless Session.exist?(session.id)
     end

data/lib/samagotchi/testing/install.rb

@@ -23,7 +23,8 @@ module Samagotchi
     module Install
       # warnings: the Installer's; plugin_failures / hook_failures:
       # [Guardrails::LoadFailures::Failure] of this bundle, each location
-      # in the source dir; registered: what it registered (#registered).
+      # in the source dir (hook_failures: the guardrails', a required
+      # plugin's among them); registered: what it registered (#registered).
       Result = Data.define(:name, :warnings, :plugin_failures, :hook_failures, :registered) do
         def failures = plugin_failures + hook_failures
       end

data/lib/samagotchi/testing/sessions.rb

@@ -60,7 +60,7 @@ module Samagotchi
       end
 
       def read(id)
-        answer(:read, [id], {}) { raise Plugin::Sessions::Error, "no session #{id}" }
+        answer(:read, [id], {}) { raise Plugin::Sessions::Error, Session::NotFound.new(id).message }
       end
 
       def children(all: false)

data/lib/samagotchi/thinking.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "config"
-require_relative "model_profile"
 require_relative "setting_explained"
 
 module Samagotchi
@@ -79,30 +78,23 @@ module Samagotchi
       nil
     end
 
-    # The level for +target+ and where it came from ("session",
+    # The level for +lookup+'s model and where it came from ("session",
     # "--thinking", "models: qwen", "hosts.work", "thinking.level"; nil for
     # the default).
-    # @param target [HostRegistry::ModelTarget]
-    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
-    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @param session [Symbol, nil] the session's own level (Session#thinking)
     # @return [Array(Symbol, String|nil)]
-    def resolve(target, names:, models: nil, session: nil)
+    def resolve(lookup, session: nil)
       return [session, SESSION_SOURCE] if session
 
-      global, origin = global_level
+      global, origin = global_level(lookup)
       return [global, origin == :cli ? "--thinking" : "SAMAGOTCHI_THINKING_LEVEL"] if global && %i[cli env].include?(origin)
 
-      models ||= begin
-        ConfigFile.model_settings
-      rescue StandardError
-        {}
-      end
-      setting = ConfigFile.model_setting(names, :thinking, models: models)
+      setting = lookup.model(:thinking)
       return [setting.value, "models: #{setting.key}"] if setting
 
-      host = target.entry.thinking
-      return [host, "hosts.#{target.entry.name}"] if host
+      host = lookup.host(:thinking)
+      return [host, "hosts.#{lookup.host_name}"] if host
       return [global, "thinking.level"] if global
 
       [DEFAULT, nil]
@@ -110,14 +102,15 @@ module Samagotchi
 
     # #resolve, as a SettingExplained with the session's own level beside it.
     # @return [SettingExplained]
-    def explain(target, names:, models: nil, session: nil)
-      level, source = resolve(target, names: names, models: models, session: session)
+    def explain(lookup, session: nil)
+      level, source = resolve(lookup, session: session)
       SettingExplained.new(level: level, source: source, own: session)
     end
 
     # thinking.level as a level and its origin (:cli, :env, :file), or nil.
-    def global_level
-      raw, origin = Config.get_with_origin("thinking.level")
+    # @param lookup [ModelLookup] whose env the key is read with
+    def global_level(lookup)
+      raw, origin = lookup.global("thinking.level")
       return nil if origin == :default
 
       where = { cli: "--thinking", env: "SAMAGOTCHI_THINKING_LEVEL" }.fetch(origin, "thinking.level")
@@ -139,13 +132,15 @@ module Samagotchi
     #              only the tail changes (llama.cpp and Splash keep the rest).
     # @param target [HostRegistry::ModelTarget]
     # @param profile [String, nil] the native prompt profile's name
+    # @param inferred [String, nil] the profile a local chat host's model
+    #   name says (ModelProfile.inferred_profile_name of its bare id)
     # @return [Symbol]
-    def cache_cost(target, profile: nil)
+    def cache_cost(target, profile: nil, inferred: nil)
       entry = target.entry
       if entry&.chat?
         return :provider if entry.remote?
 
-        return ModelProfile.inferred_profile_name(target.bare_model) == "gemma4" ? :full : :tail
+        return inferred == "gemma4" ? :full : :tail
       end
 
       profile == "gemma4" ? :full : :tail

data/lib/samagotchi/token_usage.rb

@@ -23,7 +23,7 @@ module Samagotchi
   class TokenUsage < Data.define(:prompt_tokens, :completion_tokens, :cached_tokens, :cache_write_tokens,
                                  :reasoning_tokens, :cost, :predicted_per_second, :prompt_per_second, :predicted_ms, :source)
     CHARS_PER_TOKEN = 4.0
-    # Re-prefilled tokens under this are none (KernelLoop#reprefilled_tokens,
+    # Re-prefilled tokens under this are none (ReprefillMeter#tokens,
     # SessionMetrics): servers count the cache in blocks (OpenAI's 128).
     REPREFILL_MIN_TOKENS = 128
 

data/lib/samagotchi/tool_activity.rb

@@ -5,6 +5,7 @@ require_relative "log"
 require_relative "command_steps"
 require_relative "tool_view"
 require_relative "tools/execute"
+require_relative "tools/registry"
 require_relative "tools/read"
 require_relative "tools/write"
 require_relative "tools/memory"
@@ -359,8 +360,9 @@ module Samagotchi
       name == "git" && args.first == "diff" && args.intersect?(%w[--quiet --exit-code])
     end
 
-    # +surface+: the turn's Tools::ToolSurface, for a preview that reads it
-    # (call_tool's); nil outside a turn.
+    # +surface+: the turn's Tools::ToolSurface, which a tool's entry is
+    # looked up in, for a preview that reads it (call_tool's); nil outside a
+    # turn (+registry+'s entry then).
     def tool_activity_params(tool_name, call, registry: nil, surface: nil)
       case tool_name
       when Tools::Execute::NAME
@@ -455,7 +457,8 @@ module Samagotchi
         parts << "options=#{preview_tool_param(Array(opts).join(","))}" if opts && !Array(opts).empty?
         parts.join(" ")
       else
-        registry_params(registry_entry(registry, tool_name), call, surface)
+        registry_params(surface ? surface.registered[tool_name.to_s] : registry_entry(registry, tool_name), call,
+                        surface)
       end
     end
 
@@ -473,7 +476,8 @@ module Samagotchi
     # key="value" (the parsers' args:, which a registry-less reader such as
     # the web's reload also has); nil for a tool the registry doesn't know
     # that has no args:, and for a built-in without its own words above
-    # (the reminder tools).
+    # (the reminder tools). A missing surface (Tools::MissingSurface) is
+    # raised, never taken as a failing preview.
     def registry_params(entry, call, surface = nil)
       return nil if entry&.core?
       return nil if entry.nil? && !call[:args].is_a?(Hash)
@@ -481,6 +485,8 @@ module Samagotchi
       if entry&.preview
         begin
           return entry.preview_of(call, surface)
+        rescue Tools::MissingSurface
+          raise
         rescue StandardError => e
           Log.warn(:plugins, "plugin_preview_failed", tool: entry.name, error: e.class.name,
                                                       msg: "#{entry.name} preview failed: #{e.message}")

data/lib/samagotchi/tool_declarations.rb

@@ -2,7 +2,7 @@
 
 require "json"
 require_relative "tools/args"
-require_relative "llm_context_strategy"
+require_relative "config"
 require_relative "tools/memory"
 
 module Samagotchi
@@ -482,7 +482,7 @@ module Samagotchi
     # (Tools::Registry's layer gate), so it is not in TOOL_SCHEMAS, which
     # every turn declares. Its description carries llm_context.policy
     # (#forget_outputs_schema); this one the default's.
-    FORGET_OUTPUTS_POLICY = LLMContextStrategy::DEFAULT_POLICY
+    FORGET_OUTPUTS_POLICY = Config::DEFAULT_LLM_CONTEXT_POLICY
     FORGET_OUTPUTS_DESCRIPTION = "Forget tool outputs you no longer need, to free context. Every tool output starts " \
                                  "with an id like [#t42]: list ids to forget, and each output is replaced in place by " \
                                  "a stub with your note (the call stays). %<policy>s\n" \

data/lib/samagotchi/tool_output_cut.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "config"
 require_relative "tool_output_files"
 
 module Samagotchi
@@ -28,6 +29,22 @@ module Samagotchi
   # task's log, the child's reply in its output/ folder), which the tool
   # gave with its text (Tools::RefText) and the gap line names.
   module ToolOutputCut
+    # The per-output cap with nothing set (max_tool_output_chars).
+    DEFAULT_MAX_CHARS = 10_000
+
+    # The per-output cap both loops cut tool outputs to (and the emitted
+    # tool call events carry): an explicit +override+ wins, then
+    # max_tool_output_chars (Config). A non-positive value falls back to
+    # DEFAULT_MAX_CHARS (there is intentionally no "unlimited": live UIs get
+    # a bounded `output:` plus a truthful `output_truncated:` flag). The one
+    # exception is memory_read, which ToolRunner leaves out of this cap
+    # (memory.read_max_chars, 0: no fixed cap; a memory is read whole).
+    # @return [Integer]
+    def self.max_chars(override)
+      parsed = (override || Config.get("max_tool_output_chars")).to_i
+      parsed.positive? ? parsed : DEFAULT_MAX_CHARS
+    end
+
     POLICIES = { "execute" => :head_tail_file, "task_wait" => :head_tail_ref, "delegate" => :head_tail_ref,
                  "delegate_result" => :head_tail_ref }.freeze
 

data/lib/samagotchi/tool_response.rb

@@ -35,15 +35,17 @@ module Samagotchi
     # #interrupted run for every call left (the one it cut short too), so
     # the loop's conversation answers each call, then goes on up: the turn
     # keeps its progress (Engine#ctrl_c_messages). +context+: the calls'
-    # turn (TurnContext), each run's (ToolRunner#run).
+    # turn (TurnContext), each run's (ToolRunner#run). +ids+: the calls'
+    # ToolIds, in call order (ToolIds.next_ids before the batch: the ids the
+    # entries are saved under), each on its run's tool events; nil: none.
     # @return [Array<ToolRun>] the runs
-    def run_batch(runner, calls, context:, iteration:, emit:, on_stream_event:, cap:)
+    def run_batch(runner, calls, context:, iteration:, emit:, on_stream_event:, cap:, ids: nil)
       # Before anything can be interrupted: the rescue counts it.
       runs = []
       emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
       calls.each_with_index do |call, index|
         runs << runner.run(call, context: context, iteration: iteration, call_index: index + 1, call_count: calls.length,
-                                 on_stream_event: on_stream_event, max_tool_output_chars: cap)
+                                 on_stream_event: on_stream_event, max_tool_output_chars: cap, tool_id: ids&.[](index))
         yield runs.last, index if block_given?
       end
       emit.call({ type: :tool_dispatch_completed, iteration: iteration, call_count: calls.length })

data/lib/samagotchi/tool_runner.rb

@@ -86,7 +86,10 @@ module Samagotchi
     #   file (EditPreview.change; also on tool_call_completed, never in the
     #   model's output)
     # @param context [TurnContext] the call's turn
-    def run(call, context:, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:)
+    # @param tool_id [String, nil] the id the run's output is saved under
+    #   (ToolIds, handed out before the batch runs), on both tool events
+    #   so a UI's row and the saved output share it
+    def run(call, context:, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:, tool_id: nil)
       # A call_tool of one of chi's own tools runs as that tool, from here
       # on (the gate, the row, the result): rules, approvals and hooks see
       # the real call, with via: (Tools::ToolIndex#unwrap).
@@ -114,6 +117,7 @@ module Samagotchi
       started = { type: :tool_call_started, iteration: iteration, call_count: call_count, call_index: call_index,
                   tool: call[:name], call: call.dup, params: params }
       started[:label] = label if label
+      started[:tool_id] = tool_id if tool_id
       # Its row fields (ToolRowFields: title, called_as, via, view, ref, and a
       # plugin tool's refs); the worker runs in its session's working
       # directory.
@@ -121,6 +125,8 @@ module Samagotchi
       refs = RowRefs.for(tools && !call[:name].nil? ? tools[call[:name]]&.refs : nil, call, cwd: session_cwd(context))
       fields[:refs] = refs unless refs.empty?
       started.merge!(fields)
+      # The row's clock: tool_call_completed's duration_ms runs from here.
+      started_clock = @clock.call
       emit(on_stream_event, started)
 
       # The ask comes after tool_call_started: the UI shows the tool line,
@@ -175,9 +181,20 @@ module Samagotchi
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
       completed[:output_file] = output_file if output_file
+      completed[:tool_id] = tool_id if tool_id
+      # A long output's web row (its hover): the cut a reload draws from the
+      # saved output (MessageParts#tool_part), so live and reload show the
+      # same text. The TUI keeps +output+.
+      if capped.length > ToolOutputCut::WEB_PREVIEW_CHARS
+        completed[:preview] = ToolOutputCut.preview(capped, cap: ToolOutputCut::WEB_PREVIEW_CHARS, tool: call[:name])
+      end
       # Also here: a UI that missed the start (a replay gap) builds its row
       # from this event (its title is in the activity).
       completed.merge!(fields.slice(*ToolRowFields::EVENT_KEYS))
+      # The row's duration, the one every UI shows (live, a reload's tool
+      # record, the attached terminal): SessionMetrics' definition and
+      # rounding order, from the started emit to this one, less the wait.
+      completed[:duration_ms] = [((@clock.call - started_clock) * 1000).round - (waited_ms || 0), 0].max
       emit(on_stream_event, completed)
       # After the completed event: a hook's card (check-in, skills) prints
       # under the call's tool row, not before it.
@@ -407,22 +424,25 @@ module Samagotchi
     # The kernel's tools, for the activity line of a tool that isn't built in.
     def tools = @kernel.tools
 
-    # The turn's Tools::ToolSurface (+context+'s), else one computed now
-    # from the kernel's tools (a runner outside an Engine turn).
-    def surface(context) = Tools::ToolSurface.of(context, tools)
+    # The turn's Tools::ToolSurface (+context+'s; none raises
+    # Tools::MissingSurface).
+    def surface(context) = Tools::ToolSurface.of(context)
 
     # The call its tool's entry unwraps it to (call_tool on a built-in),
     # else the call as it is. On a host that loads tools, a direct call of
     # a source's tool by its acts_as runs as the call_tool call first
     # (Registry::Index#wrap): call_tool's row, rules and approvals. One
     # that fails runs as it is: call_tool then refuses a built-in (fail
-    # closed).
+    # closed). A context without a surface raises Tools::MissingSurface
+    # here, before the gate: the call never runs.
     def unwrapped(call, context)
       return call if tools.nil? || call[:name].nil?
 
       surface = surface(context)
       call = wrapped(surface, call)
       surface.declared_entry(call[:name])&.unwrap&.call(call, surface) || call
+    rescue Tools::MissingSurface
+      raise
     rescue StandardError => e
       Log.warn(:turn, "tool_unwrap_failed", tool: call[:name].to_s, error: "#{e.class}: #{e.message}")
       call

data/lib/samagotchi/toolkit_command.rb

@@ -115,7 +115,7 @@ module Samagotchi
         raise ArgumentError, "#{NAME} #{verb} needs a tool name\n#{USAGE}" if tools.empty?
 
         tools.reduce(toolkit) do |kit, tool|
-          raise ArgumentError, "no tool named #{tool} in this session" unless @engine.tools.key?(tool)
+          raise ArgumentError, "no tool named #{tool} in this session" unless @engine.published_tools.key?(tool)
 
           verb.casecmp?("add") ? kit.adding(tool) : kit.removing(tool)
         end