samagotchi 0.91.0 → 0.93.0

data/lib/samagotchi/bundle_command/try/trace.rb

@@ -2,7 +2,10 @@
 
 require "json"
 require_relative "../../analytics_file"
+require_relative "../../bridge/card_store"
+require_relative "../../session"
 require_relative "../../session_metrics"
+require_relative "../../tool_response"
 
 module Samagotchi
   class BundleCommand
@@ -15,25 +18,23 @@ module Samagotchi
 
       class TraceReader
         DENIAL_TEXT = "No one to approve it (non-interactive run)."
-        SESSION_ID = /\A[A-Za-z0-9_-]+\z/
         STDERR_LIMIT = 4000
 
         def initialize(state_home:, session_id:)
           @state_home = state_home
-          @session_id = session_id if session_id.to_s.match?(SESSION_ID)
+          @session_id = session_id if Session.valid_id?(session_id)
         end
 
         def read(exit_code:, answer:, stderr:, sandbox:, timed_out: false)
           return empty_trace(exit_code, answer, stderr, sandbox, timed_out) unless @session_id
 
-          sessions_dir = File.join(@state_home, "samagotchi", "sessions")
-          session_path = File.join(sessions_dir, "#{@session_id}.json")
-          session_dir = File.join(sessions_dir, @session_id)
-          session = json_file(session_path) || {}
+          sessions_dir = File.join(@state_home, Session::STATE_SUBDIR)
+          session_dir = Session.session_dir(@session_id, state_dir: sessions_dir)
+          session = json_file(Session.session_file(@session_id, state_dir: sessions_dir)) || {}
           messages = Array(session["messages"]).select { |message| message.is_a?(Hash) }
           analytics = AnalyticsFile.read(session_dir) || {}
           entries = card_entries(session_dir)
-          tool_rows, denied = tools(messages, analytics, timed_out)
+          tool_rows, denied = tools(messages, analytics)
           summary = SessionMetrics.saved_summary(session_dir)
           cost, estimate = cost_summary(summary)
           questions = entries.select { |entry| entry["type"] == "question" }
@@ -62,7 +63,11 @@ module Samagotchi
                     timed_out: timed_out)
         end
 
-        def tools(messages, analytics, timed_out)
+        # One row per saved call. A turn a --timeout interrupt cut (a
+        # Ctrl-C) saves its calls too, the one it cut short answered as
+        # interrupted (ToolResponse.interrupted): a record has no row of its
+        # own, so no call shows twice.
+        def tools(messages, analytics)
           records = Array(analytics["tool_records"]).select { |record| record.is_a?(Hash) }
                                                     .to_h do |record|
             [[record["iteration"].to_i, record["call_index"].to_i], record]
@@ -86,6 +91,7 @@ module Samagotchi
               is_denied = response && response["content"].to_s.include?(DENIAL_TEXT)
               denied << index if is_denied
               status = is_denied ? "denied" : record&.dig("status").to_s
+              status = "interrupted" if status.empty? && response && ToolResponse.interrupted_text?(response["content"])
               status = "unknown" if status.empty?
               {
                 index: index,
@@ -96,24 +102,9 @@ module Samagotchi
               }
             end
           end
-          rows += unsaved_rows(records, iteration, index) if timed_out
           [rows, denied]
         end
 
-        # A turn cut by a --timeout interrupt saves only the messages before
-        # it (a Ctrl-C), while its tool records stay: the records past the
-        # last saved model message are its calls, without their arguments.
-        # Only then: a normal run's loop also counts iterations it saves no
-        # model message for (a cut's retry, an empty-answer nudge).
-        def unsaved_rows(records, saved_iterations, index)
-          records.select { |(iteration, _), _| iteration > saved_iterations }.sort.map do |_, record|
-            index += 1
-            status = record["status"].to_s
-            { index: index, name: record["called_as"] || record["tool"] || "tool", args: "",
-              status: status.empty? ? "unknown" : status, duration_ms: record["duration_ms"].to_i }
-          end
-        end
-
         def call_name(call)
           function = call["function"].is_a?(Hash) ? call["function"] : {}
           call["name"] || function["name"] || "tool"
@@ -132,10 +123,13 @@ module Samagotchi
           args.to_s.gsub(/\s+/, " ").strip[0, 200]
         end
 
+        # The listing's placement fields: nothing to place in a one-turn run.
+        LISTING_FIELDS = %w[turns_since current earlier].freeze
+
+        # The saved cards as the web reads them (CardStore.saved), with
+        # string keys and values, as the JSON trace prints them.
         def card_entries(session_dir)
-          data = json_file(File.join(session_dir, "cards.json"))
-          entries = data.is_a?(Hash) ? data["entries"] : []
-          Array(entries).select { |entry| entry.is_a?(Hash) }
+          JSON.parse(JSON.generate(Bridge::CardStore.saved(session_dir))).map { |entry| entry.except(*LISTING_FIELDS) }
         end
 
         def unanswerable?(question)

data/lib/samagotchi/bundle_command.rb

@@ -90,46 +90,6 @@ module Samagotchi
           chi bundle build --scope system --out ./my-bundle/ identity.md work.md
     TEXT
     TRASH_HELP = "Usage: chi bundle trash [--empty] [--dry-run] [--older-than DAYS]"
-    NEW_HELP = <<~TEXT
-      Usage: chi bundle new NAME [--dir DIR]
-
-        Start a bundle in DIR/NAME (default ./NAME; refused when it exists): manifest.yml (shas filled,
-        requires_chi this chi), plugin.rb (a /NAME command and an after_tool_call hook), test/NAME_test.rb
-        (passes as written) and README.md. Then: chi bundle test, chi bundle check, chi bundle install.
-    TEXT
-    TEST_HELP = <<~TEXT
-      Usage: chi bundle test [PATH] [-- ARGS]
-
-        Run the tests of the bundle at PATH (default: .) on the Ruby and the lib chi runs on, outside any Bundler env:
-        test/**/*_test.rb on Minitest (require "samagotchi/testing/minitest"), or else spec/ on RSpec with the kit
-        (-r samagotchi/testing/rspec). ARGS go to the test runner (-- -n /name/, -- -e "a name").
-        The tests run the bundle's code as written, with your HOME (the kit's sandbox is per test): run code you'd install.
-        Exit status: the tests'; 1 no tests; 2 usage, or minitest / rspec doesn't load.
-    TEXT
-    CHECK_HELP = <<~TEXT
-      Usage: chi bundle check [PATH] [--fix] [--set KEY=VALUE]
-
-        Check the bundle at PATH (default: .) as an install would take it, one finding per line:
-          error|warn|info CODE file[:line]: message (fix: hint)
-        It installs and loads the bundle in a sandbox (temp HOME, config and state), not in yours, but its plugin and
-        hooks run in this process as written: run it on code you'd install.
-        --fix            rewrite stale and placeholder sha256 lines in manifest.yml
-        --set KEY=VALUE  a setting for the load (config.yml bundles: <name>: KEY), repeatable
-        Exit status: 0 no errors, 1 errors, 2 usage.
-    TEXT
-    TRY_HELP = <<~TEXT
-      Usage: chi bundle try PATH -p TEXT [--model NAME] [--memory NAME] [--mute NAME] [--toolkit NAME]
-             [--thinking LEVEL] [--set KEY=VALUE] [--json] [--keep] [--timeout SECONDS]
-
-        Install PATH and run one non-interactive turn in an isolated temporary config, state and work directory.
-        The user's hosts, keys and ordinary runtime settings are retained; their bundles, hooks, guardrails,
-        memories, prompt additions, sessions and attached context sources are not. Shipped guardrails and a
-        $1 cost cap are installed for the run. --set KEY=VALUE sets the tried bundle's config.yml bundles entry;
-        --set cost-cap.cap=N overrides the cap (unlike chi --set BUNDLE.KEY=VALUE, these are config settings).
-        --memory and --mute accept comma-separated names and repeat. --keep retains the sandbox and debug log.
-        --json prints the experimental machine-readable trace.
-        Exit status: child turn's status; 1 on install failure or timeout; 2 for usage; 130 on Ctrl-C.
-    TEXT
 
     # The subcommands' flags: --help only; a word not starting with -- is
     # a positional (install's source, -h included). --scope takes whatever
@@ -153,27 +113,6 @@ module Samagotchi
     BUILD_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/, dash_values: false) do |f|
       %w[--scope --name --version --description --out].each { |name| f.value name }
     end
-    NEW_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
-      f.value "--dir"
-    end
-    TEST_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A-/)
-    CHECK_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
-      f.switch "--fix"
-      f.value "--set", key: :set, repeat: true
-    end
-    TRY_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A-/) do |f|
-      f.value "-p", "--prompt", key: :prompt
-      f.value "--model"
-      f.value "--memory", repeat: true
-      f.value "--mute", repeat: true
-      f.value "--toolkit"
-      f.value "--thinking"
-      f.value "--set", repeat: true
-      f.switch "--json"
-      f.switch "--keep"
-      f.value "--timeout"
-      f.refuse "--attach", "--shared", "chi bundle try can't use --attach or --shared"
-    end
     TRASH_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
       f.switch "--empty"
       f.switch "--dry-run"
@@ -855,14 +794,14 @@ module Samagotchi
     end
 
     def new_bundle(rest)
-      parsed = parse_flags(NEW_FLAGS, rest, "new", help: NEW_HELP)
+      require_relative "bundle_command/scaffold"
+      parsed = parse_flags(Scaffold::FLAGS, rest, "new", help: Scaffold::HELP)
       return parsed if parsed.is_a?(Integer)
 
       unless parsed.args.size == 1
-        @stderr.puts NEW_HELP.lines.first
+        @stderr.puts Scaffold::HELP.lines.first
         return CLI::Exit::USAGE
       end
-      require_relative "bundle_command/scaffold"
       scaffold = Scaffold.new(parsed.args.first, parent: parsed.options.fetch(:dir, "."))
       begin
         written = scaffold.write
@@ -885,20 +824,21 @@ module Samagotchi
     def test_bundle(rest)
       split = rest.index("--")
       own, args = split ? [rest[0...split], rest[(split + 1)..]] : [rest, []]
-      parsed = parse_flags(TEST_FLAGS, own, "test", help: TEST_HELP)
+      require_relative "bundle_command/test_run"
+      parsed = parse_flags(TestRun::FLAGS, own, "test", help: TestRun::HELP)
       return parsed if parsed.is_a?(Integer)
 
       dir = parsed.args.first || "."
       unless parsed.args.size <= 1 && File.directory?(dir)
-        @stderr.puts parsed.args.size > 1 ? TEST_HELP.lines.first : "chi bundle test: #{dir} isn't a folder"
+        @stderr.puts parsed.args.size > 1 ? TestRun::HELP.lines.first : "chi bundle test: #{dir} isn't a folder"
         return CLI::Exit::USAGE
       end
-      require_relative "bundle_command/test_run"
       TestRun.new(dir, args: args, stdout: @stdout, stderr: @stderr).run
     end
 
     def check(rest)
-      parsed = parse_flags(CHECK_FLAGS, rest, "check", help: CHECK_HELP)
+      require_relative "bundle_command/check"
+      parsed = parse_flags(Check::FLAGS, rest, "check", help: Check::HELP)
       return parsed if parsed.is_a?(Integer)
 
       settings = check_settings(parsed.options.fetch(:set, []), label: "check") or return CLI::Exit::USAGE
@@ -911,157 +851,15 @@ module Samagotchi
         @stderr.puts "chi bundle check: #{dir} isn't a folder"
         return CLI::Exit::USAGE
       end
-      require_relative "bundle_command/check"
       Check.new(dir, fix: parsed.options.fetch(:fix, false), settings: settings, stdout: @stdout).run
     end
 
     def try_bundle(rest)
-      parsed = parse_flags(TRY_FLAGS, rest, "try", help: TRY_HELP)
+      require_relative "bundle_command/try/command"
+      parsed = parse_flags(Try::Command::FLAGS, rest, "try", help: Try::Command::HELP)
       return parsed if parsed.is_a?(Integer)
 
-      options = parsed.options
-      if options[:prompt].nil? || parsed.args.size != 1
-        @stderr.puts "Usage: chi bundle try PATH -p TEXT [options]"
-        return CLI::Exit::USAGE
-      end
-      path = parsed.args.first
-      unless File.directory?(path)
-        @stderr.puts "chi bundle try: #{path} isn't a folder"
-        return CLI::Exit::USAGE
-      end
-      if options.values_at(:model, :toolkit, :thinking, :memory, :mute).flatten.compact.any?(&:empty?)
-        @stderr.puts "chi bundle try: model, toolkit, thinking, memory and mute values cannot be empty"
-        return CLI::Exit::USAGE
-      end
-      require_relative "thinking"
-      if options[:thinking] && !Thinking::LEVELS.map(&:to_s).include?(options[:thinking])
-        @stderr.puts "chi bundle try: --thinking takes #{Thinking::LEVELS.join(", ")}, not #{options[:thinking]}"
-        return CLI::Exit::USAGE
-      end
-
-      timeout = parse_try_timeout(options[:timeout])
-      return CLI::Exit::USAGE unless timeout
-
-      set_pairs = []
-      cost_cap = 1
-      cost_cap_override = false
-      require_relative "bundle_session_settings"
-      Array(options[:set]).each do |pair|
-        key, sep, value = pair.partition("=")
-        if sep.empty?
-          @stderr.puts "chi bundle try: --set takes KEY=VALUE, not #{pair}"
-          return CLI::Exit::USAGE
-        end
-        if key == "cost-cap.cap"
-          cost_cap = BundleSessionSettings.typed(value)
-          cost_cap_override = true
-          unless (cost_cap.is_a?(Numeric) && cost_cap >= 0) || cost_cap == false
-            @stderr.puts "chi bundle try: --set cost-cap.cap takes a non-negative number or off"
-            return CLI::Exit::USAGE
-          end
-        else
-          set_pairs << pair
-        end
-      end
-      settings = check_settings(set_pairs, label: "try")
-      return CLI::Exit::USAGE unless settings
-
-      require_relative "bundle_command/try/sandbox"
-      require_relative "bundle_command/try/run"
-      require_relative "bundle_command/try/trace"
-      sandbox = nil
-      begin
-        sandbox = Try::Sandbox.new(path, bundle_settings: settings, cost_cap: cost_cap,
-                                   cost_cap_override: cost_cap_override)
-        sandbox.install
-        result = Try::Run.new(sandbox).run(prompt: options[:prompt], options: options, timeout: timeout)
-        trace = Try::TraceReader.new(state_home: sandbox.state_home, session_id: result.session_id)
-                              .read(exit_code: result.exit_status, answer: result.stdout, stderr: result.stderr,
-                                    sandbox: options[:keep] ? sandbox.root : nil, timed_out: result.timed_out)
-        render_try_trace(trace, json: options[:json], child_stderr: result.stderr)
-        @stderr.puts "chi bundle try: timed out after #{timeout} seconds" if result.timed_out
-        result.exit_status
-      rescue Try::Sandbox::Error => e
-        @stderr.puts e.message
-        e.status
-      ensure
-        report_try_sandbox(sandbox) if options[:keep] && sandbox
-        sandbox&.cleanup unless options[:keep]
-      end
-    end
-
-    def render_try_trace(trace, json:, child_stderr:)
-      error_lines = child_stderr.lines.reject { |line| line.start_with?("Session: ") }
-      @stderr.write(error_lines.join)
-      if json
-        render_trace_lines(trace, @stderr, include_answer: false)
-        @stdout.puts JSON.generate(trace.to_h.transform_keys(&:to_s))
-      else
-        render_trace_lines(trace, @stdout, include_answer: true)
-      end
-    end
-
-    def report_try_sandbox(sandbox)
-      @stderr.puts "sandbox: #{sandbox.root}"
-      @stderr.puts "debug log: #{File.join(sandbox.state_home, "samagotchi", "samagotchi.log")}"
-    end
-
-    def render_trace_lines(trace, output, include_answer:)
-      output.puts "tools:"
-      trace.tools.each do |tool|
-        output.puts format("  %d %-16s %-7s %dms  %s", tool[:index], tool[:name], tool[:status],
-                           tool[:duration_ms], JSON.generate(tool[:args].to_s[0, 60]))
-      end
-      trace.notices.each { |notice| output.puts "notices: [#{notice["hook"] || "hook"}] #{notice["text"]}" }
-      trace.cards.each do |card|
-        output.puts "card: #{[card["title"], card["body"]].compact.join(" — ")}"
-      end
-      trace.questions.each do |entry|
-        question = entry.dig("pending_question", "question").to_s
-        outcome = if entry["cancelled"] && entry["reason"] == "non_interactive"
-                    "unanswerable (non_interactive)"
-                  elsif entry["cancelled"]
-                    "cancelled (#{entry["reason"]})"
-                  elsif entry["answer"]
-                    "answered"
-                  else
-                    "unanswered"
-                  end
-        output.puts "questions: #{JSON.generate(question)} -> #{outcome}"
-      end
-      if trace.interactive_blocked
-        count = trace.denied.size + trace.questions.count { |question| question["cancelled"] && question["reason"] == "non_interactive" }
-        output.puts "warn: #{count} question(s)/call(s) couldn't be answered"
-      end
-      if include_answer
-        answer_lines = trace.answer.lines
-        output.puts "answer:"
-        answer_lines.first(10).each { |line| output.puts "  #{line.chomp}" }
-        output.puts "  … (truncated)" if answer_lines.size > 10
-      end
-      tokens = trace.tokens
-      prompt = tokens[:prompt] || "unknown"
-      completion = tokens[:completion] || "unknown"
-      cost = if trace.cost
-               "#{"~" if trace.cost_is_estimate}$#{format("%.4f", trace.cost)}"
-             else
-               "unknown"
-             end
-      output.puts "tokens: #{prompt} in / #{completion} out  cost #{cost}  exit #{trace.exit_code}" \
-                  "#{"  (#{trace.session_id})" if trace.session_id}"
-    end
-
-    def parse_try_timeout(value)
-      return 300 unless value
-
-      timeout = Float(value)
-      return timeout if timeout.positive? && timeout.finite?
-
-      @stderr.puts "chi bundle try: --timeout must be a positive number"
-      nil
-    rescue ArgumentError
-      @stderr.puts "chi bundle try: --timeout must be a positive number"
-      nil
+      Try::Command.new(stdout: @stdout, stderr: @stderr).run(parsed)
     end
 
     # --set KEY=VALUE values as typed (BundleSessionSettings.typed), or nil

data/lib/samagotchi/bundle_session_settings.rb

@@ -9,9 +9,10 @@ module Samagotchi
   # 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>:.
+  # 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
@@ -22,25 +23,44 @@ module Samagotchi
     # 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 _.
+    # 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+\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.
-    Availability = Data.define(:offered, :notes)
+    # 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)
+    def parse(args, types: {})
       settings = {}
       Array(args).each do |arg|
         target, sep, raw = arg.to_s.partition("=")
@@ -51,7 +71,7 @@ module Samagotchi
         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)
+        (settings[bundle] ||= {})[keys.first] = value_for(raw, types.dig(bundle, keys.first))
       end
       deep_freeze(settings)
     end
@@ -60,18 +80,23 @@ module Samagotchi
     # @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: {}, flag: "--set")
+    def check!(settings, bundles: offered, notes: {}, types: {}, flag: "--set")
       settings.each do |bundle, values|
         keys = bundles[bundle]
         note = notes[bundle]
-        values.each_key do |key|
+        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
@@ -80,40 +105,59 @@ module Samagotchi
     # --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)
+      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"), 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.
+    # ("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)
 
-      case value
-      when INTEGER then Integer(value, 10)
-      when DECIMAL then Float(value)
-      when "true" then true
-      when "false", "off" then false
-      else 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's, .typed), checked like
+    # 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)
+    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) }
 
-      settings = normalize(raw.transform_values { |values| values.transform_values { |value| typed(value) } })
-      return settings if settings.empty?
+      given = normalize(raw)
+      return given if given.empty?
 
-      available = bundles ? Availability.new(offered: bundles, notes: {}) : availability
-      check!(settings, bundles: available.offered, notes: available.notes, flag: "bundle_settings")
+      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).
@@ -133,6 +177,7 @@ module Samagotchi
       dir ||= MemoryBundle::Provenance.bundles_dir
       offered = {}
       notes = {}
+      types = {}
       MemoryBundle::Provenance.each_installed(dir: dir) do |name, bundle|
         next if bundle.error?
 
@@ -141,11 +186,12 @@ module Samagotchi
           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)
+      Availability.new(offered: offered, notes: notes, types: types)
     end
 
     # A session file's value, read tolerantly: the bundles that map to
@@ -165,24 +211,14 @@ module Samagotchi
       end)
     end
 
-    # Why +bundle+'s plugin doesn't load (as Plugin::Loader checks it), nil
-    # when it does or has none.
+    # 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
 
-      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)
-
-      return nil if MemoryBundle::Provenance.unchecked?(bundle.plugin.sha256)
-
-      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
+      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.
@@ -191,8 +227,9 @@ module Samagotchi
       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
+      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
 

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

@@ -1,11 +1,11 @@
 ---
 name: core
-version: 0.3.3
+version: 0.3.4
 scope: system
 description: "Recommended safety set"
 trust_level: reviewed
 # Its members' highest floor (cost-cap's)
-requires_chi: ">= 0.86.0"
+requires_chi: ">= 0.92.0"
 includes:
 - loop-guard
 - check-in

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

@@ -1,13 +1,14 @@
 ---
 name: cost-cap
-version: 0.2.0
+version: 0.2.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:21308746c9cfa3e135909d74e1668ccfc659ea120b3fb41b1ee6a3ce386d8b45
+  sha256: sha256:28d632cd19117ef359acc6aa1c621081c14c018772b7fe1efd6284e346fea135
 # ctx.cost is new in chi 0.83.0; ask_user's effects: in the next chi
-requires_chi: ">= 0.86.0"
-# chi --set cost-cap.cap=3: a session's own cap (ctx.settings["cap"])
-session_settings: [cap]
+requires_chi: ">= 0.92.0"
+# session_settings: as a mapping of keys to types is new
+# chi --set cost-cap.cap=3: a session's own cap (ctx.settings["cap"]), a number or off
+session_settings: {cap: number}