samagotchi 0.84.0 → 0.86.0

data/lib/samagotchi/relay_verifier.rb

@@ -5,7 +5,6 @@ require_relative "session"
 require_relative "bridge_client"
 require_relative "worker_sidecar"
 require_relative "question_desk"
-require_relative "guardrails/parent_approvals"
 require_relative "log"
 
 module Samagotchi
@@ -24,8 +23,8 @@ module Samagotchi
     end
 
     # @return [Array(Hash, Integer, Hash)] headers, status, body: 200
-    #   answered, 409 no longer pending, 403 refused (a parent agent's allow
-    #   beyond this worker's guardrails.parent_approvals), 422
+    #   answered, 409 no longer pending, 403 refused (a parent agent's pick
+    #   beyond this worker's Guardrails::ParentPolicy), 422
     #   relay_unverified (logged; the question stays open)
     def answer(relay_id:, question_id:)
       parent_id = own_parent_id or return unverified("this session has no parent", relay_id)
@@ -59,8 +58,8 @@ module Samagotchi
       not_pending(question_id)
     rescue QuestionDesk::Refused => e
       log("relay_refused", relay_id, id: question_id, reason: e.reason)
-      [{}, 403, { error: "parent_approval_refused", reason: e.reason.to_s,
-                  detail: Guardrails::ParentApprovals.message(e.reason) }]
+      [{}, 403, { error: "parent_answer_refused", reason: e.reason.to_s,
+                  detail: e.detail }]
     rescue ArgumentError => e
       unverified("the answer doesn't fit the question: #{e.message}", relay_id)
     end

data/lib/samagotchi/reply_wait.rb

@@ -3,6 +3,7 @@
 require_relative "session"
 require_relative "turn_note"
 require_relative "session_inbox"
+require_relative "turn_checkpoint"
 require_relative "worker_sidecar"
 
 module Samagotchi
@@ -32,10 +33,13 @@ module Samagotchi
     # @!attribute question [PendingQuestion, nil] the pending question
     #   (:waiting_for_answer)
     # @!attribute outcome [String, nil] how the turn ended when it left no
-    #   reply (:no_reply): "failed", "canceled", "completed" (empty),
+    #   reply (:no_reply): "failed", "canceled", "completed" (empty turn or
+    #   file-delivered command ran without a turn),
     #   "exhausted" (it ran out of iterations, with nobody asked whether to
-    #   continue) or "not_continued" (a Stop answered the step-limit
-    #   question; no turn ran), from the session's last_turn; nil when unknown. With
+    #   continue), "not_continued" (a Stop answered the step-limit
+    #   question; no turn ran), from the session's last_turn, or "removed"
+    #   (turn:'s queued input was taken back before it ran, its tombstone:
+    #   SessionInbox.removed?; no turn ran); nil when unknown. With
     #   "failed", text is the failure's summary when the turn note has one.
     # @!attribute limit [Integer, nil] the iteration limit an "exhausted"
     #   turn ran out at
@@ -45,8 +49,9 @@ module Samagotchi
     #   retry
     # @!attribute cancel_reason [String, nil] a "canceled" turn's reason
     #   (user, hook, ctrl_c, manual, session_stopped: the session was
-    #   stopped mid-turn), passed through as the worker saved it; any
-    #   reason is a "canceled" outcome
+    #   stopped mid-turn; worker_stopped: turn:'s worker died in it and the
+    #   next one settled it, TurnCheckpoint.settled_turn), passed through
+    #   as the worker saved it; any reason is a "canceled" outcome
     # @!attribute stopped_by [String, nil] the hook that canceled it
     #   (loop-guard)
     # @!attribute session [Session, nil] the session as the look that
@@ -132,6 +137,11 @@ module Samagotchi
           claimed = waiting.nil?
         end
         session = Session.load(id, state_dir: state_dir)
+        # Taken back before it ran (POST turn/dequeue): no turn will come.
+        if turn && claimed && !seen_own && SessionInbox.removed?(session_dir, turn)
+          return Result.new(status: :no_reply, outcome: "removed", session: session)
+        end
+
         if turn && !seen_own && session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == turn
           seen_own = true
           own_base = session.last_turn&.ended_at
@@ -149,6 +159,12 @@ module Samagotchi
           reply.session = settled(session, id, state_dir: state_dir)
           return reply
         end
+        # Its worker died in it and the next one settled it, or an input
+        # command finished without a turn. After the reply check: a worker
+        # killed between writing the reply and its idle save left the reply.
+        if turn && (settled = TurnCheckpoint.settled_turn(session_dir, turn))
+          return Result.new(status: :no_reply, outcome: settled.outcome, session: session, **settled.stop_facts)
+        end
 
         case session.status
         when Session::STATUS_ERROR
@@ -307,7 +323,7 @@ module Samagotchi
 
       running = session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == id
       queued = SessionInbox.waiting_input(session_dir, id) == :turn_end
-      ended = session.last_turn&.enqueued_id == id
+      ended = session.last_turn&.enqueued_id == id || !TurnCheckpoint.settled_turn(session_dir, id).nil?
       running || queued || ended
     end
 

data/lib/samagotchi/send_command.rb

@@ -12,6 +12,9 @@ require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
 require_relative "parent_report"
+require_relative "turn_flow"
+require_relative "guardrails/parent_approvals"
+require_relative "guardrails/parent_policy"
 require_relative "image_store"
 require_relative "host_registry"
 require_relative "model_profile"
@@ -241,6 +244,14 @@ module Samagotchi
       if prompt && (local = local_command(prompt))
         return refuse_local_command(local, options)
       end
+
+      # A parent agent's /continue yes is chi answer --option Continue by
+      # another route: held to guardrails.parent_answers here, and marked
+      # as chi answer's (#client_id_for) so the worker checks it again.
+      if prompt && parent_continue?(prompt) && (refusal = Guardrails::ParentPolicy.continue_refusal)
+        @stderr.puts("chi send: #{refusal}")
+        return CLI::Exit::FAILED
+      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])
@@ -414,7 +425,8 @@ module Samagotchi
       return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
-                                 timeout: options[:timeout], report_turn_id: @sent_enqueued_id)
+                                 timeout: options[:timeout], turn: @sent_input_file ? @sent_enqueued_id : nil,
+                                 report_turn_id: @sent_enqueued_id)
     end
 
     # The model the new session will run, for the images check: --model
@@ -461,11 +473,13 @@ module Samagotchi
         # The turn waits on a question: the message would only queue
         # behind it, and the answer goes in with chi answer.
         if (waiting = session.waiting_question(live: owner.worker?))
+          # The whole question (its options, its tags) for what a parent may give.
+          question = ParentReport.question(session.pending_question)
           if ParentReport.approval?(waiting)
-            error_line("#{id[0, 8]}  waiting for an approval: #{ParentReport::DENY_AND_TELL} " \
-                       "(#{ParentReport.answer_with(id, waiting)})")
+            error_line("#{id[0, 8]}  waiting for an approval: #{ParentReport.approval_advice(question)} " \
+                       "(#{ParentReport.answer_with(id, question)})")
           else
-            error_line("#{id[0, 8]}  waiting for an answer: #{ParentReport.answer_with(id, waiting)} (or --text); " \
+            error_line("#{id[0, 8]}  waiting for an answer: #{ParentReport.answer_with(id, question)} (or --text); " \
                        "chi --attach #{id} shows it")
           end
         else
@@ -485,7 +499,9 @@ module Samagotchi
       # The ack's id names the queued message's turn, also when the turn
       # running at the check ended before it went in (an idle worker's ack
       # says next_step, and the file still runs as that turn).
-      turn = @queue ? @sent_enqueued_id : nil
+      # A file fallback has no delivery field; use its id to see terminal
+      # outcomes for commands that finish without starting a turn.
+      turn = @sent_enqueued_id if @queue || @sent_input_file
       report_turn_id = if @queue
                          turn
                        elsif session.status == Session::STATUS_RUNNING
@@ -493,7 +509,8 @@ module Samagotchi
                        else
                          @sent_enqueued_id
                        end
-      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?,
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn,
+                          queued: @queue && !turn.nil?,
                           report_turn_id: report_turn_id)
     end
 
@@ -550,7 +567,7 @@ module Samagotchi
       begin
         refs = copy_images(dir)
         if BridgeClient.wait_for(session.id, session_dir: dir, timeout: SessionManager::TURN_BRIDGE_WAIT)
-          result = SessionManager.deliver_turn(session.id, prompt: prompt, client_id: CLIENT_ID, images: refs,
+          result = SessionManager.deliver_turn(session.id, prompt: prompt, client_id: client_id_for(prompt), images: refs,
                                                            state_dir: @state_dir)
         end
       rescue StandardError => e
@@ -569,6 +586,7 @@ module Samagotchi
       end
 
       ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      @sent_input_file = !ack.key?("delivery")
       @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
       @sent_command = command_ack?(result[:ack])
       @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
@@ -581,6 +599,13 @@ module Samagotchi
     # /turn whose line is one answers with its command_id).
     def command_ack?(ack) = ack.is_a?(Hash) && !ack["command_id"].to_s.empty?
 
+    # chi send's client id, or chi answer's for a parent agent's /continue
+    # yes (the worker holds that to its guardrails.parent_answers).
+    def client_id_for(prompt) = parent_continue?(prompt) ? ClientId::CLI_ANSWER : CLIENT_ID
+
+    # A /continue yes (or bare /continue) from a parent agent's process.
+    def parent_continue?(prompt) = TurnFlow.continue_yes?(prompt) && Guardrails::ParentApprovals.parent_process?
+
     # Whether +text+ may be a session command, which only its worker knows
     # (a bundle's too).
     def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
@@ -648,7 +673,7 @@ module Samagotchi
       delivery = if @queue then Delivery::QUEUE
                  elsif @cut && running then Delivery::CUT
                  end
-      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir,
+      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: client_id_for(prompt), images: refs, state_dir: @state_dir,
                                                delivery: delivery)
       unless result[:status] == :accepted
         # A worker older than queueing would steer it: refused, not sent.
@@ -664,6 +689,7 @@ module Samagotchi
       end
 
       ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      @sent_input_file = !ack.key?("delivery")
       # 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

data/lib/samagotchi/session_commands.rb

@@ -14,6 +14,7 @@ require_relative "llm_context_command"
 require_relative "thinking_command"
 require_relative "toolkit_command"
 require_relative "reasoning_history_command"
+require_relative "guardrails/parent_policy"
 
 module Samagotchi
   # The session commands a REPL and a session worker both run: /model,
@@ -80,7 +81,7 @@ module Samagotchi
         next reply("nothing to continue") unless @turn_flow.awaiting_continue?
 
         answer = text.delete_prefix(CONTINUE_COMMAND).strip
-        continue_answer(answer.empty? ? CONTINUE_COMMAND : answer)
+        continue_answer(answer.empty? ? CONTINUE_COMMAND : answer, as_parent: @as_parent)
       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)", anytime: true) do |text|
@@ -123,13 +124,16 @@ module Samagotchi
       # /cut TEXT and /queue TEXT while a turn runs: a delivery the UIs parse
       # themselves (ComposerRoute.steer_choice) before any command check; the
       # entries exist for Tab completion and /help. The web composer sends
-      # /cut too. /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.
+      # /cut too (its queue is Alt+Enter). Both terminals queue: the REPL in
+      # its own list, the attached TUI's worker in its input files.
       registry.register("/cut", "cut the running generation and go in now (/cut TEXT)",
                         local: true, uis: %i[repl attached web], 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}) })
+                        local: true, uis: %i[repl attached], match: ->(text) { text.casecmp?("/queue") || text.match?(%r{\A/queue\s+\S}) })
+      # Takes back the newest message this attached TUI queued, before it
+      # runs (the worker's POST turn/dequeue); the web has × on the bubble.
+      registry.register("/unqueue", "remove your newest queued message before it runs", local: true, uis: [:attached],
+                                                                                          match: ->(text) { text.casecmp?("/unqueue") })
       registry
     end
 
@@ -251,8 +255,12 @@ module Samagotchi
     #   change asks first (CacheConfirm): true for a person at a web tab or
     #   a TUI; false applies it at once (chi send, a delegate, a plugin,
     #   chi -p)
+    # @param as_parent [Boolean] a parent agent sent it (client cli:answer):
+    #   a /continue yes is held to guardrails.parent_answers, as chi
+    #   answer --option Continue is (Guardrails::ParentPolicy)
     # @return [Result, nil] nil when +line+ is not one of these commands
-    def run(line, confirm: true)
+    def run(line, confirm: true, as_parent: false)
+      @as_parent = as_parent
       text = line.to_s.strip
       entry = @registry.lookup(text)
       return nil unless entry&.handler
@@ -265,9 +273,15 @@ module Samagotchi
     end
 
     # Answer the pending continue offer (yes / no / no, <reason>).
+    # @param as_parent [Boolean] a parent agent's answer: a yes its strategy
+    #   doesn't allow is refused (the offer stays; decision :invalid)
     # @return [Result] resume: true on yes
-    def continue_answer(text)
+    def continue_answer(text, as_parent: false)
       decision, reason = TurnFlow.continue_decision(text)
+      if decision == :resume && as_parent && (refusal = Guardrails::ParentPolicy.continue_refusal)
+        return reply(refusal, status: :error).tap { |result| result.decision = :invalid }
+      end
+
       result = case decision
                when :resume then Result.new(status: :ok, changed: [], model_name: model_name, resume: true, shell: false)
                when :abort

data/lib/samagotchi/session_inbox.rb

@@ -6,6 +6,7 @@ require "time"
 require "securerandom"
 require_relative "atomic_file"
 require_relative "delivery"
+require_relative "log"
 require_relative "session"
 
 module Samagotchi
@@ -276,5 +277,72 @@ module Samagotchi
     rescue Errno::ENOENT, Errno::EACCES
       nil
     end
+
+    # Where a removed queued input leaves its tombstone: input/removed/<id>,
+    # an empty file outside the *.json glob, so a wait for that input's
+    # turn (ReplyWait's turn:) learns it will never run (#removed?).
+    REMOVED_DIR = "removed"
+    # The worker's sidecar feature for POST turn/dequeue (Bridge::FEATURES).
+    UNQUEUE_FEATURE = "unqueue"
+
+    # Take back the unclaimed input file carrying +enqueued_id+ before a
+    # turn takes it (the Bridge's POST turn/dequeue, under the event log):
+    # only one that waits for the turn's end (a queue or an image message,
+    # #waits_for_turn_end?); a next-step file may be merged at any boundary.
+    # The file is claimed first, as the drain does (the rename is the race's
+    # one winner), then deleted, and its tombstone written.
+    # @return [Array(Symbol, Input)] [:removed, the input it held],
+    #   [:not_queued, nil] for a next-step file, [:claimed, nil] when a
+    #   turn took it (its *.json.processing is there), [:none, nil] for
+    #   none
+    def self.take_queued_input(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      return [:none, nil] if id.empty?
+
+      find_new_input_files(session_dir).sort.each do |file|
+        data = JSON.parse(File.read(file))
+        next unless data.is_a?(Hash) && data["enqueued_id"] == id
+        return [:not_queued, nil] unless Array(data["images"]).any? || Delivery.queue?(data["delivery"])
+
+        claimed = claim_input_file(file) or return [:claimed, nil]
+        input = read_input(claimed)
+        mark_removed(session_dir, id)
+        FileUtils.rm_f(claimed)
+        return [:removed, input]
+      rescue JSON::ParserError, SystemCallError
+        next
+      end
+      claimed_input?(session_dir, id) ? [:claimed, nil] : [:none, nil]
+    end
+
+    # Whether a claimed input file (*.json.processing: a turn's, now or
+    # left by a crash) carries +id+.
+    def self.claimed_input?(session_dir, id)
+      Dir.glob(File.join(session_dir, INPUT_DIR, "*.json.processing")).any? do |file|
+        data = JSON.parse(File.read(file))
+        data.is_a?(Hash) && data["enqueued_id"] == id
+      rescue JSON::ParserError, SystemCallError
+        false
+      end
+    end
+    private_class_method :claimed_input?
+
+    def self.mark_removed(session_dir, id)
+      return unless ENQUEUED_ID_NAME.match?(id)
+
+      dir = File.join(session_dir, INPUT_DIR, REMOVED_DIR)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, id), "")
+    rescue SystemCallError => e
+      Log.warn(:bridge, "removed_tombstone_write_failed", error: e.class.name, msg: e.message)
+    end
+    private_class_method :mark_removed
+
+    # @return [Boolean] whether the queued input +enqueued_id+ was removed
+    #   before it ran (#take_queued_input's tombstone)
+    def self.removed?(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      ENQUEUED_ID_NAME.match?(id) && File.exist?(File.join(session_dir, INPUT_DIR, REMOVED_DIR, id))
+    end
   end
 end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -77,7 +77,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?, state_dir: state_dir)
+                                    as_parent: Guardrails::ParentApprovals.parent_process?, state_dir: state_dir)
         ended = begin
           attached.run
         ensure

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -5,6 +5,7 @@ require_relative "../composer_route"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "../prompt_history"
+require_relative "../session_inbox"
 require_relative "attached_view"
 require_relative "status_row"
 require_relative "input_support"
@@ -104,7 +105,7 @@ module Samagotchi
       # @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,
+                     default_input: false, wait_at_eof: false, as_parent: 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) },
@@ -120,8 +121,8 @@ module Samagotchi
         @client_id = client_id
         # A parent agent drives this attach (AttachLauncher:
         # ParentApprovals.parent_process?): its answers go as chi answer's,
-        # so the worker holds them to guardrails.parent_approvals.
-        @parent_answers = parent_answers
+        # so the worker holds them to Guardrails::ParentPolicy.
+        @as_parent = as_parent
         @view = AttachedView.new(screen)
         @renderer = EventRenderer.new(@view)
         @shown_enqueued = Set.new
@@ -149,6 +150,10 @@ module Samagotchi
         # Prompts this run sent, by enqueued_id: only those come back into
         # the input when their turn fails (a replayed event must not).
         @sent_ids = Set.new
+        # This run's prompts queued for after the running turn (their ack
+        # said queue), oldest first, until their turn starts or they are
+        # removed: /unqueue takes back the newest.
+        @my_queued = []
         @wait_at_eof = wait_at_eof
         # Sent and not ended yet (by enqueued_id), the ones merged into the
         # running turn, whether the input has ended, and whether one of this
@@ -260,6 +265,7 @@ module Samagotchi
           take_session_state(event[:session_state_snapshot] || {})
           return render_snapshot(event[:snapshot] || {}, reset: event[:type] == :reset)
         when :turn_enqueued then show_enqueued(event)
+        when :turn_dequeued then turn_dequeued(event)
         when :turn_started
           @status.take_event(event)
           start_turn(event)
@@ -419,6 +425,8 @@ module Samagotchi
           show_stats
         elsif local == :recap
           show_recap
+        elsif local == :unqueue
+          unqueue_newest
         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)
@@ -584,7 +592,10 @@ module Samagotchi
       # The worker runs it and every UI renders its :command_ran, this one
       # too, so nothing waits here.
       def send_command(line)
-        reply = @client.post_command(line: line, client_id: @client_id)
+        # A parent agent's /continue yes goes as chi answer's: the worker
+        # holds it to guardrails.parent_answers.
+        client_id = @as_parent && TurnFlow.continue_yes?(line) ? ClientId::CLI_ANSWER : @client_id
+        reply = @client.post_command(line: line, client_id: client_id)
         if reply.status == 202
           # Input from a pipe ends once its output is in (#command_ran).
           command_id = reply.json&.fetch("command_id", nil)
@@ -620,6 +631,58 @@ module Samagotchi
       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)"
+      UNQUEUE_NEEDS_NEWER_WORKER = "(/unqueue needs a newer worker: restart it with chi sessions restart)"
+      NOTHING_QUEUED = "(nothing queued: /queue TEXT queues a message for after the running turn)"
+      UNQUEUE_REFUSED = { "already_started" => "(not removed: it already started)",
+                          "unknown_enqueued_id" => "(not removed: it is already gone)",
+                          "not_queued" => "(not removed: it goes in at the next step)" }.freeze
+
+      # /unqueue: take back the newest prompt this run queued for after the
+      # turn, before it runs (POST turn/dequeue). Its :turn_dequeued comes
+      # to every UI; here the reply says what became of it. A worker whose
+      # sidecar lacks "unqueue" is not asked.
+      def unqueue_newest
+        return @screen.commit(UNQUEUE_NEEDS_NEWER_WORKER) unless worker_unqueues?
+
+        id = @my_queued.last
+        return @screen.commit(NOTHING_QUEUED) unless id
+
+        reply = @client.dequeue(enqueued_id: id, client_id: @client_id)
+        error = reply.json&.fetch("error", nil)
+        return @screen.commit(UNQUEUE_NEEDS_NEWER_WORKER) if reply.status == 404 && error == "not_found"
+
+        # Removed, started or gone: no longer this run's to take back.
+        @my_queued.delete(id) if [200, 404, 409].include?(reply.status)
+        return unqueued(reply.json&.fetch("prompt", nil).to_s) if reply.status == 200
+
+        @screen.commit(UNQUEUE_REFUSED[error] || "could not remove the queued message (#{[reply.status, error].compact.join(" ")})")
+      rescue SystemCallError, IOError => e
+        @screen.commit("could not remove the queued message (#{worker_down(e)})")
+      end
+
+      # The removal's line, and its text back in the input to change and
+      # send again (as a failed turn's prompt comes back, #restore_prompt):
+      # not over typed text, and not for lines from a pipe. Its images are
+      # not put back.
+      def unqueued(prompt)
+        @screen.commit("removed: #{first_line_clip(prompt)}")
+        return if @wait_at_eof || prompt.strip.empty?
+
+        @screen.commit("(the removed message is in the input history: ↑)") unless @reader&.prefill(prompt)
+      end
+
+      def first_line_clip(text, max = 60)
+        line = text.to_s.strip.lines.first.to_s.strip
+        line.length > max ? "#{line[0, max]}…" : line
+      end
+
+      # Whether the attached worker takes queued messages back (its sidecar
+      # names SessionInbox::UNQUEUE_FEATURE). No sidecar to read: true, its Bridge
+      # answers (an older one's 404 not_found says so).
+      def worker_unqueues?
+        sidecar = WorkerSidecar.read(Session.session_dir(@client.session_id, state_dir: @state_dir))
+        sidecar.nil? || sidecar.features.include?(SessionInbox::UNQUEUE_FEATURE)
+      end
 
       # A command queued for after the running turn (command_queued with
       # waits): its line now (another client's) and a note; its command_ran
@@ -760,6 +823,7 @@ module Samagotchi
           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
+          @my_queued << enqueued_id if enqueued_id && reply.json&.fetch("delivery", nil) == Delivery::QUEUE
           note = sent_note(reply.json, delivery: delivery, images: images, running: running)
           @screen.commit(note) if note
           return
@@ -929,7 +993,7 @@ module Samagotchi
           return @screen.commit(answer.error)
         end
 
-        parent = @parent_answers ? { client_id: ClientId::CLI_ANSWER } : {}
+        parent = @as_parent ? { client_id: ClientId::CLI_ANSWER } : {}
         reply = @client.answer(id: @question.id, selected: answer.selected, freeform: answer.freeform, **parent)
         case reply.status
         when 200
@@ -1095,6 +1159,12 @@ module Samagotchi
 
       def render_snapshot(snapshot, reset:)
         @view.finish_thinking_spinner
+        queued = Array(snapshot[:queued])
+        known_queued = @my_queued.to_set
+        @my_queued = queued.filter_map do |entry|
+          id = entry[:enqueued_id]
+          id if id && (known_queued.include?(id) || (entry.key?(:client_id) && own?(entry[:client_id])))
+        end
         # A new worker's first snapshot is the session as it now stands.
         moved = @worker_changed
         reset ||= moved
@@ -1131,7 +1201,7 @@ module Samagotchi
         # A question between turns (the step-limit one) belongs to no turn.
         ask(snapshot[:pending_question]) if snapshot[:current_turn].nil? && snapshot[:pending_question]
         render_snapshot_cards(cards.select { |card| card[:current] }, joining: !reset)
-        Array(snapshot[:queued]).each do |entry|
+        queued.each do |entry|
           next if own?(entry[:client_id])
 
           @shown_enqueued << entry[:enqueued_id]
@@ -1453,10 +1523,31 @@ module Samagotchi
         @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)
       end
 
+      # A queued prompt was taken back before it ran (the web's ×, /unqueue
+      # in a terminal). One of this run's (wait_at_eof) will have no turn:
+      # it ends the wait, as a failed one does. Another client's shown
+      # line says so.
+      def turn_dequeued(event)
+        id = event[:enqueued_id]
+        @my_queued.delete(id)
+        if @open_ids.delete?(id)
+          if own?(event[:client_id])
+            @own_empty = true
+            @screen.commit("(removed before it ran)")
+          else
+            @own_failed = true
+            @screen.commit("(your queued message was removed before it ran)")
+          end
+        elsif @shown_enqueued.delete?(id)
+          @screen.commit("(a queued message was removed)")
+        end
+      end
+
       def start_turn(event)
         @running = true
         @joined_mid_turn = false
         origin = event[:origin] || {}
+        @my_queued.delete(origin[:enqueued_id])
         if event[:prompt].nil?
           # A continue turn (after the offer's yes) has no prompt to show; a
           # reminder turn shows its reminders (:reminder_injected).
@@ -1466,14 +1557,13 @@ module Samagotchi
         elsif !(own?(origin[:client_id]) || @shown_enqueued.include?(origin[:enqueued_id]))
           @screen.commit(prompt_line(origin[:client_id], event[:prompt]))
         end
-        # Another client's prompt line is up (here or at its enqueue); an
-        # own send has none, so its image lines are its echo.
-        @renderer.call(own?(origin[:client_id]) ? event : without_named_images(event, event[:prompt]))
+        # The own-send echo already names an image-only prompt; another
+        # client's prompt line does too, here or at its enqueue.
+        @renderer.call(without_named_images(event, event[:prompt]))
       end
 
-      # The turn's start without its image lines when the prompt line shown
-      # for it is the web's "[image: name]" text of a turn of images alone:
-      # that line names them already.
+      # The turn's start without its image lines when the shown prompt is
+      # the image-only "[image: name]" placeholder: that line names them.
       def without_named_images(event, shown_prompt)
         ImageRef.placeholder_only?(shown_prompt) ? event.except(:images) : event
       end

data/lib/samagotchi/terminal_ui/thinking_line.rb

@@ -11,9 +11,9 @@ module Samagotchi
     # ThinkingTicker (so it changes at most once per dwell). Both TUIs use it
     # in place of the raw tail of the stream.
     #
-    # A chunk carries :text (and :thinking): both loops split their stream,
-    # for every profile. A chunk without them (an older worker) has its raw
-    # :content, markup stripped, stand for thinking. A switch of lane starts the next sentence from the new
+    # A chunk carries :text and :thinking: both loops split their stream,
+    # for every profile (the raw :content stays in the worker,
+    # Bridge::ClientEvent). A switch of lane starts the next sentence from the new
     # lane's text; the line shown keeps the label of the lane it came from.
     class ThinkingLine
       include Formatting
@@ -43,12 +43,8 @@ module Samagotchi
       # @return [Boolean] whether the line changed
       def chunk(event)
         # The Bridge's TurnAccumulator reads the lanes by the same rule.
-        if event.key?(:text)
-          changed = add(:thinking, event[:thinking])
-          add(:writing, event[:text]) || changed
-        else
-          add(:thinking, event[:content], raw: true)
-        end
+        changed = add(:thinking, event[:thinking])
+        add(:writing, event[:text]) || changed
       end
 
       # A turn joined mid-way: the newest thinking or text part so far.