samagotchi 0.2.0 → 0.4.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,10 @@ require_relative "served_model"
 require_relative "image_store"
 require_relative "vision_context"
 require_relative "vision_support"
+require_relative "sampling_settings"
+require_relative "thinking"
+require_relative "answer_display"
+require_relative "edit_preview"
 
 module Samagotchi
   # Engine owns the core agent logic: system prompt construction, tool
@@ -74,16 +82,25 @@ 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
+      @host_registry = host_registry || HostRegistry.new
+      # A model given here (a worker's session model) is the one it runs,
+      # so its host is checked; the config default is only checked once it
+      # is used (the REPL checks the model it starts on, #switch_model!).
       @default_model_name = ModelProfile.required_model_name(model_name)
+      ModelProfile.check_host!(model_name, hosts: @host_registry.entries) unless model_name.to_s.strip.empty?
       @effective_model_name = @default_model_name
-      @host_registry = host_registry || HostRegistry.new
       # An injected client (specs) stands in for every host's client.
       @host_registry.client_override = client if client
       @client = @host_registry.resolve(@effective_model_name).client
@@ -105,6 +122,7 @@ module Samagotchi
       # to load is announced, and a required guardrail's failure denies
       # every tool call. Rules load now too, so their errors are announced.
       @guardrail_failures = Guardrails::LoadFailures.new
+      @guardrail_rules_mutex = Mutex.new
       # Plugins that failed to load: announced apart, as plugins (not
       # guardrails: no tool call is denied for them).
       @plugin_failures = Guardrails::LoadFailures.new
@@ -113,6 +131,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 +244,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 +329,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 +420,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
@@ -775,7 +854,7 @@ module Samagotchi
     def switch_model!(model_name, persist_default: false)
       # Resolve alias first (alias may point to qualified ref)
       aliased = ConfigFile.resolve_model_alias(model_name)
-      resolved = ModelProfile.required_model_name(aliased)
+      resolved = ModelProfile.check_host!(ModelProfile.required_model_name(aliased), hosts: @host_registry.entries)
       @effective_model_name = resolved
       bare = bare_model_name(resolved)
       @model_lookup_names = [model_name, aliased, resolved]
@@ -795,10 +874,6 @@ module Samagotchi
       resolved
     end
 
-    def reset_model!
-      switch_model!(@default_model_name)
-    end
-
     # ── Hooks API ──────────────────────────────────────────────────────────────
 
     # Register a hook callback for a named lifecycle event.
@@ -869,8 +944,6 @@ module Samagotchi
       clear_due_reminder_names!
       due
     end
-    # Alias for backward compatibility.
-    alias maybe_inject_reminders collect_due_reminders
 
     # @return [Boolean] whether any reminder is due now (the store's view,
     #   which #collect_due_reminders would inject), regardless of the REPL queue
@@ -892,9 +965,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 +982,38 @@ 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
+
+    # "off (models: qwen)" for /model: the effective model's thinking level
+    # and where it came from, nil when none is set.
+    def thinking_summary
+      target = @host_registry.resolve(@effective_model_name)
+      level, source = Thinking.resolve(target, names: model_lookup_names(target))
+      source ? "#{level} (#{source})" : nil
+    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 +1045,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 +1060,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
@@ -1034,6 +1139,9 @@ module Samagotchi
       base.empty? ? nil : base
     end
 
+    # A memory read (memory_read, or read of a memories/*.md file) as it
+    # starts: its names join used_memory_names.
+    # @return [Array<String>, nil] the names this call read, nil for any other event
     def capture_used_memory_from_event(event)
       return unless event.is_a?(Hash) && event[:type] == :tool_call_started
 
@@ -1044,6 +1152,7 @@ module Samagotchi
       return if names.empty?
 
       add_used_memory_names(names)
+      names
     end
 
     # ── Guardrails ─────────────────────────────────────────────────────────────
@@ -1069,6 +1178,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,33 +1202,60 @@ 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
     # installed bundles'. One that doesn't parse is a required load failure
-    # (every call is denied).
+    # (every call is denied). Read again when one of those files changed
+    # (a stat of each per tool call), so a long-lived worker follows edits.
     # @return [Guardrails::Rules]
     def guardrail_rules
-      @guardrail_rules ||= begin
-        section = Samagotchi::ConfigFile.read_yaml(path: Samagotchi::ConfigFile.global_path)
-        section = section["guardrails"] if section.is_a?(Hash)
-        rules = []
-        disable = []
-        begin
-          raise Guardrails::Rules::ParseError, "guardrails must be a mapping" unless section.nil? || section.is_a?(Hash)
-
-          rules = Guardrails::Rules.parse(section && section["rules"], source: "config")
-          disable = Guardrails::Rules.parse_disable(section && section["disable"])
-        rescue Guardrails::Rules::ParseError => e
-          Log.warn(:guardrails, "config_rules_invalid", echo: "[samagotchi:guardrails] config.yml guardrails rules: #{e.message}")
-          @guardrail_failures.add("rules in config.yml", e.message, required: true)
+      @guardrail_rules_mutex.synchronize do
+        stamp = guardrail_rules_stamp
+        if @guardrail_rules.nil? || stamp != @guardrail_rules_stamp
+          @guardrail_failures.drop(:rules)
+          @guardrail_rules = load_guardrail_rules
+          @guardrail_rules_stamp = stamp
         end
-        Guardrails::Rules.new(rules + bundle_guardrail_rules, disable: disable,
-                              enabled: Samagotchi::Config.get("guardrails.enabled") != false)
+        @guardrail_rules
       end
     end
 
+    # [path, mtime, size] of config.yml and every installed bundle's
+    # manifest.json and guardrails/ file.
+    def guardrail_rules_stamp
+      require_relative "memory_bundle/provenance"
+      paths = [Samagotchi::ConfigFile.global_path] +
+              Dir[File.join(MemoryBundle::Provenance.bundles_dir, "*", "{manifest.json,guardrails/*}")]
+      paths.compact.sort.map do |path|
+        stat = File.stat(path)
+        [path, stat.mtime.to_r, stat.size]
+      rescue SystemCallError
+        [path]
+      end
+    end
+
+    def load_guardrail_rules
+      section = Samagotchi::ConfigFile.read_yaml(path: Samagotchi::ConfigFile.global_path)
+      section = section["guardrails"] if section.is_a?(Hash)
+      rules = []
+      disable = []
+      begin
+        raise Guardrails::Rules::ParseError, "guardrails must be a mapping" unless section.nil? || section.is_a?(Hash)
+
+        rules = Guardrails::Rules.parse(section && section["rules"], source: "config")
+        disable = Guardrails::Rules.parse_disable(section && section["disable"])
+      rescue Guardrails::Rules::ParseError => e
+        Log.warn(:guardrails, "config_rules_invalid", echo: "[samagotchi:guardrails] config.yml guardrails rules: #{e.message}")
+        @guardrail_failures.add("rules in config.yml", e.message, required: true, group: :rules)
+      end
+      Guardrails::Rules.new(rules + bundle_guardrail_rules, disable: disable,
+                            enabled: Samagotchi::Config.get("guardrails.enabled") != false)
+    end
+    private :guardrail_rules_stamp, :load_guardrail_rules
+
     # Installed bundles' guardrails/*.yml, by bundle name then file name.
     # A file that is missing, changed since install (sha256) or doesn't
     # parse is a required load failure.
@@ -1121,7 +1265,7 @@ module Samagotchi
       MemoryBundle::Provenance.each_installed_with_guardrails do |bundle_name, data|
         if data[:error]
           Log.warn(:guardrails, "bundle_rules_invalid", echo: "[samagotchi:guardrails] bundle #{bundle_name}: #{data[:error]}", bundle: bundle_name)
-          @guardrail_failures.add("rules (bundle #{bundle_name})", data[:error], required: true)
+          @guardrail_failures.add("rules (bundle #{bundle_name})", data[:error], required: true, group: :rules)
           next
         end
         dir = MemoryBundle::Provenance.new(name: bundle_name).guardrails_dir
@@ -1143,14 +1287,14 @@ module Samagotchi
             rules.concat(Guardrails::Rules.parse(doc["rules"], source: "bundle #{bundle_name}"))
           rescue Guardrails::Rules::ParseError, Psych::Exception => e
             Log.warn(:guardrails, "rules_file_invalid", echo: "[samagotchi:guardrails] #{what}: #{e.message}", bundle: bundle_name, file: basename.to_s)
-            @guardrail_failures.add(what, e.message, required: true)
+            @guardrail_failures.add(what, e.message, required: true, group: :rules)
           end
         end
       end
       rules
     rescue StandardError => e
       Log.error(:guardrails, "bundle_rules_failed", echo: "[samagotchi:guardrails] failed to read installed bundles' rules: #{e.class}: #{e.message}", error: e.class.name)
-      @guardrail_failures.add("bundle rules", "#{e.class}: #{e.message}", required: true)
+      @guardrail_failures.add("bundle rules", "#{e.class}: #{e.message}", required: true, group: :rules)
       rules || []
     end
 
@@ -1224,17 +1368,62 @@ module Samagotchi
 
       # A plugin tool is asked about by its label, as its row shows it.
       label = ToolActivity.plugin_label(verdict.call[:name].to_s, registry: @tools)
-      payload = Guardrails::Approval.payload(verdict, label: label)
+      # verdict.call is the call that will run (a hook may have replaced it).
+      payload = Guardrails::Approval.payload(verdict, label: label, preview: approval_preview(verdict.call))
       Guardrails::Approval.settle(verdict, open_question(payload), payload[:approval][:scopes])
     end
 
+    # The dry-run diff of an edit/write call for its approval; a preview
+    # that fails only leaves the diff out, it never denies the call.
+    def approval_preview(call)
+      EditPreview.for(call)
+    rescue StandardError => e
+      Log.warn(:guardrails, "edit_preview_failed", error: "#{e.class}: #{e.message}")
+      nil
+    end
+    private :approval_preview
+
     # 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 +1432,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
@@ -1321,45 +1518,24 @@ module Samagotchi
       @question_mutex.synchronize { @pending_question&.dup }
     end
 
-    # Request a structured question from the user. Called from KernelLoop's
-    # turn thread (via dispatch): validates and cleans the model's payload,
-    # then #open_question. Returns a normalized JSON string for the
-    # tool_response.
+    # Ask the model's question (ask_user_question): the kernel's
+    # question_handler, called on the turn thread with the payload
+    # Tools::AskUserQuestion.validate made. Opens it (#open_question) and
+    # returns the answer as JSON for the tool result.
     # @param payload [Hash] {question:, options:, header:, multi_select:, allow_freeform:}
     # @return [String] normalized answer JSON
     def request_question(payload)
-      # Strip wire control tokens (<|...|> / stray <|,|>) that can bleed into the
-      # question text when the model wraps the tool call in markup.
-      question = strip_wire_tokens(payload[:question])
-      options = Samagotchi::Tools::AskUserQuestion.normalize_options_lenient(payload[:options])
-      # Fallback for string JSON that lenient missed
-      if options.empty? && payload[:options].is_a?(String)
-        options = Samagotchi::Tools::AskUserQuestion.normalize_options_lenient(payload[:options].to_s)
-      end
-      if question.empty? || options.empty?
-        return JSON.generate({ error: "invalid question", detail: "question and 2-8 options required (got #{options.size})" })
-      end
-      # Dumb-model salvage: allow single option (don't hard error, just render what we have)
-      if options.size == 1
-        # keep as is
-      elsif options.size < 2
-        return JSON.generate({ error: "invalid question", detail: "question and 2-8 options required (got #{options.size})" })
-      end
-      if options.size > 8
-        options = options.first(8)
-      end
-
-      clean_header = strip_wire_tokens(payload[:header])
-      result = open_question(
-        question: question,
-        options: options,
-        header: clean_header.empty? ? nil : clean_header,
-        multi_select: !!payload[:multi_select],
-        allow_freeform: !!payload[:allow_freeform]
-      )
+      result = open_question(**payload.slice(:question, :options, :header),
+                             multi_select: !!payload[:multi_select], allow_freeform: !!payload[:allow_freeform])
+      # Dismissed (the card's dismiss, Esc): an answer of its own, not a
+      # tool failure the model learns to avoid the tool from.
+      result = { dismissed: true, id: result[:id], note: QUESTION_DISMISSED_NOTE } if result.is_a?(Hash) && result[:error] == "no answer"
       result.is_a?(String) ? result : JSON.generate(result)
     end
 
+    QUESTION_DISMISSED_NOTE = "The user dismissed the question without answering. Go on with your best judgement, " \
+                              "or ask in your reply if you can't."
+
     # Open a question for the UIs and wait for its answer. Emits
     # :question_requested, persists it to the session, and BLOCKS until
     # answer_question / cancel_question wakes it (or the turn is cancelled).
@@ -1379,7 +1555,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 +1578,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 +1589,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 +1607,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 +1629,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 +1640,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,14 +1688,12 @@ 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
 
-    def strip_wire_tokens(text)
-      text.to_s.gsub(/<\|[^|]*\|>/, "").gsub(/<\||\|>/, "").strip
-    end
-    private :strip_wire_tokens
-
     def set_question_sync_handler(&block)
       @question_sync_handler = block
     end
@@ -1555,10 +1729,15 @@ module Samagotchi
     # prompt prefix, and the server's KV cache for it, stay stable.
     # @param target [HostRegistry::ModelTarget, nil]
     # @return [String]
+    # The native prompt depends on the thinking level too (Gemma's token,
+    # Qwen's turn preamble): a level change builds it again.
     def system_prompt(target = nil)
-      chat = (target || @host_registry.resolve(@effective_model_name)).entry.chat?
+      target ||= @host_registry.resolve(@effective_model_name)
+      chat = target.entry.chat?
+      level = chat ? nil : thinking_level(target)
       @system_prompts ||= {}
-      @system_prompts[chat] ||= system_prompt_with_index(assist_system_prompt(chat: chat), chat: chat)
+      @system_prompts[[chat, level]] ||= system_prompt_with_index(assist_system_prompt(chat: chat, thinking: level),
+                                                                  chat: chat, thinking: level)
     end
 
     # @return [Session] current session (Engine owns create/resume)
@@ -1586,6 +1765,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 +1797,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 +1891,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 +1906,11 @@ 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=)
+        thinking_target = @host_registry.resolve(@effective_model_name)
+        @turn_thinking = [thinking_level(thinking_target), thinking_target]
+        @kernel.thinking = @turn_thinking.first if @kernel.respond_to?(:thinking=)
+        announce_thinking_level(*@turn_thinking)
         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 +1974,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 +2007,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 +2043,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 +2067,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 +2094,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 +2110,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
@@ -1925,7 +2138,84 @@ module Samagotchi
     def turn_vision(session)
       target = @host_registry.resolve(@effective_model_name)
       VisionContext.new(session_dir: Session.session_dir(session.id, state_dir: session_state_dir),
-                        capability: -> { VisionSupport.for(target, profile: profile, adapter: vision_adapter(target)) })
+                        capability: lambda {
+                          VisionSupport.for(target, profile: profile, adapter: vision_adapter(target), names: model_lookup_names(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
+
+    # The effective model's thinking level (Thinking.resolve), read each turn.
+    def turn_thinking
+      thinking_level(@host_registry.resolve(@effective_model_name))
+    rescue StandardError
+      Thinking::DEFAULT
+    end
+
+    # An effort on a native host, which has no knob for it: said once per
+    # session and host.
+    def announce_thinking_level(level, target)
+      return if target.entry.chat? || Thinking.native(level, profile).honoured
+
+      thinking_notice_once(:unsupported, target, :info,
+                           "#{level} isn't supported by native #{profile.name} on #{target.entry.name}; " \
+                           "thinking stays as the model has it")
+    rescue StandardError
+      nil
+    end
+
+    # Thinking off, and the model thought anyway: logged each time, said
+    # once per session and host.
+    def check_thinking_honoured(event)
+      level, target = @turn_thinking
+      chars = event[:thinking_chars].to_i
+      return unless level == :off && chars.positive? && target
+
+      Log.warn(:model, "thinking_not_honoured", level: level, host: target.entry.name, model: target.bare_model, chars: chars)
+      thinking_notice_once(:not_honoured, target, :warn,
+                           "off wasn't honoured by #{target.bare_model} on #{target.entry.name} " \
+                           "(#{chars} chars of thinking); a sampling: override on the host or model may turn it off " \
+                           "(see Thinking in docs/configuration.md)")
+    rescue StandardError
+      nil
+    end
+
+    # The host refused the level's request fields (gpt-oss can't turn
+    # thinking off) and the chat loop sent the request without them: said
+    # once per session and host, standing in for the not-honoured notice.
+    def thinking_refused(event)
+      _level, target = @turn_thinking
+      return unless target
+
+      Log.warn(:model, "thinking_refused", level: event[:level], host: target.entry.name, model: event[:model],
+                                           detail: event[:detail])
+      (@thinking_notices ||= Set.new) << [@session&.id, target.entry.name, :not_honoured]
+      thinking_notice_once(:refused, target, :warn,
+                           "#{target.entry.name} refused thinking: #{event[:level]} for #{event[:model]} (#{event[:detail]}); " \
+                           "sent without it, so thinking stays as the model has it")
+    rescue StandardError
+      nil
+    end
+
+    def thinking_notice_once(kind, target, level, text)
+      key = [@session&.id, target.entry.name, kind]
+      return unless (@thinking_notices ||= Set.new).add?(key)
+
+      hook_notify(text, level, "thinking")
+    end
+
+    # +target+'s thinking level (Thinking.resolve).
+    def thinking_level(target)
+      Thinking.resolve(target, names: model_lookup_names(target)).first
+    rescue StandardError
+      Thinking::DEFAULT
     end
 
     def vision_adapter(target)
@@ -1987,29 +2277,6 @@ module Samagotchi
       replace_session_messages(@session, clone_messages(checkpoint))
     end
 
-    # Backward-compatible: runs a prompt through the kernel loop without event forwarding.
-    # @param session  [Session]
-    # @param prompt   [String]
-    # @return [String] model response text
-    def process_prompt_through_kernel(session, prompt)
-      result = run_turn(session, prompt)
-      response = result.respond_to?(:text) ? result.text.to_s : result.to_s
-      if response.strip.empty?
-        session.messages << { role: "model", content: "[No response]" }
-        "[No response]"
-      else
-        response
-      end
-    end
-
-    # Public entrypoint for background session workers.
-    # @param session  [Session]
-    # @param prompt   [String]
-    # @return [String] model response
-    def process_background_prompt(session:, prompt:)
-      process_prompt_through_kernel(session, prompt)
-    end
-
     # Clone a messages array (shallow dup of each element).
     # @param messages [Array<Hash>]
     # @return [Array<Hash>]
@@ -2050,6 +2317,12 @@ module Samagotchi
       require_relative "memory_bundle/provenance"
       settings = bundle_settings
       MemoryBundle::Provenance.each_installed_holding_hooks do |bundle_name, data|
+        if data[:error]
+          Log.warn(:hooks, "bundle_manifest_invalid", echo: "[samagotchi:hooks] bundle '#{bundle_name}': #{data[:error]}; its hooks are not loaded",
+                                                      bundle: bundle_name)
+          @guardrail_failures.add("hooks (bundle #{bundle_name})", data[:error], required: false)
+          next
+        end
         bundle_dir = File.join(MemoryBundle::Provenance.bundles_dir, bundle_name)
         hooks_dir = File.join(bundle_dir, "hooks")
         if (data[:trust_level] || "experimental").to_s == "experimental"
@@ -2161,11 +2434,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 +2451,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) : []
@@ -2394,13 +2670,18 @@ module Samagotchi
             event = event.merge(text: delta[:text], thinking: delta[:thinking]) if enrich == :always
           end
         end
+        # The chat loop asked again without the thinking fields: a notice,
+        # not an event of its own.
+        next thinking_refused(event) if event[:type] == :thinking_refused
+
         emit_event(on_event, event)
+        check_thinking_honoured(event) if event[:type] == :generation_completed
       end
     end
 
     def emit_event(on_event, event)
       # Capture used memories synchronously in the turn thread.
-      begin
+      read_names = begin
         capture_used_memory_from_event(event)
       rescue StandardError
         nil
@@ -2419,6 +2700,11 @@ module Samagotchi
       # Persistent subscribers: receive a copy with a locally-monotonic
       # `event_seq`, fan out with per-subscriber error isolation.
       @session_observer.notify(event)
+      # Every memory read, after its tool_call_started: the whole list for
+      # the UIs' memory line, and the names this call read (read_names).
+      return unless read_names
+
+      emit_event(on_event, { type: :used_memories_updated, used_memory_names: used_memory_names, read_names: read_names })
     end
 
     # The window as the target's loop would see it (see ChatLoop#context_window:
@@ -2462,10 +2748,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
@@ -2510,9 +2800,11 @@ module Samagotchi
 
     # Only Qwen has an explicit thinking-close marker, so only Qwen can
     # reliably have this preamble parsed back out of its thinking block.
-    def turn_preamble_instruction
+    # With thinking off there is no thinking to begin with it.
+    def turn_preamble_instruction(thinking = nil)
       return "" unless profile.name == "qwen36"
       return "" if Samagotchi::Config.get("thinking.turn_preamble") == false
+      return "" if (thinking || turn_thinking) == :off
 
       "\nTurn preamble: as the very first line of your thinking, write \"TURN: \" followed by a short present-tense action phrase (max 8 words) describing what you are about to do, e.g. \"TURN: reading project config\". Then continue reasoning normally.\n"
     end
@@ -2521,12 +2813,13 @@ module Samagotchi
 
     # @param chat [Boolean] for the chat loop: no tool declarations, call
     #   syntax or turn preamble (its tools go as schemas with each request)
-    def assist_system_prompt(chat: false)
+    # @param thinking [Symbol, nil] the level (Thinking); nil: the effective model's
+    def assist_system_prompt(chat: false, thinking: nil)
       return chat_system_prompt if chat
 
       declarations = tool_declarations
       hint = tool_call_hint
-      turn_preamble = turn_preamble_instruction
+      turn_preamble = turn_preamble_instruction(thinking)
 
       <<~SYS
         You are Chi (pronounced "chee"), the friendly name for the Samagotchi assistant harness. You have access to the following tools:
@@ -2606,15 +2899,12 @@ module Samagotchi
 
     # @param chat [Boolean] no Gemma thinking token (the chat API's template
     #   decides about thinking)
-    def system_prompt_with_index(base, chat: false)
+    # @param thinking [Symbol, nil] the level (Thinking); nil: the effective model's
+    def system_prompt_with_index(base, chat: false, thinking: nil)
       project_index = read_memory_index("project")
       system_index = read_memory_index("system")
       project_description = project_specific_description
-      thinking_token = if !chat && profile.name == "gemma4" && ENV["THINKING_MODE"] != "false"
-                         "<|think|>\n"
-                       else
-                         ""
-                       end
+      thinking_token = chat ? "" : Thinking.native(thinking || turn_thinking, profile).system_token
       memory_sections = [
         "Project memories:\n#{project_index}",
         "System memories:\n#{system_index}"
@@ -2661,6 +2951,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 +2985,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
@@ -2716,8 +3009,9 @@ module Samagotchi
       @activated_memory_names ||= []
     end
 
-    # System-prompt builders the TerminalUI seeds its conversation from.
-    public :tool_call_hint, :assist_system_prompt, :system_prompt_with_index, :activated_memory_names
+    # The base prompt (specs, plugins' declarations) and the --memory names
+    # the TerminalUI mirrors into its status line.
+    public :assist_system_prompt, :activated_memory_names
 
     def split_memory_scope(raw)
       value = raw.to_s.strip