samagotchi 0.141.0 → 0.143.0

data/lib/samagotchi/plugin/judgments.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../system_one/runs"
+
+module Samagotchi
+  module Plugin
+    # ctx.judgments: what came of a bundle's own runs (docs/plugins.md,
+    # Judgments), saved as later lines on them. A bundle's lines say it is
+    # theirs (+by+ is its name), and it reaches no one else's runs.
+    class Judgments
+      MAX_TEXT = 200
+      STRENGTHS = %w[strong weak].freeze
+
+      # @param layer [#call] → the SystemOne::Judgments to save through
+      # @param bundle [String]
+      def initialize(layer, bundle:)
+        @layer = layer
+        @bundle = bundle
+      end
+
+      # The bundle's own word for its run: a raw value now, mapped at analysis.
+      # @param run_id [String, nil] ctx.judge's Result#run_id, or what
+      #   ctx.judge_later returned; nil (no run was saved) saves nothing
+      # @param value [String] up to 200 characters
+      # @param by [String, nil] what said it, after the bundle's name ("card":
+      #   "check-in:card")
+      # @param strength [String, nil] "strong" or "weak"
+      # @param question [String, nil] the question it answers
+      # @return [Boolean] whether it was saved
+      # @raise [ArgumentError] a run of another bundle's, a bad value
+      def label(run_id, value, by: nil, strength: nil, question: nil)
+        value = text("label", value)
+        raise ArgumentError, "strength: is #{STRENGTHS.join(" or ")}, not #{strength.inspect}" unless strength.nil? || STRENGTHS.include?(strength.to_s)
+        return false unless own?(run_id)
+
+        @layer.call.label(run_id, value, by: by.to_s.strip.empty? ? @bundle : "#{@bundle}:#{text("by", by)}",
+                                         strength: strength&.to_s, question: question && text("question", question.to_s))
+      end
+
+      # What the bundle did with the answer: never known when the run is saved.
+      # @param what [String] up to 200 characters
+      # @return [Boolean] whether it was saved
+      # @raise [ArgumentError] a run of another bundle's, a bad value
+      def acted(run_id, what)
+        what = text("acted", what)
+        return false unless own?(run_id)
+
+        @layer.call.acted(run_id, what)
+      end
+
+      private
+
+      # False for nil; a run of anything but a judgment this bundle declared
+      # raises (a name it can't declare has no run of its).
+      def own?(run_id)
+        return false if run_id.nil?
+
+        judgment = SystemOne::Runs.judgment_of(run_id)
+        return true if judgment&.start_with?("#{@bundle}.") && @layer.call.declared?(judgment)
+
+        raise ArgumentError, "#{run_id.inspect} is not a run of bundle #{@bundle}'s"
+      end
+
+      def text(what, value)
+        word = value.to_s.strip
+        return word if value.is_a?(String) && word.length.between?(1, MAX_TEXT)
+
+        raise ArgumentError, "#{what} takes a String of 1 to #{MAX_TEXT} characters, not #{value.inspect[0, 40]}"
+      end
+    end
+  end
+end

data/lib/samagotchi/plugin/loader.rb

@@ -22,10 +22,13 @@ module Samagotchi
     # +tool_index+ the Engine's Tools::ToolIndex (chi.tool_source);
     # +peer_sources+ the Engine's PeerSources (chi.peer_source);
     # +prompt_sections+ the Engine's PromptSections (chi.prompt_section),
-    # +prompt_changed+ rebuilds its system prompts (chi.prompt_changed!).
+    # +prompt_changed+ rebuilds its system prompts (chi.prompt_changed!),
+    # +judgments+ the Engine's SystemOne::Judgments (chi.judgment),
+    # +hook_failed+ is (label, "Class: message") when a chi.on handler
+    # raises (HookRoutes#plugin_hook_failed).
     Registries = Struct.new(:commands, :tools, :hooks, :context_for, :tools_changed, :services, :stage_tools, :init,
-                            :toolkits, :tool_index, :peer_sources, :prompt_sections, :prompt_changed,
-                            keyword_init: true)
+                            :toolkits, :tool_index, :peer_sources, :prompt_sections, :prompt_changed, :judgments,
+                            :hook_failed, keyword_init: true)
 
     # Loads installed bundles' plugins (manifest plugin: {file:, sha256:})
     # into an Engine's registries (docs/plugins.md).

data/lib/samagotchi/plugin/peer.rb

@@ -10,7 +10,7 @@ require_relative "../paths"
 module Samagotchi
   module Plugin
     # The base of the peer bundles' plugins (claude-peer, codex-peer;
-    # docs/plugins.md): a live link between a chi session and another agent's
+    # docs/bundles.md): a live link between a chi session and another agent's
     # session the user works with. The peer pairs (its chi-peer skill,
     # scripts/pair): it attaches the `<peer>-inbox` context, whose hint says
     # where to send (a subclass's #check_hint!), and `<peer>-outbox`, where
@@ -131,11 +131,11 @@ module Samagotchi
         body, where = if text.length <= INLINE_CHARS
                         [text, "inline"]
                       else
-                        path = write_payload(ctx, id, title, text)
+                        path = write_payload(ctx, title, text)
                         ["payload: #{path} (#{text.lines.size} lines, #{text.length} chars)", path]
                       end
         post(hint, "chi #{id[0, 8]} · #{kind} · #{title}\n#{body}")
-        record(ctx, id, kind: kind, title: title, chars: text.length, payload: where == "inline" ? nil : where)
+        record(ctx, kind: kind, title: title, chars: text.length, payload: where == "inline" ? nil : where)
         "sent to #{self.class::NAME}: #{kind} · #{title}#{" (the text in #{where})" unless where == "inline"}"
       end
 
@@ -153,7 +153,7 @@ module Samagotchi
         left = ctx.context.left_behind.find { |row| row.name == peer::INBOX }
         hint = left&.hint.to_s.strip
         return "no #{peer::INBOX} left behind" if hint.empty?
-        return "asked already" unless claim_moved(ctx, id)
+        return "asked already" unless claim_moved(ctx)
 
         check_hint!(hint)
         post(hint, moved_message(previous, id))
@@ -175,9 +175,9 @@ module Samagotchi
 
       private
 
-      # Takes the moved marker for session +id+; false when it is there.
-      def claim_moved(ctx, id)
-        File.open(File.join(session_dir(ctx, id), MOVED_MARKER), File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
+      # Takes this session's moved marker; false when it is there.
+      def claim_moved(ctx)
+        File.open(File.join(ctx.session_dir, MOVED_MARKER), File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
           file.write("#{Time.now.utc.iso8601}\n")
         end
         true
@@ -302,7 +302,7 @@ module Samagotchi
                   ["**not paired.** In #{peer::APP}, install the chi-peer skill (Install skill below), then tell " \
                    "#{peer::NAME} \"pair with chi #{id.to_s[0, 8]}\"."]
                 end
-        lines << "last send: #{last_send_line(ctx, id)}" if id && last_send(ctx, id)
+        lines << "last send: #{last_send_line(ctx)}" if id && last_send(ctx)
         lines << "last answer (#{peer::OUTBOX}): #{outbox_line(outbox)}" if outbox
         lines << "skill: **differs from this bundle's**: #{peer::COMMAND} install-skill (Replace), then pair again" if skill_differs?(ctx)
         lines << transport_line
@@ -312,15 +312,15 @@ module Samagotchi
         nil
       end
 
-      def last_send(ctx, id)
-        path = File.join(ctx.data_dir, "sessions", id, LAST_SEND)
+      def last_send(ctx)
+        path = File.join(ctx.session_dir, LAST_SEND)
         File.file?(path) ? JSON.parse(File.read(path)) : nil
       rescue JSON::ParserError, SystemCallError
         nil
       end
 
-      def last_send_line(ctx, id)
-        sent = last_send(ctx, id)
+      def last_send_line(ctx)
+        sent = last_send(ctx)
         where = sent["payload"] ? "in `#{sent["payload"]}`" : "inline"
         "#{ago(sent["at"])} · #{sent["kind"]} · #{sent["title"]} (#{sent["chars"]} chars, #{where})"
       end
@@ -424,10 +424,9 @@ module Samagotchi
         end
       end
 
-      # sessions/<id>/<HHMMSS>-<slug>.md under the bundle's data dir, readable
-      # by its owner only.
-      def write_payload(ctx, id, title, text)
-        dir = session_dir(ctx, id)
+      # <HHMMSS>-<slug>.md in ctx.session_dir, readable by its owner only.
+      def write_payload(ctx, title, text)
+        dir = ctx.session_dir
         base = "#{Time.now.strftime("%H%M%S")}-#{slug(title)}"
         path = File.join(dir, "#{base}.md")
         n = 1
@@ -438,13 +437,9 @@ module Samagotchi
         raise SendError, "couldn't write the payload file: #{e.message}"
       end
 
-      def session_dir(ctx, id)
-        File.join(ctx.data_dir, "sessions", id).tap { |dir| FileUtils.mkdir_p(dir) }
-      end
-
-      def record(ctx, id, **send)
+      def record(ctx, **send)
         entry = { at: Time.now.utc.iso8601, **send }
-        @lock.synchronize { File.write(File.join(session_dir(ctx, id), LAST_SEND), JSON.generate(entry)) }
+        @lock.synchronize { File.write(File.join(ctx.session_dir, LAST_SEND), JSON.generate(entry)) }
       rescue SystemCallError => e
         ctx.log.info(:last_send_not_saved, error: e.message)
       end

data/lib/samagotchi/plugin_session_state.rb

@@ -5,14 +5,41 @@ require_relative "paths"
 require_relative "session"
 
 module Samagotchi
-  # A plugin's state for one session, by convention under its data dir
-  # (ctx.data_dir): sessions/<id>.json or sessions/<id>/. It goes when the
-  # session does (SessionManager.delete_session: the CLI, the web, a
-  # discarded empty session; SessionRetention's prune), so no bundle keeps
-  # state for sessions that are gone (check-in's /checkin settings).
+  # A plugin's state for one session, under its data dir (ctx.data_dir):
+  # sessions/<id>/ (ctx.session_dir), or sessions/<id>.json, the file a bundle
+  # written before ctx.session_dir may still keep. It goes when the session
+  # does (SessionManager.delete_session: the CLI, the web, a discarded empty
+  # session; SessionRetention's prune), so no bundle keeps state for sessions
+  # that are gone (check-in's /checkin settings).
   module PluginSessionState
+    # What sessions/<id>.json becomes in the folder (.dir), the name the
+    # shipped bundles that used it now write.
+    STATE_FILE = "state.json"
+
     module_function
 
+    # A session's folder under a bundle's +data_dir+, created. A
+    # sessions/<id>.json there moves in as STATE_FILE, so a running session
+    # keeps it when its bundle moves to ctx.session_dir.
+    # @return [String, nil] nil for an id that isn't a plain one (it could
+    #   name a path outside the dir)
+    def dir(data_dir, session_id)
+      id = session_id.to_s
+      return nil unless Session.valid_id?(id)
+
+      path = File.join(data_dir, "sessions", id)
+      FileUtils.mkdir_p(path)
+      adopt("#{path}.json", File.join(path, STATE_FILE))
+      path
+    end
+
+    def adopt(old, state)
+      File.rename(old, state) if File.file?(old) && !File.exist?(state)
+    rescue SystemCallError
+      nil # another worker's move, or a file that stays where it is
+    end
+    private_class_method :adopt
+
     # @return [Array<String>] the paths removed
     def remove(session_id, env: ENV)
       id = session_id.to_s

data/lib/samagotchi/prompt_warmup.rb

@@ -38,10 +38,6 @@ module Samagotchi
     DECIDE_TIMEOUT = 3
     # Seconds #stop waits for a killed warm-up's thread to end.
     STOP_JOIN_SECONDS = 1
-    # Seconds a warm-up waits for the side asks sent to the same server
-    # before it (#start's +after+: the candidate judge's, which evict the
-    # cached prefix the warm-up is there to restore).
-    AFTER_SECONDS = 5
 
     # Whether cache.warmup allows a warm-up (auto, the default; off, false,
     # no or 0 turn it off; on/true/1 (YAML's unquoted on) are auto; anything
@@ -71,11 +67,8 @@ module Samagotchi
     # Start a warm-up of +prompt+ on +client+ in its own thread.
     # @param slot [Integer, nil] the last request's slot (nil: unpinned, and
     #   nothing to pin the next request to)
-    # @param after [Thread, nil] asks to the same server that go first: the
-    #   warm-up waits for them (AFTER_SECONDS at most), so it re-warms what
-    #   they evicted
     # @return [Thread, nil] nil once #stop ran
-    def start(client:, prompt:, model:, slot:, images: [], after: nil)
+    def start(client:, prompt:, model:, slot:, images: [])
       return nil if @mutex.synchronize { @stopped }
 
       # Whether the warm-up went to its slot (true) or was skipped: the
@@ -83,7 +76,6 @@ module Samagotchi
       sent = Queue.new
       thread = Thread.new do
         Thread.current.report_on_exception = false
-        after&.join(AFTER_SECONDS)
         busy = slot.is_a?(Integer) && client.slot_status(slot, model: model) == :busy
         sent << !busy
         next skip(slot) if busy

data/lib/samagotchi/run_options.rb

@@ -207,6 +207,7 @@ module Samagotchi
                  chi memory <ls|rm> [--scope project|system]   the memories; rm moves one to the bundle trash
                  chi bundle <install|upgrade|uninstall|status|diff|list|build|trash|new|test|check|try>
                  chi guardrails replay [--dry-run] [--threshold T] [--model M]   seed System 1's record from answered approvals
+                 chi judgments ls | report NAME  System 1's saved asks on this machine
                  chi toolkit report [--days N]   grade toolkit suggestions against the tools sessions used
                  chi desktop <install|upgrade|uninstall|status>   macOS "Send to chi" helper
                  chi models [--format json] [TEXT]   the models --model takes, from every host

data/lib/samagotchi/self_report.rb

@@ -21,6 +21,7 @@ require_relative "memory_bundle/provenance"
 require_relative "memory_bundle/manifest"
 require_relative "memory_bundle/system_bundle"
 require_relative "memory_bundle/index_size"
+require_relative "memory_bundle/entry_size"
 require_relative "desktop"
 require_relative "live_versions"
 require_relative "web/lan"
@@ -60,6 +61,7 @@ module Samagotchi
         ["memories", Tools::MemoryRead.memories_dir("system", env: env)],
         ["project memories", Tools::MemoryRead.memories_dir("project", env: env)],
         ["memory index", memory_index_summary(env)],
+        ["big memories", big_memories_summary(env)],
         ["sessions", Session.default_state_dir(env: env)],
         ["log", log_path(env)],
         ["model", model ? model_label(model, default, env) : "(not configured)"],
@@ -122,6 +124,40 @@ module Samagotchi
       "(unreadable: #{e.message})"
     end
 
+    # How many big memories "big memories" names before "+N more".
+    BIG_MEMORIES_SHOWN = 5
+
+    # The memories over memory.entry_warn_tokens in both scopes, largest
+    # first, "name ~5.6k tokens (system, from samagotchi-system)": each
+    # memory_read of one pays its size, and a memory already over gets no
+    # crossing note. A bundle's memory says whose it is (upstream's to
+    # tighten). "none" when there are none, "off" with the limit 0. A scope
+    # that can't be read is named instead.
+    def big_memories_summary(env)
+      limit = MemoryBundle::EntrySize.warn_limit
+      return "off (memory.entry_warn_tokens 0)" unless limit.positive?
+
+      big = []
+      unreadable = []
+      %w[system project].each do |scope|
+        big.concat(MemoryBundle::EntrySize.over_limit(scope, limit: limit, env: env))
+      rescue StandardError => e
+        unreadable << "#{scope} memories unreadable: #{e.message}"
+      end
+      shown = big.sort_by { |size| [-size.tokens, size.scope, size.name] }.first(BIG_MEMORIES_SHOWN).map { |size| big_memory(size, env) }
+      shown << "+#{big.size - BIG_MEMORIES_SHOWN} more" if big.size > BIG_MEMORIES_SHOWN
+      parts = shown + unreadable.map { |text| "(#{text})" }
+      parts.empty? ? "none" : parts.join(", ")
+    end
+
+    def big_memory(size, env)
+      owner = MemoryBundle::Provenance.claimants("#{size.name}.md", scope: size.scope, dir: MemoryPaths.bundles_dir(env: env)).first
+      where = [size.scope, ("from #{owner}" if owner)].compact.join(", ")
+      "#{size.name} ~#{MemoryBundle::IndexSize.count_text(size.tokens)} tokens (#{where})"
+    rescue StandardError
+      "#{size.name} ~#{MemoryBundle::IndexSize.count_text(size.tokens)} tokens (#{size.scope})"
+    end
+
     def with_presence(path)
       File.exist?(path) ? path : "#{path} (missing)"
     end

data/lib/samagotchi/session_access/contract.rb

@@ -26,7 +26,7 @@ module Samagotchi
       # bin/chi subcommands that act on this machine: never sessions. chi
       # remote (this machine's list of remotes) runs here under a remote too
       # (Dispatch); the others are refused there.
-      MACHINE = %w[bootstrap update models desktop memory bundle guardrails toolkit remote home].freeze
+      MACHINE = %w[bootstrap update models desktop memory bundle guardrails toolkit judgments remote home].freeze
 
       # "command", "command sub" or either with a flag (its long name) →
       # SUPPORTED or LOCAL_ONLY. A LOCAL_ONLY command or subcommand lists

data/lib/samagotchi/session_access/local.rb

@@ -271,7 +271,7 @@ module Samagotchi
       # @return [SessionManager::RestartResult]
       def restart(id) = SessionManager.restart_session(id, **dir)
 
-      # @return [Hash] SessionManager.archive_session's
+      # @return [SessionManager::ArchiveResult]
       def archive(id) = SessionManager.archive_session(id, **dir)
 
       # @return [Hash] SessionManager.unarchive_session's

data/lib/samagotchi/session_access/remote.rb

@@ -432,13 +432,13 @@ module Samagotchi
                                       version: reply.json["version"])
       end
 
-      # @return [Hash] {id:, archived:, stopped:, discarded:}
+      # @return [SessionManager::ArchiveResult] the reply's lists coerced to arrays
       def archive(id)
         reply = request(:post, "#{session_path(id)}/archive")
         raise_refusal(reply) unless reply.status == 200
 
-        { id: reply.json["session_id"] || id, archived: Array(reply.json["archived"]), stopped: Array(reply.json["stopped"]),
-          discarded: Array(reply.json["discarded"]) }
+        SessionManager::ArchiveResult.new(id: reply.json["session_id"] || id, archived: Array(reply.json["archived"]),
+                                          stopped: Array(reply.json["stopped"]), discarded: Array(reply.json["discarded"]))
       end
 
       # @return [Hash] {id:, unarchived:}

data/lib/samagotchi/session_archive_command.rb

@@ -64,10 +64,10 @@ module Samagotchi
       id = @access.resolve_id(given)
       short = id[0, 8]
       result = @access.archive(id)
-      if result[:archived].include?(id)
+      if result.archived.include?(id)
         notes = []
-        notes << "stopped its worker" if result[:stopped].include?(id)
-        others = result[:archived].size - 1
+        notes << "stopped its worker" if result.stopped.include?(id)
+        others = result.archived.size - 1
         notes << "and #{others} delegate#{"s" if others != 1}" if others.positive?
         @stdout.puts("#{short}  archived#{" (#{notes.join(", ")})" unless notes.empty?}")
       else

data/lib/samagotchi/session_commands.rb

@@ -23,6 +23,7 @@ require_relative "working_set_command"
 require_relative "recap_command"
 require_relative "guardrails/parent_policy"
 require_relative "system_one/log"
+require_relative "system_one/approval_label"
 require_relative "system_one/record"
 
 module Samagotchi
@@ -480,6 +481,8 @@ module Samagotchi
         return reply("could not label System 1 auto-allow #{index} (see the guardrails log)", status: :error)
       end
 
+      SystemOne::ApprovalLabel.save(SystemOne::Runs.for_sessions_dir(@engine.session_state_dir), entry["id"], SystemOne::ApprovalLabel::WRONG)
+
       call = shorten_call(entry["call"].to_s.gsub(/\s+/, " "))
       probability = entry["p"].nil? ? "unknown" : format("%.2f", entry["p"].to_f)
       reply("labelled auto-allow #{index}: #{entry["rule"]}: #{call} (p=#{probability}); " \
@@ -965,13 +968,13 @@ module Samagotchi
       # Sort hosts for deterministic output
       results.keys.sort.each do |hname|
         data = results[hname]
-        host_label = "#{hname} (#{data[:host]}:#{data[:port]})"
+        host_label = "#{hname} (#{data.host}:#{data.port})"
         # Declared ids (hosts.<name>.models) first, as "(config)", never cut
         # by MODELS_PER_HOST; a host that failed keeps only those, as
         # "(config, host down)" under its unreachable line.
         rows = host_rows.fetch(hname, [])
-        if data[:error]
-          lines << "#{host_label} — unreachable: #{data[:error]}"
+        if data.error
+          lines << "#{host_label} — unreachable: #{data.error}"
           next if rows.empty?
         elsif rows.empty?
           lines << "#{host_label} — no models discovered"
@@ -992,7 +995,7 @@ module Samagotchi
         end
         next if declared.empty? && shown.empty?
 
-        lines << "#{host_label}:" unless data[:error]
+        lines << "#{host_label}:" unless data.error
         hidden = needle.empty? ? [shown.size - MODELS_PER_HOST, 0].max : 0
         (declared + shown.first(shown.size - hidden)).each do |row, identifier|
           raw = row.info&.raw || {}

data/lib/samagotchi/session_config.rb

@@ -196,18 +196,24 @@ module Samagotchi
           if keys.nil?
             raise Error, "#{where}: #{unknown_core("#{bundle}.#{key}", bundles: bundles)}" if note.nil? && core_section?(bundle)
 
-            raise Error, "#{where}: #{note || "no installed bundle #{bundle} (#{takers(bundles)})"}"
+            raise Error, "#{where}: #{note || "#{no_installed_bundle(bundle)} (#{takers(bundles)})"}"
           end
           raise Error, "#{where}: #{bundle} takes no session settings#{" #{note}" if note}" if keys.empty?
-          raise Error, "#{where}: #{bundle} takes #{keys.join(", ")}" unless keys.include?(key)
+          raise Error, "#{where}: #{takes_keys(bundle, keys)}" unless keys.include?(key)
 
           takes, what = TYPES[types.dig(bundle, key)]
-          raise Error, "#{where}: #{bundle} takes #{what} for #{key}, not #{value.inspect}" if takes && !takes.call(value)
+          raise Error, "#{where}: #{wrong_type(bundle, key, what, value)}" if takes && !takes.call(value)
         end
       end
       settings
     end
 
+    # One message per condition: --set's refusals (.check!) and config.yml's
+    # warnings (BundleSettingsCheck).
+    def no_installed_bundle(bundle) = "no installed bundle #{bundle}"
+    def takes_keys(bundle, keys) = keys.empty? ? "#{bundle} takes no settings" : "#{bundle} takes #{keys.join(", ")}"
+    def wrong_type(bundle, key, what, value) = "#{bundle} takes #{what} for #{key}, not #{value.inspect}"
+
     # --set's values parsed and checked (.parse, .check!) against the
     # installed bundles (.availability).
     # @return [Settings]

data/lib/samagotchi/session_continue.rb

@@ -134,7 +134,7 @@ module Samagotchi
         ArchiveStore.archived?(Session.session_dir(sid, state_dir: state_dir))
       end
       archive = SessionManager.archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)
-      archived = archive[:archived] - already
+      archived = archive.archived - already
       begin
         spawn_continuation(previous, prompt: prompt, preview: preview, choice: checked.choice, state_dir: state_dir,
                                      move: plan.move)

data/lib/samagotchi/session_manager.rb

@@ -6,6 +6,7 @@ require "time"
 require "securerandom"
 require "rbconfig"
 require_relative "chi_home"
+require_relative "system_one/runs"
 require_relative "child_env"
 require_relative "client_id"
 require_relative "analytics_file"
@@ -45,6 +46,7 @@ require_relative "continue_offer"
 require_relative "image_store"
 require_relative "plugin_session_state"
 require_relative "context_sources"
+require_relative "context_candidates_log"
 require_relative "session_chain"
 require_relative "child_move"
 require_relative "tools/task_runtime"
@@ -393,11 +395,15 @@ module Samagotchi
         .select { |s| s[:parent_id] == parent_id.to_s }
     end
 
+    # What one archive did: id: the session it was asked for; archived: the
+    # ids (it and its delegates) now hidden for good; stopped: the live
+    # workers stopped first; discarded: empty sessions its stopping worker deleted.
+    ArchiveResult = Data.define(:id, :archived, :stopped, :discarded)
+
     # Archive a session and its delegated children (ArchiveStore): hidden
     # from every list, kept by the retention sweep. A live idle worker is
     # stopped first; the marker is written even while it shuts down.
-    # @return [Hash] {id:, archived: [ids], stopped: [ids], discarded: [ids]};
-    #   discarded: empty sessions their stopping worker deleted
+    # @return [ArchiveResult]
     # @raise [ArgumentError] unknown id (Session::AmbiguousId for a prefix of several)
     # @raise [OwnedByTUI] a chi REPL owns it or one of its children
     # @raise [ArchiveRefused] a turn runs in it or in a child, a prompt is
@@ -417,7 +423,7 @@ module Samagotchi
       archived.each { |sid| ReminderCarry.remove(Session.session_dir(sid, state_dir: sd)) }
       # D8: an archive ends the review (unarchiving doesn't restore it).
       Participants.end_sessions(archived, by: "archive", state_dir: sd)
-      { id: id, archived: archived, stopped: stopped, discarded: discarded }
+      ArchiveResult.new(id: id, archived: archived, stopped: stopped, discarded: discarded)
     end
 
     # The session and its descendants, with their owners, when they can be
@@ -1043,7 +1049,10 @@ module Samagotchi
     # @raise [OwnedByTUI] a chi REPL owns it (never stopped from here)
     # @raise [DeleteRefused] a worker owns it and +stop+ is false, or it
     #   outlived the wait
-    def self.delete_session(id_or_prefix, state_dir: nil, stop: false, wait: STOP_WAIT)
+    # @param purge_runs [Boolean] also delete System 1's saved runs of it and
+    #   its candidate-log lines; a session a worker left empty has none worth
+    #   the read
+    def self.delete_session(id_or_prefix, state_dir: nil, stop: false, wait: STOP_WAIT, purge_runs: true)
       sd = state_dir || Session.default_state_dir
       given = id_or_prefix.to_s
       # Only a plain id: anything else could name a path outside the state dir.
@@ -1072,9 +1081,20 @@ module Samagotchi
       PluginSessionState.remove(id)
       removed.concat(ContextSources.remove_session(id, state_dir: sd))
       Participants.end_sessions([id], by: "delete", state_dir: sd)
+      if purge_runs
+        purge_session_runs(id, sd)
+        ContextCandidatesLog.purge_session(id, state_dir: sd)
+      end
       { id: id, removed: removed, stopped: !owner.nil? }
     end
 
+    # Never a reason a delete fails: one warn, and the sweep ages them out.
+    private_class_method def self.purge_session_runs(id, state_dir)
+      SystemOne::Runs.purge_session(id, sessions_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "session_runs_purge_failed", sid: id, error: e.class.name, msg: e.message.to_s[0, 200])
+    end
+
     # @return [Boolean] whether the session had no owner within +timeout+ seconds
     def self.wait_for_owner_release(session_id, timeout:, state_dir:)
       deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout.to_f
@@ -1216,7 +1236,7 @@ module Samagotchi
     private_class_method def self.discard_left_session(session_id, state_dir:, default_model:)
       return unless discardable?(session_id, state_dir: state_dir, default_model: default_model)
 
-      delete_session(session_id, state_dir: state_dir)
+      delete_session(session_id, state_dir: state_dir, purge_runs: false)
       Log.info(:worker, "discarded_empty", sid: session_id)
     rescue DeleteRefused, OwnedByTUI, ArgumentError, SystemCallError => e
       Log.info(:worker, "kept_session", sid: session_id, error: e.class.name, msg: e.message)

data/lib/samagotchi/session_retention.rb

@@ -10,6 +10,7 @@ require_relative "model_profile"
 require_relative "session_manager"
 require_relative "plugin_session_state"
 require_relative "context_sources"
+require_relative "system_one/runs"
 
 module Samagotchi
   # Which sessions go: `chi sessions prune` / `clean` (.prune) and the lazy
@@ -109,6 +110,7 @@ module Samagotchi
         return if age < interval
       end
       result = prune(state_dir: sd)
+      sweep_runs(sd)
       FileUtils.touch(marker)
       if result[:deleted].any?
         Log.info(:worker, "retention_pruned", echo: "[retention] pruned #{result[:deleted].size} sessions (kept #{result[:kept].size})", deleted: result[:deleted].size, kept: result[:kept].size)
@@ -119,6 +121,14 @@ module Samagotchi
       nil
     end
 
+    # System 1's saved runs last as long as sessions, by day file. Never a
+    # reason the session sweep fails.
+    private_class_method def self.sweep_runs(state_dir)
+      SystemOne::Runs.sweep_at(File.dirname(state_dir))
+    rescue StandardError => e
+      Log.warn(:worker, "retention_runs_failed", echo: "[retention] saved runs: #{e.class}: #{e.message}", error: e.class.name)
+    end
+
     # The caller's value (a sessions prune flag) or session.retention_days.
     private_class_method def self.resolve_days(val)
       return val.to_i if !val.nil? && val.to_s.strip != ""

data/lib/samagotchi/side_judgments.rb

@@ -16,6 +16,7 @@ module Samagotchi
   class SideJudgments
     def initialize
       @threads = {}
+      @asides = []
       @mutex = Mutex.new
     end
 
@@ -42,9 +43,19 @@ module Samagotchi
       end
     end
 
+    # Run the block on its own thread, in no kind: telling a caller there
+    # was no ask. #join waits for it too. A raise goes to +warn+.
+    # @return [Thread]
+    def aside(warn:, &block)
+      @mutex.synchronize do
+        @asides.select!(&:alive?)
+        Thread.new { run(warn, nil, &block) }.tap { |thread| @asides << thread }
+      end
+    end
+
     # Wait for every running ask, up to +seconds+ in all.
     def join(seconds)
-      threads = @mutex.synchronize { @threads.values }
+      threads = @mutex.synchronize { @threads.values + @asides }
       deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
       threads.each do |thread|
         next if thread == Thread.current