samagotchi 0.50.0 → 0.51.0

data/lib/samagotchi/send_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "client_id"
+require_relative "delivery"
 require_relative "session"
 require_relative "session_commands"
 require_relative "session_inbox"
@@ -34,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
@@ -75,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
@@ -82,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
@@ -101,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
@@ -160,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?
@@ -527,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
@@ -539,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")
@@ -554,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

@@ -100,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

@@ -379,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.
@@ -441,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,
@@ -486,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
@@ -807,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
@@ -814,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),
@@ -1020,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 }
@@ -1057,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)

data/lib/samagotchi/sessions_command.rb

@@ -339,7 +339,7 @@ module Samagotchi
       end
       return [nil, false, nil] unless File.file?(File.join(dir, "analytics.json"))
 
-      snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.snapshot
+      snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.saved_snapshot
       note = live_worker?(session.id) ? "(no live worker answered; from the saved analytics.json)" : nil
       [snapshot, false, note]
     end

data/lib/samagotchi/steer_cut.rb

@@ -44,21 +44,25 @@ module Samagotchi
     # Call it after the message is queued, with the #input_epoch read
     # before queueing it. Outside any lock; a cut that lands just after the
     # generation ended is harmless (the loop re-asks).
-    # @return [Boolean] whether a generation was cut now
+    # @return [Symbol] :now (a generation was cut now), :waits (the message
+    #   waits for the thinking to pass steer.cut_after), or :off (cutting
+    #   off for this source: a plugin, no turn, cut_after 0, a generation
+    #   that isn't thinking-only, or a drain already took the message)
     def cut_for_steer(source, epoch: nil)
-      return false unless Steer.cuts?(source)
+      return :off unless Steer.cuts?(source)
 
       after = Config.get("steer.cut_after").to_i
-      return false unless after.positive?
+      return :off unless after.positive?
 
       ctrl = @controller.call
-      return false unless ctrl
-      return cut!(ctrl, source.to_s) if @phase.cuttable?(after)
+      return :off unless ctrl
+      return cut!(ctrl, source.to_s) ? :now : :off if @phase.cuttable?(after)
 
-      Log.info(:turn, "steer_cut_waits", source: source.to_s) if @waiting.wait!(source, epoch: epoch)
-      false
+      waited = @waiting.wait!(source, epoch: epoch)
+      Log.info(:turn, "steer_cut_waits", source: source.to_s) if waited
+      waited ? :waits : :off
     rescue StandardError
-      false
+      :off
     end
 
     # The drains that took input so far (WaitingSteer#epoch): read it before

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -14,6 +14,7 @@ require_relative "reline_seam"
 require_relative "version_lines"
 require_relative "../bridge/turn_accumulator"
 require_relative "../bridge_client"
+require_relative "../delivery"
 require_relative "../log"
 require_relative "../context_note"
 require_relative "../steer"
@@ -380,6 +381,14 @@ module Samagotchi
           return answer_question(text)
         end
 
+        # /cut TEXT and /queue TEXT are this UI's own deliveries, read before
+        # every command check (SessionCommands registers them for Tab and
+        # /help only). A plain line sends no delivery: it goes in at the
+        # running turn's next step, and never cuts.
+        if (choice = steer_choice(text))
+          return submit_delivery(*choice)
+        end
+
         # The terminal's own commands (SessionCommands registers them, the
         # REPL reads the same words). Before the continue offer: the
         # leaving ones are no answer to it.
@@ -414,6 +423,20 @@ module Samagotchi
         nil
       end
 
+      # /cut TEXT and /queue TEXT while a turn runs. Only /cut goes in P1:
+      # the worker's drain doesn't skip queued files yet, so a queued
+      # message would steer the running turn; /queue says so and sends
+      # nothing. At the prompt both run the text as a normal turn.
+      # @return [nil]
+      def submit_delivery(choice, text)
+        return @screen.commit(STEER_CHOICE_USAGE) if text.empty?
+        return @screen.commit(QUEUE_UNAVAILABLE) if choice == :queue
+
+        # To an idle session it is an ordinary prompt: no delivery to send.
+        send_prompt(text, delivery: @running ? Delivery::CUT : nil)
+        nil
+      end
+
       # @return [Symbol] :detach
       def detach(line)
         @view.finish_thinking_spinner
@@ -573,6 +596,9 @@ module Samagotchi
       end
 
       QUEUED_NOTE = "(queued: runs after this turn)"
+      # /queue needs a worker whose drain skips queued input files (P3):
+      # until then a queued message would steer the running turn.
+      QUEUE_UNAVAILABLE = "(/queue isn't available in an attached session yet)"
 
       # A command queued for after the running turn (command_queued with
       # waits): its line now (another client's) and a note; its command_ran
@@ -661,19 +687,40 @@ module Samagotchi
         end
       end
 
-      def send_prompt(text)
+      # What a prompt's 202 says became of it, or nil when there is nothing
+      # to say: the dim line both TUIs print for a delivery. A plain line
+      # for a running turn goes in at its next step; a cut's outcome comes
+      # from the ack (the worker knows whether cutting is on for its model).
+      # An idle session's prompt simply runs, and a prompt with images runs
+      # as its own next turn (never merging mid-turn), so nothing is said.
+      # @param ack [Hash, nil] the Bridge's 202 body
+      # @param delivery [String, nil] what was asked for
+      # @return [String, nil]
+      def sent_note(ack, delivery: nil, images: [], running: false)
+        return nil unless running && images.empty? && ack.is_a?(Hash)
+
+        return NEXT_STEP_NOTE unless delivery == Delivery::CUT
+
+        steer_cut_note(ack["cut"].to_s.to_sym)
+      end
+
+      def send_prompt(text, delivery: nil)
         persist_recent_history(text)
         images = attach_images(text)
         return own_prompt_failed if images.nil?
 
+        running = @running
         options = { prompt: text, client_id: @client_id }
         options[:no_interrupt] = true if @no_interrupt
         options[:images] = images unless images.empty?
+        options[:delivery] = delivery if delivery
         reply = @client.post_turn(**options)
         if reply.status == 202
           enqueued_id = reply.json&.fetch("enqueued_id", nil)
           @sent_ids << enqueued_id if enqueued_id
           @open_ids << enqueued_id if enqueued_id && @wait_at_eof
+          note = sent_note(reply.json, delivery: delivery, images: images, running: running)
+          @screen.commit(note) if note
           return
         end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -31,13 +31,17 @@ module Samagotchi
 
       # What a tool line says the call did: the model's description of a
       # command (": List the specs") in place of its cut params, else the
-      # params, dim.
+      # params, dim; then, dim, the name the model called it by when that was
+      # an alias's (" (called as bash)").
       def tool_params_suffix(activity)
         description = activity[:description].to_s.strip
-        return ": #{description}" unless description.empty?
-
         params = activity[:params].to_s.strip
-        params.empty? ? "" : " #{paint(params, 90)}"
+        suffix = if !description.empty? then ": #{description}"
+                 elsif !params.empty? then " #{paint(params, 90)}"
+                 else ""
+                 end
+        called_as = activity[:called_as].to_s
+        called_as.empty? ? suffix : "#{suffix}#{paint(" (called as #{called_as})", 90)}"
       end
 
       # Green ok, yellow stopped (a wait the user's Stop ended), red the rest.
@@ -91,6 +95,45 @@ module Samagotchi
         paint("↪ cut in for #{STEER_CUT_FOR.fetch(event[:source].to_s, "your message")}", 90)
       end
 
+      # What a line submitted at the open prompt says became of it: a plain
+      # line goes in at the running turn's next step boundary (nothing cuts
+      # unless the message asked for it), /cut's cutting now or once the
+      # thinking passes steer.cut_after, and /queue's waiting for the end.
+      # Both TUIs print the same words (SteerCut#cut_for_steer's answer).
+      NEXT_STEP_NOTE = "(goes in at the next step)"
+      CUT_NOW_NOTE = "(cut in now)"
+      CUT_WAITS_NOTE = "(cuts in once the thinking passes %d s)"
+      CUT_OFF_NOTE = "(cutting is off; goes in at the next step)"
+      STEER_CHOICE_USAGE = "(/cut and /queue need a message: /cut TEXT, /queue TEXT)"
+      # The UIs' own words for a delivery, listed for Tab and /help only
+      # (a local: entry, so no command or bundle may use the names).
+      CUT_COMMAND = "/cut"
+      QUEUE_COMMAND = "/queue"
+      # The word, then any whitespace and the text (as the registry's
+      # entries match them, so a line Tab or /help knows is never a prompt).
+      STEER_CHOICE = /\A(#{CUT_COMMAND}|#{QUEUE_COMMAND})(?:\s+(.*))?\z/m
+
+      # @param outcome [Symbol] SteerCut#cut_for_steer's answer: :now, :waits or :off
+      # @return [String] the dim line to show for a /cut
+      def steer_cut_note(outcome)
+        case outcome
+        when :now then CUT_NOW_NOTE
+        when :waits then format(CUT_WAITS_NOTE, Config.get("steer.cut_after").to_i)
+        else CUT_OFF_NOTE
+        end
+      end
+
+      # The choice a mid-turn line carries, as [:cut, "TEXT"] or
+      # [:queue, "TEXT"]; nil for any other line. The text is "" when the
+      # line named the choice without one.
+      # @param line [String, nil]
+      # @return [Array(Symbol, String), nil]
+      def steer_choice(line)
+        match = STEER_CHOICE.match(line.to_s.strip) or return nil
+
+        [match[1] == CUT_COMMAND ? :cut : :queue, match[2].to_s.strip]
+      end
+
       # "✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid
       # off)": a batch of LLM context edits went in (LLMContextNotice builds
       # the line; the web prints the same), dim like the retry row.
@@ -516,6 +559,10 @@ module Samagotchi
           by_tool = snapshot[:tool_calls_by_tool].sort_by { |_k, v| -v }
           lines << "  by tool:        #{by_tool.map { |k, v| "#{k}=#{v}" }.join(", ")}"
         end
+        unless snapshot[:tool_calls_aliased].to_a.empty?
+          aliased = snapshot[:tool_calls_aliased].sort_by { |_k, v| -v }
+          lines << "  called as:      #{aliased.map { |k, v| "#{k}=#{v}" }.join(", ")}"
+        end
         lines << "iterations:       #{snapshot[:iterations_total]}"
         # Summed over every request: each prompt is sent in full again.
         lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})" \