samagotchi 0.2.0 → 0.3.0

data/lib/samagotchi/engine.rb

@@ -8,6 +8,7 @@ require "yaml"
 
 require_relative "config"
 require_relative "context_note"
+require_relative "steer"
 require_relative "turn_note"
 require_relative "model_profile"
 require_relative "thought_stream_splitter"
@@ -15,14 +16,17 @@ require_relative "cancellation_controller"
 require_relative "context_window"
 require_relative "kernel_loop"
 require_relative "tools/builtins"
+require_relative "tools/task_runtime"
 require_relative "session_commands"
 require_relative "plugin/loader"
 require_relative "log"
 require_relative "log_subscriber"
+require_relative "client"
 require_relative "host_registry"
 require_relative "llm/backend"
 require_relative "llm/openai_chat"
 require_relative "session"
+require_relative "archive_store"
 require_relative "session_observer"
 require_relative "tool_declarations"
 require_relative "session_metrics"
@@ -41,6 +45,8 @@ require_relative "served_model"
 require_relative "image_store"
 require_relative "vision_context"
 require_relative "vision_support"
+require_relative "sampling_settings"
+require_relative "answer_display"
 
 module Samagotchi
   # Engine owns the core agent logic: system prompt construction, tool
@@ -74,11 +80,16 @@ module Samagotchi
     # @param muted_memories     [Array<String>] --mute list: memories hidden from this session (not in the
     #   prompt's index, dropped from the preloads, refused by memory_read); a mute wins over a preload
     DEFAULT_SYSTEM_MEMORIES = %w[identity].freeze
+    # What memory_write answers in a scratch session.
+    SCRATCH_MEMORY_WRITE = "Error: scratch session: nothing is saved"
 
     # @param plugins            [Boolean] false: load no bundle plugins (a throwaway Engine for a prompt)
+    # @param scratch            [Boolean] a `chi scratch` session: memory writes are refused, and there is no
+    #   delegate (a child would outlive it) nor plugin fork
     def initialize(mode: :assist, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, model_name: nil, memories: [], muted_memories: [], kernel: nil, recap: nil, reminders: nil,
-                   plugins: true)
+                   plugins: true, scratch: false)
       @mode = mode.to_sym
+      @scratch = scratch
       @chat_backend = nil
       @chat_backend_mutex = Mutex.new
       @default_model_name = ModelProfile.required_model_name(model_name)
@@ -113,6 +124,12 @@ module Samagotchi
       # The tools this session offers (the prompts' declarations and the
       # kernel's dispatch): the built-ins, per Engine.
       @tools = Tools::Builtins.registry
+      if @scratch
+        # A scratch session's children would outlive it; its memories
+        # would too (write and edit into the memories: ScratchWrites).
+        [Tools::Delegate::NAME, Tools::DelegateResult::NAME].each { |name| @tools.unregister(name) }
+        @tools[Tools::MemoryWrite::NAME].handler = ->(_call, _kctx) { SCRATCH_MEMORY_WRITE }
+      end
       # Likewise the slash commands its SessionCommands run.
       @command_registry = SessionCommands.register_builtins(Commands::Registry.new)
       # Installed bundles' plugins add commands, tools and hooks to these
@@ -220,6 +237,9 @@ module Samagotchi
       @activity_seq = 0
       @turn_running = false
       @active_cancel_controller = nil
+      # Plugin steers ({text:, source:}) waiting for the running turn's next
+      # boundary (#steer); guarded by @activity_mutex.
+      @steers = []
       # Reminder names the interactive REPL's IdleReminders callback marked due;
       # the REPL polls them to decide when to run a synthetic reminder turn.
       @due_reminder_names = []
@@ -302,6 +322,58 @@ module Samagotchi
       @activity_mutex.synchronize { @turn_running }
     end
 
+    # Put +text+ into the running turn, as a UI's steering does: it joins the
+    # conversation at the loop's next iteration boundary as its own user
+    # message (kind: "steer", source:). Callable from any thread; never
+    # blocks. With no turn running it does nothing (it never starts one).
+    # True means queued, not merged: at the after-answer boundary, and when
+    # the turn ends first, it is dropped (logged).
+    # @return [Boolean] whether it was queued
+    def steer(text, source:)
+      text = text.to_s.strip
+      return false if text.empty?
+
+      @activity_mutex.synchronize do
+        return false unless @turn_running
+
+        @steers << { text: text, source: source.to_s }
+      end
+      true
+    end
+
+    # The drain a turn's loop gets: the caller's lines (a UI's steering; nil
+    # in a --non-interactive run) and the plugin steers. At the after-answer
+    # boundary the steers are dropped: the model answered, and a nudge would
+    # only restart the turn. The steer part fails on its own, never taking
+    # the user's lines with it.
+    def turn_drain(pending_input)
+      lambda do |at_answer: false|
+        lines = pending_input ? Array(pending_input.call) : []
+        lines + take_steers(at_answer)
+      end
+    end
+    private :turn_drain
+
+    def take_steers(drop)
+      steers = @activity_mutex.synchronize do
+        taken = @steers
+        @steers = []
+        taken
+      end
+      return steers unless drop
+
+      log_dropped_steers(steers, "answered")
+      []
+    rescue StandardError
+      []
+    end
+    private :take_steers
+
+    def log_dropped_steers(steers, why)
+      steers.each { |steer| Log.info(:turn, "steer_dropped", source: steer[:source], why: why, chars: steer[:text].length) }
+    end
+    private :log_dropped_steers
+
     # @return [Array<String>] reminder names queued for a synthetic REPL turn
     def due_reminder_names
       @activity_mutex.synchronize { @due_reminder_names.dup }
@@ -341,7 +413,7 @@ module Samagotchi
       snapshot = @activity_mutex.synchronize { @session&.messages }
       return "[]" if snapshot.nil?
 
-      JSON.generate(Array(snapshot).map(&:dup))
+      JSON.generate(AnswerDisplay.strip_all(snapshot).map(&:dup))
     end
 
     # Emit a :recap_ready event (additive slot) carrying the generated recap
@@ -892,9 +964,12 @@ module Samagotchi
       target = @host_registry.resolve(@effective_model_name)
       served, served_for = served_model_for(snapshot, target: target)
       snapshot = snapshot.merge(served_model: served, served_model_for: served_for)
-      unless snapshot[:context_window_tokens]
+      unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
-        snapshot = snapshot.merge(context_window_tokens: window.tokens, context_window_source: window.source) if window
+        if window
+          snapshot = snapshot.merge(context: snapshot[:context].merge(window_tokens: window.tokens,
+                                                                      window_source: window.source.to_s))
+        end
       end
       # The chat loop uses no prompt profile: drop one a native turn reported.
       return snapshot.except(:profile, :profile_source) if target.entry.chat?
@@ -906,10 +981,28 @@ module Samagotchi
       snapshot
     end
 
+    # The status line's ctx from the saved context, for a worker that has run
+    # no turn yet (it woke after an idle exit): nil when either count is
+    # unknown or context.status is off.
+    def saved_context_status(context)
+      return nil unless context && @kernel.respond_to?(:context_display)
+
+      @kernel.context_display(used_tokens: context[:used_tokens], window_tokens: context[:window_tokens])
+    end
+
     # The effective model is on a chat host (api: openai), whose loop uses
     # no prompt profile.
     def chat_model? = @host_registry.resolve(@effective_model_name).entry.chat?
 
+    # "temperature=0.6 (hosts.work)" for /model: the effective model's
+    # configured sampling, nil when none.
+    def sampling_summary
+      target = @host_registry.resolve(@effective_model_name)
+      SamplingSettings.summary(target, names: model_lookup_names(target))
+    rescue StandardError
+      nil
+    end
+
     # The model the server serves for the current model, and the name asked
     # for: what the last generation of that name reported, else llama.cpp's
     # model_alias (/props, one short cached probe; not with probe: false),
@@ -941,12 +1034,13 @@ module Samagotchi
     #     :recap_min_user_turns and :recap_inactivity_seconds (nil when not)
     def session_state_snapshot
       served_pair = served_model(probe: false)
+      metrics = @metrics.snapshot
       {
         status: @session&.status,
         message_count: (@session&.messages || []).size,
         last_prompt: @session&.last_prompt,
         event_seq: @session_observer&.event_count,
-        metrics: @metrics.snapshot,
+        metrics: metrics,
         pending_question: @question_mutex.synchronize { @pending_question&.dup },
         used_memory_names: @used_memory_mutex.synchronize { @used_memory_names.dup },
         preloaded_memory_names: preloaded_memory_names,
@@ -955,7 +1049,7 @@ module Samagotchi
         model_name: @effective_model_name,
         served_model: served_pair[0],
         served_model_for: served_pair[1],
-        context_status: @last_context_status&.dup,
+        context_status: @last_context_status&.dup || saved_context_status(metrics[:context]),
         recap_enabled: !@recap.nil?,
         recap_min_user_turns: @recap&.min_user_turns,
         recap_inactivity_seconds: @recap&.inactivity&.to_i
@@ -1069,6 +1163,14 @@ module Samagotchi
     # its own.
     attr_writer :session_state_dir
 
+    # The metrics load the session's saved records from its state dir, once.
+    def bind_metrics(session)
+      return unless session.respond_to?(:id) && session.id
+
+      @metrics.state_dir = session_state_dir
+      @metrics.session_id = session.id
+    end
+
     def session_state_dir = @session_state_dir || Session.default_state_dir
 
     # What a Bridge adds to a plugin's ctx.messages while a turn runs (the
@@ -1085,7 +1187,8 @@ module Samagotchi
     # The gate's core checks, in order.
     def guardrail_checks
       rules = guardrail_rules
-      [@guardrail_failures, rules.hook_asks, guardrail_protected_paths, rules]
+      [@guardrail_failures, rules.hook_asks, guardrail_protected_paths, (@scratch_writes ||= Guardrails::ScratchWrites.new if @scratch),
+       rules].compact
     end
 
     # The YAML rules: config.yml's `guardrails:` section (rules, disable) and
@@ -1231,10 +1334,44 @@ module Samagotchi
     # The conversation as a hook may read it: a frozen array of copied
     # messages, so a hook cannot change what the turn sends or stores.
     def hook_messages(messages)
-      Array(messages).map(&:dup).freeze
+      AnswerDisplay.strip_all(messages).map(&:dup).freeze
     end
     private :hook_messages
 
+    # How the turn ended, on the session (Session#last_turn): the caller's
+    # save puts it in the file the session hub watches.
+    def record_last_turn(session, outcome, seconds, origin)
+      client_id = origin.is_a?(Hash) ? origin[:client_id].to_s : ""
+      source = if client_id.start_with?("#{Tools::Delegate::CLIENT_PREFIX}:") then "delegate"
+               elsif client_id == SessionManager::REMINDER_CLIENT_ID then "reminder"
+               else "client"
+               end
+      session.last_turn = { "outcome" => outcome, "ended_at" => Time.now.iso8601(3),
+                            "seconds" => seconds.round(1), "origin" => source }
+    end
+    private :record_last_turn
+
+    # Keep what the after_turn hooks presented as the answer's `display`
+    # and tell the observers (:answer_display), after the turn_completed
+    # they already had: the web re-reads the answer then. A turn_completed
+    # with display_pending (after_turn hooks were about to run) always gets
+    # one, `display: nil` when nothing was presented, so the web holds the
+    # answer's pop until then and never swaps it after. Terminals are not
+    # sinks of it; they printed the answer already. The session is saved by
+    # the caller, as after every turn.
+    def store_answer_display(session, display, pending: false)
+      synchronize_events do
+        messages = Array(session.messages)
+        if display.changed? && messages.last.equal?(display.target)
+          replace_session_messages(session, messages[0...-1] + [display.target.merge(AnswerDisplay::KEY => display.text)])
+          @session_observer.notify({ type: :answer_display, display: display.text })
+        elsif pending
+          @session_observer.notify({ type: :answer_display, display: nil })
+        end
+      end
+    end
+    private :store_answer_display
+
     # ── The hook runtime (Hooks::Runtime) ─────────────────────────────────────
 
     # The three things a hook can do beyond reading its event. Each gets the
@@ -1243,11 +1380,19 @@ module Samagotchi
       Hooks::Runtime.new(
         notify: ->(text:, level:, hook:) { hook_notify(text, level, hook) },
         ask_user: ->(question:, options:, header:, allow_freeform:, hook:) { hook_ask_user(question, options, header, allow_freeform, hook) },
-        stop_turn: ->(reason:, hook:) { hook_stop_turn(reason, hook) }
+        stop_turn: ->(reason:, hook:) { hook_stop_turn(reason, hook) },
+        steer: ->(text:, hook:) { steer(text, source: hook_source(hook)) }
       )
     end
     private :hook_runtime
 
+    # What a steer is attributed to: the bundle of a bundle hook's label
+    # ("<file> (bundle <name>)"), the label of any other.
+    def hook_source(hook)
+      hook.to_s[/\(bundle (.+)\)\z/, 1] || hook.to_s
+    end
+    private :hook_source
+
     # One line to the user (:hook_notice). During a turn it is a turn
     # event: the turn's sink (the REPL) and the observers (bridge, log).
     # Outside one (a plugin's command at the prompt) it is announced with
@@ -1379,7 +1524,7 @@ module Samagotchi
       # Persist to session file for WEB stub + resume (generic for all UIs)
       if @session
         @session.pending_question = pending.dup
-        begin; @session.save; rescue StandardError; nil; end
+        begin; @session.save(state_dir: session_state_dir); rescue StandardError; nil; end
       end
       # Generic emit for all UIs (TUI, WEB, Bridge, future). Observers that
       # stash this event (e.g. TerminalUI handle_question_event) will
@@ -1402,7 +1547,7 @@ module Samagotchi
               @pending_question = nil
               if @session
                 @session.pending_question = nil
-                begin; @session.save; rescue StandardError; nil; end
+                begin; @session.save(state_dir: session_state_dir); rescue StandardError; nil; end
               end
               emit_event(nil, { type: :question_answered, id: id, answer: ans })
               return ans
@@ -1413,7 +1558,7 @@ module Samagotchi
               @pending_question = nil
               if @session
                 @session.pending_question = nil
-                begin; @session.save; rescue StandardError; nil; end
+                begin; @session.save(state_dir: session_state_dir); rescue StandardError; nil; end
               end
               emit_event(nil, { type: :question_answered, id: id, answer: sync_res })
               return sync_res
@@ -1431,7 +1576,7 @@ module Samagotchi
         @question_mutex.synchronize { @pending_question = nil }
         if @session
           @session.pending_question = nil
-          begin; @session.save; rescue StandardError; nil; end
+          begin; @session.save(state_dir: session_state_dir); rescue StandardError; nil; end
         end
         return { error: "no answer", detail: "handler failed to capture selection", id: id }
       end
@@ -1453,7 +1598,7 @@ module Samagotchi
           @pending_question = nil
           if @session
             @session.pending_question = nil
-            begin; @session.save; rescue StandardError; nil; end
+            begin; @session.save(state_dir: session_state_dir); rescue StandardError; nil; end
           end
           emit_event(nil, { type: :question_cancelled, id: id, reason: active_cancel_controller.reason.to_s })
           return { error: "cancelled", reason: active_cancel_controller.reason.to_s, id: id }
@@ -1464,7 +1609,7 @@ module Samagotchi
       @question_mutex.synchronize { @pending_question = nil }
       if @session
         @session.pending_question = nil
-        begin; @session.save; rescue StandardError; nil; end
+        begin; @session.save(state_dir: session_state_dir); rescue StandardError; nil; end
       end
       if answer
         emit_event(nil, { type: :question_answered, id: id, answer: answer })
@@ -1512,6 +1657,9 @@ module Samagotchi
         @question_answer = answer
         @question_cv.broadcast
         answer
+      end.tap do
+        # A human answered: the session is back in the lists (ArchiveStore).
+        ArchiveStore.user_input(@session&.id, state_dir: session_state_dir)
       end
     end
 
@@ -1586,6 +1734,8 @@ module Samagotchi
       @session = session
       # One session per REPL/worker process: its records carry this sid.
       Log.session_id = session.id if session.respond_to?(:id) && session.id
+      # A woken worker's /stats and status line count the turns before it.
+      bind_metrics(session)
       sync_used_memories_from_session(session)
     end
 
@@ -1616,7 +1766,7 @@ module Samagotchi
 
       messages = @activity_mutex.synchronize { @session&.messages } || []
       covered = state[:covered].to_i
-      turns_since = Array(messages).drop(covered).count { |m| m.is_a?(Hash) && (m["role"] || m[:role]).to_s == "user" }
+      turns_since = Array(messages).drop(covered).count { |m| Steer.prompt?(m) }
       { text: state[:text], covered: covered, turns_since: turns_since, created_at: state[:created_at] }
     end
 
@@ -1710,9 +1860,12 @@ module Samagotchi
       # stay unchanged for callers that don't pass it.
       with_origin = origin ? ->(event) { event.merge(origin: origin) } : ->(event) { event }
       begin
+        # A Stop cuts the /props probes this thread makes for the turn
+        # (window, served model, vision) instead of waiting their timeout.
+        probe_cancel_before = Client.swap_probe_cancel(effective_controller)
         image_refs, image_error = turn_image_refs(session, continue ? [] : images)
         # Emit turn_started event
-        @metrics.session_id = session.id
+        bind_metrics(session)
         turn_started = { type: :turn_started, session_id: session.id, prompt: prompt }
         turn_started[:continue] = true if continue
         turn_started[:images] = image_refs unless image_refs.empty?
@@ -1722,6 +1875,7 @@ module Samagotchi
         # Before anything of the turn is kept or a reminder is used up.
         vision = turn_vision(session)
         @kernel.vision = vision if @kernel.respond_to?(:vision=)
+        @kernel.sampling = turn_sampling if @kernel.respond_to?(:sampling=)
         refuse_images!(vision) unless image_refs.empty?
         announce_guardrail_failures(on_event)
         # Plugins' slow setup that brings tools (an MCP server's first
@@ -1785,7 +1939,7 @@ module Samagotchi
           cancel_controller: effective_controller,
           model_name: bare_for_backend,
           max_tool_output_chars: max_tool_output_chars,
-          pending_input: pending_input
+          pending_input: turn_drain(pending_input)
         )
 
         # Persist deduped used memories onto the session for Web + reload.
@@ -1818,24 +1972,31 @@ module Samagotchi
         # placeholder text) is a turn the model should know ended that way.
         empty = !canceled && !resumable &&
                 (response.strip.empty? || (result.respond_to?(:empty_answer?) && result.empty_answer?))
+        # after_turn hooks run below and may present the answer (the web
+        # holds its pop until it knows).
+        display_pending = !canceled && @hooks.any?(:after_turn)
         synchronize_events do
           if empty
             # The placeholder is for the UIs (a new array: it must not leak
             # into the result); the note is for the model, so it goes on the
             # result's conversation too, which the REPL keeps as-is.
+            # A retry's nudge at the tail goes: this note says it all.
             note = TurnNote.empty
-            saved = (conversation || session.messages).dup
+            conversation&.replace(TurnNote.without_trailing(conversation))
+            saved = TurnNote.without_trailing(conversation || session.messages)
             saved << { role: "model", content: "[No response]" } if response.strip.empty?
             replace_session_messages(session, saved + [note])
             conversation << note if conversation
           elsif canceled && conversation
             conversation << TurnNote.cancelled(result.cancellation_reason, seconds: turn_seconds.call,
-                                                                          shown: TurnNote.interrupted_tail?(conversation))
+                                                                          shown: TurnNote.interrupted_tail?(conversation),
+                                                                          running_tasks: Tools::TaskRuntime.running_created_in(conversation))
             replace_session_messages(session, conversation)
           elsif conversation
             replace_session_messages(session, conversation)
           end
           session.status = Session::STATUS_IDLE
+          record_last_turn(session, canceled ? "canceled" : "completed", turn_seconds.call, origin)
           if canceled
             emit_event(on_event, with_origin.call({
               type: :turn_canceled,
@@ -1847,16 +2008,22 @@ module Samagotchi
             emit_event(on_event, with_origin.call({
               type: :turn_completed,
               result: result,
-              turn_summary: turn_summary(result)
+              turn_summary: turn_summary(result),
+              display_pending: display_pending
             }))
           end
         end
-        @metrics.persist
+        @metrics.persist(state_dir: session_state_dir)
 
         # Fire :after_turn hook (runs even on cancel/success), with a read-only
-        # copy of the conversation the turn stored.
-        @hooks.fire(:after_turn, { type: :after_turn, status: canceled ? "canceled" : "completed",
-                                   messages: hook_messages(session.messages) })
+        # copy of the conversation the turn stored, and event[:present] for
+        # a display version of the answer (AnswerDisplay).
+        display = AnswerDisplay.new(session.messages)
+        after_turn = { type: :after_turn, status: canceled ? "canceled" : "completed",
+                       messages: hook_messages(session.messages) }
+        after_turn[:present] = display.presenter(after_turn)
+        @hooks.fire(:after_turn, after_turn)
+        store_answer_display(session, display, pending: display_pending)
 
         # Fire :session_end after every turn (turn-level lifecycle)
         @hooks.fire(:session_end, { type: :session_end, session_id: session.id })
@@ -1865,11 +2032,18 @@ module Samagotchi
       rescue Interrupt
         effective_controller.cancel!(:ctrl_c)
         synchronize_events do
-          replace_session_messages(session, TurnNote.replace_trailing(messages, TurnNote.cancelled(:ctrl_c, seconds: turn_seconds.call))) if messages
+          # Only the pre-turn messages survive here, so tasks this turn
+          # started are missed (plan wait-stop §6).
+          if messages
+            note = TurnNote.cancelled(:ctrl_c, seconds: turn_seconds.call,
+                                               running_tasks: Tools::TaskRuntime.running_created_in(messages))
+            replace_session_messages(session, TurnNote.replace_trailing(messages, note))
+          end
           session.status = Session::STATUS_IDLE
+          record_last_turn(session, "canceled", turn_seconds.call, origin)
           emit_event(on_event, with_origin.call({ type: :turn_canceled, cancellation_reason: :ctrl_c }))
         end
-        @metrics.persist
+        @metrics.persist(state_dir: session_state_dir)
         raise
       rescue StandardError => e
         # Keep what the turn got to (the prompt plus the loop's completed
@@ -1885,14 +2059,15 @@ module Samagotchi
         end
         replace_session_messages(session, kept) if kept
         session.status = Session::STATUS_IDLE
-        begin; session.save; rescue StandardError; nil; end
+        record_last_turn(session, "failed", turn_seconds.call, origin)
+        begin; session.save(state_dir: session_state_dir); rescue StandardError; nil; end
         failed = { type: :turn_failed, error_class: e.class.name, message: e.message }
         # A provider error says what kind it is, for one line per kind in the UIs.
         if e.is_a?(LLM::ProviderError)
           failed.merge!(error_kind: e.kind, retryable: e.retryable?, host: e.host, summary: e.summary)
         end
         emit_event(on_event, with_origin.call(failed))
-        @metrics.persist
+        @metrics.persist(state_dir: session_state_dir)
         raise
       ensure
         # A completed turn is activity: release the turn flag and advance the
@@ -1900,10 +2075,13 @@ module Samagotchi
         # treats the just-finished turn as activity and re-arms its window.
         # Always runs, even if an exception occurred.
         set_turn_running(false)
-        @activity_mutex.synchronize do
+        Client.swap_probe_cancel(probe_cancel_before)
+        left = @activity_mutex.synchronize do
           @active_cancel_controller = nil
           @turn_event_sink = nil
+          @steers.tap { @steers = [] }
         end
+        log_dropped_steers(left, "turn_ended")
         record_activity
         # Clear hooks so they remain turn-scoped and never leak into the next turn.
         clear_hooks
@@ -1928,6 +2106,15 @@ module Samagotchi
                         capability: -> { VisionSupport.for(target, profile: profile, adapter: vision_adapter(target)) })
     end
 
+    # The effective model's request parameters (hosts: and models:
+    # sampling), read per turn: /model can change the model between turns.
+    def turn_sampling
+      target = @host_registry.resolve(@effective_model_name)
+      SamplingSettings.for(target, names: model_lookup_names(target))
+    rescue StandardError
+      SamplingSettings::EMPTY
+    end
+
     def vision_adapter(target)
       target.entry.chat? ? @host_registry.adapter_for(target.entry) : nil
     rescue StandardError
@@ -2161,11 +2348,14 @@ module Samagotchi
           (task = current_init_task) ? task.cancelled? : @activity_mutex && active_cancel_controller&.cancelled?
         },
         card: ->(**card) { show_card(**card) },
+        steer: ->(text, source) { steer(text, source: source) },
+        stop_turn: ->(reason, label) { hook_stop_turn(reason, label) },
         ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:|
           ask_side_model(request, timeout: timeout, max_tokens: max_tokens, cancel_controller: cancel_controller)
         },
         model_name: -> { @session&.model_name || @effective_model_name },
-        state_dir: -> { session_state_dir }
+        state_dir: -> { session_state_dir },
+        scratch: -> { @scratch }
       )
     end
 
@@ -2175,7 +2365,7 @@ module Samagotchi
     # with the event log held, so a turn is in exactly one of the two.
     def plugin_messages
       synchronize_events do
-        messages = messages_checkpoint || []
+        messages = AnswerDisplay.strip_all(messages_checkpoint)
         first = messages.first
         messages = messages.drop(1) if first && first[:role].to_s == "system" && first[:kind].to_s.empty?
         running = turn_running? && @running_turn_messages ? Array(@running_turn_messages.call) : []
@@ -2462,10 +2652,14 @@ module Samagotchi
       end
 
       target = @host_registry.resolve(@effective_model_name)
-      # As typed (maybe an alias), the part after a host prefix, alias-resolved, bare.
+      ModelProfile.resolve(names: model_lookup_names(target), entry: target.entry, client: target.client, bare_model: target.bare_model)
+    end
+
+    # The names a models: entry may be under: as typed (maybe an alias), the
+    # part after a host prefix, alias-resolved, bare.
+    def model_lookup_names(target)
       typed = @model_lookup_names.first
-      names = @model_lookup_names + [@host_registry.parse_qualified_model(typed).last, target.bare_model]
-      ModelProfile.resolve(names: names.compact, entry: target.entry, client: target.client, bare_model: target.bare_model)
+      (@model_lookup_names + [@host_registry.parse_qualified_model(typed).last, target.bare_model]).compact
     end
 
     # Everything that holds a profile follows the resolution: the kernel's
@@ -2661,6 +2855,8 @@ module Samagotchi
       end
 
       merged = Array(baseline).dup
+      # For the warning when one can't be loaded: it names where it came from.
+      @config_memories = merged.dup
       Array(cli_memories).each do |raw|
         raw.to_s.split(",").map(&:strip).reject(&:empty?).each do |name|
           merged << name unless merged.include?(name)
@@ -2693,7 +2889,8 @@ module Samagotchi
           scope, actual_name = split_memory_scope(name)
           body = Tools::MemoryRead.call(actual_name, scope: scope)
           if body.start_with?("Error:")
-            Log.warn(:memory, "preload_failed", echo: "Warning: --memory '#{name}' could not be loaded (#{body})", memory: name)
+            source = Array(@config_memories).include?(raw) ? "memory '#{name}' (from config memories:)" : "--memory '#{name}'"
+            Log.warn(:memory, "preload_failed", echo: "Warning: #{source} could not be loaded (#{body})", memory: name)
             next
           end
           # Record activated names so the UI can echo them in the sticky

data/lib/samagotchi/guardrails/approval.rb

@@ -36,6 +36,8 @@ module Samagotchi
             label: label,
             command: targets&.command,
             paths: targets && !targets.paths.empty? ? targets.paths : nil,
+            # No command or path (an MCP tool): its arguments, as the question.
+            args: args_for_card(targets),
             cwd: targets&.cwd,
             repo_root: targets&.repo_root,
             branch: verdict.context&.branch(targets&.cwd || verdict.context.cwd),
@@ -47,6 +49,13 @@ module Samagotchi
         }
       end
 
+      def args_for_card(targets)
+        return nil if targets.nil? || targets.command || !targets.paths.empty?
+
+        text = Approval.args_text(targets.args, limit: ARGS_CHARS)
+        text.empty? ? nil : text
+      end
+
       # Settle +verdict+ from open_question's result.
       # @param answer [Hash, String] {selected_indices:, freeform:} or {error:}
       # @param scopes [Array<String>] the offered scopes, in option order

data/lib/samagotchi/guardrails/scratch_writes.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "protected_paths"
+require_relative "../memory_paths"
+
+module Samagotchi
+  module Guardrails
+    # A `chi scratch` session saves nothing: write and edit on a file under
+    # the memories folder (system and project memories, overlays, index.md)
+    # are denied. (memory_write itself refuses in a scratch session, with a
+    # shorter answer: Engine.) Reading them is fine. execute can still
+    # write there (as with ProtectedPaths).
+    class ScratchWrites
+      REASON = "scratch session: nothing is saved"
+      RULE = "scratch-session"
+
+      # @param memories_dir [#call] the memories folder (MemoryPaths.system_dir),
+      #   read per call like the memory tools do
+      def initialize(memories_dir: -> { MemoryPaths.system_dir })
+        @memories_dir = memories_dir
+      end
+
+      # Vote on +verdict+.
+      def check(verdict)
+        return verdict unless writes_memory?(verdict)
+
+        verdict.deny!(REASON, rule: RULE, source: ProtectedPaths::SOURCE, decided_by: "core")
+      end
+
+      private
+
+      def writes_memory?(verdict)
+        targets = verdict.targets
+        return false unless targets && %w[write edit].include?(targets.tool)
+
+        targets.paths.any? { |path| ProtectedPaths.within?(ProtectedPaths.real(path), @memories_dir.call) }
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails.rb

@@ -6,6 +6,7 @@ require_relative "guardrails/targets"
 require_relative "guardrails/approval"
 require_relative "guardrails/approvals"
 require_relative "guardrails/protected_paths"
+require_relative "guardrails/scratch_writes"
 require_relative "guardrails/load_failures"
 require_relative "guardrails/rules"
 require_relative "guardrails/gate"