samagotchi 0.140.0 → 0.142.0

data/lib/samagotchi/config.rb

@@ -179,17 +179,21 @@ module Samagotchi
       # mode GuardrailWiring also reads rules, threshold and min_record for the auto-allow (docs/guardrails.md).
       # off (the default) | audit (judge every ask, log it, never decide) | on. An unknown value warns and is off.
       Entry.new(key: "guardrails.system_one.mode",       yaml_path: %w[guardrails system_one mode],      type: :enum,    default: "off",  expose: %i[config], enum_values: %w[off audit on], lifecycle: :next_tool_or_approval),
-      # The hosts: entry serving /v1/systemone (Splash, or the hosted Jev API); unset: no judgment.
-      Entry.new(key: "guardrails.system_one.host",       yaml_path: %w[guardrails system_one host],      type: :string,  default: nil,    expose: %i[config], lifecycle: :next_tool_or_approval),
-      # The judgment model; unset: the host's first model, and no judgment if it names none.
-      Entry.new(key: "guardrails.system_one.model",      yaml_path: %w[guardrails system_one model],     type: :string,  default: nil,    expose: %i[config], lifecycle: :next_tool_or_approval),
       # The rule ids System 1 may answer for ("a|b", or a YAML list, parsed like guardrails.small_models).
       Entry.new(key: "guardrails.system_one.rules",      yaml_path: %w[guardrails system_one rules],      type: :string,  default: nil,    expose: %i[config], lifecycle: :next_tool_or_approval),
       # The probability an auto-allow needs, and how many clean records a rule needs before it is trusted.
       Entry.new(key: "guardrails.system_one.threshold",  yaml_path: %w[guardrails system_one threshold],  type: :float,   default: 0.8,   expose: %i[config], lifecycle: :next_tool_or_approval),
       Entry.new(key: "guardrails.system_one.min_record", yaml_path: %w[guardrails system_one min_record], type: :integer, default: 5,     expose: %i[config], lifecycle: :next_tool_or_approval),
-      # How long one judgment may take, in milliseconds; a judgment that doesn't arrive asks the user.
-      Entry.new(key: "guardrails.system_one.timeout_ms", yaml_path: %w[guardrails system_one timeout_ms], type: :integer, default: 2000,  expose: %i[config], lifecycle: :next_tool_or_approval),
+
+      # What every use of System 1 shares: approvals, toolkit suggestions, context candidates and bundles' judgments.
+      # The hosts: entry serving /v1/systemone (Splash, or the hosted Jev API); unset: no judgment, so nothing auto-allows.
+      Entry.new(key: "system_one.host",       yaml_path: %w[system_one host],       type: :string,  default: nil,  expose: %i[config], lifecycle: :next_tool_or_approval),
+      # The judgment model; unset: the host's first model, and no judgment if it names none.
+      Entry.new(key: "system_one.model",      yaml_path: %w[system_one model],      type: :string,  default: nil,  expose: %i[config], lifecycle: :next_tool_or_approval),
+      # How long one judgment may take, in milliseconds; a judgment that doesn't arrive is no judgment.
+      Entry.new(key: "system_one.timeout_ms", yaml_path: %w[system_one timeout_ms], type: :integer, default: 2000, expose: %i[config], lifecycle: :next_tool_or_approval),
+      # Save each System 1 ask and what came of it (docs/system-one.md): on (the default) | off.
+      Entry.new(key: "system_one.runs", yaml_path: %w[system_one runs], type: :enum, default: "on", expose: %i[config], enum_values: %w[on off], lifecycle: :next_tool_or_approval),
 
       Entry.new(key: "log.file",                 yaml_path: %w[log file],                 type: :string, default: nil,              expose: %i[env config cli], lifecycle: :process_start),
       Entry.new(key: "log.disable",              yaml_path: %w[log disable],              type: :bool,   default: false,            expose: %i[env config cli], lifecycle: :process_start),
@@ -204,6 +208,12 @@ module Samagotchi
       # The tokens one scope's memory index (sent with every prompt) may hold before a write that crosses it gets a note
       # (MemoryBundle::IndexSize); 0: no note. `memory:` is its own section, not the `memories:` preload list.
       Entry.new(key: "memory.index_warn_tokens", yaml_path: %w[memory index_warn_tokens], type: :integer, default: 2500,            expose: %i[env config cli], lifecycle: :next_matching_turn_display_poll_write),
+      # The most characters one memory_read result holds (ToolOutputCut cuts it with a line naming the memory file); 0: no
+      # fixed cap. memory_read is not cut by max_tool_output_chars (ToolRunner).
+      Entry.new(key: "memory.read_max_chars",    yaml_path: %w[memory read_max_chars],    type: :integer, default: 0,               expose: %i[env config cli], lifecycle: :next_matching_use),
+      # The tokens one memory may hold (each read of it pays them) before a write that crosses it gets a note
+      # (MemoryBundle::EntrySize); 0: no note.
+      Entry.new(key: "memory.entry_warn_tokens", yaml_path: %w[memory entry_warn_tokens], type: :integer, default: 5000,            expose: %i[env config cli], lifecycle: :next_matching_turn_display_poll_write),
       Entry.new(key: "context.status_thresholds", yaml_path: %w[context status_thresholds], type: :string, default: "20,40,60,80",    expose: %i[env config cli], lifecycle: :next_matching_turn_display_poll_write),
       # Attached context (ContextSources): how often a source's command runs when it names no --every (seconds; less
       # than 30 counts as 30).
@@ -219,7 +229,7 @@ module Samagotchi
       Entry.new(key: "context.peer_turns",       yaml_path: %w[context peer_turns],       type: :integer, default: 3,               expose: %i[env config cli], lifecycle: :next_matching_turn_display_poll_write),
       # The candidate judge (ContextJudge): off (no conversation text goes to a System 1 host); audit (asks and logs
       # context_candidates.jsonl, attaches nothing); on (ContextCandidateChoice: p ≥ threshold attaches quietly,
-      # offer_threshold ≤ p < threshold shows one card). Its host and model are guardrails.system_one.host/model.
+      # offer_threshold ≤ p < threshold shows one card). Its host and model are system_one.host and .model.
       # reask_after_turns: the owner prompts after a judged ask before its one re-ask.
       Entry.new(key: "context.candidates.mode",  yaml_path: %w[context candidates mode],  type: :enum,   default: "off", expose: %i[config], enum_values: %w[off audit on], lifecycle: :next_matching_turn_display_poll_write),
       Entry.new(key: "context.candidates.threshold", yaml_path: %w[context candidates threshold], type: :float, default: 0.8, expose: %i[config], lifecycle: :next_matching_turn_display_poll_write),
@@ -260,7 +270,7 @@ module Samagotchi
       Entry.new(key: "toolkit.default",          yaml_path: %w[toolkit default],          type: :string, default: nil,              expose: %i[env config], lifecycle: :session_creation),
       Entry.new(key: "toolkit.child",            yaml_path: %w[toolkit child],            type: :string, default: nil,              expose: %i[env config], lifecycle: :session_creation),
       # Toolkit suggestion (ToolkitSuggest): off; audit (logs, never blocks or changes a session); on (the first eligible
-      # turn waits up to guardrails.system_one.timeout_ms and may start on the suggested kit).
+      # turn waits up to system_one.timeout_ms and may start on the suggested kit).
       Entry.new(key: "toolkit.suggest.mode",     yaml_path: %w[toolkit suggest mode],     type: :enum,   default: "off", expose: %i[config], enum_values: %w[off audit on], lifecycle: :worker_start),
       Entry.new(key: "toolkit.suggest.threshold", yaml_path: %w[toolkit suggest threshold], type: :float, default: 0.5, expose: %i[config], lifecycle: :worker_start),
       Entry.new(key: "toolkit.suggest.defer_turns", yaml_path: %w[toolkit suggest defer_turns], type: :integer, default: 3, expose: %i[config], lifecycle: :worker_start),
@@ -390,8 +400,18 @@ module Samagotchi
     # The keys a hosts.<name>.models entry may hold (HostModel.parse_map).
     HOST_MODEL_KEYS = %w[price served].freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
-    # And toolkit's kits (Toolkit.kits).
-    SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze, "toolkit" => %w[kits].freeze }.freeze
+    # And toolkit's kits (Toolkit.kits), and bundles' judgments' settings (SystemOne::JudgmentSettings).
+    SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze, "toolkit" => %w[kits].freeze, "system_one" => %w[judgments].freeze }.freeze
+
+    # guardrails.system_one's keys that moved to system_one (SystemOne::Client.from_config).
+    SYSTEM_ONE_MOVED_KEYS = %w[host model timeout_ms].freeze
+    # What a system_one.judgments entry may hold. Core's judgments take none (RESERVED_JUDGMENTS).
+    JUDGMENT_ENTRY_KEYS = %w[mode host model].freeze
+    JUDGMENT_MODES = %w[off audit on].freeze
+    # Names core keeps, as a judgment's first word: a bundle can't declare one and
+    # system_one.judgments can't set one (Record and Similar are model-blind, so a
+    # swapped model would inherit a clean record and could auto-allow).
+    RESERVED_JUDGMENTS = %w[approvals context guardrails toolkit].freeze
 
     # What a :bool value reads as (Config.coerce!), YAML 1.1's words and 1/0.
     BOOL_WORDS = { "1" => true, "true" => true, "yes" => true, "on" => true,
@@ -464,6 +484,14 @@ module Samagotchi
         word && entry.enum_values.include?(word) ? word : nil
       end
 
+      # A system_one.judgments entry's mode as written, nil for one it can't
+      # be: an unquoted on/off is a boolean there too.
+      # @return [String, nil]
+      def judgment_mode(raw)
+        word = BOOL_ENUM_WORDS.fetch(raw) { raw.to_s.strip.downcase }
+        word if JUDGMENT_MODES.include?(word)
+      end
+
       # What +entry+'s type takes, as a refusal names it.
       def takes(entry)
         case entry.type
@@ -692,6 +720,8 @@ module Samagotchi
       # A section's leaf: a key the registry knows, or a mapping of a
       # third level (web.participants.cap) whose keys it knows.
       def leaf_problems(path, value)
+        return judgment_problems(value) if path == "system_one.judgments"
+
         if value.is_a?(Hash) && ENTRIES.any? { |e| e.key.start_with?("#{path}.") }
           value.keys.filter_map { |leaf| key_problem("#{path}.#{leaf}") }
         else
@@ -699,6 +729,29 @@ module Samagotchi
         end
       end
 
+      # system_one.judgments' entries: a map entry bypasses the registry, so
+      # its keys and mode are checked here (an unquoted on/off is a boolean).
+      # An undeclared name can only be told once the plugins have loaded
+      # (SystemOne::Judgments#warn_undeclared).
+      def judgment_problems(value)
+        return value.nil? ? [] : ["config: 'system_one.judgments' must be a mapping of judgments; ignored"] unless value.is_a?(Hash)
+
+        value.flat_map do |name, entry|
+          where = "system_one.judgments.#{name}"
+          if RESERVED_JUDGMENTS.include?(name.to_s.split(".").first)
+            next ["config: #{where}: core's judgments take no settings of their own; ignored (see docs/system-one.md)"]
+          end
+          next ["config: #{where} must be a mapping of #{JUDGMENT_ENTRY_KEYS.join(", ")}; ignored"] unless entry.is_a?(Hash)
+
+          unknown = (entry.keys.map(&:to_s) - JUDGMENT_ENTRY_KEYS).map do |k|
+            unknown_key_message("#{where}.#{k}", k, JUDGMENT_ENTRY_KEYS, prefix: "#{where}.")
+          end
+          mode = entry.key?("mode") && judgment_mode(entry["mode"]).nil? ? ["config: #{where}.mode must be off, audit or on; it is off"] : []
+          text = %w[host model].reject { |k| entry[k].nil? || entry[k].is_a?(String) }.map { |k| "config: #{where}.#{k} must be text" }
+          unknown + mode + text
+        end
+      end
+
       # What a model ref in config.yml won't do as written: an alias whose
       # target is another alias (aliases apply once, ModelRef), a ref that
       # starts with "<host>/" (only ':' names a host).
@@ -752,10 +805,17 @@ module Samagotchi
         @known_sections ||= known_config_keys.filter_map { |k| k.split(".").first if k.include?(".") }.to_set.freeze
       end
 
-      # Keys replaced by another: the warning names the new one (no alias).
+      # Keys replaced by another, and what the warning adds: it names the new
+      # one (no alias).
+      PARENT_ANSWERS_HINT = "hard, standard or soft; see docs/guardrails.md"
+      SYSTEM_ONE_MOVED_HINT = "it has moved: until all of host, model and timeout_ms have, nothing is judged or " \
+                              "auto-allowed, and every ask goes to you; see docs/configuration.md"
       REPLACED_KEYS = {
-        "guardrails.parent_approvals" => "guardrails.parent_answers",
-        "turn.parent_continue" => "guardrails.parent_answers"
+        "guardrails.parent_approvals" => ["guardrails.parent_answers", PARENT_ANSWERS_HINT],
+        "turn.parent_continue" => ["guardrails.parent_answers", PARENT_ANSWERS_HINT],
+        "guardrails.system_one.host" => ["system_one.host", SYSTEM_ONE_MOVED_HINT],
+        "guardrails.system_one.model" => ["system_one.model", SYSTEM_ONE_MOVED_HINT],
+        "guardrails.system_one.timeout_ms" => ["system_one.timeout_ms", SYSTEM_ONE_MOVED_HINT]
       }.freeze
 
       # nil when +dotted+ is a key the file may hold.
@@ -763,7 +823,7 @@ module Samagotchi
         return nil if known_config_keys.include?(dotted)
         return "config: #{ConfigFile.removed_transport_problem("'#{dotted}'")}" if dotted == "server.transport"
         if (replaced = REPLACED_KEYS[dotted])
-          return "config: unknown key '#{dotted}': replaced by '#{replaced}' (hard, standard or soft; see docs/guardrails.md)"
+          return "config: unknown key '#{dotted}': replaced by '#{replaced.first}' (#{replaced.last})"
         end
 
         entry = find_by_key(dotted)

data/lib/samagotchi/context_candidate_choice.rb

@@ -133,12 +133,19 @@ module Samagotchi
       own.add(ContextCandidates.source_for(candidate, why: CHOSEN_WHY))
       Log.info(:context, "candidate_attached", name: candidate.name, trigger: "command")
       ContextCandidatesLog.event("attached", session_id: session.id, name: candidate.name, state_dir: state_dir, by: "command")
+      label_run(session, candidate, "attached", state_dir)
       show_card.call(**closed_card(candidate, "Attached."))
       [:ok, "attached #{candidate.name}: its text comes with your next message"]
     rescue ContextSources::Invalid, ContextProviders::Invalid => e
       [:error, "#{candidate.name} not attached: #{e.message}"]
     end
 
+    # /context attach|decline (the card's buttons), on the latest ask's run.
+    def label_run(session, candidate, value, state_dir)
+      records = ContextCandidatesLog.records_for(ContextCandidatesLog.log_for(state_dir), session.id)
+      ContextCandidatesLog.label_run(records, candidate.name, value, by: "command", sessions_dir: state_dir)
+    end
+
     def decline(candidate, status, session, state_dir, show_card)
       if status == "attached"
         return [:error, "#{candidate.name} is attached; chi context rm #{candidate.name} removes it"]
@@ -147,6 +154,7 @@ module Samagotchi
 
       ContextSources.session_location(session.id, state_dir: state_dir).decline(candidate.name, candidate.url.to_s)
       ContextCandidatesLog.event("declined", session_id: session.id, name: candidate.name, state_dir: state_dir, by: "command")
+      label_run(session, candidate, "declined", state_dir)
       show_card.call(**closed_card(candidate, "Not attached here."))
       [:ok, "declined #{candidate.name}: not proposed again in this session"]
     end

data/lib/samagotchi/context_candidates_log.rb

@@ -3,6 +3,7 @@
 require_relative "log"
 require_relative "session"
 require_relative "side_judgments"
+require_relative "system_one/runs"
 
 module Samagotchi
   # The candidates' record, `context_candidates.jsonl` in the state dir
@@ -15,7 +16,8 @@ module Samagotchi
   # Kinds (every line has session_id, name and at):
   # - proposed: a plugin's ctx.context.propose recorded it (title, by)
   # - mentioned: an owner prompt named it and it was attached (mention)
-  # - judged: System 1's ask (ContextJudge.ask: p, task_p, stated, would, …)
+  # - judged: System 1's ask (ContextJudge.ask: run_id, p, task_p, stated,
+  #   would, …)
   # - judge_attached: on mode attached it (p ≥ threshold; p)
   # - carded: on mode showed its card (the middle band; p): once per
   #   candidate, read back by ContextCandidateChoice.carded?
@@ -34,6 +36,10 @@ module Samagotchi
     STATUS_OF = { "proposed" => "proposed", "mentioned" => "attached", "judge_attached" => "attached", "attached" => "attached",
                   "declined" => "declined", "detached" => "proposed", "withdrawn" => nil }.freeze
 
+    # The kinds #look sees that are a removal: a chip's ×, chi context rm. One
+    # removed after the session's last turn is never seen.
+    REMOVED = %w[declined detached].freeze
+
     module_function
 
     # @param state_dir [String, nil] the sessions folder (Session.default_state_dir)
@@ -77,10 +83,28 @@ module Samagotchi
 
         kind = status == "proposed" ? "detached" : status
         event(kind, session_id: session_id, name: candidate.name, log: log, by: "user")
+        label_run(records, candidate.name, kind, by: "user", root: log.dir) if REMOVED.include?(kind)
         kind
       end
     end
 
+    # The user's say on a candidate, as a label on the latest ask about it
+    # (the judged line's run, question "about"). No ask with a run: nothing.
+    # Never raises.
+    # @param records [Array<Hash>] the session's lines (#records_for)
+    # @param root [String, nil] the state dir; nil: from +sessions_dir+
+    # @return [Boolean] whether a label was written
+    def label_run(records, name, value, by:, sessions_dir: nil, root: nil)
+      judged = records.reverse_each.find { |line| line["kind"] == "judged" && line["name"] == name && line["run_id"] }
+      return false if judged.nil?
+
+      runs = SystemOne::Runs.in(root || File.dirname(sessions_dir || Session.default_state_dir))
+      runs.label(judged["run_id"], value, by: by, question: "about")
+    rescue StandardError => e
+      Log.warn(:context, "context_candidates_log_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      false
+    end
+
     # +text+ as a log line keeps it: one line, at most PROMPT_MAX chars.
     def short(text)
       line = text.to_s.gsub(/\s+/, " ").strip

data/lib/samagotchi/context_command.rb

@@ -25,12 +25,14 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi context <add|push|ls|show|refresh|rm|mute|unmute|report> [options] [TARGET]
-        add NAME (--cmd CMD | --push) [--every SECONDS] [--why TEXT] [--hint TEXT] TARGET
-        add URL [--why TEXT] [--hint TEXT] TARGET   a URL an installed bundle's provider knows (github-pr: a PR)
+        add NAME (--cmd CMD | --push) [--every SECONDS] [--why TEXT] [--hint TEXT] [--[no-]movable] TARGET
+        add URL [--why TEXT] [--hint TEXT] [--[no-]movable] TARGET   a URL an installed bundle's provider knows (github-pr: a PR)
               a source: CMD prints its text (plain, or JSON {"text", "summary", "wake", "hint"});
               --push: text comes from chi context push. --every: how often CMD runs
               (seconds, at least 30; default context.every_seconds). --why: why it's attached;
               --hint: one line, often its URL. NAME: a-z, 0-9 and -, up to 40.
+              --movable / --no-movable: whether a continue or a fork takes it to the new
+              session (default: a --cmd or URL source moves, a --push one stays).
         push NAME [-m TEXT] [TARGET]        new text for a --push source (stdin without -m; text or JSON)
         ls [TARGET] [--format json]         the sources, their age and state; a session's candidates
         show NAME [--json] [TARGET]         the text (--json: the source and its snapshot)
@@ -52,6 +54,8 @@ module Samagotchi
         f.value "--every"
         f.value "--why"
         f.value "--hint"
+        f.switch "--movable"
+        f.switch "--no-movable", key: :movable, set: false
         f.switch "--project"
       end,
       "push" => CLI::Flags.new(help: HELP_WORDS) do |f|
@@ -142,15 +146,27 @@ module Samagotchi
         name: name, cmd: options[:cmd], every_seconds: ContextSources.check_every!(options[:every]),
         why: ContextSources.one_line(options[:why], ContextSources::LINE_MAX_CHARS),
         hint: ContextSources.one_line(options[:hint], ContextSources::LINE_MAX_CHARS),
-        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601
+        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, movable: options[:movable]
       )
       each_target(options, args) do |target|
-        @access.context_add(target, source)
+        add_to(target, source)
         @stdout.puts("#{target.label}  attached #{name}")
         true
       end
     end
 
+    # Attaches +source+ to +target+; a movable flag an older chi web
+    # dropped (its answer has no movable) is a warning: the source is
+    # attached with the default.
+    def add_to(target, source)
+      warn_movable_dropped(target, source.name) if @access.context_add(target, source).movable_dropped
+    end
+
+    def warn_movable_dropped(target, name)
+      error_line("#{command_name}: warning: the remote's chi web is too old for --movable/--no-movable: " \
+                 "#{name} on #{target.label} has the default (update chi there)")
+    end
+
     # A URL through the installed bundles' providers (ContextProviders):
     # the provider gives the name, command, hint and interval. Not gated
     # like --cmd (chi-context-cmd): the command is the bundle's.
@@ -167,10 +183,11 @@ module Samagotchi
         name: resolved.name, cmd: resolved.cmd, every_seconds: resolved.every_seconds,
         why: ContextSources.one_line(options[:why] || resolved.why, ContextSources::LINE_MAX_CHARS),
         hint: ContextSources.one_line(options[:hint] || resolved.hint, ContextSources::LINE_MAX_CHARS),
-        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, provider: resolved.bundle
+        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, provider: resolved.bundle,
+        movable: options[:movable]
       )
       each_target(options, args) do |target|
-        @access.context_add(target, source)
+        add_to(target, source)
         @stdout.puts("#{target.label}  attached #{source.name}")
         true
       end
@@ -183,8 +200,9 @@ module Samagotchi
       why = ContextSources.one_line(options[:why], ContextSources::LINE_MAX_CHARS)
       hint = ContextSources.one_line(options[:hint], ContextSources::LINE_MAX_CHARS)
       each_target(options, args) do |target|
-        name = @access.context_add_url(target, url, why: why, hint: hint, added_by: added_by)
-        @stdout.puts("#{target.label}  attached #{name}")
+        added = @access.context_add_url(target, url, why: why, hint: hint, added_by: added_by, movable: options[:movable])
+        warn_movable_dropped(target, added.name) if added.movable_dropped
+        @stdout.puts("#{target.label}  attached #{added.name}")
         true
       end
     rescue ContextProviders::Invalid => e
@@ -210,6 +228,9 @@ module Samagotchi
           # two fetches would read as a change and then vanish.
           error_line("#{command_name}: #{SessionAccess::ContextPush.not_push_message(name)}")
           next false
+        when :continued
+          error_line("#{command_name}: #{SessionAccess::ContextPush.continued_message(name, target.session_id, pushed.next_id)}")
+          next false
         end
 
         @stdout.puts("#{target.label}  #{name}: #{pushed.revision == pushed.before ? "unchanged" : "new text"} " \
@@ -452,7 +473,8 @@ module Samagotchi
         "cmd" => source.cmd, "every_seconds" => source.every_seconds, "why" => source.why, "hint" => source.hint,
         "added_by" => source.added_by, "created_at" => source.created_at, "fetched_at" => snapshot.fetched_at,
         "revision" => snapshot.revision, "summary" => snapshot.summary, "error" => snapshot.error,
-        "muted" => entry.muted, "shadowed" => entry.shadowed, "unread" => entry.unread }.compact
+        "muted" => entry.muted, "shadowed" => entry.shadowed, "unread" => entry.unread,
+        "movable" => (source.movable? if source.scope == "session") }.compact
     end
 
     def print_rows(rows, labels:)
@@ -465,6 +487,7 @@ module Samagotchi
                 else
                   "ok"
                 end
+        state = "#{state} · stays" if r["movable"] == false
         [*(labels ? [r["target"]] : []), r["name"], r["scope"], kind, age(r["fetched_at"]), state, r["why"].to_s]
       end
       widths = lines.transpose.map { |column| column.map(&:length).max }

data/lib/samagotchi/context_judge.rb

@@ -4,6 +4,7 @@ require_relative "config"
 require_relative "context_candidates_log"
 require_relative "log"
 require_relative "system_one/question"
+require_relative "system_one/runs"
 
 module Samagotchi
   # System 1's judgment of a session's candidate context
@@ -26,6 +27,8 @@ module Samagotchi
   # (attach, card, or nothing); audit only logs.
   module ContextJudge
     MODES = %w[off audit on].freeze
+    # Its saved asks' name (SystemOne::Runs).
+    JUDGMENT = "context.candidate"
     ABOUT_ID = "about"
     TASK_ID = "task"
     # The bound on each prompt in the state.
@@ -168,14 +171,15 @@ module Samagotchi
     # candidate is asked again at the next owner prompt.
     # @return [Hash, nil] the line's fields
     def ask(client:, job:, log:, settings:, cancel_controller: nil)
+      run_id = SystemOne::Runs.new_id(JUDGMENT)
       answers = client.ask(state: state(job), questions: questions(child: !job.parent_attached.nil?),
-                           cancel_controller: cancel_controller)
+                           cancel_controller: cancel_controller, run_id: run_id)
       about = answers&.dig(ABOUT_ID)&.noul
       task = answers&.dig(TASK_ID)&.noul
       return nil if about.nil? || task.nil?
 
       stated = task >= TASK_MIN
-      fields = { "title" => job.title, "phase" => job.phase, "owner_prompts" => job.owner_prompts,
+      fields = { "run_id" => run_id, "title" => job.title, "phase" => job.phase, "owner_prompts" => job.owner_prompts,
                  "p" => about.round(4), "task_p" => task.round(4), "stated" => stated,
                  "would" => stated ? would(about, settings) : nil, "mode" => settings.mode,
                  "threshold" => settings.threshold, "offer_threshold" => settings.offer_threshold,

data/lib/samagotchi/context_move.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "context_sources"
+require_relative "session_inbox"
+require_relative "log"
+
+module Samagotchi
+  # Movable context on its two paths, a continue (SessionContinue) and a
+  # plugin fork (ctx.sessions.fork): from SessionManager.spawn_session's
+  # before_spawn, once the new session and its first note are saved and
+  # before its worker starts, so its first absorb sees the sources.
+  module ContextMove
+    # What the new session's note says it is from.
+    NOTE_SOURCE = "attached context"
+
+    # ContextSources.move, then a second note in the new session saying what
+    # moved and what stayed (named by time, it sorts after the first). Best
+    # effort: a failure is logged and the session starts without (its start
+    # must not be undone for it).
+    # @return [ContextSources::Moved]
+    def self.call(from:, to:, mode:, state_dir:, seed: nil)
+      moved = ContextSources.move(from: from, to: to, mode: mode, seed: seed, state_dir: state_dir)
+      text = moved.note_text(from)
+      SessionInbox.write_note(to, text: text, source: NOTE_SOURCE, state_dir: state_dir) if text
+      moved
+    rescue StandardError => e
+      Log.warn(:context, "context_move_failed", sid: to, from: from, error: e.class.name, msg: e.message.to_s[0, 200])
+      ContextSources::Moved.none
+    end
+  end
+end