samagotchi 0.115.0 → 0.117.0

data/lib/samagotchi/system_one/question.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module SystemOne
+    # The question types the judgment contract has.
+    QUESTION_TYPES = %i[noul choice score].freeze
+
+    # The questions of one ask, as an Array of Question: a Hash of
+    # id => Question (or of wire fields), or an Array of Questions.
+    def self.normalize_questions(questions)
+      case questions
+      when Hash then questions.map { |id, value| Question.coerce(id, value) }
+      when Array then questions.map { |value| value.is_a?(Question) ? value : Question.coerce(value.to_s, value) }
+      else raise ArgumentError, "questions must be a hash of id => question, got #{questions.class}"
+      end
+    end
+
+    # One question of a System One request: id, type (:noul a yes/no
+    # judgment, :choice one of the named criteria, :score one of the listed
+    # levels), the instruction the model reads, and the criteria a :choice
+    # (name => description or nil) or :score (a list of level names) needs.
+    #
+    #   Question.new(id: "git-push", type: "noul", instructions: "Would the user allow this git push?")
+    Question = Data.define(:id, :type, :instructions, :criteria) do
+      def initialize(id:, type:, instructions:, criteria: nil)
+        id = id.to_s.strip
+        raise ArgumentError, "SystemOne::Question needs an id" if id.empty?
+
+        type = type.to_s.strip.downcase.to_sym
+        unless QUESTION_TYPES.include?(type)
+          raise ArgumentError, "question #{id}: type must be one of #{QUESTION_TYPES.join(", ")}, got #{type.inspect}"
+        end
+
+        instructions = instructions.to_s
+        raise ArgumentError, "question #{id}: instructions are required" if instructions.strip.empty?
+
+        super(id: id, type: type, instructions: instructions, criteria: criteria_for(id, type, criteria))
+      end
+
+      # The entry of the request's questions map.
+      def to_wire
+        wire = { "type" => type.to_s, "instructions" => instructions }
+        wire["criteria"] = criteria unless criteria.nil?
+        wire
+      end
+
+      # A Question as given, or a {type:, instructions:, criteria:} hash
+      # (string or symbol keys) — what a caller has on hand.
+      def self.coerce(id, value)
+        return value if value.is_a?(Question)
+
+        unless value.is_a?(Hash)
+          raise ArgumentError, "question #{id}: expected a SystemOne::Question or a hash, got #{value.class}"
+        end
+
+        field = ->(name) { value.key?(name) ? value[name] : value[name.to_sym] }
+        new(id: id, type: field.call("type"), instructions: field.call("instructions"), criteria: field.call("criteria"))
+      end
+
+      private
+
+      def criteria_for(id, type, criteria)
+        case type
+        when :noul
+          raise ArgumentError, "question #{id}: an noul question takes no criteria" unless criteria.nil?
+
+          nil
+        when :choice
+          unless criteria.is_a?(Hash) && !criteria.empty? &&
+                 criteria.all? { |name, description| !name.to_s.strip.empty? && (description.nil? || description.is_a?(String)) }
+            raise ArgumentError, "question #{id}: a choice question takes criteria as {name => description or nil}"
+          end
+
+          criteria.to_h { |name, description| [name.to_s, description] }
+        else
+          unless criteria.is_a?(Array) && !criteria.empty? &&
+                 criteria.all? { |level| level.is_a?(String) && !level.strip.empty? }
+            raise ArgumentError, "question #{id}: a score question takes criteria as a list of level names"
+          end
+
+          criteria.map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/system_one/record.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module SystemOne
+    # One rule's record: what System 1 has judged for it and what the user
+    # did about those asks. Built from `SystemOne::Log#entries` (judgments
+    # joined with their last label), filtered to one rule. The gate before
+    # System 1 answers for the user: enough clean allows at the threshold,
+    # and no false allow among the rule's last 20 labelled asks
+    # (docs/guardrails.md, "System 1").
+    #
+    # An ask with no label, no probability, or a `none` label counts for
+    # neither side: only a judgment the user actually answered teaches
+    # anything.
+    class Record
+      # The labels that mean the user let the call through.
+      ALLOW_LABELS = %w[allow_once allow_wide].freeze
+      # A judgment at the threshold that the user did not allow: System 1
+      # was wrong, and the rule's record is not clean.
+      FALSE_ALLOW_LABELS = %w[deny should_have_asked].freeze
+      # How many of the rule's labelled asks the false-allow check looks at.
+      WINDOW = 20
+
+      attr_reader :rule, :entries
+
+      # @param entries [Array<Hash>] SystemOne::Log#entries, oldest first
+      # @param rule [String] the rule the record is for
+      def initialize(entries, rule:)
+        @rule = rule.to_s
+        @entries = Array(entries).select { |entry| entry["rule"].to_s == @rule }
+      end
+
+      # @param threshold [Float] the probability an auto-allow needs
+      # @param min_record [Integer] how many clean allows the rule needs
+      # @return [Boolean] whether System 1 may answer this rule for the user
+      def qualifies?(threshold:, min_record:)
+        clean = high(threshold).count { |entry| ALLOW_LABELS.include?(entry["answer"].to_s) }
+        return false if clean < min_record.to_i
+
+        !false_allow?(labeled.last(WINDOW), threshold)
+      end
+
+      # The counts a `/guardrails` listing shows: how many asks the rule has,
+      # how many were answered, and how each was answered.
+      # @return [Hash]
+      def summary
+        labeled_entries = labeled
+        {
+          rule: rule,
+          asks: entries.size,
+          labelled: labeled_entries.size,
+          allow_once: count("allow_once"),
+          allow_wide: count("allow_wide"),
+          deny: count("deny"),
+          should_have_asked: count("should_have_asked"),
+          none: count("none"),
+          no_label: entries.size - labeled_entries.size,
+          no_p: entries.count { |entry| entry["p"].nil? }
+        }
+      end
+
+      private
+
+      # The asks of the rule the user answered.
+      def labeled
+        entries.reject { |entry| entry["answer"].nil? }
+      end
+
+      # The asks judged at or above +threshold+.
+      def high(threshold)
+        entries.select { |entry| entry["p"] && entry["p"].to_f >= threshold.to_f }
+      end
+
+      def false_allow?(list, threshold)
+        list.any? { |entry| entry["p"] && entry["p"].to_f >= threshold.to_f && FALSE_ALLOW_LABELS.include?(entry["answer"].to_s) }
+      end
+
+      def count(label)
+        entries.count { |entry| entry["answer"].to_s == label }
+      end
+    end
+  end
+end

data/lib/samagotchi/system_one/self_protect.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../paths"
+require_relative "../config"
+require_relative "../memory_paths"
+require_relative "../hooks/loader"
+require_relative "../guardrails/protected_paths"
+
+module Samagotchi
+  module SystemOne
+    # The calls System 1 may never answer for, whatever the rule's record
+    # says: one that changes chi itself. An auto-allow on config.yml, the
+    # hooks, the installed bundles or the guardrails store would let the
+    # agent widen its own guardrails without the user (docs/guardrails.md,
+    # "System 1"). The memories dir is deliberately not one of them:
+    # reading and appending a memory file stays eligible.
+    #
+    # Pure: it only reads the paths as this process's environment names them,
+    # and answers on the approval's own facts (Guardrails::Approval.payload's
+    # approval:), the same shape ParentApprovals.protected_facts? takes.
+    module SelfProtect
+      # The rules that let one agent answer chi's questions: an auto-allow
+      # there is one agent approving another's, so the user decides them even
+      # when they are listed in `guardrails.system_one.rules`.
+      NEVER_AUTO = %w[chi-answer-piped chi-answer-http chi-broadcast].freeze
+      # chi's config file, however the user names it in config.yml.
+      CONFIG_FILE = /\Aconfig[\w-]*\.ya?ml\z/i
+      # The dirs as a shell command may spell them when the settings point
+      # elsewhere: chi's default config dir and default state dir. A path
+      # into the memories dir is not a control file.
+      DEFAULT_CONFIG_TEXT = %r{\B~/\.config/samagotchi(?!/memories)}
+      DEFAULT_STATE_TEXT = %r{\B~/\.local/state/samagotchi}
+
+      module_function
+
+      # @param approval [Hash, nil] the ask's approval facts (rule, tool,
+      #   paths, command)
+      # @return [Boolean] whether System 1 must not answer this ask
+      def refuse?(approval)
+        return false unless approval.is_a?(Hash)
+        return true if NEVER_AUTO.include?(fetch(approval, :rule).to_s)
+
+        dirs = control_dirs
+        paths = Array(fetch(approval, :paths)).map(&:to_s).reject(&:empty?)
+        return true if paths.any? { |path| control_path?(path, dirs) }
+
+        command = fetch(approval, :command).to_s
+        !command.empty? && control_text?(command, dirs)
+      end
+
+      # The dirs whose files are chi's own: its hooks, its installed bundles,
+      # the guardrails store (approvals.json and judgments.jsonl).
+      # @return [Array<String>]
+      def control_dirs
+        [Hooks::Loader.hooks_dir, MemoryPaths.bundles_dir, File.join(Paths.state_dir, "guardrails")]
+          .compact.map { |dir| dir.to_s.chomp("/") }.reject(&:empty?)
+      end
+
+      def control_path?(path, dirs)
+        real = Guardrails::ProtectedPaths.real(path)
+        return true if dirs.any? { |dir| Guardrails::ProtectedPaths.within?(real, dir) }
+        return true if config_file?(real)
+
+        control_text?(path, dirs)
+      end
+
+      # config.yml in chi's config dir — not the memories beside it.
+      def config_file?(path)
+        Guardrails::ProtectedPaths.within?(path, ConfigFile.config_dir) && File.basename(path).match?(CONFIG_FILE)
+      end
+
+      # A command or path naming one of those dirs, in the spelling this
+      # process uses or the default `~/.config/samagotchi` one.
+      def control_text?(text, dirs)
+        dirs.any? { |dir| text.include?(dir) || text.include?(File.expand_path(dir)) } ||
+          text.match?(config_text) || text.match?(DEFAULT_CONFIG_TEXT) || text.match?(DEFAULT_STATE_TEXT)
+      end
+
+      # chi's config dir as text — everything under it except the memories,
+      # which the model works with.
+      def config_text
+        Regexp.new("#{Regexp.escape(ConfigFile.config_dir)}(?![/]memories)")
+      end
+
+      def fetch(hash, key)
+        hash.key?(key) ? hash[key] : hash[key.to_s]
+      end
+    end
+  end
+end

data/lib/samagotchi/system_one/similar.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module SystemOne
+    # The few-shot examples an ask carries beside its own facts: the earlier
+    # asks the user actually answered, the most alike first — this rule in
+    # this repository, then this rule, then whatever shares the most words
+    # with this call. No embeddings: a word overlap, with the newer ask first
+    # when two tie, so the same log always gives the same five
+    # (docs/guardrails.md, "System 1").
+    module Similar
+      # How many examples the state can carry.
+      MAX = 5
+      # A "token" of a call, for the overlap: a word, lower-cased.
+      TOKEN = /[a-z0-9_]+/
+
+      module_function
+
+      # @param entries [Array<Hash>] SystemOne::Log#entries, oldest first —
+      #   the same read the record gate uses
+      # @param rule [String, nil] the rule asking now
+      # @param repo_name [String, nil] the repository this ask is in
+      # @param call_text [String] the call to approve (ApprovalQuestion.call_text)
+      # @return [Array<Hash>] at most MAX examples, most alike first; [] when
+      #   the log has nothing labelled to offer
+      def select(entries:, rule:, repo_name:, call_text:)
+        words = tokens(call_text)
+        ranked = Array(entries).each_with_index.select { |entry, _index| labelled?(entry) }
+        ranked = ranked.sort_by { |entry, index| [tier(entry, rule, repo_name), -overlap(entry["call"], words), -index] }
+        ranked.first(MAX).map { |entry, _index| example(entry) }
+      end
+
+      # A judgment teaches something only when the user answered it: no label
+      # or a `none` says nothing, and a line with no rule cannot be matched.
+      def labelled?(entry)
+        answer = entry["answer"].to_s
+        !answer.empty? && answer != "none" && !entry["rule"].to_s.strip.empty?
+      end
+
+      # 0: this rule in this repository. 1: this rule anywhere. 2: any other
+      # ask the user answered.
+      def tier(entry, rule, repo_name)
+        same_rule = entry["rule"].to_s == rule.to_s
+        return 0 if same_rule && !repo_name.to_s.strip.empty? && entry["repo_name"].to_s == repo_name.to_s
+        return 1 if same_rule
+
+        2
+      end
+
+      # How many of this call's words the logged call shares.
+      def overlap(call, words)
+        return 0 if words.empty?
+
+        (tokens(call) & words).size
+      end
+
+      def tokens(text)
+        text.to_s.downcase.scan(TOKEN).uniq
+      end
+
+      # What the judge is shown about an ask: how it was judged and what the
+      # user did, as the log holds it.
+      def example(entry)
+        { "rule" => entry["rule"].to_s, "repo" => entry["repo_name"], "call" => entry["call"],
+          "answer" => entry["answer"].to_s }.compact
+      end
+    end
+  end
+end

data/lib/samagotchi/system_one.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "system_one/errors"
+require_relative "system_one/question"
+require_relative "system_one/answer"
+require_relative "system_one/fake_backend"
+require_relative "system_one/http_backend"
+require_relative "system_one/client"
+require_relative "system_one/log"
+require_relative "system_one/record"
+require_relative "system_one/similar"
+require_relative "system_one/self_protect"
+require_relative "system_one/approval_question"
+
+module Samagotchi
+  # System 1: the cheap judgment model that will, one phase at a time,
+  # answer the guardrail asks a user always allows. P1 is the client and its
+  # settings; P2a judges every ask a user is about to see and logs the
+  # judgment and their answer (SystemOne::Log); P3a is `on` mode: a judgment
+  # that passes every gate allows the call once, without asking
+  # (SystemOne::Record, SystemOne::SelfProtect). The line a UI shows for an
+  # auto-allow is P3b (docs/guardrails.md, "System 1").
+  module SystemOne
+  end
+end

data/lib/samagotchi/task_watch.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 require_relative "config"
 require_relative "log"
 require_relative "tools/task_runtime"
@@ -182,19 +184,35 @@ module Samagotchi
     # @return [Array<Entry>]
     def holding = entries.reject { |entry| entry.note_only || entry.failures >= MAX_FAILURES }
 
-    # The #holding tasks still running ({id:, command:}), for /exit
-    # (WorkerIdleExit's watched_running): one finished meanwhile is noted
-    # as the worker leaves. One `ps` per task.
-    # @return [Array<Hash>]
+    # A watched task still running, as /exit and the exit ask see it:
+    # +age_seconds+, the seconds since it started (nil when its record has
+    # no start time).
+    Running = Data.define(:id, :command, :age_seconds)
+
+    # The #holding tasks still running, for /exit (WorkerIdleExit's
+    # watched_running): one finished meanwhile is noted as the worker leaves.
+    # One `ps` per task.
+    # @return [Array<Running>]
     def running
       holding.filter_map do |entry|
         record, = Tools::TaskRuntime.get_record(entry.id)
-        { id: entry.id, command: record.command.to_s } if record&.running?
+        next unless record&.running?
+
+        Running.new(id: entry.id, command: record.command.to_s, age_seconds: age_seconds(record))
       end
     end
 
     private
 
+    # Seconds since the task started, from its record's iso8601 +started_at+;
+    # nil when that can't be read.
+    def age_seconds(record)
+      started = Time.parse(record.started_at.to_s)
+      [(Time.now - started).round, 0].max
+    rescue ArgumentError, TypeError
+      nil
+    end
+
     # Removes +entry+; nil (a filter_map's skip), or with +kept+ whether it
     # was there. +log+: why a task leaves without a note, at +level+ (debug
     # by default), with +error+ when there is one.

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -57,17 +57,35 @@ module Samagotchi
       # An exit the worker agreed to in an empty session. Said before it has
       # left: it checks again once it lets go, and a note or prompt arriving
       # first keeps the session (SessionManager.discard_left_session).
-      EMPTY_EXIT = "Detached; the session is empty: it will be discarded if nothing arrives before its worker stops."
+      EMPTY_WORDS = "the session is empty: it will be discarded if nothing arrives before its worker stops."
+      EMPTY_EXIT = "Detached; #{EMPTY_WORDS}"
       # Why the worker stayed up after /exit, by the reason it gave.
       HELD_REASONS = {
         "turn_running" => "a turn is running", "input_queued" => "prompts are queued",
         "continue_offered" => "a continue offer is pending", "client_connected" => "another UI is attached",
         "reminders" => "reminders are set", "starting" => "the worker is still starting",
-        "background_tasks" => "background tasks it started are still running"
+        "background_tasks" => "background tasks it started are still running",
+        "delegates" => "delegates of this session are still running"
       }.freeze
       # How to end a background task that holds the worker up (an older
       # worker's 409 has no hint of its own).
       TASK_STOP_HINT = "stop one with the web's stop-task button or by asking for task_stop"
+      # The /exit ask, when every hold is one the user can stop: what still
+      # runs, then the three answers. Each kind, singular and plural.
+      EXIT_HOLD_WORDS = {
+        "reminders" => %w[reminder reminders],
+        "background_tasks" => ["background task", "background tasks"],
+        "delegates" => %w[delegate delegates]
+      }.freeze
+      # The 200's +stopped+ keys, by the kind the ask lists them under.
+      STOPPED_KEYS = { "reminders" => "reminders", "tasks" => "background_tasks", "delegates" => "delegates" }.freeze
+      EXIT_ASK_OPTIONS = ["Keep running in the background (detach)", "Stop them and exit", "Back to the session"].freeze
+      # How the ask reads an answer.
+      EXIT_ANSWERS = {
+        "1" => :keep, "keep" => :keep, "detach" => :keep, "background" => :keep,
+        "2" => :stop, "stop" => :stop, "exit" => :stop,
+        "3" => :back, "back" => :back, "stay" => :back
+      }.freeze
       # How much of the last answer a join shows.
       JOIN_ANSWER_LINES = 12
       JOIN_ANSWER_CHARS = 1200
@@ -175,6 +193,8 @@ module Samagotchi
         @own_failed = false
         # A continue offer is pending: the prompt asks for the answer.
         @continue_offer = nil
+        # The /exit ask is open: the next line is its answer (#answer_exit_ask).
+        @exit_ask = nil
         # The status row: the worker's model, ctx, the session's memories.
         @status = StatusRow.new(screen)
         # Participants' names by author ("p:<id>"), from the join's state
@@ -470,6 +490,14 @@ module Samagotchi
 
       # @return [Symbol, nil] :detach to end the loop
       def submit(line)
+        if @exit_ask
+          # The exit ask is open: this line answers it. Ctrl-D and /detach
+          # detach without stopping anything, the way its 1 does.
+          return detach(kept_line(@exit_ask)) if line.nil? || command_registry.lookup_local(line.strip)&.id == :detach
+
+          return answer_exit_ask(line)
+        end
+
         return detach("Detached; the session keeps running. Re-attach with: #{via.attach(@client.session_id)}") if line.nil?
 
         text = line.strip
@@ -599,14 +627,104 @@ module Samagotchi
 
       # Detach, and ask the worker to exit now. The worker decides: it stays
       # up while anything still needs it (a turn, queued input, a continue
-      # offer, another UI, reminders), and the line says which.
-      # @return [Symbol] :detach
+      # offer, another UI, reminders), and the line says which. When the only
+      # holds are ones the user can stop, it asks what to do with them instead
+      # of detaching (#answer_exit_ask).
+      # @return [Symbol, nil] :detach, or nil to stay at the prompt
       def exit_worker
-        detach(exit_line(@client.request_exit(client_id: @client_id)))
+        reply = @client.request_exit(client_id: @client_id)
+        holds = reply.status == 409 ? reply.json&.fetch("holds", nil) : nil
+        return detach(exit_line(reply)) unless holds.is_a?(Array) && !holds.empty?
+
+        @exit_ask = holds
+        @screen.commit(ask_lines(holds))
+        nil
       rescue SystemCallError, IOError => e
         detach(exit_failed_line(e.message))
       end
 
+      # The ask: what still runs, then the three answers.
+      def ask_lines(holds)
+        lines = holds.map do |hold|
+          items = Array(hold["items"])
+          singular, plural = hold_words(hold["kind"])
+          "  • #{items.size} #{items.size == 1 ? singular : plural}: #{items.map { |item| item_word(item, hold["kind"]) }.join(", ")}"
+        end
+        lines += EXIT_ASK_OPTIONS.each_with_index.map { |option, index| "  #{index + 1}. #{option}" }
+        (["This session still has:"] + lines).join("\n")
+      end
+
+      # One entry of a hold: the command or name, with its detail in
+      # brackets; a delegate leads with its short id and its title in quotes.
+      def item_word(item, kind)
+        label = item["label"].to_s
+        label = "#{item["id"].to_s[0, 8]} \"#{label}\"" if kind == "delegates"
+        detail = item["detail"].to_s
+        detail.empty? ? label : "#{label} (#{detail})"
+      end
+
+      # The answer to the exit ask.
+      # @return [Symbol, nil] :detach for 1 and 2, nil for 3 or a line the
+      #   ask doesn't understand
+      def answer_exit_ask(line)
+        choice = EXIT_ANSWERS[line.to_s.strip.downcase]
+        unless choice
+          @screen.commit("Say 1 (keep running), 2 (stop them and exit) or 3 (back to the session).")
+          return nil
+        end
+
+        holds = @exit_ask
+        @exit_ask = nil
+        case choice
+        when :keep then detach(kept_line(holds))
+        when :stop then stop_and_exit
+        else
+          @screen.commit("(nothing stopped; the worker keeps running)")
+          nil
+        end
+      end
+
+      # 1: detach, everything left running.
+      def kept_line(holds)
+        "Detached; the session keeps running (#{hold_words_list(holds)}). " \
+          "Re-attach with: #{via.attach(@client.session_id)}"
+      end
+
+      # 2: ask the worker to stop them all and exit.
+      # @return [Symbol] :detach
+      def stop_and_exit
+        reply = @client.request_exit(client_id: @client_id, stop: true)
+        detach(exit_line(reply))
+      rescue SystemCallError, IOError => e
+        detach(exit_failed_line(e.message))
+      end
+
+      # "2 reminders, 1 background task, 1 delegate" from the ask's holds.
+      def hold_words_list(holds)
+        holds.map do |hold|
+          items = Array(hold["items"])
+          singular, plural = hold_words(hold["kind"])
+          "#{items.size} #{items.size == 1 ? singular : plural}"
+        end.join(", ")
+      end
+
+      def hold_words(kind) = EXIT_HOLD_WORDS.fetch(kind.to_s, [kind.to_s, kind.to_s])
+
+      # What a stop-all exit stopped: "stopped 2 reminders (api_health, git
+      # push), 1 background task (rails s)"; nil when it stopped nothing.
+      def stopped_words(stopped)
+        return nil unless stopped.is_a?(Hash)
+
+        parts = STOPPED_KEYS.filter_map do |key, kind|
+          names = Array(stopped[key])
+          next if names.empty?
+
+          singular, plural = hold_words(kind)
+          "#{names.size} #{names.size == 1 ? singular : plural} (#{names.join(", ")})"
+        end
+        parts.empty? ? nil : "stopped #{parts.join(", ")}"
+      end
+
       # /exit --delete: the worker exits as for /exit, then the session is
       # deleted. When the worker stays up (another UI, queued input, ...),
       # nothing is deleted.
@@ -656,7 +774,9 @@ module Samagotchi
       # (SessionManager.archive_session). An empty session: the worker
       # deletes it as it leaves.
       def exit_and_archive
-        reply = @client.request_exit(client_id: @client_id)
+        # /archive can't ask about what still runs: a child the archive will
+        # stop is not worth a question here.
+        reply = @client.request_exit(client_id: @client_id, ask: false)
         id = @client.session_id
         return detach(EMPTY_EXIT) if reply.status == 200 && discards?(reply)
         return detach("#{exit_line(reply)} Not archived.") unless [200, 409].include?(reply.status)
@@ -676,9 +796,11 @@ module Samagotchi
         error = reply.json&.fetch("error", nil)
         case reply.status
         when 200
-          return EMPTY_EXIT if discards?(reply)
+          stopped = stopped_words(reply.json&.fetch("stopped", nil))
+          return EMPTY_EXIT if discards?(reply) && stopped.nil?
+          return "Detached; #{stopped}. #{EMPTY_WORDS.capitalize}" if discards?(reply)
 
-          "Detached; the session's worker is stopping. Resume with: #{via.resume(id)}"
+          "Detached; #{stopped || "the session's worker is stopping"}. Resume with: #{via.resume(id)}"
         when 409
           reason = reply.json&.fetch("reason", nil).to_s
           "Detached; the session keeps running (#{held_words(reason, reply.json&.fetch("tasks", nil))}). " \
@@ -1550,7 +1672,8 @@ module Samagotchi
               record = join_record(records, part)
               duration = record&.dig("duration_ms")
               @screen.commit(join_tool_line(part, duration_ms: duration.is_a?(Numeric) ? duration : nil,
-                                                  saved_status: record&.dig("status")))
+                                                  saved_status: record&.dig("status"),
+                                                  auto_allowed: record&.dig("guardrail")))
             end
           end
         end
@@ -1594,8 +1717,10 @@ module Samagotchi
       # A saved call's row; "no result" for a call the turn never answered
       # (it ended first). Its status is the saved record's, as live and the
       # web's reload (a guardrail's "blocked" is no error), else read from
-      # its result (a guardrail's deny text reads blocked too).
-      def join_tool_line(part, duration_ms: nil, saved_status: nil)
+      # its result (a guardrail's deny text reads blocked too). A record that
+      # System 1 allowed once (+auto_allowed+, its saved {rule, p}) says so,
+      # as the live row does.
+      def join_tool_line(part, duration_ms: nil, saved_status: nil, auto_allowed: nil)
         output = part[:output]
         command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
         text = ToolActivity.saved_result_text(output) unless output.nil?
@@ -1612,7 +1737,15 @@ module Samagotchi
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }
         "#{format_tool_activity_line(activity, duration_ms: duration_ms)}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}"
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}" \
+          "#{auto_allowed_suffix(auto_allowed)}"
+      end
+
+      # The live row's System 1 suffix for a saved record's {rule, p}.
+      def auto_allowed_suffix(saved)
+        return "" unless saved.is_a?(Hash)
+
+        format_tool_guardrail_suffix({ decided_by: "system one", p: saved["p"] || saved[:p] })
       end
 
       # The context notes that came since the last prompt (all of them in a

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -221,6 +221,7 @@ module Samagotchi
         line += @view.format_tool_image_suffix(images) if images&.any?
         line += @view.format_tool_diff_suffix(diff) if diff
         line += @view.format_tool_cut_suffix(output_truncated) if output_truncated
+        line += @view.format_tool_guardrail_suffix(activity[:guardrail]) if activity[:guardrail]
         @view.print_line(line)
       end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -202,6 +202,20 @@ module Samagotchi
         output_truncated ? " #{paint("[cut]", 90)}" : ""
       end
 
+      # A call System 1 allowed once instead of asking: " · auto-allowed
+      # (System 1, p=0.97)", yellow, from the activity's guardrail (symbol or
+      # string keys: live, snapshot). Any other guardrail data adds nothing.
+      def format_tool_guardrail_suffix(guardrail)
+        return "" unless guardrail.is_a?(Hash)
+
+        get = ->(key) { guardrail[key] || guardrail[key.to_s] }
+        return "" unless get.call(:decided_by) == "system one"
+
+        p_value = get.call(:p)
+        detail = p_value.nil? ? "System 1" : format("System 1, p=%.2f", p_value.to_f)
+        " #{paint("\u00b7 auto-allowed (#{detail})", 33)}"
+      end
+
       # Prompt labels by the sender's client_id: a whole id, or a prefix
       # (ending in ":") it starts with (turn_events.js CLIENT_LABELS;
       # spec/shared/labels_matrix.json).