samagotchi 0.91.0 → 0.92.0

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

@@ -15,6 +15,9 @@
 #   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
+# A cap reads as a number (3, .5, 1e1, "$2" as text too); one that doesn't
+# (cap: five) warns the user once and the next key is used, so a typo is
+# never a silent "no cap".
 #
 # 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
@@ -32,12 +35,15 @@ class Plugin
   # spends more, Stop denies; under hard a parent may only Stop.
   EFFECTS = { "Continue" => :spend, "Stop" => :deny }.freeze
   WARN_AT = 0.8
+  # A cap as text: 3, 2.5, .5, 1e1, -1 (a negative is none), after a "$".
+  NUMBER = /\A-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[-+]?\d+)?\z/i
 
   def initialize(_settings)
     @mutex = Mutex.new
     @resolved = nil        # {session:, cap:, step:}
     @warned = nil          # [session id, cap] the share warning was given for
     @unknown_warned = nil  # the session id the "can't be enforced" notice was given for
+    @unread_warned = nil   # the session id the "isn't a number" notice was given for
   end
 
   def register(chi)
@@ -50,13 +56,39 @@ class Plugin
     end
   end
 
-  # The cap in USD (a positive Float) or nil (none, 0, off, false).
+  # The cap in USD (a positive Float) or nil (none, 0, off, false, or a
+  # value that isn't a number: .readable? tells them apart).
   def self.amount(value)
+    number = number(value)
+    number&.positive? ? number : nil
+  end
+
+  # +value+ as a finite Float (a number, or text NUMBER reads after a "$"),
+  # else nil. "5." gets its 0 first (.float_text: Ruby 3.3's Float wants
+  # one); 1e400 (Infinity) is no cap anyone reaches.
+  def self.number(value)
     number = case value
              when Numeric then value.to_f
-             when String then value.strip.delete_prefix("$").then { |s| s.match?(/\A\d+(\.\d+)?\z/) ? s.to_f : nil }
+             when String
+               text = value.strip.delete_prefix("$")
+               Float(float_text(text)) if text.match?(NUMBER)
              end
-    number&.positive? ? number : nil
+    number if number&.finite?
+  end
+
+  # A NUMBER as Float reads it on every Ruby: a bare point ("5.", "5.e1")
+  # gets a 0 after it.
+  def self.float_text(text) = text.sub(/\.(?=e|\z)/i, ".0")
+
+  # Whether +value+ reads as a cap or as none: a number (text too), off,
+  # false or nil; not "five", true or a list.
+  def self.readable?(value)
+    case value
+    when false, nil then true
+    when Numeric then value.finite?
+    when String then value.strip.casecmp?("off") || !number(value).nil?
+    else false
+    end
   end
 
   # Cents, or up to four decimals under $0.10, so a small cap (/cap 0.003)
@@ -71,6 +103,7 @@ class Plugin
 
   def check(ctx)
     resolved = resolve(ctx)
+    unreadable(ctx, resolved)
     cap = resolved[:cap]
     return unless cap
 
@@ -101,6 +134,16 @@ class Plugin
                level: :warn)
   end
 
+  # Once per session: the settings whose cap didn't read, and what is used.
+  def unreadable(ctx, resolved)
+    bad = resolved[:unreadable]
+    return if bad.nil? || bad.empty? || !first_time?(:@unread_warned, resolved[:session])
+
+    named = bad.map { |key, value| "#{key}: #{value.inspect}" }.join(" and ")
+    used = resolved[:cap] ? "using #{resolved[:key]}: (#{money(resolved[:cap])})" : "no cap"
+    ctx.notify("cost-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{used}", level: :warn)
+  end
+
   def at_cap(ctx, resolved, cost)
     cap = resolved[:cap]
     raised = raised_cap(cap, resolved[:step] || cap, cost.total)
@@ -148,12 +191,13 @@ class Plugin
       save(ctx, session, "cap" => nil)
       return "cost-cap: no cap for this session"
     end
-    value = arg.match?(/\A\$?\d+(\.\d+)?\z/) ? self.class.amount(arg) : nil
+    value = self.class.amount(arg)
     return USAGE unless value
 
     save(ctx, session, "cap" => value, "step" => value)
     "cost-cap: cap set to #{money(value)} (#{money(ctx.cost.total)} spent)"
   rescue StandardError => e
+    ctx.log.warn(:cap_command_failed, error: "#{e.class}: #{e.message}")
     "cost-cap: #{e.message}"
   end
 
@@ -194,16 +238,17 @@ class Plugin
     nil
   end
 
+  # The first of cap:, child: (a delegate's) and default: that is set and
+  # reads (.readable?); the ones set that don't read are kept for the
+  # notice (#unreadable).
   def configured(ctx)
     settings = ctx.settings
-    return { cap: nil, step: nil } unless %w[cap default child].any? { |key| settings.key?(key) }
-
-    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 }
+    keys = %w[cap child default].select { |key| settings.key?(key) }
+    keys.delete("child") if keys.include?("child") && !ctx.delegate?
+    bad = keys.reject { |key| self.class.readable?(settings[key]) }
+    key = (keys - bad).first
+    cap = key && self.class.amount(settings[key])
+    { cap: cap, step: cap, key: key, unreadable: bad.to_h { |name| [name, settings[name]] } }
   end
 
   def warn_share(ctx)

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

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

data/lib/samagotchi/child_env.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "installed_gem"
+require_relative "installed_versions"
+
+module Samagotchi
+  # What a chi process another chi starts must not take from its spawner's
+  # environment, in one place: a session's worker (SessionManager's
+  # spawn_options) and `chi bundle try`'s sandboxed child
+  # (BundleCommand::Try::Sandbox) both scrub these. Each adds its own policy
+  # on top (the worker passes the CLI settings and the log file; try drops
+  # the user's config sections too).
+  module ChildEnv
+    # The spawner's guardrails settings: never a child's (docs/guardrails.md).
+    GUARDRAILS_PREFIX = "SAMAGOTCHI_GUARDRAILS_"
+    # A worker's own markers (SessionManager::WORKER_PROCESS_ENV, ...).
+    WORKER_PREFIX = "SAMAGOTCHI_WORKER_"
+    # The markers a session's execute and tasks export
+    # (Tools::Builtins.parent_env): that session's, not a child chi's.
+    SESSION_MARKERS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING
+                         SAMAGOTCHI_SESSION_REASONING_HISTORY].freeze
+
+    module_function
+
+    # The keys of +env+ a child chi must not inherit: the guardrails
+    # settings, the session markers and a smoke's fake "newest installed"
+    # (InstalledVersions::ENV_KEY, for the spawner's notices only).
+    # @return [Array<String>]
+    def spawner_keys(env = ENV)
+      env.each_key.select { |key| key.start_with?(GUARDRAILS_PREFIX) } + SESSION_MARKERS + [InstalledVersions::ENV_KEY]
+    end
+
+    # #spawner_keys mapped to nil: Process.spawn unsets a key mapped to nil.
+    # @return [Hash{String=>nil}]
+    def unset(env = ENV) = spawner_keys(env).to_h { |key| [key, nil] }
+
+    # +env+ without #spawner_keys (a copy).
+    # @param env [Hash]
+    # @return [Hash]
+    def scrub(env) = env.except(*spawner_keys(env))
+
+    # In gem mode, what Bundler changed in +env+ mapped back
+    # (InstalledGem.unbundled_env_changes): a child activates the installed
+    # gem itself rather than inherit this app's bundle. {} in a checkout.
+    # @return [Hash{String=>String, nil}]
+    def unbundled(env = ENV.to_h)
+      InstalledGem.spec ? InstalledGem.unbundled_env_changes(env) : {}
+    end
+  end
+end

data/lib/samagotchi/engine.rb

@@ -1828,8 +1828,9 @@ module Samagotchi
     #   that put the turn's first message in the session already (a context
     #   wake's note) names it with this id
     #
-    # An Interrupt (SIGINT) cancels the turn: the pre-turn conversation plus
-    # the prompt is kept in the session and :turn_canceled is emitted, then the
+    # An Interrupt (SIGINT) cancels the turn: what it got to is kept in the
+    # session as after a Stop (the prompt, the loop's finished tool
+    # iterations, a cancel note) and :turn_canceled is emitted, then the
     # Interrupt is re-raised so the caller still decides whether to exit. One
     # after the turn's end event (in its after_turn/session_end hooks) is
     # only re-raised: the turn already ended; so is any error there. Any
@@ -1856,14 +1857,14 @@ module Samagotchi
         complete_turn(turn, result)
         warm_up_next_turn(turn, result)
         result
-      rescue Interrupt
+      rescue Interrupt => e
         # After the end event (in the after_turn/session_end hooks) the
         # turn is over: no second ending, the answer stays.
         raise if turn.ended
 
         turn.controller.cancel!(:ctrl_c)
         end_turn(turn, "canceled") do |seconds|
-          [ctrl_c_messages(turn, seconds), { type: :turn_canceled, cancellation_reason: :ctrl_c, duration_ms: (seconds * 1000).round }]
+          [ctrl_c_messages(turn, e, seconds), { type: :turn_canceled, cancellation_reason: :ctrl_c, duration_ms: (seconds * 1000).round }]
         end
         raise
       rescue StandardError => e
@@ -2263,17 +2264,26 @@ module Samagotchi
     end
     private :kept_messages
 
-    # A Ctrl-C keeps the turn's messages so far with a cancel note (nil
-    # before there are any). Only the pre-turn messages survive here, so
-    # tasks this turn started are missed (plan wait-stop §6).
-    def ctrl_c_messages(turn, seconds)
-      return nil unless turn.messages
+    # A Ctrl-C keeps the loop's conversation so far, as a Stop does (its
+    # finished tool iterations, every call answered: ToolResponse.run_batch),
+    # else the turn's messages so far (it came before the loop), with a
+    # cancel note naming the tasks still running; nil before there are any.
+    def ctrl_c_messages(turn, interrupt, seconds)
+      kept = loop_conversation(interrupt) || turn.messages
+      return nil unless kept
 
-      note = TurnNote.cancelled(:ctrl_c, seconds: seconds, running_tasks: Tools::TaskRuntime.running_created_in(turn.messages))
-      TurnNote.replace_trailing(turn.messages, note)
+      note = TurnNote.cancelled(:ctrl_c, seconds: seconds, running_tasks: Tools::TaskRuntime.running_created_in(kept))
+      TurnNote.replace_trailing(kept, note)
     end
     private :ctrl_c_messages
 
+    # The conversation the loop had built when +error+ ended the turn
+    # (LLM::FailedTurn), or nil.
+    def loop_conversation(error)
+      error.partial_conversation if error.respond_to?(:partial_conversation) && error.partial_conversation.is_a?(Array)
+    end
+    private :loop_conversation
+
     # A failure keeps the loop's partial conversation (else the turn's
     # messages so far) with a failed note; nil when the turn never reached
     # the model. The model reads why on its next turn. A turn that got to
@@ -2283,7 +2293,7 @@ module Samagotchi
     # turn (TurnFlow#prompt_turn_failed), and roll back the others, with a
     # note of their own; -p --non-interactive keeps what this keeps.
     def failed_messages(turn, error)
-      kept = error.respond_to?(:partial_conversation) && error.partial_conversation.is_a?(Array) ? error.partial_conversation : turn.messages
+      kept = loop_conversation(error) || turn.messages
       return nil unless kept
 
       steps = LLM::FailedTurn.progress(turn.session.messages, kept)

data/lib/samagotchi/hooks/registry.rb

@@ -93,6 +93,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)

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

@@ -6,6 +6,7 @@ require "json"
 require_relative "cli/exit"
 require_relative "pending_question"
 require_relative "session"
+require_relative "turn_checkpoint"
 require_relative "guardrails/parent_policy"
 
 module Samagotchi
@@ -339,6 +340,8 @@ module Samagotchi
     end
 
     def no_reply_line(result, session_id = nil, strategy: nil)
+      return command_line(result) if result.origin == TurnCheckpoint::COMMAND_ORIGIN
+
       case result.outcome
       when "failed" then failed_line(result)
       when "canceled"
@@ -360,6 +363,15 @@ module Samagotchi
       end
     end
 
+    # A file-delivered session command's outcome: no turn ran for it.
+    def command_line(result)
+      case result.outcome
+      when "completed" then "the command ran (no turn)"
+      when "failed" then "the command failed"
+      else "the command was refused (#{result.cancel_reason || "canceled"})"
+      end
+    end
+
     # A failed turn's line; one whose work stayed says so, so the task isn't
     # sent again over what it changed.
     def failed_line(result)

data/lib/samagotchi/reply_wait.rb

@@ -59,8 +59,11 @@ module Samagotchi
     #   :canceled and :timeout
     # @!attribute turn_id [String, nil] the id of the turn this result is
     #   about, when known
+    # @!attribute origin [String, nil] "command" for a :no_reply that a
+    #   file-delivered session command settled (no turn ran:
+    #   TurnCheckpoint.record_command_outcome); nil otherwise
     Result = Struct.new(:status, :text, :file, :question, :outcome, :limit, :error_kind, :retryable, :cancel_reason,
-                        :stopped_by, :kept_steps, :session, :turn_id, keyword_init: true)
+                        :stopped_by, :kept_steps, :session, :turn_id, :origin, keyword_init: true)
 
     module_function
 
@@ -163,7 +166,8 @@ module Samagotchi
         # command finished without a turn. After the reply check: a worker
         # killed between writing the reply and its idle save left the reply.
         if turn && (settled = TurnCheckpoint.settled_turn(session_dir, turn))
-          return Result.new(status: :no_reply, outcome: settled.outcome, session: session, **settled.stop_facts)
+          return Result.new(status: :no_reply, outcome: settled.outcome, session: session, origin: settled.origin,
+                            **settled.stop_facts)
         end
 
         case session.status

data/lib/samagotchi/sandbox_layout.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+require "yaml"
+require_relative "paths"
+
+module Samagotchi
+  # The temp folders a sandboxed chi runs in, shared by `chi bundle try`'s
+  # child (BundleCommand::Try::Sandbox) and the test kit
+  # (Testing::Sandbox): one realpath'd root holding config/, state/,
+  # work/ and whatever else the sandbox wants, the XDG pair pointing at
+  # them, and the switches every sandbox turns off. Where the environment
+  # goes is each sandbox's own: try builds its child's Hash, the kit
+  # changes ENV.
+  class SandboxLayout
+    DIRS = %w[config state work].freeze
+    # No recap request and no cache warm-up request in a sandbox.
+    QUIET_ENV = { "SAMAGOTCHI_RECAP_ENABLED" => "false", "SAMAGOTCHI_CACHE_WARMUP" => "off" }.freeze
+
+    # A new temp root (Dir.mktmpdir +prefix+, its realpath) with DIRS and
+    # +extra+ folders in it.
+    # @return [SandboxLayout]
+    def self.create(prefix, extra: [])
+      root = File.realpath(Dir.mktmpdir(prefix))
+      (DIRS + extra).each { |dir| FileUtils.mkdir_p(File.join(root, dir)) }
+      new(root)
+    rescue StandardError
+      FileUtils.rm_rf(root) if root
+      raise
+    end
+
+    # @return [String]
+    attr_reader :root
+
+    def initialize(root)
+      @root = root
+    end
+
+    def dir(name) = File.join(root, name)
+
+    def config_home = dir("config")
+
+    def state_home = dir("state")
+
+    def work_dir = dir("work")
+
+    # XDG_CONFIG_HOME and XDG_STATE_HOME at the sandbox's, and QUIET_ENV.
+    # @return [Hash{String=>String}]
+    def env = { "XDG_CONFIG_HOME" => config_home, "XDG_STATE_HOME" => state_home }.merge(QUIET_ENV)
+
+    # config.yml under +config_home+ (default the sandbox's): a Hash (as
+    # YAML) or YAML text.
+    # @return [String] its path
+    def write_config(data, config_home: self.config_home)
+      path = File.join(config_home, Paths::APP_DIR, "config.yml")
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, data.is_a?(String) ? data : YAML.dump(data))
+      path
+    end
+
+    def remove
+      FileUtils.rm_rf(root)
+    end
+  end
+end

data/lib/samagotchi/send_command.rb

@@ -93,9 +93,9 @@ module Samagotchi
         --set BUNDLE.KEY=VALUE
                     (--new) a bundle setting for this session, over
                     config.yml's bundles: (repeatable; a key its bundle's
-                    manifest lists in session_settings:; 3, 2.5, true,
-                    false and off are typed, the rest is text:
-                    --set cost-cap.cap=3)
+                    manifest lists in session_settings:; numbers (3,
+                    .5) and booleans (true, off, no) are typed, the
+                    rest is text: --set cost-cap.cap=3)
         --parent-answers LEVEL
                     (--new) what a parent agent may answer on its
                     questions: hard, standard or soft, only stricter than