samagotchi 0.25.0 → 0.27.0

data/lib/samagotchi/prompt_warmup.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "log"
+
+module Samagotchi
+  # The turn-end warm-up (cache.warmup). After a turn, the next turn's prompt
+  # differs from the last request at its tail: the previous answer's
+  # thinking is stripped (Gemma's and Qwen's specs), so a hybrid model on
+  # llama.cpp prefills from a restore point well before the end, longer
+  # with every turn. The warm-up sends that prompt, up to where the new user
+  # turn starts, while the user reads, so the next turn prefills only its
+  # own message (measured on Ornith: 0.73 s -> 0.11 s; 417 -> 26 tokens).
+  #
+  # The slot rule (R4 spike, llama.cpp with its host-memory prompt cache):
+  # - the warm-up runs on the slot the turn's last request used, which still
+  #   holds its state (Client#warm_up, `id_slot`);
+  # - the next request is pinned to that slot only while the warm-up still
+  #   runs, so it queues behind it (0.6 s) instead of starting cold on
+  #   another slot (12 s);
+  # - once the warm-up is done, nothing is pinned: the server finds the
+  #   state itself, and pinning to a slot it has since cleared skips its
+  #   prompt cache (12 s again). #take_pin forgets the slot either way.
+  class PromptWarmup
+    MODES = %w[auto off].freeze
+
+    # Whether cache.warmup allows a warm-up (auto, the default; off, false,
+    # no or 0 turn it off; anything else warns once and is auto).
+    def self.enabled?
+      value = Config.get("cache.warmup").to_s.strip.downcase
+      return false if %w[off false no 0].include?(value)
+
+      unless value.empty? || value == "auto" || @warned
+        @warned = true
+        Log.warn(:config, "invalid_value", echo: "Warning: invalid value for cache.warmup: #{value.inspect} (allowed: auto, off) — using auto",
+                                           key: "cache.warmup")
+      end
+      true
+    rescue StandardError
+      true
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      # The pin (#take_pin forgets it) and the last warm-up's thread.
+      @state = nil
+      @thread = nil
+    end
+
+    # Start a warm-up of +prompt+ on +client+ in its own thread.
+    # @param slot [Integer, nil] the last request's slot (nil: unpinned, and
+    #   nothing to pin the next request to)
+    # @return [Thread]
+    def start(client:, prompt:, model:, slot:, images: [])
+      thread = Thread.new do
+        Thread.current.report_on_exception = false
+        result = client.warm_up(prompt, model: model, slot: slot, images: images)
+        Log.info(:model, "warmup", slot: result&.slot, cached: result&.cache_n, prefilled: result&.prompt_n,
+                                   prefill_ms: result&.prompt_ms, chars: prompt.length)
+        result
+      rescue StandardError => e
+        Log.warn(:model, "warmup_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+        nil
+      end
+      @mutex.synchronize do
+        @thread = thread
+        @state = { thread: thread, client: client, slot: slot }
+      end
+      thread
+    end
+
+    # The slot the next request on +client+ must run on: the warm-up's,
+    # while it still runs there; nil otherwise (done, failed, unpinned, or
+    # another host). Called once per request; the first call forgets the
+    # warm-up, so no later request is ever pinned.
+    def take_pin(client)
+      state = @mutex.synchronize { @state.tap { @state = nil } }
+      return nil unless state && state[:slot].is_a?(Integer) && state[:client].equal?(client)
+
+      state[:thread].alive? ? state[:slot] : nil
+    end
+
+    # Whether a warm-up is running (specs, measurements).
+    def running?
+      thread = @mutex.synchronize { @thread }
+      thread&.alive? || false
+    end
+
+    # Wait up to +timeout+ seconds for the running warm-up (specs).
+    def wait(timeout = nil)
+      thread = @mutex.synchronize { @thread }
+      thread&.join(timeout)
+    end
+  end
+end

data/lib/samagotchi/terminal_ui.rb

@@ -173,6 +173,8 @@ module Samagotchi
       # -p without --non-interactive drops into the REPL, which can answer
       # an approval; --non-interactive can't, so an approval there denies.
       @engine.interface = @non_interactive ? :non_interactive : :repl
+      # A --non-interactive run exits after its turn: no turn-end warm-up.
+      @engine.next_turn_waiting = -> { true } if @non_interactive
       @turn_flow = TurnFlow.new(engine: @engine)
       # A recap written while a continue offer waits says the turn stopped
       # unfinished. (Answering at the prompt is typing: activity already.)

data/lib/samagotchi/thinking_tails.rb

@@ -23,7 +23,7 @@ module Samagotchi
   class ThinkingTails
     FILE = "thinking_tails.jsonl"
     # The last chars of a generation's thinking kept: a loop's cycle and
-    # some of its lead-in.
+    # some of its lead-in. TurnNote cuts an empty step's thinking to it too.
     TAIL_CHARS = 20_000
     MAX_RECORDS = 10
 
@@ -55,8 +55,9 @@ module Samagotchi
       when :generation_chunk then add(event[:thinking].to_s)
       when :generation_completed then completed(event)
       when :generation_cancelled
-        # A plugin's stop_turn mid-generation; a user's Stop is not kept.
-        keep(event, finish_reason: "cancelled", stopped_by: "hook") if event[:reason].to_s == "hook"
+        # A plugin's stop_turn mid-generation (the bundle that stopped it,
+        # "hook" when unknown); a user's Stop is not kept.
+        keep(event, finish_reason: "cancelled", stopped_by: (event[:stopped_by] || "hook").to_s) if event[:reason].to_s == "hook"
       end
     rescue StandardError
       nil

data/lib/samagotchi/tool_activity.rb

@@ -150,12 +150,13 @@ module Samagotchi
     # "error" for an "Error:" result, and for an execute whose command
     # exited non-zero (its last "exit: N" line; no number: killed by a
     # signal), so the turn tally's "(N failed)" counts it. "stopped" for a
-    # task_wait the user's Stop ended: the task itself runs on.
+    # task_wait the user's Stop ended (the task itself runs on), and for one
+    # whose task was stopped (the stop-task button, or the model's task_stop).
     def tool_activity_status(result, tool_name = nil)
       text = result.to_s
       return "error" if text.start_with?("Error:")
       return "error" if tool_name == Tools::Execute::NAME && execute_failed?(text)
-      return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^wait_result: canceled$/)
+      return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^(wait_result: canceled|status: stopped)$/)
 
       "ok"
     end

data/lib/samagotchi/tool_declarations.rb

@@ -28,7 +28,7 @@ module Samagotchi
             },
             description: {
               type: "string",
-              description: "Optional: what this command does, in a few words (what, not why)"
+              description: "What this command does, in a few words (what, not why). Shown to the user as the step's title, so include it on every call."
             },
             cwd: {
               type: "string",

data/lib/samagotchi/tool_view.rb

@@ -3,6 +3,7 @@
 require_relative "command_steps"
 require_relative "tools/execute"
 require_relative "tools/task_create"
+require_relative "tools/task_wait"
 
 module Samagotchi
   # What a richer UI shows of a tool call beyond its one-line params: the
@@ -18,8 +19,9 @@ module Samagotchi
   # can't (the fallback: the UI shows the command itself) or the command
   # is cut. +description+: what the model said the command does (execute's
   # optional description), whitespace collapsed, a trailing period gone;
-  # nil when it gave none.
-  ToolView = Data.define(:command, :cwd, :truncated, :chars, :cd, :steps, :description) do
+  # nil when it gave none. +task_id+: the task a task_wait waits on (its
+  # only field), for the web's stop-task button.
+  ToolView = Data.define(:command, :cwd, :truncated, :chars, :cd, :steps, :description, :task_id) do
     def to_h = super.merge(steps: steps&.map(&:to_h)).compact.reject { |_key, value| value == false }
   end
 
@@ -37,6 +39,7 @@ module Samagotchi
     # @return [ToolView, nil] nil for a tool without a view and for an
     #   empty command
     def self.for(tool_name, call)
+      return task_wait(call) if tool_name == Tools::TaskWait::NAME && call.is_a?(Hash)
       return nil unless TOOLS.include?(tool_name) && call.is_a?(Hash)
 
       command = call[:content].to_s
@@ -47,9 +50,17 @@ module Samagotchi
       parsed = truncated ? nil : CommandSteps.parse(command)
       new(command: truncated ? command[0, COMMAND_LIMIT] : command, cwd: cwd.empty? ? nil : cwd,
           truncated: truncated, chars: truncated ? command.length : nil, cd: parsed&.cd, steps: parsed&.steps,
-          description: description(call))
+          description: description(call), task_id: nil)
     end
 
+    def self.task_wait(call)
+      task_id = call[:content].to_s.strip
+      return nil if task_id.empty?
+
+      new(command: nil, cwd: nil, truncated: false, chars: nil, cd: nil, steps: nil, description: nil, task_id: task_id)
+    end
+    private_class_method :task_wait
+
     # The call's description as a view shows it, nil for none.
     def self.description(call)
       text = call[:description]

data/lib/samagotchi/tools/task_get.rb

@@ -30,8 +30,9 @@ module Samagotchi
           "finished_at: #{record["finished_at"]}",
           "exit_code: #{record["exit_code"]}",
           "stop_reason: #{record["stop_reason"]}",
-          "output_path: #{record.fetch("output_path")}"
-        ].join("\n")
+          "output_path: #{record.fetch("output_path")}",
+          (TaskRuntime::USER_STOP_NOTE if TaskRuntime.stopped_by_user?(record))
+        ].compact.join("\n")
       end
       private_class_method :format_record
     end

data/lib/samagotchi/tools/task_runtime.rb

@@ -22,6 +22,9 @@ module Samagotchi
       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].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.
+      USER_STOP_NOTE = "note: the user stopped this task; don't restart it unless they ask."
 
       module_function
 
@@ -107,19 +110,27 @@ module Samagotchi
       # A native tool_response joins its calls' results with "---".
       # @return [Array<Hash>] {id:, command:}, oldest first
       def running_created_in(messages)
-        ids = Array(messages).flat_map do |message|
+        created_ids_in(messages).filter_map do |id|
+          record, _error = get_record(id)
+          { id: id, command: record["command"].to_s } if record&.fetch("status") == "running"
+        end
+      end
+
+      # The ids of every task this conversation's task_create calls started,
+      # whatever their status now, oldest first.
+      # @return [Array<String>]
+      def created_ids_in(messages)
+        Array(messages).flat_map do |message|
           next [] unless (message[:role] || message["role"]).to_s == "tool_response"
 
           (message[:content] || message["content"]).to_s.split("\n\n---\n\n").filter_map do |block|
             block[/\A\[task_create\]\ntask_id: (\S+)/, 1]
           end
-        end
-        ids.uniq.filter_map do |id|
-          record, _error = get_record(id)
-          { id: id, command: record["command"].to_s } if record&.fetch("status") == "running"
-        end
+        end.uniq
       end
 
+      def stopped_by_user?(record) = record["stop_reason"] == "stopped_by_user"
+
       def get_record(task_id)
         record = load_record(task_id)
         return [nil, "Error: task not found: #{task_id}"] unless record
@@ -142,13 +153,19 @@ module Samagotchi
         content.lines.last(line_count).join
       end
 
-      def stop_task(task_id)
+      # A requested stop ends as "stopped" whatever the exit code: the flag
+      # is on disk before the TERM, so a reader refreshing the record while
+      # the group dies records the stop, not a failure.
+      # @param by [String] "model" (task_stop) or "user" (the web's button)
+      def stop_task(task_id, by:)
         record = load_record(task_id)
         return [nil, "Error: task not found: #{task_id}"] unless record
 
         refreshed = refresh_record(record)
         return [refreshed, nil] unless refreshed["status"] == "running"
 
+        refreshed["stop_requested_by"] = by.to_s
+        write_record(refreshed)
         pid = refreshed["pid"].to_i
 
         begin
@@ -168,10 +185,7 @@ module Samagotchi
           end
         end
 
-        updated = refresh_record(refreshed)
-        updated["status"] = "stopped" if updated["status"] == "running"
-        updated["finished_at"] ||= timestamp
-        updated["stop_reason"] = "stopped_by_user"
+        updated = mark_stopped(refresh_record(refreshed))
         write_record(updated)
 
         [updated, nil]
@@ -294,9 +308,15 @@ module Samagotchi
       end
 
       def mark_finished_without_exit_code(record)
+        record = current_record(record)
+        return record unless record["status"] == "running"
+
         exit_code = read_exit_code(record["exit_code_path"])
 
-        if exit_code.nil?
+        if record["stop_requested_by"]
+          record["exit_code"] = exit_code
+          mark_stopped(record)
+        elsif exit_code.nil?
           record["status"] = "failed"
           record["exit_code"] = nil
           record["stop_reason"] ||= "process_ended_without_exit_code"
@@ -313,6 +333,23 @@ module Samagotchi
         record
       end
 
+      # The disk copy when it is newer than +record+: already finished, or
+      # flagged by a stop that started after +record+ was read.
+      def current_record(record)
+        disk = load_record(record.fetch("id"))
+        return record unless disk
+        return disk if disk["status"] != "running" || disk["stop_requested_by"]
+
+        record
+      end
+
+      def mark_stopped(record)
+        record["status"] = "stopped"
+        record["stop_reason"] = "stopped_by_#{record["stop_requested_by"]}"
+        record["finished_at"] ||= timestamp
+        record
+      end
+
       def read_exit_code(path)
         return nil if path.to_s.empty? || !File.exist?(path)
 

data/lib/samagotchi/tools/task_stop.rb

@@ -10,7 +10,7 @@ module Samagotchi
       def self.name = NAME
 
       def self.call(task_id)
-        record, error = TaskRuntime.stop_task(task_id.to_s.strip)
+        record, error = TaskRuntime.stop_task(task_id.to_s.strip, by: "model")
         return error if error
 
         [

data/lib/samagotchi/tools/task_wait.rb

@@ -37,10 +37,10 @@ module Samagotchi
           return "Error: #{error}" if error
 
           status = record.fetch("status")
-          return format_response(record) unless status == "running"
+          return finished_response(record, tail_lines) unless status == "running"
 
           if completion_pattern
-            output_tail = TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+            output_tail = output_tail(record, tail_lines)
             return format_response(record, wait_result: "pattern_matched", output_tail: output_tail) if completion_pattern.match?(output_tail)
           end
 
@@ -53,10 +53,9 @@ module Samagotchi
 
         # Timeout reached — do one final refresh to capture the latest status
         refreshed, = TaskRuntime.get_record(task_id)
-        return format_response(refreshed) unless refreshed.fetch("status") == "running"
+        return finished_response(refreshed, tail_lines) unless refreshed.fetch("status") == "running"
 
-        output_tail = TaskRuntime.output_tail_lines(refreshed.fetch("output_path"), tail_lines)
-        format_response(refreshed, wait_result: "timeout", output_tail: output_tail)
+        format_response(refreshed, wait_result: "timeout", output_tail: output_tail(refreshed, tail_lines))
       rescue StandardError => e
         "Error: #{e.message}"
       end
@@ -66,18 +65,31 @@ module Samagotchi
       def self.cancelled_response(task_id, tail_lines, started)
         record, error = TaskRuntime.get_record(task_id)
         return "Error: #{error}" if error
-        return format_response(record) unless record.fetch("status") == "running"
+        return finished_response(record, tail_lines) unless record.fetch("status") == "running"
 
-        output_tail = TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
         note = [
           "note: the user stopped the turn while waiting; the task is STILL RUNNING.",
           "  To keep waiting: task_wait #{task_id}. If it is stuck or no longer needed: task_stop #{task_id}.",
           "waited: #{(monotonic_time - started).round}s"
         ]
-        format_response(record, wait_result: "canceled", output_tail: output_tail, extra: note)
+        format_response(record, wait_result: "canceled", output_tail: output_tail(record, tail_lines), extra: note)
       end
       private_class_method :cancelled_response
 
+      # A task the user stopped also says so, with the tail of its output:
+      # the model sees where the job was cut off.
+      def self.finished_response(record, tail_lines)
+        return format_response(record) unless TaskRuntime.stopped_by_user?(record)
+
+        format_response(record, output_tail: output_tail(record, tail_lines), extra: [TaskRuntime::USER_STOP_NOTE])
+      end
+      private_class_method :finished_response
+
+      def self.output_tail(record, tail_lines)
+        TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+      end
+      private_class_method :output_tail
+
       def self.format_response(record, wait_result: nil, output_tail: nil, extra: [])
         lines = [
           "task_id: #{record.fetch("id")}",
@@ -86,9 +98,9 @@ module Samagotchi
           "stop_reason: #{record["stop_reason"]}",
           "output_path: #{record.fetch("output_path")}"
         ]
-        return lines.join("\n") unless wait_result
+        return lines.join("\n") unless output_tail
 
-        lines << "wait_result: #{wait_result}"
+        lines << "wait_result: #{wait_result}" if wait_result
         lines.concat(extra)
         lines << "output_tail:"
         lines << output_tail.rstrip unless output_tail.empty?

data/lib/samagotchi/turn_note.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "model_profile"
+require_relative "thinking_tails"
+
 module Samagotchi
   # The one-line system note a turn leaves in the conversation when it ends
   # without an answer: failed before the model replied, cancelled, or over
@@ -19,6 +22,13 @@ module Samagotchi
     TASK_COMMAND_CHARS = 60
     RETRY_NUDGE = :retry_nudge
     EMPTY_ANSWER = :empty_answer
+    # An empty step's thinking kept on the marker: its tail, so a model
+    # that thought for minutes doesn't put megabytes in the session file.
+    # The same cap as ThinkingTails' saved tails.
+    STEP_CHARS = ThinkingTails::TAIL_CHARS
+    # A step's native thinking starts with one of these; the cut keeps it,
+    # so the UIs still find the thinking (MessageParts).
+    THINK_OPENS = ["<think>", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN].freeze
 
     module_function
 
@@ -75,16 +85,32 @@ module Samagotchi
     # UIs, which draw the turn's notice and steps from it after a reload:
     # +retries+ the empty-answer retries spent, +steps+ the empty
     # generations as model messages (their thinking; the loops keep them out
-    # of the conversation, where they'd be empty assistant turns). Never
+    # of the conversation, where they'd be empty assistant turns), each
+    # text cut to its last STEP_CHARS. Never
     # sent: the payload builders send a system message's content, and the
     # copies for hooks, plugins and the recap drop it (AnswerDisplay.strip).
     def empty(retries: 0, steps: [])
       marker = { retries: retries.to_i }
-      marker[:steps] = steps.map { |step| step.slice(:role, :content, :thinking) } unless steps.empty?
+      marker[:steps] = steps.map { |step| capped_step(step) } unless steps.empty?
       message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
         .merge(EMPTY_ANSWER => marker)
     end
 
+    def capped_step(step)
+      step.slice(:role, :content, :thinking).to_h do |key, value|
+        [key, key == :role || !value.is_a?(String) ? value : tail_of(value)]
+      end
+    end
+
+    # The last STEP_CHARS of +text+ after a line saying how much was cut
+    # (and the thinking's opening tag when it had one); short text as is.
+    def tail_of(text)
+      return text if text.length <= STEP_CHARS
+
+      open = THINK_OPENS.find { |tag| text.start_with?(tag) }
+      "#{open}[… #{text.length - STEP_CHARS} earlier characters cut]\n#{text[-STEP_CHARS..]}"
+    end
+
     # The empty-answer marker of +entry+ (either key type), or nil.
     def empty_answer(entry)
       return nil unless note?(entry)

data/lib/samagotchi/turn_state.rb

@@ -133,6 +133,12 @@ module Samagotchi
       true
     end
 
+    # @return [Boolean] whether #steer_next_turn queued anything a turn has
+    #   yet to begin with
+    def carried_steers?
+      @lock.synchronize { !@carried_steers.empty? }
+    end
+
     # Drop what #steer_next_turn queued and no turn began with (a no-op
     # once #begin! took it).
     # @return [Array<Hash>] the steers dropped ({text:, source:})

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -139,6 +139,7 @@ module Samagotchi
         ["GET", %r{\A/api/sessions/([^/]+)/stream\z}, :handle_stream],
         ["GET", %r{\A/api/sessions/([^/]+)/output\z}, :handle_output],
         ["POST", %r{\A/api/sessions/([^/]+)/cancel\z}, :handle_cancel],
+        ["POST", %r{\A/api/sessions/([^/]+)/tasks/([^/]+)/stop\z}, :handle_task_stop],
         ["POST", %r{\A/api/sessions/([^/]+)/stop\z}, :handle_stop],
         ["POST", %r{\A/api/sessions/([^/]+)/restart\z}, :handle_restart],
         ["POST", %r{\A/api/sessions/([^/]+)/archive\z}, :handle_archive],
@@ -1019,6 +1020,30 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # A task id as TaskRuntime.generate_task_id makes it.
+      TASK_ID = /\A\d{14}-\h{8}\z/
+
+      # The stop-task button: the worker stops the task as the user
+      # (Bridge#handle_task_stop) and its task_wait returns. Its own 404
+      # (not this conversation's task) and 409 (already ended) pass through;
+      # a 404 from a worker without the route is the stale worker's 501.
+      def handle_task_stop(_req, id, task_id)
+        return error_response(400, "invalid_task_id", "not a task id: #{task_id.to_s[0, 80]}") unless TASK_ID.match?(task_id)
+
+        @session_class.load(id, state_dir: default_state_dir)
+        request = ->(client) { client.stop_task(task_id) }
+        relay(id, bridge_client(id), request, what: "the task was not stopped", cant: "stop tasks") do |reply|
+          body = reply.json || {}
+          case reply.status
+          when 200 then json_response(200, { status: body["status"], stop_reason: body["stop_reason"], task_id: task_id, session_id: id })
+          when 404 then (error_response(404, "task_not_found", "no task #{task_id} in this conversation") if body["error"] == "task_not_found")
+          when 409 then json_response(409, { error: "not_running", status: body["status"], task_id: task_id, session_id: id })
+          end
+        end
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
       def handle_stop(_req, id)
         # Bounded, so a Rack thread isn't held long; a worker still exiting
         # after it just means an immediate resume finds it (rare).

data/lib/samagotchi/web/markdown_renderer.rb

@@ -8,7 +8,7 @@ module Samagotchi
     class MarkdownRenderer
       WARNING = "Markdown rendering is enabled, but the optional commonmarker gem is not installed. Install it with: gem install commonmarker"
       # NOTE: `span` is allowed because the syntax highlighter (commonmarker/syntect)
-      # emits inline-styled <span>s; keeping it lets highlighting render.
+      # emits classed <span>s; keeping it lets highlighting render.
       ALLOWED_ELEMENTS = %w[a blockquote br code del em h1 h2 h3 h4 h5 h6 hr li ol p pre s strong span table tbody td th thead tr ul].freeze
       DROP_ELEMENTS = %w[iframe object script style svg].freeze
       ALLOWED_PROTOCOLS = %w[http https mailto].freeze
@@ -35,6 +35,11 @@ module Samagotchi
         html = Commonmarker.to_html(markdown.to_s, options: {
           render: { escape: true }, # escape raw HTML from source; highlighter output is still emitted
           extension: { header_ids: nil }
+        }, plugins: {
+          # An empty theme makes syntect emit scope classes (`keyword`, `string`, ...)
+          # instead of inline colours from one fixed theme, so the page's light and
+          # dark palettes colour code blocks (the --code-* tokens in index.html).
+          syntax_highlighter: { theme: "" }
         })
         return nil unless html
 
@@ -74,6 +79,7 @@ module Samagotchi
 
           node.remove_attribute(attribute.name)
         end
+        prefix_highlight_classes(node) if node.name == "span"
         return unless node.name == "a"
 
         href = node["href"].to_s.strip
@@ -85,16 +91,25 @@ module Samagotchi
         node["rel"] = "noopener noreferrer"
       end
 
-      # The syntax highlighter emits inline `style=` on <span>/<pre>/<code>. Those
-      # values come from the (trusted) theme, not user input, and raw HTML from the
-      # markdown source is already escaped by commonmarker (escape: true), so style
-      # attributes are safe to keep on these elements only.
+      # The syntax highlighter emits `class=` on <pre> ("syntax-highlighting") and
+      # <span> (syntect scope names). They come from the highlighter, not user input:
+      # raw HTML from the markdown source is already escaped by commonmarker
+      # (escape: true), so class attributes are safe to keep on these elements only.
       def allowed_attribute?(node, name)
-        return true if name == "style" && %w[span pre code].include?(node.name)
+        return true if name == "class" && %w[span pre].include?(node.name)
 
         node.name == "a" && %w[href title].include?(name)
       end
 
+      # Scope names are plain words ("diff", "meta", "name", ...) that page CSS and
+      # querySelectors use too: prefix them so they only ever match the hl-* rules.
+      def prefix_highlight_classes(node)
+        words = node["class"].to_s.split
+        return node.remove_attribute("class") if words.empty?
+
+        node["class"] = words.map { |word| "hl-#{word}" }.join(" ")
+      end
+
       def safe_href?(href)
         return true if href.start_with?("#", "/")
 

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

@@ -23,6 +23,7 @@ import { chipName, chipsHtml, imageFiles, restoredChips, thumbsHtml, turnRefs, t
 import { escapeHtml, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, userBodyHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy } from "./format.js";
 import { EMPTY_ANSWER_CLASS, createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { createStageView } from "./stage_view.js";
+import { createTaskStopper } from "./task_stop.js";
 import { appendQuote } from "./annotations.js";
 import { parsePresets } from "./annotate_presets.js";
 import { createAnnotateBar } from "./annotate_bar.js";
@@ -86,6 +87,9 @@ const viewArgs = {
   isNearBottom: () => isNearBottom(),
   sawText: (k) => seenContent.add(k),
   sessionId: () => selected,
+  // The stop-task button on a running task_wait, for a worker that has
+  // the route (its sidecar features).
+  taskStop: createTaskStopper({ sessionId: () => selected, features: () => current.workerFeatures }),
 };
 const turnDom = view === "stage"
   ? createStageView({ ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl })

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

@@ -20,8 +20,9 @@ export function rowHover(row) {
 //
 // A view with steps (CommandSteps) shows them in the command's place, its
 // leading cd as one more "in" tag, and a "raw" toggle (a checkbox, CSS
-// only, so a live and a reloaded row behave alike) that swaps the steps
-// for the command as written. The copy button copies the raw command
+// only, so a live and a reloaded row behave alike; beside the first step
+// when there's no "in" tag) that swaps the steps for the command as
+// written. The copy button copies the raw command
 // either way. A view without steps (the parser's fallback) is the raw
 // block alone: nothing hides the command.
 //
@@ -47,7 +48,9 @@ export function commandBlockHtml(view, title = null) {
     const cwd = where ? `<div class="activity-command-cwd">${where}</div>` : "";
     return `<div class="activity-command code-wrap">${desc}${cwd}${raw}${copyButtonHtml("code")}${cut}</div>`;
   }
-  const head = `<div class="activity-command-head"><span class="activity-command-cwd">${where}</span>` +
+  // No "in" tag: the toggle alone, floated beside the first step (an
+  // empty line for it would sit above the steps).
+  const head = (where ? `<div class="activity-command-head"><span class="activity-command-cwd">${where}</span>` : `<div class="activity-command-head bare">`) +
     `<label class="activity-command-raw" title="Show the command as written"><input type="checkbox">raw</label></div>`;
   return `<div class="activity-command code-wrap has-steps">${desc}${head}${stepsHtml(steps)}${raw}${copyButtonHtml("code")}${cut}</div>`;
 }

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

@@ -123,6 +123,17 @@ export function stopSession(id, opts = {}) {
   return api(`/api/sessions/${id}/stop`, { method: "POST", body: JSON.stringify({}), ...opts });
 }
 
+// Kills a background task the session's conversation started (the
+// stop-task button): 200 {status, stop_reason}; 409 it already ended, 503
+// no live worker.
+export function stopTask(id, taskId, opts = {}) {
+  return api(`/api/sessions/${encodeURIComponent(id)}/tasks/${encodeURIComponent(taskId)}/stop`, {
+    method: "POST",
+    body: JSON.stringify({}),
+    ...opts,
+  });
+}
+
 // Hands the session to a new worker on the newest chi installed: 200
 // {status, from_version, version}, or 409 with the reason in words (detail).
 export function restartSession(id, opts = {}) {