samagotchi 0.131.0 → 0.133.0

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -107,7 +107,7 @@ class Plugin
       @next_id = 0
       @dead = nil
       @closing = false
-      @stdin, @stdout, @stderr, @wait = Open3.popen3(env.to_h { |k, v| [k.to_s, v.to_s] }, *command,
+      @stdin, @stdout, @stderr, @wait = Open3.popen3(env.to_h { |k, v| [k.to_s, v&.to_s] }, *command,
                                                      chdir: cwd, pgroup: true)
       @pid = @wait.pid
       start_watchdog
@@ -433,7 +433,7 @@ class Plugin
   def spawn(server, ctx)
     cancelled = -> { ctx.cancelled? }
     client = server.client = Client.new(
-      server.command, env: server.env, cwd: server.cwd,
+      server.command, env: server_env(server), cwd: server.cwd,
                       log: ->(event, **fields) { ctx.log.debug("mcp_#{event}", server: server.name, **fields) },
                       on_exit: ->(reason) { exited(server, reason, ctx) },
                       on_notification: lambda { |method, _params|
@@ -454,6 +454,13 @@ class Plugin
     client
   end
 
+  # A server's env: the session's project env (the worker's mise env, on a
+  # chi that has it: Samagotchi::ProjectEnv) under the server's own keys.
+  def server_env(server)
+    project = defined?(Samagotchi::ProjectEnv) ? Samagotchi::ProjectEnv.current.env : {}
+    project.merge(server.env)
+  end
+
   # The first sentence of initialize's instructions (at most
   # DESCRIPTION_CHARS), nil when there are none.
   def info_of(result)
@@ -494,7 +501,7 @@ class Plugin
       return nil unless lock.flock(File::LOCK_EX | File::LOCK_NB)
 
       cancelled = -> { ctx.cancelled? }
-      client = Client.new(server.command, env: server.env, cwd: server.cwd,
+      client = Client.new(server.command, env: server_env(server), cwd: server.cwd,
                                           log: ->(event, **fields) { ctx.log.debug("mcp_#{event}", server: server.name, **fields) })
       begin
         initialized = client.request("initialize", { protocolVersion: PROTOCOL_VERSION, capabilities: {},

data/lib/samagotchi/bundles/model-notes/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: model-notes
-version: 0.1.0
+version: 0.2.0
 scope: system
 description: "Reviewed model notes: working habits a model family needs, loaded into the prompt only for the models each note's models: line names"
 trust_level: reviewed
@@ -9,3 +9,6 @@ files:
   model_notes_deepseek.md:
     sha256: sha256:0b07e40edc1a3d4a3ad6bea08d9b338913f78cab19a5809bcf4593f459f9bc5e
     description: "DeepSeek V4 working habits: explore briefly then act, commit per item, stop digging, memory_read for memories, file tools over heredocs"
+  model_notes_tone.md:
+    sha256: sha256:e47a93dc3b3cb78a9bd3eb7f04ef1c4d2a30b4a7c0110a66e1e3a26e363827ca
+    description: "Concise answers for every model (models: *): answer first, no preambles or closing offers"

data/lib/samagotchi/bundles/model-notes/model_notes_tone.md

@@ -0,0 +1,3 @@
+models: *
+How to write answers:
+- Answer first, in plain words. Skip preambles, restating the question and closing offers. Use a list only for steps or several parallel items.

data/lib/samagotchi/bundles/model-notes/notes/README.md

@@ -35,3 +35,17 @@ bundle itself.
   The dates and tasks differ, so this is a hint, not an A/B: an A/B is the same kind of task with the note on and
   muted (`chi send --new --mute model_notes_deepseek`). The shipped text is shorter than the one measured (795
   characters against 1,519) and keeps its habits.
+
+## model_notes_tone
+
+- **models:** `*`: every model. It stacks on a family's note (`spec/model_ids.yml` `expected_overlaps`).
+- **Origin, 2026-10-29:** chi's prompt has no style guidance, so each model talks in its own voice and answers run
+  long. A `/tone` bundle (presets, a session command) was built and parked; the user chose the lighter way, a model
+  note, with the gentlest text: only the anti-padding part of the concise preset ("leave out what went as expected"
+  was dropped: it can hide useful confirmations).
+- **Approved:** the text as shipped, by the user, 2026-10-29 (after the check below); ships in model-notes (the `dev`
+  profile) first, `core` later only after more evidence (other model families, a week of the user's own use).
+- **Evidence:** a with/without check on the local Qwen3.8 Flash Next (Splash), 5 tasks (4 questions about this repo,
+  1 small code edit), one run each, `chi --non-interactive` with isolated state: answers 12.5k → 10.1k characters
+  (−19%), 4 of 5 shorter; openings more direct, closing summaries gone; nothing a task needed was lost (dropped: one
+  worked glob example, one aside about the model's own fixed mistake). N=1 per task: a direction, not a measurement.

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

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

data/lib/samagotchi/cache_confirm.rb

@@ -12,6 +12,9 @@ module Samagotchi
     # The costs worth asking about (Thinking.cache_cost,
     # ReasoningHistory.cache_cost); :tail and nil are not.
     COSTLY = %i[full provider history].freeze
+    # Thread.current key: whether the plugin command running on this
+    # thread may ask (#asking).
+    ASKING = :samagotchi_cache_confirm_asking
 
     # The line that applies a change, and the question the reply ends with.
     Confirm = Data.define(:line, :text) do
@@ -42,6 +45,21 @@ module Samagotchi
       changed && history && COSTLY.include?(cost)
     end
 
+    # Run +block+ as a plugin command whose sender can answer a confirm
+    # (+flag+: SessionCommands#run's confirm, false once the line has
+    # --yes): Plugin::Context#cache_confirm asks only inside it, on this
+    # thread. Nests; threads the block starts don't inherit it.
+    def asking(flag)
+      previous = Thread.current[ASKING]
+      Thread.current[ASKING] = flag ? true : false
+      yield
+    ensure
+      Thread.current[ASKING] = previous
+    end
+
+    # Whether the plugin command on this thread may ask (#asking).
+    def asking? = Thread.current[ASKING] == true
+
     # Whether a cache-changing command should ask, and its reply line.
     # Kept independent of any UI so commands and plugins can share it.
     # @param line [String] the full command line without --yes

data/lib/samagotchi/chi_home.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "open3"
+require "rbconfig"
+require "time"
+require_relative "atomic_file"
+require_relative "installed_gem"
+require_relative "log"
+require_relative "paths"
+require_relative "version"
+
+module Samagotchi
+  # The chi home: the one Ruby (and its gem path) every chi launch boots,
+  # whoever launches it (a terminal on another Ruby, chi web, the macOS
+  # helper under launchd). Recorded in home.json under the config dir
+  # ($XDG_CONFIG_HOME/samagotchi/home.json) by `chi home set`, or once, the
+  # first time, by chi bootstrap or chi update (#record_first!); never
+  # overwritten implicitly.
+  #
+  # One mechanism (docs/architecture.md, "How chi launches itself"):
+  # Record#boot_argv puts `Gem.paths = {…}` at the front of a `ruby -e`
+  # boot string, so no GEM_HOME/GEM_PATH ever goes into an environment
+  # (the tools a worker runs keep the spawner's, or the project's). Every
+  # launch site asks #current at launch time and keeps its own argv when
+  # there is no usable home.
+  module ChiHome
+    FILE = "home.json"
+    # What a launch outside a worker boots: the newest chi in the home,
+    # run as its own `chi` executable (ARGV after the "--").
+    CHI_BOOT = "gem 'samagotchi', '>= 0.a'; load Gem.bin_path('samagotchi', 'chi')"
+    # Where `mise` usually is when PATH doesn't have it (launchd's bare PATH).
+    MISE_DIRS = ["/opt/homebrew/bin", "/usr/local/bin", File.join(Dir.home, ".local", "bin")].freeze
+    # What a probe of another Ruby must not inherit: they would move it off
+    # its own gems.
+    PROBE_UNSET = %w[GEM_HOME GEM_PATH RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH].freeze
+    PROBE = "require 'json'; print JSON.generate('ruby' => RbConfig.ruby, 'gem_home' => Gem.dir, " \
+            "'gem_path' => Gem.path.join(File::PATH_SEPARATOR))"
+    GEMSPEC = /\Asamagotchi-(#{Gem::Version::VERSION_PATTERN})\.gemspec\z/
+
+    class Invalid < StandardError
+    end
+
+    # home.json's fields. +gem_path+ is what `Gem.paths=` takes (dirs joined
+    # by File::PATH_SEPARATOR); +mise+ an absolute path or nil.
+    Record = Data.define(:ruby, :gem_home, :gem_path, :mise, :set_at, :set_by_version) do
+      # home.json's (or a probe's) fields, checked: ruby, gem_home and every
+      # gem_path entry absolute paths, mise an absolute path or nil.
+      # @raise [Invalid]
+      def self.from_h(hash)
+        fields = members.to_h { |key| [key, hash[key.to_s]] }
+        %i[ruby gem_home gem_path].each do |key|
+          value = fields[key]
+          raise Invalid, "#{key} is missing" unless value.is_a?(String) && !value.empty?
+        end
+        raise Invalid, "ruby is not an absolute path" unless fields[:ruby].start_with?("/")
+        raise Invalid, "gem_home is not an absolute path" unless fields[:gem_home].start_with?("/")
+
+        dirs = fields[:gem_path].split(File::PATH_SEPARATOR)
+        raise Invalid, "gem_path has a relative entry" unless dirs.all? { |dir| dir.start_with?("/") }
+
+        mise = fields[:mise]
+        raise Invalid, "mise is not an absolute path" unless mise.nil? || (mise.is_a?(String) && mise.start_with?("/"))
+
+        new(**fields)
+      end
+
+      def to_h = members.to_h { |key| [key.to_s, public_send(key)] }
+      def gem_dirs = gem_path.split(File::PATH_SEPARATOR).reject(&:empty?)
+      def spec_dirs = gem_dirs.map { |dir| File.join(dir, "specifications") }
+      # The home Ruby's own gem command (its bindir, not a shim).
+      def gem_bin = File.join(File.dirname(ruby), "gem")
+      def ruby_ok? = File.file?(ruby) && File.executable?(ruby)
+
+      # The samagotchi versions installed in the home, newest last.
+      # @return [Array<Gem::Version>]
+      def versions
+        spec_dirs.flat_map do |dir|
+          Dir.children(dir).filter_map { |name| GEMSPEC.match(name)&.[](1) }
+        rescue SystemCallError
+          []
+        end.select { |v| Gem::Version.correct?(v) }.map { |v| Gem::Version.new(v) }.uniq.sort
+      end
+
+      def newest_version = versions.last
+
+      # Whether a gem named +name+ is installed in the home.
+      def gem?(name)
+        spec_dirs.any? { |dir| !Dir.glob(File.join(dir, "#{name}-*.gemspec")).empty? }
+      end
+
+      # The `Gem.paths =` line every boot starts with: string literals only
+      # (String#inspect escapes `#{`), no env read.
+      def prelude = "Gem.paths = {'GEM_HOME' => #{gem_home.inspect}, 'GEM_PATH' => #{gem_path.inspect}}"
+
+      # [ruby, "-e", "<prelude>; <run>"]: a site appends "--" and its args
+      # when +run+ runs chi's executable (CHI_BOOT).
+      def boot_argv(run:) = [ruby, "-e", "#{prelude}; #{run}"]
+
+      # Whether this process runs on the home: its Ruby and its gem dir.
+      def running_here?(ruby: RbConfig.ruby, gem_dir: Gem.dir)
+        ChiHome.real(ruby) == ChiHome.real(self.ruby) && ChiHome.real(gem_dir) == ChiHome.real(gem_home)
+      end
+    end
+
+    @warned = {}
+    @warn_mutex = Mutex.new
+
+    module_function
+
+    # @return [String] $XDG_CONFIG_HOME/samagotchi/home.json
+    def path(env: ENV) = File.join(Paths.config_home(env: env), Paths::APP_DIR, FILE)
+
+    # The record as home.json has it, usable or not (chi home shows it);
+    # nil without one.
+    # @raise [Invalid] a file that isn't home.json's shape
+    def read(path: self.path)
+      return nil unless File.file?(path)
+
+      data = JSON.parse(File.read(path))
+      raise Invalid, "#{Paths.tilde(path)} is not a JSON object" unless data.is_a?(Hash)
+
+      Record.from_h(data)
+    rescue JSON::ParserError, SystemCallError => e
+      raise Invalid, "#{Paths.tilde(path)}: #{e.message.lines.first.to_s.strip}"
+    rescue Invalid => e
+      raise if e.message.start_with?(Paths.tilde(path))
+
+      raise Invalid, "#{Paths.tilde(path)}: #{e.message}"
+    end
+
+    # The home every launch boots, or nil, where each site keeps its own
+    # argv: no home.json; one that isn't its shape (warned once); its ruby
+    # gone (a Ruby upgrade); no samagotchi in its gem path; or this chi
+    # runs from a source checkout (a worktree's bin/chi spawns its own code).
+    # @param gem_spec [Gem::Specification, nil] the installed gem this runs from
+    # @return [Record, nil]
+    def current(path: self.path, gem_spec: InstalledGem.spec)
+      return nil unless gem_spec
+
+      home = read(path: path)
+      return nil unless home
+
+      why = problem(home)
+      why ? warn_once(:unusable, path: path, problem: why) : home
+    rescue Invalid => e
+      warn_once(:invalid, path: path, error: e.message)
+    end
+
+    # Why a recorded home can't boot chi, or nil.
+    # @return [String, nil]
+    def problem(home)
+      return "home ruby missing: #{home.ruby}" unless home.ruby_ok?
+      return "no samagotchi in the home's gems (#{home.gem_path})" if home.versions.empty?
+
+      nil
+    end
+
+    # The home's boot, or nil without a usable home (#current).
+    # @return [Array<String>, nil]
+    def boot_argv(run:, home: current) = home&.boot_argv(run: run)
+
+    # Where a gem install lands: the home's gem dir, else this process's
+    # (UpdateCheck's writability).
+    def gem_dir(gem_spec: InstalledGem.spec) = current(gem_spec: gem_spec)&.gem_home || Gem.dir
+
+    # The specification dirs new workers activate chi from: the home's,
+    # else this process's (InstalledVersions' "installed; restart").
+    def spec_dirs(gem_spec: InstalledGem.spec) = current(gem_spec: gem_spec)&.spec_dirs || Gem::Specification.dirs
+
+    # The gem command a gem install runs: the home's, else this Ruby's own.
+    def gem_bin(home = current) = home ? home.gem_bin : File.join(RbConfig::CONFIG["bindir"], "gem")
+
+    # The env for a gem install child (chi update, chi bootstrap's
+    # commonmarker): into the home's gems whatever the spawner's
+    # GEM_HOME/GEM_PATH say (a chruby shell, an old helper's launch file),
+    # and with mise's dir on PATH (mise's rubygems plugin runs `mise
+    # reshim` after an install). {} without a home: the env as today.
+    # @return [Hash{String=>String}]
+    def install_env(home = current, env: ENV)
+      return {} unless home
+
+      result = { "GEM_HOME" => home.gem_home, "GEM_PATH" => home.gem_path }
+      if home.mise
+        dirs = env["PATH"].to_s.split(File::PATH_SEPARATOR)
+        mise_dir = File.dirname(home.mise)
+        result["PATH"] = (dirs + [mise_dir]).uniq.join(File::PATH_SEPARATOR) unless dirs.include?(mise_dir)
+      end
+      result
+    end
+
+    # The fallback pin for a worker's `>= 0.a` (a broken newest install):
+    # the spawner's own version when the home has it, else the home's
+    # newest.
+    # @return [String, nil]
+    def fallback_version(home, gem_spec)
+      versions = home.versions
+      own = gem_spec && Gem::Version.new(gem_spec.version.to_s)
+      (own && versions.include?(own) ? own : versions.last)&.to_s
+    end
+
+    # This process's Ruby and gem path as a record (chi home set without
+    # --ruby, a first record from the running chi).
+    def from_running(env: ENV)
+      Record.new(ruby: real(RbConfig.ruby), gem_home: Gem.dir, gem_path: Gem.path.join(File::PATH_SEPARATOR),
+                 mise: find_mise(env: env), set_at: Time.now.utc.iso8601, set_by_version: VERSION)
+    end
+
+    # Another Ruby's own gem dirs, asked of it (its GEM_*/RUBYOPT unset
+    # unless +gem_env+ gives the GEM_HOME/GEM_PATH its chi lived under).
+    # @param runner [#call] (env, argv) → [output, success]
+    # @return [Record, nil] nil when it doesn't run or answer
+    def probe(ruby, gem_env: {}, env: ENV, runner: method(:capture))
+      child_env = PROBE_UNSET.to_h { |key| [key, nil] }.merge(gem_env.slice("GEM_HOME", "GEM_PATH").compact)
+      output, ok = runner.call(child_env, [ruby, "-e", PROBE])
+      return nil unless ok
+
+      data = JSON.parse(output.to_s.lines.last.to_s)
+      return nil unless data.is_a?(Hash)
+
+      Record.from_h(data.merge("ruby" => data["ruby"].is_a?(String) ? real(data["ruby"]) : data["ruby"],
+                               "mise" => find_mise(env: env), "set_at" => Time.now.utc.iso8601,
+                               "set_by_version" => VERSION))
+    rescue JSON::ParserError, TypeError, Invalid
+      nil
+    end
+
+    # @raise [SystemCallError]
+    def write!(home, path: self.path)
+      FileUtils.mkdir_p(File.dirname(path))
+      AtomicFile.write(path, "#{JSON.pretty_generate(home.to_h)}\n", perm: 0o644)
+      home
+    end
+
+    # The first record, once, from an installed chi (chi bootstrap, chi
+    # update): of the macOS helper's ruby (when its launch file names one
+    # whose newest chi is at least this one: the Ruby it already runs) and
+    # this chi's, the one with the newest chi; the helper's on a tie.
+    # Never over an existing home.json, never from a checkout or under
+    # Bundler, never a Ruby without samagotchi.
+    # @param launch_path [String, nil] the helper's launch.json
+    # @param bundler [Boolean, nil] running under Bundler (nil: found out)
+    # @return [Record, nil] the home written, nil when none was
+    def record_first!(gem_spec: InstalledGem.spec, launch_path: nil, path: self.path, env: ENV,
+                      runner: method(:capture), bundler: nil)
+      return nil unless gem_spec
+      return nil if bundler.nil? ? under_bundler?(env) : bundler
+      return nil if File.exist?(path)
+
+      own = Gem::Version.new(VERSION)
+      helper = helper_home(launch_path, env: env, runner: runner)
+      helper = nil if helper && (helper.newest_version.nil? || helper.newest_version < own)
+      home = [helper, from_running(env: env)].compact.select { |candidate| problem(candidate).nil? }
+                                             .max_by(&:newest_version)
+      home && write!(home, path: path)
+    rescue SystemCallError => e
+      Log.warn(:config, "home_record_failed", error: e.class.name, msg: e.message)
+      nil
+    end
+
+    # The helper's launch.json ruby (argv[0]) probed with the GEM_* it was
+    # installed with; nil without one.
+    def helper_home(launch_path, env:, runner:)
+      return nil unless launch_path && File.file?(launch_path)
+
+      launch = JSON.parse(File.read(launch_path))
+      ruby = Array(launch["argv"]).first if launch.is_a?(Hash)
+      return nil unless ruby.is_a?(String) && ruby.start_with?("/") && File.executable?(ruby)
+
+      gem_env = launch["env"].is_a?(Hash) ? launch["env"] : {}
+      probe(ruby, gem_env: gem_env, env: env, runner: runner)
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    # The test UpdateCommand's @bundler makes: a first record from a
+    # `bundle exec` would name the bundle's gems.
+    def under_bundler?(env = ENV) = !!(defined?(::Bundler) || !env["BUNDLE_GEMFILE"].to_s.empty?)
+
+    # mise's absolute path: on +env+'s PATH, else in MISE_DIRS; nil without.
+    def find_mise(env: ENV)
+      dirs = env["PATH"].to_s.split(File::PATH_SEPARATOR).select { |dir| dir.start_with?("/") } + MISE_DIRS
+      dirs.map { |dir| File.join(dir, "mise") }.find { |file| File.file?(file) && File.executable?(file) }
+    end
+
+    def real(path)
+      File.realpath(path)
+    rescue SystemCallError, TypeError
+      path.to_s
+    end
+
+    def capture(env, argv)
+      output, status = Open3.capture2e(env, *argv)
+      [output, status.success?]
+    rescue SystemCallError => e
+      [e.message, false]
+    end
+
+    # Logs a home that can't be used, once per process and reason; nil.
+    def warn_once(event, **fields)
+      key = [event, fields]
+      first = @warn_mutex.synchronize { @warned[key] ? false : (@warned[key] = true) }
+      Log.warn(:config, "home_#{event}", **fields) if first
+      nil
+    end
+
+    # Specs: forget what was warned.
+    def reset_warnings! = @warn_mutex.synchronize { @warned.clear }
+  end
+end

data/lib/samagotchi/chi_shim.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "shellwords"
+require_relative "atomic_file"
+require_relative "chi_home"
+require_relative "log"
+require_relative "paths"
+
+module Samagotchi
+  # The `chi` a worker's tools run: $XDG_STATE_HOME/samagotchi/bin/chi, a
+  # shell script that execs the chi home's Ruby with its boot
+  # (ChiHome::Record#boot_argv, CHI_BOOT). ProjectEnv puts its dir first on
+  # the worker's PATH, so after the project env (whose PATH would find the
+  # project Ruby's chi, an old one or none) an agent's `chi send`, `chi self`
+  # or `chi answer` still runs the home's chi. The dir holds `chi` only: the
+  # project's ruby, gem and bundle stay the project's; bin/chi, a checkout
+  # path or `bundle exec chi` stay themselves.
+  module ChiShim
+    NAME = "chi"
+    HEADER = "# chi's own chi for its tools (ChiShim): rewritten at each worker start from the chi home.\n"
+    # A project's RUBYOPT/RUBYLIB/RUBYGEMS_GEMDEPS/GEMRC/BUNDLE_* (a `bundle
+    # exec` the tool runs under, a mise [env]) would load the project's gems
+    # or settings into the home's chi, its LD_*/DYLD_* libraries into its
+    # ruby: unset before the exec.
+    UNSET = "unset RUBYOPT RUBYLIB RUBYGEMS_GEMDEPS GEMRC LD_PRELOAD LD_LIBRARY_PATH DYLD_INSERT_LIBRARIES " \
+            "DYLD_LIBRARY_PATH\n" \
+            "for v in $(/usr/bin/env | /usr/bin/sed -n 's/^\\(BUNDLE[A-Za-z0-9_]*\\)=.*/\\1/p'); do unset \"$v\"; done\n"
+
+    module_function
+
+    # @return [String] $XDG_STATE_HOME/samagotchi/bin
+    def dir(env: ENV) = File.join(Paths.state_dir(env: env), "bin")
+
+    def path(dir: self.dir) = File.join(dir, NAME)
+
+    # The script for +home+.
+    # @param home [ChiHome::Record]
+    def content(home)
+      argv = home.boot_argv(run: ChiHome::CHI_BOOT) + ["--"]
+      "#!/bin/sh\n#{HEADER}#{UNSET}exec #{argv.map { |arg| Shellwords.escape(arg) }.join(" ")} \"$@\"\n"
+    end
+
+    # Writes the shim for +home+ unless it is already that (atomically: a
+    # tool running `chi` meanwhile gets the old one or the new one).
+    # @return [Boolean] whether the shim is there and current
+    def ensure!(home, dir: self.dir)
+      file = path(dir: dir)
+      want = content(home)
+      return true if current?(file, want)
+
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(file, want, perm: 0o755)
+      true
+    rescue SystemCallError => e
+      Log.warn(:worker, "chi_shim_failed", path: file, error: e.class.name, msg: e.message)
+      false
+    end
+
+    # Why the shim isn't +home+'s (chi home doctor), or nil: nil too
+    # without one (the first worker start writes it).
+    # @return [String, nil]
+    def problem(home, dir: self.dir)
+      file = path(dir: dir)
+      return nil if !File.exist?(file) || current?(file, content(home))
+
+      "the chi script tools run (#{Paths.tilde(file)}) boots another chi than the home: " \
+        "the next worker start rewrites it (chi sessions restart ID for a running session)"
+    end
+
+    def current?(file, want)
+      File.file?(file) && File.executable?(file) && File.read(file) == want
+    rescue SystemCallError
+      false
+    end
+  end
+end

data/lib/samagotchi/child_env.rb

@@ -2,6 +2,7 @@
 
 require_relative "installed_gem"
 require_relative "installed_versions"
+require_relative "project_env"
 
 module Samagotchi
   # What a chi process another chi starts must not take from its spawner's
@@ -23,11 +24,12 @@ module Samagotchi
     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).
+    # settings, the session markers, a smoke's fake "newest installed"
+    # (InstalledVersions::ENV_KEY, for the spawner's notices only) and the
+    # worker's project env marker and record (a child worker applies its own).
     # @return [Array<String>]
     def spawner_keys(env = ENV)
-      env.each_key.select { |key| key.start_with?(GUARDRAILS_PREFIX) } + SESSION_MARKERS + [InstalledVersions::ENV_KEY]
+      env.each_key.select { |key| key.start_with?(GUARDRAILS_PREFIX) } + SESSION_MARKERS + [InstalledVersions::ENV_KEY, ProjectEnv::MARKER_ENV, ProjectEnv::ORIG_ENV]
     end
 
     # #spawner_keys mapped to nil: Process.spawn unsets a key mapped to nil.

data/lib/samagotchi/config.rb

@@ -138,6 +138,8 @@ module Samagotchi
       Entry.new(key: "session.keep_status",           yaml_path: %w[session keep_status],           type: :string, default: "", expose: %i[env config cli], lifecycle: :next_retention_sweep),
       Entry.new(key: "session.sweep_interval_hours",  yaml_path: %w[session sweep_interval_hours],  type: :integer, default: 24,   expose: %i[env config cli], lifecycle: :next_retention_sweep),
       Entry.new(key: "session.idle_exit_minutes",     yaml_path: %w[session idle_exit_minutes],     type: :float,   default: 30.0, expose: %i[env config cli], lifecycle: :worker_start),
+      # Tools follow the project: a worker applies its folder's `mise env` at start (ProjectEnv); off keeps the spawner's env.
+      Entry.new(key: "session.project_env",           yaml_path: %w[session project_env],           type: :enum,    default: "mise", expose: %i[env config], enum_values: %w[mise off], lifecycle: :worker_start),
       # Plain `chi` runs like `chi --shared` (bin/chi, LaunchMode); false, or --no-shared per run, keeps the plain REPL. No CLI flag: that would duplicate --shared.
       Entry.new(key: "session.shared",                yaml_path: %w[session shared],                type: :bool,    default: true,  expose: %i[env config], lifecycle: :next_invocation),
       # false: a session nothing happened in is deleted when it is left (SessionManager.discardable?).

data/lib/samagotchi/context_fetch.rb

@@ -5,6 +5,7 @@ require_relative "context_sources"
 require_relative "context_providers"
 require_relative "log"
 require_relative "process_group"
+require_relative "project_env"
 
 module Samagotchi
   # Runs an attached context source's command once and records the result
@@ -108,8 +109,9 @@ module Samagotchi
 
     def env_for(location, name)
       previous = location.snapshot_path(name)
-      { "SAMAGOTCHI_CONTEXT_NAME" => name,
-        "SAMAGOTCHI_CONTEXT_PREVIOUS" => File.exist?(previous) ? previous : nil }
+      # The session's project env (ProjectEnv) under the source's own keys.
+      ProjectEnv.tools_env.merge("SAMAGOTCHI_CONTEXT_NAME" => name,
+                                 "SAMAGOTCHI_CONTEXT_PREVIOUS" => File.exist?(previous) ? previous : nil)
     end
 
     # @return [Run]