samagotchi 0.83.0 → 0.85.0

data/lib/samagotchi/bundle_session_settings.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "version"
+
+module Samagotchi
+  # A session's own bundle settings (chi --set BUNDLE.KEY=VALUE, chi send
+  # --new --set, POST /api/sessions bundle_settings): {bundle => {key =>
+  # value}}, string keys, scalar values (.typed). A bundle offers the keys a
+  # session may set in its manifest's session_settings: (recorded at install,
+  # InstalledBundle#session_settings); any other bundle or key is refused, so
+  # a typo isn't saved. The session keeps them (Session#bundle_settings,
+  # SessionSetup) and Plugin::Context#settings lays them over config.yml's
+  # bundles: <name>:.
+  module BundleSessionSettings
+    # A refused --set (or request field): the message says why.
+    class Error < ArgumentError; end
+
+    # A bundle name (MemoryBundle::Manifest::BUNDLE_NAME) and a setting key.
+    BUNDLE = /\A[A-Za-z0-9][A-Za-z0-9_-]*\z/
+    KEY = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
+    # The values a setting may take.
+    SCALARS = [String, Integer, Float, TrueClass, FalseClass].freeze
+    REQUEST_SHAPE = "bundle_settings is an object of bundle => {key => scalar}"
+    # What .typed reads as a number: no leading zero, no exponent, no _.
+    INTEGER = /\A-?(?:0|[1-9]\d*)\z/
+    DECIMAL = /\A-?(?:0|[1-9]\d*)\.\d+\z/
+    # The shipped bundles' sources (a stale record's hint reads them).
+    SHIPPED_DIR = File.expand_path("bundles", __dir__)
+
+    # The installed bundles a session may set settings of: +offered+ the
+    # keys of each bundle whose plugin loads ({name => keys}), +notes+ what
+    # a refusal adds for a bundle ({name => text}): why its plugin doesn't
+    # load, or how to refresh a record from before session_settings.
+    Availability = Data.define(:offered, :notes)
+
+    module_function
+
+    # --set's values as typed, in order: a later one of the same key wins.
+    # @param args [Array<String>] "BUNDLE.KEY=VALUE" each
+    # @return [Hash{String => Hash{String => Object}}] frozen
+    # @raise [Error] a value of another shape
+    def parse(args)
+      settings = {}
+      Array(args).each do |arg|
+        target, sep, raw = arg.to_s.partition("=")
+        bundle, *keys = target.split(".", -1)
+        if sep.empty? || keys.empty? || !BUNDLE.match?(bundle.to_s) || keys.any? { |key| !KEY.match?(key) }
+          raise Error, "--set takes BUNDLE.KEY=VALUE, not #{arg}"
+        end
+        raise Error, "--set #{arg}: one key under the bundle (BUNDLE.KEY), no nested path" if keys.size > 1
+        raise Error, "--set #{arg}: give a value" if raw.strip.empty?
+
+        (settings[bundle] ||= {})[keys.first] = typed(raw)
+      end
+      deep_freeze(settings)
+    end
+
+    # +settings+ when every bundle is installed and offers each key.
+    # @param bundles [Hash{String => Array<String>}] the installed bundles'
+    #   offered keys (.offered)
+    # @param notes [Hash{String => String}] Availability#notes
+    # @param flag [String] what a refusal names ("--set", a request field)
+    # @return [Hash] +settings+
+    # @raise [Error]
+    def check!(settings, bundles: offered, notes: {}, flag: "--set")
+      settings.each do |bundle, values|
+        keys = bundles[bundle]
+        note = notes[bundle]
+        values.each_key do |key|
+          where = "#{flag} #{bundle}.#{key}"
+          raise Error, "#{where}: #{note || "no installed bundle #{bundle} (#{takers(bundles)})"}" if keys.nil?
+          raise Error, "#{where}: #{bundle} takes no session settings#{" #{note}" if note}" if keys.empty?
+          raise Error, "#{where}: #{bundle} takes #{keys.join(", ")}" unless keys.include?(key)
+        end
+      end
+      settings
+    end
+
+    # --set's values parsed and checked (.parse, .check!) against the
+    # installed bundles (.availability).
+    def from_flags(args, available: availability)
+      check!(parse(args), bundles: available.offered, notes: available.notes)
+    end
+
+    # A value as --set (and a request's string) gives it: an integer
+    # ("3", "-1"), a decimal ("2.5"), true, false or off (false); any other
+    # string stays as given ("010", "0x10", "3:30", "No", "null"). A value
+    # that isn't a String (a JSON number or boolean) is kept.
+    def typed(value)
+      return value unless value.is_a?(String)
+
+      case value
+      when INTEGER then Integer(value, 10)
+      when DECIMAL then Float(value)
+      when "true" then true
+      when "false", "off" then false
+      else value
+      end
+    end
+
+    # POST /api/sessions bundle_settings: nil for none, else an object of
+    # objects of scalars (a string typed as --set's, .typed), checked like
+    # --set; an empty bundle entry is dropped.
+    # @param bundles [Hash, nil] the offered keys (.availability's by default)
+    # @return [Hash] frozen
+    # @raise [Error]
+    def from_request(raw, bundles: nil)
+      return {} if raw.nil?
+      raise Error, REQUEST_SHAPE unless raw.is_a?(Hash) && raw.all? { |_, values| scalar_map?(values) }
+
+      settings = normalize(raw.transform_values { |values| values.transform_values { |value| typed(value) } })
+      return settings if settings.empty?
+
+      available = bundles ? Availability.new(offered: bundles, notes: {}) : availability
+      check!(settings, bundles: available.offered, notes: available.notes, flag: "bundle_settings")
+    end
+
+    # Each installed bundle's offered keys, by name (Availability#offered).
+    # @return [Hash{String => Array<String>}]
+    def offered(dir: nil) = availability(dir: dir).offered
+
+    # The installed bundles a session may set settings of: a record that
+    # doesn't read is left out, and so is one whose plugin doesn't load as
+    # chi's loader decides (Plugin::Loader#unloadable_reason: requires_chi,
+    # the file, its sha256), with a note saying why. A record with no
+    # session_settings whose shipped bundle lists some (installed before
+    # them) gets a note on refreshing it.
+    # @return [Availability]
+    def availability(dir: nil, shipped_dir: SHIPPED_DIR)
+      require_relative "memory_bundle/provenance"
+      require_relative "memory_bundle/manifest"
+      dir ||= MemoryBundle::Provenance.bundles_dir
+      offered = {}
+      notes = {}
+      MemoryBundle::Provenance.each_installed(dir: dir) do |name, bundle|
+        next if bundle.error?
+
+        if (reason = unloadable(dir, name, bundle))
+          notes[name] = "#{name} is installed but its plugin doesn't load: #{reason}"
+          next
+        end
+        offered[name] = bundle.session_settings
+        if bundle.session_settings.empty? && shipped_settings?(shipped_dir, name)
+          notes[name] = "(run `chi update` or `chi bundle upgrade #{name}` to refresh it)"
+        end
+      end
+      Availability.new(offered: offered, notes: notes)
+    end
+
+    # A session file's value, read tolerantly: the bundles that map to
+    # settings, the scalar ones of those, string keys, frozen; {} for
+    # anything else.
+    # @return [Hash{String => Hash{String => Object}}]
+    def normalize(raw)
+      return {}.freeze unless raw.is_a?(Hash)
+
+      deep_freeze(raw.each_with_object({}) do |(bundle, values), acc|
+        next unless values.is_a?(Hash)
+
+        kept = values.each_with_object({}) do |(key, value), scalars|
+          scalars[key.to_s] = value if SCALARS.any? { |kind| value.is_a?(kind) }
+        end
+        acc[bundle.to_s] = kept unless kept.empty?
+      end)
+    end
+
+    # Why +bundle+'s plugin doesn't load (as Plugin::Loader checks it), nil
+    # when it does or has none.
+    def unloadable(dir, name, bundle)
+      return nil unless bundle.plugin
+
+      failure = MemoryBundle::Manifest.requires_chi_failure(bundle.requires_chi, Samagotchi::VERSION)
+      return failure if failure
+
+      file = File.join(dir, name, "plugin", bundle.plugin.file.to_s)
+      return "the file is missing" unless File.file?(file)
+
+      expected = MemoryBundle::Provenance.recorded_sha(bundle.plugin.sha256)
+      return "no sha256 recorded for it (reinstall the bundle)" if expected.empty?
+
+      actual = MemoryBundle::Provenance.file_sha(file)
+      "its sha256 differs from the installed one (edited after install? reinstall the bundle)" unless actual == expected
+    end
+
+    # Whether chi ships a bundle +name+ whose manifest lists session_settings.
+    def shipped_settings?(shipped_dir, name)
+      path = File.join(shipped_dir, name, "manifest.yml")
+      return false unless File.file?(path)
+
+      raw = YAML.safe_load_file(path)
+      raw.is_a?(Hash) && raw["session_settings"].is_a?(Array) && !raw["session_settings"].empty?
+    rescue StandardError
+      false
+    end
+
+    def scalar_map?(values)
+      values.is_a?(Hash) && values.values.all? { |value| SCALARS.any? { |kind| value.is_a?(kind) } }
+    end
+
+    def takers(bundles)
+      names = bundles.reject { |_, keys| keys.empty? }.keys.sort
+      names.empty? ? "no installed bundle takes --set" : "bundles that take --set: #{names.join(", ")}"
+    end
+
+    def deep_freeze(settings)
+      settings.to_h { |bundle, values| [bundle.dup.freeze, values.to_h { |k, v| [k.dup.freeze, v.frozen? ? v : v.dup.freeze] }.freeze] }.freeze
+    end
+
+    private_class_method :unloadable, :shipped_settings?, :scalar_map?, :takers, :deep_freeze
+  end
+end

data/lib/samagotchi/bundles/cost-cap/manifest.yml

@@ -1,11 +1,13 @@
 ---
 name: cost-cap
-version: 0.1.0
+version: 0.1.1
 scope: system
 description: "A per-session $ cap: at the cap the turn pauses on Continue (another cap's worth) / Stop, a warning at 80% goes to the user only; /cap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:bc6683af0063b90d6a3d7c2796bccf446043dfb1b3f07c04bd54d22d26199e1d
+  sha256: sha256:2ea7f76af1ea1c1b0a9a8b0b4b11d6e85a4a816fae224ef5b220cfd20fb48f42
 # ctx.cost is new in chi 0.83.0
 requires_chi: ">= 0.83.0"
+# chi --set cost-cap.cap=3: a session's own cap (ctx.settings["cap"])
+session_settings: [cap]

data/lib/samagotchi/bundles/cost-cap/plugin.rb

@@ -10,13 +10,16 @@
 #
 # Settings (config.yml, bundles: cost-cap:), read at each use from
 # ctx.settings, never at load:
+#   cap: 3.00       this session's own cap, set with chi --set cost-cap.cap=3
+#                   (session_settings: in the manifest); 0/off: none
 #   default: 5.00   USD cap for a session with none set; absent/0/off: none
 #   child: 2.00     for delegate children (ctx.delegate?); absent: default
 #   warn_at: 0.8    the share of the cap that warns; 0/off: no warning
 #
 # State: <data_dir>/sessions/<session id>.json, {"cap": 3.0, "step": 3.0},
 # written by /cap and by Continue; "cap": null (or false) is off for the
-# session, over the config. Without a file the cap comes from the settings.
+# session, over the config. Without a file the cap comes from the settings:
+# cap:, else child: for a delegate, else default:.
 # The cap is resolved once per session id (ctx.delegate? parses the session
 # file) and kept until /cap or Continue writes a new one.
 require "json"
@@ -164,8 +167,9 @@ class Plugin
 
   def breakdown(cost) = "#{money(cost.total)} (#{parts(cost)})"
 
-  # The session's cap and step now: the state file's, else child: for a
-  # delegate, else default:. Cached per session id.
+  # The session's cap and step now: the state file's, else the session's
+  # own cap: (--set), else child: for a delegate, else default:. Cached per
+  # session id.
   def resolve(ctx)
     session = ctx.session_id
     cached = @mutex.synchronize { @resolved }
@@ -189,9 +193,12 @@ class Plugin
 
   def configured(ctx)
     settings = ctx.settings
-    return { cap: nil, step: nil } unless settings.key?("default") || settings.key?("child")
+    return { cap: nil, step: nil } unless %w[cap default child].any? { |key| settings.key?(key) }
 
-    key = settings.key?("child") && ctx.delegate? ? "child" : "default"
+    key = if settings.key?("cap") then "cap"
+          elsif settings.key?("child") && ctx.delegate? then "child"
+          else "default"
+          end
     cap = self.class.amount(settings[key])
     { cap: cap, step: cap }
   end

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.83.0
+version: 0.85.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/engine.rb

@@ -762,7 +762,7 @@ module Samagotchi
     # Event types #announce accepts: facts about the session's input queue,
     # a failed turn's prompt handed back and the continue offer, which live
     # UIs need in the event log, emitted outside any turn's stream.
-    ANNOUNCEABLE_EVENTS = %i[turn_enqueued input_merged prompt_restored continue_offered continue_resolved
+    ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
                              plugin_init_started plugin_init_finished].freeze
 

data/lib/samagotchi/kernel_loop.rb

@@ -372,6 +372,11 @@ module Samagotchi
     # Ends with its :generation_completed (and, unless cut, the
     # after_generation hook).
     def generate(turn, request)
+      # Before the generation starts: a hook that waits (a question) isn't
+      # the generation's time, and a Stop there leaves none started.
+      fire_hook(:before_generation, { type: :before_generation, iteration: turn.iteration }) if @hooks
+      raise Client::RequestCancelled, turn.cancel_controller.reason if turn.cancel_controller&.cancelled?
+
       # Each ask splits its own stream (run_generation rebuilds the
       # splitter), so one that ended inside a thought or a tool call doesn't
       # leave the next one "inside" it.
@@ -383,7 +388,6 @@ module Samagotchi
       # streamed, for the log (a stuck thinking generation shows as
       # thinking_chars=N content_length=…).
       generation = Generation.new(usage: nil, served_model: nil, streamed_thinking: 0)
-      fire_hook(:before_generation, { type: :before_generation, iteration: turn.iteration }) if @hooks
       buffer_mark = generation.buffer_mark = turn.buffer.length
       # A cancel salvages only this generation's thinking: the earlier
       # steps' is on their own messages already.

data/lib/samagotchi/llm/chat_loop.rb

@@ -655,10 +655,14 @@ module Samagotchi
           @loop.apply_llm_context!(@conversation, context: @context, emit: method(:emit))
           window = @window = @loop.context_window(@model_name)
           observe_context(iteration, window)
+          # Before the generation starts: a hook that waits (a question)
+          # isn't the generation's time, and a Stop there leaves none started.
+          @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
+          return [@cancel_controller.reason, "", ""] if @cancel_controller&.cancelled?
+
           retry_generation = @empty_retry.take_sampling!
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
                context_window_source: window&.source, price: @loop.price&.to_h)
-          @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
           streamed = +""
           thought = +""
           generation_controller = nil

data/lib/samagotchi/log_subscriber.rb

@@ -16,6 +16,7 @@ module Samagotchi
     # One line each, with a few of their own fields (never text).
     ANNOUNCED = {
       turn_enqueued: %i[enqueued_id client_id],
+      turn_dequeued: %i[enqueued_id client_id],
       command_queued: %i[command_id client_id],
       command_ran: %i[command_id client_id status],
       input_merged: %i[count],

data/lib/samagotchi/memory_bundle/builder.rb

@@ -202,7 +202,7 @@ module Samagotchi
         parts.scripts.each_value { |src| FileUtils.cp(src, File.join(staging, "scripts", File.basename(src))) }
       end
 
-      # manifest.yml for the staged bundle: requires_chi, needs and the
+      # manifest.yml for the staged bundle: requires_chi, needs, session_settings and the
       # file descriptions come from the installed bundle's record, the
       # trust_level from the CLI else the record.
       def write_manifest(staging, name, version, files_map, parts)
@@ -223,7 +223,8 @@ module Samagotchi
           needs: record&.needs,
           scripts: parts.scripts.transform_values { |src| "sha256:#{Digest::SHA256.hexdigest(File.binread(src))}" },
           context_providers: parts.context_providers,
-          file_descriptions: file_descriptions(record, files_map)
+          file_descriptions: file_descriptions(record, files_map),
+          session_settings: record&.session_settings || []
         )
       end
 

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -20,13 +20,15 @@ module Samagotchi
     #               the lists as recorded (nil when absent): Manifest.parse_needs
     #               and ContextProviders.parse_list check them
     #   includes    a profile's recorded members, nil for a plain bundle
+    #   session_settings
+    #               the keys a session may set (chi --set), [] when none
     #   error       why manifest.json couldn't be read (the rest empty), else nil
     class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :trust_level, :source_commit,
                                         :requires_chi, :files, :hooks, :guardrails, :scripts, :plugin, :needs,
-                                        :includes, :context_providers, :error)
+                                        :includes, :context_providers, :session_settings, :error)
       OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, trust_level: nil, source_commit: nil,
                    requires_chi: nil, files: {}, hooks: {}, guardrails: {}, scripts: {}, plugin: nil, needs: nil,
-                   includes: nil, context_providers: nil, error: nil }.freeze
+                   includes: nil, context_providers: nil, session_settings: [], error: nil }.freeze
 
       def initialize(name:, **fields)
         super(name: name, **OPTIONAL, **fields)
@@ -57,7 +59,8 @@ module Samagotchi
             guardrails: mapping(h["guardrails"]) { |meta| sha(meta) },
             scripts: mapping(h["scripts"]) { |meta| sha(meta) },
             plugin: PluginRef.parse(h["plugin"]), needs: h["needs"], context_providers: h["context_providers"],
-            includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil)
+            includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil,
+            session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [])
       end
 
       def self.string(value) = value&.to_s

data/lib/samagotchi/memory_bundle/installer.rb

@@ -420,7 +420,8 @@ module Samagotchi
           conflicts: @conflicts.keys,
           scripts_files: installed.script_files,
           context_providers: @manifest.context_providers,
-          file_descriptions: @manifest.file_descriptions
+          file_descriptions: @manifest.file_descriptions,
+          session_settings: @manifest.session_settings
         )
       end
 

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -41,6 +41,9 @@ module Samagotchi
     #       cmd: '{ruby} {bundle_dir}/scripts/pr_context.rb {url}'
     #       why: GitHub PR      #   optional
     #       every_seconds: 300  #   optional
+    #   session_settings: [cap] # optional — the settings a session may set
+    #                          #   (chi --set cost-cap.cap=3), read by the
+    #                          #   plugin from ctx.settings at call time
     #   includes: [a, b]       # optional — a profile (meta bundle): the
     #                          #   shipped bundles it installs; its dir holds
     #                          #   only manifest.yml (MemoryBundle::Profile)
@@ -60,7 +63,7 @@ module Samagotchi
       # the description a mapping gave, for the files that have one; hooks:
       # name → BundleHook.
       attr_reader :name, :version, :scope, :description, :files, :file_descriptions, :hooks, :trust_level, :plugin, :requires_chi, :needs, :includes,
-                  :scripts, :context_providers
+                  :scripts, :context_providers, :session_settings
 
       def initialize(path:)
         @path = path
@@ -84,6 +87,7 @@ module Samagotchi
         @scripts = parse_scripts(raw["scripts"])
         @context_providers = parse_context_providers(raw["context_providers"])
         @includes = parse_includes(raw["includes"])
+        @session_settings = self.class.parse_session_settings(raw["session_settings"])
       end
 
       # A profile: it installs the bundles in includes instead of files.
@@ -136,7 +140,8 @@ module Samagotchi
       # Writes a fresh manifest.yml from computed checksums at `dir`.
       # +file_descriptions+ (name → text) writes those files as mappings.
       def self.write(dir:, name:, version:, files:, scope: nil, description: "", hooks: nil, trust_level: nil,
-                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], file_descriptions: {})
+                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], file_descriptions: {},
+                     session_settings: [])
         FileUtils.mkdir_p(dir)
         manifest = {
           "name" => name,
@@ -159,9 +164,26 @@ module Samagotchi
         manifest["needs"] = needs.map { |n| n.transform_keys(&:to_s).compact } unless needs.empty?
         manifest["scripts"] = scripts.transform_keys(&:to_s) unless scripts.empty?
         manifest["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
+        manifest["session_settings"] = Array(session_settings).map(&:to_s) unless Array(session_settings).empty?
         File.write(File.join(dir, "manifest.yml"), YAML.dump(manifest))
       end
 
+      # A setting key a session may set (BundleSessionSettings::KEY).
+      SESSION_SETTING = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
+
+      # session_settings: → the keys, [] when absent; anything but a list of
+      # plain key names is a ValidationError.
+      def self.parse_session_settings(raw)
+        return [] if raw.nil?
+
+        keys = raw.is_a?(Array) ? raw : nil
+        unless keys&.all? { |key| (key.is_a?(String) || key.is_a?(Symbol)) && key.to_s.match?(SESSION_SETTING) }
+          raise ValidationError, "session_settings: a list of setting names (#{raw.inspect})"
+        end
+
+        keys.map(&:to_s).uniq
+      end
+
       # needs: → [{command:, why:, hint:}] (why/hint a String or nil), [] when
       # absent. Takes the manifest's string-keyed YAML or the symbol-keyed
       # form provenance stores. Duplicates merge (the first one's why/hint

data/lib/samagotchi/memory_bundle/provenance.rb

@@ -141,7 +141,7 @@ module Samagotchi
       # @param context_providers [Array<ContextProviders::Provider>]
       def write(files:, scope:, version:, source_path:, hooks: {}, trust_level: nil, source_commit: nil, hooks_files: {},
                 guardrails_files: {}, plugin_file: nil, requires_chi: nil, needs: nil, conflicts: [], includes: nil,
-                scripts_files: {}, context_providers: [], file_descriptions: {})
+                scripts_files: {}, context_providers: [], file_descriptions: {}, session_settings: [])
         FileUtils.mkdir_p(@bundle_dir)
         bases_dir = File.join(@bundle_dir, "bases")
         FileUtils.mkdir_p(bases_dir)
@@ -239,6 +239,7 @@ module Samagotchi
           end
         end
         manifest_data["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
+        manifest_data["session_settings"] = Array(session_settings).map(&:to_s) unless Array(session_settings).empty?
 
         write_manifest(manifest_data)
       end

data/lib/samagotchi/parent_report.rb

@@ -34,8 +34,9 @@ module Samagotchi
     # @param result [ReplyWait::Result]
     # @return [String] answered, question, failed, canceled, limit (the
     #   turn ran out of iterations, nobody asked), not_continued (a Stop
-    #   answered the step-limit question), no_answer, error, worker_gone,
-    #   stopped or running
+    #   answered the step-limit question), removed (the queued message was
+    #   taken back before it ran), no_answer, error, worker_gone, stopped
+    #   or running
     def status(result)
       case result.status
       when :done then "answered"
@@ -46,6 +47,7 @@ module Samagotchi
         when "canceled" then "canceled"
         when "exhausted" then "limit"
         when "not_continued" then "not_continued"
+        when "removed" then "removed"
         else "no_answer"
         end
       when :error then "error"
@@ -258,6 +260,7 @@ module Samagotchi
       when "canceled" then "the turn was canceled"
       when "completed" then "the turn ended with no visible answer"
       when "not_continued" then "the turn was not continued (Stop); its work so far stays"
+      when "removed" then "the queued message was removed before it ran; no turn ran for it"
       when "exhausted"
         "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered; " \
           "chi send #{session_id} -m '/continue yes' continues it, a message drops it"

data/lib/samagotchi/plugin/context.rb

@@ -97,8 +97,25 @@ module Samagotchi
       # @return [String] the bundle the plugin came with
       attr_reader :bundle
 
-      # @return [Hash] config.yml `bundles: <bundle>:` (string keys), frozen
-      attr_reader :settings
+      # config.yml `bundles: <bundle>:` with the session's own values for
+      # the bundle laid over it (chi --set BUNDLE.KEY=VALUE, through the
+      # Host's setup: SessionSetup#bundle_settings), string keys, frozen.
+      # Plugin init and chi.ctx run before the session is bound: with no
+      # session id yet it is the config alone, and it is built again once
+      # per session id (the session's values never change after it starts).
+      # A plugin's initialize(settings) gets the config only: a value a
+      # session may set is read here, at call time.
+      # @return [Hash]
+      def settings
+        id = session_id
+        cached = @session_settings
+        return cached.last if cached && cached.first == id
+
+        values = session_values(id) if id
+        merged = id ? overlay(@settings, values || {}) : @settings
+        @session_settings = [id, merged].freeze unless id && values.nil?
+        merged
+      end
 
       # @return [Logger]
       attr_reader :log
@@ -419,6 +436,23 @@ module Samagotchi
         nil
       end
 
+      # The session's own values for this bundle ({} without any; nil when
+      # the Host couldn't tell them, so #settings can retry).
+      def session_values(id)
+        values = @host.setup&.call&.bundle_settings
+        values.is_a?(Hash) ? values.fetch(@bundle, {}) : {}
+      rescue StandardError => e
+        unless (@session_settings_unread ||= {}).key?(id)
+          @session_settings_unread[id] = true
+          @log.warn("session_settings_unread", error: "#{e.class}: #{e.message}")
+        end
+        nil
+      end
+
+      def overlay(config, values)
+        values.empty? ? config : deep_freeze(config.merge(values))
+      end
+
       def deep_freeze(value)
         case value
         when Hash then value.to_h { |k, v| [deep_freeze(k), deep_freeze(v)] }.freeze

data/lib/samagotchi/reply_wait.rb

@@ -35,7 +35,9 @@ module Samagotchi
     #   reply (:no_reply): "failed", "canceled", "completed" (empty),
     #   "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
+    #   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
@@ -132,6 +134,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