samagotchi 0.91.0 → 0.93.0

data/lib/samagotchi/guardrails/data_readers.rb

@@ -32,17 +32,30 @@ module Samagotchi
 
       # Where command_word's word is in +words+ (nil when there is none).
       def command_index(words)
-        i = 0
+        each_argument_index(words).find { |i| !assignment?(words[i]) }
+      end
+
+      # Each index of +words+ from +from+ on that is no redirection and no
+      # spaced redirection's target (the "/tmp/x" of "> /tmp/x"); an
+      # Enumerator without a block.
+      def each_argument_index(words, from = 0)
+        return enum_for(:each_argument_index, words, from) unless block_given?
+
+        i = from
         while i < words.size
           word = words[i]
           if word.match?(REDIRECT)
-            i += 1 if word.match?(/\A\d*[<>]{1,2}\z/)
-          elsif !word.match?(/\A[A-Za-z_]\w*=/)
-            return i
+            i += word.match?(/\A\d*[<>]{1,2}\z/) ? 2 : 1
+            next
           end
+          yield i
           i += 1
         end
-        nil
+      end
+
+      # Whether a word is a NAME=value assignment.
+      def assignment?(word)
+        word.match?(/\A[A-Za-z_]\w*=/)
       end
 
       # Whether a cat or tee command sends its output to a file (a file
@@ -62,8 +75,21 @@ module Samagotchi
       # ">& -". A >& with any other target does write one: bash reads
       # ">& file" and ">&file" as "&>file".
       def stdout_file?(words)
+        redirects_to_file?(words, /\A1?(>>?)(&?)(.*)\z/m)
+      end
+
+      # Whether one of +words+ sends any fd's output to a file (3>run.sh,
+      # 2>>log, {fd}>run.sh, 3<>run.sh as well as stdout_file?'s forms),
+      # /dev/null and fd dups left out as there.
+      def output_file?(words)
+        redirects_to_file?(words, /\A(?:\d*|\{\w+\})(>>?|<>)(&?)(.*)\z/m)
+      end
+
+      # stdout_file? and output_file?: a word matching +pattern+ (its
+      # captures: the operator, an &, the target) that writes a file.
+      def redirects_to_file?(words, pattern)
         words.each_with_index do |word, i|
-          match = word.match(/\A1?(>>?)(&?)(.*)\z/m)
+          match = word.match(pattern)
           next unless match
 
           amp = match[2]
@@ -84,18 +110,7 @@ module Samagotchi
         verb = command_index(words)
         return false unless verb
 
-        i = verb + 1
-        while i < words.size
-          word = words[i]
-          if word.match?(REDIRECT)
-            i += word.match?(/\A\d*[<>]{1,2}\z/) ? 2 : 1
-            next
-          end
-          return true if filename_word?(word)
-
-          i += 1
-        end
-        false
+        each_argument_index(words, verb + 1).any? { |i| filename_word?(words[i]) }
       end
 
       # Whether a tee argument names a file: not an option, a heredoc's tag,
@@ -139,18 +154,7 @@ module Samagotchi
       # their spaced targets), the <<TAG words and the heredoc bodies left
       # out.
       def arguments(words)
-        args = []
-        i = 0
-        while i < words.size
-          word = words[i]
-          if word.match?(REDIRECT)
-            i += word.match?(/\A\d*[<>]{1,2}\z/) ? 2 : 1
-            next
-          end
-          args << word unless word.match?(/\A[A-Za-z_]\w*=/) || heredoc_word?(word)
-          i += 1
-        end
-        args
+        each_argument_index(words).map { |i| words[i] }.reject { |word| assignment?(word) || heredoc_word?(word) }
       end
 
       # Whether a word is a heredoc's <<TAG or one of its bodies.

data/lib/samagotchi/guardrails/parent_levels.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Guardrails
+    # The parent-answers level words and their one reading (#parse_level),
+    # apart from the rest of ParentPolicy so Session (its parent_answers
+    # setter) reads them without loading the guardrails.
+    module ParentPolicy
+      HARD = "hard"
+      STANDARD = "standard"
+      SOFT = "soft"
+      # Strictest first: a session's own level may only move left of
+      # config.yml's.
+      ORDER = [HARD, STANDARD, SOFT].freeze
+      # A session value that means "none of its own" (config's).
+      UNSET = "default"
+
+      # A level word as written anywhere (a session file, /parent-answers,
+      # --parent-answers), stripped and case-blind.
+      # @param word [String, Symbol, nil]
+      # @return [String, Symbol] the level, :unset (nil, "" or "default":
+      #   config's) or :invalid
+      def self.parse_level(word)
+        text = word.to_s.strip.downcase
+        return :unset if text.empty? || text == UNSET
+
+        ORDER.include?(text) ? text : :invalid
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails/parent_policy.rb

@@ -3,6 +3,7 @@
 require_relative "../config"
 require_relative "../pending_question"
 require_relative "approval"
+require_relative "parent_levels"
 require_relative "parent_approvals"
 
 module Samagotchi
@@ -49,9 +50,8 @@ module Samagotchi
       KEY = "guardrails.parent_answers"
       # A session's own value (Session#parent_answers): it may only tighten KEY.
       SESSION_KEY = "parent_answers"
-      HARD = "hard"
-      STANDARD = "standard"
-      SOFT = "soft"
+      # The level words (HARD, STANDARD, SOFT, ORDER, UNSET) and
+      # #parse_level: parent_levels.rb.
 
       # A strategy: its name, the effects a parent may pick under it, and
       # where it comes from: :config (config.yml's) or :session (a
@@ -83,12 +83,6 @@ module Samagotchi
       # @return [Strategy]
       def strategy(name) = STRATEGIES.fetch(name.to_s, STRATEGIES[HARD])
 
-      # Strictest first: a session's own level may only move left of
-      # config.yml's.
-      ORDER = [HARD, STANDARD, SOFT].freeze
-      # A session value that means "none of its own" (config's).
-      UNSET = "default"
-
       # The stricter of two strategies, by name; a tie keeps +a+.
       # @return [Strategy]
       def stricter(a, b) = ORDER.index(b.name) < ORDER.index(a.name) ? b : a
@@ -99,18 +93,16 @@ module Samagotchi
       # is read on every parent answer).
       # @return [String, nil]
       def session_level(value)
-        word = value.to_s.strip.downcase
-        return nil if word.empty? || word == UNSET
-
-        STRATEGIES.key?(word) ? word : HARD
+        case (level = parse_level(value))
+        when :unset then nil
+        when :invalid then HARD
+        else level
+        end
       end
 
       # Whether a session's own value is set but not a level (a hand-edited
       # file: read as hard); the worker says so once when it loads.
-      def unknown_level?(value)
-        word = value.to_s.strip.downcase
-        !word.empty? && word != UNSET && !STRATEGIES.key?(word)
-      end
+      def unknown_level?(value) = parse_level(value) == :invalid
 
       # What a parent may answer on a session whose own value is
       # +session_value+: config.yml's (+config+) unless the session's is
@@ -150,9 +142,6 @@ module Samagotchi
         level.nil? ? ORDER.size : ORDER.index(level)
       end
 
-      # @return [Array<String>] the effects +strategy+ lets a parent pick
-      def allowed_effects(strategy) = strategy.allowed
-
       # Each option's effect, in option order. Tagged questions carry them;
       # an untagged one (asked by an older worker, a relayed card built
       # from an older child's question) gets them derived as before:

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -95,6 +95,7 @@ module Samagotchi
 
         bodies = lexer.heredoc_spans.map { |doc| doc[:span] }
         cuts = []
+        redirected = false
         each_command(tokens) do |indices|
           words = indices.map { |i| tokens[i][1] }
           indices.each_with_index do |i, position|
@@ -103,12 +104,13 @@ module Samagotchi
 
             span = lexer.spans[i]
             cut = if bodies.include?(span)
-                    body_cut(text, span, words) if value == HEREDOC
+                    body_cut(text, span, words, redirected) if value == HEREDOC
                   elsif value == SUBST
                     substitution_cut(text, tokens, i, span, words, position)
                   end
             cuts << cut if cut
           end
+          redirected ||= exec_redirect?(tokens, indices, words)
         end
         cuts.sort_by { |span, _| -span.begin }.each_with_object(+text) do |(span, replacement), out|
           out[span] = replacement
@@ -134,25 +136,44 @@ module Samagotchi
 
       # [span, what it becomes] for a data heredoc's body at +span+ (its
       # command's +words+), or nil when the body stays in the code text: a
-      # cat or tee writing a file may be run later (D1).
-      def self.body_cut(text, span, words)
-        return nil unless cut_body?(words)
+      # cat or tee writing a file may be run later (D1), and so may one
+      # printing after an earlier exec sent the shell's output to a file
+      # (+redirected+).
+      def self.body_cut(text, span, words, redirected)
+        return nil unless cut_body?(words, redirected)
 
         [span, terminator_line(text[span])]
       end
       private_class_method :body_cut
 
       # Whether a body a data reader reads leaves the code text: a cat or tee
-      # sending it to a file keeps it (D1); a body any other command reads as
+      # sending it to a file keeps it (D1), as does any cat or tee once an
+      # exec redirected the shell's output (+redirected+: its stdout, or the
+      # fd a >&3 names, may be a file); a body any other command reads as
       # data is one the lexer's data_sink? approved.
-      def self.cut_body?(words)
+      def self.cut_body?(words, redirected)
         verb = DataReaders.command_word(words)
         return true unless DataReaders::SINKS.include?(File.basename(verb.to_s))
 
-        !DataReaders.writes_file?(words)
+        !redirected && !DataReaders.writes_file?(words)
       end
       private_class_method :cut_body?
 
+      # Whether the simple command at +indices+ may be an exec that redirects
+      # the shell's own output to a file (exec >run.sh, exec 3>run.sh,
+      # exec {fd}>run.sh, exec 3<>run.sh): what a later cat or tee prints may
+      # land there. Any exec word counts, not only the command word ({ exec
+      # …; }, then exec …, command exec …, a function's body), and so does an
+      # exec backgrounded (exec &>run.sh, which the lexer reads as "exec &"
+      # and ">run.sh"): the conservative reading.
+      def self.exec_redirect?(tokens, indices, words)
+        return false unless words.include?("exec")
+
+        following = tokens[indices.last + 1]
+        DataReaders.output_file?(words) || following == [:op, "&"]
+      end
+      private_class_method :exec_redirect?
+
       # [span, what it becomes] for the body of a "$(cat <<'EOF' … EOF)" given
       # as a message (-m, --body, …) of a data reader (D2), or nil: eval,
       # bash -c, a command piped on and a body that runs stay.

data/lib/samagotchi/hook_question.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A hook's or a plugin's question (event[:ask_user], ctx.ask_user) as one
+  # value on its way to the question flow: built at the plugin-facing edge
+  # (Hooks::Registry's event helper, Plugin::Context#ask_user), passed
+  # through the hook runtime and the plugin host (Hooks::Runtime#ask_user,
+  # Plugin::Host#ask_user), Engine#hook_ask_user and HookRoutes#ask_user to
+  # QuestionDesk#ask_for_hook. The bundle test kit records it as asked
+  # (Testing::Recorder#questions).
+  #
+  # question, options, header, allow_freeform: as the hook gave them
+  # (QuestionDesk checks the options); hook: the asking hook's or plugin's
+  # label; effects: what an option does for a parent agent's answer, by its
+  # label (label => effect, as the hook gave it; nil for none). QuestionDesk
+  # turns it into the pending question's per-option tags
+  # (Guardrails::ParentPolicy.option_tags, PendingQuestion#effects).
+  HookQuestion = Data.define(:question, :options, :header, :allow_freeform, :hook, :effects) do
+    def initialize(effects: nil, **) = super
+  end
+end

data/lib/samagotchi/hook_routes.rb

@@ -31,14 +31,13 @@ module Samagotchi
     end
 
     # The things a hook can do beyond reading its event. Each gets the
-    # hook's label (event[:hook]) from the registry.
+    # hook's label (event[:hook]) from the registry; ask_user gets it inside
+    # the HookQuestion.
     # @return [Hooks::Runtime]
     def runtime
       Hooks::Runtime.new(
         notify: ->(text:, level:, hook:, fallback_for: nil) { notify(text, level, hook, fallback_for: fallback_for) },
-        ask_user: lambda { |question:, options:, header:, allow_freeform:, hook:, effects: nil|
-          ask_user(question, options, header, allow_freeform, hook, effects: effects)
-        },
+        ask_user: ->(question) { ask_user(question) },
         stop_turn: ->(reason:, hook:) { stop_turn(reason, hook) },
         steer: ->(text:, hook:) { @steer.call(text, source(hook)) },
         stop_generation: ->(reason:, hook:) { stop_generation(reason, hook) }
@@ -87,9 +86,10 @@ module Samagotchi
     # web), single-select, kind "hook". A --non-interactive run has no one
     # to ask: nil at once. Anything but an answer (a sync handler's text, no
     # answer, cancelled) is nil too.
+    # @param question [HookQuestion]
     # @return [Hash, nil] {selected:, freeform:, selected_indices:}
-    def ask_user(question, options, header, allow_freeform, hook, effects: nil)
-      @question_desk.call.ask_for_hook(question, options, header, allow_freeform, hook, effects: effects)
+    def ask_user(question)
+      @question_desk.call.ask_for_hook(question)
     end
 
     # Cancel the running turn (reason :hook), after a notice that says why.

data/lib/samagotchi/hooks/registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "monitor"
+require_relative "../hook_question"
 require_relative "../log"
 
 module Samagotchi
@@ -93,6 +94,8 @@ module Samagotchi
       lambda do |payload|
         yield(payload)
       rescue Exception => e # rubocop:disable Lint/RescueException -- :deny fails closed on anything
+        # Ctrl-C and kill signals are the user's, whatever the policy.
+        raise if e.is_a?(SignalException)
         raise unless policy == :deny || e.is_a?(StandardError) || e.is_a?(ScriptError)
 
         Hooks.record_failure(label, event, e)
@@ -111,8 +114,8 @@ module Samagotchi
     # callables, each given the hook's label. +notify+ takes
     # (text:, level:, hook:, and fallback_for: when the hook gave one: what
     # the line stands in for, HookRoutes#notify) and shows one line to the
-    # user; +ask_user+ takes (question:, options:, header:, allow_freeform:, hook:, and
-    # effects: when the hook gave them) and returns the answer hash or nil; +stop_turn+ takes (reason:, hook:) and
+    # user; +ask_user+ takes a HookQuestion (the hook's label in it) and
+    # returns the answer hash or nil; +stop_turn+ takes (reason:, hook:) and
     # cancels the running turn (true when it did); +steer+ takes (text:,
     # hook:) and puts the text into the running turn (Engine#steer, true
     # when queued); +stop_generation+ takes (reason:, hook:) and cuts the
@@ -390,9 +393,8 @@ module Samagotchi
           nil
         }
         event[:ask_user] ||= lambda { |question:, options:, header: nil, allow_freeform: false, effects: nil|
-          @runtime&.ask_user&.call(question: question, options: options, header: header,
-                                   allow_freeform: allow_freeform, hook: event[:hook],
-                                   **(effects.nil? ? {} : { effects: effects }))
+          @runtime&.ask_user&.call(HookQuestion.new(question: question, options: options, header: header,
+                                                    allow_freeform: allow_freeform, hook: event[:hook], effects: effects))
         }
         event[:stop_turn] ||= lambda { |reason|
           next false if TURN_OVER_EVENTS.include?(event[:type])

data/lib/samagotchi/host_registry.rb

@@ -68,7 +68,7 @@ module Samagotchi
       def api_base_url
         return openai_base_url unless api&.to_sym == :anthropic
 
-        (url || root_url).chomp("/").delete_suffix("/v1")
+        LLM::AnthropicMessages.api_root(url || root_url)
       end
 
       # The header the host's key goes in: auth: when set, else the api's

data/lib/samagotchi/kernel_loop.rb

@@ -243,7 +243,9 @@ module Samagotchi
                                                    streamed_thinking: turn.streamed_thinking)
       end
       finish(turn)
-    rescue StandardError => e
+    rescue StandardError, Interrupt => e
+      # A failure, or a Ctrl-C, carries the conversation so far: the
+      # Engine keeps the turn's finished iterations.
       LLM::FailedTurn.attach(e, turn && duplicate_conversation(turn.conversation))
       raise
     end
@@ -671,8 +673,17 @@ module Samagotchi
     def dispatch_calls(turn, calls)
       turn.qwen_attempts = 0
       turn.qwen_partial = nil
-      runs = ToolResponse.run_batch(tool_runner, calls, iteration: turn.iteration, emit: turn.emit,
-                                                        on_stream_event: turn.on_stream_event, cap: turn.cap)
+      runs = []
+      begin
+        ToolResponse.run_batch(tool_runner, calls, iteration: turn.iteration, emit: turn.emit,
+                                                   on_stream_event: turn.on_stream_event, cap: turn.cap) { |run, _| runs << run }
+      rescue Interrupt
+        # A Ctrl-C mid-batch: the entry still answers every call (the
+        # finished runs, then run_batch's interrupted ones), for #run to
+        # hand on with the conversation.
+        turn.conversation << ToolResponse.joined(runs, ids: ToolIds.next_ids(turn.conversation, runs.size))
+        raise
+      end
       turn.tool_activity.concat(ToolResponse.activities(runs))
       # One entry for the batch: the capped outputs joined (ToolResponse.joined),
       # an id per run (ToolIds).

data/lib/samagotchi/llm/anthropic_messages.rb

@@ -87,6 +87,11 @@ module Samagotchi
 
       attr_reader :base_url, :host_name, :api_key_env, :models_ttl, :first_token_timeout, :dialect
 
+      # The Messages API root a base URL names: without a trailing / and a
+      # trailing /v1 (as ANTHROPIC_BASE_URL), so requests never go to
+      # /v1/v1. HostEntry#api_base_url and the bootstrap probe both use it.
+      def self.api_root(url) = url.to_s.chomp("/").delete_suffix("/v1")
+
       # @param entry [HostRegistry::HostEntry]
       def self.for(entry, **)
         new(base_url: entry.api_base_url, host_name: entry.name, api_key_env: entry.api_key_env, auth: entry.auth,

data/lib/samagotchi/llm/chat_loop.rb

@@ -90,7 +90,9 @@ module Samagotchi
         conversation = Array(messages).map(&:dup)
         Run.new(self, conversation, on_stream_event, cancel_controller, model_name, pending_input, start: reasoning_since)
            .call(max_iterations: max_iterations || 1, cap: KernelLoop.resolve_output_char_cap(max_tool_output_chars))
-      rescue StandardError => e
+      rescue StandardError, Interrupt => e
+        # A failure, or a Ctrl-C (its calls answered: ToolResponse.run_batch),
+        # carries the conversation so far for the Engine to keep.
         FailedTurn.attach(e, conversation && plain(conversation))
         raise
       end

data/lib/samagotchi/llm/errors.rb

@@ -547,10 +547,10 @@ module Samagotchi
       end
     end
 
-    # Marks an error that ended a turn with the conversation the loop had
-    # built by then (the prompt plus completed tool iterations; a half
-    # streamed reply is not kept), so the caller can keep it, as a cancel's
-    # salvage does.
+    # Marks an error that ended a turn (or the Interrupt of a Ctrl-C) with
+    # the conversation the loop had built by then (the prompt plus completed
+    # tool iterations; a half streamed reply is not kept), so the caller can
+    # keep it, as a cancel's salvage does.
     module FailedTurn
       # +kept_steps+: set by the Engine when the turn's work stays
       # (Engine#failed_messages): the tool results it got to; nil when it

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, session_settings and the
+      # manifest.yml for the staged bundle: requires_chi, needs, session_settings (typed) 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)
@@ -224,7 +224,8 @@ module Samagotchi
           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),
-          session_settings: record&.session_settings || []
+          session_settings: record&.session_settings || [],
+          session_setting_types: record&.session_setting_types || {}
         )
       end
 

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -22,15 +22,19 @@ module Samagotchi
     #   includes    a profile's recorded members, nil for a plain bundle
     #   session_settings
     #               the keys a session may set (chi --set), [] when none
+    #   session_setting_types
+    #               {key => type} for the typed ones (Manifest::SESSION_SETTING_TYPES), {} when none
     #   dev         a dev install (`chi bundle install --dev`): its source is
     #               the folder it links to and its files carry Provenance::DEV_SHA
     #   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, :session_settings, :dev, :error)
+                                        :includes, :context_providers, :session_settings, :session_setting_types, :dev,
+                                        :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, session_settings: [], dev: false, error: nil }.freeze
+                   includes: nil, context_providers: nil, session_settings: [], session_setting_types: {}, dev: false,
+                   error: nil }.freeze
 
       def initialize(name:, **fields)
         super(name: name, **OPTIONAL, **fields)
@@ -63,6 +67,7 @@ module Samagotchi
             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,
             session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [],
+            session_setting_types: mapping(h["session_setting_types"]) { |type| type.to_s },
             dev: h["dev"] == true)
       end
 

data/lib/samagotchi/memory_bundle/installer.rb

@@ -440,6 +440,7 @@ module Samagotchi
           context_providers: @manifest.context_providers,
           file_descriptions: @manifest.file_descriptions,
           session_settings: @manifest.session_settings,
+          session_setting_types: @manifest.session_setting_types,
           dev: @dev
         )
       end

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -43,7 +43,9 @@ module Samagotchi
     #       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
+    #                          #   plugin from ctx.settings at call time;
+    #                          #   or {cap: number}: each with the type
+    #                          #   --set checks (SESSION_SETTING_TYPES)
     #   includes: [a, b]       # optional — a profile (meta bundle): the
     #                          #   shipped bundles it installs; its dir holds
     #                          #   only manifest.yml (MemoryBundle::Profile)
@@ -63,7 +65,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, :session_settings
+                  :scripts, :context_providers, :session_settings, :session_setting_types
 
       def initialize(path:)
         @path = path
@@ -88,6 +90,7 @@ module Samagotchi
         @context_providers = parse_context_providers(raw["context_providers"])
         @includes = parse_includes(raw["includes"])
         @session_settings = self.class.parse_session_settings(raw["session_settings"])
+        @session_setting_types = self.class.parse_session_setting_types(raw["session_settings"])
       end
 
       # A profile: it installs the bundles in includes instead of files.
@@ -141,7 +144,7 @@ module Samagotchi
       # +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: {},
-                     session_settings: [])
+                     session_settings: [], session_setting_types: {})
         FileUtils.mkdir_p(dir)
         manifest = {
           "name" => name,
@@ -164,26 +167,57 @@ 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?
+        manifest["session_settings"] = session_settings_entry(session_settings, session_setting_types) 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.
+      # The types a session setting may be given (session_settings: {key:
+      # type}), checked by BundleSessionSettings.check!: number (or off),
+      # boolean, string; any (or a list's key) takes every scalar.
+      SESSION_SETTING_TYPES = %w[number boolean string any].freeze
+
+      # session_settings: → the keys, [] when absent: a list of plain key
+      # names, or a mapping of them to types; anything else is a
+      # ValidationError.
       def self.parse_session_settings(raw)
         return [] if raw.nil?
 
-        keys = raw.is_a?(Array) ? raw : nil
+        keys = raw.is_a?(Hash) && raw.values.all?(String) ? raw.keys : raw
+        keys = nil unless keys.is_a?(Array)
         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})"
+          raise ValidationError, "session_settings: a list of setting names, or a mapping of them to types (#{raw.inspect})"
         end
 
         keys.map(&:to_s).uniq
       end
 
+      # session_settings: → {key => type} for the keys a mapping types
+      # (any left out), {} for a list or none.
+      # @raise [ValidationError] a type that isn't one of SESSION_SETTING_TYPES
+      def self.parse_session_setting_types(raw)
+        return {} unless raw.is_a?(Hash)
+
+        raw.each_with_object({}) do |(key, type), types|
+          unless SESSION_SETTING_TYPES.include?(type)
+            raise ValidationError, "session_settings: #{key}'s type is #{SESSION_SETTING_TYPES[0..-2].join(", ")} or " \
+                                   "#{SESSION_SETTING_TYPES.last}, not #{type.inspect}"
+          end
+          types[key.to_s] = type unless type == "any"
+        end
+      end
+
+      # session_settings: as written back: a list without types, else a
+      # mapping (an untyped key as any).
+      def self.session_settings_entry(keys, types)
+        keys = Array(keys).map(&:to_s)
+        return keys if types.nil? || types.empty?
+
+        keys.to_h { |key| [key, types[key] || "any"] }
+      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

@@ -154,7 +154,7 @@ module Samagotchi
       #   source, recorded as DEV_SHA (no sha256 check) with "dev": true
       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: {}, session_settings: [], dev: false)
+                scripts_files: {}, context_providers: [], file_descriptions: {}, session_settings: [], session_setting_types: {}, dev: false)
         FileUtils.mkdir_p(@bundle_dir)
         bases_dir = File.join(@bundle_dir, "bases")
         FileUtils.mkdir_p(bases_dir)
@@ -255,6 +255,7 @@ module Samagotchi
         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?
+        manifest_data["session_setting_types"] = session_setting_types.to_h { |k, v| [k.to_s, v.to_s] } unless session_setting_types.to_h.empty?
 
         write_manifest(manifest_data)
       end

data/lib/samagotchi/parent_answers_command.rb

@@ -25,10 +25,11 @@ module Samagotchi
       return [:show] if words.empty?
       return [:usage] if words.size > 1
 
-      word = words.first.downcase
-      return [:set, nil] if word == Guardrails::ParentPolicy::UNSET
-
-      Guardrails::ParentPolicy::ORDER.include?(word) ? [:set, word] : [:usage]
+      case (level = Guardrails::ParentPolicy.parse_level(words.first))
+      when :unset then [:set, nil]
+      when :invalid then [:usage]
+      else [:set, level]
+      end
     end
 
     # Whether the command line +line+ loosens a session whose own value is
@@ -72,8 +73,7 @@ module Samagotchi
       effective = Guardrails::ParentPolicy.for_session(session)
       own = session.parent_answers || "none"
       # A hand-edited value that isn't a level: fail-closed, said here.
-      own = "#{own} (unreadable value, read as hard)" if session.parent_answers &&
-                                                         !Guardrails::ParentPolicy::ORDER.include?(session.parent_answers)
+      own = "#{own} (unreadable value, read as hard)" if Guardrails::ParentPolicy.unknown_level?(session.parent_answers)
       "parent answers: #{effective.name} (this session: #{own}; config.yml #{config.label})"
     end
   end