samagotchi 0.133.0 → 0.135.0

data/lib/samagotchi/guardrails/parent_approvals.rb

@@ -42,7 +42,7 @@ module Samagotchi
       MEMORY_REMOVE_RULE = "memory-remove"
       # The guardrails bundle's shell-touches-chi, for a word it can't
       # resolve to a path (Guardrails::ShellPaths): CHI_TEXT and .git/hooks.
-      CHI_SHELL_TEXT = Regexp.union(CHI_TEXT, %r{\.git/hooks})
+      CHI_SHELL_TEXT = Regexp.union(CHI_TEXT, %r{\.git/(?:modules/\S+/)?hooks})
 
       module_function
 
@@ -63,13 +63,15 @@ module Samagotchi
 
       # #protected? on an approval's facts (Approval.payload's approval:),
       # at ask time.
+      # @param facts [ApprovalFacts, Hash, nil] as built, or as saved
       def protected_facts?(facts)
-        return false unless facts.is_a?(Hash)
-        return true if PROTECTED_RULES.include?(fetch(facts, :rule).to_s)
-        return true if fetch(facts, :source).to_s == ProtectedPaths::SOURCE
+        facts = ApprovalFacts.from_h(facts)
+        return false if facts.nil?
+        return true if PROTECTED_RULES.include?(facts.rule.to_s)
+        return true if facts.source.to_s == ProtectedPaths::SOURCE
         # A memory's file sits in the config dir, but removing one is the
         # memory-remove rule's ask, which a parent may answer.
-        return false if fetch(facts, :rule).to_s == MEMORY_REMOVE_RULE
+        return false if facts.rule.to_s == MEMORY_REMOVE_RULE
 
         chi_files?(facts)
       end
@@ -77,15 +79,17 @@ module Samagotchi
       # Whether an approval's paths or command name chi's own dirs (#chi_dirs)
       # or CHI_TEXT, whatever its rule: the part of #protected_facts? that
       # System 1's SystemOne::SelfProtect shares.
+      # @param facts [ApprovalFacts, Hash, nil] as built, or as saved
       def chi_files?(facts)
-        return false unless facts.is_a?(Hash)
+        facts = ApprovalFacts.from_h(facts)
+        return false if facts.nil?
 
         dirs = chi_dirs
-        paths = Array(fetch(facts, :paths)).map(&:to_s).reject(&:empty?)
+        paths = Array(facts.paths).map(&:to_s).reject(&:empty?)
         reals = paths.flat_map { |path| PathResolve.reals(path) }
         return true if reals.any? { |real| dirs.any? { |dir| PathResolve.within?(real, dir) } }
 
-        command = fetch(facts, :command).to_s
+        command = facts.command.to_s
         return false if command.empty?
 
         command.match?(CHI_TEXT) || dirs.any? { |dir| command.include?(dir) || command.include?(PathResolve.real(dir)) }
@@ -103,8 +107,7 @@ module Samagotchi
       # The offered scopes, in option order, or nil when they are missing,
       # empty, not strings, or leave no option after them for Deny.
       def scopes(pending)
-        facts = pending.approval
-        scopes = facts.is_a?(Hash) ? fetch(facts, :scopes) : nil
+        scopes = ApprovalFacts.from_h(pending.approval)&.scopes
         return nil unless scopes.is_a?(Array) && !scopes.empty? && scopes.all?(String)
         return nil unless scopes.size < options(pending).size
 
@@ -112,12 +115,6 @@ module Samagotchi
       end
 
       def options(pending) = Array(pending.options)
-
-      def fetch(hash, key)
-        return nil unless hash.is_a?(Hash)
-
-        hash.key?(key) ? hash[key] : hash[key.to_s]
-      end
     end
   end
 end

data/lib/samagotchi/guardrails/read_only_shell.rb

@@ -17,7 +17,9 @@ module Samagotchi
     # sh -c, eval, timeout, …), a background &, a $ expansion other than
     # $HOME / the XDG dirs / $TMPDIR / $PWD at a word's start, a brace
     # expansion, a < or << redirection, a path to a verb (/bin/ls), and
-    # less/more/vim (they run commands) are all not read-only.
+    # less/more/vim (they run commands) are all not read-only. test and
+    # [ … ] read only as one file or string check (.test_expr): `[[` and
+    # anything else they can do are not.
     #
     # .read_only_but_writes? (the child boundary's) also lets through the
     # writes it can name: a > or >> target, cp's destination and tee's
@@ -98,12 +100,44 @@ module Samagotchi
         text = command.to_s
         return false if text.strip.empty?
 
-        commands = split(ShellLex.lex(text)) or return false
-        !commands.empty? && commands.all? { |words| simple_read_only?(words) }
+        tokens_read_only?(ShellLex.lex(text))
       rescue ArgumentError, EncodingError
         false
       end
 
+      def tokens_read_only?(tokens)
+        commands = split(tokens) or return false
+        !commands.empty? && commands.all? { |words| simple_read_only?(words) }
+      end
+
+      # Operators that end a part of a list (.read_only_parts) outside ( … ).
+      PART_ENDS = ["&&", "||", ";", "\n"].freeze
+
+      # Per simple command of +tokens+ (ShellLex.lex's; the word lists of
+      # ShellLex.simple_commands, in order), whether the part of the list it
+      # is in only reads: the list split at ;, &&, || and newlines outside
+      # ( … ). A pipe or a group keeps its commands in one part, so
+      # `find . -name x | xargs rm` reads as one part that writes.
+      # @return [Array<Boolean>]
+      def read_only_parts(tokens)
+        parts = [[]]
+        depth = 0
+        tokens.each do |token|
+          kind, value = token
+          depth += 1 if kind == :op && value == "("
+          depth -= 1 if kind == :op && value == ")" && depth.positive?
+          next parts << [] if kind == :op && depth.zero? && PART_ENDS.include?(value)
+
+          parts.last << token
+        end
+        parts.flat_map do |part|
+          read_only = tokens_read_only?(part)
+          ShellLex.simple_commands(part).grep(Array).map { read_only }
+        end
+      rescue ArgumentError, EncodingError
+        ShellLex.simple_commands(tokens).grep(Array).map { false }
+      end
+
       # Whether the command only reads but for writes whose resolved paths
       # the block accepts: > and >> targets, cp's destination (and the
       # files it makes in it) and tee's files. Paths resolve against +cwd+
@@ -199,6 +233,7 @@ module Samagotchi
 
         writes&.walk&.step(args)
         verb = args.shift
+        return args.last == "]" && test_expr(args[0...-1]) if verb == "["
         return false unless verb&.match?(/\A[a-z][\w.-]*\z/)
         return true if PLAIN.include?(verb)
         return WRITE_CHECKS[verb].call(args, writes) if writes && WRITE_CHECKS[verb]
@@ -244,6 +279,25 @@ module Samagotchi
 
       def rg(args) = args.none? { |a| a.start_with?("--pre") }
 
+      # test's checks that only look: a file's type, mode or size, a string
+      # being empty or not.
+      TEST_UNARY = %w[-e -f -d -s -r -w -x -L -h -b -c -p -S -g -u -k -O -G -n -z].freeze
+      # Comparisons of two strings or integers.
+      TEST_BINARY = %w[= == != -eq -ne -lt -le -gt -ge].freeze
+
+      # test's (and [ … ]'s, without the ]) expression when it is one check:
+      # an optional !, then a unary TEST_UNARY with its operand or a
+      # TEST_BINARY between two. Any other shape (-a/-o, ( ), -v, one bare
+      # word, a missing operand) is not read-only.
+      def test_expr(args)
+        args = args.drop(1) if args.first == "!"
+        case args.size
+        when 2 then TEST_UNARY.include?(args[0])
+        when 3 then TEST_BINARY.include?(args[1])
+        else false
+        end
+      end
+
       FIND_ACTIONS = %w[-delete -exec -execdir -ok -okdir -fprint -fprint0 -fprintf -fls].freeze
 
       def find(args) = args.none? { |a| FIND_ACTIONS.any? { |action| a.start_with?(action) } }
@@ -458,7 +512,7 @@ module Samagotchi
       CHECKS = {
         "rg" => method(:rg), "find" => method(:find), "tree" => method(:tree), "file" => method(:file),
         "sort" => method(:sort), "uniq" => method(:uniq), "sed" => method(:sed), "awk" => method(:awk),
-        "git" => method(:git), "sqlite3" => method(:sqlite3), "gh" => method(:gh)
+        "git" => method(:git), "sqlite3" => method(:sqlite3), "gh" => method(:gh), "test" => method(:test_expr)
       }.freeze
 
       # A sed script parsed far enough to tell that it only reads: its

data/lib/samagotchi/guardrails/shared_git.rb

@@ -52,7 +52,7 @@ module Samagotchi
       def git_call(words)
         words = words.drop_while { |w| w.match?(/\A[A-Za-z_]\w*=/) || ShellGitDirs::PREFIXES.include?(w) }
         verb = words.first
-        return nil unless verb == "git" || verb.to_s.end_with?("/git")
+        return nil unless ShellLex.program?(verb, "git")
 
         args = words.drop(1).grep_v(ShellLex::REDIRECT)
         until args.empty?

data/lib/samagotchi/guardrails/shell_git_dirs.rb

@@ -28,7 +28,12 @@ module Samagotchi
       STASH_READS = %w[list show].freeze
       PREFIXES = %w[command builtin exec time nohup env ! { if then else elif do while until].freeze
       # git global options that take the next word as their value.
-      VALUE_OPTIONS = %w[-C -c --git-dir --work-tree --namespace].freeze
+      VALUE_OPTIONS = %w[-C -c --git-dir --work-tree --namespace --attr-source --shallow-file].freeze
+      # The variables that hand git config of their own (another global or
+      # system file, settings as -c gives them) or a template (an init's
+      # hooks): what they set may run a command (Targets::SHELL_REDEFINING_ENV,
+      # PairCommand's refusal). GIT_CONFIG_NOSYSTEM only turns one off.
+      CONFIG_ENV = /\A(?:GIT_CONFIG(?:_GLOBAL|_SYSTEM|_PARAMETERS|_COUNT|_KEY_\d+|_VALUE_\d+)?|GIT_TEMPLATE_DIR)\z/
 
       # @param command [String] the shell command
       # @param cwd [String] where it starts (the call's cwd:, else the session's)
@@ -92,7 +97,7 @@ module Samagotchi
             @pushed << @dirs
             @dirs = args.first ? dirs_after(args.first) : [nil]
           when "popd" then @dirs = @pushed.pop unless @pushed.empty?
-          else git(args, env) if verb == "git" || verb.end_with?("/git")
+          else git(args, env) if ShellLex.program?(verb, "git")
           end
         end
 

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -39,6 +39,28 @@ module Samagotchi
         Lexer.new(text).tokens
       end
 
+      # A program word's name as the guardrails compare it: its basename,
+      # case-folded (GIT, Git, /usr/bin/SH, ſh → git, sh), since a
+      # case-insensitive file system (macOS's default) runs `GIT` as git.
+      # Every check that tells a program by its name goes through this
+      # (PairCommand, ImplicitWriters, SelfProtect, ShellGitDirs, SharedGit).
+      # A word with a NUL (a SUBST) raises, as File.basename does.
+      def self.program_name(word)
+        name = File.basename(word.to_s)
+        name.valid_encoding? ? name.downcase(:fold) : name
+      end
+
+      # Whether +word+ runs the program +name+ (.program_name). A word with a
+      # NUL (a SUBST: "$(dirname $(which git))/git") by what follows its last
+      # `/`, folded the same way: no `/`, no name.
+      def self.program?(word, name)
+        word = word.to_s
+        return program_name(word) == name unless word.include?("\0")
+
+        last = word[%r{/([^/]*)\z}, 1] or return false
+        (last.valid_encoding? ? last.downcase(:fold) : last) == name
+      end
+
       # Whether +text+ ends inside a quote, a $(…) or a heredoc: its tokens
       # are a best guess.
       def self.unterminated?(text)
@@ -63,6 +85,29 @@ module Samagotchi
         commands.reject { |c| c.is_a?(Array) && c.empty? }
       end
 
+      # For each word list .simple_commands gives (its :open / :close
+      # markers left out), whether it reads a pipe: a | or |& comes before
+      # it, a ( between them included (`x | (sh)`).
+      # @return [Array<Boolean>]
+      def self.piped_flags(tokens)
+        flags = []
+        words = 0
+        pending = false
+        piped = false
+        tokens.each do |kind, value|
+          if kind == :op
+            flags << piped if words.positive?
+            words = 0
+            pending = %w[| |&].include?(value) || (value == "(" && pending)
+          else
+            piped = pending if words.zero?
+            words += 1
+          end
+        end
+        flags << piped if words.positive?
+        flags
+      end
+
       # Whether an ( or { group is still open at token +at+: a pipe after
       # the group's ) or } takes what the group prints. The counters never go
       # below 0 (a case pattern's "x)" closes nothing); ((…)) arithmetic and

data/lib/samagotchi/guardrails/shell_paths.rb

@@ -11,7 +11,8 @@ module Samagotchi
     # command is in by then (cd, pushd/popd and ( … ) followed as in
     # ShellGitDirs), with ~, $HOME and the XDG dirs expanded and symlinks
     # resolved. A word names a dir when it is in it. Any path with a
-    # .git/hooks part counts too, outside the tmp dirs.
+    # .git/hooks part (a submodule's .git/modules/<name>/hooks too) counts
+    # too, outside the tmp dirs.
     #
     # A word it can't resolve (another $VAR, $(…), a glob, a relative path
     # after cd $X) or one that reads as a script (sh -c '…', ruby -e '…':
@@ -23,7 +24,7 @@ module Samagotchi
       # A word that is a script rather than a path.
       SCRIPT = /[\s;&|<>()'"`]/
       GLOB = /[*?\[\]{}]/
-      HOOKS_PART = %r{(?:\A|/)\.git/hooks(?:/|\z)}
+      HOOKS_PART = %r{(?:\A|/)\.git/(?:modules/.+/)?hooks(?:/|\z)}
       # $HOME, ${HOME} and the XDG dirs at a word's start (PathResolve's).
       EXPANSION = PathResolve::EXPANSION
       # Where XDG dirs default when unset.

data/lib/samagotchi/guardrails/targets.rb

@@ -46,7 +46,8 @@ module Samagotchi
       # goes, under every shell chi may use or in the programs it runs: a
       # startup file (BASH_ENV, ENV), an exported function (BASH_FUNC_…), a
       # cd search path, word splitting, shell options, a library loaded into
-      # every program, git config or a diff program that runs. A call whose
+      # every program, git config or a diff program that runs (and the rest
+      # of git's config variables: ShellGitDirs::CONFIG_ENV). A call whose
       # env: sets one is never read-only (.redefines_shell?). PATH is not
       # one (the tool's own description suggests it); nor are
       # PROMPT_COMMAND (interactive shells only) and ZDOTDIR (zsh in sh
@@ -250,9 +251,13 @@ module Samagotchi
         {}
       end
 
-      # Whether +env+ sets a SHELL_REDEFINING_ENV variable.
+      # Whether +env+ sets a SHELL_REDEFINING_ENV variable (or a git config
+      # one: ShellGitDirs::CONFIG_ENV).
       def self.redefines_shell?(env)
-        env.each_key.any? { |key| SHELL_REDEFINING_ENV.include?(key) || key.start_with?(SHELL_REDEFINING_PREFIX) }
+        env.each_key.any? do |key|
+          SHELL_REDEFINING_ENV.include?(key) || key.start_with?(SHELL_REDEFINING_PREFIX) ||
+            key.match?(ShellGitDirs::CONFIG_ENV)
+        end
       end
 
       # +path+ (a file tool's, as Tools::ToolPath has it) absolute against

data/lib/samagotchi/guardrails_command.rb

@@ -7,6 +7,7 @@ require_relative "cli/exit"
 require_relative "cli/flags"
 require_relative "config"
 require_relative "bridge/card_store"
+require_relative "guardrails/approval"
 require_relative "guardrails/approvals"
 require_relative "guardrails/parent_policy"
 require_relative "host_registry"
@@ -71,7 +72,7 @@ module Samagotchi
     }.freeze
 
     # One ask a replay judges: the card's question id, the session it came
-    # from, its approval as the card saved it, the label its answer gives,
+    # from, its approval as the card saved it (Guardrails::ApprovalFacts), the label its answer gives,
     # and when the user was asked.
     Ask = Data.define(:question_id, :session_id, :approval, :label, :asked_at)
 
@@ -208,17 +209,19 @@ module Samagotchi
 
       pending = entry[:pending_question]
       return :no_approval unless pending.is_a?(Hash) && pending[:approval].is_a?(Hash)
+
       # A participant's turn's ask is never System 1's to judge, live or here
       # (GuardrailWiring#system_one_judge): no record of it is the user's
       # rule-level decision (it offered once only).
-      return :participant if pending[:approval][:author]
+      approval = Guardrails::ApprovalFacts.from_h(pending[:approval])
+      return :participant if approval.author
 
       question_id = pending[:id].to_s
       return :no_question_id if question_id.empty?
 
       origin = judged.question_ids[question_id]
       return origin == "replay" ? :already_replayed : :judged_live if origin
-      return :judged_live if judged.take_live(session_id, pending[:approval])
+      return :judged_live if judged.take_live(session_id, approval)
 
       answer = entry[:answer]
       label = if entry[:cancelled]
@@ -230,15 +233,15 @@ module Samagotchi
                 # label only where the parent could have allowed: a parent
                 # that was not allowed to permit says nothing about the user
                 # (docs/guardrails.md, "System 1").
-                return :answered_by_parent unless label_for(answer, pending[:approval][:scopes]) == "deny"
+                return :answered_by_parent unless label_for(answer, approval.scopes) == "deny"
                 return :parent_cannot_allow unless parent_may_permit?(pending, session_id, sessions_dir)
 
                 "deny"
               else
-                label_for(answer, pending[:approval][:scopes])
+                label_for(answer, approval.scopes)
               end
 
-      Ask.new(question_id: question_id, session_id: session_id, approval: pending[:approval],
+      Ask.new(question_id: question_id, session_id: session_id, approval: approval,
               label: label, asked_at: pending[:created_at])
     end
 
@@ -298,15 +301,15 @@ module Samagotchi
       p = answers && answers[SystemOne::ApprovalQuestion::ID]&.noul
 
       unless @dry_run
-        id = log.judgment(session_id: ask.session_id, rule: ask.approval[:rule], source: ask.approval[:source],
-                          tool: ask.approval[:tool], **SystemOne::ApprovalQuestion.call_fields(ask.approval),
-                          repo_name: ask.approval[:repo_name], p: p, threshold: threshold, model: client.model,
+        id = log.judgment(session_id: ask.session_id, rule: ask.approval.rule, source: ask.approval.source,
+                          tool: ask.approval.tool, **SystemOne::ApprovalQuestion.call_fields(ask.approval),
+                          repo_name: ask.approval.repo_name, p: p, threshold: threshold, model: client.model,
                           latency_ms: latency_ms, decision: "replay", origin: "replay",
                           question_id: ask.question_id, asked_at: ask.asked_at)
         log.label(id, ask.label)
       end
 
-      { rule: ask.approval[:rule].to_s, label: ask.label, p: p, session: ask.session_id }
+      { rule: ask.approval.rule.to_s, label: ask.label, p: p, session: ask.session_id }
     end
 
     # The session's title, as the ask's state carries it; nil when there is

data/lib/samagotchi/home_command.rb

@@ -3,6 +3,7 @@
 require "rbconfig"
 require_relative "chi_home"
 require_relative "home_doctor"
+require_relative "home_notice"
 require_relative "cli/command"
 require_relative "cli/exit"
 require_relative "cli/flags"
@@ -25,8 +26,9 @@ module Samagotchi
         set --ruby PATH   record that Ruby (its own gem dirs) as the home; it must have samagotchi
                           (gem install samagotchi with it first)
         doctor            check the home (its Ruby is there and has samagotchi) and what should
-                          follow it: this chi, the desktop helper, sessions, the tools' chi script,
-                          this project's Gemfile.lock, mise and the last worker's project env
+                          follow it: this chi, the last worker boot, the desktop helper, sessions,
+                          the tools' chi script, this project's Gemfile.lock, mise and the last
+                          worker's project env
         Every chi launch (workers, chi web's restart and Update, the macOS helper's next
         chi desktop install or upgrade) boots the home's Ruby with the home's gems. Saved in
         #{Paths.tilde(ChiHome.path)}.
@@ -42,14 +44,16 @@ module Samagotchi
     # @param path [String] home.json
     # @param probe [#call] (ruby) → ChiHome::Record or nil (ChiHome.probe)
     # @param doctor [#call] (home) → HomeDoctor
+    # @param bundler [Boolean, nil] running under Bundler (nil: found out)
     def initialize(argv, stdout: $stdout, stderr: $stderr, path: ChiHome.path, gem_spec: InstalledGem.spec,
-                   env: ENV, probe: nil, doctor: nil)
+                   env: ENV, probe: nil, doctor: nil, bundler: nil)
       @argv = argv.dup
       @stdout = stdout
       @stderr = stderr
       @path = path
       @gem_spec = gem_spec
       @env = env
+      @bundler = bundler.nil? ? ChiHome.under_bundler?(env) : bundler
       @probe = probe || ->(ruby) { ChiHome.probe(ruby, env: env) }
       @doctor = doctor || lambda { |home|
         HomeDoctor.new(home: home, env: env, gem_spec: gem_spec, helper: HomeDoctor.default_helper(env: env))
@@ -70,6 +74,9 @@ module Samagotchi
     rescue ChiHome::Invalid => e
       error_line("#{command_name}: #{e.message} (chi home set rewrites it)")
       CLI::Exit::FAILED
+    rescue ChiHome::UnderBundler => e
+      error_line("#{command_name}: #{e.message}")
+      CLI::Exit::FAILED
     end
 
     private
@@ -98,12 +105,12 @@ module Samagotchi
       list
     end
 
-    def running_home?(home) = @gem_spec && home.running_here? && home.newest_version.to_s == VERSION
+    def running_home?(home) = @gem_spec && HomeNotice.home?(home)
 
     def running_ruby = "#{RbConfig.ruby}#{" (a checkout)" unless @gem_spec}"
 
     def run_set(options)
-      home = options[:ruby] ? probed(options[:ruby]) : ChiHome.from_running(env: @env)
+      home = options[:ruby] ? probed(options[:ruby]) : running_record
       return CLI::Exit::FAILED unless home
 
       if (problem = ChiHome.problem(home))
@@ -127,13 +134,22 @@ module Samagotchi
         error_line("#{command_name}: no Ruby at #{ruby}")
         return nil
       end
-      return ChiHome.from_running(env: @env) if ChiHome.real(path) == ChiHome.real(RbConfig.ruby)
+      return running_record if ChiHome.real(path) == ChiHome.real(RbConfig.ruby)
 
       home = @probe.call(path)
       error_line("#{command_name}: #{ruby} didn't answer as a Ruby") unless home
       home
     end
 
+    # This process's Ruby and gem path, never under Bundler (the bundle's
+    # gems). Another Ruby is probed with Bundler's variables unset.
+    # @raise [ChiHome::UnderBundler]
+    def running_record
+      raise ChiHome::UnderBundler if @bundler
+
+      ChiHome.from_running(env: @env)
+    end
+
     # The home's rows and what should follow it (HomeDoctor); exit 1 when
     # one fails.
     def run_doctor

data/lib/samagotchi/home_doctor.rb

@@ -7,6 +7,7 @@ require_relative "config"
 require_relative "desktop"
 require_relative "home_notice"
 require_relative "installed_gem"
+require_relative "log_line"
 require_relative "log_path"
 require_relative "paths"
 require_relative "project_env"
@@ -51,18 +52,21 @@ module Samagotchi
     def rows
       list = [home_row]
       if @home && !ChiHome.problem(@home)
-        list.concat([running_row, helper_row, sessions_row, shim_row].compact)
+        list.concat([running_row, boot_row, helper_row, sessions_row, shim_row].compact)
       end
       list.concat([gemfile_row, mise_row, project_env_row].compact)
     end
 
     # The desktop helper chi home doctor checks: this machine's, when it
-    # is installed.
+    # is installed and its chi reads this chi's config dir (home.json's,
+    # Desktop::MacOS#reads_this_config?).
     def self.default_helper(env: ENV)
       return nil unless Desktop.supported?
 
       helper = Desktop::MacOS.new(env: env, register: false)
-      File.file?(helper.launch_path) ? helper : nil
+      return nil unless File.file?(helper.launch_path)
+
+      helper.reads_this_config? ? helper : nil
     end
 
     private
@@ -89,6 +93,35 @@ module Samagotchi
       text && warn_row("#{text}: launches boot the home; chi home set makes this chi the home")
     end
 
+    # The newest worker boot in the debug log since the home was set, when
+    # it is SessionManager::HOME_BOOT_FAILED's line (the home's Ruby
+    # couldn't load chi) rather than a worker's `start`. Without a log
+    # file (log.file off) there is no line to read.
+    def boot_row
+      failed = last_boot_failure
+      return nil unless failed
+
+      ruby = failed.fields["ruby"] || @home.ruby
+      fail_row("the last worker (#{failed.ts}, session #{failed.sid}) failed to boot the home's chi on #{ruby}: " \
+               "#{failed.fields["error"]}: gem install samagotchi with #{ruby} (or chi home set another Ruby), " \
+               "then chi sessions restart #{failed.sid}")
+    end
+
+    def last_boot_failure
+      return nil unless @log_path && File.file?(@log_path)
+
+      since = Time.iso8601(@home.set_at.to_s)
+      newest = nil
+      LogLine.each_tail_record(@log_path, bytes: ProjectEnv::LOG_TAIL_BYTES) do |record|
+        next unless record.tag == "worker" && %w[start boot_failed].include?(record.event)
+
+        newest = record if Time.iso8601(record.ts) >= since
+      end
+      newest if newest&.event == "boot_failed"
+    rescue SystemCallError, ArgumentError
+      nil
+    end
+
     def helper_row
       return nil unless @helper
 

data/lib/samagotchi/home_notice.rb

@@ -48,11 +48,18 @@ module Samagotchi
       nil
     end
 
+    # Whether this chi is +home+'s: it runs on the home's Ruby and gems and
+    # is its newest chi. The one rule for "not the home's chi" (this line,
+    # chi home doctor, chi home's "running" row, chi self's home row).
+    def home?(home, ruby: RbConfig.ruby, gem_dir: Gem.dir, version: VERSION)
+      home.running_here?(ruby: ruby, gem_dir: gem_dir) && home.newest_version.to_s == version
+    end
+
     # This chi isn't the home's: the text, also chi home doctor's row; nil
     # when this process runs on +home+ (or there is none).
     # @return [String, nil]
     def mismatch(home, ruby: RbConfig.ruby, gem_dir: Gem.dir, version: VERSION)
-      return nil if home.nil? || (home.running_here?(ruby: ruby, gem_dir: gem_dir) && home.newest_version.to_s == version)
+      return nil if home.nil? || home?(home, ruby: ruby, gem_dir: gem_dir, version: version)
 
       where = ruby
       # The same Ruby on other gems (a chruby GEM_HOME): name them both.

data/lib/samagotchi/hooks/loader.rb

@@ -165,6 +165,11 @@ module Samagotchi
         end
       end
 
+      # Forgets the cached plugin instances (load_plugin builds new ones;
+      # Ruby's require cache keeps their classes). For tests: the cache is
+      # process-wide.
+      def self.reset_cache! = @plugin_cache = nil
+
       # The plugin's #call under the entry's error policy: a required
       # before_tool_call hook that raises denies the call; otherwise
       # on_error: log warns and skip is silent.

data/lib/samagotchi/llm/chat_loop.rb

@@ -429,8 +429,8 @@ module Samagotchi
       # The shape the engine persists: role and content (parts stay an
       # Array), plus a model turn's tool_calls and thinking (the host's
       # reasoning, sent back as #wire_messages says), a result's tool_call_id, the image
-      # refs of a user message or a tool result, a prompt's turn_id (Engine,
-      # never sent) and a wake turn's report's turn_start (Steer, never sent), and a plugin tool result's tool_params and tool_labels
+      # refs of a user message or a tool result, a prompt's turn_id and its
+      # Verify/Revise anchors (Engine, never sent) and a wake turn's report's turn_start (Steer, never sent), and a plugin tool result's tool_params and tool_labels
       # (the live row's params line and label, never sent back), an
       # edit/write result's tool_diffs (never sent), an empty-answer
       # note's marker (TurnNote.empty, never sent), and an answer's display
@@ -448,6 +448,7 @@ module Samagotchi
           message[:turn_id] = entry[:turn_id] if entry[:turn_id]
           message[:turn_start] = true if entry[:turn_start] == true
           message[:verify] = entry[:verify] if entry[:verify].is_a?(Hash)
+          message[:revises] = entry[:revises] if entry[:revises].is_a?(Hash)
           message[:thinking] = entry[:thinking] if entry[:thinking].is_a?(String) && !entry[:thinking].empty?
           message[:anthropic_content] = entry[:anthropic_content] if entry[:anthropic_content].is_a?(Array)
           ToolResponse::SAVED_KEYS.each { |key| message[key] = entry[key] if entry[key] }
@@ -706,7 +707,7 @@ module Samagotchi
         end
 
         # The host's reasoning, kept on the model message as +thinking+ for
-        # the web turn view's reload (the whole of it, as the live view
+        # the web turn block's reload (the whole of it, as the live block
         # shows), and sent back to the model as ChatLoop#wire_messages says
         # (reasoning_history). A wire that sends its blocks back keeps them
         # as +anthropic_content+ (ChatResponse#provider_content: string

data/lib/samagotchi/log_line.rb

@@ -104,6 +104,18 @@ module Samagotchi
       line.start_with?(INDENT)
     end
 
+    # Yields each Record in the last +bytes+ of the log at +path+ (a torn
+    # first line skipped): chi home doctor's readers.
+    # @raise [SystemCallError]
+    def each_tail_record(path, bytes:, &)
+      File.open(path, "rb") do |io|
+        size = io.size
+        io.seek([size - bytes, 0].max)
+        io.gets if size > bytes
+        each_record(io, &)
+      end
+    end
+
     # Yields each Record of a log (payload lines joined onto theirs). Lines
     # that are neither (an older format, a torn write) go to on_invalid.
     def each_record(io, on_invalid: nil)

data/lib/samagotchi/message_parts.rb

@@ -13,7 +13,7 @@ require_relative "row_refs"
 require_relative "tool_output_cut"
 
 module Samagotchi
-  # What a saved assistant message did, for a turn view's reload: its
+  # What a saved assistant message did, for the web turn block's reload: its
   # thinking and its tool calls (name, the params line the live row shows,
   # the output from the tool_response messages after it). Two storage
   # shapes, best effort: