samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/update_command.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "desktop"
+require_relative "gem_update"
+require_relative "installed_gem"
+require_relative "live_versions"
+require_relative "memory_bundle/shipped_update"
+require_relative "memory_bundle/system_bundle"
+require_relative "session"
+require_relative "version"
+
+module Samagotchi
+  # `chi update`: brings an installed chi up to date in one go: the system
+  # bundle, the shipped bundles the user installed, and the macOS helper.
+  # Unedited things update; edited ones are kept (.md) or replaced and
+  # reported (hooks, plugin, rules, which didn't load once edited). Live
+  # workers and a running chi web are reported, never restarted. Prints one
+  # table; a second run changes nothing and says so.
+  class UpdateCommand
+    USAGE = <<~TEXT
+      Usage: chi update [--dry-run] [--no-gem] [--no-bundles] [--no-desktop]
+        Updates this chi's install: the gem (from rubygems.org), then the
+        system bundle, the bundles chi ships that you installed (chi bundle
+        list), and the desktop helper (macOS; rebuilt only when its sources
+        changed). Edited memory files are kept and reported; nothing is
+        installed that isn't already, and old gem versions stay.
+        --dry-run      show what would change; change nothing
+        --no-gem       don't install a newer gem (config update.gem: false)
+        --no-bundles   leave the shipped bundles alone (config update.bundles: false)
+        --no-desktop   leave the desktop helper alone (config update.desktop: false)
+        Running sessions keep their chi until they idle out (30 min) or
+        chi sessions stop ID; a running chi web needs a restart.
+    TEXT
+
+    FLAGS = { "--dry-run" => :dry_run, "--no-gem" => :no_gem, "--no-bundles" => :no_bundles, "--no-desktop" => :no_desktop,
+              # Hidden: no pbs/lsregister/open/pkill for a helper under HOME=<tmp>.
+              "--no-register" => :no_register }.freeze
+
+    # A table row. info rows (live workers, chi web) say what runs; they
+    # never fail.
+    Row = Struct.new(:component, :from, :to, :status, :failed, keyword_init: true)
+
+    # What a row says after a change, and in a dry run.
+    VERBS = { update: ["updated", "would update"], install: ["installed", "would install"],
+              restore: ["restored missing files", "would restore missing files"] }.freeze
+
+    # @param gem_spec [Gem::Specification, nil] the installed gem (nil: a checkout)
+    # @param platform [#call] register: → a Desktop::MacOS-like object
+    # @param exec [#call] argv → replaces this process (the new chi's update)
+    # @param bundler [Boolean] running under Bundler (bundle exec)
+    def initialize(argv, stdout: $stdout, stderr: $stderr, gem_spec: InstalledGem.spec,
+                   shipped_dir: MemoryBundle::SourceNormalizer::SHIPPED_DIR, platform: nil,
+                   supported: Desktop.supported?, state_dir: Session.default_state_dir, web: nil,
+                   gem_update: GemUpdate.new, exec: nil, bundler: nil)
+      @gem_update = gem_update
+      @exec = exec || ->(argv) { Kernel.exec(*argv) }
+      @bundler = bundler.nil? ? (defined?(::Bundler) || !ENV["BUNDLE_GEMFILE"].to_s.empty?) : bundler
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @gem_spec = gem_spec
+      @shipped_dir = shipped_dir
+      @platform = platform || ->(register:) { Desktop::MacOS.new(register: register) }
+      @supported = supported
+      @state_dir = state_dir
+      @web = web || [Config.get("web.host").to_s, Config.get("web.port").to_i]
+    end
+
+    # @return [Integer] 0 nothing failed, 1 a part failed (or a checkout), 2 usage
+    def run
+      options = parse or return 2
+      if options[:help]
+        @stdout.puts(USAGE)
+        return 0
+      end
+      unless @gem_spec
+        @stderr.puts("chi update: running from a checkout (#{InstalledGem::ROOT}): chi update updates an installed chi; " \
+                     "git pull, or chi bundle upgrade NAME for one bundle")
+        return 1
+      end
+
+      @dry_run = options[:dry_run]
+      gem = gem_row(options)
+      rows = [gem, system_bundle_row, *bundle_rows(options), desktop_row(options), *live_rows].compact
+      print_table(rows)
+      footers(options).each { |line| @stdout.puts(line) }
+      @stdout.puts(summary(rows))
+      rows.any?(&:failed) ? 1 : 0
+    end
+
+    private
+
+    def parse
+      argv = @argv.dup
+      options = {}
+      while (arg = argv.shift)
+        if %w[-h --help help].include?(arg)
+          options[:help] = true
+        elsif arg == "--gem-from" && argv.first
+          # Hidden: the old version, passed by the chi that installed this one.
+          options[:gem_from] = argv.shift
+        elsif FLAGS.key?(arg)
+          options[FLAGS[arg]] = true
+        else
+          @stderr.puts("chi update: unknown option #{arg}")
+          @stderr.puts(USAGE)
+          return nil
+        end
+      end
+      options
+    end
+
+    # Installs a newer gem and hands over to it (exec: the new code syncs
+    # and prints the table), or says why not. A failed install is a failed
+    # row; the sync then runs on this version.
+    def gem_row(options)
+      row = Row.new(component: "chi (gem)", from: VERSION)
+      if options[:gem_from]
+        row.from = options[:gem_from]
+        row.to = VERSION
+        return done(row, :update)
+      end
+      if (why = off(options, "gem"))
+        return skipped(row, why)
+      end
+      return skipped(row, "under Bundler: bundle update samagotchi") if @bundler
+
+      latest = begin
+        @gem_update.latest
+      rescue GemUpdate::Error => e
+        return row.tap { |r| r.status = "couldn't check (#{e.message})" }
+      end
+      return up_to_date(row) unless @gem_update.newer?(latest)
+
+      row.to = latest.version
+      return done(row, :update) if @dry_run
+
+      @stdout.puts("installing samagotchi #{latest.version}…")
+      output, ok = @gem_update.install(latest)
+      return failed(row, output.lines.map(&:strip).reject(&:empty?).last.to_s) unless ok
+
+      hand_over(options, row)
+    end
+
+    # exec the wrapper, which activates the newest installed samagotchi.
+    # Without one (installed with --bindir), this version syncs.
+    def hand_over(options, row)
+      wrapper = InstalledGem.wrapper(@gem_spec)
+      return done(row, :update, "run chi update again to sync with it") unless wrapper
+
+      passed = FLAGS.select { |_, key| options[key] && key != :dry_run }.keys
+      @stdout.flush
+      @exec.call([RbConfig.ruby, wrapper, "update", "--no-gem", "--gem-from", VERSION, *passed])
+      done(row, :update) # only when exec is a spec's stand-in
+    end
+
+    # Why a part is off for this run, or nil.
+    def off(options, part)
+      return "--no-#{part}" if options[:"no_#{part}"]
+      return "update.#{part}: false" unless Config.get("update.#{part}")
+
+      nil
+    end
+
+    def system_bundle_row
+      result = MemoryBundle::SystemBundle.sync(dry_run: @dry_run)
+      row = Row.new(component: "system bundle", from: result.from, to: result.to)
+      case result.status
+      when :installed then done(row, :install)
+      when :updated then done(row, :update, kept(result.kept, MemoryBundle::SystemBundle::BUNDLE_NAME))
+      when :restored then done(row, :restore).tap { |r| r.to = nil }
+      when :up_to_date then up_to_date(row)
+      when :newer_installed then skipped(row, "newer than this chi's #{result.to}: left").tap { |r| r.to = nil }
+      when :skipped then skipped(row, result.error)
+      else failed(row, result.error)
+      end
+    end
+
+    def bundle_rows(options)
+      if (why = off(options, "bundles"))
+        return [Row.new(component: "bundles", status: "skipped (#{why})")]
+      end
+
+      rows = MemoryBundle::ShippedUpdate.plan(shipped_dir: @shipped_dir)
+      rows = MemoryBundle::ShippedUpdate.apply(rows) unless @dry_run
+      rows.map { |r| bundle_row(r) }
+    end
+
+    def bundle_row(update)
+      row = Row.new(component: update.name, from: update.from, to: update.to)
+      case update.status
+      when :would_update, :updated
+        notes = [kept(update.kept, update.name), replaced(update.replaced)].compact
+        done(row, :update, notes.empty? ? nil : notes.join("; "))
+      when :up_to_date then up_to_date(row)
+      when :skipped then skipped(row, update.note)
+      else failed(row, update.note)
+      end
+    end
+
+    def desktop_row(options)
+      return nil unless @supported
+
+      row = Row.new(component: "Chi Helper")
+      if (why = off(options, "desktop"))
+        return skipped(row, why)
+      end
+
+      helper = @platform.call(register: !options[:no_register])
+      return row.tap { |r| r.status = "not installed" } unless helper.installed?
+
+      row.from = helper.app_version
+      if helper.stale?
+        row.to = VERSION
+        return done(row, :update, @dry_run ? "rebuilds and restarts it" : "restarted") { helper.upgrade { nil } }
+      end
+
+      return up_to_date(row) unless helper.launch_outdated?
+
+      helper.refresh_launch_file unless @dry_run
+      up_to_date(row).tap { |r| r.status += @dry_run ? " (would refresh the launch file)" : " (launch file refreshed)" }
+    rescue Desktop::MacOS::Error, SystemCallError => e
+      failed(row, e.message.lines.first.to_s.strip)
+    end
+
+    def live_rows
+      rows = []
+      stale = LiveVersions.stale_workers(VERSION, state_dir: @state_dir)
+      unless stale.empty?
+        versions = stale.map { |w| w.version || "an older chi" }.uniq.join(", ")
+        ids = stale.map { |w| w.session_id[0, 8] }.join(" ")
+        rows << Row.new(component: "workers",
+                        status: "#{stale.size} live on #{versions}: they move to #{VERSION} at idle exit (30 min) " \
+                                "or chi sessions stop #{ids}")
+      end
+      host, port = @web
+      web = LiveVersions.web_version(host, port)
+      if web && web != VERSION
+        rows << Row.new(component: "chi web :#{port}", from: web,
+                        status: "running old code: new sessions it starts run #{web} too; restart it")
+      end
+      rows
+    end
+
+    def footers(options)
+      return [] if off(options, "bundles")
+
+      names = MemoryBundle::ShippedUpdate.not_installed(shipped_dir: @shipped_dir).map(&:source)
+      names.empty? ? [] : ["Also shipped, not installed: #{names.join(", ")} (chi bundle install NAME)"]
+    end
+
+    def summary(rows)
+      return "(dry run: nothing was changed)" if @dry_run
+      return "some parts failed (see above)" if rows.any?(&:failed)
+
+      rows.all? { |r| r.status.start_with?("up to date", "skipped", "not installed", "couldn't check") } ? "everything is up to date" : "done"
+    end
+
+    # "updated" (or "would update" in a dry run), with a note; the block
+    # makes the change (not in a dry run).
+    def done(row, verb, note = nil)
+      yield if block_given? && !@dry_run
+      text = VERBS.fetch(verb)[@dry_run ? 1 : 0]
+      row.status = note ? "#{text} (#{note})" : text
+      row
+    end
+
+    def up_to_date(row)
+      row.to = nil
+      row.status = "up to date"
+      row
+    end
+
+    def skipped(row, why)
+      row.status = "skipped (#{why})"
+      row
+    end
+
+    def failed(row, why)
+      row.status = "failed (#{why})"
+      row.failed = true
+      row
+    end
+
+    def kept(files, bundle)
+      return nil if files.empty?
+
+      verb = @dry_run ? "would keep" : "kept"
+      "#{verb} your edits in #{files.join(", ")}: chi bundle diff #{bundle} #{files.first}"
+    end
+
+    def replaced(files)
+      return nil if files.empty?
+
+      "#{@dry_run ? "would replace" : "replaced"} edited #{files.join(", ")} (it wasn't loading)"
+    end
+
+    def print_table(rows)
+      header = %w[component from to status]
+      cells = rows.map { |r| [r.component, r.from.to_s, r.to.to_s, r.status] }
+      widths = (0..2).map { |i| ([header] + cells).map { |c| c[i].length }.max }
+      ([header] + cells).each do |c|
+        @stdout.puts((0..2).map { |i| c[i].ljust(widths[i]) }.join("  ") + "  " + c[3])
+      end
+    end
+  end
+end

data/lib/samagotchi/update_hint.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "desktop"
+require_relative "memory_bundle/shipped_update"
+require_relative "session"
+require_relative "version"
+
+module Samagotchi
+  # One line at the first interactive start of a new chi version (REPL,
+  # attached, chi web) when something chi update would update is behind:
+  # "chi 0.3.1: 2 bundles and the desktop helper can be updated: chi update".
+  # Noted once per version in $XDG_STATE_HOME/samagotchi/update_noted,
+  # whether or not anything was behind. No network; nothing is changed (the
+  # system bundle syncs itself at every start).
+  module UpdateHint
+    NOTED_FILE = "update_noted"
+
+    module_function
+
+    # Only a person starting chi at a terminal: not -p or --non-interactive
+    # (a script), not a checkout (git pull updates it), never a worker
+    # (workers don't start through bin/chi's launch).
+    def wanted?(prompt:, non_interactive:, tty:, installed:)
+      !!(tty && installed && !prompt && !non_interactive)
+    end
+
+    # @param helper [#stale?, nil] the desktop helper (nil off macOS)
+    # @return [String, nil] the line shown, if any
+    def show(io: $stderr, env: ENV, version: VERSION, helper: default_helper(env),
+             shipped_dir: MemoryBundle::SourceNormalizer::SHIPPED_DIR)
+      path = File.join(File.dirname(Session.default_state_dir(env: env)), NOTED_FILE)
+      noted = File.exist?(path) ? File.readlines(path, chomp: true) : []
+      return nil if noted.include?(version)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, "#{version}\n", mode: "a")
+      line = message(version, shipped_dir: shipped_dir, helper: helper)
+      io.puts(line) if line
+      line
+    rescue StandardError
+      nil
+    end
+
+    def message(version, shipped_dir:, helper:)
+      bundles = MemoryBundle::ShippedUpdate.plan(shipped_dir: shipped_dir).count { |r| r.status == :would_update }
+      parts = []
+      parts << (bundles == 1 ? "1 bundle" : "#{bundles} bundles") if bundles.positive?
+      parts << "the desktop helper" if helper&.stale?
+      return nil if parts.empty?
+
+      "chi #{version}: #{parts.join(" and ")} can be updated: chi update"
+    end
+
+    def default_helper(env)
+      Desktop.supported? ? Desktop::MacOS.new(env: env) : nil
+    end
+  end
+end

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/vision_support.rb

@@ -25,10 +25,12 @@ module Samagotchi
     # @param profile [ModelProfile, nil] the model's prompt profile (native)
     # @param adapter [LLM::OpenAIChat, nil] the chat host's adapter
     # @param models [Hash, nil] ConfigFile.model_settings (specs)
+    # @param names [Array<String>, nil] the model's lookup names, the typed
+    #   alias first (Engine#model_lookup_names); default: the target's names
     # @return [Answer]
-    def self.for(target, profile: nil, adapter: nil, models: nil)
+    def self.for(target, profile: nil, adapter: nil, models: nil, names: nil)
       entry = target.entry
-      configured = configured(target, entry, models)
+      configured = configured(target, entry, models, names)
       return configured if configured&.no?
 
       if entry.chat?
@@ -44,18 +46,14 @@ module Samagotchi
       marker.is_a?(String) && !marker.empty? ? marker : nil
     end
 
-    def self.configured(target, entry, models)
+    def self.configured(target, entry, models, names = nil)
       models ||= begin
         ConfigFile.model_settings
       rescue StandardError
         {}
       end
-      [target.model, target.bare_model].map { |name| name.to_s.strip.downcase }.uniq.each do |key|
-        value = models.dig(key, :vision)
-        next if value.nil?
-
-        return Answer.new(value: value, reason: value ? nil : "models: #{key} sets vision: false")
-      end
+      key, value = ConfigFile.model_setting(names || [target.model, target.bare_model], :vision, models: models)
+      return Answer.new(value: value, reason: value ? nil : "models: #{key} sets vision: false") if key
       return nil if entry.vision.nil?
 
       Answer.new(value: entry.vision, reason: entry.vision ? nil : "hosts.#{entry.name} sets vision: false")

data/lib/samagotchi/web/app.rb

@@ -13,10 +13,12 @@ require_relative "../bridge/bounded_queue"
 require_relative "../session"
 require_relative "../session_manager"
 require_relative "../session_commands"
+require_relative "../steer"
 require_relative "../host_registry"
 require_relative "../model_profile"
 require_relative "../project_scope"
 require_relative "../version"
+require_relative "../config"
 require_relative "../output_formatter"
 require_relative "../image_store"
 require_relative "../context_note"
@@ -71,6 +73,9 @@ module Samagotchi
       # @param turn_view [Boolean] the page's per-turn view (web.turn_view,
       #   the default); false is the classic row of bubbles; ?view=turn|chat
       #   overrides it for one page load
+      # @param annotate_presets [String, Array] the quick replies next to
+      #   Annotate (web.annotate_presets, "|"-separated); "" shows none. The
+      #   page parses them (annotate_presets.js).
       # @param hub [SessionHub, nil] the session projection GET /api/events
       #   streams from; without one the route answers 503
       # @param registry [HostRegistry, nil] the hosts GET /api/models lists
@@ -79,6 +84,7 @@ module Samagotchi
       #   waits for the hosts' lists
       def initialize(manager: nil, session_class: nil, state_dir: nil, public_dir: nil,
                      bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, turn_view: true, hub: nil,
+                     annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
                      registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT)
         @manager = manager || SessionManager
@@ -92,6 +98,7 @@ module Samagotchi
         @bridge_wait_timeout = bridge_wait_timeout
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @turn_view = turn_view
+        @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
         @hub = hub
         @events_heartbeat = events_heartbeat
         @events_queue = events_queue
@@ -138,6 +145,9 @@ module Samagotchi
           if (m = %r{\A/api/sessions/([^/]+)/stop\z}.match(req.path_info)) && req.post?
             return handle_stop(req, m[1])
           end
+          if (m = %r{\A/api/sessions/([^/]+)/(archive|unarchive)\z}.match(req.path_info)) && req.post?
+            return m[2] == "archive" ? handle_archive(req, m[1]) : handle_unarchive(req, m[1])
+          end
           if (m = %r{\A/api/sessions/([^/]+)/turn\z}.match(req.path_info)) && req.post?
             return handle_turn(req, m[1])
           end
@@ -224,6 +234,8 @@ module Samagotchi
         offset = sanitize_offset(req.params["offset"])
         return list_from_hub(root, sort: sort, order: order, limit: limit, offset: offset) if @hub
 
+        # Archived ones too, as the hub's: the page filters them at render.
+        scope[:include_archived] = true
         sessions = if @state_dir
                      @manager.list_sessions(state_dir: @state_dir, sort: sort, order: order, limit: limit, offset: offset,
                                             **scope)
@@ -396,11 +408,16 @@ module Samagotchi
         # spelled as GET /api/models lists it); blank means the default.
         model = (body["model"] || body["model_name"]).to_s.strip
         folder[:model_name] = model unless model.empty?
+        # preview: an idle session's first message, sent as its first turn
+        # next; the list and the notifications name the session by it
+        # until that turn is saved.
+        preview = idle ? body["preview"].to_s.strip : ""
+        folder[:title] = preview unless preview.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
-        rescue ArgumentError => e
-          return error_response(400, "invalid_model", e.message) if e.message.match?(/SAMAGOTCHI_DEFAULT_MODEL/)
-          raise
+        rescue ModelProfile::MissingModel => e
+          # No model configured, or one qualified with an unknown host.
+          return error_response(400, "invalid_model", e.message)
         end
         # The worker's Bridge is the single live transport: wait (bounded) for
         # it so the client can attach without client-side polling.
@@ -464,6 +481,7 @@ module Samagotchi
           session: session_json,
           history: read_history(id),
           messages: messages_for_display(raw_messages, parts: req.params["parts"] == "1"),
+          failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
           queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
           recap: turn_snapshot && turn_snapshot["recap"],
@@ -597,7 +615,8 @@ module Samagotchi
         client = live_bridge_client(id)
         return error_response(503, "not_live", "no live bridge for session #{id}") unless client
 
-        reply = client.post_command(line: line, client_id: body["client_id"])
+        # card: a card's action; its command events say so (no echo).
+        reply = client.post_command(line: line, client_id: body["client_id"], card: body["card"] == true)
         case reply.status
         when 202 then json_response(202, reply.json || { status: "accepted" })
         when 400 then error_response(400, reply.json&.dig("error") || "unknown_command", reply.json&.dig("detail") || "not a session command")
@@ -805,6 +824,32 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # POST /api/sessions/:id/archive: hide it (and its delegates) from the
+      # lists, keep it for good. A live idle worker is stopped first; a turn
+      # running in it or a delegate, a chi REPL's session and a scratch one
+      # are refused (409).
+      def handle_archive(_req, id)
+        result = @manager.archive_session(id, state_dir: @state_dir, wait: STOP_WAIT_SECONDS)
+        (result[:archived] + result[:discarded]).each { |sid| @hub&.touch(sid) }
+        json_response(200, { status: "archived", session_id: result[:id], archived: result[:archived],
+                             stopped: result[:stopped], discarded: result[:discarded] })
+      rescue SessionManager::OwnedByTUI
+        error_response(409, "owned_by_tui", "session #{id} is open in a chi REPL; close it there first")
+      rescue SessionManager::ArchiveRefused => e
+        error_response(409, e.reason == :scratch ? "scratch" : "busy", e.message)
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
+      # POST /api/sessions/:id/unarchive: back to the lists, delegates too.
+      def handle_unarchive(_req, id)
+        result = @manager.unarchive_session(id, state_dir: @state_dir)
+        result[:unarchived].each { |sid| @hub&.touch(sid) }
+        json_response(200, { status: "unarchived", session_id: result[:id], unarchived: result[:unarchived] })
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
       # DELETE /api/sessions/:id: the session for good. A live worker is
       # stopped first (the page's confirm says so); a chi REPL's session is
       # refused.
@@ -1038,7 +1083,11 @@ module Samagotchi
           turn_records: Array(source["turn_records"]),
           tool_records: Array(source["tool_records"]),
           active_turn: source["active_turn"],
-          active_tools: Array(source["active_tools"])
+          active_tools: Array(source["active_tools"]),
+          # The context last seen and the token sums, for the ctx meter
+          # before the next turn streams (live over saved).
+          context: source["context"],
+          tokens: source["tokens"]
         }
       end
 
@@ -1084,12 +1133,19 @@ module Samagotchi
         return nil unless saved
 
         messages = Array(session.messages)
-        since = messages.drop(saved[:covered].to_i).count { |m| (m[:role] || m["role"]).to_s == "user" }
+        since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.prompt?(m) }
         { text: saved[:text], turns_since: since }
       rescue StandardError
         nil
       end
 
+      # The step (iteration) that answered the steer at +index+: one past
+      # the model messages between it and the prompt before it.
+      def steer_step(list, index)
+        list[0...index].reverse_each.take_while { |m| !Samagotchi::Steer.prompt?(m) }
+                       .count { |m| %w[model assistant].include?((m[:role] || m["role"]).to_s) } + 1
+      end
+
       def read_history(id)
         raw = @manager.read_responses(id, since_time: nil, state_dir: @state_dir)
         raw.map { |chunk| OutputFormatter.strip(chunk) }.reject(&:empty?)
@@ -1113,6 +1169,12 @@ module Samagotchi
             filtered << { role: "note", content: Samagotchi::ContextNote.text_of(m), label: Samagotchi::ContextNote.label_of(m) }
             next
           end
+          # A plugin's steer: a row of the step that answered it, which the
+          # page finds by `step`.
+          if Samagotchi::Steer.steer?(m)
+            filtered << { role: "steer", content: content, source: (m[:source] || m["source"]).to_s, step: steer_step(list, index) }
+            next
+          end
           next if role == "system"
           next if role == "tool_response"
 
@@ -1129,7 +1191,16 @@ module Samagotchi
           message = { role: norm_role, content: stripped }
           images = m[:images] || m["images"]
           message[:images] = Array(images).map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } if norm_role == "user" && images.is_a?(Array) && !images.empty?
-          message[:html] = @markdown_renderer.render(stripped) if norm_role == "assistant" && !stripped.empty? && @markdown_renderer.available?
+          if norm_role == "assistant"
+            # What an after_turn hook presented (AnswerDisplay): rendered and
+            # copied in place of the answer, sanitised the same way; content
+            # stays the model's text, which the page finds the bubble by.
+            display = m[:display] || m["display"]
+            shown = display.is_a?(String) ? Samagotchi::OutputFormatter.strip_markup(display) : ""
+            message[:display] = shown unless shown.strip.empty?
+            rendered = message[:display] || stripped
+            message[:html] = @markdown_renderer.render(rendered) if !rendered.empty? && @markdown_renderer.available?
+          end
           message[:parts] = did if did
           filtered << message
         end
@@ -1138,6 +1209,17 @@ module Samagotchi
         []
       end
 
+      # The last turn failed and its prompt went back to the user: the
+      # prompt (session.last_prompt) and why, for the page to show after the
+      # conversation as it did live. nil otherwise.
+      def failed_turn_for(session, msgs)
+        summary = Samagotchi::TurnNote.restored_failure(msgs)
+        prompt = session.last_prompt.to_s
+        return nil if summary.nil? || prompt.strip.empty?
+
+        { prompt: prompt, summary: summary }
+      end
+
       # The parts of the assistant message at +index+, with the tool_response
       # messages right after it.
       def message_parts(list, index)
@@ -1199,6 +1281,8 @@ module Samagotchi
       def index_data_attributes(req)
         attrs = { "sessions-dir" => sessions_dir_label, "server-dir" => home_label(Dir.pwd) }
         attrs["turn-view"] = "1" if turn_view?(req.params["view"])
+        # Always there: an empty one means no presets, not the default.
+        attrs["annotate-presets"] = @annotate_presets
         dir, = scope_dir(req.params["dir"])
         root = dir && ProjectScope.root_for(dir)
         if root

data/lib/samagotchi/web/message_parts.rb

@@ -93,9 +93,10 @@ module Samagotchi
         outputs = split_outputs(joined, calls.length)
         shown = saved_list(responses, :tool_params, calls.length)
         labels = saved_list(responses, :tool_labels, calls.length)
+        diffs = saved_list(responses, :tool_diffs, calls.length)
         images = split_images(responses, calls.length)
         calls.each_with_index.map do |call, i|
-          tool_part(call, outputs[i], registry, shown[i], images[i], label: labels[i])
+          tool_part(call, outputs[i], registry, shown[i], images[i], label: labels[i], diff: diffs[i])
         end
       end
 
@@ -124,7 +125,8 @@ module Samagotchi
           call = LLM::NativeToolNormalizer.normalize(ref) || { name: ref.name }
           response = by_id[field(raw, :id)] || (field(responses[i], :tool_call_id).nil? ? responses[i] : nil)
           tool_part(call, response && field(response, :content).to_s, registry, field(response, :tool_params),
-                    response && field(response, :images), label: field(response, :tool_labels))
+                    response && field(response, :images), label: field(response, :tool_labels),
+                                                          diff: field(response, :tool_diffs))
         end
       end
 
@@ -145,7 +147,9 @@ module Samagotchi
       end
 
       # +shown+ is the saved params line, when it is a String.
-      def tool_part(call, output, registry, shown = nil, images = nil, label: nil)
+      # +diff+ is what an edit/write changed (EditPreview.change), saved as
+      # tool_diffs.
+      def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil)
         name = call[:name].to_s
         params = shown.is_a?(String) ? shown : ToolActivity.tool_activity_params(name, call, registry: registry)
         part = { tool: name, params: params.to_s }
@@ -156,6 +160,7 @@ module Samagotchi
         end
         refs = Array(images).select { |ref| ref.is_a?(Hash) }
         part[:images] = refs.map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } unless refs.empty?
+        part[:diff] = diff if diff.is_a?(Hash)
         part
       end