samagotchi 0.83.0 → 0.85.0

data/lib/samagotchi/send_command.rb

@@ -7,6 +7,7 @@ require_relative "session"
 require_relative "session_commands"
 require_relative "session_inbox"
 require_relative "session_manager"
+require_relative "bundle_session_settings"
 require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
@@ -39,7 +40,7 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [-m TEXT] [--image PATH]...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [--set BUNDLE.KEY=VALUE]... [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
@@ -65,8 +66,9 @@ module Samagotchi
                     (--new) start the next link of that session's chain:
                     in its folder, on its model (or --model's; one whose
                     host is gone falls back to the default, with a
-                    warning), LLM context, thinking level and toolkit,
-                    with a note carrying its recap; it is archived.
+                    warning), LLM context, thinking level, toolkit and
+                    bundle settings, with a note carrying its recap; it
+                    is archived.
                     last:ID names the chain's latest link.
                     Without -m the new session waits idle. Refused for a
                     session continued already (naming the next link) or
@@ -84,6 +86,12 @@ module Samagotchi
                     (full, lean, child, a config or bundle one; default
                     config's toolkit.default), and tools declared on top
                     of it or left out (repeatable, a comma list too)
+        --set BUNDLE.KEY=VALUE
+                    (--new) a bundle setting for this session, over
+                    config.yml's bundles: (repeatable; a key its bundle's
+                    manifest lists in session_settings:; 3, 2.5, true,
+                    false and off are typed, the rest is text:
+                    --set cost-cap.cap=3)
         --wait      wait for the answer and print it (one session); the
                     other lines go to stderr. Exit 3: it waits for an
                     answer from you: the question, its options and the
@@ -141,6 +149,7 @@ module Samagotchi
       f.value "--toolkit"
       f.value "--tool", key: :tools, repeat: true
       f.value "--no-tool", key: :no_tools, repeat: true
+      f.value "--set", key: :sets, repeat: true
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
       f.switch "--cut"
@@ -284,6 +293,7 @@ module Samagotchi
       %i[dir model continues thinking toolkit].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       TOOLKIT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") unless Array(options[key]).empty? }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
+      return usage_error("--set needs --new") unless Array(options[:sets]).empty?
       return usage_error("give session ids") if options[:ids].empty?
 
       options
@@ -302,10 +312,11 @@ module Samagotchi
       if options[:continues]
         taken = [("--dir" if options[:dir])] +
                 LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] } + [("--thinking" if options[:thinking])] +
-                [("--toolkit" if options[:toolkit])] + TOOLKIT_FLAGS.filter_map { |key, flag| flag unless Array(options[key]).empty? }
+                [("--toolkit" if options[:toolkit])] + TOOLKIT_FLAGS.filter_map { |key, flag| flag unless Array(options[key]).empty? } +
+                [("--set" unless Array(options[:sets]).empty?)]
         unless taken.compact.empty?
-          return usage_error("--continues takes the previous session's folder, LLM context, thinking level and " \
-                             "toolkit; " \
+          return usage_error("--continues takes the previous session's folder, LLM context, thinking level, " \
+                             "toolkit and bundle settings; " \
                              "leave out #{taken.compact.join(", ")}")
         end
       end
@@ -327,6 +338,11 @@ module Samagotchi
       end
       toolkit = Toolkit.from_flags(name: options[:toolkit], add: options[:tools], remove: options[:no_tools])
       options[:toolkit_value] = toolkit if toolkit
+      begin
+        options[:bundle_settings] = BundleSessionSettings.from_flags(options[:sets]) unless Array(options[:sets]).empty?
+      rescue BundleSessionSettings::Error => e
+        return usage_error(e.message)
+      end
 
       if options[:dir]
         options[:dir] = File.expand_path(options[:dir])
@@ -376,7 +392,8 @@ module Samagotchi
                                                           model_name: options[:model],
                                                           setup: SessionSetup.new(llm_context: options[:llm_context],
                                                                                   thinking: options[:thinking],
-                                                                                  toolkit: options[:toolkit_value]),
+                                                                                  toolkit: options[:toolkit_value],
+                                                                                  bundle_settings: options[:bundle_settings] || {}),
                                                           state_dir: @state_dir)
                   end
       rescue SessionContinue::Refused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e

data/lib/samagotchi/session.rb

@@ -208,6 +208,18 @@ module Samagotchi
       @toolkit = value.is_a?(Toolkit) ? value : Toolkit.from_file(value)
     end
 
+    # The session's own bundle settings (chi --set BUNDLE.KEY=VALUE):
+    # {bundle => {key => value}}, frozen, {} for none and for a session from
+    # before them. Given when it was created and never changed; a respawn,
+    # a continue and a fork keep them (SessionSetup.of), a delegate child
+    # doesn't. Plugin::Context#settings lays them over config.yml's.
+    attr_reader :bundle_settings
+
+    # @param value [Hash, nil] the session file's form too
+    def bundle_settings=(value)
+      @bundle_settings = BundleSessionSettings.normalize(value)
+    end
+
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
     # left), e.g. "loop-guard"; nil when it ended otherwise.
     def stopped_by
@@ -242,7 +254,7 @@ module Samagotchi
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
                    continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [],
-                   toolkit: nil, interrupted_turn: nil)
+                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -272,6 +284,7 @@ module Samagotchi
       self.reasoning_history = reasoning_history
       self.appended_prompt_files = appended_prompt_files
       self.toolkit = toolkit
+      self.bundle_settings = bundle_settings
       self.interrupted_turn = interrupted_turn
       @turn_checkpoint = nil
       @archived = false
@@ -369,6 +382,7 @@ module Samagotchi
         reasoning_history: setup.reasoning_history,
         appended_prompt_files: setup.appended_prompt_files,
         toolkit: setup.toolkit,
+        bundle_settings: setup.bundle_settings,
         continues: continues
       )
     end
@@ -434,6 +448,7 @@ module Samagotchi
       "reasoning_history" => nil,
       "appended_prompt_files" => [],
       "toolkit" => nil,
+      "bundle_settings" => {},
       "interrupted_turn" => nil
     }.freeze
 

data/lib/samagotchi/session_commands.rb

@@ -123,13 +123,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
 

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/session_setup.rb

@@ -4,6 +4,7 @@ require_relative "llm_context_override"
 require_relative "reasoning_history"
 require_relative "thinking"
 require_relative "toolkit"
+require_relative "bundle_session_settings"
 
 module Samagotchi
   # A session's own settings that come before its model's, carried as one
@@ -15,20 +16,26 @@ module Samagotchi
   # +appended_prompt_files+ the absolute paths chi --append-system-prompt
   # named (their text goes into the system prompt; [] with none),
   # +toolkit+ a Toolkit or nil (SessionManager.spawn_session gives the
-  # session config's toolkit.default then).
+  # session config's toolkit.default then), +bundle_settings+ the bundle
+  # settings chi --set gave ({bundle => {key => value}}, frozen; {} with
+  # none), which Plugin::Context#settings lays over config.yml's.
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
   # without one (but the toolkit its delegate call named); a continue and a
   # fork copy their session's (.of).
-  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit) do
-    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil)
+  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit,
+                             :bundle_settings) do
+    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil,
+                   bundle_settings: {})
       super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
-            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit)
+            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit,
+            bundle_settings: BundleSessionSettings.normalize(bundle_settings))
     end
 
     def empty?
-      llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil?
+      llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil? &&
+        bundle_settings.empty?
     end
 
     # A session's own setup, for a session that starts from it. Its
@@ -40,7 +47,8 @@ module Samagotchi
       return new if session.nil?
 
       new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
-          appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit))
+          appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit),
+          bundle_settings: session.bundle_settings)
     end
   end
 end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -50,7 +50,9 @@ module Samagotchi
       #   session's toolkit (config's toolkit.default without); an existing
       #   session keeps its own
       # @param toolkit_flags [Array<String>] which of those were given, for
-      #   the line an existing session's run prints
+      #   the line an existing session's run prints (--set too)
+      # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
+      #   a new session's setup carries them; an existing session keeps its own
       # @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,
@@ -58,11 +60,12 @@ module Samagotchi
       #   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: [], toolkit: nil,
-              toolkit_flags: [], state_dir: nil)
+              toolkit_flags: [], bundle_settings: {}, 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, toolkit: toolkit, toolkit_flags: toolkit_flags)
+                         appended_prompt_files: appended_prompt_files, toolkit: toolkit, toolkit_flags: toolkit_flags,
+                         bundle_settings: bundle_settings)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
@@ -131,7 +134,7 @@ module Samagotchi
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
                   memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-                  toolkit_flags: [], err: $stderr)
+                  toolkit_flags: [], bundle_settings: {}, err: $stderr)
         sd = state_dir || Session.default_state_dir
         if attach || resume
           warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files,
@@ -153,7 +156,7 @@ module Samagotchi
                                                  setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
                                                                          thinking: Thinking.session_level(thinking),
                                                                          appended_prompt_files: appended_prompt_files,
-                                                                         toolkit: toolkit))
+                                                                         toolkit: toolkit, bundle_settings: bundle_settings))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)
         client || raise(Error, "the worker for session #{session.id} did not start its Bridge in time")

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"
@@ -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)
@@ -620,6 +628,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 +820,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
@@ -1095,6 +1156,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 +1198,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 +1520,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).

data/lib/samagotchi/terminal_ui.rb

@@ -67,6 +67,8 @@ module Samagotchi
     COMMAND_QUEUED = "(queued: runs after this turn)"
     # /detach is the attached terminal's; the REPL owns its session.
     REPL_DETACH_NOTE = "(not attached: this session runs in this terminal; /exit ends it)"
+    # /unqueue is the attached terminal's (its worker's queued input files).
+    REPL_UNQUEUE_NOTE = "(/unqueue is the attached terminal's; here a line queued with /queue TEXT runs after the turn)"
     IMAGE_LINE_WAITS = "(a line with images runs as the next turn)"
 
     # Raised when another process (a `chi web` worker or another chi) owns the
@@ -100,12 +102,16 @@ module Samagotchi
     # @param toolkit [Toolkit, nil] --toolkit/--tool/--no-tool: a new
     #   session's toolkit (config's toolkit.default without); a resumed one
     #   keeps its own, with a line naming +toolkit_flags+ (the flags given)
+    # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
+    #   a new session's own; a resumed one keeps its own (--set is in
+    #   +toolkit_flags+ then)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
                    spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [])
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], bundle_settings: {})
       @scratch        = scratch
       @toolkit        = toolkit
       @toolkit_flags  = toolkit_flags
+      @bundle_settings = bundle_settings
       @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
@@ -274,7 +280,8 @@ module Samagotchi
         preloaded_memory_names: @requested_memories,
         muted_memory_names: @muted_memory_names,
         scratch: @scratch,
-        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured)
+        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured,
+                                bundle_settings: @bundle_settings)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.
@@ -1154,6 +1161,7 @@ module Samagotchi
       case local_command(input)
       when :stats then @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
       when :recap then @surface.commit("\nmodel> #{handle_recap_command}")
+      when :unqueue then @surface.commit(REPL_UNQUEUE_NOTE)
       else return false
       end
       true

data/lib/samagotchi/testing/bundle.rb

@@ -11,6 +11,7 @@ require_relative "../peer_sources"
 require_relative "../toolkit"
 require_relative "../guardrails/gate"
 require_relative "../memory_bundle/manifest"
+require_relative "../session_setup"
 require_relative "sandbox"
 require_relative "recorder"
 require_relative "host"
@@ -74,11 +75,15 @@ module Samagotchi
         # @param dir [String] the bundle's folder (its manifest.yml)
         # @param settings [Hash] config.yml `bundles: <name>:`
         # @param host [Hash] session values (Recorder::DEFAULTS' keys)
+        # @param session_settings [Hash] the session's own values for the
+        #   bundle (chi --set), keys its manifest lists in session_settings:;
+        #   ctx.settings lays them over +settings+ (Plugin::Context#settings),
+        #   initialize(settings) doesn't see them
         # @param sandbox [Sandbox, nil] default Sandbox.current, else one of
         #   its own, left at #shutdown
         # @return [Bundle]
-        def load(dir, settings: {}, host: {}, sandbox: nil)
-          new(dir, settings: settings, host: host, sandbox: sandbox).tap(&:load!)
+        def load(dir, settings: {}, host: {}, session_settings: {}, sandbox: nil)
+          new(dir, settings: settings, host: host, session_settings: session_settings, sandbox: sandbox).tap(&:load!)
         end
 
         # A bundle chi ships (lib/samagotchi/bundles/<name>), as #load.
@@ -118,14 +123,16 @@ module Samagotchi
       # @return [Integer] how often chi was told the tools changed
       attr_reader :tools_changes
 
-      def initialize(dir, settings: {}, host: {}, sandbox: nil)
+      def initialize(dir, settings: {}, host: {}, session_settings: {}, sandbox: nil)
         @dir = File.expand_path(dir)
         @manifest = MemoryBundle::Manifest.read(dir: @dir)
         @name = @manifest.name
         @settings = stringify(settings || {})
+        @session_moves = 1
+        own = session_settings.nil? || session_settings.empty? ? {} : { setup: setup_with(session_settings, host[:setup]) }
         @own_sandbox = sandbox.nil? && Sandbox.current.nil?
         @sandbox = sandbox || Sandbox.current || Sandbox.enter
-        @recorder = Recorder.new(cwd: @sandbox.work_dir, **host)
+        @recorder = Recorder.new(cwd: @sandbox.work_dir, **host, **own)
         @sessions = Sessions.new
         @http = FakeHttp.new
         @inits = []
@@ -309,7 +316,16 @@ module Samagotchi
       end
 
       # Change the session's values (cwd:, messages:, running: …).
-      def set(**values)
+      # +session_settings+ changes the session's own values for the bundle
+      # (as Bundle.load's) and moves it to a new session id
+      # ("test-session-2", or the session_id: given beside it): chi never
+      # changes them within a session, and ctx.settings is built once per
+      # session id.
+      def set(session_settings: nil, **values)
+        unless session_settings.nil?
+          values[:setup] = setup_with(session_settings, @recorder[:setup])
+          values[:session_id] ||= "#{@recorder[:session_id] || "test-session"}-#{@session_moves += 1}"
+        end
         @recorder.set(**values)
         self
       end
@@ -363,6 +379,16 @@ module Samagotchi
         result
       end
 
+      # +setup+ (the recorder's, nil for none) with +session_settings+ as
+      # this bundle's own values, checked against the manifest's
+      # session_settings: as chi --set checks them.
+      # @raise [ArgumentError] a key the manifest doesn't list
+      def setup_with(session_settings, setup)
+        values = { @name => stringify(session_settings) }
+        BundleSessionSettings.check!(values, bundles: { @name => @manifest.session_settings }, flag: "session_settings")
+        (setup || SessionSetup.new).with(bundle_settings: values)
+      end
+
       def stringify(value)
         case value
         when Hash then value.to_h { |key, item| [key.to_s, stringify(item)] }

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.83.0"
+  VERSION = "0.85.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end