samagotchi 0.40.0 → 0.42.0

data/lib/samagotchi/self_report.rb

@@ -10,6 +10,8 @@ require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
 require_relative "model_overlay"
+require_relative "model_notes"
+require_relative "prompt_note"
 require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
@@ -20,6 +22,7 @@ require_relative "hooks/loader"
 require_relative "memory_bundle/provenance"
 require_relative "memory_bundle/manifest"
 require_relative "memory_bundle/system_bundle"
+require_relative "memory_bundle/index_size"
 require_relative "desktop"
 require_relative "live_versions"
 require_relative "web/lan"
@@ -53,10 +56,12 @@ module Samagotchi
         ["hooks dir", hooks_dir(env)],
         ["memories", Tools::MemoryRead.memories_dir("system", env: env)],
         ["project memories", Tools::MemoryRead.memories_dir("project", env: env)],
+        ["memory index", memory_index_summary(env)],
         ["sessions", Session.default_state_dir(env: env)],
         ["log", log_path(env)],
         ["model", model ? model_label(model, default, env) : "(not configured)"],
         ["model key", model ? model_key_for(model, env) : "-"],
+        ["model notes", model ? model_notes_for(model, env) : "-"],
         ["host", model ? host_for(model, env) : "-"],
         ["api key", model ? api_key_for(model, env) : "-"],
         ["loop", model ? loop_for(model, env) : "-"],
@@ -100,6 +105,19 @@ module Samagotchi
       LogPath.resolve(env: env) || "(disabled: log.disable)"
     end
 
+    # "system ~2.0k tokens (54 lines), project ~1.4k tokens (35 lines)":
+    # the two indexes every prompt carries (before a session's mutes), a
+    # scope over memory.index_warn_tokens marked so. Two file reads. The
+    # indexes come from +env+'s memories dirs; the limit and
+    # context.chars_per_token from Config, which reads the process's ENV
+    # and config.yml as the rest of chi self's settings (web.port) do.
+    def memory_index_summary(env)
+      limit = MemoryBundle::IndexSize.warn_limit
+      %w[system project].map { |scope| MemoryBundle::IndexSize.of_scope(scope, env: env).summary(limit) }.join(", ")
+    rescue StandardError => e
+      "(unreadable: #{e.message})"
+    end
+
     def with_presence(path)
       File.exist?(path) ? path : "#{path} (missing)"
     end
@@ -172,6 +190,35 @@ module Samagotchi
       ModelOverlay.key_for(model) || "-"
     end
 
+    # "model_notes_deepseek (system, 612 chars)": the model notes a prompt
+    # of +model+ loads (ModelNotes: matched on its bare id and key, the
+    # session's --mute list left out when chi self runs in one), "none"
+    # without any. Read from the memories dirs now: a session's prompt
+    # takes them at its next build (/stats names the ones it carries).
+    def model_notes_for(model, env)
+      bare = HostRegistry.new(env: env).bare_name(model)
+      notes = ModelNotes.for(name: bare, key: ModelOverlay.key_for(bare), muted: session_muted(env), env: env,
+                             warn: false)
+      text = PromptNote.text(notes.map { |note| PromptNote.from_note(note) })
+      text.empty? ? "none" : text
+    rescue StandardError => e
+      "(unreadable: #{e.message})"
+    end
+
+    # The --mute list of the session chi self runs in (its execute exports
+    # SAMAGOTCHI_PARENT_SESSION); [] outside one.
+    def session_muted(env)
+      id = env[PARENT_SESSION_ENV].to_s
+      return [] if id.empty? || !Session.valid_id?(id)
+
+      state_dir = Session.default_state_dir(env: env)
+      return [] unless Session.exist?(id, state_dir: state_dir)
+
+      MutedMemories.normalize_list(Session.load(id, state_dir: state_dir).muted_memory_names)
+    rescue StandardError
+      []
+    end
+
     def model_name
       ModelProfile.required_model_name
     rescue ArgumentError

data/lib/samagotchi/send_command.rb

@@ -33,7 +33,7 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [-m TEXT] [--image PATH]...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
@@ -53,6 +53,9 @@ module Samagotchi
         --dir DIR   (--new) its folder, the project it belongs to; default
                     the current one
         --model M   (--new) its model; default the configured one
+        --llm-context LAYERS, --llm-context-apply RULE, --llm-context-budget N
+                    (--new) its own LLM context strategy (none, stale,forget),
+                    apply rule and budget (64k, off), as chi takes them
         --wait      wait for the answer and print it (one session); the
                     other lines go to stderr. Exit 3: it waits for an
                     answer from you: the question, its options and the
@@ -81,6 +84,9 @@ module Samagotchi
       f.switch "--new"
       f.value "--dir"
       f.value "--model"
+      f.value "--llm-context", key: :llm_strategy
+      f.value "--llm-context-apply", key: :llm_apply
+      f.value "--llm-context-budget", key: :llm_budget
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
       f.value "--timeout"
@@ -200,14 +206,27 @@ module Samagotchi
       return new_options(options) if options[:new]
 
       %i[dir model].each { |key| return usage_error("--#{key} needs --new") if options[key] }
+      LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
 
       options
     end
 
+    # The --llm-context* option keys, and their fields.
+    LLM_CONTEXT_FLAGS = { llm_strategy: "--llm-context", llm_apply: "--llm-context-apply",
+                          llm_budget: "--llm-context-budget" }.freeze
+    LLM_CONTEXT_FIELDS = { llm_strategy: :strategy, llm_apply: :apply, llm_budget: :budget_tokens }.freeze
+
     def new_options(options)
       return usage_error("--new takes no session ids: it starts one session") unless options[:ids].empty?
 
+      words = LLM_CONTEXT_FIELDS.filter_map { |key, field| [field, options[key]] if options[key] }.to_h
+      begin
+        options[:llm_context] = LLMContextOverride.update(nil, words) unless words.empty?
+      rescue ArgumentError => e
+        return usage_error(e.message)
+      end
+
       if options[:dir]
         options[:dir] = File.expand_path(options[:dir])
         return usage_error("no folder #{options[:dir]}") unless File.directory?(options[:dir])
@@ -246,7 +265,8 @@ module Samagotchi
       begin
         start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
         session = SessionManager.spawn_session(**start, working_directory: options[:dir],
-                                                        model_name: options[:model], state_dir: @state_dir)
+                                                        model_name: options[:model], llm_context: options[:llm_context],
+                                                        state_dir: @state_dir)
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1

data/lib/samagotchi/session.rb

@@ -6,6 +6,8 @@ require "securerandom"
 require "time"
 require_relative "atomic_file"
 require_relative "context_note"
+require_relative "llm_context_override"
+require_relative "prompt_note"
 
 require_relative "paths"
 require_relative "project_scope"
@@ -43,6 +45,17 @@ module Samagotchi
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
     attr_accessor :preloaded_memory_names, :muted_memory_names
+    # The model notes the session's system prompt carried at its last build
+    # (Array<PromptNote>: name, scope, chars, digest; ModelNotes), set by the
+    # Engine at each build (a start, a resume's or a woken worker's first
+    # turn, /model) and saved, so what a session ran with can be read later.
+    attr_reader :prompt_notes
+
+    # @param notes [Array<PromptNote, Hash>] a file's hashes are read
+    #   (PromptNote.list)
+    def prompt_notes=(notes)
+      @prompt_notes = PromptNote.list(notes)
+    end
     # The name model_name was typed as when that differs from the resolved
     # ref stored in model_name (an alias: `small` for `gemma-small`), else
     # nil. The models: lookup takes it (HostRegistry#lookup_names).
@@ -70,6 +83,26 @@ module Samagotchi
     # delegate children's reports (ChildReports); context: one an attached
     # context source's change started (Worker).
     attr_accessor :last_turn
+    # The session's own llm_context values (LLMContextOverride: strategy,
+    # apply rule, budget), before the model's; nil when it has none.
+    # Saved, so a --resume and a respawned worker keep them; a plugin's
+    # fork copies them, a delegate child starts without.
+    attr_reader :llm_context
+
+    # @param value [LLMContextOverride, Hash, nil] an empty one is nil; a
+    #   file's Hash keeps the fields it can't read (LLMContextOverride.unread),
+    #   saved back as they were until the session sets its own
+    def llm_context=(value)
+      @llm_context_unread = LLMContextOverride.unread(value)
+      @llm_context = LLMContextOverride.from_file(value)
+    end
+
+    # The session file's "llm_context": the override's fields over the ones
+    # it couldn't read; nil when there are none.
+    def llm_context_file
+      saved = @llm_context_unread.merge(@llm_context&.to_file || {})
+      saved.empty? ? nil : saved
+    end
 
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
     # left), e.g. "loop-guard"; nil when it ended otherwise. Both strings
@@ -97,7 +130,7 @@ module Samagotchi
                    first_preview: "", test_run: false, pending_question: nil,
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
-                   last_turn: nil, model_typed: nil, delegate: false)
+                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [])
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -115,11 +148,13 @@ module Samagotchi
       @used_memory_names = self.class.name_list(used_memory_names)
       @preloaded_memory_names = self.class.name_list(preloaded_memory_names)
       @muted_memory_names = self.class.name_list(muted_memory_names)
+      self.prompt_notes = prompt_notes
       @project_root = project_root
       @parent_id = parent_id&.to_s
       @scratch = !!scratch
       @last_turn = last_turn
       @delegate = !!delegate
+      self.llm_context = llm_context
       @archived = false
     end
 
@@ -170,7 +205,7 @@ module Samagotchi
     #   seed); [] by default
     def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
                          preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
-                         scratch: false, model_typed: nil, delegate: false)
+                         scratch: false, model_typed: nil, delegate: false, llm_context: nil)
       now = Time.now.iso8601(3)
       resolved_test = if test_run.nil?
                         test_session_env?
@@ -194,7 +229,8 @@ module Samagotchi
         muted_memory_names: muted_memory_names,
         parent_id: parent_id,
         scratch: scratch,
-        delegate: delegate
+        delegate: delegate,
+        llm_context: llm_context
       )
     end
 
@@ -246,10 +282,12 @@ module Samagotchi
       "project_root" => nil,
       "preloaded_memory_names" => [],
       "muted_memory_names" => [],
+      "prompt_notes" => [],
       "parent_id" => nil,
       "scratch" => false,
       "last_turn" => nil,
-      "delegate" => false
+      "delegate" => false,
+      "llm_context" => nil
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -368,6 +406,8 @@ module Samagotchi
                 when "pending_question" then @pending_question && scrub_utf8(stringify_message_keys(@pending_question))
                 when "test_run" then !!@test_run
                 when "delegate" then @delegate
+                when "llm_context" then llm_context_file
+                when "prompt_notes" then @prompt_notes.map(&:to_file)
                 when "used_memory_names", "preloaded_memory_names", "muted_memory_names"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")

data/lib/samagotchi/session_commands.rb

@@ -3,16 +3,18 @@
 require_relative "config"
 require_relative "model_profile"
 require_relative "served_model"
+require_relative "prompt_note"
 require_relative "turn_flow"
 require_relative "tools/execute"
 require_relative "tools/builtins"
 require_relative "tools/context_read"
 require_relative "tools/peers"
 require_relative "commands/registry"
+require_relative "llm_context_command"
 
 module Samagotchi
   # The session commands a REPL and a session worker both run: /model,
-  # /models, /guardrails, /context, !rollback, !cmd and the answer to a continue offer. They act on
+  # /models, /llm-context, /guardrails, /context, !rollback, !cmd and the answer to a continue offer. They act on
   # the Engine and its TurnFlow; the host prints the result's output and
   # runs a continue turn when asked to (#run never runs a turn).
   #
@@ -26,6 +28,7 @@ module Samagotchi
     GUARDRAILS_COMMAND = "/guardrails"
     CONTEXT_COMMAND = "/context"
     HELP_COMMAND = "/help"
+    LLM_CONTEXT_COMMAND = LLMContextCommand::NAME
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
     MODELS_PER_HOST = 20
@@ -73,6 +76,9 @@ module Samagotchi
       end
       registry.register(MODEL_COMMAND, "show or switch the model",
                         match: ->(text) { text.match?(%r{\A/model(?:\s+.*)?\z}) }) { |text| model(text) }
+      # Not anytime: it saves the session; it takes effect at the next turn's start.
+      registry.register(LLM_CONTEXT_COMMAND, "show or set this session's LLM context strategy, apply rule and budget",
+                        id: :llm_context, match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -105,6 +111,14 @@ module Samagotchi
       @builtin_registry ||= register_builtins(Commands::Registry.new).freeze
     end
 
+    # The name of this chi's own session command +line+ is (one a worker
+    # runs), or nil. A worker that answers such a line unknown_command runs
+    # an older chi that doesn't have it yet (/llm-context against 0.39.0):
+    # the UIs say so (BridgeClient.stale_worker_message) instead of "not a
+    # session command".
+    # @return [String, nil]
+    def self.builtin_name(line) = builtin_registry.lookup(line)&.name
+
     # @return [String] the model /model clear goes back to
     attr_reader :default_model
 
@@ -330,6 +344,21 @@ module Samagotchi
       @save.call(session)
     end
 
+    # /llm-context (LLMContextCommand); :llm_context in changed when it set
+    # the session's values.
+    def llm_context(text)
+      output, changed = LLMContextCommand.new(engine: @engine, save: ->(session) { save_llm_context(session) })
+                                         .run(text.delete_prefix(LLM_CONTEXT_COMMAND))
+      reply(output, changed: changed ? [:llm_context] : [])
+    rescue ArgumentError => e
+      reply(e.message, status: :error)
+    end
+
+    def save_llm_context(session)
+      @engine.store_model!(session)
+      @save.call(session)
+    end
+
     def model(text)
       output, switched = model_command(text)
       reply(output, changed: switched ? [:model] : [])
@@ -342,9 +371,9 @@ module Samagotchi
     def model_command(input)
       suffix = input.delete_prefix(MODEL_COMMAND).strip
       if suffix.empty?
-        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}", false] if model_name == @engine.model_ref_for(@default_model)
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{notes_note}", false] if model_name == @engine.model_ref_for(@default_model)
 
-        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}", false]
+        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{notes_note}", false]
       end
 
       # Parse flags: --default and --alias <name> / --alias=<name> (tolerant order)
@@ -414,14 +443,14 @@ module Samagotchi
           return ["--default cannot be combined with clear/default/none/off", false] if persist_default
 
           switch_model(@default_model)
-          return ["runtime model reset to #{model_name}#{model_note}", true]
+          return ["runtime model reset to #{model_name}#{model_note}#{notes_note}", true]
         end
 
         switch_model(arg, persist_default: persist_default)
         if persist_default
-          ["runtime model set to #{model_name}#{model_note} and default updated", true]
+          ["runtime model set to #{model_name}#{model_note} and default updated#{notes_note}", true]
         else
-          ["runtime model set to #{model_name}#{model_note}", true]
+          ["runtime model set to #{model_name}#{model_note}#{notes_note}", true]
         end
       end
     end
@@ -462,6 +491,16 @@ module Samagotchi
       ""
     end
 
+    # "; notes: model_notes_deepseek (system, 612 chars)": the model notes
+    # the session's prompt carries (after a switch, the ones the new
+    # model's prompt loads); "" without any.
+    def notes_note
+      text = PromptNote.text(@engine.prompt_notes)
+      text.empty? ? "" : "; notes: #{text}"
+    rescue StandardError
+      ""
+    end
+
     # "; thinking: off (models: qwen)" when the model has a level set.
     def thinking_note
       summary = @engine.thinking_summary

data/lib/samagotchi/session_manager.rb

@@ -129,11 +129,13 @@ module Samagotchi
     # @param images_from [String, nil] the session dir the seed's images are in
     # @param title [String, nil] what the lists show before the first turn
     #   (the prompt's preview by default, else the seed's first user message)
+    # @param llm_context [LLMContextOverride, nil] the session's own
+    #   llm_context values (chi --llm-context; a fork copies its parent's)
     # @return [Session] with #seed_images_dropped: refs whose file was gone,
     #   and #model_warning: an id its host's saved list doesn't have
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
-                           title: nil, delegate: false)
+                           title: nil, delegate: false, llm_context: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
       # alias is retargeted), with the name as typed beside it. A wrong host
@@ -153,7 +155,8 @@ module Samagotchi
         muted_memory_names: muted_memories,
         parent_id: parent_id,
         messages: messages,
-        delegate: delegate
+        delegate: delegate,
+        llm_context: llm_context
       )
       session.model_warning = model_warning
       # With no prompt there is no first turn to run (an attaching UI sends

data/lib/samagotchi/session_metrics.rb

@@ -37,6 +37,8 @@ module Samagotchi
     # The most turns (with their tool calls) a live snapshot carries: the
     # unsaved ones of a collector whose saves keep failing stay bounded.
     LIVE_RECORDS_CAP = 20
+    # The most characters of a failed turn's error message its record keeps.
+    FAILURE_MESSAGE_CHARS = 2000
 
     # A generation shorter than this gets no decode speed of its own: one
     # tiny generation would skew the session's average.
@@ -53,8 +55,14 @@ module Samagotchi
     # had none) and the session's tokens block as the snapshot has it.
     GenerationReport = Data.define(:speed, :tokens)
 
-    SavedSummary = Data.define(:ctx_pct, :prompt_sum, :completion_sum, :cached_sum, :reasoning_sum, :cost_sum) do
-      def tokens = to_h.except(:ctx_pct)
+    # memory_index: the memory indexes the session's prompt held
+    # ({ system: { tokens:, lines: }, project: … }, string keys as saved),
+    # nil when an older file has none.
+    SavedSummary = Data.define(:ctx_pct, :prompt_sum, :completion_sum, :cached_sum, :reasoning_sum, :cost_sum,
+                               :memory_index) do
+      def initialize(memory_index: nil, **) = super
+
+      def tokens = to_h.except(:ctx_pct, :memory_index)
     end
 
     # Per-turn transient state, reset on each turn_started.
@@ -150,7 +158,8 @@ module Samagotchi
       count = ->(key) { tokens[key].is_a?(Numeric) ? tokens[key] : 0 }
       SavedSummary.new(ctx_pct: saved_pct(data["context"]), prompt_sum: count.call("prompt_sum"),
                        completion_sum: count.call("completion_sum"), cached_sum: count.call("cached_sum"),
-                       reasoning_sum: count.call("reasoning_sum"), cost_sum: count.call("cost_sum"))
+                       reasoning_sum: count.call("reasoning_sum"), cost_sum: count.call("cost_sum"),
+                       memory_index: data["memory_index"].is_a?(Hash) ? data["memory_index"] : nil)
     rescue JSON::ParserError, SystemCallError, TypeError
       nil
     end
@@ -196,6 +205,7 @@ module Samagotchi
       @wall_clock = wall_clock || -> { Time.now }
       @session_id = nil
       @state_dir = nil
+      @memory_index = nil
       @started_at = nil
       @last_activity_at = nil
       @turn = nil
@@ -217,6 +227,14 @@ module Samagotchi
       end
     end
 
+    # The memory indexes the session's prompt holds (SystemPrompt#memory_index:
+    # { system: { tokens:, lines: }, project: … }), set by the Engine when
+    # it builds the prompt it sends; the snapshot and analytics.json carry it.
+    # @param block [Hash, nil]
+    def memory_index=(block)
+      @mutex.synchronize { @memory_index = block if block }
+    end
+
     # The sessions dir analytics.json is read from and saved to (nil: the
     # XDG default). Set it before #session_id=.
     attr_writer :state_dir
@@ -292,7 +310,7 @@ module Samagotchi
       when :turn_canceled
         end_turn(status: "canceled", reason: event[:cancellation_reason], by: event[:cancelled_by])
       when :turn_failed
-        end_turn(status: "failed")
+        end_turn(status: "failed", failure: failure_fields(event))
       end
 
       @mutex.synchronize { @last_activity_at = now.iso8601(3) }
@@ -367,6 +385,7 @@ module Samagotchi
         cancellations: totals[:cancellations],
         tokens: tokens_block(totals, turn),
         context: context_block(@turn_records),
+        memory_index: @memory_index,
         profile: @profile,
         profile_source: @profile_source,
         served_model: @served_model,
@@ -480,9 +499,10 @@ module Samagotchi
     end
 
     # A canceled turn's record keeps why (+reason+: "user", "ctrl_c", ...)
-    # and who stopped it (+by+: a hook's bundle), so a reloaded web history
-    # can show the cancel line the live one did.
-    def end_turn(status: "completed", reason: nil, by: nil)
+    # and who stopped it (+by+: a hook's bundle), a failed one what its line
+    # says (+failure+, #failure_fields), so a reloaded web history can show
+    # the cancel or failure line the live one did.
+    def end_turn(status: "completed", reason: nil, by: nil, failure: nil)
       @mutex.synchronize do
         if @turn
           # A turn that failed mid-stream never saw its generation end:
@@ -505,6 +525,7 @@ module Samagotchi
           }
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
           record[:cancelled_by] = by.to_s unless by.nil? || by.to_s.empty?
+          record[:failure] = failure if failure
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)
@@ -513,6 +534,19 @@ module Samagotchi
       end
     end
 
+    # What turn_failed's line is made of (format.js failedTurnText): a
+    # provider error's summary, else the message (capped: a server's error
+    # page can be long) and class, and the steps that stayed (kept_steps).
+    def failure_fields(event)
+      summary = event[:summary].to_s
+      return { summary: summary, kept_steps: event[:kept_steps] }.compact unless summary.empty?
+
+      message = event[:message].to_s
+      message = "#{message[0, FAILURE_MESSAGE_CHARS - 1]}…" if message.length > FAILURE_MESSAGE_CHARS
+      { message: message.empty? ? nil : message, error_class: event[:error_class]&.to_s,
+        kept_steps: event[:kept_steps] }.compact
+    end
+
     # The model the server says answered, and the name asked for then (a
     # /model switch makes it stale until the next generation reports).
     def record_served_model(event)
@@ -875,6 +909,8 @@ module Samagotchi
         @served_model = prior["served_model"]
         @served_model_for = prior["served_model_for"]
       end
+      # The indexes the prompt last held, until this process builds its own.
+      @memory_index ||= symbolized(prior["memory_index"]) if prior["memory_index"].is_a?(Hash)
       # The window last seen, until this process's first generation reports.
       window = prior["context"].is_a?(Hash) ? prior["context"] : {}
       if window["window_tokens"] && @context_window_tokens.nil?
@@ -885,6 +921,10 @@ module Samagotchi
       nil
     end
 
+    def symbolized(hash)
+      hash.to_h { |key, value| [key.to_sym, value.is_a?(Hash) ? symbolized(value) : value] }
+    end
+
     def loaded_records(records)
       Array(records).filter_map { |record| record.transform_keys(&:to_sym) if record.is_a?(Hash) && record["id"] }
     end