samagotchi 0.101.0 → 0.103.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.
@@ -345,6 +347,8 @@ module Samagotchi
       # A plugin tool's row refs resolve against the session's folder, as
       # answer refs do (AnswerRefs), not the process's.
       @kernel.session_cwd = -> { @session&.working_directory }
+      # forget_outputs refuses what the user pinned in the working set.
+      @kernel.working_set_pins = -> { @session&.working_set_pins || [] }
       # A cut tool output is saved whole in the session's folder.
       @kernel.session_dir = -> { @session&.id && Session.session_dir(@session.id, state_dir: session_state_dir) }
       @kernel.guardrail_gate = @guardrail_wiring.gate
@@ -786,7 +790,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 +811,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 +1163,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 +1179,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 +1759,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 +1791,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)
@@ -2846,30 +2945,54 @@ module Samagotchi
     end
 
     # The working set (WorkingSet) as the model has it, as a
-    # :working_set_updated event ({items:, at:}): at each request (the
+    # :working_set_updated event ({items:, at:}, adds: while the user's
+    # adds are pending): at each request (the
     # 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,
+                                  pins: session.working_set_pins)
 
-      items = snapshot.items.map(&:to_h)
-      return if @working_set_emitted == [session.id, items]
+      shown = snapshot.to_h.except(:at)
+      last = @working_set_emitted
+      if snapshot.empty?
+        return unless last && last[0] == session.id && last[1] != { items: [] }
+      elsif last == [session.id, shown]
+        return
+      end
 
-      @working_set_emitted = [session.id, items]
-      emit_event(on_event, { type: :working_set_updated, items: items, at: snapshot.at })
+      @working_set_emitted = [session.id, shown]
+      event = { type: :working_set_updated, **shown, 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_recap.rb

@@ -550,10 +550,16 @@ module Samagotchi
       @client
     end
 
+    # The summarize thread: its recap, or nil when it failed. A failure of
+    # any kind (a LoadError, a stack overflow too) ends it quietly, logged:
+    # no recap this time, and no dead thread's trace on the worker's
+    # stderr. A real exit or interrupt goes on as raised.
     def spawn_summarize(client, prompt)
       Thread.new do
         client.summarize(prompt, session_id: @session_id.call, on_usage: @on_usage)
-      rescue StandardError => e
+      rescue SystemExit, SignalException
+        raise
+      rescue Exception => e # rubocop:disable Lint/RescueException -- a recap's failure, whatever it is, is no recap
         # No recap this time (the next idle window tries again); say why.
         Log.exception(:recap, "summarize_failed", e)
         nil

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/kernel_loop.rb

@@ -30,6 +30,7 @@ require_relative "tool_ids"
 require_relative "llm_context_view"
 require_relative "llm_context_apply"
 require_relative "llm_context_forget"
+require_relative "working_set"
 require_relative "llm_context_notice"
 require_relative "answer_display"
 require_relative "llm/model_result"
@@ -178,6 +179,10 @@ module Samagotchi
     # a plugin tool's row refs resolve their files against (ToolRunner,
     # RowRefs); the Engine sets it. nil: the process's own (Dir.pwd).
     attr_accessor :session_cwd
+    # The session's working-set pins (a callable → Array<WorkingSetPin>),
+    # which forget_outputs refuses (LLMContextForget); the Engine sets it.
+    # nil: none.
+    attr_accessor :working_set_pins
     # The session's folder (a callable → String or nil), where ToolRunner
     # saves a cut output whole (ToolOutputFiles); the Engine sets it. nil:
     # none (a bare kernel), the cut says the output wasn't saved.
@@ -945,9 +950,16 @@ module Samagotchi
       end
 
       apply = -> { apply_llm_context!(turn.conversation, llm_context, context: turn.context, emit: turn.emit) }
-      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply)
+      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply, pinned: method(:pinned_ids))
     end
 
+    # The ids of +conversation+'s outputs the session's pins hold.
+    def pinned_ids(conversation)
+      pins = Array(@working_set_pins&.call)
+      WorkingSet.pinned_ids(conversation, pins: pins, cwd: @session_cwd&.call)
+    end
+    private :pinned_ids
+
     # Before each request of both loops (+moment+ :request; the warm-up
     # too, on its own copy, as the next turn's first request) and at the
     # end of a turn the model answered (:turn_end): the strategy's layers

data/lib/samagotchi/launch_mode.rb

@@ -11,6 +11,14 @@ module Samagotchi
     # reach the worker: a /model command, and no_interrupt on each posted
     # turn; --memory and --mute are session fields the worker reads.)
     REPL_ONLY = { verbose: "--verbose" }.freeze
+    # What an attached run can't be combined with (the worker runs its turns).
+    ATTACHED_CONFLICTS = { non_interactive: "--non-interactive", verbose: "--verbose" }.freeze
+    # Opening a `chi scratch` session a killed REPL left behind would turn it
+    # into a kept one.
+    SCRATCH_LEFTOVER = "that's a leftover scratch session; it is deleted at the next sweep (chi sessions clean)"
+    # A worker spawned or resumed for an attach whose Bridge never came (%s:
+    # the session id).
+    BRIDGE_LATE = "the worker for session %s did not start its Bridge in time"
 
     module_function
 
@@ -30,5 +38,19 @@ module Samagotchi
 
       [:attached, nil]
     end
+
+    # Why an attached run's flags don't go together, or nil when they do.
+    # @param options [Hash] bin/chi's parsed options
+    # @return [String, nil]
+    def attached_conflict(options)
+      conflict = ATTACHED_CONFLICTS.find { |key, _flag| options[key] }
+      if options[:attach] && options[:shared]
+        "use either --attach ID or --shared"
+      elsif options[:attach] && options[:resume]
+        "--attach takes the session id; --resume goes with --shared"
+      elsif conflict
+        "--attach/--shared can't be combined with #{conflict.last}"
+      end
+    end
   end
 end

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,12 @@ 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;
+  # - an output of an item the user pinned (+pinned+: WorkingSet.pinned_ids
+  #   of the session's pins), in WorkingSetSteer::Refused's words too (a
+  #   restore of one is fine: it brings the output back).
   # A read is never restored: reading the file again is its restore, and
   # the file may have changed.
   module LLMContextForget
@@ -71,8 +77,10 @@ module Samagotchi
     # call (both loops add the model's entry before its calls run).
     # @param apply [#call] → LLMContextApply::Outcome: the apply rule at a
     #   request, on the turn's conversation (KernelLoop#apply_llm_context!)
+    # @param pinned [#call, nil] conversation → the ids the user's pins
+    #   hold (WorkingSet.pinned_ids), asked only when a forget is asked
     # @return [String] the tool result
-    def call(turn, call, llm_context:, apply:, root: Dir.pwd, now: Time.now.utc.iso8601(3))
+    def call(turn, call, llm_context:, apply:, root: Dir.pwd, pinned: nil, now: Time.now.utc.iso8601(3))
       request = Tools::ForgetOutputs.parse(call)
       conversation = turn.conversation
       return restore(turn, request.restore, llm_context) if request.restore? && request.ids.empty?
@@ -82,7 +90,8 @@ module Samagotchi
                "what's ruled out, NEXT), since it is all that stays of them"
       end
 
-      forgotten, refused = forget(conversation, request, llm_context.protect_steps, root, now)
+      pinned_ids = pinned ? pinned.call(conversation) : Set.new
+      forgotten, refused = forget(conversation, request, llm_context.protect_steps, root, now, pinned_ids)
       lines = if forgotten.empty?
                 ["nothing forgotten"]
               else
@@ -96,7 +105,7 @@ module Samagotchi
     # Saves a staged forget on each output +request+ names that may go.
     # @return [Array(Array<String>, Hash{String => String})] the ids
     #   forgotten, and the refused ones with why
-    def forget(conversation, request, protect_steps, root, now)
+    def forget(conversation, request, protect_steps, root, now, pinned_ids)
       outputs = outputs(conversation)
       last = LLMContextStale.step_count(conversation)
       # The steps before the call's own: protected_ids counts that one too.
@@ -104,7 +113,7 @@ module Samagotchi
                                                                root: root)
       refused = {}
       forgotten = request.ids.select do |id|
-        why = refusal(conversation, outputs[id], request.keep[id], last, protect_steps, kept_reads)
+        why = refusal(conversation, outputs[id], request.keep[id], last, protect_steps, kept_reads, pinned_ids)
         refused[id] = why if why
         why.nil?
       end
@@ -121,9 +130,13 @@ module Samagotchi
     # Why +output+ can't go (a String for the result), nil when it can.
     # +last+: the call's own step; the protect_steps steps before it are
     # the model's latest outputs.
-    def refusal(conversation, output, keep, last, protect_steps, kept_reads)
+    def refusal(conversation, output, keep, last, protect_steps, kept_reads, pinned_ids)
       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 WorkingSetSteer::Refused.text(:pinned_by_user) if pinned_ids.include?(output.ref.id)
+      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 +185,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