samagotchi 0.141.0 → 0.142.0

data/lib/samagotchi/engine.rb

@@ -169,6 +169,7 @@ module Samagotchi
       @chat_backend = nil
       @chat_backend_mutex = Mutex.new
       @side_judgments = SideJudgments.new
+      @judgments = build_judgments
       @context_judge_after_turn = nil
       # On mode's cards an answer brought while a turn ran: shown once it
       # has ended (#show_context_cards_after_turn).
@@ -431,7 +432,11 @@ module Samagotchi
         # System 1 (experimental, audit phase): the judgment client is read
         # from config on every ask, and the running turn's cancel controller
         # closes a judgment that is no longer wanted.
-        system_one: -> { SystemOne::Client.from_config(host_registry: @host_registry) },
+        system_one: lambda {
+          system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: Config.get("guardrails.system_one.mode")),
+                               SystemOne::ApprovalQuestion::JUDGMENT, @session)
+        },
+        system_one_runs: -> { system_one_runs },
         cancel_controller: -> { active_cancel_controller },
         # A participant's turn: their name on the owner's card, their
         # grant's mode for the turn's (GuardrailWiring#turn_mode).
@@ -2924,13 +2929,24 @@ module Samagotchi
         tool_index: @tool_index,
         peer_sources: @peer_sources,
         prompt_sections: @prompt_sections,
-        prompt_changed: -> { prompt_changed! }
+        prompt_changed: -> { prompt_changed! },
+        judgments: @judgments
       )
       # What plugins show while they load (an MCP server that didn't
       # start) waits for the first turn, beside the load warnings: no UI
       # is there yet, and the Engine isn't built.
-      @extension_load.load_plugins(registries, failures: @plugin_failures)
+      @extension_load.load_plugins(registries, failures: @plugin_failures) { warn_undeclared_judgments }
+    end
+
+    # Held with the plugins' own notices, so every UI gets it: a worker's
+    # stderr goes nowhere.
+    def warn_undeclared_judgments
+      @judgments.undeclared.each do |name|
+        Log.warn(:config, "judgment_undeclared", judgment: name)
+        hook_notify("system_one.judgments.#{name}: no loaded bundle declares it, so it does nothing", :warn, "config")
+      end
     end
+    private :warn_undeclared_judgments
 
     # Keep a plugin's new tool set (chi.replace_tools, from any thread)
     # for the turn thread (PluginTasks#stage_tools).
@@ -3055,7 +3071,8 @@ module Samagotchi
         return
       end
 
-      client = SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit)
+      client = system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit),
+                                    ToolkitSuggest::JUDGMENT, session, mode: Config.get("toolkit.suggest.mode").to_s)
       return unless client
 
       # D7: on a shared single-slot server audit's free ask would compete
@@ -3091,7 +3108,9 @@ module Samagotchi
         state: { project: state[:project].dup.freeze, prompt: state[:prompt].dup.freeze }.freeze
       )
       threshold = Config.get("toolkit.suggest.threshold")
+      runs = session.scratch ? nil : system_one_runs
       pending = ToolkitSuggest::Pending.new(log: log, joined: joined,
+                                            acted: runs && ->(judged, did) { runs.acted(judged.fields[:run_id], did) },
                                             timeout_seconds: SystemOne::Client.configured_timeout_ms / 1000.0)
       # On mode: cut by a Stop while the turn waits (Pending#wait), not
       # by one after it went on; audit's ask is never cut.
@@ -3124,7 +3143,7 @@ module Samagotchi
         # slow System 1 host (a local one) is the usual cause.
         timeout_ms = SystemOne::Client.configured_timeout_ms
         Log.warn(:toolkit, "toolkit_suggest_timeout", session_id: turn.session.id, timeout_ms: timeout_ms,
-                                                      reason: "System 1 gave no answer within guardrails.system_one.timeout_ms")
+                                                      reason: "System 1 gave no answer within system_one.timeout_ms")
         @toolkit_binding.fell_back(turn.session, "System 1 took over #{timeout_ms} ms")
         return
       end
@@ -3210,6 +3229,46 @@ module Samagotchi
     end
     private :toolkit_suggestion_log
 
+    # +client+ (nil for none) saving its asks as +judgment+'s runs. Anything
+    # going wrong here leaves the client as it was: a run is never worth a
+    # judgment.
+    #
+    # A scratch session's asks aren't saved; a participant's turn is never
+    # judged, so it never comes here.
+    # @param mode [String, nil] the use's mode, for its runs (Recording.wrap)
+    def system_one_recording(client, judgment, session, mode: nil)
+      return client if client.nil? || session&.scratch
+
+      context = SystemOne::Recording::Context.of(session, session_model: session && effective_model_name)
+      SystemOne::Recording.wrap(client, judgment: judgment, runs: system_one_runs, context: context, recorded_mode: mode)
+    rescue StandardError => e
+      Log.warn(:system_one, "system_one_recording_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      client
+    end
+    private :system_one_recording
+
+    # Bundles' judgments (chi.judgment), on this Engine's Runs and side asks.
+    # A judgment's own host and model are for bundles only: core's clients
+    # above never pass them (D2, JudgmentSettings).
+    def build_judgments
+      SystemOne::Judgments.new(
+        client_for: lambda { |_name, settings|
+          SystemOne::Client.from_config(host_registry: @host_registry, mode: settings.mode, host: settings.host,
+                                        model: settings.client_model, tag: :plugins)
+        },
+        runs: -> { @session&.scratch ? SystemOne::Runs.new : system_one_runs },
+        where: -> { @session && SystemOne::Recording::Context.of(@session, session_model: effective_model_name) },
+        side: @side_judgments,
+        shared_host_busy: ->(host) { turn_running? && system_one_shares_local_host?(host) },
+        participant: -> { !turn_author.nil? }
+      )
+    end
+    private :build_judgments
+
+    # Where this Engine's runs are saved; read each time, as the settings are.
+    def system_one_runs = SystemOne::Runs.for_sessions_dir(session_state_dir)
+    private :system_one_runs
+
     # D7: System 1's host is the session's model server, and a local one
     # (a single-slot Splash or llama.cpp): the same name, or two hosts:
     # entries for one server root (scheme, host, port).
@@ -3270,7 +3329,8 @@ module Samagotchi
                                               parent_attached: context_parent_attached(session))
       return if jobs.empty?
 
-      client = SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :context)
+      client = system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :context),
+                                    ContextJudge::JUDGMENT, session, mode: settings.mode)
       return unless client
 
       choice = context_choice(session, log, settings)
@@ -3451,7 +3511,8 @@ module Samagotchi
         turn_author: -> { turn_author },
         # A plugin's prompt section is in the stable part: a full re-read.
         cache_confirm: ->(line, changed) { CacheConfirm.ask(line: line, cost: :full, changed: changed, engine: self) },
-        candidate_proposed: ->(_candidate) { judge_late_candidates }
+        candidate_proposed: ->(_candidate) { judge_late_candidates },
+        judgments: -> { @judgments }
       )
     end
 

data/lib/samagotchi/extension_load.rb

@@ -43,11 +43,12 @@ module Samagotchi
     end
 
     # Load the installed bundles' plugins into +registries+; one that fails
-    # goes to +failures+, and the rest still load.
+    # goes to +failures+, and the rest still load. The block runs after them,
+    # still loading: what it shows is held with theirs.
     def load_plugins(registries, failures:)
       @held_events = []
       @loading = true
-      Plugin::Loader.load_installed(registries, failures: failures, settings: bundle_settings)
+      Plugin::Loader.load_installed(registries, failures: failures, settings: bundle_settings).tap { yield if block_given? }
     ensure
       @loading = false
     end

data/lib/samagotchi/guardrail_wiring.rb

@@ -44,12 +44,15 @@ module Samagotchi
     #   (a bundle's rules kept because it needs a newer chi)
     # @param system_one [#call] → SystemOne::Client or nil: the judgment client
     #   (nil while `guardrails.system_one.mode` is off or no host is set)
+    # @param system_one_runs [#call] → SystemOne::Runs or nil: where labels
+    #   and what an ask led to are saved
     # @param cancel_controller [#call] → the running turn's CancellationController, nil
     # @param participant [#call] (author) → the participant's
     #   Participants::Entry (participants.json: their name, their grant's
     #   mode), nil for none
     def initialize(scratch:, hooks:, tools:, session:, model_key:, cancelled:, ask:, model_name: -> {},
-                   notify: ->(_message) {}, system_one: -> {}, cancel_controller: -> {}, participant: ->(_author) {})
+                   notify: ->(_message) {}, system_one: -> {}, system_one_runs: -> {}, cancel_controller: -> {},
+                   participant: ->(_author) {})
       @scratch = scratch
       @hooks_lookup = hooks
       @tools_lookup = tools
@@ -60,6 +63,7 @@ module Samagotchi
       @ask = ask
       @notify = notify
       @system_one = system_one
+      @system_one_runs = system_one_runs
       @cancel_controller = cancel_controller
       @participant = participant
       @turn_mode = nil
@@ -273,6 +277,7 @@ module Samagotchi
           config_path: Samagotchi::ConfigFile.global_path,
           hooks_dir: Hooks::Loader.hooks_dir,
           context_dir: ContextSources.root,
+          runs_dir: File.join(File.dirname(@approvals.path, 2), "system_one"),
           home_path: ChiHome.path,
           shim_path: ChiShim.path
         )
@@ -375,11 +380,13 @@ module Samagotchi
       # judged is written after it, so the examples are always earlier asks.
       entries = log.entries
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      # A scratch session saves no run, so nothing hangs a later line on one.
+      run_id = SystemOne::Runs.new_id(SystemOne::ApprovalQuestion::JUDGMENT) unless @session_lookup.call&.scratch
       answers = begin
         client.ask(state: SystemOne::ApprovalQuestion.state(approval, session_title: @session_lookup.call&.title,
                                                             entries: entries),
                    questions: { SystemOne::ApprovalQuestion::ID => SystemOne::ApprovalQuestion.question },
-                   cancel_controller: @cancel_controller.call)
+                   cancel_controller: @cancel_controller.call, run_id: run_id)
       rescue LLM::RequestCancelled
         raise
       rescue StandardError => e
@@ -393,13 +400,14 @@ module Samagotchi
       auto = system_one_auto_allow?(client, approval, p, entries, targets: targets)
       decision = system_one_decision(client, auto)
 
-      id = log.judgment(session_id: @session_lookup.call&.id,
+      id = log.judgment(id: run_id, session_id: @session_lookup.call&.id,
                         rule: approval.rule, source: approval.source, tool: approval.tool,
                         **SystemOne::ApprovalQuestion.call_fields(approval),
                         repo_name: approval.repo_name,
                         p: p, threshold: Config.get("guardrails.system_one.threshold"), model: client.model,
                         latency_ms: latency_ms, decision: decision, origin: "live")
       # A judgment the log cannot hold is no judgment: the user is asked.
+      system_one_run_facts(run_id, approval, targets, id.nil? && auto ? "asked" : decision)
       { id: id, p: p, auto: auto && !id.nil? }
     rescue LLM::RequestCancelled
       raise
@@ -409,6 +417,22 @@ module Samagotchi
       nil
     end
 
+    # The saved run's later lines: what the ask led to, and what the gates
+    # say of it now, which can't be recomputed later (a rule list changes):
+    # a later comparison must tell a sweep of gated asks from ungated ones.
+    def system_one_run_facts(run_id, approval, targets, what)
+      runs = @system_one_runs.call
+      return unless run_id && runs&.on?
+
+      rule = approval.rule.to_s
+      runs.gates(run_id, rule: rule, rule_listed: system_one_rules.include?(rule),
+                         self_protect_refused: SystemOne::SelfProtect.refuse?(approval, targets: targets),
+                         threshold: Config.get("guardrails.system_one.threshold"))
+      runs.acted(run_id, what)
+    rescue StandardError => e
+      Samagotchi::Log.warn(:guardrails, "system_one_run_facts_failed", error: "#{e.class}: #{e.message}")
+    end
+
     # What the judgment line says it did: "auto" (System 1 answered for the
     # user), "asked" (on mode, the user decides), "audit" (nothing decided).
     def system_one_decision(client, auto)
@@ -450,43 +474,24 @@ module Samagotchi
       []
     end
 
-    # The user's answer to that ask, as a label on the judgment: the scope
-    # they took, a denial, or none for an ask that was cancelled. A parent
-    # agent's answer is not the user's: its allow labels nothing, and its
-    # deny is a label only where the parent could have allowed — a parent
-    # that was not allowed to permit says nothing about what the user would
-    # have done (docs/guardrails.md, "System 1").
+    # The answer to that ask, as a label on the judgment and on its saved run
+    # (SystemOne::ApprovalLabel: which answers are labels, how strong).
     def system_one_label(judgment, answer, payload)
       id = judgment && judgment[:id]
       return nil if id.nil?
 
-      scopes = Array(payload[:approval].scopes)
-      if !answer.is_a?(Samagotchi::QuestionAnswer)
-        label = "none"
-      elsif answer.parent_agent?
-        return nil if parent_allowed?(answer, scopes) || !parent_may_permit?(payload)
-
-        label = "deny"
-      else
-        index = answer.selected_indices.first
-        label = if index && index < scopes.size
-                  scopes[index] == "once" ? "allow_once" : "allow_wide"
-                else
-                  "deny"
-                end
-      end
-      system_one_log.label(id, label, question_id: (answer.id if answer.is_a?(Samagotchi::QuestionAnswer)))
+      label = SystemOne::ApprovalLabel.of(answer, scopes: Array(payload[:approval].scopes),
+                                                  parent_may_permit: -> { parent_may_permit?(payload) })
+      return nil if label.nil?
+
+      written = system_one_log.label(id, label.value, question_id: (answer.id if answer.is_a?(Samagotchi::QuestionAnswer)))
+      SystemOne::ApprovalLabel.save(@system_one_runs.call, id, label)
+      written
     rescue StandardError => e
       Samagotchi::Log.warn(:guardrails, "system_one_label_failed", error: "#{e.class}: #{e.message}")
       nil
     end
 
-    # Whether a parent's answer picked one of the offered scopes.
-    def parent_allowed?(answer, scopes)
-      index = answer.selected_indices.first
-      !index.nil? && index < scopes.size
-    end
-
     # Whether this session's parent level lets a parent allow a call at all,
     # and the ask is not one only the user may answer.
     def parent_may_permit?(payload)

data/lib/samagotchi/guardrails/chi_dirs.rb

@@ -12,8 +12,9 @@ module Samagotchi
     # words against, as this process's environment and config.yml name them
     # (read each call). Each surface keeps its set:
     #   .protected     the config dir, the hooks dir, the approval store's
-    #                  dir, the installed bundles' dir, attached context: an
-    #                  ask only the user may answer (ParentApprovals.chi_files?)
+    #                  dir, the installed bundles' dir, attached context,
+    #                  System 1's saved runs: an ask only the user may answer
+    #                  (ParentApprovals.chi_files?)
     #   .touches       .protected and the session repo's git hooks dir: a
     #                  rule's touches: chi_dirs (Targets#touches_chi?)
     #   .self_protect  .protected and the whole state dir, resolved: what
@@ -27,11 +28,13 @@ module Samagotchi
       module_function
 
       # chi's config dir, the hooks dir, the approval store's dir, the
-      # installed bundles' dir and attached context.
+      # installed bundles' dir, attached context and System 1's saved runs
+      # (labels there may train a model: no agent writes them).
       def protected
         hooks = begin Hooks::Loader.hooks_dir rescue nil end
         bundles = begin MemoryPaths.bundles_dir rescue nil end
-        [ConfigFile.config_dir, hooks, File.join(Paths.state_dir, "guardrails"), bundles, File.join(Paths.state_dir, "context")]
+        [ConfigFile.config_dir, hooks, File.join(Paths.state_dir, "guardrails"), bundles, File.join(Paths.state_dir, "context"),
+         File.join(Paths.state_dir, "system_one")]
           .compact.map { |dir| dir.to_s.chomp("/") }.reject(&:empty?).uniq
       end
 

data/lib/samagotchi/guardrails/path_resolve.rb

@@ -9,7 +9,7 @@ module Samagotchi
     # Outside, ShellPaths, RmTargets, ReviewPaths, PairCommand, Targets,
     # ParentApprovals, System 1's SelfProtect). Each surface keeps its own
     # predicate; this only says where a path lands and whether it is in a
-    # dir. docs/internals/tool-guardrails.md maps which surface uses which.
+    # dir. docs/internals/tool-output-limits.md maps which surface uses which.
     module PathResolve
       # How many symlinks .real follows on a path that doesn't exist
       # (about the kernel's own ELOOP limit).

data/lib/samagotchi/guardrails/protected_paths.rb

@@ -11,9 +11,10 @@ module Samagotchi
     # lexical answer and where the write lands, a vote when either is
     # protected).
     #   deny: the approval store's dir, installed bundles (.bundles/:
-    #         hooks, rules, manifests) and attached context (a source's
+    #         hooks, rules, manifests), attached context (a source's
     #         command runs later, outside the gate; chi context writes
-    #         it); nothing legitimate writes there through the file tools.
+    #         it) and System 1's saved runs (a label there may train a
+    #         model); nothing legitimate writes there through the file tools.
     #   ask (once / session): config.yml, home.json (the chi home: the
     #         Ruby every chi launch boots), the chi shim (ChiShim: the
     #         `chi` every tool runs) and the plain hooks dir. The
@@ -31,13 +32,15 @@ module Samagotchi
       # @param config_path [String] config.yml
       # @param hooks_dir [String] the plain hooks dir
       # @param context_dir [String, nil] <state dir>/context (ContextSources.root)
+      # @param runs_dir [String, nil] <state dir>/system_one (SystemOne::Runs)
       # @param home_path [String, nil] home.json (ChiHome.path)
       # @param shim_path [String, nil] the chi shim (ChiShim.path)
-      def initialize(store_dir:, bundles_dir:, config_path:, hooks_dir:, context_dir: nil, home_path: nil, shim_path: nil)
+      def initialize(store_dir:, bundles_dir:, config_path:, hooks_dir:, context_dir: nil, runs_dir: nil, home_path: nil, shim_path: nil)
         @deny = [
           ["guardrail-store", store_dir, "the approval store belongs to the user"],
           ["installed-bundles", bundles_dir, "installed bundles (hooks, rules, manifests) are changed by chi bundle install"],
-          ["chi-context", context_dir, "attached context sources run commands; change them with chi context"]
+          ["chi-context", context_dir, "attached context sources run commands; change them with chi context"],
+          ["system-one-runs", runs_dir, "System 1's saved runs are chi's own record"]
         ]
         @ask = [
           ["chi-config", config_path, "changes chi's config.yml"],

data/lib/samagotchi/guardrails_command.rb

@@ -39,7 +39,7 @@ module Samagotchi
           user-only). --threshold overrides guardrails.system_one.threshold
           for the table; --model overrides the configured model for this run.
           --dry-run judges and prints the table without writing a line. Needs
-          guardrails.system_one.mode audit or on and a guardrails.system_one.host
+          guardrails.system_one.mode audit or on and a system_one.host
           (exit 2 without one).
     TEXT
 
@@ -146,10 +146,10 @@ module Samagotchi
       threshold = threshold(options[:threshold])
       return usage_error(threshold) if threshold.is_a?(String)
 
-      client = @client || SystemOne::Client.from_config(host_registry: HostRegistry.new, model: options[:model])
+      client = @client || SystemOne::Client.from_config(host_registry: HostRegistry.new, mode: Config.get("guardrails.system_one.mode"), model: options[:model])
       if client.nil?
         error_line("chi guardrails replay: no System 1 client — set guardrails.system_one.mode to audit or on " \
-                   "and guardrails.system_one.host in config.yml")
+                   "and system_one.host in config.yml")
         return CLI::Exit::USAGE
       end
 

data/lib/samagotchi/judgments_command.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "cli/command"
+require_relative "cli/exit"
+require_relative "cli/flags"
+require_relative "session"
+require_relative "system_one/runs"
+
+module Samagotchi
+  # `chi judgments`: what System 1's saved runs hold (docs/system-one.md).
+  # Reads only: it never asks a model or changes a run.
+  class JudgmentsCommand
+    include CLI::Command
+
+    USAGE = <<~TEXT
+      Usage: chi judgments ls
+             chi judgments report NAME [--days N]
+        System 1's saved asks on this machine. ls: each judgment's digests,
+        runs, labels, failures, models and size. report: one judgment's counts,
+        p histogram and labels by value, over N days (default: all that's kept).
+    TEXT
+
+    SUBCOMMANDS = %w[ls report].freeze
+    FLAGS = { "ls" => CLI::Flags.new(args: false), "report" => CLI::Flags.new { |flags| flags.value "--days" } }.freeze
+    BINS = 10
+
+    # @param argv [Array<String>] the arguments after "judgments"
+    # @param sessions_dir [String, nil] the sessions folder (a spec seam)
+    # @param now [Time] the report's clock (a spec seam)
+    def initialize(argv, stdout: $stdout, stderr: $stderr, sessions_dir: nil, now: Time.now)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @store = SystemOne::RunsStore.new(File.dirname(sessions_dir || Session.default_state_dir))
+      @now = now
+    end
+
+    def run
+      @sub = @argv.first
+      if @sub.nil? || HELP_WORDS.include?(@sub)
+        @stdout.puts(USAGE)
+        return CLI::Exit::OK
+      end
+      return usage_error("unknown subcommand #{@sub}") unless SUBCOMMANDS.include?(@sub)
+
+      parsed = parse_flags(FLAGS.fetch(@sub), @argv[1..])
+      return parsed if parsed.is_a?(Integer)
+
+      @sub == "ls" ? ls : report(parsed)
+    end
+
+    private
+
+    def command_name = @sub ? "chi judgments #{@sub}" : "chi judgments"
+
+    def ls
+      names = @store.names
+      if names.empty?
+        @stdout.puts("No saved runs.")
+        return CLI::Exit::OK
+      end
+
+      names.each { |name| @stdout.puts(ls_line(name)) }
+      CLI::Exit::OK
+    end
+
+    def ls_line(name)
+      runs, later = @store.lines(name).partition { |line| line["kind"] == "run" }
+      models = runs.filter_map { |run| run["served_model"] || run["model"] }.uniq
+      "#{name}  digests #{@store.versions(name).size}  runs #{runs.size}  " \
+        "labels #{last_labels(runs, later).size}  failures #{runs.count { |run| run["failure"] }}  " \
+        "models #{models.empty? ? "none" : models.join(", ")}  #{size_text(@store.size(name))}"
+    end
+
+    def size_text(bytes)
+      return "#{bytes} B" if bytes < 1024
+      return format("%.1f KB", bytes / 1024.0) if bytes < 1024 * 1024
+
+      format("%.1f MB", bytes / (1024.0 * 1024))
+    end
+
+    def report(parsed)
+      name = parsed.args.first
+      return usage_error("report takes one judgment's name (see chi judgments ls)") if parsed.args.size != 1
+      return usage_error("not a judgment's name: #{name}") unless name.match?(SystemOne::RunsStore::NAME)
+
+      days = parsed.options[:days]
+      return usage_error("--days takes a positive whole number") if days && !days.to_s.match?(/\A[1-9]\d*\z/)
+
+      since = days && (@now.utc - (Integer(days, 10) * 86_400)).strftime("%F")
+      runs, later = @store.lines(name).partition { |line| line["kind"] == "run" }
+      runs = runs.select { |run| since.nil? || run["at"].to_s[0, 10] >= since }
+      if runs.empty?
+        @stdout.puts("No runs of #{name}#{" in the last #{days} days" if days}.")
+        return CLI::Exit::OK
+      end
+
+      print_report(name, days, runs, later)
+      CLI::Exit::OK
+    end
+
+    def print_report(name, days, runs, later)
+      @stdout.puts("#{name} · #{days ? "last #{days} days" : "all kept"}")
+      asked = runs.count { |run| run["asked"] != false }
+      @stdout.puts("runs #{runs.size}  asked #{asked}  skipped #{runs.size - asked}  failures #{runs.count { |run| run["failure"] }}  " \
+                   "truncated #{runs.count { |run| run["truncated"] }}  test runs #{runs.count { |run| run["test_run"] }}")
+      failures = tally(runs.filter_map { |run| run["failure"] })
+      @stdout.puts("failures by class: #{failures}") unless failures.empty?
+      print_answers(runs)
+      last = last_labels(runs, later)
+      ids = runs.to_h { |run| [run["id"], true] }
+      @stdout.puts("labels: #{last.empty? ? "none" : tally(last.map { |line| "#{line["value"]} (#{line["by"]})" })}")
+      acted = later.select { |line| line["kind"] == "acted" && ids[line["run_id"]] }
+      @stdout.puts("acted: #{tally(acted.map { |line| line["what"] })}") unless acted.empty?
+    end
+
+    # One label per run and question: the last said. One whose run is gone
+    # or out of the window doesn't count.
+    def last_labels(runs, later)
+      ids = runs.to_h { |run| [run["id"], true] }
+      labels = later.select { |line| line["kind"] == "label" && ids[line["run_id"]] }
+      labels.to_h { |line| [[line["run_id"], line["question"]], line] }.values
+    end
+
+    def print_answers(runs)
+      answers = runs.flat_map { |run| (run["answers"].is_a?(Hash) ? run["answers"] : {}).to_a }
+      answers.group_by(&:first).sort.each do |question, pairs|
+        values = pairs.map(&:last).grep(Hash)
+        probabilities = values.filter_map { |answer| answer["noul"] || answer["confidence"] }.grep(Numeric).select { |p| p.between?(0, 1) }
+        kind = values.first&.fetch("type", nil)
+        @stdout.puts("#{question} (#{kind}): #{probabilities.size} with a p#{", picks #{picks(values)}" if picks(values)}")
+        histogram(probabilities).each { |line| @stdout.puts("  #{line}") }
+      end
+    end
+
+    def picks(values)
+      chosen = values.filter_map { |answer| answer["choice"] }
+      chosen.empty? ? nil : tally(chosen)
+    end
+
+    def histogram(values)
+      return [] if values.empty?
+
+      counts = Array.new(BINS, 0)
+      values.each { |value| counts[[(value.to_f * BINS).floor, BINS - 1].min] += 1 }
+      counts.each_with_index.map do |count, bin|
+        format("%.1f–%.1f %5d", bin.to_f / BINS, (bin + 1).to_f / BINS, count)
+      end
+    end
+
+    def tally(values)
+      values.tally.sort_by { |value, count| [-count, value.to_s] }.map { |value, count| "#{value} #{count}" }.join(", ")
+    end
+  end
+end

data/lib/samagotchi/kernel_loop.rb

@@ -193,6 +193,16 @@ module Samagotchi
     attr_accessor :generation_guard
 
     # The generation guard, if any; one that raises never breaks the turn.
+    # The model's context window as this loop knows it (ContextWindow.resolve
+    # on the client and the turn's setting): ToolRunner halves it for
+    # memory_read's overflow guard. nil when it can't be read.
+    # @return [ContextWindow::Resolved, nil]
+    def tool_output_window
+      ContextWindow.resolve(client: @client, model: @turn_settings&.model_name, setting: @turn_settings&.window_setting)
+    rescue StandardError
+      nil
+    end
+
     def guard_generation
       @generation_guard&.call
     rescue StandardError => e
@@ -306,7 +316,9 @@ module Samagotchi
     # Precedence: an explicit override wins, then max_tool_output_chars
     # (Config). A non-positive value falls back to
     # DEFAULT_MAX_TOOL_OUTPUT_CHARS (there is intentionally no "unlimited" — live UIs get a
-    # bounded `output:` plus a truthful `output_truncated:` flag).
+    # bounded `output:` plus a truthful `output_truncated:` flag). The one
+    # exception is memory_read, which ToolRunner leaves out of this cap
+    # (memory.read_max_chars, 0: no fixed cap; a memory is read whole).
     # Class-level so the chat loop resolves it the same way.
     def self.resolve_output_char_cap(override)
       parsed = (override || Samagotchi::Config.get("max_tool_output_chars")).to_i