samagotchi 0.54.0 → 0.56.0

data/lib/samagotchi/terminal_ui.rb

@@ -371,12 +371,13 @@ module Samagotchi
 
     # `chi -p "/models" --non-interactive`: the command's output; a refused
     # one fails the run (bin/chi exits 1). The session is saved only when
-    # the command changed it.
+    # the command changed it. Nobody is there to answer a confirm: a
+    # costly /thinking or /reasoning-history applies at once.
     # @return [Symbol, nil] :turn_failed when the command was refused
     def run_one_shot_command(session)
       line = @prompt.strip
       result = begin
-        @commands.run(line)
+        @commands.run(line, confirm: false)
       rescue StandardError => e
         SessionCommands::Result.new(status: :error, output: "#{line.split.first}: #{e.message}", changed: [])
       end
@@ -789,11 +790,14 @@ module Samagotchi
 
       # /model, /models, !rollback, !cmd, /continue (shared with workers);
       # an anytime command's cards print as it shows them (btw's
-      # "thinking…" before the answer).
+      # "thinking…" before the answer). Piped input has nobody to answer a
+      # confirm (the next line is already written): a costly /thinking or
+      # /reasoning-history applies at once.
+      confirm = !piped_input?
       command = if command_registry.anytime?(input)
-                  @engine.running_anytime { @commands.run(input) }
+                  @engine.running_anytime { @commands.run(input, confirm: confirm) }
                 else
-                  @commands.run(input)
+                  @commands.run(input, confirm: confirm)
                 end
       if command
         show_command_result(command)
@@ -874,7 +878,9 @@ module Samagotchi
       session.save unless Session.exist?(session.id)
     end
 
-    # A !cmd shows its own output; everything else is the model> line.
+    # A !cmd shows its own output; everything else is the model> line. A
+    # change that asks first (CacheConfirm) puts its --yes line in the next
+    # input: Enter applies it.
     def show_command_result(result)
       if result.shell
         @surface.commit(result.output)
@@ -882,6 +888,7 @@ module Samagotchi
       elsif !result.output.nil?
         @surface.commit("\nmodel> #{result.output}")
       end
+      queue_input_prefill(result.confirm.line) if result.confirm && !piped_input?
       sync_model_mirrors if result.changed.include?(:model)
     end
 

data/lib/samagotchi/thinking.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "config"
+require_relative "model_profile"
+require_relative "setting_explained"
 
 module Samagotchi
   # How much a model thinks: one level per model, host or run, mapped to each
@@ -38,21 +40,6 @@ module Samagotchi
     # The source a session's own level reads as.
     SESSION_SOURCE = "session"
 
-    # A level and where it came from (#explain): +source+ is "session",
-    # "--thinking", "SAMAGOTCHI_THINKING_LEVEL", "models: qwen",
-    # "hosts.work" or "thinking.level", nil for the default; +own+ is the
-    # session's own level, nil without one. What /thinking, /model,
-    # /stats, the snapshots and the web read.
-    Explained = Data.define(:level, :source, :own) do
-      # "low (session)", "default" with no source.
-      def label = source ? "#{level} (#{source})" : level.to_s
-
-      # The plain form the snapshots, the worker's command_ran event and
-      # the web read.
-      # @return [Hash] symbol keys
-      def summary = { level: level.to_s, source: source, own: own&.to_s }
-    end
-
     module_function
 
     # A session's own level from its file or a command word: :off, :low,
@@ -113,11 +100,11 @@ module Samagotchi
       [DEFAULT, nil]
     end
 
-    # #resolve, as an Explained with the session's own level beside it.
-    # @return [Explained]
+    # #resolve, as a SettingExplained with the session's own level beside it.
+    # @return [SettingExplained]
     def explain(target, names:, models: nil, session: nil)
       level, source = resolve(target, names: names, models: models, session: session)
-      Explained.new(level: level, source: source, own: session)
+      SettingExplained.new(level: level, source: source, own: session)
     end
 
     # thinking.level as a level and its origin (:cli, :env, :file), or nil.
@@ -133,17 +120,25 @@ module Samagotchi
     end
 
     # What a level change costs the prompt cache on +target+ (/thinking's
-    # note; a confirm step may ask before the costly ones):
-    #   :full      the native Gemma 4 prompt starts with <|think|>, so the
-    #              whole prompt is read again;
-    #   :provider  a chat host gets other request fields: a local llama.cpp
-    #              or Splash server keeps its cache, a hosted API may not;
-    #   :tail      native Qwen and the rest: only the tail changes.
+    # note; CacheConfirm asks before the costly ones):
+    #   :full      Gemma 4's prompt starts with <|think|> (the native
+    #              profile, or a local chat server whose model name says
+    #              gemma: its template writes the same token), so the whole
+    #              prompt is read again;
+    #   :provider  a remote chat host gets other request fields: Claude's
+    #              message breakpoints and OpenAI's prefix cache are lost;
+    #   :tail      native Qwen, a local chat server's Qwen and the rest:
+    #              only the tail changes (llama.cpp and Splash keep the rest).
     # @param target [HostRegistry::ModelTarget]
     # @param profile [String, nil] the native prompt profile's name
     # @return [Symbol]
     def cache_cost(target, profile: nil)
-      return :provider if target.entry&.chat?
+      entry = target.entry
+      if entry&.chat?
+        return :provider if entry.remote?
+
+        return ModelProfile.inferred_profile_name(target.bare_model) == "gemma4" ? :full : :tail
+      end
 
       profile == "gemma4" ? :full : :tail
     end

data/lib/samagotchi/thinking_command.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "cache_confirm"
 require_relative "thinking"
 
 module Samagotchi
@@ -10,6 +11,7 @@ module Samagotchi
   # model, its host, then thinking.level). A change takes effect at the
   # next turn's start (the REPL and the worker run it between turns), and
   # the reply says what it costs the prompt cache (Thinking.cache_cost).
+  # A costly change asks first (CacheConfirm); --yes (or -y) applies it.
   class ThinkingCommand
     NAME = "/thinking"
     SETTABLE = (Thinking::LEVELS - [Thinking::DEFAULT]).freeze
@@ -17,35 +19,43 @@ module Samagotchi
 
     COST_NOTES = {
       full: "On this model the whole prompt is read again (Gemma's <|think|> starts it).",
-      provider: "The request's thinking fields change: a local llama.cpp or Splash server keeps its cache; " \
-                "hosted APIs (OpenRouter → Claude, OpenAI) may restart theirs.",
+      provider: "The request's thinking fields change: a hosted API (OpenRouter, Claude, OpenAI) reads the whole " \
+                "conversation again.",
       tail: "Only the prompt's tail changes: the cache keeps the rest."
     }.freeze
 
-    # @param engine [Engine] #thinking_explained, #thinking_override(=),
-    #   #session, #thinking_cache_cost
+    # @param engine [Engine] #thinking_explained(own:), #thinking_override(=),
+    #   #session, #thinking_cache_cost, #history?
     # @param save [#call] saves the session after a change
     def initialize(engine:, save:)
       @engine = engine
       @save = save
     end
 
-    # @param args [String] what follows /thinking
-    # @return [Array(String, Boolean)] the reply and whether the level changed
+    # @param args [String] what follows /thinking (--yes anywhere)
+    # @param confirm [Boolean] ask before a costly change (CacheConfirm);
+    #   false applies it at once (chi send, a delegate, a start flag)
+    # @return [Array(String, Boolean, CacheConfirm::Confirm|nil)] the reply,
+    #   whether the level changed, and the confirm it asks for (nothing
+    #   changed then)
     # @raise [ArgumentError] a word that isn't a level (with USAGE)
-    def run(args)
-      word = args.to_s.strip.downcase
-      return [listing(@engine.thinking_explained), false] if word.empty?
+    def run(args, confirm: true)
+      word, yes = CacheConfirm.split(args)
+      return [listing(@engine.thinking_explained), false, nil] if word.empty?
 
       level = word.to_sym
       raise ArgumentError, "unknown thinking level #{word}\n#{USAGE}" unless Thinking::LEVELS.include?(level)
 
       session = @engine.session or raise ArgumentError, "no session yet"
+      own = SETTABLE.include?(level) ? level : nil
       before = @engine.thinking_explained
-      @engine.thinking_override = SETTABLE.include?(level) ? level : nil
+      ask = confirm && !yes ? ask(before, own, word) : nil
+      return ask if ask
+
+      @engine.thinking_override = own
       @save.call(session)
       after = @engine.thinking_explained
-      [[listing(after), *notes(before, after)].join("\n"), true]
+      [[listing(after), *notes(before, after)].join("\n"), true, nil]
     end
 
     # The level, where it came from, and what the session sets itself.
@@ -62,6 +72,18 @@ module Samagotchi
 
     private
 
+    # The reply that asks before a costly change, nil when it needn't.
+    def ask(before, own, word)
+      would = @engine.thinking_explained(own: own)
+      return nil unless before && would
+
+      cost = @engine.thinking_cache_cost
+      return nil unless CacheConfirm.needed?(cost: cost, history: @engine.history?, changed: would.level != before.level)
+
+      step = CacheConfirm.confirm(NAME, word)
+      [[listing(before), "Switching to #{would.level} restarts the prompt cache: #{COST_NOTES[cost]}", step.text].join("\n"), false, step]
+    end
+
     def notes(before, after)
       return [] unless before && after
       return ["(no change to what the next turn runs under)"] if before.level == after.level

data/lib/samagotchi/tool_row_fields.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "tool_activity"
+require_relative "tool_view"
+require_relative "file_ref"
+
+module Samagotchi
+  # The fields a tool row shows beyond its params, built from the call in
+  # one place for every path: the live tool_call_started (ToolRunner#run)
+  # and a reload from the saved call (Web::MessageParts#tool_part). The
+  # bridge's snapshot and replay (Bridge::TurnAccumulator) copy them by
+  # these lists, so a new field is added here and travels everywhere.
+  #
+  # They travel in two places:
+  # * ACTIVITY_KEYS: top-level on tool_call_started, inside +activity+ on
+  #   tool_call_completed (ToolActivity.tool_activity_event builds that
+  #   activity itself, for the TUI and the metrics);
+  # * EVENT_KEYS: top-level on both, so a UI that missed the start (a
+  #   replay gap) builds its row from the completed event.
+  #
+  # params and label stay where they are: their sources differ per path
+  # (the registry's preview, a plugin's label, the saved shown params).
+  module ToolRowFields
+    ACTIVITY_KEYS = %i[title called_as].freeze
+    EVENT_KEYS = %i[view ref].freeze
+    KEYS = (ACTIVITY_KEYS + EVENT_KEYS).freeze
+
+    module_function
+
+    # @param cwd [String, nil] the session's working directory (the title is
+    #   relative to it when inside it)
+    # @return [Hash] title (a few words: a project-relative path, a command
+    #   without its "cd … &&"), called_as (the name the model called it by
+    #   when that was an alias's: bash), view (ToolView: the full command)
+    #   and ref (FileRef: the file a file tool touched), each only when
+    #   there is one
+    def for(tool_name, call, cwd:)
+      {
+        title: ToolActivity.tool_title(tool_name, call, cwd: cwd),
+        called_as: call[:called_as],
+        view: ToolView.for(tool_name, call)&.to_h,
+        ref: FileRef.for(tool_name, call, cwd: cwd)&.to_h
+      }.compact
+    end
+  end
+end

data/lib/samagotchi/tool_runner.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "tool_activity"
-require_relative "tool_view"
+require_relative "tool_row_fields"
 require_relative "guardrails"
 require_relative "vision_context"
 require_relative "log"
@@ -54,14 +54,10 @@ module Samagotchi
       started = { type: :tool_call_started, iteration: iteration, call_count: call_count, call_index: call_index,
                   tool: call[:name], call: call.dup, params: params }
       started[:label] = label if label
-      # The worker runs in its session's working directory.
-      title = ToolActivity.tool_title(call[:name], call, cwd: Dir.pwd)
-      started[:title] = title if title
-      # The name the model called it by when that was an alias's (bash).
-      started[:called_as] = call[:called_as] if call[:called_as]
-      # The full command for a richer UI (params stays cut at 80).
-      view = ToolView.for(call[:name], call)&.to_h
-      started[:view] = view if view
+      # Its row fields (ToolRowFields: title, called_as, view, ref); the worker runs in
+      # its session's working directory.
+      fields = ToolRowFields.for(call[:name], call, cwd: Dir.pwd)
+      started.merge!(fields)
       emit(on_stream_event, started)
 
       # The ask comes after tool_call_started: the UI shows the tool line,
@@ -102,8 +98,8 @@ module Samagotchi
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
       # Also here: a UI that missed the start (a replay gap) builds its row
-      # from this event.
-      completed[:view] = view if view
+      # from this event (its title is in the activity).
+      completed.merge!(fields.slice(*ToolRowFields::EVENT_KEYS))
       emit(on_stream_event, completed)
       # After the completed event: a hook's card (check-in, skills) prints
       # under the call's tool row, not before it.

data/lib/samagotchi/tools/builtins.rb

@@ -121,7 +121,8 @@ module Samagotchi
       # /model), which chi self reports; unset when unknown, so a value
       # inherited from an outer session never passes for this one. So too
       # the session's own thinking level (SAMAGOTCHI_SESSION_THINKING, unset
-      # without one), which chi self puts first. A
+      # without one), which chi self puts first, and its own reasoning_history
+      # level (SAMAGOTCHI_SESSION_REASONING_HISTORY, the same way). A
       # worker's `chi --model X` default (ModelProfile::MODEL_FROM_CLI_ENV)
       # is unset: it was that run's, not the default of a chi run here.
       def parent_env(kctx, env: ENV)
@@ -129,9 +130,11 @@ module Samagotchi
         id = peers.respond_to?(:session_id) ? peers.session_id.to_s : ""
         model = peers.respond_to?(:model_ref) ? peers.model_ref.to_s : ""
         thinking = peers.respond_to?(:thinking) ? peers.thinking&.to_s : nil
+        history = peers.respond_to?(:reasoning_history) ? peers.reasoning_history&.to_s : nil
         { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
           SESSION_MODEL_ENV => model.empty? ? nil : model,
-          SESSION_THINKING_ENV => thinking }.merge(cli_model_unset(env))
+          SESSION_THINKING_ENV => thinking,
+          SESSION_REASONING_HISTORY_ENV => history }.merge(cli_model_unset(env))
       end
 
       # The unsets that keep a `chi --model X` worker's default from passing
@@ -144,6 +147,7 @@ module Samagotchi
 
       SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
       SESSION_THINKING_ENV = "SAMAGOTCHI_SESSION_THINKING"
+      SESSION_REASONING_HISTORY_ENV = "SAMAGOTCHI_SESSION_REASONING_HISTORY"
 
       # task_create's parent_env, less the unsets of a variable the model
       # set in its env (a SAMAGOTCHI_DEFAULT_MODEL it asked for stays).

data/lib/samagotchi/tools/peers.rb

@@ -9,10 +9,12 @@ module Samagotchi
     # delegate's approval is relayed through (relay: nil when this session
     # can't host one), and the model the session runs on (model_ref: the
     # resolved ref, live after /model), and the session's own thinking level
-    # (thinking: nil without one). Engine hands KernelLoop one that follows its current
+    # (thinking: nil without one) and reasoning_history level
+    # (reasoning_history: nil without one). Engine hands KernelLoop one that follows its current
     # session (Engine::PeerView); this plain one is for specs and a kernel
     # without an Engine.
-    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, keyword_init: true) do
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, :reasoning_history,
+                       keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/task_runtime.rb

@@ -22,7 +22,8 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
-      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING
+                           SAMAGOTCHI_SESSION_REASONING_HISTORY].freeze
       # task_wait and task_get add it to a task the user stopped (the web's
       # stop-task button), so the model doesn't rerun the job.
       # A record whose pid isn't a process group chi started (missing, 0, 1,

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -26,6 +26,7 @@ require_relative "../llm_context_override"
 require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../thinking"
+require_relative "../reasoning_history"
 require_relative "../sampling_settings"
 require_relative "../served_model"
 require_relative "../project_scope"
@@ -40,6 +41,7 @@ require_relative "../context_providers"
 require_relative "../recap_store"
 require_relative "markdown_renderer"
 require_relative "capabilities"
+require_relative "editor"
 require_relative "message_parts"
 require_relative "session_summary"
 require_relative "../log"
@@ -88,6 +90,9 @@ module Samagotchi
       # @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 editor [String] what a ref opens on this machine (web.editor:
+      #   a preset or a URL template, Web::Editor); only a local viewer gets
+      #   it (#viewer_editor)
       # @param hub [SessionHub, nil] the session projection GET /api/sessions
       #   lists and GET /api/events streams from (Server always builds one);
       #   without one both routes answer 503
@@ -102,6 +107,7 @@ module Samagotchi
       def initialize(manager: nil, session_class: nil, state_dir: nil, public_dir: nil,
                      bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, view: Config::BY_KEY["web.view"].default, hub: nil,
                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
+                     editor: Config::BY_KEY["web.editor"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
                      registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil)
         @manager = manager || SessionManager
@@ -117,6 +123,7 @@ module Samagotchi
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @view = view
         @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
+        @editor_url = Editor.template(editor)
         @hub = hub
         @events_heartbeat = events_heartbeat
         @events_queue = events_queue
@@ -212,6 +219,23 @@ module Samagotchi
                                    ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       end
 
+      # The payload's capabilities (Capabilities, per request) and, next to
+      # them, editor_url: the URL template a ref opens (web.editor), nil
+      # when this viewer can't open one.
+      def viewer_capabilities(req)
+        editor_url = @editor_url && local_viewer?(req) ? @editor_url : nil
+        { capabilities: Capabilities.for(@markdown_renderer, editor: !editor_url.nil?).to_h, editor_url: editor_url }
+      end
+
+      # A viewer on this machine, whose editor can open the session's
+      # paths: a loopback peer, or this Mac on its own LAN address (the LAN
+      # URL or its QR code opened here). The phone isn't. An SSH tunnel or
+      # a local reverse proxy looks like loopback too (a known gap).
+      def local_viewer?(req)
+        peer = req.get_header("REMOTE_ADDR").to_s
+        LOOPBACK_PEERS.include?(peer) || (!@lan.nil? && peer == @lan[:ip])
+      end
+
       LOOPBACK_NAMES = %w[127.0.0.1 [::1] localhost].freeze
       LOOPBACK_PEERS = %w[127.0.0.1 ::1 ::ffff:127.0.0.1].freeze
 
@@ -494,7 +518,7 @@ module Samagotchi
       end
 
       # The thinking level +model+ starts at, with where it came from (the
-      # start page's think chip; Thinking::Explained#summary, no session).
+      # start page's think chip; SettingExplained#summary, no session).
       def add_thinking(model, target, names, settings)
         model[:thinking] = Thinking.explain(target, names: names, models: settings).summary
       rescue StandardError
@@ -538,7 +562,7 @@ module Samagotchi
       end
 
       # A session's thinking level with where it came from and its own
-      # (Thinking::Explained#summary), as its worker would resolve it; nil
+      # (SettingExplained#summary), as its worker would resolve it; nil
       # when it can't be. Config and the registry only: no network.
       def thinking_for(session)
         registry = host_registry
@@ -550,6 +574,22 @@ module Samagotchi
         nil
       end
 
+      # A session's reasoning_history level with where it came from and its
+      # own (SettingExplained#summary), as its worker would resolve it; nil
+      # on a native host (it ignores the level) or when it can't be. Config
+      # and the registry only: no network.
+      def reasoning_history_for(session)
+        registry = host_registry
+        name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
+        target = registry.resolve(name)
+        return nil unless target.entry&.chat?
+
+        names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
+        ReasoningHistory.explain(target, names: names, session: session.reasoning_history).summary
+      rescue StandardError
+        nil
+      end
+
       # Built again when config.yml's hosts: changed (compared as read: the
       # YAML read is mtime-cached), so the model picker lists a host added
       # while chi web runs. An injected registry (specs) stays.
@@ -797,6 +837,10 @@ module Samagotchi
         session_json = session_json.merge(llm_context: (snapshot && snapshot["llm_context"]) || llm_context_for(session))
         # The thinking level the next turn runs at (the think chip), the same way.
         session_json = session_json.merge(thinking: (snapshot && snapshot["thinking"]) || thinking_for(session))
+        # Its reasoning history (the reasoning chip): the worker's (nil on a
+        # native host), else the server's reading (an older worker, none).
+        history = snapshot&.key?("reasoning_history") ? snapshot["reasoning_history"] : reasoning_history_for(session)
+        session_json = session_json.merge(reasoning_history: history)
         raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
         timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
         json_response(200, {
@@ -821,7 +865,7 @@ module Samagotchi
           # names its plugins' too.
           commands: turn_snapshot&.fetch("commands", nil) || SessionCommands.builtin_registry.listing,
           markdown_warning: @markdown_renderer.warning,
-          capabilities: Capabilities.for(@markdown_renderer).to_h,
+          **viewer_capabilities(req),
           pending_question: pending,
           last_event_seq: last_event_seq,
           # The stream cursor `<seq>-<epoch>`: a later worker resets it
@@ -881,7 +925,7 @@ module Samagotchi
           session: session_json,
           messages: messages,
           markdown_warning: @markdown_renderer.warning,
-          capabilities: Capabilities.for(@markdown_renderer).to_h,
+          **viewer_capabilities(req),
           timing: timing
         })
       rescue ArgumentError => e

data/lib/samagotchi/web/capabilities.rb

@@ -3,16 +3,20 @@
 module Samagotchi
   module Web
     # What this web page renders that a notice may stand in for
-    # (Engine#hook_notify's fallback_for:). The session and tail JSON carry
-    # it as +capabilities+; the page leaves out a notice whose fallback_for
-    # names a capability that is true here. +display+: the answer's display
-    # is rendered as markdown, so its links are links (web.markdown on and
-    # commonmarker installed). A later capability is a new member. (The
-    # member hides Object#display, which nothing calls on it.)
-    Capabilities = Data.define(:display) do # rubocop:disable Lint/DataDefineOverride
+    # (Engine#hook_notify's fallback_for:), and what this viewer can do. The
+    # session and tail JSON carry it as +capabilities+; the page leaves out
+    # a notice whose fallback_for names a capability that is true here.
+    # +display+: the answer's display is rendered as markdown, so its links
+    # are links (web.markdown on and commonmarker installed). +editor+: this
+    # viewer can open a path in this machine's editor (a viewer on this
+    # machine, web.editor not none); per request, the URL template goes next
+    # to it as the payload's editor_url. A later capability is a new member.
+    # (The member hides Object#display, which nothing calls on it.)
+    Capabilities = Data.define(:display, :editor) do # rubocop:disable Lint/DataDefineOverride
       # @param markdown_renderer [MarkdownRenderer]
-      def self.for(markdown_renderer)
-        new(display: markdown_renderer.available? == true)
+      # @param editor [Boolean] this request's viewer can open refs
+      def self.for(markdown_renderer, editor: false)
+        new(display: markdown_renderer.available? == true, editor: editor == true)
       end
     end
   end

data/lib/samagotchi/web/editor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../log"
+
+module Samagotchi
+  module Web
+    # web.editor: the URL a ref's click opens in this machine's editor, as a
+    # template with {path} (the file's absolute path, each segment encoded
+    # by the page) and an optional {line}. A preset name, or a template of
+    # one's own; "none" (or an unknown name) turns refs off.
+    module Editor
+      PRESETS = {
+        "vscode" => "vscode://file{path}:{line}",
+        "vscode-insiders" => "vscode-insiders://file{path}:{line}",
+        "cursor" => "cursor://file{path}:{line}",
+        "zed" => "zed://file{path}:{line}"
+      }.freeze
+      NONE = "none"
+
+      module_function
+
+      # @param value [String, nil] the web.editor setting
+      # @return [String, nil] the URL template; nil for none. A value that
+      #   is neither a preset nor has {path} logs a warning and is none.
+      def template(value)
+        text = value.to_s.strip
+        return text if text.include?("{path}")
+
+        name = text.downcase
+        return nil if name.empty? || name == NONE
+        return PRESETS[name] if PRESETS.key?(name)
+
+        Log.warn(:web, "editor_unknown", value: text)
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/web/message_parts.rb

@@ -3,7 +3,7 @@
 require_relative "../model_profile"
 require_relative "../tool_call_parser"
 require_relative "../tool_activity"
-require_relative "../tool_view"
+require_relative "../tool_row_fields"
 require_relative "../llm/native_tool_normalizer"
 require_relative "../tools/builtins"
 require_relative "../image_store"
@@ -231,15 +231,10 @@ module Samagotchi
         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
-        # The name the model called it by when that was an alias's (the
-        # saved call is rebuilt by BuiltinCalls, which sets it again).
-        part[:called_as] = call[:called_as] if call[:called_as]
-        # Built from the saved call (never saved itself), so older sessions
-        # get it too.
-        view = ToolView.for(name, call)&.to_h
-        part[:view] = view if view
+        # Its row fields (ToolRowFields: title, called_as, view, ref), built from the saved
+        # call (never saved themselves), so older sessions get them too. The
+        # saved call is rebuilt by BuiltinCalls, which sets called_as again.
+        part.merge!(ToolRowFields.for(name, call, cwd: cwd))
         part[:label] = label if label.is_a?(String) && !label.empty?
         unless output.nil?
           part[:output] = output.length > OUTPUT_MAX ? output[0, OUTPUT_MAX] : output