samagotchi 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9914119c74e2e2233fcd5931386afca4fbc95b84aa7603e2f4f14289651a12c
-  data.tar.gz: 5ba92c2703f202dffe2d4125eac11fd9d93c970a032cc56af1ce41c0827ab5ba
+  metadata.gz: b91f830918a3f58dac1d54820450ec90b4caa2d8f970b3fab03c8a0199b3ac2e
+  data.tar.gz: 1d1f0f1dc839247801be1462a895e8a57e189a68882fbaeb5a7707fdb4add0ab
 SHA512:
-  metadata.gz: 881df5c769cb4d5ca994253bf7cccfbbd29d033f51e9f73533cf74926d8d6fe155c8e0e92a7a6226b770dceb4e4a816b1d78dd0ff0b1502938a6e8761a26c8d3
-  data.tar.gz: 0a6c687f219568001c688d385221b239a2f285c66f17895c2202bf77098c40236a42cd3ca6b824b493260acb698bf6345e715ecaaa8e53ce6368e938c0bb155f
+  metadata.gz: 398faa2152be479cf78093fb9c752158932a2c186bf1fa5fd1ee9a622895bf742f82f1a25c843febfb877c826cee869623ee9871c50154015fdb54d02a490054
+  data.tar.gz: 35a4b45af554dd9cfd79c87d67ed7d819d14759421f8f669ac769ddbb1b37a64f5b0c79101f15a002ebdb4a2e2e9bee1def9eead820d50f61312c9f4a8cc41c8

data/CHANGELOG.md

@@ -8,6 +8,25 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.27.0] - 2026-10-04
+
+### Added
+
+- Web: a "stop task" button on a running `task_wait` stops the background task; the turn goes on and the model is
+  told the user stopped it (Cancel still cancels the turn and leaves the task running).
+
+### Changed
+
+- `/mcp` lists each server's tools alphabetically, not in the order the server sent them (mcp bundle 0.4.3).
+
+### Fixed
+
+- A stopped background task ends as `stopped`, not `failed`, and records who stopped it (the user or the model).
+- Code blocks in the web follow the light theme too: their highlighting comes from the page's palette instead of one
+  fixed dark theme.
+
+Update with `chi update` (mcp 0.4.3).
+
 ## [0.26.0] - 2026-10-04
 
 ### Added
@@ -1419,7 +1438,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.26.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.27.0...HEAD
+[0.27.0]: https://github.com/dm1try/samagotchi/compare/v0.26.0...v0.27.0
 [0.26.0]: https://github.com/dm1try/samagotchi/compare/v0.25.0...v0.26.0
 [0.25.0]: https://github.com/dm1try/samagotchi/compare/v0.24.0...v0.25.0
 [0.24.0]: https://github.com/dm1try/samagotchi/compare/v0.23.0...v0.24.0

data/docs/architecture.md

@@ -246,6 +246,12 @@ process that already owns the `Engine`); every worker starts it, and it exposes:
   `guardrails.parent_approvals` is `403 parent_approval_refused`, the question still open.
 - `POST /session/:id/question/dismiss` — leave the question unanswered (an approval: denied);
   `200`, or `409` when it is no longer pending.
+- `POST /session/:id/tasks/stop` — `{task_id}`: stop a background task as the user
+  (`TaskRuntime.stop_task by: "user"`, the web's stop-task button on a running `task_wait`;
+  web route `POST /api/sessions/:id/tasks/:task_id/stop`). Only a task this conversation's
+  `task_create` started (the saved messages, or the running turn's accumulator); answers once the
+  task is gone: `200 {status, stop_reason, task_id}`, `404 task_not_found`, `409 not_running`.
+  The worker names it in its sidecar features (`task_stop`).
 - `POST /session/:id/relay` — the approval relay, on a delegated child's worker
   (`{action, relay_id, question_id}`): `opened` / `closed` (with a `reason`) set or clear the
   pending question's `relayed_to` mark (`QuestionDesk#annotate`, `:question_relay`); `answered`

data/docs/hooks.md

@@ -56,7 +56,7 @@ The plugin class must respond to `#call(event)` — duck-typed, no base class re
 | `:after_generation` | After LLM returns (both loops); not after a generation a hook cut (`stop_generation`) | `{ type: :after_generation, iteration: N, response: "...", messages: [...] (the conversation as sent) }` |
 | `:generation_progress` | While the response streams, in batches (see [Watching the stream](#watching-the-stream)) | `{ type: :generation_progress, iteration: N, thinking: "..." (new since the last fire), text: "..." (new visible text), thinking_chars: N, text_chars: N (this generation so far), elapsed_ms: N }` |
 | `:before_tool_call` | Before tool dispatch (and before `tool_call_started`) | `{ type: :before_tool_call, iteration: N, call: {...}, params: "...", guardrail: Verdict, context: {...}, targets: {...}, blocked: false, block_reason: nil }` |
-| `:after_tool_call` | After tool execution | `{ type: :after_tool_call, iteration: N, tool: "read", output: "..." (capped at max_tool_output_chars), status: "ok" \| "error" \| "blocked" \| "stopped" }` |
+| `:after_tool_call` | After tool execution | `{ type: :after_tool_call, iteration: N, tool: "read", output: "..." (capped at max_tool_output_chars), status: "ok" \| "error" \| "blocked" \| "stopped" }`; `stopped` is a `task_wait` the turn's Stop ended (the task runs on) or whose task was stopped |
 | `:session_end` | After each turn `:after_turn` fires for, after it (turn-level lifecycle) | `{ type: :session_end, session_id: "..." }` |
 
 Every event also carries the hook runtime (next section): `hook:` (the label

data/lib/samagotchi/bridge.rb

@@ -27,6 +27,8 @@ require_relative "version"
 require_relative "worker_sidecar"
 require_relative "relay_verifier"
 require_relative "relay_watcher"
+require_relative "tools/task_create"
+require_relative "tools/task_runtime"
 
 module Samagotchi
   # Bridge is an optional HTTP transport that lets an external web / desktop
@@ -461,7 +463,8 @@ module Samagotchi
     # sidecar (WorkerSidecar#features): a client checks a name here rather
     # than a version.
     # restart: POST /exit takes "restart": true (WorkerIdleExit#hold_for_restart).
-    FEATURES = ["restart"].freeze
+    # task_stop: POST tasks/stop (#handle_task_stop), the web's stop-task button.
+    FEATURES = %w[restart task_stop].freeze
 
     # The routes, by method and what follows /session/:id/: a handler takes
     # the session id and the request body and returns [headers, status, body].
@@ -477,6 +480,7 @@ module Samagotchi
       %w[POST recap] => :handle_recap,
       %w[POST relay] => :handle_relay,
       %w[POST relay/status] => :handle_relay_status,
+      %w[POST tasks/stop] => :handle_task_stop,
       %w[GET state] => :handle_state,
       %w[GET stats] => :handle_stats,
       %w[GET snapshot] => :handle_snapshot,
@@ -539,6 +543,38 @@ module Samagotchi
       end
     end
 
+    # POST /session/:id/tasks/stop {task_id}: stop a background task as the
+    # user (TaskRuntime.stop_task by: "user"); a task_wait on it returns, and
+    # the turn goes on. Only a task this conversation created: records in
+    # tmp/tasks are shared by every session in the cwd. Those are in the
+    # saved conversation, or, created in the running turn, only in the
+    # accumulator's task_create parts. 200 {status, stop_reason, task_id},
+    # 404 task_not_found, 409 not_running (it already ended), 400 no id.
+    # Answers once the task is gone: up to STOP_GRACE_SEC.
+    def handle_task_stop(_session_id, body)
+      parsed = parse_json(body)
+      task_id = (fetched(parsed, "task_id") if parsed.is_a?(Hash)).to_s.strip
+      return [{ "Allow" => "POST" }, 400, { error: "missing_fields", detail: "task_id required" }] if task_id.empty?
+      return [{}, 404, { error: "task_not_found", task_id: task_id }] unless own_task_ids.include?(task_id)
+
+      record, error = Tools::TaskRuntime.get_record(task_id)
+      return [{}, 404, { error: "task_not_found", task_id: task_id }] if error
+      return [{}, 409, { error: "not_running", status: record["status"], task_id: task_id }] unless record["status"] == "running"
+
+      Log.info(:bridge, "task_stop", task_id: task_id)
+      record, error = Tools::TaskRuntime.stop_task(task_id, by: "user")
+      return [{}, 500, { error: "bridge_error", detail: error }] if error
+
+      [{}, 200, { status: record["status"], stop_reason: record["stop_reason"], task_id: task_id }]
+    end
+
+    def own_task_ids
+      running = Array(@accumulator.current_turn&.dig(:parts)).filter_map do |part|
+        part[:output].to_s[/\A(?:\[task_create\]\n)?task_id: (\S+)/, 1] if part[:kind] == "tool" && part[:tool] == Tools::TaskCreate::NAME
+      end
+      Tools::TaskRuntime.created_ids_in(@engine.messages_checkpoint) | running
+    end
+
     # Answer the pending question. A past +deadline+ (see #handle_post_turn):
     # 408 deadline_passed, and the question stays open. An answer takes no
     # event hold, so it is checked right before it is recorded.

data/lib/samagotchi/bridge_client.rb

@@ -187,6 +187,15 @@ module Samagotchi
       post("cancel", { reason: reason }, read_body: true)
     end
 
+    # POST /session/:id/tasks/stop: stop a background task this session's
+    # conversation created, as the user (Bridge#handle_task_stop). 200 with
+    # its final status, 404 task_not_found, 409 not_running. Synchronous:
+    # the worker answers once the task is gone (up to its 3 s grace).
+    # @return [Response]
+    def stop_task(task_id)
+      post("tasks/stop", { task_id: task_id }, read_body: true)
+    end
+
     # How long the approval relay's calls wait for a reply: a parent's Stop
     # isn't held for READ_TIMEOUT by a child that doesn't answer.
     RELAY_TIMEOUT = 5

data/lib/samagotchi/bundles/mcp/manifest.yml

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.4.2
+version: 0.4.3
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:d0491b038e7f111f9f8c629729a2b0525d573fd0b17d48ea8ec59c4a2b8b821b
+  sha256: sha256:079a42892f10822115235e1ced7ccd481f80c9ef54abb094f9a1c599bb03e8e2
 requires_chi: ">= 0.8.0"

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -752,7 +752,8 @@ class Plugin
 
     @servers.map do |server|
       head = "**#{server.name}**: #{state_text(server)}"
-      tools = server.tools.map { |tool| tool["chi_name"] }.compact
+      # Sorted: a server lists its tools in its own (often grouped) order.
+      tools = server.tools.map { |tool| tool["chi_name"] }.compact.sort
       tools.empty? ? head : "#{head}\n#{tools.map { |t| "- `#{t}`" }.join("\n")}"
     end.join("\n\n")
   end

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.26.0
+version: 0.27.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/log.rb

@@ -23,6 +23,8 @@ module Samagotchi
   # (once, until Config.reload!). While that runs (Config can warn itself)
   # records only echo. Nothing here raises into the caller: a record that
   # can't be formatted is dropped, an unwritable file pauses (DebugLog).
+  # The one exception is strict mode (SAMAGOTCHI_LOG_STRICT=1, the spec
+  # suite): an unknown tag or a malformed event raises, whatever the level.
   module Log
     LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze
     DEFAULT_LEVEL = :info
@@ -39,6 +41,7 @@ module Samagotchi
     @state = nil
     @resolving = false
     @session_id = nil
+    @strict = ENV["SAMAGOTCHI_LOG_STRICT"] == "1"
 
     class << self
       # @param path [String, nil, :auto] the file; :auto → LogPath.resolve
@@ -72,6 +75,9 @@ module Samagotchi
       # carry its first SID_LENGTH chars unless they pass their own sid:.
       attr_accessor :session_id
 
+      # Raise on an unknown tag or a bad event instead of dropping the record.
+      attr_accessor :strict
+
       def debug(tag, event, **kw) = log(:debug, tag, event, **kw)
       def info(tag, event, **kw) = log(:info, tag, event, **kw)
       def warn(tag, event, **kw) = log(:warn, tag, event, **kw)
@@ -96,7 +102,19 @@ module Samagotchi
         resolved_state&.dig(:writer)&.path
       end
 
-      def log(level, tag, event, payload: nil, sid: nil, echo: nil, **fields)
+      def log(level, tag, event, **kw)
+        check_names!(tag, event) if strict
+        write_record(level, tag, event, **kw)
+      end
+
+      private
+
+      def check_names!(tag, event)
+        raise ArgumentError, "unknown log tag #{tag}" unless LogLine::TAGS.include?(tag.to_s)
+        raise ArgumentError, "bad log event #{event}" unless event.to_s.match?(LogLine::SLUG)
+      end
+
+      def write_record(level, tag, event, payload: nil, sid: nil, echo: nil, **fields)
         options = @options
         echo_to_stderr(echo) if echo && options.fetch(:stderr, true)
         state = resolved_state
@@ -113,8 +131,6 @@ module Samagotchi
         nil
       end
 
-      private
-
       def build(level, tag, event, payload:, sid:, fields:)
         tag = tag.to_s
         event = event.to_s

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
 

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_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,6 +1,7 @@
 # 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
@@ -23,7 +24,8 @@ module Samagotchi
     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.
-    STEP_CHARS = 20_000
+    # 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

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.26.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/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 = {}) {

data/lib/samagotchi/web/public/index.html

@@ -8,11 +8,13 @@
 :root{color-scheme:dark;--bg:#0b0d11;--bg-panel:#151821;--bg-inset:#0f1115;--bg-raised:#22262f;--bg-hover:#1b1f27;--border:#1f232b;--border-strong:#2d333f;--text:#e6e8eb;--text-bright:#f0f3f6;--text-2:#c9d1d9;--text-3:#9aa4b2;--text-muted:#8b949e;--text-faint:#6e7681;--accent:#7aa5ff;--accent-strong:#1f6feb;--accent-bg:#1b2336;--accent-ring:rgba(122,165,255,.18);--primary:#2a68d1;--ok:#3fb950;--ok-text:#7ee787;--ok-bg:#1a2e1a;--warn:#d29922;--warn-text:#e3b341;--warn-bright:#f2cc60;--warn-bg:#2b2108;--warn-border:#6b5416;--danger:#f85149;--danger-bg:#da3633;--danger-text:#ff7b72;--danger-bg-dim:#3d1f1f;--think:#8957e5;--think-text:#d2a8ff;--accent-border:#223150;--accent-tint:color-mix(in srgb,var(--accent) 7%,transparent);--narr:color-mix(in srgb,var(--accent) 38%,var(--text-muted));
   --glass-bg:color-mix(in srgb,var(--bg-panel) 70%,transparent);--glass-border:rgba(255,255,255,.08);--glass-highlight:rgba(255,255,255,.05);--glass-shadow:0 8px 30px rgba(0,0,0,.35);
   --diff-add-bg:rgba(63,185,80,.14);--diff-add-text:#aff5b4;--diff-del-bg:rgba(248,81,73,.14);--diff-del-text:#ffc1bc;
+  --code-text:#c9d1d9;--code-keyword:#ff7b72;--code-string:#a5d6ff;--code-comment:#8b949e;--code-constant:#79c0ff;--code-func:#d2a8ff;--code-type:#ffa657;
   --card-hover-border:rgba(255,255,255,.14);--on-solid:#fff;--on-warn:#fff;--text-hover:#fff;--badge-bg:rgba(255,255,255,.08);--badge-ring:rgba(255,255,255,.18);--shadow-strong:rgba(0,0,0,.5);--backdrop:rgba(0,0,0,.85);--toast-shadow:0 6px 24px rgba(0,0,0,.25)}
 /* Light palette: follows the system setting. :not([data-theme="dark"]) leaves room for a later in-page toggle (data-theme on <html>); there is none yet. Each palette sets color-scheme, so native radios, inputs and scrollbars follow it. */
 @media (prefers-color-scheme:light){:root:not([data-theme="dark"]){color-scheme:light;--bg:#f5f6f8;--bg-panel:#ffffff;--bg-inset:#f1f3f6;--bg-raised:#e8ebf0;--bg-hover:#eceff4;--border:#dde1e7;--border-strong:#c3c9d2;--text:#1f2328;--text-bright:#0d1117;--text-2:#2f363d;--text-3:#475160;--text-muted:#57606a;--text-faint:#636c76;--accent:#0b5cd5;--accent-strong:#0550ae;--accent-bg:#e2ecfd;--accent-ring:rgba(11,92,213,.2);--primary:#1f6feb;--ok:#1a7f37;--ok-text:#116329;--ok-bg:#dafbe1;--warn:#9a6700;--warn-text:#7d4e00;--warn-bright:#875c00;--warn-bg:#fff6cc;--warn-border:#d4a72c;--danger:#cf222e;--danger-bg:#cf222e;--danger-text:#a40e26;--danger-bg-dim:#ffebe9;--think:#8250df;--think-text:#6639ba;--accent-border:#b8cef5;
   --glass-border:rgba(31,35,40,.10);--glass-highlight:rgba(255,255,255,.7);--glass-shadow:0 8px 30px rgba(31,35,40,.10);
   --diff-add-bg:rgba(26,127,55,.12);--diff-add-text:#116329;--diff-del-bg:rgba(207,34,46,.10);--diff-del-text:#82071e;
+  --code-text:#1f2328;--code-keyword:#cf222e;--code-string:#0a3069;--code-comment:#57606a;--code-constant:#0550ae;--code-func:#8250df;--code-type:#953800;
   --card-hover-border:rgba(31,35,40,.18);--on-solid:#fff;--on-warn:#1f2328;--text-hover:#0d1117;--badge-bg:rgba(31,35,40,.06);--badge-ring:rgba(31,35,40,.15);--shadow-strong:rgba(31,35,40,.18);--backdrop:rgba(13,17,23,.85);--toast-shadow:0 6px 24px rgba(31,35,40,.14)}}
 *{box-sizing:border-box;margin:0;padding:0}
 body{font-family: ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;background:radial-gradient(1100px 700px at 8% 0%,color-mix(in srgb,var(--accent) 13%,transparent),transparent 70%),radial-gradient(900px 700px at 100% 100%,color-mix(in srgb,var(--think) 9%,transparent),transparent 70%),var(--bg);background-attachment:fixed;color:var(--text);height:100vh;display:flex;flex-direction:column}
@@ -62,6 +64,18 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .bubble.output.markdown code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:.88em}
 .bubble.output.markdown :not(pre)>code{background:var(--bg-inset);border:1px solid var(--border);border-radius:4px;padding:1px 5px;color:var(--text)}
 .bubble.output.markdown pre{font-size:13px;line-height:1.45;border:1px solid var(--border)}
+/* Code highlighting (markdown_renderer.rb): syntect scope classes, hl-prefixed, coloured from the palette's --code-* tokens. More classes win over fewer (a function name is also "entity"). */
+.syntax-highlighting{color:var(--code-text)}
+.syntax-highlighting .hl-keyword,.syntax-highlighting .hl-storage{color:var(--code-keyword)}
+.syntax-highlighting .hl-string{color:var(--code-string)}
+.syntax-highlighting .hl-string .hl-embedded{color:var(--code-text)}
+.syntax-highlighting .hl-constant{color:var(--code-constant)}
+.syntax-highlighting .hl-entity.hl-name.hl-function,.syntax-highlighting .hl-support.hl-function{color:var(--code-func)}
+.syntax-highlighting .hl-entity.hl-name.hl-class,.syntax-highlighting .hl-entity.hl-name.hl-type,.syntax-highlighting .hl-entity.hl-other.hl-inherited-class,.syntax-highlighting .hl-support.hl-class,.syntax-highlighting .hl-support.hl-type,.syntax-highlighting .hl-meta.hl-diff.hl-range{color:var(--code-type)}
+.syntax-highlighting .hl-comment{color:var(--code-comment);font-style:italic}
+.syntax-highlighting .hl-markup.hl-inserted{color:var(--diff-add-text)}
+.syntax-highlighting .hl-markup.hl-deleted{color:var(--diff-del-text)}
+.syntax-highlighting .hl-invalid{color:var(--danger-text)}
 .bubble.output.markdown h1,.bubble.output.markdown h2,.bubble.output.markdown h3,.bubble.output.markdown h4,.bubble.output.markdown h5,.bubble.output.markdown h6{font-weight:600;line-height:1.3;margin:18px 0 8px;color:var(--text-bright)}
 .bubble.output.markdown h1{font-size:19px}
 .bubble.output.markdown h2{font-size:17px}
@@ -122,6 +136,11 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .activity-status.stopped{color:var(--warn-text);opacity:.8}
 .activity-status.blocked{color:var(--danger-text)}
 .activity-tool{color:var(--accent);font-weight:600}
+/* The stop-task button on a running task_wait (task_stop.js): a small ghost
+   button in the danger colours, at the row's end and in the stage's now slot. */
+button.task-stop{flex:none;margin-left:auto;padding:1px 8px;border:1px solid color-mix(in srgb,var(--danger) 45%,transparent);border-radius:6px;background:transparent;color:var(--danger-text);font-size:11.5px;line-height:18px;white-space:nowrap}
+button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:none}
+.ts-now button.task-stop{align-self:center}
 .activity-params{color:var(--text-muted);word-break:break-all}
 .activity-duration{color:var(--text-faint);font-size:11px;font-variant-numeric:tabular-nums;white-space:nowrap}
 .activity-output{margin:4px 0 2px 60px;font-size:12px;color:var(--text-muted);white-space:pre-wrap;word-break:break-word;background:var(--bg);border-radius:6px;padding:6px 8px;max-height:160px;overflow:auto}

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

@@ -85,6 +85,12 @@ function withCommand(slot, row) {
   return row.view?.command ? { ...slot, command: row.view.command } : slot;
 }
 
+// A running task_wait's slot: the task it waits on and the row's key, for
+// the stop-task button (task_stop.js).
+function withTask(slot, row) {
+  return row.tool === "task_wait" && row.view?.task_id ? { ...slot, taskId: row.view.task_id, key: row.key } : slot;
+}
+
 // While the first step has no thinking and no tool rows the turn is plain:
 // its text streams in the stage's answer slot, as the turn view's
 // chrome-less block streams like a bubble.
@@ -106,7 +112,7 @@ const NO_ANSWER = "no answer";
 //            feed), else the newest thinking one (+thinking+, its ticker),
 //            else "…";
 //   tool     the running call ({name, title, kind}, and command: its full
-//            command when it has one) or null;
+//            command when it has one; taskId and key: a task_wait's) or null;
 //   trail    the last three finished calls, newest last (a file's title
 //            without its dir; command as for tool);
 //   ticks    one per call: {kind, status, step (the gen's index)}.
@@ -137,7 +143,7 @@ export function liveSlots(turn, { narration = "", thinking = "", pending = false
     phase,
     step: ended ? gens.filter((g) => !g.answer || g.thinking || g.tools.length).length : gens.length,
     headline,
-    tool: running ? withCommand({ name: toolName(running), title: rowTitle(running), kind: toolKind(running.tool) }, running) : null,
+    tool: running ? withTask(withCommand({ name: toolName(running), title: rowTitle(running), kind: toolKind(running.tool) }, running), running) : null,
     trail,
     ticks: rows.map(({ row, step }) => ({ kind: toolKind(row.tool), status: row.status, step })),
   };

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

@@ -13,6 +13,7 @@
 import { createTurnView } from "./turn_view.js";
 import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
+import { taskCommand, taskStopButton } from "./task_stop.js";
 
 const COLLAPSE_KEY = "chi_stage_collapsed";
 const WATCH_MS = 200;
@@ -45,7 +46,9 @@ function readCollapsed() {
 // +historyNearBottom+: the history's own follow check (the hand-off scrolls
 // the history only for a reader at its end). +dockEl+, +centerEl+ and
 // +composerEl+ size the stage's cap.
-export function createStageView({ historyEl, appendToHistory, isNearBottom: historyNearBottom, sawText, sessionId, dockEl, centerEl, composerEl }) {
+// +taskStop+: the page's stopper (task_stop.js), for the stop-task button
+// on a running task_wait.
+export function createStageView({ historyEl, appendToHistory, isNearBottom: historyNearBottom, sawText, sessionId, dockEl, centerEl, composerEl, taskStop = null }) {
   // The dock becomes a clear column: the stage's card, then the composer's
   // (its rows moved into .dock-card, which wears the glass and the focus ring).
   document.body.classList.add("stage-view");
@@ -131,6 +134,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     },
     useHold: false,
     newestFirst: true,
+    taskStop,
     onChange: () => scheduleRefresh(),
     onThinkingLine: (text) => {
       const { turn } = view.current();
@@ -223,7 +227,11 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
 
   function drawNow(tool, gen) {
     const quiet = gen?.text && !gen.textDone ? "writing…" : "thinking…";
-    const key = tool ? `run|${tool.name}|${tool.title}|${tool.command || ""}` : `quiet|${quiet}`;
+    // A task_wait's stop button, as the row's (task_stop.js): in the key
+    // with its in-flight state, so a redraw keeps a clicked one disabled.
+    const stopId = tool?.taskId && taskStop?.target({ tool: "task_wait", status: "running", view: { task_id: tool.taskId } });
+    const stopKey = stopId ? `|stop:${tool.key}:${taskStop.busy(stopId)}` : "";
+    const key = tool ? `run|${tool.name}|${tool.title}|${tool.command || ""}${stopKey}` : `quiet|${quiet}`;
     if (shown.now === key) return;
     shown.now = key;
     now.replaceChildren();
@@ -236,6 +244,10 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
       title.textContent = tool.title;
       // The full command when the call has one (the title is its first step +N).
       title.title = tool.command || tool.title;
+      if (stopId) {
+        const command = () => taskCommand(view.current().turn?.gens, stopId);
+        now.appendChild(taskStopButton(taskStop, stopId, { command, onChange: scheduleRefresh }));
+      }
     } else {
       const word = node("span", "ts-title quiet", now);
       word.textContent = quiet;

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

@@ -0,0 +1,101 @@
+// The stop-task button on a running task_wait (POST …/tasks/:task_id/stop,
+// Bridge#handle_task_stop): the worker kills the task as the user, the wait
+// returns, and the turn goes on. Which row gets one, what the confirm says,
+// and the stops in flight. The in-flight set lives here, not in the DOM:
+// the stage rebuilds its "now" slot, and a redraw must keep a clicked
+// button disabled. Pure but for the injected calls, so `node --test`
+// covers it; turn_view.js and stage_view.js draw the button.
+import { stopTask as postStopTask } from "./data.js";
+
+// What a worker that has the route names in its sidecar features.
+export const TASK_STOP_FEATURE = "task_stop";
+const COMMAND_SHOWN = 120;
+
+// The task a row's button would stop: a running task_wait's (its server
+// view's task_id), on a worker that has the route; else null.
+export function stopTarget(row, features) {
+  if (!row || row.tool !== "task_wait" || row.status !== "running") return null;
+  if (!Array.isArray(features) || !features.includes(TASK_STOP_FEATURE)) return null;
+  return row.view?.task_id || null;
+}
+
+// The command a task_create of this turn started +taskId+ with (its row's
+// view), or null: a task from an earlier turn has no row here.
+export function taskCommand(gens, taskId) {
+  for (const gen of gens || []) {
+    for (const row of gen.tools || []) {
+      if (row.tool !== "task_create") continue;
+      const id = /(?:^|\n)task_id: (\S+)/.exec(row.output || "")?.[1];
+      if (id === taskId) return row.view?.command || null;
+    }
+  }
+  return null;
+}
+
+export function confirmText(taskId, command) {
+  const line = String(command || "").replace(/\s+/g, " ").trim();
+  const what = !line ? taskId : line.length > COMMAND_SHOWN ? `${line.slice(0, COMMAND_SHOWN - 1)}…` : line;
+  return `Stop task ${what}?`;
+}
+
+// A failed stop said nothing about: 409 (the task ended meanwhile), 503
+// (no live worker: it can't be stopped now).
+export function quietFailure(error) {
+  return error?.status === 409 || error?.status === 503;
+}
+
+// +sessionId+ and +features+ are read at each call (the selected session,
+// its worker's sidecar features).
+export function createTaskStopper({
+  sessionId,
+  features,
+  stopTask = postStopTask,
+  confirm = (text) => globalThis.confirm(text),
+  alert = (text) => globalThis.alert(text),
+}) {
+  const inFlight = new Set();
+  const keyOf = (taskId) => `${sessionId()}|${taskId}`;
+  return {
+    target: (row) => stopTarget(row, features()),
+    busy: (taskId) => inFlight.has(keyOf(taskId)),
+    // true once the worker stopped it. A stop that went through stays in
+    // flight: the button goes with its row's completion a moment later.
+    async stop(taskId, command = null) {
+      const id = sessionId();
+      const key = keyOf(taskId);
+      if (!id || inFlight.has(key) || !confirm(confirmText(taskId, command))) return false;
+      inFlight.add(key);
+      try {
+        await stopTask(id, taskId);
+        return true;
+      } catch (e) {
+        inFlight.delete(key);
+        if (!quietFailure(e)) alert(e.message);
+        return false;
+      }
+    },
+  };
+}
+
+// The button itself (the one DOM part): a click asks, posts, and keeps it
+// disabled while the stop is in flight. +command+ is read at the click;
+// +onChange+ lets a view redraw (the stage's slot).
+export function taskStopButton(stopper, taskId, { command = () => null, onChange = () => {} } = {}) {
+  const btn = document.createElement("button");
+  btn.type = "button";
+  btn.className = "ghost task-stop";
+  btn.textContent = "stop task";
+  btn.title = "Kill this background task; the model is told you stopped it";
+  btn.disabled = stopper.busy(taskId);
+  btn.addEventListener("click", (e) => {
+    e.stopPropagation();
+    const pending = stopper.stop(taskId, command());
+    btn.disabled = stopper.busy(taskId);
+    onChange();
+    pending.then(() => {
+      btn.disabled = stopper.busy(taskId);
+      onChange();
+    });
+  });
+  return btn;
+}

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

@@ -23,6 +23,7 @@ import { createSentenceFeed } from "./sentences.js";
 import { createTicker } from "./thinking_ticker.js";
 import * as model from "./turn_model.js";
 import { createHold } from "./hold.js";
+import { taskCommand, taskStopButton } from "./task_stop.js";
 
 // A row's status (live, or a saved tool record's on reload): running,
 // error, stopped (a task_wait the user's Stop ended), blocked (a guardrail
@@ -90,7 +91,9 @@ function fillActivityRow(el, row, sessionId) {
 //                  (chronological() restores the order);
 //   onChange()     after anything in the turn changed (the stage redraws
 //                  its slots from current());
-//   onThinkingLine(sentence) the live step's ticker showed a new line.
+//   onThinkingLine(sentence) the live step's ticker showed a new line;
+//   taskStop       the page's stopper (task_stop.js): a running task_wait
+//                  row gets its stop-task button (none: no button).
 export function createTurnView({
   historyEl, appendToHistory, isNearBottom, sawText, sessionId,
   blockHost = appendToHistory,
@@ -100,6 +103,7 @@ export function createTurnView({
   newestFirst = false,
   onChange = () => {},
   onThinkingLine = () => {},
+  taskStop = null,
 }) {
   let turn = null;
   let blockEl = null;
@@ -407,14 +411,33 @@ export function createTurnView({
       const stick = isNearBottom();
       body.appendChild(el);
       fillActivityRow(el, r.row, sessionId());
+      syncTaskStop(el, r.row);
       if (stick) follow();
     } else {
       fillActivityRow(el, r.row, sessionId());
+      syncTaskStop(el, r.row);
     }
     updateBlockSummary();
     onChange();
   }
 
+  // The stop-task button after a running task_wait's params; gone once the
+  // row completes.
+  function syncTaskStop(el, row) {
+    const taskId = taskStop?.target(row);
+    const btn = el.querySelector(":scope > .task-stop");
+    if (!taskId) {
+      btn?.remove();
+      return;
+    }
+    if (btn) {
+      btn.disabled = taskStop.busy(taskId);
+      return;
+    }
+    const command = () => taskCommand(turn?.gens, taskId);
+    el.querySelector(".activity-params").after(taskStopButton(taskStop, taskId, { command }));
+  }
+
   // A hook's line (hook_notice) as a row of the current step, above the row
   // of the call it judged; false with no running turn (app.js shows the
   // bubble then). data.line is a whole row of chi's own (an empty-answer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.27.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -471,6 +471,7 @@ files:
 - lib/samagotchi/web/public/stage_view.js
 - lib/samagotchi/web/public/strip.js
 - lib/samagotchi/web/public/tally.js
+- lib/samagotchi/web/public/task_stop.js
 - lib/samagotchi/web/public/thinking_ticker.js
 - lib/samagotchi/web/public/timing.js
 - lib/samagotchi/web/public/turn_events.js