samagotchi 0.101.0 → 0.102.0

data/lib/samagotchi/engine.rb

@@ -107,6 +107,8 @@ module Samagotchi
 
     # What memory_write answers in a scratch session.
     SCRATCH_MEMORY_WRITE = "Error: scratch session: nothing is saved"
+    # The session setting /recap on|off|default writes (#recap_override=).
+    RECAP_ENABLED_KEY = "recap.enabled"
 
     # @param client             [Client, nil] defaults to Client.new
     # @param profile            [ModelProfile, Symbol, String, nil]
@@ -232,9 +234,9 @@ module Samagotchi
       # across UIs.
       @turn_state.restart_clock!
       @side_client_mutex = Mutex.new
-      @recap = RecapSetup.build(recap, engine: self, host_registry: @host_registry,
-                                session_target: -> { session_model_recap_target },
-                                session_id: -> { @session&.id }, state_dir: -> { session_state_dir })
+      # Kept for a rebuild under a bound session's own recap values.
+      @recap_kwarg = recap
+      @recap = build_recap
       # One shared poller for the whole idle layer (reminders + optional
       # recap). Both jobs read the activity seam above; the scheduler owns
       # the single background thread and isolates per-job failures.
@@ -786,7 +788,7 @@ module Samagotchi
     # UIs need in the event log, emitted outside any turn's stream.
     ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
-                             plugin_init_started plugin_init_finished].freeze
+                             plugin_init_started plugin_init_finished working_set_updated].freeze
 
     # Put a transport-level event into the ordered event log. Unlike turn
     # events it reaches only persistent observers (no turn sink, no memory
@@ -807,6 +809,34 @@ module Samagotchi
       @session_observer.synchronize(&)
     end
 
+    # The working set's :working_set_updated, announced between turns
+    # (after a command changed what the next request sends), when it
+    # differs from the last one emitted (#emit_working_set). Under the
+    # event lock, so it is ordered with the change's own events.
+    def announce_working_set(session = @session)
+      return unless session
+
+      synchronize_events { emit_working_set(nil, session, session.messages) }
+    end
+
+    # The strategy the working set is built under now, as LLMContextView
+    # takes it: the running turn's, else the next turn's (#emit_working_set).
+    # /working-set's ops act under it.
+    # @return [Symbol, Array<Symbol>]
+    def working_set_strategy
+      working_set_llm_context&.strategy || LLMContextView::NONE
+    end
+
+    # Replace the current session's conversation, between turns (a
+    # /working-set op's copy: #clone_messages, then its edits).
+    # @param messages [Array<Hash>]
+    # @return [Array<Hash>] the session's messages
+    def replace_messages(messages)
+      raise ArgumentError, "no current session" unless @session
+
+      replace_session_messages(@session, messages)
+    end
+
     # Add a context note to the session's conversation, between turns: a
     # tail system message the next turn sees, announced as :context_added.
     # The array is replaced, not mutated, and the append and the event
@@ -1131,6 +1161,8 @@ module Samagotchi
     # price_host: the effective model's host, whose hosts.<name>.models
     # prices the cost estimate names. kit_prompt: the next turn's kit
     # prompt text ({kit:, tokens:}), only when its toolkit has one.
+    # settings: the session's own settings ({"recap.enabled" => false}),
+    # only when it has some.
     # @return [Hash] @metrics.snapshot, filled in
     def stats_snapshot
       snapshot = @metrics.snapshot
@@ -1145,6 +1177,9 @@ module Samagotchi
                                 price_host: model.host_name)
       kit_prompt = kit_prompt_stats
       snapshot = snapshot.merge(kit_prompt: kit_prompt) if kit_prompt
+      # The session's own settings (chi --set), as --set names them.
+      settings = @session&.settings&.flat || {}
+      snapshot = snapshot.merge(settings: settings) unless settings.empty?
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(model)
         if window
@@ -1722,6 +1757,8 @@ module Samagotchi
       @session = session
       # One session per REPL/worker process: its records carry this sid.
       Log.session_id = session.id if session&.id
+      # Its own recap values (chi --set recap.enabled=false) rebuild the job.
+      rebuild_recap!
       # A woken worker's /stats and status line count the turns before it.
       bind_metrics(session)
       @used_memories.absorb(session)
@@ -1752,6 +1789,66 @@ module Samagotchi
     # @return [IdleRecap, nil] the idle recap detector, or nil when disabled
     attr_reader :recap
 
+    # Whether a continue offer waits (the Worker's or the REPL's TurnFlow),
+    # for the recap job: this one and any rebuilt one (IdleRecap#awaiting_continue=).
+    def recap_awaiting_continue=(callable)
+      @recap_awaiting_continue = callable
+      @recap&.awaiting_continue = callable
+    end
+
+    # The idle recap job (RecapSetup.build) under the current session's own
+    # recap values, which it records.
+    # @return [IdleRecap, nil]
+    def build_recap
+      @recap_built_for = session_recap_values
+      recap = RecapSetup.build(@recap_kwarg, engine: self, host_registry: @host_registry,
+                                             session_target: -> { session_model_recap_target },
+                                             session_id: -> { @session&.id }, state_dir: -> { session_state_dir },
+                                             session_config: -> { @session&.settings&.core })
+      recap.awaiting_continue = @recap_awaiting_continue if recap && @recap_awaiting_continue
+      recap
+    end
+    private :build_recap
+
+    # The bound session's own recap.* values ({} for none).
+    def session_recap_values
+      (@session&.settings&.core || {}).select { |key, _| key.start_with?("recap.") }
+    end
+    private :session_recap_values
+
+    # A new recap job when the bound session's own recap values differ from
+    # the ones the current job was built under (none at start): the old one
+    # is dropped (an attempt in flight goes stale) and the scheduler swaps
+    # it, keeping its one thread. Binding the same session again changes
+    # nothing (the REPL binds it twice).
+    def rebuild_recap!
+      return if session_recap_values == @recap_built_for
+
+      old = @recap
+      old&.invalidate!
+      @recap = build_recap
+      @idle_scheduler&.replace_job(old, @recap)
+    end
+
+    # /recap on|off|default: the bound session's own recap.enabled (true,
+    # false; nil removes it, so config.yml's applies again), and the recap
+    # job rebuilt under it at once. It doesn't save: the command says
+    # changed: [:recap] and its host saves (Worker#run_command).
+    # @param enabled [Boolean, nil]
+    # @raise [ArgumentError] no session is bound
+    def recap_override=(enabled)
+      raise ArgumentError, "no session" unless @session
+
+      core = @session.settings.core.dup
+      enabled.nil? ? core.delete(RECAP_ENABLED_KEY) : core[RECAP_ENABLED_KEY] = enabled
+      @session.settings = @session.settings.with(core: core)
+      rebuild_recap!
+    end
+
+    # The bound session's own recap.enabled (/recap on|off, --set), or nil.
+    # @return [Boolean, nil]
+    def recap_override = @session&.settings&.core&.fetch(RECAP_ENABLED_KEY, nil)
+
     # Write the recap now, before the session is left (IdleRecap#write_now).
     # @return [String, nil] the recap written, nil when none was (recap off,
     #   nothing new, an error, the timeout)
@@ -2850,26 +2947,48 @@ module Samagotchi
     # stream handler's :generation_started, from the running turn's
     # conversation) and at turn end (#end_turn, from the session's kept
     # messages). Only when it differs from the last one emitted for this
-    # session, and never while it is empty, so a tool-free turn emits
-    # none. The web overlays it on the rows' set; other UIs ignore it.
+    # session, and never while it is empty — except one empty event,
+    # remembered, when the last one for this session had items (a
+    # rollback removed the tool calls), so a tool-free turn emits none
+    # and the next empty request sends nothing more. The web overlays it
+    # on the rows' set; other UIs ignore it.
+    #
+    # Between turns (#announce_working_set: no +on_event+) it is
+    # announced, under the next turn's strategy.
     def emit_working_set(on_event, session, conversation)
       return unless session && conversation
 
-      llm_context = @kernel.respond_to?(:turn_settings) ? @kernel.turn_settings&.llm_context : nil
-      snapshot = WorkingSet.build(conversation, cwd: session.working_directory,
-                                                strategy: llm_context&.strategy || LLMContextView::NONE)
-      return if snapshot.empty?
+      snapshot = WorkingSet.build(conversation, cwd: session.working_directory, strategy: working_set_strategy)
 
       items = snapshot.items.map(&:to_h)
-      return if @working_set_emitted == [session.id, items]
+      last = @working_set_emitted
+      if items.empty?
+        return unless last && last[0] == session.id && !last[1].empty?
+      elsif last == [session.id, items]
+        return
+      end
 
       @working_set_emitted = [session.id, items]
-      emit_event(on_event, { type: :working_set_updated, items: items, at: snapshot.at })
+      event = { type: :working_set_updated, items: items, at: snapshot.at }
+      on_event ? emit_event(on_event, event) : announce_or_hold(event)
     rescue StandardError => e
       Log.warn(:turn, "working_set_failed", error: e.class.name, msg: e.message.to_s[0, 200])
     end
     private :emit_working_set
 
+    # The strategy the set is built under: the running turn's
+    # (TurnSettings#llm_context: what its requests send); between turns
+    # the next turn's (as #warm_up_next_turn: the turn's settings keep the
+    # last turn's, stale after a /llm-context or /model change), the last
+    # turn's when it can't be resolved.
+    def working_set_llm_context
+      turn = @kernel.respond_to?(:turn_settings) ? @kernel.turn_settings&.llm_context : nil
+      return turn if turn_running?
+
+      @model_settings.turn_llm_context || turn
+    end
+    private :working_set_llm_context
+
     # A :generation_completed with the generation's decode speed (`speed:`
     # {decode_tps:, source:}, nil without one), the session's running
     # token totals (`tokens:`, the snapshot's block) and its per-model rows

data/lib/samagotchi/idle_scheduler.rb

@@ -25,7 +25,7 @@ module Samagotchi
       raise ArgumentError, "IdleScheduler requires an engine" unless engine
 
       @engine = engine
-      @jobs = jobs.compact
+      @jobs = jobs.compact.freeze
       @thread = nil
       @stopped = false
     end
@@ -49,6 +49,21 @@ module Samagotchi
       @thread = nil
     end
 
+    # Swap the job +old+ for +new+ (Engine#session= rebuilding the recap):
+    # nil +old+ adds +new+, nil +new+ drops +old+. The list is replaced
+    # whole, so a tick on the thread steps the old list or the new one; a
+    # running scheduler keeps its one thread, and one with no jobs yet
+    # starts it once #start is called.
+    def replace_job(old, new)
+      jobs = if @jobs.any? { |job| job.equal?(old) }
+               @jobs.map { |job| job.equal?(old) ? new : job }
+             else
+               @jobs + [new]
+             end
+      @jobs = jobs.compact.freeze
+      self
+    end
+
     # One step across all jobs. Public so specs can drive it deterministically.
     def tick
       return if @stopped

data/lib/samagotchi/llm_context_edit.rb

@@ -14,17 +14,21 @@ module Samagotchi
   # are replaced, never changed in place (.store), or an edit would reach
   # a checkpoint it was rolled back from.
   #
-  # kind: :stale (chi saw a later read or edit supersede it) or :forget
-  # (the model forgot it, its note keeping the finding); note: what the
-  # stub says; by: who made it ("chi", the model); staged_at/applied_at:
+  # kind: :stale (chi saw a later read or edit supersede it), :forget
+  # (the model forgot it, its note keeping the finding) or :drop (the user
+  # dropped it from the working set: WorkingSetSteer; sent whatever the
+  # strategy, LLMContextView#sends?); note: what the
+  # stub says; by: who made it ("chi", the model, "user"); staged_at/applied_at:
   # ISO 8601 times, applied_at nil while it waits to reach the prompt;
   # keep: the output's lines a forget keeps ([[first, last], …], as the
   # model named them; saved only when there are some), sent under the
   # stub; keep_offset: what those numbers are past the output's own lines
   # (a ranged read's start_line - 1: a read's keep names file lines; saved
-  # only when not 0).
-  LLMContextEdit = Data.define(:id, :kind, :note, :by, :staged_at, :applied_at, :keep, :keep_offset) do
-    def initialize(keep: [], keep_offset: 0, **fields) = super
+  # only when not 0); was: a drop's, the edit the output held before it
+  # (its saved Hash: an applied forget sent whole under none, a staged
+  # one, a stale stub), which an undrop puts back (one edit per id).
+  LLMContextEdit = Data.define(:id, :kind, :note, :by, :staged_at, :applied_at, :keep, :keep_offset, :was) do
+    def initialize(keep: [], keep_offset: 0, was: nil, **fields) = super
 
     def applied? = !applied_at.nil?
 
@@ -33,19 +37,27 @@ module Samagotchi
     # What the model reads instead of the output, after the output's
     # "[name]" lead.
     def stub
-      kind == :forget ? "(forgotten) #{note}" : note.to_s
+      case kind
+      when :forget then "(forgotten) #{note}"
+      when :drop then LLMContextEdit::DROP_STUB
+      else note.to_s
+      end
     end
 
     # The saved form, without the id (it is the key).
     def to_h
       saved = { "kind" => kind.to_s, "note" => note, "by" => by, "staged_at" => staged_at, "applied_at" => applied_at }
       saved = saved.merge("keep" => keep) if keep?
-      keep_offset.zero? ? saved : saved.merge("keep_offset" => keep_offset)
+      saved = saved.merge("keep_offset" => keep_offset) unless keep_offset.zero?
+      was ? saved.merge("was" => was) : saved
     end
   end
 
   class LLMContextEdit
-    KINDS = %i[stale forget].freeze
+    KINDS = %i[stale forget drop].freeze
+    # A user's drop is sent whatever the strategy (no layer names it).
+    DROP = :drop
+    DROP_STUB = "(dropped by the user) — read it again if the task needs it"
 
     # +hash+ as saved (string or symbol keys), or nil for one of no known
     # kind.
@@ -58,7 +70,8 @@ module Samagotchi
 
       new(id: id.to_s, kind: kind, note: field.call(:note).to_s, by: field.call(:by), staged_at: field.call(:staged_at),
           applied_at: field.call(:applied_at), keep: ranges(field.call(:keep)),
-          keep_offset: field.call(:keep_offset).is_a?(Integer) ? [field.call(:keep_offset), 0].max : 0)
+          keep_offset: field.call(:keep_offset).is_a?(Integer) ? [field.call(:keep_offset), 0].max : 0,
+          was: field.call(:was).is_a?(Hash) ? field.call(:was) : nil)
     end
 
     # Saved keep ranges as [[first, last], …]: pairs of positive Integers,
@@ -87,6 +100,15 @@ module Samagotchi
       entry
     end
 
+    # Whether +entry+ holds a saved drop (applied or not): the cheap check
+    # LLMContextView#messages makes under none.
+    def self.drop_on?(entry)
+      saved = entry[:edits]
+      saved.is_a?(Hash) && saved.each_value.any? do |hash|
+        hash.is_a?(Hash) && (hash["kind"] || hash[:kind]).to_s == "drop"
+      end
+    end
+
     # The edits saved on +entry+, by id.
     # @return [Hash{String => LLMContextEdit}]
     def self.on(entry)

data/lib/samagotchi/llm_context_forget.rb

@@ -9,6 +9,7 @@ require_relative "llm_context_stale"
 require_relative "llm_context_apply"
 require_relative "llm_context_view"
 require_relative "tools/forget_outputs"
+require_relative "working_set_steer"
 
 module Samagotchi
   # The forget layer (LLMContextStrategy :forget, experimental): the
@@ -33,7 +34,9 @@ module Samagotchi
   #   read (CLM's lesson);
   # - a keep that holds all of the output, an output too small for a stub
   #   to free anything (SMALL), an output already stubbed or forgotten, an
-  #   id nothing in context has.
+  #   id nothing in context has;
+  # - an output the user dropped (WorkingSetSteer): neither forgotten nor
+  #   restored by the model, in WorkingSetSteer::Refused's words.
   # A read is never restored: reading the file again is its restore, and
   # the file may have changed.
   module LLMContextForget
@@ -123,7 +126,10 @@ module Samagotchi
     # the model's latest outputs.
     def refusal(conversation, output, keep, last, protect_steps, kept_reads)
       return "no output with that id in context (ids look like t42)" unless output
-      return "already forgotten or stubbed" if LLMContextEdit.on(conversation[output.index]).key?(output.ref.id)
+
+      held = LLMContextEdit.on(conversation[output.index])[output.ref.id]
+      return WorkingSetSteer::Refused.text(:dropped) if held&.kind == LLMContextEdit::DROP
+      return "already forgotten or stubbed" if held
       if protect_steps.positive? && output.step >= last - protect_steps
         return "from your last #{protect_steps} step#{"s" unless protect_steps == 1}; you may still need it, forget it later"
       end
@@ -172,7 +178,10 @@ module Samagotchi
       ids.each do |id|
         output = outputs[id]
         edit = output && LLMContextEdit.on(conversation[output.index])[id]
-        if edit.nil? || edit.kind != :forget
+        if edit&.kind == LLMContextEdit::DROP
+          # The user's: only the user takes it back (/working-set undrop).
+          refused[id] = WorkingSetSteer::Refused.text(:dropped)
+        elsif edit.nil? || edit.kind != :forget
           refused[id] = "not forgotten"
         elsif output.read? && edit.applied?
           refused[id] = "a read: read the file again instead (it may have changed)"

data/lib/samagotchi/llm_context_view.rb

@@ -5,6 +5,7 @@ require_relative "tool_response"
 require_relative "tool_ids"
 require_relative "llm_context_edit"
 require_relative "llm_context_stale"
+require_relative "llm_context_strategy"
 
 module Samagotchi
   # What the model is sent of the stored conversation: the one step
@@ -15,11 +16,14 @@ module Samagotchi
   #
   # Under +none+ (the default) nothing changes: #messages returns the
   # conversation it was given, the same Array of the same entries, so the
-  # prompt is byte for byte what it was before the view existed.
+  # prompt is byte for byte what it was before the view existed. The one
+  # exception is the user's layer: an applied :drop (WorkingSetSteer, the
+  # working set's drop) is sent as its stub under every strategy, none
+  # too; a conversation without one is still returned as it is.
   #
-  # Under a strategy of layers (:stale, :forget), each applied edit saved
-  # on a tool_response entry (LLMContextEdit) whose kind is one of the
-  # layers sends that run's output as its stub. The entry stays where it
+  # Under a strategy of layers (:stale, :forget), each edit saved on a
+  # tool_response entry (LLMContextEdit) that #sends? (applied, and its
+  # kind one of the layers) sends that run's output as its stub. The entry stays where it
   # is, with its role and tool_call_id, so a call keeps its response and
   # the image plan (which indexes by entry) lines up. A stub keeps the
   # output's "[name]" lead (Gemma's prompt writes response:NAME from it),
@@ -44,7 +48,10 @@ module Samagotchi
   # (re-reading the file is a read's restore).
   class LLMContextView
     NONE = :none
-    LAYERS = LLMContextEdit::KINDS
+    # The strategy's layers (LLMContextStrategy::LAYERS), not the edit
+    # kinds (LLMContextEdit::KINDS): a kind no strategy names never
+    # becomes a layer, whatever a caller passes as the strategy.
+    LAYERS = LLMContextStrategy::LAYERS
 
     # @return [Array<Symbol>] the layers; empty under none
     attr_reader :layers
@@ -78,7 +85,7 @@ module Samagotchi
     # @param conversation [Array<Hash>] the stored entries, in order
     # @return [Array<Hash>] the entries to format
     def messages(conversation)
-      return conversation if none?
+      return conversation if none? && conversation.none? { |entry| LLMContextEdit.drop_on?(entry) }
 
       group = Group.new
       group.paired = forget? ? LLMContextStale.paired_runs(conversation).to_set { |run| run.ref.id } : Set.new
@@ -87,6 +94,11 @@ module Samagotchi
 
     def forget? = layers.include?(:forget)
 
+    # Whether +edit+ (an LLMContextEdit) is sent: the one rule for which
+    # edits the view applies, applied and of one of the layers, or the
+    # user's drop (always on: no strategy names it).
+    def sends?(edit) = edit.applied? && (edit.kind == LLMContextEdit::DROP || layers.include?(edit.kind))
+
     # The forget whose stub carries the note the next forgotten output of
     # the same call points to: its first id and its note, author and stamp.
     # +paired+: the ids of the runs that pair with their calls.
@@ -100,7 +112,7 @@ module Samagotchi
     def edited(conversation, entry, index, group)
       return entry unless entry[:role].to_s == "tool_response"
 
-      edits = LLMContextEdit.on(entry).select { |_id, edit| edit.applied? && layers.include?(edit.kind) }
+      edits = LLMContextEdit.on(entry).select { |_id, edit| sends?(edit) }
       return entry if edits.empty? && !forget?
 
       refs = ToolIds.refs_at(conversation, index)

data/lib/samagotchi/memory_bundle/installer.rb

@@ -259,6 +259,8 @@ module Samagotchi
         @source_owned = prepared.owned
         @source_commit = prepared.commit
         @manifest = Manifest.read(dir: @bundle_dir)
+        clash = @manifest.session_settings_clash
+        raise InstallError, clash if clash
       rescue SourceNormalizer::UnknownSourceError => e
         raise InstallError, "Source normalization failed: #{e.message}"
       rescue Manifest::ValidationError => e

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -93,6 +93,17 @@ module Samagotchi
         @session_setting_types = self.class.parse_session_setting_types(raw["session_settings"])
       end
 
+      # Why the install refuses this bundle's session_settings: a key whose
+      # NAME.KEY is chi's own session setting (SessionConfig.clash, the
+      # words chi bundle check reports too), nil when none clashes.
+      # @return [String, nil]
+      def session_settings_clash
+        return nil if @session_settings.empty?
+
+        require_relative "../session_config"
+        SessionConfig.clash(@name, @session_settings)
+      end
+
       # A profile: it installs the bundles in includes instead of files.
       def meta?
         !@includes.empty?
@@ -171,11 +182,11 @@ module Samagotchi
         File.write(File.join(dir, "manifest.yml"), YAML.dump(manifest))
       end
 
-      # A setting key a session may set (BundleSessionSettings::KEY).
+      # A setting key a session may set (SessionConfig::KEY).
       SESSION_SETTING = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
 
       # The types a session setting may be given (session_settings: {key:
-      # type}), checked by BundleSessionSettings.check!: number (or off),
+      # type}), checked by SessionConfig.check!: number (or off),
       # boolean, string; any (or a list's key) takes every scalar.
       SESSION_SETTING_TYPES = %w[number boolean string any].freeze
 

data/lib/samagotchi/message_parts.rb

@@ -187,6 +187,9 @@ module Samagotchi
       mark[:staged] = true unless edit.applied?
       if edit.kind == :stale
         mark[:note] = edit.note[/superseded by .*\z/] || edit.note
+      elsif edit.kind == LLMContextEdit::DROP
+        # The user's: no note, no grouping (a forget's key is its note).
+        mark[:by] = edit.by
       else
         key = [edit.note, edit.by, edit.staged_at]
         if first.key?(key)
@@ -201,12 +204,14 @@ module Samagotchi
       mark
     end
 
-    # +output+'s ✂ mark (+marks+ by +id+); an applied stale stub says
-    # what it frees: its output, ~chars/4.
+    # +output+'s ✂ mark (+marks+ by +id+); an applied stale stub or a
+    # user's drop says what it frees: its output, ~chars/4.
+    WHOLE_STUBS = %w[stale drop].freeze
+
     def mark_of(id, marks, output)
       mark = marks[id]
       return nil unless mark
-      return mark unless mark[:kind] == "stale" && !mark[:staged] && output
+      return mark unless WHOLE_STUBS.include?(mark[:kind]) && !mark[:staged] && output
 
       mark.merge(tokens: (output.length / TokenUsage::CHARS_PER_TOKEN).ceil)
     end

data/lib/samagotchi/plugin/context.rb

@@ -104,7 +104,7 @@ module Samagotchi
 
       # config.yml `bundles: <bundle>:` with the session's own values for
       # the bundle laid over it (chi --set BUNDLE.KEY=VALUE, through the
-      # Host's setup: SessionSetup#bundle_settings), string keys, frozen.
+      # Host's setup: SessionSetup#settings's bundles), string keys, frozen.
       # Plugin init and chi.ctx run before the session is bound: with no
       # session id yet it is the config alone, and it is built again once
       # per session id (the session's values never change after it starts).
@@ -473,7 +473,7 @@ module Samagotchi
       # The session's own values for this bundle ({} without any; nil when
       # the Host couldn't tell them, so #settings can retry).
       def session_values(id)
-        values = @host.setup&.call&.bundle_settings
+        values = @host.setup&.call&.settings&.bundles
         values.is_a?(Hash) ? values.fetch(@bundle, {}) : {}
       rescue StandardError => e
         unless (@session_settings_unread ||= {}).key?(id)

data/lib/samagotchi/prompt.rb

@@ -27,7 +27,7 @@ module Samagotchi
   #   - Generation cue: <|im_start|>assistant\n
   module Prompt
     # Tail system messages whose text isn't the harness's own.
-    ESCAPED_KINDS = %w[note turn_note context].freeze
+    ESCAPED_KINDS = %w[note turn_note context working_set].freeze
 
     # @param messages [Array<Hash>] each element has :role and :content.
     #   Recognised roles: "system", "user", "model", "tool_response".

data/lib/samagotchi/recap_command.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Samagotchi
+  # /recap on|off|default, the setting form of /recap (the bare /recap,
+  # which shows the recap, is the UIs' own): this session's own
+  # recap.enabled (Engine#recap_override=), the same value
+  # `chi --set recap.enabled=…` saves, applied at once (the idle recap job
+  # is rebuilt or dropped). `default` removes it, and config.yml (or env)
+  # decides again. The session's value beats config.yml's: `/recap on`
+  # turns it on under `recap: false` too. It doesn't save: its host does
+  # on the reply's changed: [:recap] (Worker#run_command).
+  class RecapCommand
+    NAME = "/recap"
+    CHOICES = { "on" => true, "off" => false, "default" => nil }.freeze
+    USAGE = "usage: #{NAME} [on|off|default]".freeze
+
+    # @param engine [Engine] #session, #recap_override=, #recap
+    def initialize(engine:)
+      @engine = engine
+    end
+
+    # @param args [String] what follows /recap
+    # @return [Array(String, Boolean, Symbol)] the reply, whether this
+    #   session's recap setting changed, and :ok or :error
+    def run(args)
+      word = args.to_s.strip.downcase
+      return [USAGE, false, :error] unless CHOICES.key?(word)
+      return ["no session yet", false, :error] unless @engine.session
+
+      value = CHOICES.fetch(word)
+      changed = @engine.recap_override != value
+      @engine.recap_override = value if changed
+      [status_line(value), changed, :ok]
+    end
+
+    # "recap: off (this session; config.yml: on)", "recap: on (config.yml)".
+    # @param own [Boolean, nil] the session's own value, nil for none
+    def status_line(own)
+      from_config = self.class.config_status
+      line = if own.nil?
+               "recap: #{word(from_config[:on])} (#{from_config[:source]})"
+             else
+               "recap: #{word(own)} (this session; #{from_config[:source]}: #{word(from_config[:on])})"
+             end
+      # On by its own word, yet no job: a pinned recap host or model that
+      # doesn't resolve (warned in the log), or an embedder's recap: false.
+      on = own.nil? ? from_config[:on] : own
+      on && @engine.recap.nil? ? "#{line}; no recap is written: its host or model doesn't resolve (see the log)" : line
+    end
+
+    # Whether the recap is on without the session's own value: off by a
+    # scalar `recap: false`, `recap: {enabled: false}` or
+    # SAMAGOTCHI_RECAP_ENABLED=false (ConfigFile.recap_config sees all
+    # three), else on (the default).
+    # @return [Hash] {on: Boolean, source: "config.yml" or "env"}
+    def self.config_status
+      on = ConfigFile.recap_config != false
+      _value, origin = Config.get_with_origin("recap.enabled")
+      { on: on, source: origin == :env ? "env" : "config.yml" }
+    end
+
+    private
+
+    def word(enabled) = enabled ? "on" : "off"
+  end
+end