samagotchi 0.62.0 → 0.64.0

data/lib/samagotchi/session_inbox.rb

@@ -158,11 +158,39 @@ module Samagotchi
       nil
     end
 
-    def self.write_output(session_dir, response)
+    # A turn's reply: output/<timestamp>.txt, or
+    # output/<timestamp>-<enqueued_id>.txt for a turn that ran an input
+    # with an id, so a wait for that input's turn (ReplyWait's turn:) finds
+    # its own reply. The names still sort by time ("-" sorts before ".",
+    # so an id'd name and a bare one of the same timestamp keep order);
+    # every reader globs *.txt.
+    # @param enqueued_id [String, nil] the turn's input id (LastTurn#enqueued_id)
+    def self.write_output(session_dir, response, enqueued_id: nil)
       output_dir = File.join(session_dir, OUTPUT_DIR)
       FileUtils.mkdir_p(output_dir)
       timestamp = Time.now.strftime("%Y%m%d%H%M%S%9N")
-      AtomicFile.write(File.join(output_dir, "#{timestamp}.txt"), response.to_s)
+      AtomicFile.write(File.join(output_dir, "#{output_name(timestamp, enqueued_id)}.txt"), response.to_s)
+    end
+
+    # An id that is safe in a file name (a Bridge's or deliver_turn's
+    # uuid); anything else leaves the name bare.
+    ENQUEUED_ID_NAME = /\A[A-Za-z0-9_-]{1,64}\z/
+
+    def self.output_name(timestamp, enqueued_id)
+      id = enqueued_id.to_s
+      ENQUEUED_ID_NAME.match?(id) ? "#{timestamp}-#{id}" : timestamp
+    end
+    private_class_method :output_name
+
+    # @return [String, nil] the reply filename of the turn that ran the
+    #   input +enqueued_id+, or nil while it has none
+    def self.reply_for(session_dir, enqueued_id)
+      dir = File.join(session_dir, OUTPUT_DIR)
+      id = enqueued_id.to_s
+      return nil if id.empty? || !Dir.exist?(dir)
+
+      suffix = "-#{id}.txt"
+      Dir.children(dir).select { |f| f.end_with?(suffix) }.max
     end
 
     # The output files' text, oldest first; with +since_time+ only files
@@ -218,12 +246,40 @@ module Samagotchi
     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.
+    # of its own instead of merging it at a step boundary: a queued message
+    # (`delivery: queue`) or an image message (steering merges text only).
+    # The drain skips such a file without stopping at it, so a later text
+    # line still merges; the drain's file filter reads this one predicate,
+    # so what a boundary leaves changes in one place.
     def self.waits_for_turn_end?(input_file)
-      input_has_images?(input_file)
+      data = JSON.parse(File.read(input_file))
+      data.is_a?(Hash) && (Array(data["images"]).any? || Delivery.queue?(data["delivery"]))
+    rescue JSON::ParserError, SystemCallError
+      false
+    end
+
+    # Whether an input file carrying +enqueued_id+ still waits unclaimed in
+    # input/ (no worker has taken it for a turn or a step yet).
+    def self.input_waiting?(session_dir, enqueued_id) = !waiting_input(session_dir, enqueued_id).nil?
+
+    # How the unclaimed input file carrying +enqueued_id+ waits: :turn_end
+    # (a queue or an image message: it runs as a turn of its own, never
+    # merged, #waits_for_turn_end?), :merges (a running turn's drain may
+    # take it as a steer), or nil when none waits.
+    # @return [Symbol, nil]
+    def self.waiting_input(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      return nil if id.empty?
+
+      find_new_input_files(session_dir).each do |file|
+        data = JSON.parse(File.read(file))
+        next unless data.is_a?(Hash) && data["enqueued_id"] == id
+
+        return Array(data["images"]).any? || Delivery.queue?(data["delivery"]) ? :turn_end : :merges
+      rescue JSON::ParserError, SystemCallError
+        next
+      end
+      nil
     end
 
     def self.claim_input_file(input_file)

data/lib/samagotchi/session_manager.rb

@@ -205,8 +205,9 @@ module Samagotchi
     # child inherits this process's ENV and reads config.yml itself (as it
     # is when the worker starts); opts[:env] adds to it (merged, not
     # replaced) what it can't read there: this `chi`'s CLI settings
-    # (Config.cli_env), the hosts and the absolute log file. It unsets
-    # SAMAGOTCHI_GUARDRAILS_* and the session markers (SESSION_MARKER_ENV).
+    # (Config.cli_env) and the absolute log file. It unsets
+    # SAMAGOTCHI_GUARDRAILS_*, the session markers (SESSION_MARKER_ENV) and
+    # SAMAGOTCHI_HOSTS_JSON (HOSTS_JSON_ENV).
     # XDG_CONFIG_HOME passes: whoever starts or
     # wakes the worker picks which config.yml it reads (docs/guardrails.md).
     private_class_method def self.spawn_options(session)
@@ -223,14 +224,12 @@ module Samagotchi
         Log.warn(:worker, "cwd_gone", sid: session.id, dir: dir, cwd: Dir.pwd)
       end
       child_env = {}
-      # Propagate hosts config for multi-host routing
-      begin
-        require_relative "config"
-        hosts_json = ConfigFile.hosts_json_for_env
-        child_env["SAMAGOTCHI_HOSTS_JSON"] = hosts_json if hosts_json && !hosts_json.strip.empty?
-      rescue StandardError
-        nil
-      end
+      # The worker reads config.yml's hosts: as it starts, like every other
+      # setting: a host added or changed after this process (a parent
+      # worker, `chi web`) started reaches it. Unset, not just left out: a
+      # worker an older chi started still has one, and its delegates would
+      # inherit its start-time hosts.
+      child_env[HOSTS_JSON_ENV] = nil
       # A worker gets no CLI args: --model, --thinking, --log-level and the
       # other flags this chi was started with.
       child_env.merge!(Config.cli_env)
@@ -694,7 +693,7 @@ module Samagotchi
     # so a resume right after spawns a fresh worker instead of finding the
     # dying one.
     # A turn still running is canceled first (STOP_CANCEL_WAIT), as the
-    # web's Cancel does: its worker saves it. The TERM stops (and saves)
+    # web's Cancel does, with reason STOP_CANCEL_REASON: its worker saves it. The TERM stops (and saves)
     # what still runs (WorkerSignals), with a short grace after the marker.
     # @return [Boolean, nil] with +wait+: whether the owner was gone in time
     # @raise [OwnedByTUI] when the interactive TUI owns the session
@@ -714,7 +713,14 @@ module Samagotchi
       wait_for_owner_release(session_id, timeout: wait, state_dir: sd) if wait
     end
 
+    # ConfigFile.hosts_config's override of config.yml's hosts:, which no
+    # spawned worker inherits (spawn_options).
+    HOSTS_JSON_ENV = "SAMAGOTCHI_HOSTS_JSON"
+
     STOP_CANCEL_WAIT = 3.0
+    # The cancel reason of a turn a session stop cancels (Bridge::CANCEL_REASONS):
+    # not the user's Stop, which only ends the turn ("user").
+    STOP_CANCEL_REASON = "session_stopped"
 
     # Cancel the session's running turn over its Bridge and wait (up to
     # STOP_CANCEL_WAIT) for the worker to save it. Best effort: without a
@@ -723,7 +729,7 @@ module Samagotchi
       return unless Session.load(session_id, state_dir: state_dir).status == Session::STATUS_RUNNING
 
       client = BridgeClient.discover(session_id, session_dir: Session.session_dir(session_id, state_dir: state_dir))
-      return unless client && client.cancel(reason: "user").status == 202
+      return unless client && client.cancel(reason: STOP_CANCEL_REASON).status == 202
 
       BridgeClient.poll(STOP_CANCEL_WAIT) do
         Session.load(session_id, state_dir: state_dir).status != Session::STATUS_RUNNING
@@ -1167,9 +1173,12 @@ module Samagotchi
     #   the session's sidecar, waiting TURN_BRIDGE_WAIT for a new worker's
     # @return [Hash] {status: :accepted, ack: Hash} (the Bridge's reply, or
     #   {status:, enqueued_id:, session_id:} for a file), {status: :refused,
-    #   code:, ack:} when the Bridge refused the images, {status: :timeout,
-    #   ack:} when it took the request but never answered (no file then), or
-    #   {status: :failed} when the input file couldn't be written
+    #   code:, ack:} when the Bridge refused the request (any 4xx with an
+    #   error: bad images, a delivery it doesn't run) or a queue would reach
+    #   a worker that doesn't queue (no file then: it would steer),
+    #   {status: :timeout, ack:} when it took the request but never answered
+    #   (no file then), or {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: [], delivery: nil, state_dir: nil, manager: self,
@@ -1178,20 +1187,28 @@ module Samagotchi
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir)
       if (client = bridge.call)
+        # A worker from before queueing (no "delivery" feature) ignores the
+        # field or refuses it; either way a file would steer the running turn.
+        return queue_unavailable if Delivery.queue?(delivery) && !worker_queues?(session_dir)
+
         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.
+          # An old worker ignores the field: it cuts anyway (its own default).
           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)
-          if ack.is_a?(Hash) && ack["error"] == "bad_images"
-            return { status: :refused, code: reply.status, ack: ack }
-          end
           # Read after its deadline and dropped: a file would run it after all.
           return turn_timeout if ack.is_a?(Hash) && ack["error"] == "deadline_passed"
+          # Any other 4xx with an error is a refusal (bad images, a delivery
+          # it doesn't run, a client bug): a file would bypass it, and a
+          # refused queue would steer. A 413 (a body over the Bridge's
+          # limit, a big piped chi send) and a 5xx keep the file fallback
+          # below, which carries the delivery (a queue too).
+          if (400..499).cover?(reply.status) && reply.status != 413 && ack.is_a?(Hash) && ack["error"]
+            return { status: :refused, code: reply.status, ack: ack }
+          end
         rescue Errno::ETIMEDOUT
           # The Bridge drops a turn it reads after the request's deadline
           # (BridgeClient#post_turn), so a worker that wakes later won't run
@@ -1222,6 +1239,18 @@ module Samagotchi
       { status: :accepted, ack: { status: "accepted", enqueued_id: enqueued_id, session_id: session_id } }
     end
 
+    # Whether the session's live worker runs delivery: queue (its sidecar
+    # names the feature). No sidecar to read (the client came from a stand-in,
+    # or it went between the wait and here): true, the post finds out.
+    private_class_method def self.worker_queues?(session_dir)
+      sidecar = WorkerSidecar.read(session_dir)
+      sidecar.nil? || sidecar.features.include?(Delivery::QUEUE_FEATURE)
+    end
+
+    private_class_method def self.queue_unavailable
+      { status: :refused, code: 409, ack: Delivery::QUEUE_UNAVAILABLE }
+    end
+
     private_class_method def self.turn_timeout
       { status: :timeout, ack: { "error" => "worker_timeout",
                                  "detail" => "the session's worker did not answer, so the message was not sent" } }

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -46,12 +46,15 @@ module Samagotchi
       # @param thinking [String, nil] --thinking as typed: a new session
       #   starts with it as its own level; a resumed or attached one's
       #   worker gets a /thinking, after those
+      # @param state_dir [String, nil] where the sessions are (the default
+      #   state dir by default): the worker's, for the attached loop too
       # @return [Symbol] :detached, :closed when the worker went away,
       #   :failed when the --model switch didn't go through, or (input from a
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
-              memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [])
-        client = connect(attach: attach, shared: shared, resume: resume, model: model,
+              memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], state_dir: nil)
+        state_dir ||= Session.default_state_dir
+        client = connect(attach: attach, shared: shared, resume: resume, model: model, state_dir: state_dir,
                          memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
                          appended_prompt_files: appended_prompt_files)
         commands = []
@@ -65,7 +68,7 @@ module Samagotchi
                                     first_command: first_command, no_interrupt: no_interrupt,
                                     default_input: default_input && !prompt && !attach && !resume,
                                     wait_at_eof: !$stdin.tty?,
-                                    parent_answers: Guardrails::ParentApprovals.parent_process?)
+                                    parent_answers: Guardrails::ParentApprovals.parent_process?, state_dir: state_dir)
         ended = begin
           attached.run
         ensure

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../client_id"
+require_relative "../composer_route"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "../prompt_history"
@@ -100,14 +101,18 @@ module Samagotchi
       #   (the -p one too) have had their turns; if one failed, #run says so
       # @param children_counts [#call] session id -> its delegates'
       #   ChildrenStatus::Counts, the status row's children segment
+      # @param state_dir [String] the state dir the worker was found in: its
+      #   session folder (@path images, saved records) is under it
       def initialize(client:, screen:, client_id:, first_prompt: nil, first_command: nil, no_interrupt: false,
                      default_input: false, wait_at_eof: false, parent_answers: false,
                      clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                      delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) },
                      archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) },
                      installed_version: -> { InstalledVersions.new.newest },
-                     children_counts: ->(id) { ChildrenStatus.counts(id, state_dir: Session.default_state_dir) })
+                     state_dir: Session.default_state_dir,
+                     children_counts: ->(id) { ChildrenStatus.counts(id, state_dir: state_dir) })
         @client = client
+        @state_dir = state_dir
         @installed_version = installed_version
         @delete_session = delete_session
         @archive_session = archive_session
@@ -342,7 +347,7 @@ module Samagotchi
         id = @client.session_id
         return :gone if Session.stopped_marker?(id)
 
-        BridgeClient.discover(id, session_dir: Session.session_dir(id), host: @client.host)
+        BridgeClient.discover(id, session_dir: Session.session_dir(id, state_dir: @state_dir), host: @client.host)
       end
 
       # The stream moved to a new worker (a restart): requests go there too.
@@ -383,61 +388,72 @@ module Samagotchi
         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
+        # every command check (ComposerRoute; 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.
+        route = ComposerRoute.call(text, running: @running, registry: command_registry)
+        return submit_delivery(route) if route.choice
 
         # 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.
-        local = command_registry.lookup_local(text)&.id
+        local = route.local
         return submit(nil) if local == :detach
         return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
         return archive_after_turn if local == :archive && (@running || !@queued_ids.empty?)
         return exit_and_archive if local == :archive
 
         if @continue_offer
-          return answer_continue(text) unless local || command_registry.command?(text)
+          return answer_continue(text) unless local || route.kind == :command
 
           # Not an answer: the read left no echo, so show what ran.
           echo_answer(text)
         end
-        return if text.empty?
+        return if route.kind == :empty
 
         if local == :stats
           show_stats
         elsif local == :recap
           show_recap
-        elsif command_registry.command?(text)
+        elsif route.kind == :command
           # The history keeps !cmds, as the REPL's does (prompts: #send_prompt).
           persist_recent_history(text) if PromptHistory.shell_line?(text)
           send_command(text)
-        elsif (hint = command_registry.unknown_command_hint(text))
+        elsif route.kind == :typo
           # A typo of a command (/modle) is not a prompt: say so, send nothing.
-          @screen.commit(hint)
+          @screen.commit(route.reply)
         else
           send_prompt(text)
         end
         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.
+      # /cut TEXT and /queue TEXT (+route+ has a choice). During a turn the
+      # text goes with its delivery: a cut, or queued to run as a turn of
+      # its own after this one. A worker that doesn't queue (its sidecar
+      # names no "delivery" feature) would steer a queue, so it is not sent.
+      # At the prompt both send the text as typed, a normal turn: no local
+      # word or typo check (the worker's Bridge runs a session command as
+      # the command).
+      # @param route [ComposerRoute::Route]
       # @return [nil]
-      def submit_delivery(choice, text)
-        return @screen.commit(STEER_CHOICE_USAGE) if text.empty?
-        return @screen.commit(QUEUE_UNAVAILABLE) if choice == :queue && @running
+      def submit_delivery(route)
+        return @screen.commit(STEER_CHOICE_USAGE) if route.kind == :usage
+        return @screen.commit(QUEUE_NEEDS_NEWER_WORKER) if Delivery.queue?(route.delivery) && !worker_queues?
 
         # To an idle session it is an ordinary prompt: no delivery to send.
-        send_prompt(text, delivery: @running ? Delivery::CUT : nil)
+        send_prompt(route.text, delivery: route.delivery)
         nil
       end
 
+      # Whether the attached worker runs delivery: queue (its sidecar names
+      # Delivery::QUEUE_FEATURE). No sidecar to read: true, its Bridge
+      # answers (a P0-P2 worker refuses a queue: #send_prompt).
+      def worker_queues?
+        sidecar = WorkerSidecar.read(Session.session_dir(@client.session_id, state_dir: @state_dir))
+        sidecar.nil? || sidecar.features.include?(Delivery::QUEUE_FEATURE)
+      end
+
       # @return [Symbol] :detach
       def detach(line)
         @view.finish_thinking_spinner
@@ -597,9 +613,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)"
+      QUEUE_RUNS_NOW = "(the turn had ended: runs as the next turn)"
+      # /queue to a worker from before queueing, which would steer it.
+      QUEUE_NEEDS_NEWER_WORKER = "(/queue needs a newer worker: restart it with chi sessions restart, then send again)"
 
       # A command queued for after the running turn (command_queued with
       # waits): its line now (another client's) and a note; its command_ran
@@ -683,7 +699,11 @@ module Samagotchi
                   end
         @continue_answer = nil
         @screen.commit(QuestionSlot.continue_summary(outcome, paint: method(:paint))) if outcome && !asked
-        sync_prompt
+        # Back to the > prompt: with the text a question set aside meanwhile
+        # (#close_question), else what the ? read holds.
+        set_aside = @set_aside
+        @set_aside = nil
+        set_aside ? sync_prompt(keep_text: false, prefill: set_aside) : sync_prompt
       end
 
       # The notes slot shows the offer's choices while it waits (a question
@@ -701,14 +721,20 @@ module Samagotchi
       # 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).
+      # from the ack (the worker knows whether cutting is on for its model);
+      # a queued one waits for the turn's end (the ack says queue).
       # 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 nil unless running && ack.is_a?(Hash)
+        # The Bridge acks queue only while a turn ran at enqueue; a /queue
+        # it acks next_step found the turn over: it is the next turn.
+        return QUEUED_NOTE if ack["delivery"] == Delivery::QUEUE
+        return QUEUE_RUNS_NOW if Delivery.queue?(delivery)
+        return nil unless images.empty?
 
         return NEXT_STEP_NOTE unless delivery == Delivery::CUT
 
@@ -740,6 +766,8 @@ module Samagotchi
         detail = reply.json&.fetch("error", nil)
         # Read after its deadline and dropped (BridgeClient::DEADLINE_SHARE).
         return @screen.commit("could not send the prompt (#{LATE})") if detail == "deadline_passed"
+        # A worker from 0.51 to 0.63 refuses a queue (nothing was sent).
+        return @screen.commit(QUEUE_NEEDS_NEWER_WORKER) if detail == "delivery_unavailable"
 
         @screen.commit("could not send the prompt (#{[reply.status, detail].compact.join(" ")})")
       rescue SystemCallError, IOError => e
@@ -802,7 +830,7 @@ module Samagotchi
         paths = ImageInput.extract(text)
         return [] if paths.empty?
 
-        session_dir = Session.session_dir(@client.session_id)
+        session_dir = Session.session_dir(@client.session_id, state_dir: @state_dir)
         paths.map do |image|
           ref = ImageStore.ingest(session_dir, path: image[:path])
           { file: ref[:file], name: ref[:name] }
@@ -865,7 +893,9 @@ module Samagotchi
 
         @view.finish_thinking_spinner
         # What was typed at the prompt waits for the question to close.
-        @set_aside = @reader&.typed_text unless @question
+        # Not over text already set aside (a question that closed while a
+        # continue offer waits): the ? read holds an answer then, if anything.
+        @set_aside = @reader&.typed_text.to_s.then { |typed| typed.empty? ? nil : typed } unless @question || @set_aside
         @question = QuestionPrompt.new(pending)
         @question_pending = pending
         # The step-limit question stands for the continue offer's own slot
@@ -987,10 +1017,14 @@ module Samagotchi
         @screen.clear_slot(:notes)
         @screen.commit(@question.summary(outcome, paint: method(:paint))) if outcome
         @question = nil
+        # A continue offer still waiting keeps the ? prompt (the step-limit
+        # question closes before its offer resolves): the text set aside
+        # waits for the > prompt (#continue_resolved).
+        return sync_continue_slot if @continue_offer
+
         set_aside = @set_aside
         @set_aside = nil
         sync_prompt(keep_text: false, prefill: set_aside)
-        sync_continue_slot if @continue_offer
       end
 
       # Restart the open read when its prompt no longer fits (a question or a
@@ -1195,7 +1229,10 @@ module Samagotchi
         return unless last_user
 
         @screen.commit(join_prompt_line(exchange[last_user]))
-        Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
+        # An image-only turn's text names its images already.
+        unless ImageRef.placeholder_only?(exchange[last_user][:content])
+          Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
+        end
         from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
         failed = join_failed_record(exchange[last_user])
@@ -1244,7 +1281,7 @@ module Samagotchi
       # machine's state dir, as #attach_images): none for a prompt with no
       # turn id (an older session) or a session with no analytics.
       def join_tool_records(prompt)
-        SessionMetrics.saved_tool_records(Session.session_dir(@client.session_id), prompt[:turn_id] || prompt["turn_id"])
+        SessionMetrics.saved_tool_records(Session.session_dir(@client.session_id, state_dir: @state_dir), prompt[:turn_id] || prompt["turn_id"])
       rescue Session::InvalidId
         []
       end
@@ -1254,7 +1291,7 @@ module Samagotchi
       # canceled or older turn — or one saved before the failure field —
       # draws its answer as before.
       def join_failed_record(prompt)
-        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id),
+        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id, state_dir: @state_dir),
                                                   prompt[:turn_id] || prompt["turn_id"])
         return nil unless record && record["status"] == "failed" && record["failure"].is_a?(Hash)
 
@@ -1394,7 +1431,8 @@ module Samagotchi
         return if own?(event[:client_id])
 
         @shown_enqueued << event[:enqueued_id]
-        @screen.commit(prompt_line(event[:client_id], event[:prompt]))
+        line = prompt_line(event[:client_id], event[:prompt])
+        @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)
       end
 
       def start_turn(event)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -108,14 +108,8 @@ module Samagotchi
       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)"
+      # A bare /cut or /queue (ComposerRoute's :usage).
       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
       # @param after [Integer, nil] the run's cut wait (the model's own
@@ -133,17 +127,6 @@ module Samagotchi
       # The same words, for a UI that includes the module.
       def steer_cut_note(outcome, after = nil) = Formatting.steer_cut_note(outcome, after)
 
-      # 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.
@@ -363,7 +346,8 @@ module Samagotchi
 
       # A cancel's reason as the UIs name it (anything else as it is);
       # spec/shared/labels_matrix.json pins it for both.
-      CANCEL_REASONS = { "ctrl_c" => "Ctrl-C", "user" => "stopped", "hook" => "by a hook", "worker_stopped" => "worker stopped" }.freeze
+      CANCEL_REASONS = { "ctrl_c" => "Ctrl-C", "user" => "stopped", "hook" => "by a hook", "worker_stopped" => "worker stopped",
+                         "session_stopped" => "session stopped" }.freeze
       # A canceled turn's mark: a stop someone chose (Ctrl-C, Stop, a hook),
       # not an error's ✕ (timing.js STOP_MARK; the labels matrix pins it).
       STOP_MARK = "■"