samagotchi 0.134.0 → 0.136.0

data/lib/samagotchi/guardrails/parent_approvals.rb

@@ -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
@@ -231,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]
@@ -276,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) } }
@@ -490,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

@@ -97,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)

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/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/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:

data/lib/samagotchi/revise_anchor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "verify_anchor"
+
+module Samagotchi
+  # The earlier turn a Revise turn rewrites the answer of, carried only by
+  # a Revise turn (TurnAnchors). Its stamp on the turn's opening message
+  # is display metadata, never in the prompt (Engine#revision_target).
+  ReviseAnchor = Data.define(:turn_id) do
+    def self.from(value)
+      return value if value.is_a?(self)
+      return nil unless value.is_a?(Hash)
+
+      fields = value.to_h { |key, entry| [key.to_s, entry] }
+      return nil unless fields.keys == %w[turn_id]
+
+      turn_id = fields["turn_id"]
+      return nil unless turn_id.is_a?(String) && VerifyAnchor::UUID.match?(turn_id)
+
+      new(turn_id:)
+    end
+
+    def to_h = { turn_id: }
+
+    def to_file = { "turn_id" => turn_id }
+  end
+
+  ReviseAnchor::FEATURE = "revise"
+  ReviseAnchor::UNAVAILABLE = {
+    "error" => "revise_unavailable",
+    "detail" => "this session's worker predates Revise turns; restart this session to use Revise"
+  }.freeze
+end

data/lib/samagotchi/session_inbox.rb

@@ -12,8 +12,10 @@ require_relative "steer"
 require_relative "turn_origin"
 
 module Samagotchi
-  # Loaded on first use (a Verify turn's input): keeps the bundle test kit's
-  # load budget (spec/samagotchi/testing/sandbox_spec.rb).
+  # Loaded on first use (any turn's input, a Verify or a Revise turn's
+  # anchor): keeps the bundle test kit's load budget
+  # (spec/samagotchi/testing/sandbox_spec.rb).
+  autoload :TurnAnchors, File.expand_path("turn_anchors", __dir__)
   autoload :VerifyAnchor, File.expand_path("verify_anchor", __dir__)
 
   # A session directory's file inbox and outbox (see SessionManager for the
@@ -54,10 +56,12 @@ module Samagotchi
     # @param author [String, nil] who wrote the message when it isn't the
     #   session's owner (Web::Principal#author); nil, the owner's, is never
     #   written, so an owner's file is as it always was
+    # @param anchors [TurnAnchors, Hash, nil] a Verify turn's claim, a Revise
+    #   turn's draft (TurnAnchors#to_file's keys; none: none written)
     # @param now [Time] the time the file is named by (a spec's clock)
     # @return [String, false] the input file's path, or false
     def self.write_input(session_dir, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [],
-                         delivery: nil, author: nil, verify: nil, now: Time.now)
+                         delivery: nil, author: nil, anchors: nil, now: Time.now)
       images = Array(images)
       input_dir = File.join(session_dir, INPUT_DIR)
       FileUtils.mkdir_p(input_dir)
@@ -67,7 +71,8 @@ module Samagotchi
                  "no_interrupt" => (no_interrupt ? true : nil),
                  "delivery" => (Delivery.queue?(delivery) ? Delivery::QUEUE : nil),
                  "images" => (images.empty? ? nil : images.map { |image| image.transform_keys(&:to_s) }),
-                 "author" => author, "verify" => VerifyAnchor.from(verify)&.to_file }.compact
+                 "author" => author }.compact
+      record.merge!(TurnAnchors.from(anchors).to_file) if anchors
       AtomicFile.write(path, JSON.generate(record))
       path
     rescue StandardError
@@ -231,10 +236,12 @@ module Samagotchi
     # no sender), whether its turn runs with the raised iteration limit
     # (+no_interrupt+, --no-interrupt), its +images+ ({file:, name:} refs),
     # and its +delivery+ ("queue" or nil; a file without the key is one an
-    # older chi wrote, so nil).
-    Input = Data.define(:prompt, :origin, :no_interrupt, :images, :delivery, :verify) do
-      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil, verify: nil)
-        super(prompt:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:, verify: verify && VerifyAnchor.from(verify))
+    # older chi wrote, so nil), and its +anchors+ (TurnAnchors, nil when it
+    # names none: TurnAnchors loads on first use, not with UNREADABLE_INPUT).
+    Input = Data.define(:prompt, :origin, :no_interrupt, :images, :delivery, :anchors) do
+      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil, anchors: nil)
+        anchors &&= TurnAnchors.from(anchors)
+        super(prompt:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:, anchors: anchors && anchors.empty? ? nil : anchors)
       end
     end
     # A file that doesn't parse, or isn't a JSON object: no prompt.
@@ -250,7 +257,7 @@ module Samagotchi
       origin = TurnOrigin.from(data.slice("client_id", "enqueued_id", "author"))
       images = Array(data["images"]).select { |image| image.is_a?(Hash) }.map { |image| image.transform_keys(&:to_sym) }
       Input.new(prompt: data["prompt"].to_s, origin: origin, no_interrupt: data["no_interrupt"] == true,
-                images: images, delivery: Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil, verify: data["verify"])
+                images: images, delivery: Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil, anchors: data)
     rescue JSON::ParserError
       UNREADABLE_INPUT
     end
@@ -282,11 +289,12 @@ module Samagotchi
       true
     end
 
-    # A parsed input file's #waits_for_turn_end?. A Verify turn waits too:
-    # merged into a running turn as a steer, its anchor would be lost.
+    # A parsed input file's #waits_for_turn_end?. A Verify or a Revise turn
+    # waits too: merged into a running turn as a steer, its anchor would be
+    # lost.
     def self.turn_end_data?(data)
       Array(data["images"]).any? || Delivery.queue?(data["delivery"]) || Steer.participant_author?(data["author"]) ||
-        data["verify"].is_a?(Hash)
+        TurnAnchors.named_in?(data)
     end
 
     # Whether a message waits that a running turn's next boundary merges and

data/lib/samagotchi/session_manager.rb

@@ -1368,10 +1368,11 @@ module Samagotchi
     #   session's images/
     # @return [String, false] the input file's path, or false.
     def self.write_turn_input(session_id, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, state_dir: nil,
-                              images: [], delivery: nil, author: nil, verify: nil)
+                              images: [], delivery: nil, author: nil, anchors: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       SessionInbox.write_input(session_dir, prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
-                                            no_interrupt: no_interrupt, images: images, delivery: delivery, author: author, verify: verify)
+                                            no_interrupt: no_interrupt, images: images, delivery: delivery, author: author,
+                                            anchors: anchors)
     end
 
     # How long a turn waits for the Bridge of a worker a resume just spawned.
@@ -1440,6 +1441,9 @@ module Samagotchi
     # @param pending_limit [Integer, nil] with +author+: how many of their
     #   turns may be running or waiting (the Bridge counts them; with no
     #   worker, their waiting files): :refused 429 too_many_turns past it
+    # @param anchors [TurnAnchors, Hash, nil] a Verify turn's claim, a Revise
+    #   turn's draft: each refused (409, its UNAVAILABLE) by a worker without
+    #   its feature
     # @param manager [#resume_session, #write_turn_input] this class, or a
     #   stand-in (the web's specs); #session_owner is optional
     # @param bridge [#call, nil] returns the BridgeClient or nil; defaults to
@@ -1453,8 +1457,8 @@ module Samagotchi
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, no_interrupt: false,
-                          author: nil, pending_limit: nil, verify: nil, state_dir: nil, manager: self, bridge: nil)
-      verify = VerifyAnchor.from(verify)
+                          author: nil, pending_limit: nil, anchors: nil, state_dir: nil, manager: self, bridge: nil)
+      anchors = TurnAnchors.from(anchors)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= lambda do
         link = WorkerLink.await(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT)
@@ -1462,7 +1466,9 @@ module Samagotchi
       end
       manager.resume_session(session_id, state_dir: state_dir)
       if (client = bridge.call)
-        return verify_unavailable if verify && !worker_has?(client, VerifyAnchor::FEATURE)
+        if (missing = anchors.present.find { |anchor| !worker_has?(client, anchor.class::FEATURE) })
+          return DeliverResult.new(status: :refused, code: 409, ack: missing.class::UNAVAILABLE)
+        end
         # A worker from before queueing (no "delivery" feature) ignores the
         # field or refuses it; either way a file would steer the running turn.
         return queue_unavailable if Delivery.queue?(delivery) && !worker_has?(client, Delivery::QUEUE_FEATURE)
@@ -1477,7 +1483,7 @@ module Samagotchi
           options[:no_interrupt] = true if no_interrupt
           options[:author] = author if author
           options[:pending_limit] = pending_limit if author && pending_limit
-          options[:verify] = verify if verify
+          options[:anchors] = anchors unless anchors.empty?
           reply = client.post_turn(**options)
           ack = reply.json
           return DeliverResult.new(status: :accepted, via: :bridge, ack: ack) if reply.status == 202 && ack.is_a?(Hash)
@@ -1515,7 +1521,7 @@ module Samagotchi
       input[:delivery] = delivery unless Delivery.next_step?(delivery)
       input[:no_interrupt] = true if no_interrupt
       input[:author] = author if author
-      input[:verify] = verify if verify
+      input[:anchors] = anchors unless anchors.empty?
       path = participant_queue_lock(session_dir, author && pending_limit) do
         # No worker: the participant's waiting files are all their turns,
         # counted and written under one lock (the Bridge counts under its).
@@ -1581,10 +1587,6 @@ module Samagotchi
       DeliverResult.new(status: :refused, code: 409, ack: Delivery::REVIEW_UNAVAILABLE)
     end
 
-    private_class_method def self.verify_unavailable
-      DeliverResult.new(status: :refused, code: 409, ack: VerifyAnchor::UNAVAILABLE)
-    end
-
     private_class_method def self.turn_timeout
       DeliverResult.new(status: :timeout, via: :bridge,
                         ack: { "error" => "worker_timeout",

data/lib/samagotchi/system_one/approval_question.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 
+require_relative "../guardrails/approval"
 require_relative "question"
 require_relative "similar"
 
@@ -35,29 +36,31 @@ module Samagotchi
         Question.new(id: ID, type: "noul", instructions: INSTRUCTIONS)
       end
 
-      # @param approval [Hash] payload[:approval]: the ask the user is shown
+      # @param approval [Guardrails::ApprovalFacts, Hash] payload[:approval]:
+      #   the ask the user is shown (a saved card's hash too)
       # @param session_title [String, nil] the session's title, when it has one
       # @param entries [Array<Hash>] SystemOne::Log#entries: the judgments the
       #   user has answered so far, read once per ask and shared with the
       #   record gate (GuardrailWiring#system_one_judge)
       # @return [Hash] the state, with the fields the ask didn't give left out
       def self.state(approval, session_title: nil, entries: nil)
+        approval = Guardrails::ApprovalFacts.from_h(approval)
         {
-          "rule" => approval[:rule],
-          "source" => approval[:source],
-          "reason" => approval[:reason],
-          "tool" => approval[:tool],
-          "command" => cut(approval[:command]),
-          "paths" => Array(approval[:paths]).map { |path| cut(path) },
-          "change" => change_text(approval[:preview]),
-          "cwd" => approval[:cwd],
-          "repo_name" => approval[:repo_name],
-          "branch" => approval[:branch],
+          "rule" => approval.rule,
+          "source" => approval.source,
+          "reason" => approval.reason,
+          "tool" => approval.tool,
+          "command" => cut(approval.command),
+          "paths" => Array(approval.paths).map { |path| cut(path) },
+          "change" => change_text(approval.preview),
+          "cwd" => approval.cwd,
+          "repo_name" => approval.repo_name,
+          "branch" => approval.branch,
           "session" => session_title,
           # Which memory entry the ask is about, when it is a memory ask.
-          "memory" => memory_facts(approval[:memory]),
+          "memory" => memory_facts(approval.memory),
           # The asks this one looks like, and what the user did about them.
-          "examples" => Similar.select(entries: entries, rule: approval[:rule], repo_name: approval[:repo_name],
+          "examples" => Similar.select(entries: entries, rule: approval.rule, repo_name: approval.repo_name,
                                        call_text: call_text(approval))
         }.reject do |_key, value|
           value.nil? || (value.is_a?(String) && value.strip.empty?) ||
@@ -67,14 +70,16 @@ module Samagotchi
 
       # What the call is, whole: the command, the paths, or a plugin tool's
       # arguments.
+      # @param approval [Guardrails::ApprovalFacts, Hash] as built or saved
       def self.call_text(approval)
-        command = approval[:command]
+        approval = Guardrails::ApprovalFacts.from_h(approval)
+        command = approval.command
         return command.to_s if command && !command.to_s.empty?
 
-        paths = Array(approval[:paths])
+        paths = Array(approval.paths)
         return paths.join("\n") unless paths.empty?
 
-        approval[:args].to_s
+        approval.args.to_s
       end
 
       # The judgment log's two fields for the call: what it was, cut to

data/lib/samagotchi/system_one/self_protect.rb

@@ -3,6 +3,7 @@
 require_relative "../config"
 require_relative "../memory_paths"
 require_relative "../paths"
+require_relative "../guardrails/approval"
 require_relative "../guardrails/chi_dirs"
 require_relative "../guardrails/path_resolve"
 require_relative "../guardrails/pair_command"
@@ -86,20 +87,21 @@ module Samagotchi
 
       module_function
 
-      # @param approval [Hash, nil] the ask's approval facts (rule, tool,
-      #   paths, command, cwd)
+      # @param approval [Guardrails::ApprovalFacts, Hash, nil] the ask's
+      #   approval facts (rule, tool, paths, command, cwd), as built or saved
       # @param targets [Guardrails::Targets, nil] the call's targets, for its
       #   env: (Targets#shell_envs, #redefines_shell?)
       # @return [Boolean] whether System 1 must not answer this ask
       def refuse?(approval, targets: nil)
-        return false unless approval.is_a?(Hash)
-        return true if NEVER_AUTO.include?(fetch(approval, :rule).to_s)
+        approval = Guardrails::ApprovalFacts.from_h(approval)
+        return false if approval.nil?
+        return true if NEVER_AUTO.include?(approval.rule.to_s)
         # An env: that redefines the shell (BASH_ENV, BASH_FUNC_…) runs what
         # no word of the command says.
         return true if targets&.redefines_shell?
 
-        command = fetch(approval, :command).to_s
-        words = command.empty? ? nil : words(command, cwd: fetch(approval, :cwd), targets: targets)
+        command = approval.command.to_s
+        words = command.empty? ? nil : words(command, cwd: approval.cwd, targets: targets)
         return true if words&.chi
         return true if chi_paths?(approval)
         # The test that makes an ask user_only (ParentApprovals#chi_files?:
@@ -116,7 +118,7 @@ module Samagotchi
         memories = Guardrails::PathResolve.real(MemoryPaths.system_dir)
         bundles = Guardrails::PathResolve.real(MemoryPaths.bundles_dir)
         dirs = chi_dirs
-        Array(fetch(approval, :paths)).map(&:to_s).reject(&:empty?).any? do |path|
+        Array(approval.paths).map(&:to_s).reject(&:empty?).any? do |path|
           Guardrails::PathResolve.reals(path).any? do |real|
             dirs.any? { |dir| Guardrails::PathResolve.within?(real, dir) } && !memory?(real, memories, bundles)
           end
@@ -129,12 +131,12 @@ module Samagotchi
       def beyond_memories(approval, exempt:)
         memories = Guardrails::PathResolve.real(MemoryPaths.system_dir)
         bundles = Guardrails::PathResolve.real(MemoryPaths.bundles_dir)
-        paths = Array(fetch(approval, :paths)).map(&:to_s).reject do |path|
+        paths = Array(approval.paths).map(&:to_s).reject do |path|
           Guardrails::PathResolve.reals(path).all? { |real| memory?(real, memories, bundles) }
         end
-        command = fetch(approval, :command).to_s
+        command = approval.command.to_s
         command = command.gsub(memories_text) { |text| text.include?("/.bundles") ? text : "" } if exempt
-        { paths: paths, command: command }
+        approval.with(paths: paths, command: command)
       end
 
       # Whether the command's memories text may be taken out: no command,
@@ -211,7 +213,7 @@ module Samagotchi
         simple.each_with_index.any? do |word, i|
           next false if word.include?("\0")
 
-          verbs = FILE_RUNNERS.find { |pattern, _| File.basename(word).match?(pattern) }&.last
+          verbs = FILE_RUNNERS.find { |pattern, _| Guardrails::ShellLex.program_name(word).match?(pattern) }&.last
           verbs && (verbs.empty? || simple[(i + 1)..].intersect?(verbs))
         end
       end
@@ -240,10 +242,6 @@ module Samagotchi
         word = WORD_END.sub("[", "[^")
         Regexp.new("(?:#{prefixes.join("|")})/memories(?=/|#{WORD_END}|\\z)(?:/#{word}*)?")
       end
-
-      def fetch(hash, key)
-        hash.key?(key) ? hash[key] : hash[key.to_s]
-      end
     end
   end
 end