samagotchi 0.3.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.3.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,13 +46,13 @@ 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
-      key, value = ConfigFile.model_setting([target.model, target.bare_model], :vision, models: models)
+      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?
 

data/lib/samagotchi/web/app.rb

@@ -415,9 +415,9 @@ module Samagotchi
         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.

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
 

data/lib/samagotchi/web/public/activity.js

@@ -88,6 +88,9 @@ export function addCompleted(model, event = {}) {
   // The images the tool returned (a reload in the turn view draws them from
   // the saved parts, turn_view.js reloadRowHtml).
   if (event.images?.length) row.images = event.images;
+  // What an edit/write changed in its file (a reload draws it from the
+  // saved parts, turn_view.js reloadRowHtml).
+  if (event.diff) row.diff = event.diff;
   return row;
 }
 

data/lib/samagotchi/web/public/app.js

@@ -27,6 +27,7 @@ import { parsePresets, presetNote } from "./annotate_presets.js";
 import { COPY_SOURCE_ATTR, copySource, copySourceAttr, copyText, installCopy, showsAnswer } from "./copy.js";
 import { routeChunk } from "./chunk_router.js";
 import { extractCtxPct, savedCtxPct, cardCtxText } from "./ctx.js";
+import { diffHtml } from "./diff_view.js";
 import { approvalAllowed, approvalView, isApproval, nextCardAction, resultText, summaryText } from "./question_card.js";
 import { cardClass, cardInnerHtml, cardPlace, splitSnapshotCards, turnNoticePlace } from "./card.js";
 import { gripFloor, promptHeight } from "./composer_size.js";
@@ -41,7 +42,7 @@ import {
   appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, normalizeTiming, turnTimingText,
 } from "./timing.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, continueLine, emptyRetryLine, hookNoticeLabel, isCommandLine, isOwn, keepEarlyRestore, newClientId, promptOps, reminderText, restoreAction, restoreOnAck, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, continueLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isCommandLine, isOwn, keepEarlyRestore, newClientId, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -104,6 +105,10 @@ let currentOwner = null;
 let currentTiming = normalizeTiming();
 let turnRunning = false;
 let liveTurnTimingEl = null;
+// What the running turn waits on, after its live timing line: a provider
+// retry (generation_retrying) or plugins' setup (plugin_init_wait); "" when
+// it streams again.
+let liveTurnNote = "";
 let timingInterval = null;
 // Live ask_user_question card, keyed by pending question id. Re-rendered from
 // pending_question on session select so a reload mid-question restores it.
@@ -1272,6 +1277,7 @@ function startLiveTurnTiming(startedAt = new Date().toISOString()) {
   currentTiming.activeTurn = { started_at: startedAt };
   // The turn records hold the finished turns, so this one comes next.
   liveTurnNumber = currentTiming.turnRecords.length + 1;
+  liveTurnNote = "";
   liveTurnTimingEl = document.createElement("div");
   liveTurnTimingEl.className = "turn-timing live";
   historyEl.appendChild(liveTurnTimingEl);
@@ -1286,16 +1292,24 @@ function appendToHistory(el) {
 function updateLiveTiming() {
   const duration = elapsedSince(currentTiming.activeTurn?.started_at);
   if (liveTurnTimingEl && duration !== null) {
-    liveTurnTimingEl.textContent = turnTimingText(liveTurnNumber, duration, { running: true });
+    liveTurnTimingEl.textContent = turnTimingText(liveTurnNumber, duration, { running: true }) + (liveTurnNote ? ` · ${liveTurnNote}` : "");
   }
   updateInfoBar();
 }
 
+// Set (or clear, "") what the running turn waits on.
+function setLiveTurnNote(text) {
+  if (liveTurnNote === text) return;
+  liveTurnNote = text;
+  if (currentTiming.activeTurn) updateLiveTiming();
+}
+
 function finishLiveTurnTiming(record = null) {
   const duration = Number.isFinite(Number(record?.duration_ms))
     ? Number(record.duration_ms)
     : elapsedSince(currentTiming.activeTurn?.started_at);
   if (liveTurnTimingEl && duration !== null) {
+    liveTurnNote = "";
     liveTurnTimingEl.classList.remove("live");
     const at = record ? currentTiming.turnRecords.indexOf(record) : -1;
     liveTurnTimingEl.textContent = turnTimingText(at >= 0 ? at + 1 : liveTurnNumber, duration);
@@ -1322,15 +1336,12 @@ function updateFirstPeek() {
   }
 }
 
-function addUsedMemory(name) {
-  const v = String(name||"").trim();
-  if (!v || currentUsedMemories.includes(v)) return;
-  currentUsedMemories.push(v);
+function setUsedMemories(names) {
+  currentUsedMemories = names.slice();
   updateInfoBar();
   const sess = allSessions.find(s=>s.id===selected);
   if (sess) {
-    sess.used_memory_names = sess.used_memory_names || [];
-    if (!sess.used_memory_names.includes(v)) sess.used_memory_names.push(v);
+    sess.used_memory_names = currentUsedMemories.slice();
     render();
     document.querySelectorAll(".card").forEach(el=>el.classList.toggle("active", el.dataset.id===selected));
   }
@@ -1394,6 +1405,7 @@ const streamHandlers = {
     // block (see chunk_router.js). Raw `content` is only used as a fallback
     // for pre-Phase-2 / non-enriched servers.
     const { text, thinking } = routeChunk(data);
+    setLiveTurnNote("");
     turnDom.chunk({ text, thinking, iteration: data.iteration ?? null });
     const pct = extractCtxPct(data, currentCtxWindow);
     if (pct !== null && !Number.isNaN(pct)) {
@@ -1404,9 +1416,11 @@ const streamHandlers = {
   },
   generation_started: (data) => {
     if (data?.context_window_tokens) currentCtxWindow = data.context_window_tokens;
+    setLiveTurnNote("");
     turnDom.generationStarted(data || {});
   },
   generation_completed: (data) => {
+    setLiveTurnNote("");
     if (data?.served_model) {
       currentServed = [data.served_model, data.requested_model];
       updateInfoBar();
@@ -1530,24 +1544,11 @@ const streamHandlers = {
   context_added: (data) => addNoteBubble({ label: data.label, content: data.text || "" }),
   continue_offered: (data) => renderContinueCard(data),
   continue_resolved: (data) => resolveContinueCard(data),
-  tool_call_started: (data) => {
-    turnDom.toolStarted(data);
-    const call = data.call || {};
-    let name = null;
-    if (call.name === "memory_read" && call.content) {
-      name = String(call.content).split(",")[0].trim();
-      if (name) name = name.replace(/\.md$/,"").split("/").pop();
-    } else if (call.name === "read" && call.content && /memories\/.+\.md/.test(call.content)) {
-      name = String(call.content).split("/").pop().replace(/\.md$/,"");
-    }
-    if (name) addUsedMemory(name);
-  },
+  tool_call_started: (data) => turnDom.toolStarted(data),
   tool_call_completed: (data) => turnDom.toolCompleted(data),
+  // The engine's list, after every memory read and at a turn's end.
   used_memories_updated: (data) => {
-    if (Array.isArray(data.used_memory_names)) {
-      currentUsedMemories = data.used_memory_names.slice();
-      updateInfoBar();
-    }
+    if (Array.isArray(data.used_memory_names)) setUsedMemories(data.used_memory_names);
   },
   context_status: (data) => {
     const pct = extractCtxPct(data, currentCtxWindow);
@@ -1575,6 +1576,10 @@ const streamHandlers = {
   // The loop asks again after an empty answer: a row of the empty step (the
   // chat view shows nothing; after a reload neither does the turn view).
   empty_answer_retry: (data) => { turnDom.notice({ line: emptyRetryLine(data) }); },
+  // The provider is asked again after an error, or the turn waits for
+  // plugins' setup: a note on the live timing line until it streams.
+  generation_retrying: (data) => setLiveTurnNote(retryStatusLine(data)),
+  plugin_init_wait: (data) => setLiveTurnNote(initWaitLine(data)),
   plugin_init_started: (data) => onInitEvent("plugin_init_started", data),
   plugin_init_finished: (data) => onInitEvent("plugin_init_finished", data),
   // A plugin's card, or a new version of one (the same id).
@@ -1752,6 +1757,13 @@ function renderApprovalDetails(view) {
     what.appendChild(code);
     box.appendChild(what);
   }
+  // An edit/write: the diff it would make, under the path.
+  if (view.preview) {
+    const diff = document.createElement("div");
+    diff.className = "approval-diff";
+    diff.innerHTML = diffHtml(view.preview);
+    box.appendChild(diff);
+  }
   for (const [cls, label, text] of [["approval-where", "in", view.where], ["approval-why", "why", view.why]]) {
     if (!text) continue;
     const row = document.createElement("div");

data/lib/samagotchi/web/public/chat_view.js

@@ -11,6 +11,7 @@
 import { newActivity, addStarted, addCompleted, finalizeActivity, activityCount, toolName } from "./activity.js";
 import { copySourceAttr } from "./copy.js";
 import { escapeHtml, leadTrimmed, messageBodyHtml, noteHtml, normalize, steerRowHtml } from "./format.js";
+import { activityDiffHtml } from "./diff_view.js";
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { tallyText } from "./tally.js";
@@ -366,4 +367,6 @@ export function fillActivityRow(el, row, sessionId) {
   // The images a tool returned (the chat view's reloaded history has no tool
   // rows; the turn view's has, turn_view.js reloadRowHtml).
   if (row.images?.length && !el.querySelector(".thumbs")) el.insertAdjacentHTML("beforeend", thumbsHtml(sessionId, row.images));
+  // An edit/write's change, collapsed: "diff +3 −1".
+  if (row.diff && !el.querySelector(".activity-diff")) el.insertAdjacentHTML("beforeend", activityDiffHtml(row.diff));
 }

data/lib/samagotchi/web/public/data.js

@@ -29,6 +29,8 @@ const DEFAULT_EVENT_TYPES = Object.freeze([
   "guardrail_warning",
   "hook_notice",
   "empty_answer_retry",
+  "generation_retrying",
+  "plugin_init_wait",
   "card",
   "plugin_init_started",
   "plugin_init_finished",