samagotchi 0.3.0 → 0.5.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -4,6 +4,7 @@ require "set"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "attached_view"
+require_relative "status_row"
 require_relative "input_support"
 require_relative "image_input"
 require_relative "line_reader"
@@ -31,19 +32,9 @@ module Samagotchi
       include Formatting
       include InputSupport
 
-      STATS_COMMAND = "/stats"
-      RECAP_COMMAND = "/recap"
       PROMPT = "> "
-      # Detach and leave the worker up.
-      DETACH_COMMANDS = %w[/detach].freeze
-      # Detach and ask the worker to exit (bare `exit` too, as in the REPL).
-      EXIT_COMMANDS = %w[/exit /quit].freeze
-      # After an exit command: delete the session once the worker has gone.
-      DELETE_FLAG = "--delete"
       # How long /exit --delete waits for the worker to let go.
       DELETE_WAIT = 10
-      # Leave, and archive the session (hidden from the lists, kept for good).
-      ARCHIVE_COMMAND = "/archive"
       # A second Ctrl-C at an empty idle prompt within this many seconds detaches.
       DETACH_WINDOW = 2.0
       DETACH_HINT = "Ctrl-D to detach, /exit stops the worker"
@@ -55,7 +46,6 @@ module Samagotchi
         "continue_offered" => "a continue offer is pending", "client_connected" => "another UI is attached",
         "reminders" => "reminders are set", "starting" => "the worker is still starting"
       }.freeze
-      ROLLBACK_HINT = "partial progress kept in context; !rollback restores the pre-turn state"
       # How much of the last answer a join shows.
       JOIN_ANSWER_LINES = 12
       JOIN_ANSWER_CHARS = 1200
@@ -67,7 +57,8 @@ module Samagotchi
 
       # @return [String, nil] the model the worker's turns run on, as the
       #   last command said
-      attr_reader :model_name
+      # @return [String, nil] the worker's model
+      def model_name = @status[:model]
 
       # @return [QuestionPrompt, nil] the question waiting for an answer
       attr_reader :question
@@ -87,8 +78,12 @@ module Samagotchi
       # @param delete_session [#call] session id -> deletes it (/exit --delete)
       # @param archive_session [#call] session id -> archives it (/archive);
       #   SessionManager.archive_session's result
+      # @param wait_at_eof [Boolean] lines come from a pipe or a file (`chi -p
+      #   X </dev/null`): at their end, detach only once this run's prompts
+      #   (the -p one too) have had their turns; if one failed, #run says so
       def initialize(client:, screen:, client_id:, first_prompt: nil, first_command: nil, no_interrupt: false,
-                     default_input: false, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
+                     default_input: false, wait_at_eof: false,
+                     clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                      delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) },
                      archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) })
         @client = client
@@ -116,20 +111,18 @@ module Samagotchi
         # Prompts this run sent, by enqueued_id: only those come back into
         # the input when their turn fails (a replayed event must not).
         @sent_ids = Set.new
+        @wait_at_eof = wait_at_eof
+        # Sent and not ended yet (by enqueued_id), the ones merged into the
+        # running turn, whether the input has ended, and whether one of this
+        # run's prompts failed (wait_at_eof only).
+        @open_ids = Set.new
+        @merged_ids = Set.new
+        @input_ended = false
+        @own_failed = false
         # A continue offer is pending: the prompt asks for the answer.
         @continue_offer = nil
-        @model_name = nil
-        @turn_continues = false
-        # The idle status line's data (the REPL's segments).
-        @memory_names = []
-        # The session's --memory list (shown with the used memories until the
-        # first turn records them) and its --mute list, from the join.
-        @preloaded_names = []
-        @muted_names = []
-        # The session that delegated this one, shown as ↳ <short id>.
-        @parent_id = nil
-        @context_estimate = nil
-        @status_rows = nil
+        # The status row: the worker's model, ctx, the session's memories.
+        @status = StatusRow.new(screen)
       end
 
       def running? = @running
@@ -137,8 +130,10 @@ module Samagotchi
       # Follow the session and read input until Ctrl-D, /detach, /exit or
       # the worker goes away. The worker keeps running after a detach; /exit
       # asks it to exit too, and it does unless something still needs it.
-      # @return [Symbol] :detached, :closed when the worker went away, or
-      #   :failed when the first command (--model) didn't go through
+      # @return [Symbol] :detached, :closed when the worker went away,
+      #   :failed when the first command (--model) didn't go through, or
+      #   (wait_at_eof) :turn_failed when one of this run's prompts failed and
+      #   :unanswered when a question came after the input ended
       # @param input [#call, nil] prompt -> line (nil = Ctrl-D, raising
       #   Interrupt = Ctrl-C); defaults to Reline
       def run(input: nil)
@@ -158,8 +153,17 @@ module Samagotchi
           case kind
           when :event
             ended = safely_handle(payload)
-            return ended if ended == :closed || ended == :failed
-          when :line then return :detached if submit(payload) == :detach
+            return ended if %i[closed failed unanswered].include?(ended)
+            return end_of_input if @input_ended && !own_turns_pending?
+          when :line
+            if payload.nil? && @wait_at_eof && own_turns_pending?
+              # The pipe's end: this run's turns first. An open question
+              # has nothing left to answer it.
+              return unanswered_question if @question
+
+              next @input_ended = true
+            end
+            return end_of_input if submit(payload) == :detach
           when :interrupt then return :detached if interrupt(payload) == :detach
           end
         end
@@ -186,22 +190,19 @@ module Samagotchi
           return render_snapshot(event[:snapshot] || {}, reset: event[:type] == :reset)
         when :turn_enqueued then show_enqueued(event)
         when :turn_started then start_turn(event)
-        when :turn_completed then complete_turn(event)
-        when :turn_canceled
-          continued = @turn_continues
-          end_turn("turn cancelled (#{event[:cancellation_reason]})")
-          # A cancelled continue is back where it started; a prompt turn's
-          # partial progress stays, as in the REPL.
-          @screen.commit(ROLLBACK_HINT) unless continued
-        when :turn_failed
-          end_turn("turn failed: #{event[:summary] || "#{event[:message]} (#{event[:error_class]})"}")
+        when :turn_completed
+          complete_turn(event)
+          own_turn_ended(event)
+        # The renderer says how it ended (the REPL's words too).
+        when :turn_canceled, :turn_failed
+          @renderer.call(event)
+          end_turn
+          own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
         when :context_status
-          @context_estimate = { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] }
-          refresh_status
+          @status.update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
         when :used_memories_updated
-          @memory_names = Array(event[:used_memory_names])
-          refresh_status
+          @status.update(used_memories: Array(event[:used_memory_names]))
         # Another client's anytime command: its line now, before the cards
         # it shows (its command_ran comes when it's done).
         when :command_queued
@@ -217,8 +218,12 @@ module Samagotchi
         when :continue_resolved then continue_resolved(event)
         # The note comes with the kernel's :pending_input_merged (EventRenderer),
         # after the answer the merge follows.
-        when :input_merged then nil
-        when :question_requested then ask(event[:pending_question])
+        when :input_merged then merged_own_prompts(event)
+        when :question_requested
+          # Nothing is left to answer it with.
+          return unanswered_question if @input_ended
+
+          ask(event[:pending_question])
         when :question_answered then question_answered(event)
         when :question_cancelled
           close_question("(question cancelled)") if @question
@@ -269,23 +274,26 @@ module Samagotchi
 
         text = line.strip
         return answer_question(text) if @question
-        # Before the continue offer: neither is an answer to it.
-        return submit(nil) if DETACH_COMMANDS.include?(text.downcase)
-        return exit_worker if exit_command?(text)
-        return exit_and_delete if exit_command?(text.delete_suffix(DELETE_FLAG).rstrip) && text.end_with?(" #{DELETE_FLAG}")
-        return exit_and_archive if text.casecmp?(ARCHIVE_COMMAND)
-        command = text.split(/\s+/, 2).first
+
+        # The terminal's own commands (SessionCommands registers them, the
+        # REPL reads the same words). Before the continue offer: the
+        # leaving ones are no answer to it.
+        local = command_registry.lookup_local(text)&.id
+        return submit(nil) if local == :detach
+        return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
+        return exit_and_archive if local == :archive
+
         if @continue_offer
-          return answer_continue(text) unless command_registry.command?(text) || [STATS_COMMAND, RECAP_COMMAND].include?(command)
+          return answer_continue(text) unless local || command_registry.command?(text)
 
           # Not an answer: the read left no echo, so show what ran.
           echo_answer(text)
         end
         return if text.empty?
 
-        if command == STATS_COMMAND
+        if local == :stats
           show_stats
-        elsif command == RECAP_COMMAND
+        elsif local == :recap
           show_recap
         elsif command_registry.command?(text)
           # The history keeps !cmds, as the REPL's does (prompts: #send_prompt).
@@ -314,8 +322,6 @@ module Samagotchi
         detach(exit_failed_line(e.message))
       end
 
-      def exit_command?(text) = EXIT_COMMANDS.include?(text.downcase) || text.casecmp?("exit")
-
       # /exit --delete: the worker exits as for /exit, then the session is
       # deleted. When the worker stays up (another UI, queued input, ...),
       # nothing is deleted.
@@ -443,9 +449,8 @@ module Samagotchi
         return unless event[:model_name]
 
         # After the output, so the status row changes with the line saying why.
-        @served_model = nil if @model_name != event[:model_name]
-        @model_name = event[:model_name]
-        refresh_status
+        served = @status[:model] == event[:model_name] ? @status[:served] : nil
+        @status.update(model: event[:model_name], default_model: default_model_name, served: served)
       end
 
       # Our command the worker couldn't run yet goes back into the prompt, for
@@ -498,21 +503,22 @@ module Samagotchi
 
       def send_prompt(text)
         persist_recent_history(text)
-        # #memory shorthand becomes words the model reads, as in the REPL.
-        prompt = normalize_model_input(text)
         images = attach_images(text)
-        return if images.nil?
+        return own_prompt_failed if images.nil?
 
-        options = { prompt: prompt, client_id: @client_id }
+        options = { prompt: text, client_id: @client_id }
         options[:no_interrupt] = true if @no_interrupt
         options[:images] = images unless images.empty?
         reply = @client.post_turn(**options)
         if reply.status == 202
           enqueued_id = reply.json&.fetch("enqueued_id", nil)
           @sent_ids << enqueued_id if enqueued_id
+          @open_ids << enqueued_id if enqueued_id && @wait_at_eof
           return
         end
 
+        own_prompt_failed
+
         detail = reply.json&.fetch("error", nil)
         # Read after its deadline and dropped (BridgeClient::DEADLINE_SHARE).
         return @screen.commit("could not send the prompt (#{LATE})") if detail == "deadline_passed"
@@ -520,9 +526,51 @@ module Samagotchi
         explained = reply.json&.fetch("detail", nil) if detail == "images_unsupported"
         @screen.commit("could not send the prompt (#{[reply.status, detail].compact.join(" ")})#{": #{explained}" if explained}")
       rescue SystemCallError, IOError => e
+        own_prompt_failed
         @screen.commit("could not send the prompt (#{worker_down(e)})")
       end
 
+      # Whether the input's end must wait: the -p prompt isn't sent yet, or
+      # a prompt this run sent hasn't had its turn.
+      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty?
+
+      # A turn ended: this run's prompt (and ours merged into it) had its turn.
+      def own_turn_ended(event)
+        return unless @wait_at_eof
+
+        id = (event[:origin] || {})[:enqueued_id]
+        ours = @open_ids.include?(id) || !@merged_ids.empty?
+        @own_failed = true if ours && event[:type] == :turn_failed
+        @open_ids.delete(id)
+        @open_ids.subtract(@merged_ids)
+        @merged_ids.clear
+      end
+
+      # Ours merged into the running turn: they end with it.
+      def merged_own_prompts(event)
+        Array(event[:origins]).each do |origin|
+          id = origin[:enqueued_id]
+          @merged_ids << id if own?(origin[:client_id]) && @open_ids.include?(id)
+        end
+        nil
+      end
+
+      def own_prompt_failed
+        @own_failed = true if @wait_at_eof
+        nil
+      end
+
+      # The input ended and nothing of ours is left to wait for.
+      def end_of_input
+        detach("Detached; the session keeps running. Re-attach with: chi --attach #{@client.session_id}") if @input_ended
+        @own_failed ? :turn_failed : :detached
+      end
+
+      def unanswered_question
+        detach("A question waits for an answer: chi --attach #{@client.session_id}")
+        :unanswered
+      end
+
       # The prompt's `@path` images, stored in the session's images/ here
       # (this machine, the worker's state dir) and sent as refs: the Bridge
       # never takes a path. nil (after a line saying why) when one can't be.
@@ -595,6 +643,13 @@ module Samagotchi
         # What was typed at the prompt waits for the question to close.
         @set_aside = @reader&.typed_text unless @question
         @question = QuestionPrompt.new(pending)
+        # An edit's diff goes above, into the scrollback, once per question
+        # (a join gets it from the snapshot and may get the event too).
+        unless @previewed_id == @question.id
+          @previewed_id = @question.id
+          preview = @question.preview_lines(paint: method(:paint))
+          @screen.commit(preview.join("\n")) unless preview.empty?
+        end
         # The prompt first, so the choices never show under the typed text.
         sync_prompt(keep_text: false)
         @screen.set_slot(:notes, @question.slot(paint: method(:paint)))
@@ -661,11 +716,13 @@ module Samagotchi
       def restore_prompt(event)
         origin = event[:origin] || {}
         return unless own?(origin[:client_id]) && @sent_ids.include?(origin[:enqueued_id])
+        # Lines from a pipe: nobody to retry it (the REPL's rule).
+        return if @wait_at_eof
 
         if @reader&.prefill(event[:prompt].to_s)
-          @screen.commit("(prompt restored for retry)")
+          @screen.commit(turn_end_hint("prompt restored for retry"))
         else
-          @screen.commit("(the failed prompt is in the input history: ↑)")
+          @screen.commit(turn_end_hint("the failed prompt is in the input history (↑)"))
         end
       end
 
@@ -907,8 +964,9 @@ module Samagotchi
         @joined_mid_turn = @running
         return unless turn
 
-        @turn_continues = turn[:prompt].nil?
-        unless @turn_continues && reminder_origin?(turn[:origin] || {})
+        continues = turn[:prompt].nil?
+        @renderer.turn_continues = continues
+        unless continues && reminder_origin?(turn[:origin] || {})
           @screen.commit(prompt_line(turn.dig(:origin, :client_id), turn[:prompt] || "(continuing)"))
         end
         Array(turn[:images]).each { |ref| @screen.commit(format_image_line(ref)) }
@@ -945,9 +1003,8 @@ module Samagotchi
       def start_turn(event)
         @running = true
         @joined_mid_turn = false
-        @turn_continues = event[:prompt].nil?
         origin = event[:origin] || {}
-        if @turn_continues
+        if event[:prompt].nil?
           # A continue turn (after the offer's yes) has no prompt to show; a
           # reminder turn shows its reminders (:reminder_injected).
           @screen.commit(prompt_line(origin[:client_id], "(continuing)")) unless reminder_origin?(origin)
@@ -965,16 +1022,13 @@ module Samagotchi
         end
         @renderer.call(event)
         # The turn's summary carries its last context estimate.
-        @context_estimate = @view.context_status if @view.context_status
-        refresh_status
+        @status.update(context: @view.context_status) if @view.context_status
         @running = false
         @joined_mid_turn = false
         close_question("(the turn ended)") if @question
       end
 
-      def end_turn(message)
-        @view.finish_thinking_spinner
-        @screen.commit(message)
+      def end_turn
         @running = false
         @joined_mid_turn = false
         close_question("(the turn ended)") if @question
@@ -985,43 +1039,22 @@ module Samagotchi
       # The joining snapshot's session state: the worker's model and the
       # memories the session used.
       def take_session_state(state)
-        @model_name = state[:model_name] if state[:model_name]
-        @served_model = nil
-        take_served_model(state[:served_model], state[:served_model_for], refresh: false)
-        @memory_names = Array(state[:used_memory_names]) if state.key?(:used_memory_names)
-        @preloaded_names = Array(state[:preloaded_memory_names]) if state.key?(:preloaded_memory_names)
-        @muted_names = Array(state[:muted_memory_names]) if state.key?(:muted_memory_names)
-        @parent_id = state[:parent_id] if state.key?(:parent_id)
+        fields = { served: nil }
+        fields.merge!(model: state[:model_name], default_model: default_model_name) if state[:model_name]
+        fields[:served] = [state[:served_model], state[:served_model_for]] if state[:served_model]
+        fields[:used_memories] = Array(state[:used_memory_names]) if state.key?(:used_memory_names)
+        fields[:preloaded] = Array(state[:preloaded_memory_names]) if state.key?(:preloaded_memory_names)
+        fields[:muted] = Array(state[:muted_memory_names]) if state.key?(:muted_memory_names)
+        fields[:parent_id] = state[:parent_id] if state.key?(:parent_id)
         # The last turn's ctx, so it shows before this client's first turn.
-        @context_estimate = state[:context_status] if state[:context_status].is_a?(Hash)
-        refresh_status
+        fields[:context] = state[:context_status] if state[:context_status].is_a?(Hash)
+        @status.update(**fields)
       end
 
-      # The REPL's idle status line (model · ctx · memories) in the status
-      # row, redrawn when its text changes.
-      def refresh_status
-        return unless status_line_enabled?
-
-        served, served_for = @served_model
-        segments = [@model_name ? status_model_text(@model_name, default_model_name, served: served, served_for: served_for) : "",
-                    @parent_id ? "↳ #{@parent_id.to_s[0, 8]}" : "",
-                    status_context_text(estimate: @context_estimate),
-                    status_memory_text(@memory_names | @preloaded_names, MEMORY_STICKY_PREVIEW_LIMIT),
-                    status_memory_text(@muted_names, MEMORY_STICKY_PREVIEW_LIMIT, label: "muted")].reject(&:empty?)
-        rows = status_rows(segments, @screen.columns - 1)
-        return if rows == @status_rows
-
-        @status_rows = rows
-        rows.empty? ? @screen.clear_slot(:status) : @screen.set_slot(:status, rows)
-      end
-
-      # What the worker's server said it served for a name (a generation, or
-      # the join's session state); dropped when /model switches.
-      def take_served_model(served, served_for, refresh: true)
-        return unless served
-
-        @served_model = [served, served_for]
-        refresh_status if refresh
+      # What the worker's server said it served for a name (a generation);
+      # dropped when /model switches.
+      def take_served_model(served, served_for)
+        @status.update(served: [served, served_for]) if served
       end
 
       # The config's default model, as the worker's /model names it.
@@ -1063,7 +1096,7 @@ module Samagotchi
         params_suffix = params.empty? ? "" : " #{paint(params, 90)}"
         status = part[:status].to_s
         "#{paint('tool>', 36)} #{part[:tool]}#{params_suffix}: #{paint(status, status_color(status))}" \
-          "#{format_tool_image_suffix(part[:images])}"
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
       end
     end
   end

data/lib/samagotchi/terminal_ui/attached_view.rb

@@ -8,13 +8,12 @@ require_relative "thinking_line"
 
 module Samagotchi
   class TerminalUI
-    # EventRenderer's view in attached mode, drawn on a Screen: the
-    # thinking feedback is the activity slot, one row right above the prompt
-    # (spinner frame, then the running tool or the newest sentence of the
-    # model's thinking or text, ThinkingLine),
-    # and every finished line is committed output. The local REPL's
-    # multi-line spinner redraws in place, which can't share the terminal
-    # with an open prompt.
+    # EventRenderer's view in both TUIs (attached mode and the REPL), drawn
+    # on a Screen: the thinking feedback is the activity slot, one row right
+    # above the prompt (spinner frame, then the running tool or the newest
+    # sentence of the model's thinking or text, ThinkingLine), and every
+    # finished line is committed output. On a PlainSurface the activity
+    # slot is dropped.
     #
     # The spinner turns with time, not per chunk: while the slot is shown a
     # ticker thread redraws it every TICK_INTERVAL, so a turn that gets no
@@ -59,6 +58,16 @@ module Samagotchi
         @screen.commit(text)
       end
 
+      # Draw on +surface+ from now on (the REPL swaps in its live region
+      # after the view is built, and back when it ends): 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
@@ -81,7 +90,7 @@ module Samagotchi
 
       def generation_feedback_retrying(event)
         @lock.synchronize do
-          @retry = "retrying (attempt #{event[:attempt]})"
+          @retry = retry_text(event)
           # The retry streams from the start: wait for its first token again.
           @waiting_since = @clock.call if @thinking
           redraw_status
@@ -194,9 +203,6 @@ module Samagotchi
         @context_status = status if status
       end
 
-      # The REPL's sticky memories line has no source in attached mode.
-      def emit_active_memories_line; end
-
       private
 
       def reset_feedback_state
@@ -207,6 +213,15 @@ module Samagotchi
         @waiting_since = nil
       end
 
+      # "retrying (1/4 in 0.5s): Errno::ECONNREFUSED": the attempt of all
+      # there will be, the wait before it, and what failed.
+      def retry_text(event)
+        return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
+
+        text = "retrying (#{event[:attempt]}/#{event[:max_retries].to_i + 1} in #{format("%.1f", event[:next_delay].to_f)}s)"
+        event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
+      end
+
       def tally_key(event)
         [event[:iteration].to_i, event[:call_index].to_i]
       end
@@ -246,7 +261,7 @@ module Samagotchi
       def status_text
         now = @clock.call
         frame = FRAMES[((now - @origin) / FRAME_INTERVAL).floor % FRAMES.length]
-        return "#{frame} #{@retry}" if @retry
+        return "#{frame} #{paint(@retry, 90)}" if @retry
         return "#{frame} #{@tool}…" if @tool
         return "#{frame} #{@init_tasks.values.join(" · ")}…" if !@thinking && @init_tasks.any?
         return nil unless @thinking

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require "set"
+require_relative "formatting"
 
 module Samagotchi
   class TerminalUI
     # Renders one UI's view of Engine turn events: the thinking spinner while
     # the model generates, a `tool>` line per completed tool call, and the
     # answer (with any tool activity not already shown) from :turn_completed's
-    # turn_summary. It is the `on_event:` sink the REPL hands Engine#run_turn.
+    # turn_summary, and how a turn ended. It is the `on_event:` sink the REPL
+    # hands Engine#run_turn, and renders what attached mode gets over the
+    # Bridge.
     #
-    # Drawing is delegated to a +view+ (the TerminalUI), so the same dispatch
-    # can later render events that arrive over the Bridge. The renderer keeps
+    # Drawing is delegated to a +view+ (an AttachedView in both TUIs). The
+    # renderer keeps
     # only per-turn bookkeeping that must come from the events themselves:
     # which tool lines were already streamed, and when each tool call started.
     # Events that came over the Bridge as JSON (string keys) are symbolized first.
@@ -22,8 +25,14 @@ module Samagotchi
         @tool_started_at = {}
         # Card ids shown so far (across turns): one shown again is updated.
         @card_ids = Set.new
+        @turn_continues = false
       end
 
+      # Whether the running turn continues an earlier one (a continue or a
+      # reminder turn): set from :turn_started, or by a UI that joined the
+      # turn mid-way. A canceled one gets no rollback hint.
+      attr_writer :turn_continues
+
       # Deep-convert a string-keyed event (JSON from the Bridge) to the local
       # shape: symbol keys and a symbol :type. Other values stay as they are.
       def self.symbolize(event)
@@ -45,6 +54,7 @@ module Samagotchi
         case event[:type]
         when :turn_started
           begin_turn
+          @turn_continues = event[:continue] ? true : event[:prompt].nil?
           Array(event[:images]).each { |ref| @view.print_line(@view.format_image_line(ref)) }
         when :generation_started
           @view.generation_feedback_started(event)
@@ -58,7 +68,8 @@ module Samagotchi
         when :tool_call_completed
           @view.clear_generation_retry
           @view.tool_call_feedback_completed(event)
-          render_streamed_tool_activity(event[:activity], duration_ms: tool_duration_ms(event), images: event[:images])
+          render_streamed_tool_activity(event[:activity], duration_ms: tool_duration_ms(event), images: event[:images],
+                                                          diff: event[:diff])
         when :generation_completed, :generation_cancelled, :tool_dispatch_started
           @view.generation_feedback_finished
         when :pending_input_merged
@@ -68,6 +79,15 @@ module Samagotchi
           @view.print_line(@view.format_empty_retry_line(event))
         when :turn_completed
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
+        when :turn_canceled
+          @view.finish_thinking_spinner
+          @view.print_line(@view.turn_canceled_line(event[:cancellation_reason], event[:duration_ms]))
+          @view.print_line(@view.turn_end_hint(Formatting::ROLLBACK_HINT)) unless @turn_continues
+        when :turn_failed
+          # A provider error's one-line summary, else the message (an image
+          # that couldn't be used).
+          @view.finish_thinking_spinner
+          @view.print_line(@view.turn_failed_line(event[:summary] || event[:message], event[:duration_ms]))
         when :guardrail_warning
           @view.print_line(self.class.load_warning_line(event))
         when :hook_notice
@@ -104,7 +124,8 @@ module Samagotchi
       # @param event [Hash] :hook_notice event or a snapshot part with
       #   hook:, text:, level:
       def self.hook_notice_line(event)
-        label = event[:hook].to_s[/\(bundle (.+)\)\z/, 1] || "hook"
+        # chi's own notices name themselves with a bare word (thinking).
+        label = event[:hook].to_s[/\(bundle (.+)\)\z/, 1] || event[:hook].to_s[/\A[a-z][a-z0-9-]*\z/] || "hook"
         text = event[:text].to_s
         text = "warning: #{text}" if event[:level].to_s == "warn"
         "#{label}> #{text}"
@@ -134,7 +155,7 @@ module Samagotchi
       end
 
       # Render a finished turn: tool activity the stream did not already show,
-      # the status lines, the answer, and the iteration-limit notice.
+      # the answer, and the iteration-limit notice.
       # @param summary [Hash] Engine#turn_summary
       def render_turn_summary(summary)
         @view.finish_thinking_spinner
@@ -144,7 +165,6 @@ module Samagotchi
 
           @view.print_line(@view.format_tool_activity_line(activity))
         end
-        @view.emit_active_memories_line
         @view.print_line(summary[:output])
         @view.print_line("iteration limit reached") if summary[:resumable]
       end
@@ -162,12 +182,13 @@ module Samagotchi
 
 private
 
-      def render_streamed_tool_activity(activity, duration_ms:, images: nil)
+      def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil)
         return if activity.nil?
 
         @streamed_tool_activity[tool_activity_key(activity)] += 1
         line = @view.format_tool_activity_line(activity, duration_ms: duration_ms)
         line += @view.format_tool_image_suffix(images) if images&.any?
+        line += @view.format_tool_diff_suffix(diff) if diff
         @view.print_line(line)
       end