samagotchi 0.49.0 → 0.51.0

data/lib/samagotchi/hooks/stream_watch.rb

@@ -32,16 +32,20 @@ module Samagotchi
         @clock = clock
         @slow_logged = false
         @iteration = nil
+        @restarted = false
       end
 
-      # A new generation (:generation_started).
-      def started(iteration)
+      # A new generation (:generation_started), or a dropped stream's step
+      # asked again (restarted: true: the first fire after it carries
+      # restarted: true — what came before is void).
+      def started(iteration, restarted: false)
         @iteration = iteration
         @started_at = @last_fire_at = @clock.call
         @thinking = +""
         @text = +""
         @thinking_chars = 0
         @text_chars = 0
+        @restarted = restarted
       end
 
       # One chunk's new thinking and visible text.
@@ -70,6 +74,9 @@ module Samagotchi
                   elapsed_ms: ((now - @started_at) * 1000).round,
                   # A question would hold the HTTP read for minutes.
                   ask_user: ->(**) {} }
+        # The first fire after a restarted retry says so, once.
+        event[:restarted] = true if @restarted
+        @restarted = false
         @thinking = +""
         @text = +""
         @last_fire_at = now

data/lib/samagotchi/host_registry.rb

@@ -200,9 +200,11 @@ module Samagotchi
     # id it is sent as (ModelRef: one alias pass). A ref that names a host
     # goes there. A bare id goes to the hosts whose cached list has it or
     # that declare it (hosts.<name>.models, known before any /models): the
-    # default host when it is one of them, else the first in hosts: order,
-    # else the default host (before /models nothing is listed: no
-    # discovery here, the latency budget). Never by a substring.
+    # default host when it is one of them, else the first in hosts: order.
+    # When none does, the hosts whose saved list (ModelListStore, another
+    # process's listing: a worker spawned with --model never lists) has
+    # it, the same way; else the default host (no discovery here, the
+    # latency budget). Never by a substring.
     def host_for_model(raw_model)
       ref = model_ref(raw_model)
       # ModelRef names a host only when it is one of ours
@@ -211,6 +213,7 @@ module Samagotchi
       down = ref.id.to_s.strip.downcase
       listed = @mutex.synchronize { @model_index }&.fetch(down, nil) || []
       candidates = @entries.values.select { |e| listed.include?(e.name) || e.models&.key?(down) }.map(&:name)
+      candidates = saved_hosts_for(down) if candidates.empty?
       default = default_entry
       name = candidates.include?(default.name) ? default.name : candidates.first
       [(name && find_entry(name)) || default, ref.id]
@@ -383,7 +386,17 @@ module Samagotchi
     # a worker without listing (`chi send --new --model`, delegate):
     # ModelListStore is what they check an id against.
     def save_model_list(name, models)
-      ModelListStore.save(name, Array(models).map(&:id))
+      ModelListStore.save(name, Array(models).map(&:id), env: @env)
+    end
+
+    # The configured hosts, in hosts: order, whose fresh saved list
+    # (ModelListStore) has +down+ (a downcased id). The store never raises.
+    def saved_hosts_for(down)
+      saved = ModelListStore.read(env: @env)
+      @entries.each_key.select do |name|
+        list = saved[name]
+        list && !list.stale? && list.known?(down)
+      end
     end
 
     def fresh_list(name, entry)

data/lib/samagotchi/kernel_loop.rb

@@ -952,11 +952,30 @@ module Samagotchi
 
     private
 
+    # Shell-like names (the harness's is `execute`). The unknown-tool error
+    # never echoes the name the model used — a model that sees its own wrong
+    # name again calls it again (a steer that named `bash` raised one model's
+    # bash rate from 9% to 30%); the activity event and the logs keep it.
+    SHELL_LIKE_TOOL_NAMES = %w[
+      bash sh zsh shell terminal cmd command run run_command run_shell exec execute_command
+    ].freeze
+
+    # The error an unknown tool name gets back. A shell-like name with
+    # `execute` offered this turn points at `execute`; every other unknown
+    # name lists what is offered. Neither echoes the wrong name.
+    def unknown_tool_error(name, layers)
+      names = @tools.names(layers: layers)
+      if SHELL_LIKE_TOOL_NAMES.include?(name.to_s.downcase) && names.include?("execute")
+        "Error: no such tool. Shell commands run with `execute` (same arguments)."
+      else
+        "Error: no such tool. Available: #{names.join(", ")}"
+      end
+    end
+
     def dispatch(call)
       entry = @tools.offered(call[:name], layers: llm_context_layers)
       unless entry
-        available = @tools.names(layers: llm_context_layers).join(", ")
-        result = "Error: unknown tool '#{call[:name]}'. Available: #{available}"
+        result = unknown_tool_error(call[:name], llm_context_layers)
         return {
           output: result,
           activity: ToolActivity.tool_activity_event(call[:name], call, result, registry: @tools)
@@ -965,6 +984,13 @@ module Samagotchi
 
       dump_log("tool_call", call[:content], tool: call[:name], path: call[:path], scope: call[:scope])
 
+      if call[:called_as]
+        # The model's spelling for a tool an alias ran (bash → execute); its
+        # rate is what the alias exists for, so it goes in the log. Tag :turn
+        # like the other per-call tool logs (there is no :tool tag).
+        Log.info(:turn, "tool_alias", name: call[:called_as], as: call[:name])
+      end
+
       result = entry.handler.call(call, tool_context)
 
       dump_log("tool_result", result, tool: call[:name])

data/lib/samagotchi/llm/native_tool_normalizer.rb

@@ -11,8 +11,8 @@ module Samagotchi
     # the call, as it does for the Gemma and Qwen parsers.
     #
     # Unknown tool names pass through with their arguments on args:, so
-    # `dispatch` renders its standard "unknown tool … available: …" error —
-    # the loop feeds that back like any tool result.
+    # `dispatch` renders its standard "no such tool …" error (which never
+    # echoes the name) — the loop feeds that back like any tool result.
     class NativeToolNormalizer
       class << self
         # Map a single native tool call (LLM::ToolCall) to the internal call hash.

data/lib/samagotchi/send_command.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "client_id"
+require_relative "delivery"
 require_relative "session"
+require_relative "session_commands"
 require_relative "session_inbox"
 require_relative "session_manager"
 require_relative "session_chain"
@@ -33,13 +35,14 @@ module Samagotchi
     MAX_IMAGES = ImageStore::MAX_TURN_REFS
 
     USAGE = <<~TEXT
-      Usage: chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...
+      Usage: chi send [-m TEXT] [--image PATH]... [--cut] (ID|PREFIX)...
              chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
-        or a running one picks it up. A stopped session's worker starts.
+        or a running one takes it at its next step. A stopped session's
+        worker starts.
         A session command (/model x, !cmd) runs as the command; --wait
         then has no reply to wait for (exit 0, status command).
         -m TEXT     the message; stdin, when piped too, goes above it as a
@@ -74,6 +77,14 @@ module Samagotchi
                     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)
+        --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
+                    the message waits for the thinking to pass it). A
+                    message without --cut goes in at the running turn's
+                    next step and cuts nothing. To an idle session it
+                    sends normally. Refused with --wait into a running
+                    turn (the steer's turn is the running one)
         --timeout S (--wait) give up after S seconds, exit 4 (the turn
                     goes on); default no limit
         --format json
@@ -81,7 +92,8 @@ module Samagotchi
                     status answered (text), question (question,
                     answer_with), running, or failed, canceled,
                     limit, no_answer, error, worker_gone, stopped,
-                    command (detail)
+                    command (detail); with --cut also delivery (what
+                    the worker applied) and cut (now, waits, off)
         Exit with --wait: 0 answered, 1 failed or gone, 2 usage, 3 a
         question waits, 4 still running (--timeout), 130 Ctrl-C.
         Only sessions on this machine. Answers show in the attached TUI
@@ -100,6 +112,7 @@ module Samagotchi
       f.value "--llm-context-budget", key: :llm_budget
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
+      f.switch "--cut"
       f.value "--timeout"
       f.value "--format"
       # Starting a turn in every live session at once is too easy to do
@@ -159,6 +172,7 @@ module Samagotchi
     def run_parsed(options)
       # With --wait stdout is the answer alone.
       @info = options[:wait] ? @stderr : @stdout
+      @cut = options[:cut] == true
       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?
@@ -175,6 +189,14 @@ module Samagotchi
         @stderr.puts("chi send: #{e.message}")
         return 1
       end
+      # A UI-only command (/stats, /exit, …) runs in the terminal and the web,
+      # not in the worker: sent through, the worker doesn't run it and the
+      # line reaches the model as a prompt, costing a whole turn. Refused
+      # before anything is sent (before a --new session is created too); the
+      # session's plugin commands are never local.
+      if prompt && (local = local_command(prompt))
+        return refuse_local_command(local, options)
+      end
       # A file that is not there or not an image: a run-time failure (1),
       # reported in the --format json line too; --image itself was fine.
       return CLI::Exit::FAILED unless ingest_images(options[:images])
@@ -440,6 +462,58 @@ module Samagotchi
     # (a bundle's too).
     def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
 
+    # The UI-only built-in command +text+ (stripped) is a line of (/stats,
+    # /exit, …), or nil: the worker never runs it, so chi send must not pass
+    # it on. What the UIs run: the line as the entry's match takes it — bare
+    # "exit" too (/exit's match), but not with arguments ("/exit --delete" is
+    # a UI line; "/stats please" is a prompt), as in a terminal.
+    # @return [Commands::Registry::Entry, nil]
+    def local_command(text)
+      line = text.to_s.strip
+      return nil unless command_like?(line) || line.match?(/\Aexit\z/i)
+
+      entry = SessionCommands.builtin_registry.lookup_local(line)
+      # Only the exact line the UI runs: "/stats please" is a prompt, and
+      # "/exit --delete" is left to the worker (the TUI runs it as /exit, the
+      # worker answers its unknown-command way). Bare "exit" is /exit's line
+      # as its match takes it; the reply names the command, /exit.
+      return nil unless entry
+      return entry if line == entry.name
+
+      line.match?(/\Aexit\z/i) ? entry : nil
+    end
+
+    # A UI-only command: nothing is sent (with --new, no session is created
+    # either). /stats points at its model-free reader and names the session;
+    # the others just say the worker doesn't run them. Exit 1, as other
+    # refusals; with --wait --format json the line is the usual error object
+    # (ParentWait's end-of-run line when the reply never comes).
+    # @return [Integer] 1
+    def refuse_local_command(entry, options)
+      if options[:new]
+        error_line("chi send: refused: #{local_refusal(entry.name, nil)}")
+      elsif options[:wait]
+        # --wait: the JSON line goes to stdout, @info is stderr; an unknown
+        # or ambiguous id gets resolve's own error line.
+        id = resolve(options[:ids].first) or return CLI::Exit::FAILED
+        @stderr.puts("#{id[0, 8]}  refused: #{local_refusal(entry.name, id)}")
+      else
+        options[:ids].uniq.each do |given|
+          id = resolve(given) or next
+          @info.puts("#{id[0, 8]}  refused: #{local_refusal(entry.name, id)}")
+        end
+      end
+      CLI::Exit::FAILED
+    end
+
+    # Why a UI-only command isn't sent: /stats points at its model-free
+    # reader (naming the session when there is one).
+    def local_refusal(name, id)
+      return "#{name} is a terminal and web command; chi send doesn't run it" unless name == "/stats"
+
+      "#{name} is a terminal and web command; use chi sessions stats #{id ? id[0, 8] : "ID"}"
+    end
+
     # --wait after a message that ran as a session command: no reply comes
     # for it. Its output shows where the session is open.
     # @return [Integer] 0
@@ -466,7 +540,11 @@ module Samagotchi
       owner = SessionManager.session_owner(id, state_dir: @state_dir)
       running = owner && session.status == Session::STATUS_RUNNING
       refs = copy_images(Session.session_dir(id, state_dir: @state_dir))
-      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir)
+      # --cut asks the running turn for a cut; to an idle session it is an
+      # ordinary message (there is nothing to cut).
+      delivery = @cut && running ? Delivery::CUT : nil
+      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir,
+                                               delivery: delivery)
       unless result[:status] == :accepted
         @info.puts("#{short}  failed: #{result.dig(:ack, "detail") || "could not queue it"}")
         return false
@@ -478,12 +556,12 @@ module Samagotchi
         return true
       end
 
-      # A busy worker runs a message with images as its own next turn
-      # rather than merging it into the running one.
-      note = if owner.nil? then " (started its worker)"
-             elsif running then refs.empty? ? " (the running turn picks it up)" : " (runs after the current turn)"
-             end
-      @info.puts("#{short}  sent#{with_images}#{note}")
+      ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      # What the worker applied, for --format json: its ack's delivery
+      # (next_step for an idle session) and a cut's outcome.
+      @sent_delivery = ack["delivery"] || delivery
+      @sent_cut = ack["cut"]
+      @info.puts("#{short}  sent#{with_images}#{delivery_note(ack, delivery: delivery, running: running, owner: owner)}")
       true
     rescue SessionManager::OwnedByTUI
       @info.puts("#{short}  refused: it is open in a chi REPL; messages need attached mode")
@@ -493,6 +571,42 @@ module Samagotchi
       false
     end
 
+    # What the line says became of the message: a plain one goes in at the
+    # running turn's next step (nothing cuts by default); a --cut one names
+    # the outcome from the ack (now, waits, off); images keep their own
+    # wording; an idle session's turn simply runs.
+    # @param ack [Hash] the Bridge's 202 body ({} for the input file)
+    # @return [String] "" or " (...)"
+    def delivery_note(ack, delivery:, running:, owner:)
+      return " (started its worker)" if owner.nil?
+      return "" unless running
+
+      # A busy worker runs a message with images as its own next turn
+      # rather than merging it into the running one.
+      return " (runs after the current turn)" unless @images.empty?
+
+      case (Delivery.cut?(delivery) ? ack["cut"].to_s : "")
+      when "now" then " (cut in now)"
+      when "waits" then " (cuts in once the thinking passes #{Config.get("steer.cut_after").to_i} s)"
+      when "off" then " (cutting is off; goes in at the next step)"
+      # No outcome: a plain message, or the input file (the Bridge went
+      # away), which the next step's drain takes.
+      else " (goes in at the running turn's next step)"
+      end
+    end
+
+    # More keys for --format json, with --cut only (the line is unchanged
+    # otherwise): the delivery the worker applied (next_step to an idle
+    # session) and a cut's outcome (now, waits, off). In P1 --cut --wait is
+    # refused for a running turn, so the json line says next_step.
+    def report_extra
+      return {} unless @cut
+
+      extra = { delivery: @sent_delivery || Delivery::NEXT_STEP }
+      extra[:cut] = @sent_cut if @sent_cut
+      extra
+    end
+
     # What to say when +model_name+ is known not to take images, or nil
     # (it does, or it is unknown: sent as before). Asked once per model.
     def vision_refusal(model_name, typed: nil)

data/lib/samagotchi/session_commands.rb

@@ -71,8 +71,7 @@ module Samagotchi
         continue_answer(answer.empty? ? CONTINUE_COMMAND : answer)
       end
       # It reads the hosts only (the registry is mutex-guarded): mid-turn too.
-      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)",
-                        mid_turn: ->(_text) { :anytime }) do |text|
+      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)", anytime: true) do |text|
         reply(models_listing(text.delete_prefix(MODELS_COMMAND).strip))
       end
       registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)",
@@ -101,6 +100,15 @@ module Samagotchi
       # The REPL owns its session: it answers /detach with a note, and doesn't offer it.
       registry.register("/detach", "leave and keep the worker running", local: true, uis: [:attached],
                                                                         match: ->(text) { text.casecmp?("/detach") })
+      # /cut TEXT and /queue TEXT while a turn runs: a delivery the UIs parse
+      # themselves (Formatting#steer_choice) before any command check; the
+      # entries exist for Tab completion and /help. /queue is a real
+      # after-the-turn list only in the local REPL (the attached TUI's
+      # worker doesn't skip queued files yet), so it is offered there.
+      registry.register("/cut", "cut the running generation and go in now (/cut TEXT)",
+                        local: true, match: ->(text) { text.casecmp?("/cut") || text.match?(%r{\A/cut\s+\S}) })
+      registry.register("/queue", "run as the next turn after this one (/queue TEXT)",
+                        local: true, uis: [:repl], match: ->(text) { text.casecmp?("/queue") || text.match?(%r{\A/queue\s+\S}) })
       registry
     end
 

data/lib/samagotchi/session_inbox.rb

@@ -5,6 +5,7 @@ require "json"
 require "time"
 require "securerandom"
 require_relative "atomic_file"
+require_relative "delivery"
 require_relative "session"
 
 module Samagotchi
@@ -34,12 +35,18 @@ module Samagotchi
     class NoteRejected < ArgumentError; end
 
     # Queue a turn's input file: JSON with the prompt and the sender's ids.
+    # +delivery+ is only written when it is "queue": a step-boundary
+    # message is the default an older worker assumes, and a cut is done by
+    # the sender (the Bridge) at once, not by the file.
     # @param client_id [String, nil] the sending UI
     # @param enqueued_id [String, nil] the id its ACK / :turn_enqueued carry
+    # @param delivery [String, nil] the wire value: "next_step" (default),
+    #   "cut" or "queue"
     # @param images [Array<Hash>] image refs ({file:, name:}) in the
     #   session's images/
     # @return [String, false] the input file's path, or false
-    def self.write_input(session_dir, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [])
+    def self.write_input(session_dir, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [],
+                         delivery: nil)
       images = Array(images)
       input_dir = File.join(session_dir, INPUT_DIR)
       FileUtils.mkdir_p(input_dir)
@@ -47,6 +54,7 @@ module Samagotchi
       path = File.join(input_dir, "#{Time.now.strftime("%Y%m%d%H%M%S%9N")}.json")
       record = { "prompt" => prompt.to_s, "client_id" => client_id, "enqueued_id" => enqueued_id,
                  "no_interrupt" => (no_interrupt ? true : nil),
+                 "delivery" => (Delivery.queue?(delivery) ? Delivery::QUEUE : nil),
                  "images" => (images.empty? ? nil : images.map { |image| image.transform_keys(&:to_s) }) }.compact
       AtomicFile.write(path, JSON.generate(record))
       path
@@ -175,17 +183,20 @@ module Samagotchi
       Dir.glob(File.join(input_dir, "*.json"))
     end
 
-    # @return [Array(String, Hash|nil, Boolean, Array<Hash>)] a claimed input
-    #   file's prompt, origin ({client_id:, enqueued_id:}, nil when it names
-    #   no sender), whether its turn runs with the raised iteration limit
-    #   (--no-interrupt), and its image refs ({file:, name:})
+    # @return [Array(String, Hash|nil, Boolean, Array<Hash>, String|nil)] a
+    #   claimed input file's prompt, origin ({client_id:, enqueued_id:},
+    #   nil when it names no sender), whether its turn runs with the raised
+    #   iteration limit (--no-interrupt), its image refs ({file:, name:}),
+    #   and its delivery ("queue" or nil; a file without the key is one an
+    #   older chi wrote, so nil)
     def self.read_input(claimed_file)
       data = JSON.parse(File.read(claimed_file).to_s)
       origin = { client_id: data["client_id"], enqueued_id: data["enqueued_id"] }.compact
       images = Array(data["images"]).select { |image| image.is_a?(Hash) }.map { |image| image.transform_keys(&:to_sym) }
-      [data["prompt"].to_s, origin.empty? ? nil : origin, data["no_interrupt"] == true, images]
+      [data["prompt"].to_s, origin.empty? ? nil : origin, data["no_interrupt"] == true, images,
+       Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil]
     rescue JSON::ParserError
-      [nil, nil, false, []]
+      [nil, nil, false, [], nil]
     end
 
     # Whether an unclaimed input file carries images (a mid-turn drain
@@ -197,6 +208,15 @@ module Samagotchi
       false
     end
 
+    # Whether a mid-turn drain leaves this unclaimed input file for a turn
+    # of its own instead of merging it at a step boundary. Today that is an
+    # image message (steering merges text only); the drain's file filter
+    # reads this one predicate, so what a boundary refuses changes in one
+    # place.
+    def self.waits_for_turn_end?(input_file)
+      input_has_images?(input_file)
+    end
+
     def self.claim_input_file(input_file)
       processing_path = "#{input_file}.processing"
       File.rename(input_file, processing_path)

data/lib/samagotchi/session_manager.rb

@@ -8,6 +8,7 @@ require "rbconfig"
 require_relative "client_id"
 require_relative "atomic_file"
 require_relative "config"
+require_relative "delivery"
 
 require_relative "session"
 require_relative "session_inbox"
@@ -1288,14 +1289,16 @@ module Samagotchi
     # boundary. The file is JSON carrying the sender's ids.
     # @param client_id [String, nil] the sending UI
     # @param enqueued_id [String, nil] the id its ACK / :turn_enqueued carry
+    # @param delivery [String, nil] the wire value: "next_step" (default),
+    #   "cut" or "queue"
     # @param images [Array<Hash>] image refs ({file:, name:}) in the
     #   session's images/
     # @return [String, false] the input file's path, or false.
     def self.write_turn_input(session_id, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, state_dir: nil,
-                              images: [])
+                              images: [], delivery: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       SessionInbox.write_input(session_dir, prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
-                                            no_interrupt: no_interrupt, images: images)
+                                            no_interrupt: no_interrupt, images: images, delivery: delivery)
     end
 
     # How long a turn waits for the Bridge of a worker a resume just spawned.
@@ -1308,6 +1311,8 @@ module Samagotchi
     # exit). Race-safe against a TUI taking the session, or the worker
     # exiting, between the resume and the write.
     # @param images [Array<Hash>] refs ({file:, name:}) already in images/
+    # @param delivery [String, nil] what the message asks the running turn
+    #   for: "next_step" (default), "cut" or "queue"
     # @param manager [#resume_session, #write_turn_input] this class, or a
     #   stand-in (the web's specs); #session_owner is optional
     # @param bridge [#call, nil] returns the BridgeClient or nil; defaults to
@@ -1319,7 +1324,8 @@ module Samagotchi
     #   {status: :failed} when the input file couldn't be written
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
-    def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], state_dir: nil, manager: self, bridge: nil)
+    def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, state_dir: nil, manager: self,
+                          bridge: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir)
@@ -1327,6 +1333,9 @@ module Samagotchi
         begin
           options = { prompt: prompt, client_id: client_id }
           options[:images] = images unless images.empty?
+          # An old worker ignores the field: it cuts anyway (its own default)
+          # and its file never carries a queue, so a queue would steer there.
+          options[:delivery] = delivery unless Delivery.next_step?(delivery)
           reply = client.post_turn(**options)
           ack = reply.json
           return { status: :accepted, ack: ack } if reply.status == 202 && ack.is_a?(Hash)
@@ -1347,6 +1356,7 @@ module Samagotchi
       enqueued_id = SecureRandom.uuid
       input = { prompt: prompt, client_id: client_id, enqueued_id: enqueued_id, state_dir: state_dir }
       input[:images] = images unless images.empty?
+      input[:delivery] = delivery unless Delivery.next_step?(delivery)
       path = manager.write_turn_input(session_id, **input)
       return { status: :failed } unless path
 

data/lib/samagotchi/session_metrics.rb

@@ -141,6 +141,9 @@ module Samagotchi
       :cuts,
       :capped,
       :model,
+      # The turn the user started by answering the step-limit question with
+      # Continue (:turn_started's +continue+); its record carries it.
+      :continue,
       :id,
       :started_at,
       :started_monotonic,
@@ -376,6 +379,16 @@ module Samagotchi
       @mutex.synchronize { build_snapshot(:recent) }
     end
 
+    # The snapshot of a session no worker runs, read from disk (`chi
+    # sessions stats`): #snapshot's, but its records are the newest saved
+    # turn's (and its tool calls), as a live worker's snapshot carries its
+    # newest finished turn; #snapshot would list none, this collector having
+    # finished no turn of its own.
+    # @return [Hash]
+    def saved_snapshot
+      @mutex.synchronize { build_snapshot(:last) }
+    end
+
     # Close the open generation now, ahead of its :generation_completed
     # (which then finds it closed), and report its speed with the session's
     # running token totals: what the event carries to the UIs.
@@ -438,6 +451,9 @@ module Samagotchi
         served_model_for: @served_model_for,
         tool_calls_total: @tool_records.size + in_flight.size,
         tool_calls_by_tool: tally_into(totals[:by_tool].dup, in_flight),
+        # The calls the model made under an alias's name (bash run as
+        # execute), by its own spelling; only when there are any.
+        **(totals[:aliased].empty? ? {} : { tool_calls_aliased: totals[:aliased].dup }),
         tool_errors: totals[:tool_errors],
         iterations_total: totals[:iterations] + (turn&.iteration_count || 0),
         gen_latency_ms: (totals[:gen_ms] + (turn&.gen_latency_accum || 0)).round,
@@ -483,14 +499,16 @@ module Samagotchi
 
     # The records a snapshot carries, copied. :all is every record; :recent
     # the newest turn this collector finished (live before its save lands)
-    # and the unsaved ones (capped), and the tool records of those turns and
-    # of the running one. Records are appended in turn order, so both come
-    # from the tails. Caller holds the mutex.
+    # and the unsaved ones (capped); :last the newest turn, loaded or not;
+    # and the tool records of those turns and of the running one. Records
+    # are appended in turn order, so both come from the tails. Caller holds
+    # the mutex.
     def records_view(mode)
       return { turn_records: @turn_records.map(&:dup), tool_records: @tool_records.map(&:dup) } if mode == :all
 
       unsaved = @turn_records.size - @persisted_turns
-      count = unsaved.clamp(@turn_records.size > @loaded_turns ? 1 : 0, LIVE_RECORDS_CAP)
+      fresh = @turn_records.size > @loaded_turns ? 1 : 0
+      count = mode == :last ? 1 : unsaved.clamp(fresh, LIVE_RECORDS_CAP)
       turns = @turn_records.last(count)
       ids = turns.to_set { |record| record[:id] }
       ids << @turn.id if @turn
@@ -539,6 +557,7 @@ module Samagotchi
           cuts: 0,
           capped: 0,
           model: nil,
+          continue: event[:continue] ? true : false,
           id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
@@ -575,6 +594,9 @@ module Samagotchi
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
           record[:cancelled_by] = by.to_s unless by.nil? || by.to_s.empty?
           record[:failure] = failure if failure
+          # Every record says, so the report can tell a file with no Continue
+          # from one written before the mark.
+          record[:continue] = @turn.continue
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)
@@ -800,6 +822,8 @@ module Samagotchi
         active = @turn.tool_calls_by_id.delete(key)
         return unless active
 
+        called_as = event.dig(:activity, :called_as)
+        active[:called_as] = called_as.to_s if called_as
         finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
       end
     end
@@ -807,7 +831,7 @@ module Samagotchi
     # Caller holds the mutex.
     def finish_tool_record(active, status, waited_ms: 0)
       record = active.slice(
-        :id, :turn_id, :iteration, :call_index, :tool, :started_at
+        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :started_at
       ).merge(
         status: status,
         completed_at: now.iso8601(3),
@@ -1013,7 +1037,7 @@ module Samagotchi
     # (#snapshot adds the running turn). Caller holds the mutex.
     def reset_totals
       @totals = { cancellations: 0, prompt_sum: 0, completion_sum: 0, token_sources: [], iterations: 0,
-                  gen_ms: 0, retries: 0, cuts: 0, capped: 0, by_tool: {}, tool_errors: 0, cached_sum: 0, cache_write_sum: 0,
+                  gen_ms: 0, retries: 0, cuts: 0, capped: 0, by_tool: {}, aliased: {}, tool_errors: 0, cached_sum: 0, cache_write_sum: 0,
                   reprefill_sum: 0, reasoning_sum: 0,
                   cost_sum: 0, cost_estimate_sum: 0, decode_ms_sum: 0, decode_tokens_sum: 0, last_decode_tps: nil,
                   last_prefill_tps: nil, tps_source: nil }
@@ -1050,6 +1074,8 @@ module Samagotchi
     def count_tool(record)
       @totals[:tool_errors] += 1 if record[:status] == "error"
       tally_into(@totals[:by_tool], [record])
+      called_as = record[:called_as].to_s
+      @totals[:aliased][called_as] = @totals[:aliased].fetch(called_as, 0) + 1 unless called_as.empty?
     end
 
     def tally_into(counts, tools)