samagotchi 0.101.0 → 0.102.0

data/lib/samagotchi/working_set_steer.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "llm_context_edit"
+require_relative "llm_context_view"
+require_relative "llm_context_apply"
+require_relative "token_usage"
+require_relative "working_set"
+
+module Samagotchi
+  # The user steering the working set (/working-set, the web's popover):
+  # drop an item (every content output of it still sent goes out of the
+  # prompt as a stub) and undrop it. Pure, on a conversation the caller
+  # owns (Engine#clone_messages' copies: an op stores new edits Hashes,
+  # LLMContextEdit.store) and runs between turns, so the next turn's first
+  # request is the first with the change (prompt caching: one break where
+  # the new prompt is fresh anyway).
+  #
+  # A drop is the user's layer (LLMContextEdit kind :drop, by "user"),
+  # saved applied: the view sends it whatever the strategy, none too
+  # (LLMContextView#sends?). One edit per id: a drop on an output that
+  # holds an edit already (a forget sent whole under none, a staged one, a
+  # stale stub) keeps that edit's saved Hash in its +was+, and an undrop
+  # puts it back. The outputs are WorkingSet.outputs_of's, the projection's
+  # own pairing, so the set and the op never disagree.
+  #
+  # Every op since the last turn is listed in one tail system message
+  # (kind "working_set", #record!), so the model learns what changed and
+  # doesn't read a dropped file again by reflex. An inverse op before the
+  # next turn cancels its op there (a drop then an undrop: nothing sent,
+  # nothing noted).
+  module WorkingSetSteer
+    BY = "user"
+    NOTE_KIND = "working_set"
+    # The tail note's ops: [{"op", "kind", "key", "label"}], until the turn
+    # that sends it (the chat loop's kept entries leave the key out).
+    OPS = :working_set_ops
+    NOTE_OPEN = "[WORKING SET: "
+    DROP = "drop"
+    UNDROP = "undrop"
+    INVERSE = { DROP => UNDROP, UNDROP => DROP }.freeze
+    MEMORY_PREFIX = "memory:"
+    URL = %r{\A[a-z][a-z0-9+.-]*://}i
+
+    # Why an op can't be done: the one place each refusal's words live
+    # (/working-set and forget_outputs add context only).
+    class Refused < StandardError
+      MESSAGES = {
+        dropped: "dropped by the user",
+        not_in_set: "not in the working set",
+        only_edited: "nothing to drop: only edited or written (no read of it is sent)",
+        derived: "nothing to drop: an older session's output that chi can't name",
+        already_dropped: "already dropped",
+        not_sent: "nothing to drop: none of it is sent now (forgotten or stubbed)",
+        not_dropped: "not dropped"
+      }.freeze
+
+      # @return [Symbol] a key of MESSAGES
+      attr_reader :reason
+
+      def initialize(reason)
+        @reason = reason
+        super(MESSAGES.fetch(reason))
+      end
+
+      # The words for +reason+, for a caller that only reports it.
+      def self.text(reason) = MESSAGES.fetch(reason)
+    end
+
+    # What a KEY names: an item's identity (WorkingSet's kind and key) and
+    # how replies name it (a file relative to the session's folder).
+    Target = Data.define(:kind, :key, :label)
+
+    # What an op did: the ids it changed, and the chars it frees (a drop)
+    # and the tail the server reads again from its earliest entry on.
+    # +free+: an undrop that took back a drop never sent (nothing changes).
+    Done = Data.define(:target, :op, :ids, :freed_chars, :tail_chars, :free)
+
+    module_function
+
+    # +word+ (a path, absolute or the session's folder's; memory:NAME; a
+    # URL) as a Target.
+    def target(word, cwd:)
+      word = word.to_s.strip
+      if word.start_with?(MEMORY_PREFIX)
+        name = word.delete_prefix(MEMORY_PREFIX).strip
+        Target.new(kind: WorkingSet::MEMORY, key: name, label: "memory #{name}")
+      elsif word.match?(URL)
+        url = word.gsub(/\s+/, " ")
+        Target.new(kind: WorkingSet::URL, key: url, label: url)
+      else
+        path = File.expand_path(word, cwd.to_s.empty? ? Dir.pwd : cwd)
+        Target.new(kind: WorkingSet::FILE, key: path, label: relative(path, cwd))
+      end
+    end
+
+    # A path as replies show it: below +cwd+ relative, else as it is.
+    def relative(path, cwd)
+      base = "#{cwd.to_s.chomp("/")}/"
+      !cwd.to_s.empty? && path.start_with?(base) ? path.delete_prefix(base) : path
+    end
+
+    # Drops +target+'s content outputs that are still sent under
+    # +strategy+ (the next turn's: LLMContextView's form), saving an applied
+    # :drop on each.
+    # @return [Done]
+    # @raise [Refused]
+    def drop(conversation, target, strategy:, cwd:, now: Time.now.utc.iso8601(3))
+      outputs = WorkingSet.outputs_of(conversation, kind: target.kind, key: target.key, strategy: strategy, cwd: cwd)
+      raise Refused, (known?(conversation, target, strategy, cwd) ? :only_edited : :not_in_set) if outputs.empty?
+
+      named = outputs.reject(&:derived)
+      raise Refused, :derived if named.empty?
+      raise Refused, :already_dropped if named.all? { |output| drop_of(conversation, output) }
+
+      sent = named.select(&:sent)
+      raise Refused, :not_sent if sent.empty?
+
+      edits = sent.map do |output|
+        was = LLMContextEdit.on(conversation[output.index])[output.id]
+        [output.index, LLMContextEdit.new(id: output.id, kind: LLMContextEdit::DROP, note: "", by: BY, staged_at: now,
+                                          applied_at: now, was: was&.to_h)]
+      end
+      freed, tail = LLMContextApply.weigh(conversation, layers: layers(strategy), edits: edits)
+      edits.each { |index, edit| LLMContextEdit.store(conversation[index], edit) }
+      Done.new(target: target, op: DROP, ids: edits.map { |_, edit| edit.id }, freed_chars: freed, tail_chars: tail,
+               free: false)
+    end
+
+    # Takes +target+'s drops off, putting back what each output held before
+    # it (+was+). +sent+: whether the drop reached a request (else the
+    # undrop is free).
+    # @return [Done]
+    # @raise [Refused]
+    def undrop(conversation, target, strategy:, cwd:, sent: true)
+      outputs = WorkingSet.outputs_of(conversation, kind: target.kind, key: target.key, strategy: strategy, cwd: cwd)
+      dropped = outputs.filter_map { |output| (edit = drop_of(conversation, output)) && [output, edit] }
+      if dropped.empty?
+        raise Refused, (outputs.empty? && !known?(conversation, target, strategy, cwd) ? :not_in_set : :not_dropped)
+      end
+
+      dropped.each do |output, edit|
+        entry = conversation[output.index]
+        LLMContextEdit.remove(entry, output.id)
+        before = edit.was && LLMContextEdit.from_h(output.id, edit.was)
+        LLMContextEdit.store(entry, before) if before
+      end
+      first = dropped.map { |output, _| output.index }.min
+      view = LLMContextView.new(strategy: strategy)
+      tail = sent ? LLMContextView.chars(view.messages(conversation)[first..]) : 0
+      Done.new(target: target, op: UNDROP, ids: dropped.map { |output, _| output.id }, freed_chars: 0, tail_chars: tail,
+               free: !sent)
+    end
+
+    # +output+'s drop (an LLMContextEdit), or nil.
+    def drop_of(conversation, output)
+      edit = LLMContextEdit.on(conversation[output.index])[output.id]
+      edit if edit&.kind == LLMContextEdit::DROP
+    end
+
+    # Whether the set holds +target+ at all (an edit-only file does).
+    def known?(conversation, target, strategy, cwd)
+      WorkingSet.build(conversation, cwd: cwd, strategy: strategy).items.any? do |item|
+        item.kind == target.kind && item.key == target.key
+      end
+    end
+
+    def layers(strategy) = LLMContextView.new(strategy: strategy).layers
+
+    # ── the tail note ───────────────────────────────────────────────────
+
+    # The index of the note the next turn will send (one after the last
+    # turn's entries: only system messages follow it), or nil.
+    def pending_note_index(messages)
+      (messages.size - 1).downto(0) do |index|
+        message = messages[index]
+        return nil unless message[:role].to_s == "system"
+        return index if message[:kind].to_s == NOTE_KIND
+      end
+      nil
+    end
+
+    # The ops the pending note lists ([{"op", "kind", "key", "label"}]).
+    def pending_ops(messages)
+      index = pending_note_index(messages)
+      index ? Array(messages[index][OPS]).select { |op| op.is_a?(Hash) } : []
+    end
+
+    # Whether +target+'s +op+ is pending (made since the last turn).
+    def pending?(messages, op, target)
+      pending_ops(messages).any? { |entry| same?(entry, op, target) }
+    end
+
+    # +messages+ with +done+'s op in the pending note: its inverse there
+    # cancels both (the note goes when nothing is left), else it is added
+    # (the note appended when there is none). A new Array; the note is a new
+    # Hash.
+    # @return [Array<Hash>]
+    def record!(messages, done)
+      index = pending_note_index(messages)
+      ops = index ? pending_ops(messages) : []
+      inverse = ops.index { |entry| same?(entry, INVERSE.fetch(done.op), done.target) }
+      if inverse
+        ops = ops.reject.with_index { |_, i| i == inverse }
+      else
+        ops = ops.reject { |entry| same?(entry, done.op, done.target) }
+        ops += [{ "op" => done.op, "kind" => done.target.kind, "key" => done.target.key, "label" => done.target.label }]
+      end
+      messages = messages.dup
+      if ops.empty?
+        messages.delete_at(index) if index
+      elsif index
+        messages[index] = note(ops)
+      else
+        messages << note(ops)
+      end
+      messages
+    end
+
+    def same?(entry, op, target)
+      entry["op"] == op && entry["kind"] == target.kind && entry["key"] == target.key
+    end
+
+    # The note listing +ops+: a tail system message, escaped like a context
+    # note (Prompt::ESCAPED_KINDS: it carries paths and URLs).
+    def note(ops)
+      drops = ops.select { |entry| entry["op"] == DROP }.map { |entry| entry["label"] }
+      undrops = ops.select { |entry| entry["op"] == UNDROP }.map { |entry| entry["label"] }
+      parts = []
+      unless drops.empty?
+        parts << "the user dropped #{drops.join(", ")} from your context: you are sent a stub instead of " \
+                 "#{drops.size == 1 ? "its outputs" : "their outputs"}; read #{drops.size == 1 ? "it" : "them"} again " \
+                 "only if the task needs it"
+      end
+      unless undrops.empty?
+        parts << "the user brought back #{undrops.join(", ")}: #{undrops.size == 1 ? "its outputs are" : "their outputs are"} " \
+                 "sent whole again"
+      end
+      { role: "system", kind: NOTE_KIND, content: "#{NOTE_OPEN}since your last turn #{parts.join("; ")}.]", OPS => ops }
+    end
+
+    # "12.4k tokens", chars/4.
+    def k(chars)
+      tokens = (chars / TokenUsage::CHARS_PER_TOKEN).ceil
+      tokens >= 1000 ? format("%.1fk tokens", tokens / 1000.0) : "#{tokens} tokens"
+    end
+
+    private_class_method :relative, :drop_of, :known?, :layers, :same?
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.101.0
+  version: 0.102.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -211,7 +211,6 @@ files:
 - lib/samagotchi/bundle_command/try/sandbox.rb
 - lib/samagotchi/bundle_command/try/trace.rb
 - lib/samagotchi/bundle_needs.rb
-- lib/samagotchi/bundle_session_settings.rb
 - lib/samagotchi/bundles/agents-md/manifest.yml
 - lib/samagotchi/bundles/agents-md/plugin.rb
 - lib/samagotchi/bundles/btw/manifest.yml
@@ -493,6 +492,7 @@ files:
 - lib/samagotchi/queued_command.rb
 - lib/samagotchi/reasoning_history.rb
 - lib/samagotchi/reasoning_history_command.rb
+- lib/samagotchi/recap_command.rb
 - lib/samagotchi/recap_setup.rb
 - lib/samagotchi/recap_store.rb
 - lib/samagotchi/redacted_inspect.rb
@@ -517,6 +517,7 @@ files:
 - lib/samagotchi/session_archive_command.rb
 - lib/samagotchi/session_chain.rb
 - lib/samagotchi/session_commands.rb
+- lib/samagotchi/session_config.rb
 - lib/samagotchi/session_continue.rb
 - lib/samagotchi/session_delete_command.rb
 - lib/samagotchi/session_inbox.rb
@@ -777,6 +778,8 @@ files:
 - lib/samagotchi/worker_task_wakes.rb
 - lib/samagotchi/worker_wakes.rb
 - lib/samagotchi/working_set.rb
+- lib/samagotchi/working_set_command.rb
+- lib/samagotchi/working_set_steer.rb
 - lib/samagotchi/yaml_lines.rb
 homepage: https://github.com/dm1try/samagotchi
 licenses:

data/lib/samagotchi/bundle_session_settings.rb

@@ -1,251 +0,0 @@
-# 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, and so is a value of another type than the manifest
-  # gives the key (session_settings: {cap: number}). 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 _; a decimal may
-    # leave out either side of its point (.5, 5.) and take an exponent
-    # (1e1, 2.5e-3), which YAML 1.1 leaves as text.
-    INTEGER = /\A-?(?:0|[1-9]\d*)\z/
-    DECIMAL = /\A-?(?:(?:0|[1-9]\d*)(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?\z/
-    # YAML 1.1's booleans (config.yml's), any case.
-    TRUE_WORDS = %w[true yes on].freeze
-    FALSE_WORDS = %w[false no off].freeze
-    # 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;
-    # +types+ the types its manifest gives keys ({name => {key => type}}).
-    Availability = Data.define(:offered, :notes, :types) do
-      def initialize(offered:, notes:, types: {}) = super
-    end
-
-    # What each type (MemoryBundle::Manifest::SESSION_SETTING_TYPES) takes,
-    # as a value .typed gives it, and how a refusal names it. A number may
-    # be off (false), as a bundle's own settings are turned off.
-    TYPES = {
-      "number" => [->(value) { (value.is_a?(Numeric) && value.finite?) || value == false }, "a number (or off)"],
-      "boolean" => [->(value) { [true, false].include?(value) }, "true or false"],
-      "string" => [->(value) { value.is_a?(String) }, "text"]
-    }.freeze
-
-    module_function
-
-    # --set's values as typed, in order: a later one of the same key wins.
-    # A key +types+ gives as string keeps its text as given (.value_for).
-    # @param args [Array<String>] "BUNDLE.KEY=VALUE" each
-    # @param types [Hash{String => Hash{String => String}}] Availability#types
-    # @return [Hash{String => Hash{String => Object}}] frozen
-    # @raise [Error] a value of another shape
-    def parse(args, types: {})
-      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] = value_for(raw, types.dig(bundle, keys.first))
-      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 types [Hash{String => Hash{String => String}}] Availability#types:
-    #   a typed key's value must be of its type (TYPES)
-    # @param flag [String] what a refusal names ("--set", a request field)
-    # @return [Hash] +settings+
-    # @raise [Error]
-    def check!(settings, bundles: offered, notes: {}, types: {}, flag: "--set")
-      settings.each do |bundle, values|
-        keys = bundles[bundle]
-        note = notes[bundle]
-        values.each do |key, value|
-          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)
-
-          takes, what = TYPES[types.dig(bundle, key)]
-          raise Error, "#{where}: #{bundle} takes #{what} for #{key}, not #{value.inspect}" if takes && !takes.call(value)
-        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, types: available.types), bundles: available.offered, notes: available.notes, types: available.types)
-    end
-
-    # A value as --set (and a request's string) gives it: an integer
-    # ("3", "-1"), a decimal ("2.5", ".5", "1e1"), a boolean as config.yml's
-    # YAML reads one (true/yes/on, false/no/off, any case); any other string
-    # stays as given ("010", "0x10", "3:30", "y", "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)
-      return Integer(value, 10) if INTEGER.match?(value)
-
-      if DECIMAL.match?(value)
-        number = Float(float_text(value))
-        # 1e400 is Infinity: no cap reaches it and JSON can't save it.
-        return number.finite? ? number : value
-      end
-
-      word = value.downcase
-      return true if TRUE_WORDS.include?(word)
-      return false if FALSE_WORDS.include?(word)
-
-      value
-    end
-
-    # A value for a key of +type+: a string key's text as given (--set
-    # b.name=yes stays "yes"), any other's .typed.
-    def value_for(value, type) = type == "string" ? value : typed(value)
-
-    # A decimal DECIMAL matches as Float reads it on every Ruby: a point
-    # with no digit after it ("5.", "5.e1") gets a 0, which Ruby 3.3's
-    # Float wants.
-    def float_text(value) = value.sub(/\.(?=e|\z)/i, ".0")
-
-    # POST /api/sessions bundle_settings: nil for none, else an object of
-    # objects of scalars (a string typed as --set types it), checked like
-    # --set; an empty bundle entry is dropped.
-    # @param bundles [Hash, nil] the offered keys (.availability's by default)
-    # @param types [Hash] their types, with +bundles+ (Availability#types)
-    # @return [Hash] frozen
-    # @raise [Error]
-    def from_request(raw, bundles: nil, types: {})
-      return {} if raw.nil?
-      raise Error, REQUEST_SHAPE unless raw.is_a?(Hash) && raw.all? { |_, values| scalar_map?(values) }
-
-      given = normalize(raw)
-      return given if given.empty?
-
-      available = bundles ? Availability.new(offered: bundles, notes: {}, types: types) : availability
-      settings = normalize(given.to_h do |bundle, values|
-        [bundle, values.to_h { |key, value| [key, value_for(value, available.types.dig(bundle, key))] }]
-      end)
-      check!(settings, bundles: available.offered, notes: available.notes, types: available.types, 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 = {}
-      types = {}
-      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
-        types[name] = bundle.session_setting_types unless bundle.session_setting_types.empty?
-        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, types: types)
-    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 chi's loader decides it
-    # (Plugin::Loader.unloadable_reason), nil when it does or has none.
-    def unloadable(dir, name, bundle)
-      return nil unless bundle.plugin
-
-      require_relative "plugin/loader"
-      # +dir+, not Provenance#plugin_path's bundles_dir: a spec's records live elsewhere.
-      Plugin::Loader.unloadable_reason(File.join(dir, name, "plugin", bundle.plugin.file.to_s), bundle)
-    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)
-      listed = raw.is_a?(Hash) ? raw["session_settings"] : nil
-      (listed.is_a?(Array) || listed.is_a?(Hash)) && !listed.empty?
-    rescue Psych::Exception, SystemCallError
-      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