samagotchi 0.154.0 → 0.154.1

data/lib/samagotchi/engine_snapshots.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "degrade"
 require_relative "session_setting"
 require_relative "token_usage"
 
@@ -171,16 +172,16 @@ module Samagotchi
     # doesn't count. Without a model (EffectiveModel), no probe. A remote
     # chat host has no /props: nil until a turn. The name asked is never
     # resolved (HostRegistry#bare_name), so it holds on a broken resolve.
-    def served_model_for(snapshot, model: nil)
-      asked = bare_model_name(model ? model.name : effective_model_name)
-      return [snapshot[:served_model], asked] if snapshot[:served_model] && snapshot[:served_model_for] == asked
-      return [nil, nil] unless model
-
-      model.served_from_props(asked)
     # Only bare_model_name and the snapshot lookup are left to fail here:
     # the probe's failure is EffectiveModel#served_from_props's.
-    rescue StandardError
-      [nil, nil]
+    def served_model_for(snapshot, model: nil)
+      Degrade.call(:model, "served_model_unreadable", fallback: [nil, nil]) do
+        asked = bare_model_name(model ? model.name : effective_model_name)
+        return [snapshot[:served_model], asked] if snapshot[:served_model] && snapshot[:served_model_for] == asked
+        return [nil, nil] unless model
+
+        model.served_from_props(asked)
+      end
     end
 
     # The next turn's kit prompt text for /stats: its kit and its estimated

data/lib/samagotchi/idle_recap.rb

@@ -473,7 +473,9 @@ module Samagotchi
       parsed = safe_parse(@engine.messages_json_for_recap)
       return :too_short if parsed.nil?
 
-      user_turns = parsed.count { |message| Steer.prompt?(message) }
+      # The turns as the page counts them (Steer.turn_opening?): not Qwen's
+      # recovery line, nor input merged into a running turn.
+      user_turns = parsed.count { |message| Steer.turn_opening?(message) }
       if parsed.empty? || user_turns < @min_user_turns
         drop_stale(parsed)
         return :too_short

data/lib/samagotchi/kernel_loop.rb

@@ -18,8 +18,8 @@ require_relative "cut"
 require_relative "cut_policy"
 require_relative "thinking"
 require_relative "hooks"
-require_relative "pending_input_queue"
 require_relative "steer"
+require_relative "stream_event"
 require_relative "reasoning_history"
 require_relative "thought_stream_splitter"
 require_relative "tools/builtins"
@@ -726,7 +726,8 @@ module Samagotchi
       turn.pending_tool_calls = false
       if turn.qwen_partial && turn.qwen_attempts < QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_LIMIT
         turn.qwen_attempts += 1
-        turn.conversation << { role: "user", content: QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_PROMPT, preserve_literals: true }
+        turn.conversation << { role: "user", kind: Steer::RECOVERY_KIND, content: QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_PROMPT,
+                               preserve_literals: true }
         return :next
       end
 
@@ -834,7 +835,7 @@ module Samagotchi
 
     # A failing stream callback (a UI gone) must not break the turn.
     def emit_stream_event(callback, event)
-      Degrade.call(:turn, "stream_event_callback_failed", type: (event[:type] if event.is_a?(Hash))) { callback&.call(event) }
+      StreamEvent.emit(callback, event, failure: "stream_event_callback_failed")
     end
 
     # ── Hook dispatch helper ───────────────────────────────────────────────────

data/lib/samagotchi/llm/chat_loop.rb

@@ -432,7 +432,8 @@ module Samagotchi
       # Array), plus a model turn's tool_calls and thinking (the host's
       # reasoning, sent back as #wire_messages says), a result's tool_call_id, the image
       # refs of a user message or a tool result, a prompt's turn_id and its
-      # Verify/Revise anchors (Engine, never sent) and a wake turn's report's turn_start (Steer, never sent), and a plugin tool result's tool_params and tool_labels
+      # Verify/Revise anchors (Engine, never sent), an opening's opening_id
+      # (TurnFlow#abort_continue!'s reason line, never sent) and a wake turn's report's turn_start (Steer, never sent), and a plugin tool result's tool_params and tool_labels
       # (the live row's params line and label, never sent back), an
       # edit/write result's tool_diffs (never sent), an empty-answer
       # note's marker (TurnNote.empty, never sent), and an answer's display
@@ -448,6 +449,7 @@ module Samagotchi
           message[:tool_call_id] = entry[:tool_call_id] if entry[:tool_call_id]
           message[:images] = entry[:images] if entry[:images].is_a?(Array) && !entry[:images].empty?
           message[:turn_id] = entry[:turn_id] if entry[:turn_id]
+          message[:opening_id] = entry[:opening_id] if entry[:opening_id].is_a?(String)
           message[:turn_start] = true if entry[:turn_start] == true
           message[:verify] = entry[:verify] if entry[:verify].is_a?(Hash)
           message[:revises] = entry[:revises] if entry[:revises].is_a?(Hash)

data/lib/samagotchi/session_manager.rb

@@ -33,6 +33,7 @@ require_relative "worker_idle_exit"
 require_relative "worker_signals"
 require_relative "chi_invocation"
 require_relative "log"
+require_relative "degrade"
 require_relative "log_path"
 require_relative "paths"
 require_relative "project_env"
@@ -282,7 +283,7 @@ module Samagotchi
       child_env[ModelProfile::MODEL_FROM_CLI_ENV] = "1" if child_env.key?(ModelProfile::MODEL_ENV)
       # And the spawner's debug log, absolute: a relative log.file would
       # otherwise land in the worker's (the session's) directory.
-      log_path = begin LogPath.resolve rescue nil end
+      log_path = begin LogPath.resolve rescue nil end # degrade-ok: no log to say it in; the worker's is off (below)
       if log_path
         child_env["SAMAGOTCHI_LOG_FILE"] = log_path
       else
@@ -936,9 +937,7 @@ module Samagotchi
     # session.keep_empty off: sessions left with nothing in them are deleted
     # (the worker as it exits, the retention sweep).
     def self.discard_empty?
-      Samagotchi::Config.get("session.keep_empty") != true
-    rescue StandardError
-      false
+      Degrade.call(:config, "keep_empty_unreadable", fallback: false) { Samagotchi::Config.get("session.keep_empty") != true }
     end
 
     # Whether a session being left (or found left) is deleted: session.keep_empty
@@ -977,9 +976,9 @@ module Samagotchi
       return true if one.to_s == other.to_s
       return false if one.nil? || other.nil?
 
-      ConfigFile.model_ref(one).ref == ConfigFile.model_ref(other).ref
-    rescue StandardError
-      false
+      Degrade.call(:config, "model_ref_unresolved", fallback: false) do
+        ConfigFile.model_ref(one).ref == ConfigFile.model_ref(other).ref
+      end
     end
 
     # Only the system prompt (an Engine seeds one, a saved session keeps
@@ -1281,9 +1280,7 @@ module Samagotchi
     end
 
     def self.config_idle_exit_minutes
-      Samagotchi::Config.get("session.idle_exit_minutes")
-    rescue StandardError
-      nil
+      Degrade.call(:config, "idle_exit_minutes_unreadable") { Samagotchi::Config.get("session.idle_exit_minutes") }
     end
 
     private_class_method def self.setup_session_directory(session_dir, session, state_dir:)
@@ -1640,9 +1637,7 @@ module Samagotchi
     end
 
     private_class_method def self.delivery_owner(manager, session_id, state_dir)
-      manager.session_owner(session_id, state_dir: state_dir)
-    rescue StandardError
-      nil
+      Degrade.call(:worker, "owner_unreadable", sid: session_id) { manager.session_owner(session_id, state_dir: state_dir) }
     end
 
     def self.stopped_on_disk?(session_id, state_dir:)

data/lib/samagotchi/session_retention.rb

@@ -18,7 +18,7 @@ module Samagotchi
   # (session.retention_days), count (session.max_count, counting only the
   # sessions that stay), statuses kept (session.keep_status), sessions left
   # empty (SessionManager.discardable?, an hour on), leftover scratch
-  # sessions and skeleton-only directories; a session with a live owner
+  # sessions (once past SCRATCH_START_GRACE) and skeleton-only directories; a session with a live owner
   # always stays.
   module SessionRetention
     # The session.retention_days / max_count / keep_status defaults.
@@ -93,6 +93,16 @@ module Samagotchi
       end
     end
 
+    # How long after its save an unowned scratch session may still be
+    # waiting for the worker just spawned for it to take its owner lock.
+    SCRATCH_START_GRACE = SessionManager::WORKER_START_GRACE
+
+    private_class_method def self.scratch_starting?(path, now)
+      now - File.mtime(path) < SCRATCH_START_GRACE
+    rescue SystemCallError
+      false
+    end
+
     # Lazy sweep guard: runs prune at most once per SWEEP_INTERVAL_HOURS
     # (session.sweep_interval_hours).
     MARKER = ".last_retention"
@@ -162,7 +172,9 @@ module Samagotchi
     # count (`chi sessions clean` with no --days: test runs are throwaway).
     #
     # A scratch session nobody owns (its terminal and worker were killed) goes whatever its
-    # age, its status and the count; +test_only+ takes it too.
+    # age, its status and the count; +test_only+ takes it too. One saved
+    # within SCRATCH_START_GRACE (its file's mtime, against +now+) stays: its
+    # worker may not have taken the owner lock yet.
     #
     # +max_count+ counts the sessions that stay: one deleted whatever its
     # place (scratch, left empty, expired, +any_age+) takes no slot.
@@ -173,7 +185,7 @@ module Samagotchi
     # @return [Hash] { deleted: [ids], kept: [ids], skipped: [ids] }
     def self.apply(state_dir: Session.default_state_dir, days: DEFAULT_RETENTION_DAYS, max_count: DEFAULT_MAX_COUNT,
                    keep_status: DEFAULT_KEEP_STATUS, dry_run: false, test_only: false, alive_check: nil,
-                   empty_check: nil, any_age: false)
+                   empty_check: nil, any_age: false, now: Time.now)
       keep_status = Array(keep_status).map(&:to_s)
       # Fetch all sessions sorted newest-first for count logic
       all = Session.list(state_dir: state_dir, sort: "updated_at", order: "desc")
@@ -182,7 +194,6 @@ module Samagotchi
         all = all.select { |session| session.test_run || session.scratch }
       end
 
-      now = Time.now
       cutoff = days.to_i.positive? ? now - (days.to_i * 86_400) : nil
       max = max_count.to_i
 
@@ -217,6 +228,15 @@ module Samagotchi
           end
         end
 
+        # A scratch session saved within SCRATCH_START_GRACE: `chi scratch`
+        # saves it, then spawns the worker that takes its owner lock, so no
+        # owner yet doesn't mean a leftover. Kept, it takes no count slot.
+        if session.scratch && scratch_starting?(path, now)
+          kept << session.id
+          passed_over += 1
+          next
+        end
+
         left_empty = begin
           empty_check&.call(session.id)
         rescue StandardError

data/lib/samagotchi/steer.rb

@@ -28,6 +28,12 @@ module Samagotchi
   module Steer
     KIND = "steer"
     INPUT_KIND = "input"
+    # KernelLoop's line asking a Qwen model to finish the tool call it left
+    # open: a user line inside the running turn, the model's alone. No turn
+    # opens with it (#turn_prompt?), and the page draws nothing for it, as it
+    # showed nothing live. Its kind adds no header (#header): its bytes go
+    # out as before it had one.
+    RECOVERY_KIND = "recovery"
 
     # A drain item for an input line with its sender (source nil = the user).
     # A plain String is still a valid item: the user's line. +mark+: fields
@@ -317,6 +323,11 @@ module Samagotchi
       message.is_a?(Hash) && (message[:role] || message["role"]).to_s == "user" && !steer?(message)
     end
 
+    # KernelLoop's recovery line (RECOVERY_KIND).
+    def recovery?(message)
+      message.is_a?(Hash) && (message[:kind] || message["kind"]).to_s == RECOVERY_KIND
+    end
+
     # The user's lines merged into a running turn (Merge#messages).
     def input?(message)
       message.is_a?(Hash) && (message[:kind] || message["kind"]).to_s == INPUT_KIND
@@ -333,7 +344,7 @@ module Samagotchi
       start = (message[:turn_start] || message["turn_start"]) == true
       return start if (message[:role] || message["role"]).to_s == "system"
 
-      prompt?(message) && (!input?(message) || start)
+      prompt?(message) && !recovery?(message) && (!input?(message) || start)
     end
 
     # A stored `!shell` line: "!(cmd)\n<output>", no turn id. A user message,

data/lib/samagotchi/stream_event.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "degrade"
+
+module Samagotchi
+  # The one rule for handing a loop event to its on_stream_event callback
+  # (KernelLoop#emit_stream_event, ToolRunner#emit): no callback is fine, and
+  # a failing one (a UI gone) must not break the turn or the tool call. Its
+  # failure is a Degrade record under :turn, named by the caller (+failure+,
+  # so a log still says which side lost the event), with the event's type.
+  module StreamEvent
+    module_function
+
+    # @param callback [#call, nil] the loop's on_stream_event
+    # @param event [Hash] the event
+    # @param failure [String] the Degrade event slug when +callback+ raises
+    # @return the callback's value, nil when it raised or there is none
+    def emit(callback, event, failure:)
+      Degrade.call(:turn, failure, type: (event[:type] if event.is_a?(Hash))) { callback&.call(event) }
+    end
+  end
+end

data/lib/samagotchi/system_prompt.rb

@@ -77,6 +77,10 @@ module Samagotchi
       # a new process. The files' text is read at each build.
       @config_appended = Degrade.call(:prompt, "appended_list_unreadable", fallback: []) { ConfigFile.appended_prompt_files }
       @cli_appended = Array(appended_files).map { |path| File.expand_path(path.to_s) }
+      # { [chat, thinking, layers] => Built }, swapped for a new one by #reset!
+      @cache = {}
+      # The Built #build returned last; nil before a build and after #reset!.
+      @last = nil
     end
 
     # @return [Array<String>] the names the session preloads, known before
@@ -85,37 +89,35 @@ module Samagotchi
       @requested_memories.map { |raw| split_memory_scope(raw).last }.uniq
     end
 
+    # A prompt #build made, with what it read while it did: the memory
+    # index sizes (#memory_index), the model notes, the files and the
+    # plugins' sections it holds, and its stable part's length (chat).
+    Built = Data.define(:prompt, :memory_index, :notes, :files, :sections, :stable_length)
+
     # The full prompt: #base wrapped with the index and the rest. Built once
     # per loop and level (until #reset!) so the prompt prefix, and the
     # server's KV cache for it, stay stable.
+    #
+    # #reset! runs on other threads (a plugin's tools_changed! /
+    # prompt_changed!, a /stats re-resolving the profile) and, through the
+    # profile lookup, inside a build on this one. So a build reads @cache
+    # once and computes into locals: a reset meanwhile swaps in a new cache
+    # and this build's result goes into the dropped one, so it is returned
+    # (the same bytes as without the reset) but not kept, and the next
+    # build reads the sources again. No lock: the build reads memory files
+    # and calls the lookups, one of which takes ModelBinding's mutex, whose
+    # holder (a /stats thread) may itself call #reset!.
     # @param chat [Boolean] for the chat loop
     # @param thinking [Symbol, nil] the level (Thinking); nil: the effective model's
     # @param layers [Array<Symbol>] the turn's LLM context layers: the
     #   native prompt declares the tools they add (Tools::Registry#entries)
     def build(chat: false, thinking: nil, layers: [])
       key = [chat, thinking, layers]
-      @built ||= {}
-      @index_sizes ||= {}
-      @notes_loaded ||= {}
-      @files_loaded ||= {}
-      @sections_loaded ||= {}
-      unless @built.key?(key)
-        @section_notes = nil
-        @section_files = []
-        @section_plugins = []
-        @built[key] = system_prompt_with_index(
-          assist_system_prompt(chat: chat, layers: layers), chat: chat, thinking: thinking, layers: layers
-        )
-        @index_sizes[key] = @measured_index
-        @notes_loaded[key] = @section_notes || []
-        @files_loaded[key] = @section_files.freeze
-        @sections_loaded[key] = @section_plugins.freeze
-      end
-      @memory_index = @index_sizes[key]
-      @prompt_notes = @notes_loaded[key]
-      @prompt_files = @files_loaded[key]
-      @prompt_sections = @sections_loaded[key]
-      @built[key]
+      cache = @cache
+      built = cache[key] || (cache[key] = build_prompt(chat: chat, thinking: thinking, layers: layers))
+      @memory_index = built.memory_index
+      @last = built
+      built.prompt
     end
 
     # The memory indexes the prompt #build returned last holds, per scope
@@ -130,7 +132,7 @@ module Samagotchi
     # (Array<ModelNotes::Note>, [] with none), nil before a build and after
     # #reset!. Read when the prompt is built, as the section is.
     # @return [Array<ModelNotes::Note>, nil]
-    attr_reader :prompt_notes
+    def prompt_notes = @last&.notes
 
     # The files whose text the prompt #build returned last holds, as
     # absolute paths in prompt order: the AGENTS.md chain, then the
@@ -138,26 +140,21 @@ module Samagotchi
     # build and after #reset!. Read when the prompt is built, as the
     # sections are.
     # @return [Array<String>]
-    def prompt_files = @prompt_files || []
+    def prompt_files = @last&.files || []
 
     # The plugins' prompt sections the prompt #build returned last holds
     # (Plugin::PromptSections::Built, prompt order), [] before a build and
     # after #reset!.
     # @return [Array<Plugin::PromptSections::Built>]
-    def prompt_sections = @prompt_sections || []
+    def prompt_sections = @last&.sections || []
 
     # Drops the built prompts: the next #build reads the profile, tools,
     # indexes and memories again (a model or profile switch, changed tools).
     def reset!
-      @built = nil
-      @index_sizes = nil
-      @notes_loaded = nil
-      @prompt_notes = nil
-      @files_loaded = nil
-      @prompt_files = nil
-      @sections_loaded = nil
-      @prompt_sections = nil
-      @stable_lengths = nil
+      # Single assignments: a build in flight keeps the cache it read
+      # (#build), so it neither fails nor is kept.
+      @cache = {}
+      @last = nil
     end
 
     # The length of +prompt+'s stable part when it is a chat prompt #build
@@ -165,7 +162,12 @@ module Samagotchi
     # a remote prompt cache can keep for every session (PromptCache). nil
     # for any other text, or a prompt without those lines.
     # @return [Integer, nil]
-    def stable_length(prompt) = @stable_lengths&.[](prompt)
+    def stable_length(prompt)
+      last = @last
+      return last.stable_length if last&.prompt == prompt
+
+      @cache.each_value.find { |built| built.prompt == prompt }&.stable_length
+    end
 
     # The base prompt (specs, plugins' declarations), with Gemma's tool
     # declarations at its end as #build has them.
@@ -182,6 +184,20 @@ module Samagotchi
 
     private
 
+    # One #build's work: the prompt and what it read, in a Built. The
+    # @section_* and @measured_* scratch is this build's (the turn thread's)
+    # alone: #reset! never touches it.
+    def build_prompt(chat:, thinking:, layers:)
+      @section_notes = nil
+      @section_files = []
+      @section_plugins = []
+      @measured_stable_length = nil
+      prompt = system_prompt_with_index(assist_system_prompt(chat: chat, layers: layers),
+                                        chat: chat, thinking: thinking, layers: layers)
+      Built.new(prompt: prompt, memory_index: @measured_index, notes: @section_notes || [],
+                files: @section_files.freeze, sections: @section_plugins.freeze, stable_length: @measured_stable_length)
+    end
+
     def profile = @profile_lookup.call
 
     def turn_thinking = @thinking_lookup.call
@@ -331,7 +347,7 @@ module Samagotchi
       return with_tail_declarations(stable_text, chat: chat, layers: layers) if volatile.empty?
 
       prompt = "#{stable_text}\n#{volatile.join("\n")}"
-      (@stable_lengths ||= {})[prompt] = stable_text.length + 1 if chat
+      @measured_stable_length = stable_text.length + 1 if chat
       with_tail_declarations(prompt, chat: chat, layers: layers)
     end
 

data/lib/samagotchi/terminal_ui/attached_view.rb

@@ -60,15 +60,6 @@ module Samagotchi
         @screen.commit(text)
       end
 
-      # Draw on +surface+ from now on (no caller since the REPL went): what the slot shows
-      # moves there.
-      def surface=(surface)
-        @lock.synchronize do
-          @screen = surface
-          redraw_status if status_text
-        end
-      end
-
       # A new turn: its tally starts over too.
       def reset_turn_feedback
         @lock.synchronize do

data/lib/samagotchi/terminal_ui/input_support.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "reline"
 
 require_relative "../config"
+require_relative "../degrade"
 require_relative "../memory_paths"
 require_relative "../prompt_history"
 require_relative "../tools/memory"
@@ -90,20 +91,18 @@ module Samagotchi
         fragment = slash_fragment.to_s.strip
         return [] unless fragment.start_with?("/")
 
-        begin
+        # Only at the line's start: "/x" mid-line is a path, not a command.
+        Degrade.call(:attached, "completion_line_unreadable") do
           buf = Reline.line_buffer.to_s
-          if !buf.empty? && !buf.lstrip.start_with?("/")
-            return []
-          end
-        rescue StandardError
-          nil
+          return [] if !buf.empty? && !buf.lstrip.start_with?("/")
         end
 
         lowered = fragment.downcase
         return slash_commands.dup if lowered == "/"
 
         slash_commands.select { |cmd| cmd.start_with?(lowered) }
-      rescue StandardError
+      rescue StandardError => e
+        Degrade.note(:attached, "slash_completion_failed", e)
         []
       end
 
@@ -134,7 +133,8 @@ module Samagotchi
           relative_path = "#{relative_path}/" if File.directory?(absolute_path)
           "#{AT_PATH_COMPLETION_PREFIX}#{relative_path}"
         end
-      rescue StandardError
+      rescue StandardError => e
+        Degrade.note(:attached, "path_completion_failed", e)
         []
       end
 
@@ -190,7 +190,8 @@ module Samagotchi
             yield scope, name
           end
         end
-      rescue StandardError
+      rescue StandardError => e
+        Degrade.note(:attached, "memory_completion_failed", e)
         []
       end
 
@@ -207,8 +208,8 @@ module Samagotchi
         @history_signature = PromptHistory.signature
         @history_seen = PromptHistory.entries
         @history_seen.last(PromptHistory::LIMIT).each { |entry| Reline::HISTORY << entry }
-      rescue StandardError
-        nil
+      rescue StandardError => e
+        Degrade.note(:attached, "history_load_failed", e)
       end
 
       # A scratch session keeps nothing, its typed lines neither.
@@ -223,8 +224,8 @@ module Samagotchi
           history_lock.synchronize { forget_own_line(own) } if own
           raise
         end
-      rescue StandardError
-        nil
+      rescue StandardError => e
+        Degrade.note(:attached, "history_append_failed", e)
       end
 
       # Before a main-prompt read, and on the first ↑ of a walk at an open
@@ -255,8 +256,8 @@ module Samagotchi
           @history_signature = signature
           @history_seen = entries
           history_lock.synchronize { add_others_lines(fresh) }
-        rescue StandardError
-          nil
+        rescue StandardError => e
+          Degrade.note(:attached, "history_pickup_failed", e)
         end
       end
 

data/lib/samagotchi/terminal_ui/join_replay.rb

@@ -77,8 +77,11 @@ module Samagotchi
         Log.session_id = @link.client.session_id
         Log.info(:attached, "joined", session: @link.client.session_id, messages: exchange.size,
                                       notes: messages.count { |m| ContextNote.note?(m) })
-        last_user = exchange.rindex { |m| Steer.prompt?(m) }
-        render_join_notes(messages)
+        # The last turn's own prompt (Steer.turn_prompt?, as the page's
+        # turns): not Qwen's recovery line, nor input merged into the turn.
+        last_user = exchange.rindex { |m| Steer.turn_prompt?(m) }
+        from = last_user && messages.index { |m| m.equal?(exchange[last_user]) }
+        render_join_notes(messages, from)
         return unless last_user
 
         @screen.commit(join_prompt_line(exchange[last_user]))
@@ -86,7 +89,6 @@ module Samagotchi
         unless ImageRef.placeholder_only?(exchange[last_user][:content])
           Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         end
-        from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
         record = @link.saved_turn_record(exchange[last_user][:turn_id] || exchange[last_user]["turn_id"])
         failed = join_failed_record(record)
@@ -114,19 +116,21 @@ module Samagotchi
                                              .find { |text| !text.empty? }
           @screen.commit(last_lines(answer)) if answer
         end
-        render_join_notes(messages, after_exchange: true)
+        render_join_notes(messages, from, after_exchange: true)
       end
 
       # What the last exchange did, as the live turn drew it: each saved
       # call's tool row (action, params, status from its result, and its
       # duration from +durations+, the turn's saved tool records) and a
-      # plugin's steer where it came. The step texts stay out, as live (the
-      # ticker's).
+      # plugin's steer and the user's input merged into the turn where they
+      # came. The step texts stay out, as live (the ticker's).
       def render_join_steps(messages, from, durations: [])
         records = durations.dup
         messages.each_with_index.drop(from + 1).each do |m, i|
           if Steer.steer?(m)
             @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
+          elsif Steer.input?(m) && !Steer.turn_prompt?(m)
+            @screen.commit("input> #{m[:content]}")
           elsif %w[model assistant].include?(m[:role].to_s)
             responses = messages.drop(i + 1).take_while { |r| r[:role].to_s == "tool_response" }
             Array(MessageParts.for_message(m, responses)&.dig(:tools)).each do |part|
@@ -209,13 +213,13 @@ module Samagotchi
         format_tool_guardrail_suffix({ decided_by: "system one", p: saved["p"] || saved[:p] })
       end
 
-      # The context notes that came since the last prompt (all of them in a
-      # session with none), after the exchange the header shows.
-      def render_join_notes(messages, after_exchange: false)
-        last_user = messages.rindex { |m| Steer.prompt?(m) }
-        return if after_exchange != !last_user.nil?
+      # The context notes that came since the last prompt (+from+, its index
+      # in +messages+; all of them in a session with none), after the
+      # exchange the header shows.
+      def render_join_notes(messages, from, after_exchange: false)
+        return if after_exchange != !from.nil?
 
-        messages[(last_user ? last_user + 1 : 0)..].select { |m| ContextNote.note?(m) }.each do |m|
+        messages[(from ? from + 1 : 0)..].select { |m| ContextNote.note?(m) }.each do |m|
           @screen.commit(context_note_line(ContextNote.label_of(m), ContextNote.text_of(m)))
         end
       end

data/lib/samagotchi/terminal_ui/reline_seam.rb

@@ -44,11 +44,6 @@ module Samagotchi
         # @return [#call, nil]
         attr_accessor :interrupt_handler
 
-        # Called with no arguments for each key a read takes (typing is
-        # activity for an idle clock; nobody sets it now).
-        # @return [#call, nil]
-        attr_accessor :key_handler
-
         # @return [Boolean] a Reline read is open (it owns stdin)
         def reading? = @reading == true
 
@@ -150,11 +145,6 @@ module Samagotchi
         @rendered_screen.base_y = 0 if RelineSeam.screen
       end
 
-      def update(key)
-        RelineSeam.key_handler&.call
-        super
-      end
-
       def screen_height
         screen = RelineSeam.screen
         screen ? [super, screen.editor_budget].min : super

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -54,13 +54,6 @@ module Samagotchi
         @shown = nil
       end
 
-      # The surface it draws on (no caller since the REPL went): the row
-      # is drawn there at the next change.
-      def surface=(surface)
-        @surface = surface
-        @shown = nil
-      end
-
       def [](field) = @values[field]
 
       # Change some fields; the row is redrawn when its text changed.

data/lib/samagotchi/tool_runner.rb

@@ -7,6 +7,7 @@ require_relative "file_ref"
 require_relative "guardrails"
 require_relative "vision_context"
 require_relative "degrade"
+require_relative "stream_event"
 require_relative "log"
 require_relative "edit_preview"
 require_relative "tool_output_cut"
@@ -562,7 +563,7 @@ module Samagotchi
 
     # A failing stream callback (a UI gone) must not break the call either.
     def emit(callback, event)
-      Degrade.call(:turn, "tool_event_callback_failed", type: (event[:type] if event.is_a?(Hash))) { callback&.call(event) }
+      StreamEvent.emit(callback, event, failure: "tool_event_callback_failed")
     end
   end
 end