samagotchi 0.3.0 → 0.5.0

data/lib/samagotchi/web/app.rb

@@ -70,9 +70,8 @@ module Samagotchi
 
       # @param bridge_wait_timeout [Float] bounded seconds to wait for a
       #   freshly-spawned worker's bridge before answering POST /api/sessions.
-      # @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 view ["turn", "stage", "chat"] the page's view of a turn
+      #   (web.view); ?view=turn|stage|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).
@@ -82,11 +81,15 @@ module Samagotchi
       #   (built from the config on first use)
       # @param models_wait_timeout [Float] bounded seconds GET /api/models
       #   waits for the hosts' lists
+      # @param lan [Hash, nil] LAN mode (web.host: lan): { ip:, token: },
+      #   the address the server also listens on and its access token (a
+      #   String, or a Web::Token::Source that follows the file); nil:
+      #   loopback only, no token
       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,
+                     bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, view: "turn", 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)
+                     registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil)
         @manager = manager || SessionManager
         @registry = registry
         @models_wait_timeout = models_wait_timeout
@@ -97,12 +100,15 @@ module Samagotchi
         @public_dir = public_dir || File.expand_path("public", __dir__)
         @bridge_wait_timeout = bridge_wait_timeout
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
-        @turn_view = turn_view
+        @view = 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
         @server_running = -> { true }
+        @lan = lan
+        @refused_mutex = Mutex.new
+        @refused_logged = {}
       end
 
       def call(env)
@@ -116,7 +122,12 @@ module Samagotchi
 
       def route(env)
         req = Rack::Request.new(env)
-        return forbidden unless localhost?(req)
+        return forbidden unless local_host_header?(env)
+        return cross_origin if cross_site?(env)
+        if @lan && !LOOPBACK_PEERS.include?(env["REMOTE_ADDR"].to_s)
+          denied = token_gate(req)
+          return denied if denied
+        end
 
         case [req.request_method, req.path_info]
         when ["GET", "/"], ["GET", "/index.html"]
@@ -199,15 +210,140 @@ module Samagotchi
                                    ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       end
 
-      def localhost?(req)
-        # Only 127.0.0.1 / ::1 / localhost are allowed. The socket is bound to
-        # 127.0.0.1, but an explicit Host check prevents DNS-rebind tricks.
-        host = req.host.to_s.downcase.split(":").first
-        %w[127.0.0.1 ::1 localhost].include?(host)
+      LOOPBACK_NAMES = %w[127.0.0.1 [::1] localhost].freeze
+      LOOPBACK_PEERS = %w[127.0.0.1 ::1 ::ffff:127.0.0.1].freeze
+
+      # Only 127.0.0.1 / [::1] / localhost (any port), and in LAN mode the
+      # LAN address, are answered. The socket is bound to those, but a Host
+      # check stops DNS-rebinding pages. It reads the raw Host header:
+      # Rack's req.host trusts X-Forwarded-Host, which such a page could
+      # set. A request with no Host (HTTP/1.0) is answered only for a
+      # loopback peer.
+      def local_host_header?(env)
+        host = env["HTTP_HOST"].to_s
+        return LOOPBACK_PEERS.include?(env["REMOTE_ADDR"].to_s) if host.empty?
+
+        name = host.downcase.sub(/:\d*\z/, "")
+        LOOPBACK_NAMES.include?(name) || (!@lan.nil? && name == @lan[:ip])
+      end
+
+      TOKEN_COOKIE = "chi_token"
+      # 400 days, the longest a browser keeps a cookie (Chrome's cap). No
+      # Secure: the LAN page is plain http. Lax, not Strict: a token link
+      # opened from another site (a web messenger) makes its 303 chain
+      # cross-site, and a Strict cookie wouldn't ride on the redirected GET;
+      # the cross-site check already refuses what Strict would add.
+      TOKEN_COOKIE_ATTRIBUTES = "HttpOnly; SameSite=Lax; Path=/; Max-Age=34560000"
+      REFUSED_LOG_INTERVAL = 60.0
+
+      # LAN mode, a peer that isn't this machine (the peer is the socket's
+      # address, REMOTE_ADDR: never X-Forwarded-For or req.ip, which trust
+      # headers a phone could send): every route needs the access token, as
+      # the chi_token cookie or an Authorization: Bearer header. The page
+      # with ?token= trades it for the cookie and a 303 to itself without
+      # it, so the token doesn't stay in the phone's history.
+      # @return [Array, nil] the response that refuses it, or nil to go on
+      def token_gate(req)
+        token = current_token
+        if req.get? && ["/", "/index.html"].include?(req.path_info) && req.params.key?("token")
+          return token_redirect(req, token) if token_match?(req.params["token"], token)
+        else
+          auth = req.get_header("HTTP_AUTHORIZATION").to_s[/\ABearer +(\S+)\z/, 1]
+          return nil if token_match?(auth, token) || token_match?(req.cookies[TOKEN_COOKIE], token)
+        end
+
+        unauthorized(req)
+      end
+
+      def current_token
+        token = @lan[:token]
+        token.respond_to?(:current) ? token.current : token
+      end
+
+      def token_match?(given, token)
+        return false if given.nil? || given.empty? || token.nil? || token.empty?
+
+        Rack::Utils.secure_compare(given, token)
+      end
+
+      # The same page (and its other parameters, as they were written), the
+      # token traded for the cookie.
+      def token_redirect(req, token)
+        query = req.query_string.split("&").reject { |pair| pair.split("=", 2).first == "token" }.join("&")
+        location = query.empty? ? req.path_info : "#{req.path_info}?#{query}"
+        [303, { "Location" => location, "Set-Cookie" => "#{TOKEN_COOKIE}=#{token}; #{TOKEN_COOKIE_ATTRIBUTES}",
+                "Cache-Control" => "no-store", "Content-Length" => "0" }, []]
+      end
+
+      def unauthorized(req)
+        log_refused(req.get_header("REMOTE_ADDR").to_s, req.path_info)
+        return error_response(401, "unauthorized", "chi web on the LAN needs its access token") if req.path_info.start_with?("/api/")
+
+        body = UNAUTHORIZED_PAGE
+        [401, { "Content-Type" => "text/html; charset=utf-8", "Content-Length" => body.bytesize.to_s, "Cache-Control" => "no-store" },
+         [body]]
+      end
+
+      # At most once a minute per peer: a phone with an old link retries.
+      def log_refused(peer, path)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        due = @refused_mutex.synchronize do
+          @refused_logged.delete_if { |_, at| now - at >= REFUSED_LOG_INTERVAL } if @refused_logged.size > 64
+          last = @refused_logged[peer]
+          (last.nil? || now - last >= REFUSED_LOG_INTERVAL).tap { |fresh| @refused_logged[peer] = now if fresh }
+        end
+        Log.warn(:web, "unauthorized", peer: peer, path: path) if due
+      end
+
+      # What a phone sees without the token. The field is for a home-screen
+      # web app: it has its own cookies, and the QR code opens the browser.
+      UNAUTHORIZED_PAGE = <<~HTML
+        <!doctype html>
+        <html lang="en"><head><meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>chi web: access token needed</title>
+        <style>
+          :root { color-scheme: light dark; }
+          body { font: 16px/1.5 -apple-system, system-ui, sans-serif; max-width: 30rem; margin: 3rem auto; padding: 0 1rem; }
+          input { font: inherit; width: 100%; box-sizing: border-box; padding: .5rem; margin: .5rem 0; }
+          button { font: inherit; padding: .4rem 1rem; }
+        </style></head>
+        <body>
+        <h1>chi web</h1>
+        <p>This page needs chi web's access token. Open the LAN link chi web printed in its terminal, or scan its QR code.</p>
+        <form method="get" action="/">
+          <label for="token">Or paste the token:</label>
+          <input id="token" name="token" autocomplete="off" autocapitalize="off" spellcheck="false">
+          <button type="submit">Open</button>
+        </form>
+        </body></html>
+      HTML
+
+      # Another website's page in the desktop browser can send "simple"
+      # requests here (a text/plain POST needs no preflight) and would start
+      # sessions that run commands. Refused: any request but GET/HEAD from
+      # another site (Sec-Fetch-Site cross-site/same-site, or an Origin other
+      # than exactly this server's: another local port and "null" are
+      # foreign), and GETs of /api/* the same way (no blind reads, no SSE
+      # subscriptions). The page itself is same-origin; curl, Net::HTTP and
+      # chi's own clients send neither header and pass. A link followed from
+      # another site still opens the page (a top-level GET).
+      def cross_site?(env)
+        foreign = %w[cross-site same-site].include?(env["HTTP_SEC_FETCH_SITE"].to_s.downcase)
+        origin = env["HTTP_ORIGIN"]
+        foreign ||= !origin.nil? && origin.downcase != "http://#{env["HTTP_HOST"].to_s.downcase}"
+        return false unless foreign
+
+        !%w[GET HEAD].include?(env["REQUEST_METHOD"]) || env["PATH_INFO"].to_s.start_with?("/api/")
+      end
+
+      def cross_origin
+        error_response(403, "cross_origin", "requests from other websites are refused")
       end
 
       def forbidden
-        error_response(403, "forbidden", "only 127.0.0.1 is allowed")
+        names = @lan ? "127.0.0.1, [::1], localhost and #{@lan[:ip]}" : "127.0.0.1, [::1] and localhost"
+        error_response(403, "forbidden", "only the host names #{names} are answered")
       end
 
       # The page's scope: ?dir=<folder> lists that folder's project (every
@@ -248,7 +384,7 @@ module Samagotchi
           session_to_json(s, status: displayed_status(s, owner: owner), owner: owner, root_cache: roots)
         end
         # Expose total via header for pagination (total unordered count)
-        headers = { "Content-Type" => "application/json; charset=utf-8", "Cache-Control" => "no-store", "Access-Control-Allow-Origin" => "*" }
+        headers = { "Content-Type" => "application/json; charset=utf-8", "Cache-Control" => "no-store" }
         # Compute total without limit/offset for header
         if limit || offset.positive?
           total = if @state_dir
@@ -269,7 +405,7 @@ module Samagotchi
         all = @hub.snapshot(project_root: root, sort: sort, order: order)
         page = all.drop(offset)
         page = page.first(limit) if limit
-        headers = { "Content-Type" => "application/json; charset=utf-8", "Cache-Control" => "no-store", "Access-Control-Allow-Origin" => "*" }
+        headers = { "Content-Type" => "application/json; charset=utf-8", "Cache-Control" => "no-store" }
         headers["X-Total-Count"] = all.size.to_s if limit || offset.positive?
         body = JSON.generate(page)
         headers["Content-Length"] = body.bytesize.to_s
@@ -294,7 +430,7 @@ module Samagotchi
       # is chi web, and it knows ?dir (features).
       def handle_info
         json_response(200, { app: "chi-web", version: Samagotchi::VERSION, pid: Process.pid, cwd: Dir.pwd,
-                             features: ["dir"] })
+                             features: ["dir"], lan: @lan && @lan[:ip] })
       end
 
       # The models a new session can start on, spelled as chi spells them
@@ -415,9 +551,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.
@@ -480,7 +616,8 @@ module Samagotchi
         json_response(200, {
           session: session_json,
           history: read_history(id),
-          messages: messages_for_display(raw_messages, parts: req.params["parts"] == "1"),
+          messages: messages_for_display(raw_messages, parts: req.params["parts"] == "1",
+                                                       cwd: session.respond_to?(:working_directory) ? session.working_directory : nil),
           failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
           queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
@@ -889,8 +1026,7 @@ module Samagotchi
           "Content-Type" => "text/event-stream",
           "Cache-Control" => "no-cache",
           "Connection" => "keep-alive",
-          "X-Accel-Buffering" => "no",
-          "Access-Control-Allow-Origin" => "*"
+          "X-Accel-Buffering" => "no"
         }
 
         # Handlers that buffer enumerable bodies before responding (rackup's
@@ -924,8 +1060,7 @@ module Samagotchi
           "Content-Type" => "text/event-stream",
           "Cache-Control" => "no-cache",
           "Connection" => "keep-alive",
-          "X-Accel-Buffering" => "no",
-          "Access-Control-Allow-Origin" => "*"
+          "X-Accel-Buffering" => "no"
         }
         body = EventsBody.new(hub: @hub, project_root: root, heartbeat: @events_heartbeat, capacity: @events_queue,
                               server_running: @server_running)
@@ -1159,7 +1294,9 @@ module Samagotchi
       #   assistant message also carries what it did (MessageParts: thinking,
       #   tool calls with params and output), and a message with nothing to
       #   show but that (a text-less step) is kept with empty content
-      def messages_for_display(msgs, parts: false)
+      # @param cwd [String, nil] the session's working directory (the parts'
+      #   tool titles are relative to it)
+      def messages_for_display(msgs, parts: false, cwd: nil)
         filtered = []
         list = Array(msgs)
         list.each_with_index do |m, index|
@@ -1179,7 +1316,7 @@ module Samagotchi
           next if role == "tool_response"
 
           stripped = Samagotchi::OutputFormatter.strip_markup(content)
-          did = parts && %w[model assistant].include?(role) ? message_parts(list, index) : nil
+          did = parts && %w[model assistant].include?(role) ? message_parts(list, index, cwd) : nil
           next if stripped.empty? && did.nil?
 
           norm_role = role == "model" ? "assistant" : role
@@ -1222,9 +1359,9 @@ module Samagotchi
 
       # The parts of the assistant message at +index+, with the tool_response
       # messages right after it.
-      def message_parts(list, index)
+      def message_parts(list, index, cwd = nil)
         responses = list.drop(index + 1).take_while { |r| (r[:role] || r["role"]).to_s == "tool_response" }
-        MessageParts.for_message(list[index], responses)
+        MessageParts.for_message(list[index], responses, cwd: cwd)
       end
 
       # The last message messages_for_display shows as an answer, as a list of
@@ -1280,7 +1417,7 @@ module Samagotchi
       # nothing here: the list call answers 400 and the page says so.
       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"])
+        attrs["view"] = view_name(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"])
@@ -1301,19 +1438,17 @@ module Samagotchi
         attrs.map { |key, value| %(data-#{key}="#{Rack::Utils.escape_html(value)}") }.join(" ")
       end
 
-      # The turn view for this page load: ?view=turn or ?view=chat wins,
-      # anything else leaves the config's choice.
-      def turn_view?(param)
-        case param
-        when "turn" then true
-        when "chat" then false
-        else @turn_view
-        end
+      VIEWS = Config::BY_KEY["web.view"].enum_values
+
+      # The view for this page load: ?view=turn|stage|chat wins, anything
+      # else leaves the config's choice (web.view).
+      def view_name(param)
+        VIEWS.include?(param) ? param : @view
       end
 
       def json_response(status, payload)
         body = JSON.generate(payload)
-        [status, { "Content-Type" => "application/json; charset=utf-8", "Content-Length" => body.bytesize.to_s, "Cache-Control" => "no-store", "Access-Control-Allow-Origin" => "*" }, [body]]
+        [status, { "Content-Type" => "application/json; charset=utf-8", "Content-Length" => body.bytesize.to_s, "Cache-Control" => "no-store" }, [body]]
       end
 
       # The request body, "" when there is none: WEBrick (through rackup)

data/lib/samagotchi/web/lan.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "socket"
+
+module Samagotchi
+  module Web
+    # web.host beyond loopback: `lan` (this machine's private IPv4 address)
+    # or one of its IPv4 addresses. chi web then listens on 127.0.0.1 and
+    # that address; the local tools (a second chi web, chi update) keep
+    # talking to 127.0.0.1 (local_host). IPv6 LAN addresses aren't offered.
+    module Lan
+      LOOPBACK_NAMES = %w[127.0.0.1 ::1 localhost].freeze
+      # Interfaces `lan` never picks: VPN tunnels, bridges, VMs and
+      # containers, Apple's low-latency link.
+      SKIPPED = /\A(utun|bridge|docker|vboxnet|vmnet|llw)/
+      PRIVATE = [IPAddr.new("10.0.0.0/8"), IPAddr.new("172.16.0.0/12"), IPAddr.new("192.168.0.0/16")].freeze
+
+      Address = Struct.new(:ip, :interface, keyword_init: true) do
+        def to_s = "#{ip} (#{interface})"
+      end
+
+      # The address chi web adds, the other private ones `lan` could have
+      # picked (said in the startup lines), and whether it isn't a private
+      # one (an explicit Tailscale or public address: a warning).
+      Choice = Struct.new(:ip, :interface, :others, :public, keyword_init: true)
+
+      class Error < StandardError; end
+
+      module_function
+
+      # Does this web.host ask for LAN access? `lan`, or an IPv4 address
+      # that isn't loopback or 0.0.0.0 (never bound: every interface).
+      def wanted?(setting)
+        setting = setting.to_s.strip
+        return true if setting == "lan"
+
+        ip = ipv4(setting)
+        !ip.nil? && !ip.loopback? && ip != IPAddr.new("0.0.0.0")
+      end
+
+      # Where this machine reaches its own chi web: the loopback address
+      # for `lan` or a LAN address, ::1 and localhost as they are, and
+      # 127.0.0.1 for anything else (chi web binds that instead).
+      def local_host(setting)
+        setting = setting.to_s.strip
+        %w[::1 localhost].include?(setting) ? setting : "127.0.0.1"
+      end
+
+      # @param ifaddrs [Array<Socket::Ifaddr>] this machine's interfaces
+      # @return [Choice]
+      # @raise [Error] `lan` with no private address, or an address that
+      #   isn't this machine's
+      def choose(setting, ifaddrs: Socket.getifaddrs)
+        setting = setting.to_s.strip
+        mine = addresses(ifaddrs)
+        if setting == "lan"
+          candidates = mine.select { |a| private?(a.ip) && !a.interface.match?(SKIPPED) }
+          raise Error, "web.host is lan, but this machine has no private IPv4 address on the network (Wi-Fi off?)" if candidates.empty?
+
+          first, *others = candidates
+          return Choice.new(ip: first.ip, interface: first.interface, others: others, public: false)
+        end
+
+        found = mine.find { |a| a.ip == setting }
+        raise Error, "web.host is #{setting}, which isn't an address of this machine" unless found
+
+        others = mine.select { |a| a.ip != found.ip && private?(a.ip) && !a.interface.match?(SKIPPED) }
+        Choice.new(ip: found.ip, interface: found.interface, others: others, public: !private?(found.ip))
+      end
+
+      # This machine's IPv4 addresses on interfaces that are up, loopback
+      # left out, in the system's order.
+      def addresses(ifaddrs)
+        ifaddrs.filter_map do |ifa|
+          addr = ifa.addr
+          next unless addr&.ipv4?
+          next if ifa.flags.nobits?(Socket::IFF_UP) || ifa.flags.anybits?(Socket::IFF_LOOPBACK)
+
+          Address.new(ip: addr.ip_address, interface: ifa.name)
+        end.uniq(&:ip)
+      end
+
+      def private?(ip)
+        addr = ipv4(ip)
+        !addr.nil? && PRIVATE.any? { |net| net.include?(addr) }
+      end
+
+      def ipv4(text)
+        return nil unless text.to_s.match?(/\A\d{1,3}(\.\d{1,3}){3}\z/)
+
+        addr = IPAddr.new(text)
+        addr.ipv4? ? addr : nil
+      rescue IPAddr::Error
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/web/message_parts.rb

@@ -55,15 +55,17 @@ module Samagotchi
       # @param message [Hash] a saved model message (symbol or string keys)
       # @param responses [Array<Hash>] the tool_response messages after it
       # @param registry [Tools::Registry] the session's tools
-      # @return [Hash, nil] { thinking:, tools: [{ tool:, params:, output:,
-      #   output_truncated:, images: }] } with only what it found; nil for nothing
-      def for_message(message, responses, registry: Tools::Builtins.default)
+      # @param cwd [String, nil] the session's working directory (a file
+      #   tool's title is relative to it)
+      # @return [Hash, nil] { thinking:, tools: [{ tool:, params:, title:,
+      #   output:, output_truncated:, images: }] } with only what it found; nil for nothing
+      def for_message(message, responses, registry: Tools::Builtins.default, cwd: nil)
         content = field(message, :content).to_s
         calls = field(message, :tool_calls)
         tools = if calls.is_a?(Array) && !calls.empty?
-                  native_tools(calls, responses, registry)
+                  native_tools(calls, responses, registry, cwd)
                 else
-                  markup_tools(content, responses, registry)
+                  markup_tools(content, responses, registry, cwd)
                 end
         parts = {}
         thinking = [field(message, :thinking).to_s.strip, thinking_of(content)].reject(&:empty?).join("\n\n")
@@ -83,7 +85,7 @@ module Samagotchi
         blocks.map(&:strip).reject(&:empty?).join("\n\n")
       end
 
-      def markup_tools(content, responses, registry)
+      def markup_tools(content, responses, registry, cwd = nil)
         calls = []
         calls.concat(ToolCallParser::Qwen.new(ModelProfile.qwen36).parse(content)) if content.include?("<tool_call>")
         calls.concat(ToolCallParser::Gemma.new(ModelProfile.gemma4).parse(content)) if content.include?("<|tool_call>")
@@ -93,9 +95,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], cwd: cwd)
         end
       end
 
@@ -117,14 +120,15 @@ module Samagotchi
         counts.map { |n| images.shift(n) }
       end
 
-      def native_tools(calls, responses, registry)
+      def native_tools(calls, responses, registry, cwd = nil)
         by_id = responses.to_h { |r| [field(r, :tool_call_id), r] }
         calls.each_with_index.map do |raw, i|
           ref = CallRef.new(field(raw, :name).to_s, field(raw, :arguments))
           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), cwd: cwd)
         end
       end
 
@@ -145,10 +149,14 @@ 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. +cwd+: the session's working directory, for the title.
+      def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil, cwd: 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 }
+        title = ToolActivity.tool_title(name, call, cwd: cwd)
+        part[:title] = title if title
         part[:label] = label if label.is_a?(String) && !label.empty?
         unless output.nil?
           part[:output] = output.length > OUTPUT_MAX ? output[0, OUTPUT_MAX] : output
@@ -156,6 +164,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

@@ -46,6 +46,7 @@ export function addStarted(model, event = {}) {
     row.tool = event.tool || row.tool;
     row.label = event.label || row.label;
     row.params = event.params || row.params;
+    row.title = event.title || row.title;
     return { row, created: false };
   }
   row = {
@@ -55,6 +56,10 @@ export function addStarted(model, event = {}) {
     tool: event.tool || "tool",
     label: event.label || null,
     params: event.params || "",
+    // What the call did in a few words (the server's tool title: a
+    // project-relative path, a command without its "cd … &&"); rows show it
+    // in place of the params when there is one.
+    title: event.title || null,
     status: ROW_STATUS.RUNNING,
     output: "",
     output_truncated: false,
@@ -78,6 +83,7 @@ export function addCompleted(model, event = {}) {
       tool: event.tool,
       label: event.label,
       params: event.activity?.params || "",
+      title: event.activity?.title,
     });
     row = synthesized.row;
   }
@@ -85,9 +91,13 @@ export function addCompleted(model, event = {}) {
   row.output = event.output || "";
   row.output_truncated = !!event.output_truncated;
   if (event.activity?.params) row.params = event.activity.params;
+  if (event.activity?.title) row.title = event.activity.title;
   // 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;
 }