samagotchi 0.90.0 → 0.92.0

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../../cli/exit"
+require_relative "../../cli/flags"
+require_relative "../../bundle_session_settings"
+require_relative "../../thinking"
+require_relative "sandbox"
+require_relative "run"
+require_relative "trace"
+require_relative "render"
+
+module Samagotchi
+  class BundleCommand
+    module Try
+      # `chi bundle try PATH -p TEXT [options]` (docs/cli.md, "Trying a
+      # bundle"): checks the arguments, then installs PATH in a Sandbox, runs
+      # one turn (Run), stops what the run left (Sandbox#stop_leftovers),
+      # reads its Trace and prints it (Render). BundleCommand parses the
+      # flags (FLAGS, HELP) and hands the result to #run.
+      class Command
+        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
+        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
+        DEFAULT_TIMEOUT = 300
+        # The sandbox's cost-cap bundle setting (--set cost-cap.cap=N).
+        COST_CAP_KEY = "cost-cap.cap"
+        DEFAULT_COST_CAP = 1
+        # The tried bundle's --set values, and the cap for the run.
+        Settings = Data.define(:bundle, :cost_cap, :cost_cap_override)
+
+        def initialize(stdout:, stderr:)
+          @stdout = stdout
+          @stderr = stderr
+        end
+
+        # @param parsed [CLI::Flags::Result] FLAGS' parse of the arguments
+        # @return [Integer] exit status
+        def run(parsed)
+          options = parsed.options
+          path = checked_path(parsed) or return CLI::Exit::USAGE
+          timeout = parse_timeout(options[:timeout]) or return CLI::Exit::USAGE
+          settings = parse_settings(Array(options[:set])) or return CLI::Exit::USAGE
+
+          try(path, options, timeout, settings)
+        end
+
+        private
+
+        def try(path, options, timeout, settings)
+          render = Render.new(stdout: @stdout, stderr: @stderr)
+          sandbox = nil
+          begin
+            sandbox = Sandbox.new(path, bundle_settings: settings.bundle, cost_cap: settings.cost_cap,
+                                        cost_cap_override: settings.cost_cap_override)
+            sandbox.install
+            result = Run.new(sandbox).run(prompt: options[:prompt], options: options, timeout: timeout)
+            # Before the trace: a delegate's worker saves its session as it stops.
+            sandbox.stop_leftovers
+            trace = 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.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 Sandbox::Error => e
+            @stderr.puts e.message
+            e.status
+          ensure
+            if options[:keep] && sandbox
+              sandbox.stop_leftovers
+              render.sandbox(sandbox)
+            end
+            sandbox&.cleanup unless options[:keep]
+          end
+        end
+
+        # @return [String, nil] PATH, or nil after saying what's wrong
+        def checked_path(parsed)
+          options = parsed.options
+          if options[:prompt].nil? || parsed.args.size != 1
+            @stderr.puts "Usage: chi bundle try PATH -p TEXT [options]"
+            return nil
+          end
+          path = parsed.args.first
+          unless File.directory?(path)
+            @stderr.puts "chi bundle try: #{path} isn't a folder"
+            return nil
+          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 nil
+          end
+          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 nil
+          end
+          path
+        end
+
+        def parse_timeout(value)
+          return DEFAULT_TIMEOUT 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
+        end
+
+        # The --set KEY=VALUE pairs, typed as BundleSessionSettings.typed:
+        # cost-cap.cap is the run's cap, the others the tried bundle's.
+        # @return [Settings, nil] nil after saying what's wrong
+        def parse_settings(pairs)
+          bundle = {}
+          cost_cap = DEFAULT_COST_CAP
+          override = false
+          pairs.each do |pair|
+            key, sep, value = pair.partition("=")
+            if key == COST_CAP_KEY && !sep.empty?
+              cost_cap = BundleSessionSettings.typed(value)
+              override = true
+              next if (cost_cap.is_a?(Numeric) && cost_cap >= 0) || cost_cap == false
+
+              @stderr.puts "chi bundle try: --set #{COST_CAP_KEY} takes a non-negative number or off"
+              return nil
+            end
+            unless !sep.empty? && key.match?(BundleSessionSettings::KEY)
+              @stderr.puts "chi bundle try: --set takes KEY=VALUE, not #{pair}"
+              return nil
+            end
+            bundle[key] = BundleSessionSettings.typed(value)
+          end
+          Settings.new(bundle: bundle, cost_cap: cost_cap, cost_cap_override: override)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Samagotchi
+  class BundleCommand
+    module Try
+      # What `chi bundle try` prints of a run: the trace's text lines (on
+      # stdout, or on stderr under the --json report) and --keep's paths.
+      class Render
+        def initialize(stdout:, stderr:)
+          @stdout = stdout
+          @stderr = stderr
+        end
+
+        # The child's stderr (without its Session: line), then the trace.
+        def trace(trace, json:, child_stderr:)
+          error_lines = child_stderr.lines.reject { |line| line.start_with?("Session: ") }
+          @stderr.write(error_lines.join)
+          if json
+            lines(trace, @stderr, include_answer: false)
+            @stdout.puts JSON.generate(trace.to_h.transform_keys(&:to_s))
+          else
+            lines(trace, @stdout, include_answer: true)
+          end
+        end
+
+        def sandbox(sandbox)
+          @stderr.puts "sandbox: #{sandbox.root}"
+          @stderr.puts "debug log: #{File.join(sandbox.state_home, "samagotchi", "samagotchi.log")}"
+        end
+
+        def 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
+      end
+    end
+  end
+end

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

@@ -2,10 +2,20 @@
 
 require "open3"
 require "rbconfig"
+require_relative "../../process_group"
 
 module Samagotchi
   class BundleCommand
     module Try
+      # The sandboxed child chi of `chi bundle try`, in a process group of
+      # its own (ProcessGroup). A --timeout sends it INT (a Ctrl-C: the turn
+      # is saved), then after INTERRUPT_GRACE ProcessGroup.stop stops the
+      # group and the groups its processes started. After any exit the
+      # group is stopped only while something of the child's is still in it
+      # (#stop_stragglers): a group signal to a leader reaped with nothing
+      # left would reach whatever reuses its pid. What left the group and
+      # its parent (a delegate's worker, a task once the child exited) is
+      # Sandbox#stop_leftovers', by the records in the sandbox.
       class Run
         Result = Data.define(:exit_status, :stdout, :stderr, :session_id, :timed_out)
         INTERRUPT_GRACE = 5
@@ -30,18 +40,19 @@ module Samagotchi
               streams = [stdout, stderr]
               stdin.close
               readers = streams.map { |stream| Thread.new { read_stream(stream) } }
-              attach_child(trap_state, pid)
+              attach_child(trap_state, pid, wait)
               timed_out = false
               status = wait_for(wait, timeout)
               if status == :timeout
                 timed_out = true
-                signal_group(pid, "INT")
+                ProcessGroup.signal(pid, "INT")
                 status = wait_for(wait, INTERRUPT_GRACE)
                 if status == :timeout
-                  terminate_group(pid)
+                  ProcessGroup.stop(pid, grace: GROUP_TERM_GRACE, poll: POLL_INTERVAL, stopped: -> { !wait.alive? })
                   status = wait.value
                 end
               end
+              trap_state[:pid] = nil
               out, err = finish_readers(readers, streams)
               code = timed_out ? CLI::Exit::FAILED : process_exit_status(status)
               Result.new(exit_status: code, stdout: out, stderr: err, session_id: err[/^Session: (\S+)/, 1],
@@ -50,7 +61,8 @@ module Samagotchi
           rescue SystemCallError => e
             raise Sandbox::Error, "chi bundle try: couldn't run chi: #{e.message}"
           ensure
-            terminate_group(pid) if pid
+            trap_state[:pid] = nil
+            stop_stragglers(pid) if pid
             close_streams(streams)
             stop_readers(readers)
             restore_traps(old_traps)
@@ -79,12 +91,13 @@ module Samagotchi
         end
 
         def trap_forwarding
-          state = { pid: nil, pending: nil }
+          state = { pid: nil, wait: nil, pending: nil }
           old = {}
           %w[INT TERM].each do |signal|
             old[signal] = Signal.trap(signal) do
               if state[:pid]
-                signal_group(state[:pid], signal)
+                # Not once its waiter reaped it: that group may be gone.
+                ProcessGroup.signal(state[:pid], signal) if state[:wait]&.alive?
               else
                 state[:pending] ||= signal
               end
@@ -93,27 +106,32 @@ module Samagotchi
           [state, old]
         end
 
-        def attach_child(state, pid)
+        def attach_child(state, pid, wait)
+          state[:wait] = wait
           state[:pid] = pid
           pending = state[:pending]
           state[:pending] = nil
-          signal_group(pid, pending) if pending
+          ProcessGroup.signal(pid, pending) if pending
         end
 
         def restore_traps(old)
           old.each { |signal, handler| Signal.trap(signal, handler) }
         end
 
-        def signal_group(pid, signal)
-          Process.kill(signal, -pid)
-        rescue Errno::ESRCH
-          nil
-        end
+        # Stops what is left in the child's group once the child (its
+        # leader) is reaped: a descendant still holding its pipes. Only
+        # while one is in it: no process left means no group, and the pid
+        # may be reused by now. While a member is left the group's id
+        # can't be reused; the reaped leader's pid can, so a group whose
+        # member is the pid itself is someone else's.
+        def stop_stragglers(pid)
+          return unless ProcessGroup.signalable?(pid) && ProcessGroup.group_alive?(pid)
+
+          members = ProcessGroup.process_table.select { |_pid, _ppid, group| group == pid }.map(&:first)
+          return if members.empty? || members.include?(pid)
 
-        def terminate_group(pid)
-          signal_group(pid, "TERM")
-          sleep(GROUP_TERM_GRACE)
-          signal_group(pid, "KILL")
+          ProcessGroup.stop(pid, grace: GROUP_TERM_GRACE, poll: POLL_INTERVAL,
+                                 stopped: -> { !ProcessGroup.group_alive?(pid) })
         end
 
         def read_stream(stream)

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

@@ -6,11 +6,18 @@ require "rbconfig"
 require "tmpdir"
 require "yaml"
 require_relative "../../config"
+require_relative "../../child_env"
 require_relative "../../cli/exit"
-require_relative "../../installed_gem"
+require_relative "../../memory_bundle/system_bundle"
 require_relative "../../memory_bundle"
 require_relative "../../memory_bundle/shas"
+require_relative "../../owner_lock"
+require_relative "../../process_group"
+require_relative "../../sandbox_layout"
+require_relative "../../session"
 require_relative "../../session_manager"
+require_relative "../../tools/task_record"
+require_relative "../../tools/task_runtime"
 
 module Samagotchi
   class BundleCommand
@@ -19,18 +26,46 @@ module Samagotchi
         LIB_DIR = File.expand_path("../../..", __dir__)
         CHI = File.expand_path("../../../../bin/chi", __dir__)
         SHIPPED_DIR = MemoryBundle::SourceNormalizer::SHIPPED_DIR
+        # The config.yml sections the sandbox drops (and their SAMAGOTCHI_<SECTION>_* env forms); context:
+        # loses only its sources: (#write_config).
         CONFIG_DENYLIST = %w[
           bundles hooks guardrails memories append_system_prompt recap session log web update kitty tmux broadcast
-          context_sources
         ].freeze
         CONFIG_DENYLIST_ENV_PREFIXES = CONFIG_DENYLIST.map do |section|
           prefix = if section == "guardrails"
-                     SessionManager::GUARDRAILS_ENV_PREFIX.delete_suffix("_")
+                     ChildEnv::GUARDRAILS_PREFIX.delete_suffix("_")
                    else
                      "SAMAGOTCHI_#{section.upcase}"
                    end
           prefix
         end.freeze
+        # `chi bundle install PATH --force` for each PATH in ARGV, in one
+        # process (bin/chi's start, once): an install that fails prints
+        # what it printed and exits with its status; the ones before it
+        # print nothing.
+        INSTALL_SCRIPT = <<~RUBY
+          require "stringio"
+          require "samagotchi/utf8_default"
+          Samagotchi::Utf8Default.apply!
+          require "samagotchi/config"
+          Samagotchi::ConfigFile.load!
+          require "samagotchi"
+          require "samagotchi/bundle_command"
+          ARGV.each do |path|
+            out = StringIO.new
+            err = StringIO.new
+            status = Samagotchi::BundleCommand.new(["install", path, "--force"], stdout: out, stderr: err).run
+            next if status.zero?
+
+            $stdout.write(out.string)
+            $stderr.write(err.string)
+            exit(status)
+          end
+        RUBY
+        # How long a leftover worker or task gets after TERM (a worker saves
+        # its session) before ProcessGroup.stop KILLs it.
+        LEFTOVER_GRACE = 3.0
+        LEFTOVER_POLL = 0.05
         class Error < StandardError
           attr_reader :status
 
@@ -40,7 +75,7 @@ module Samagotchi
           end
         end
 
-        attr_reader :root, :config_home, :state_home, :work_dir, :manifest
+        attr_reader :root, :config_home, :state_home, :work_dir
 
         def initialize(path, bundle_settings: {}, cost_cap: 1, cost_cap_override: false)
           @path = File.realpath(path)
@@ -48,12 +83,11 @@ module Samagotchi
           @cost_cap = cost_cap
           @cost_cap_override = cost_cap_override
           read_manifest
-          @root = File.realpath(Dir.mktmpdir("chi-bundle-try-"))
-          @config_home = File.join(root, "config")
-          @state_home = File.join(root, "state")
-          @work_dir = File.join(root, "work")
-          [config_home, state_home, work_dir].each { |dir| FileUtils.mkdir_p(dir) }
-          @work_dir = File.realpath(@work_dir)
+          @layout = SandboxLayout.create("chi-bundle-try-")
+          @root = @layout.root
+          @config_home = @layout.config_home
+          @state_home = @layout.state_home
+          @work_dir = @layout.work_dir
           write_config
           @child_env = build_child_env
         rescue StandardError
@@ -63,20 +97,43 @@ module Samagotchi
 
         def child_env = @child_env.dup
 
+        # Installs the tried bundle, then the shipped guardrails and
+        # cost-cap (unless it is one of them), each as `chi bundle install
+        # PATH --force` in one child chi with the sandbox's environment.
+        # @return [MemoryBundle::Manifest]
+        # @raise [Error] what the first install that failed printed
         def install
-          install_path(@path)
-          %w[guardrails cost-cap].each do |name|
-            next if @manifest.name == name
-
-            install_path(File.join(SHIPPED_DIR, name))
+          paths = [@path] + %w[guardrails cost-cap].reject { |name| @manifest.name == name }
+                                                     .map { |name| File.join(SHIPPED_DIR, name) }
+          out, err, status = Open3.capture3(child_env, RbConfig.ruby, "-I", LIB_DIR, "-e", INSTALL_SCRIPT, *paths,
+                                            chdir: work_dir)
+          unless status.success?
+            message = [out, err].reject(&:empty?).join("\n").strip
+            raise Error, "chi bundle try: #{message.empty? ? "bundle install failed" : message}"
           end
           @manifest
         end
 
         def cleanup
+          stop_leftovers
           FileUtils.rm_rf(root) if root && File.exist?(root)
         end
 
+        # Stops what the run started that outlives its child chi: the
+        # workers of its delegates (they leave the child's process tree,
+        # SessionManager.detach_from_spawner) and its tasks (a group of
+        # their own each, reparented once the child exits). Found by their
+        # records in the sandbox, so nothing outside it: a session's lock
+        # held by a group leader, a running task's record whose pid still
+        # leads its group and started when the record says (#same_process?). Workers
+        # first: one may start a task as it stops.
+        def stop_leftovers
+          return unless root && File.directory?(root)
+
+          leftover_workers.each { |pid| stop_group(pid) }
+          leftover_tasks.each { |pid| stop_group(pid) }
+        end
+
         private
 
         def write_config
@@ -92,9 +149,7 @@ module Samagotchi
           data["bundles"][@manifest.name] ||= {}
           data["bundles"][@manifest.name].merge!(@bundle_settings)
           data["bundles"]["cost-cap"]["cap"] = @cost_cap if @cost_cap_override
-          path = File.join(config_home, "samagotchi", "config.yml")
-          FileUtils.mkdir_p(File.dirname(path))
-          File.write(path, YAML.dump(data))
+          @layout.write_config(data)
         end
 
         def read_manifest
@@ -121,36 +176,60 @@ module Samagotchi
           raise Error, "chi bundle try: manifest.yml is not valid YAML (#{e.message})"
         end
 
-        def install_path(path)
-          out, err, status = Open3.capture3(child_env, RbConfig.ruby, "-I", LIB_DIR, CHI,
-                                            "bundle", "install", path, "--force", chdir: work_dir)
-          return if status.success?
+        def leftover_workers
+          sessions = File.join(state_home, Session::STATE_SUBDIR)
+          Dir.glob(File.join(sessions, "*", OwnerLock::FILE)).filter_map do |lock|
+            pid = OwnerLock.owner(File.dirname(lock))&.pid
+            pid if ProcessGroup.leader?(pid)
+          end
+        end
+
+        def leftover_tasks
+          pattern = File.join(work_dir, Tools::TaskRuntime::TASKS_DIR, "*", Tools::TaskRuntime::METADATA_FILENAME)
+          Dir.glob(pattern).filter_map do |file|
+            record = Tools::TaskRecord.from_file(JSON.parse(File.read(file)))
+            record.pid if record&.running? && same_process?(record)
+          rescue JSON::ParserError, SystemCallError
+            nil
+          end
+        end
+
+        # Stricter than TaskRuntime.chis_group?: a record with no start time
+        # (a hand-over not adopted yet) or a start time that can't be read
+        # now is skipped, never a group whose leader may reuse the pid.
+        def same_process?(record)
+          started = record.pid_started
+          return false unless started && ProcessGroup.signalable?(record.pid)
+
+          ProcessGroup.start_time(record.pid) == started && ProcessGroup.leader?(record.pid)
+        end
 
-          message = [out, err].reject(&:empty?).join("\n").strip
-          raise Error, "chi bundle try: #{message.empty? ? "bundle install failed" : message}"
+        def stop_group(pid)
+          ProcessGroup.stop(pid, grace: LEFTOVER_GRACE, poll: LEFTOVER_POLL)
+        rescue ArgumentError, SystemCallError
+          nil
         end
 
+        # The user's environment (their hosts and keys) minus what no child
+        # chi takes from its spawner (ChildEnv), the worker markers, this
+        # chi's log and test settings, and the env forms of the config
+        # sections the sandbox drops.
         def build_child_env
-          env = ENV.to_h
-          SessionManager::SESSION_MARKER_ENV.each { |key| env.delete(key) }
+          env = ChildEnv.scrub(ENV.to_h)
           env.delete("SAMAGOTCHI_LOG_FILE")
           env.delete("SAMAGOTCHI_LOG_DISABLE")
-          env.delete("SAMAGOTCHI_SKIP_SYSTEM_BUNDLE")
+          env.delete(MemoryBundle::SystemBundle::SKIP_ENV)
           env.delete("SAMAGOTCHI_ENV") if env["SAMAGOTCHI_ENV"] == "test"
-          env.delete("SAMAGOTCHI_INSTALLED_VERSION")
           env.delete_if do |key, _|
-            key.start_with?(SessionManager::WORKER_ENV_PREFIX) || key == SessionManager::BOOT_FALLBACK_ENV ||
+            key.start_with?(ChildEnv::WORKER_PREFIX) || key == SessionManager::BOOT_FALLBACK_ENV ||
               CONFIG_DENYLIST_ENV_PREFIXES.any? { |prefix| key == prefix || key.start_with?("#{prefix}_") }
           end
           env.merge!(
             "HOME" => Dir.home,
             "SAMAGOTCHI_KEYCHAIN" => "on",
-            "XDG_CONFIG_HOME" => config_home,
-            "XDG_STATE_HOME" => state_home,
-            "SAMAGOTCHI_RECAP_ENABLED" => "false",
-            "SAMAGOTCHI_CACHE_WARMUP" => "off"
+            **@layout.env
           )
-          env.merge!(InstalledGem.unbundled_env_changes(env)) if InstalledGem.spec
+          env.merge!(ChildEnv.unbundled(env))
           env
         end
       end