samagotchi 0.2.0 → 0.3.0

data/lib/samagotchi/tools/execute.rb

@@ -18,16 +18,22 @@ module Samagotchi
       TIMEOUT_SEC = 30
       STOP_GRACE_SEC = 1.0
       STOP_POLL_INTERVAL_SEC = 0.05
+      WAIT_SLICE_SEC = 0.2
+      NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
 
       def self.name        = NAME
 
-      def self.call(command, cwd: nil)
+      # @param cancelled [#call] true once the user stopped the turn: the
+      #   command is killed (or not started) and its output so far returned
+      def self.call(command, cwd: nil, cancelled: -> { false })
+        return NOT_RUN_ON_STOP if cancelled.call
+
         command = command.strip
         resolved_cwd = resolve_cwd(cwd)
         return "Error: cwd not found: #{resolved_cwd}" unless resolved_cwd
 
         timeout_sec = timeout_seconds
-        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd)
+        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled)
 
         stdout_block = output_block("stdout", stdout)
         stderr_block = output_block("stderr", stderr)
@@ -45,19 +51,29 @@ module Samagotchi
       rescue CommandTimedOut => e
         # Keep the "Error:" first line (callers classify on it) and return
         # whatever the command printed before it was killed.
-        parts = ["Error: command timed out after #{timeout_sec}s"]
-        parts << output_block("stdout", e.stdout)
-        parts << output_block("stderr", e.stderr)
-        parts.compact.join("\n")
+        stopped_result("Error: command timed out after #{timeout_sec}s", e)
+      rescue CommandCancelled => e
+        stopped_result("Error: command stopped by the user after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue => e
         "Error: #{e.message}"
       end
 
-      def self.run_command(command, timeout_sec:, cwd:)
+      def self.stopped_result(first_line, error)
+        parts = [first_line]
+        parts << output_block("stdout", error.stdout)
+        parts << output_block("stderr", error.stderr)
+        parts.compact.join("\n")
+      end
+      private_class_method :stopped_result
+
+      def self.run_command(command, timeout_sec:, cwd:, cancelled: -> { false })
         stdout_text = ""
         stderr_text = ""
         status = nil
         timed_out = false
+        was_cancelled = false
+        started = monotonic_time
+        deadline = started + timeout_sec
 
         Open3.popen3(command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
@@ -65,14 +81,24 @@ module Samagotchi
           stderr_reader = reader_thread_for(stderr)
 
           begin
-            if wait_thr.join(timeout_sec)
-              status = wait_thr.value
-            else
-              timed_out = true
-              terminate_process_tree(wait_thr.pid)
-              wait_thr.join
-              status = wait_thr.value
+            until wait_thr.join(WAIT_SLICE_SEC)
+              if cancelled.call
+                was_cancelled = true
+                break
+              elsif monotonic_time > deadline
+                timed_out = true
+                break
+              end
             end
+            terminate_process_tree(wait_thr.pid) if timed_out || was_cancelled
+            wait_thr.join
+            status = wait_thr.value
+          rescue Exception # rubocop:disable Lint/RescueException -- kill the child, then re-raise
+            # An Interrupt (or anything else) mid-wait: the child is in its own
+            # process group, so it never saw the SIGINT. Kill it, or the reads
+            # below block until it closes stdout.
+            terminate_process_tree(wait_thr.pid)
+            raise
           ensure
             # Read the buffered output before closing the pipes. For a process
             # that exits almost instantly (e.g. `echo hello`), the background
@@ -86,6 +112,7 @@ module Samagotchi
         end
 
         raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
+        raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
 
         [stdout_text, stderr_text, status]
       end
@@ -209,6 +236,17 @@ module Samagotchi
           super("command timed out")
         end
       end
+
+      class CommandCancelled < StandardError
+        attr_reader :stdout, :stderr, :elapsed
+
+        def initialize(stdout, stderr, elapsed)
+          @stdout = stdout
+          @stderr = stderr
+          @elapsed = elapsed
+          super("command stopped by the user")
+        end
+      end
     end
   end
 end

data/lib/samagotchi/tools/task_runtime.rb

@@ -94,6 +94,25 @@ module Samagotchi
         end.compact.sort_by { |record| record["created_at"].to_s }.reverse
       end
 
+      # The tasks this conversation's task_create calls started that are
+      # still running. Only task_create results count: records are shared by
+      # every session in the worker's cwd, and task_list shows them all.
+      # 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|
+          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
+
       def get_record(task_id)
         record = load_record(task_id)
         return [nil, "Error: task not found: #{task_id}"] unless record

data/lib/samagotchi/tools/task_wait.rb

@@ -14,7 +14,10 @@ module Samagotchi
 
       def self.name = NAME
 
-      def self.call(task_id, timeout: TIMEOUT_DEFAULT, tail_lines: TAIL_LINES_DEFAULT, done_pattern: nil)
+      # @param cancelled [#call] true once the user stopped the turn: the
+      #   wait returns then, and the task keeps running
+      def self.call(task_id, timeout: TIMEOUT_DEFAULT, tail_lines: TAIL_LINES_DEFAULT, done_pattern: nil,
+                    cancelled: -> { false })
         timeout = TIMEOUT_DEFAULT if blank?(timeout)
         tail_lines = TAIL_LINES_DEFAULT if blank?(tail_lines)
         timeout = timeout.to_i
@@ -27,7 +30,8 @@ module Samagotchi
         return completion_pattern if completion_pattern.is_a?(String)
 
         task_id = task_id.to_s.strip
-        deadline = monotonic_time + timeout
+        started = monotonic_time
+        deadline = started + timeout
 
         loop do
           record, error = TaskRuntime.get_record(task_id)
@@ -41,6 +45,8 @@ module Samagotchi
             return format_response(record, wait_result: "pattern_matched", output_tail: output_tail) if completion_pattern.match?(output_tail)
           end
 
+          return cancelled_response(task_id, tail_lines, started) if cancelled.call
+
           break if monotonic_time > deadline
           sleep(POLL_INTERVAL)
         end
@@ -55,7 +61,24 @@ module Samagotchi
         "Error: #{e.message}"
       end
 
-      def self.format_response(record, wait_result: nil, output_tail: nil)
+      # The task may have finished between the poll and the Stop: then the
+      # normal finished result. Only a task still running says so.
+      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"
+
+        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)
+      end
+      private_class_method :cancelled_response
+
+      def self.format_response(record, wait_result: nil, output_tail: nil, extra: [])
         lines = [
           "task_id: #{record.fetch("id")}",
           "status: #{record.fetch("status")}",
@@ -66,6 +89,7 @@ module Samagotchi
         return lines.join("\n") unless wait_result
 
         lines << "wait_result: #{wait_result}"
+        lines.concat(extra)
         lines << "output_tail:"
         lines << output_tail.rstrip unless output_tail.empty?
         lines.join("\n")

data/lib/samagotchi/turn_note.rb

@@ -13,6 +13,10 @@ module Samagotchi
     KIND = "turn_note"
     OPEN = "[SYSTEM: "
     CLOSE = "]"
+    FAILED = "the previous turn failed before any answer: "
+    RESTORED = "The message went back to the user, who may send it again."
+    TASKS_LISTED = 5
+    TASK_COMMAND_CHARS = 60
 
     module_function
 
@@ -21,28 +25,48 @@ module Samagotchi
     #   failed user message is not in the conversation any more)
     # @param continued [Boolean] it was a continue turn (no user message)
     def failed(summary, restored: false, continued: false)
-      tail = if restored then "The message went back to the user, who may send it again."
+      tail = if restored then RESTORED
              elsif continued then "The continued turn stopped there."
              else "The user's last message was not answered."
              end
-      message("the previous turn failed before any answer: #{one_line(summary)}. #{tail}")
+      message("#{FAILED}#{one_line(summary)}. #{tail}")
     end
 
     # @param reason [Symbol, String, nil] the cancel reason (:ctrl_c, :user…)
     # @param seconds [Numeric, nil] how long the turn had run
     # @param shown [Boolean] visible text had streamed (an `[interrupted]`
     #   model message precedes this note)
-    def cancelled(reason, seconds: nil, shown: false)
+    # @param running_tasks [Array<Hash>] {id:, command:} of this session's
+    #   background tasks still running: a Stop doesn't end them
+    def cancelled(reason, seconds: nil, shown: false, running_tasks: [])
       why = reason.to_s.empty? ? "" : " (#{reason.to_s.tr("_", "-")})"
       after = seconds ? " after #{seconds.round}s" : ""
       what = shown ? "the answer above ends where it was cut off." : "no answer had been shown."
-      message("the previous turn was cancelled#{why}#{after}; #{what}")
+      message("the previous turn was cancelled#{why}#{after}; #{what}#{still_running(running_tasks)}")
+    end
+
+    def still_running(tasks)
+      return "" if tasks.empty?
+
+      listed = tasks.first(TASKS_LISTED).map do |task|
+        command = one_line(task[:command])
+        command = "#{command[0, TASK_COMMAND_CHARS - 1]}…" if command.length > TASK_COMMAND_CHARS
+        "task #{task[:id]} (#{command})"
+      end
+      listed << "#{tasks.size - TASKS_LISTED} more (task_list)" if tasks.size > TASKS_LISTED
+      " Still running: #{listed.join(", ")}. Continue with task_wait <id> or stop with task_stop <id>."
     end
 
     def empty
       message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
     end
 
+    # The hidden nudge before a retry of an empty answer (EmptyAnswerRetry):
+    # the model never sees its empty generation, so it is told what happened.
+    def empty_retry
+      message("your last reply had no visible answer. Answer the user's last message now, briefly.")
+    end
+
     def note?(entry)
       return false unless entry.respond_to?(:[])
 
@@ -56,11 +80,41 @@ module Samagotchi
     # +messages+ plus +note+, in place of a note already at the tail (behind
     # context notes at most): failed retries leave one note, not a pile.
     def replace_trailing(messages, note)
+      without_trailing(messages) << note
+    end
+
+    # A copy of +messages+ without the note at its tail (behind context
+    # notes at most).
+    def without_trailing(messages)
       list = Array(messages).dup
+      index = trailing_index(list)
+      list.delete_at(index) if index
+      list
+    end
+
+    # The index of the note at the tail of +list+ (behind context notes at
+    # most), or nil.
+    def trailing_index(list)
       index = list.length - 1
       index -= 1 while index >= 0 && (list[index][:role] || list[index]["role"]).to_s == "system" && !note?(list[index])
-      list.delete_at(index) if index >= 0 && note?(list[index])
-      list << note
+      index >= 0 && note?(list[index]) ? index : nil
+    end
+
+    # The failure summary of the note at the tail of +messages+ (behind
+    # context notes at most) when it says a failed turn's prompt went back
+    # to the user, else nil: the prompt is not in the conversation any more
+    # (the session's last_prompt holds it), so a UI shows it from here.
+    def restored_failure(messages)
+      list = Array(messages)
+      index = trailing_index(list)
+      return nil unless index
+
+      text = (list[index][:content] || list[index]["content"]).to_s
+      prefix = "#{OPEN}#{FAILED}"
+      suffix = ". #{RESTORED}#{CLOSE}"
+      return nil unless text.start_with?(prefix) && text.end_with?(suffix)
+
+      text[prefix.length...-suffix.length]
     end
 
     # The last message is a reply cut short (`[interrupted]`).

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -50,12 +50,8 @@ module Samagotchi
       rescue StandardError
         {}
       end
-      [target.model, target.bare_model].map { |name| name.to_s.strip.downcase }.uniq.each do |key|
-        value = models.dig(key, :vision)
-        next if value.nil?
-
-        return Answer.new(value: value, reason: value ? nil : "models: #{key} sets vision: false")
-      end
+      key, value = ConfigFile.model_setting([target.model, target.bare_model], :vision, models: models)
+      return Answer.new(value: value, reason: value ? nil : "models: #{key} sets vision: false") if key
       return nil if entry.vision.nil?
 
       Answer.new(value: entry.vision, reason: entry.vision ? nil : "hosts.#{entry.name} sets vision: false")

data/lib/samagotchi/web/app.rb

@@ -13,10 +13,12 @@ require_relative "../bridge/bounded_queue"
 require_relative "../session"
 require_relative "../session_manager"
 require_relative "../session_commands"
+require_relative "../steer"
 require_relative "../host_registry"
 require_relative "../model_profile"
 require_relative "../project_scope"
 require_relative "../version"
+require_relative "../config"
 require_relative "../output_formatter"
 require_relative "../image_store"
 require_relative "../context_note"
@@ -71,6 +73,9 @@ module Samagotchi
       # @param turn_view [Boolean] the page's per-turn view (web.turn_view,
       #   the default); false is the classic row of bubbles; ?view=turn|chat
       #   overrides it for one page load
+      # @param annotate_presets [String, Array] the quick replies next to
+      #   Annotate (web.annotate_presets, "|"-separated); "" shows none. The
+      #   page parses them (annotate_presets.js).
       # @param hub [SessionHub, nil] the session projection GET /api/events
       #   streams from; without one the route answers 503
       # @param registry [HostRegistry, nil] the hosts GET /api/models lists
@@ -79,6 +84,7 @@ module Samagotchi
       #   waits for the hosts' lists
       def initialize(manager: nil, session_class: nil, state_dir: nil, public_dir: nil,
                      bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, turn_view: true, hub: nil,
+                     annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
                      registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT)
         @manager = manager || SessionManager
@@ -92,6 +98,7 @@ module Samagotchi
         @bridge_wait_timeout = bridge_wait_timeout
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @turn_view = turn_view
+        @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
         @hub = hub
         @events_heartbeat = events_heartbeat
         @events_queue = events_queue
@@ -138,6 +145,9 @@ module Samagotchi
           if (m = %r{\A/api/sessions/([^/]+)/stop\z}.match(req.path_info)) && req.post?
             return handle_stop(req, m[1])
           end
+          if (m = %r{\A/api/sessions/([^/]+)/(archive|unarchive)\z}.match(req.path_info)) && req.post?
+            return m[2] == "archive" ? handle_archive(req, m[1]) : handle_unarchive(req, m[1])
+          end
           if (m = %r{\A/api/sessions/([^/]+)/turn\z}.match(req.path_info)) && req.post?
             return handle_turn(req, m[1])
           end
@@ -224,6 +234,8 @@ module Samagotchi
         offset = sanitize_offset(req.params["offset"])
         return list_from_hub(root, sort: sort, order: order, limit: limit, offset: offset) if @hub
 
+        # Archived ones too, as the hub's: the page filters them at render.
+        scope[:include_archived] = true
         sessions = if @state_dir
                      @manager.list_sessions(state_dir: @state_dir, sort: sort, order: order, limit: limit, offset: offset,
                                             **scope)
@@ -396,6 +408,11 @@ module Samagotchi
         # spelled as GET /api/models lists it); blank means the default.
         model = (body["model"] || body["model_name"]).to_s.strip
         folder[:model_name] = model unless model.empty?
+        # preview: an idle session's first message, sent as its first turn
+        # next; the list and the notifications name the session by it
+        # until that turn is saved.
+        preview = idle ? body["preview"].to_s.strip : ""
+        folder[:title] = preview unless preview.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
         rescue ArgumentError => e
@@ -464,6 +481,7 @@ module Samagotchi
           session: session_json,
           history: read_history(id),
           messages: messages_for_display(raw_messages, parts: req.params["parts"] == "1"),
+          failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
           queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
           recap: turn_snapshot && turn_snapshot["recap"],
@@ -597,7 +615,8 @@ module Samagotchi
         client = live_bridge_client(id)
         return error_response(503, "not_live", "no live bridge for session #{id}") unless client
 
-        reply = client.post_command(line: line, client_id: body["client_id"])
+        # card: a card's action; its command events say so (no echo).
+        reply = client.post_command(line: line, client_id: body["client_id"], card: body["card"] == true)
         case reply.status
         when 202 then json_response(202, reply.json || { status: "accepted" })
         when 400 then error_response(400, reply.json&.dig("error") || "unknown_command", reply.json&.dig("detail") || "not a session command")
@@ -805,6 +824,32 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # POST /api/sessions/:id/archive: hide it (and its delegates) from the
+      # lists, keep it for good. A live idle worker is stopped first; a turn
+      # running in it or a delegate, a chi REPL's session and a scratch one
+      # are refused (409).
+      def handle_archive(_req, id)
+        result = @manager.archive_session(id, state_dir: @state_dir, wait: STOP_WAIT_SECONDS)
+        (result[:archived] + result[:discarded]).each { |sid| @hub&.touch(sid) }
+        json_response(200, { status: "archived", session_id: result[:id], archived: result[:archived],
+                             stopped: result[:stopped], discarded: result[:discarded] })
+      rescue SessionManager::OwnedByTUI
+        error_response(409, "owned_by_tui", "session #{id} is open in a chi REPL; close it there first")
+      rescue SessionManager::ArchiveRefused => e
+        error_response(409, e.reason == :scratch ? "scratch" : "busy", e.message)
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
+      # POST /api/sessions/:id/unarchive: back to the lists, delegates too.
+      def handle_unarchive(_req, id)
+        result = @manager.unarchive_session(id, state_dir: @state_dir)
+        result[:unarchived].each { |sid| @hub&.touch(sid) }
+        json_response(200, { status: "unarchived", session_id: result[:id], unarchived: result[:unarchived] })
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
       # DELETE /api/sessions/:id: the session for good. A live worker is
       # stopped first (the page's confirm says so); a chi REPL's session is
       # refused.
@@ -1038,7 +1083,11 @@ module Samagotchi
           turn_records: Array(source["turn_records"]),
           tool_records: Array(source["tool_records"]),
           active_turn: source["active_turn"],
-          active_tools: Array(source["active_tools"])
+          active_tools: Array(source["active_tools"]),
+          # The context last seen and the token sums, for the ctx meter
+          # before the next turn streams (live over saved).
+          context: source["context"],
+          tokens: source["tokens"]
         }
       end
 
@@ -1084,12 +1133,19 @@ module Samagotchi
         return nil unless saved
 
         messages = Array(session.messages)
-        since = messages.drop(saved[:covered].to_i).count { |m| (m[:role] || m["role"]).to_s == "user" }
+        since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.prompt?(m) }
         { text: saved[:text], turns_since: since }
       rescue StandardError
         nil
       end
 
+      # The step (iteration) that answered the steer at +index+: one past
+      # the model messages between it and the prompt before it.
+      def steer_step(list, index)
+        list[0...index].reverse_each.take_while { |m| !Samagotchi::Steer.prompt?(m) }
+                       .count { |m| %w[model assistant].include?((m[:role] || m["role"]).to_s) } + 1
+      end
+
       def read_history(id)
         raw = @manager.read_responses(id, since_time: nil, state_dir: @state_dir)
         raw.map { |chunk| OutputFormatter.strip(chunk) }.reject(&:empty?)
@@ -1113,6 +1169,12 @@ module Samagotchi
             filtered << { role: "note", content: Samagotchi::ContextNote.text_of(m), label: Samagotchi::ContextNote.label_of(m) }
             next
           end
+          # A plugin's steer: a row of the step that answered it, which the
+          # page finds by `step`.
+          if Samagotchi::Steer.steer?(m)
+            filtered << { role: "steer", content: content, source: (m[:source] || m["source"]).to_s, step: steer_step(list, index) }
+            next
+          end
           next if role == "system"
           next if role == "tool_response"
 
@@ -1129,7 +1191,16 @@ module Samagotchi
           message = { role: norm_role, content: stripped }
           images = m[:images] || m["images"]
           message[:images] = Array(images).map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } if norm_role == "user" && images.is_a?(Array) && !images.empty?
-          message[:html] = @markdown_renderer.render(stripped) if norm_role == "assistant" && !stripped.empty? && @markdown_renderer.available?
+          if norm_role == "assistant"
+            # What an after_turn hook presented (AnswerDisplay): rendered and
+            # copied in place of the answer, sanitised the same way; content
+            # stays the model's text, which the page finds the bubble by.
+            display = m[:display] || m["display"]
+            shown = display.is_a?(String) ? Samagotchi::OutputFormatter.strip_markup(display) : ""
+            message[:display] = shown unless shown.strip.empty?
+            rendered = message[:display] || stripped
+            message[:html] = @markdown_renderer.render(rendered) if !rendered.empty? && @markdown_renderer.available?
+          end
           message[:parts] = did if did
           filtered << message
         end
@@ -1138,6 +1209,17 @@ module Samagotchi
         []
       end
 
+      # The last turn failed and its prompt went back to the user: the
+      # prompt (session.last_prompt) and why, for the page to show after the
+      # conversation as it did live. nil otherwise.
+      def failed_turn_for(session, msgs)
+        summary = Samagotchi::TurnNote.restored_failure(msgs)
+        prompt = session.last_prompt.to_s
+        return nil if summary.nil? || prompt.strip.empty?
+
+        { prompt: prompt, summary: summary }
+      end
+
       # The parts of the assistant message at +index+, with the tool_response
       # messages right after it.
       def message_parts(list, index)
@@ -1199,6 +1281,8 @@ module Samagotchi
       def index_data_attributes(req)
         attrs = { "sessions-dir" => sessions_dir_label, "server-dir" => home_label(Dir.pwd) }
         attrs["turn-view"] = "1" if turn_view?(req.params["view"])
+        # Always there: an empty one means no presets, not the default.
+        attrs["annotate-presets"] = @annotate_presets
         dir, = scope_dir(req.params["dir"])
         root = dir && ProjectScope.root_for(dir)
         if root

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

@@ -10,6 +10,8 @@ export const ROW_STATUS = Object.freeze({
   RUNNING: "running",
   OK: "ok",
   ERROR: "error",
+  // A task_wait the user's Stop ended (the task itself runs on).
+  STOPPED: "stopped",
 });
 
 // What a row shows for its tool: a plugin tool's label ("chrome:
@@ -79,7 +81,7 @@ export function addCompleted(model, event = {}) {
     });
     row = synthesized.row;
   }
-  row.status = event.activity?.status === "error" ? ROW_STATUS.ERROR : ROW_STATUS.OK;
+  row.status = completedStatus(event.activity?.status);
   row.output = event.output || "";
   row.output_truncated = !!event.output_truncated;
   if (event.activity?.params) row.params = event.activity.params;
@@ -89,6 +91,13 @@ export function addCompleted(model, event = {}) {
   return row;
 }
 
+// A completed call's row status from the server's: error, stopped, else ok.
+export function completedStatus(status) {
+  if (status === "error") return ROW_STATUS.ERROR;
+  if (status === "stopped") return ROW_STATUS.STOPPED;
+  return ROW_STATUS.OK;
+}
+
 // Mark a turn's activity model as finalized (rows stay; rendering collapses).
 export function finalizeActivity(model) {
   if (model) model.finalized = true;

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

@@ -0,0 +1,26 @@
+// Annotate presets: quick replies next to "Annotate" in the selection bubble
+// (web.annotate_presets, "Agreed|Could you please elaborate?"). A preset
+// fills the composer with the quote and its text as the note; it never
+// sends. Its own module, not more exports on annotations.js: static files
+// are cached at unversioned URLs, and a fresh app.js importing a missing
+// export from a cached annotations.js would fail to link.
+
+export const MAX_PRESETS = 5;
+
+// The presets in +raw+ ("a|b|c"): trimmed, blanks and repeats dropped, at
+// most MAX_PRESETS. A preset can't hold "|".
+export function parsePresets(raw) {
+  const out = [];
+  for (const part of String(raw ?? "").split("|")) {
+    const text = part.trim();
+    if (text && !out.includes(text)) out.push(text);
+    if (out.length === MAX_PRESETS) break;
+  }
+  return out;
+}
+
+// The quote +block+ (from quoteBlock, ending in a blank line) with +text+
+// as its note.
+export function presetNote(block, text) {
+  return `${block}${text}`;
+}

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

@@ -65,3 +65,16 @@ export function appendQuote(value, block) {
   const before = String(value ?? "").replace(/\s+$/, "");
   return before ? `${before}\n\n${block}` : block;
 }
+
+// The Annotate bar's left edge (fixed position, px) under the selection's
+// last line (+rect+: its {left, right}): right-aligned to where the
+// selection ends; where that would clamp to the page gutter (a selection
+// ending near the bubble's left edge), left-aligned to where the selection
+// starts on that line instead, so the bar stays by the text.
+// @param width the bar's width; @param viewport the window's inner width
+export function annotateBarLeft(rect, width, viewport, gutter = 8) {
+  const max = viewport - width - gutter;
+  const right = rect.right - width;
+  const left = right < gutter ? rect.left : right;
+  return Math.max(Math.min(left, max), gutter);
+}