samagotchi 0.75.0 → 0.77.0

data/lib/samagotchi/terminal_ui/model_segments_text.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../memory_bundle/index_size"
+
+module Samagotchi
+  class TerminalUI
+    # A session's rows per model in /stats (the snapshot's model_segments).
+    # The four public model_segment_* labels are the words the web's ctx
+    # tooltip shares (ctx.js; spec/shared/labels_matrix.json model_segments).
+    # Rows come symbol- or string-keyed (the attached TUI's as JSON).
+    # Included by Formatting, whose cost_text and speed_text it uses.
+    module ModelSegmentsText
+      # A row's model: its ref; the rows folded past the cap ("3 earlier
+      # segments", told by folded_segments); a session's turns from before
+      # turns named their model ("earlier turns").
+      def model_segment_label(row)
+        folded = segment_value(row, :folded_segments).to_i
+        return "#{folded} earlier segments" if folded.positive?
+
+        ref = segment_value(row, :model_ref).to_s
+        ref.empty? ? "earlier turns" : ref
+      end
+
+      # "6.0k in / 40 out": the row's prompt and completion sums.
+      def model_segment_tokens_text(row)
+        count = ->(key) { MemoryBundle::IndexSize.count_text(segment_value(row, key).to_i) }
+        "#{count.call(:prompt_sum)} in / #{count.call(:completion_sum)} out"
+      end
+
+      # "$0.42", "~$0.12", "$0.42 + ~$0.12" (reported + estimated); "" for none.
+      def model_segment_cost_text(row)
+        [cost_text(segment_value(row, :cost_sum)), cost_text(segment_value(row, :cost_estimate_sum), estimate: true)]
+          .reject(&:empty?).join(" + ")
+      end
+
+      # "switch prefill 3.0k uncached prompt ≈$0.0060": what the switch to the
+      # row's model prefilled (its cost an estimate from the configured
+      # price, left out without one); "" for none.
+      def model_segment_prefill_text(row)
+        tokens = segment_value(row, :prefill_tokens).to_i
+        return "" unless tokens.positive?
+
+        cost = cost_text(segment_value(row, :prefill_cost_estimate))
+        "switch prefill #{MemoryBundle::IndexSize.count_text(tokens)} uncached prompt#{" ≈#{cost}" unless cost.empty?}"
+      end
+
+      private
+
+      def segment_value(row, key)
+        row[key] || row[key.to_s]
+      end
+
+      # /stats' models: block, in place of the tokens line: a row per
+      # segment (model, when, turns, tokens, its average speed and cost), a
+      # switch's prefill under the row of the model switched to, and the
+      # total (the tokens line's sums and breakdown).
+      def models_block_lines(segments, turns, tokens, token_src_label)
+        dated = segment_dates_differ?(segments)
+        cells = segments.map do |row|
+          speed = speed_text(segment_value(row, :avg_decode_tps), segment_value(row, :tps_source))
+          [model_segment_label(row), segment_span_text(row, dated: dated), turns_text(segment_value(row, :turns)),
+           [model_segment_tokens_text(row), speed, model_segment_cost_text(row)].reject(&:empty?).join("  ")]
+        end
+        total = ["total", "", turns_text(turns),
+                 "#{MemoryBundle::IndexSize.count_text(tokens[:prompt_sum].to_i)} in / " \
+                 "#{MemoryBundle::IndexSize.count_text(tokens[:completion_sum].to_i)} out " \
+                 "(all requests, #{token_src_label}#{token_breakdown_text(tokens)})"]
+        widths = (0..2).map { |i| (cells + [total]).map { |cell| cell[i].length }.max }
+        row_text = ->(cell) { cell.each_with_index.map { |text, i| i < 3 ? text.ljust(widths[i]) : text }.join("  ") }
+        lines = []
+        segments.each_with_index do |row, i|
+          lines << "#{i.zero? ? "models:".ljust(18) : " " * 18}#{row_text.call(cells[i])}"
+          prefill = model_segment_prefill_text(row)
+          lines << "#{" " * 20}└ #{prefill}" unless prefill.empty?
+        end
+        lines << "#{" " * 18}#{row_text.call(total)}"
+      end
+
+      def turns_text(count)
+        "#{count.to_i} #{count.to_i == 1 ? "turn" : "turns"}"
+      end
+
+      # "10:02–10:41", "10:43–now" (a row with a turn running); with the
+      # day ("Oct 16 10:02") when the rows span more than one day.
+      def segment_span_text(row, dated:)
+        started = segment_time(segment_value(row, :started_at))
+        ended = segment_time(segment_value(row, :ended_at))
+        format_time = lambda { |time|
+          if time
+            time.strftime(dated ? "%b %-d %H:%M" : "%H:%M")
+          else
+            "?"
+          end
+        }
+        "#{format_time.call(started)}–#{ended ? format_time.call(ended) : "now"}"
+      end
+
+      def segment_dates_differ?(segments)
+        days = segments.flat_map { |row| [segment_value(row, :started_at), segment_value(row, :ended_at)] }
+                       .filter_map { |stamp| segment_time(stamp)&.strftime("%F") }
+        days.uniq.size > 1
+      end
+
+      def segment_time(stamp)
+        stamp ? Time.iso8601(stamp.to_s).localtime : nil
+      rescue ArgumentError
+        nil
+      end
+
+      # The row the session's last speed came from: the newest with one.
+      def last_speed_label(segments)
+        row = segments.reverse_each.find { |segment| segment_value(segment, :last_decode_tps) }
+        row && model_segment_label(row)
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -89,7 +89,9 @@ module Samagotchi
       # hint). Other events change nothing.
       def take_event(event)
         case event[:type]
-        when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
+        # usage nil (a /model whose window didn't resolve) clears it.
+        when :context_status
+          update(context: event[:usage] ? { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] } : nil)
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
           update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]

data/lib/samagotchi/terminal_ui.rb

@@ -873,6 +873,7 @@ module Samagotchi
                   end
         if command
           show_command_result(command)
+          refresh_status_row(clear_unknown_context: true) if command.changed.include?(:model)
           persist_recent_history(input) if command.shell
           return
         end
@@ -1400,9 +1401,10 @@ module Samagotchi
 
     # The status row under the prompt, from the Engine's state (what a
     # worker hands an attached TUI when it joins): drawn when it changed.
-    def refresh_status_row
+    def refresh_status_row(clear_unknown_context: false)
       state = @engine.session_state_snapshot.merge(model_name: @effective_model_name)
       @status_row.take_state(state, default_model: @default_model_name)
+      @status_row.update(context: nil) if clear_unknown_context && state.key?(:context_status) && state[:context_status].nil?
       refresh_children_status
     end
 
@@ -1463,13 +1465,13 @@ module Samagotchi
     def drain_pending_question?
       pq = @pending_question_event
       # Also check Engine's persisted pending (covers resume)
-      pq ||= @engine.pending_question
+      pq ||= @engine.pending_question&.to_h
       return false unless pq
 
       # If the pending no longer matches the engine's current pending (stale
       # event after sync handler already answered and cleared), discard.
       current = @engine.pending_question
-      if current && (pq[:id] || pq["id"]).to_s != (current[:id] || current["id"]).to_s
+      if current && (pq[:id] || pq["id"]).to_s != current.id.to_s
         @pending_question_event = nil
         return false
       end

data/lib/samagotchi/tool_output_cut.rb

@@ -38,7 +38,7 @@ module Samagotchi
     HEAD_CUT = /\[cut: \d+ of \d+ chars; read it in parts\]\z/
 
     # What a web row keeps of a tool's output, on a reload
-    # (Web::MessageParts) and a mid-turn join (Bridge::TurnAccumulator): the
+    # (MessageParts) and a mid-turn join (Bridge::TurnAccumulator): the
     # row shows 300 chars and the rest on hover. A longer one keeps its head
     # and tail (preview).
     WEB_PREVIEW_CHARS = 2000

data/lib/samagotchi/tool_response.rb

@@ -29,7 +29,7 @@ module Samagotchi
     # Runs +calls+ in order (ToolRunner#run each), yielding each run and its
     # index as it finishes. +emit+ takes the dispatch events, the runner's
     # own go to +on_stream_event+.
-    # @return [Array<Hash>] the runs
+    # @return [Array<ToolRun>] the runs
     def run_batch(runner, calls, iteration:, emit:, on_stream_event:, cap:)
       emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
       runs = calls.each_with_index.map do |call, index|
@@ -45,7 +45,7 @@ module Samagotchi
     # The runs' activity, for the turn's tool list (none for a call whose
     # dispatcher raised).
     def activities(runs)
-      runs.filter_map { |run| run[:activity] }
+      runs.filter_map(&:activity)
     end
 
     # The native loop's entry for a batch: the capped outputs joined, every image
@@ -53,14 +53,14 @@ module Samagotchi
     # each on its own tool row), and the saved-only fields one per call:
     # +ids+ (ToolIds.next_ids) as tool_ids.
     def joined(runs, ids:)
-      images = runs.flat_map { |run| Array(run[:images]) }
-      entry = { role: "tool_response", content: runs.map { |run| run[:capped_output] }.join(SEPARATOR) }
+      images = runs.flat_map { |run| Array(run.images) }
+      entry = { role: "tool_response", content: runs.map(&:capped_output).join(SEPARATOR) }
       unless images.empty?
         entry[:images] = images
-        entry[:image_counts] = runs.map { |run| Array(run[:images]).size }
+        entry[:image_counts] = runs.map { |run| Array(run.images).size }
       end
-      saved = { tool_params: runs.map { |run| run[:shown_params] }, tool_labels: runs.map { |run| run[:shown_label] },
-                tool_diffs: runs.map { |run| run[:diff] }, tool_refs: runs.map { |run| run[:refs] } }
+      saved = { tool_params: runs.map(&:shown_params), tool_labels: runs.map(&:shown_label),
+                tool_diffs: runs.map(&:diff), tool_refs: runs.map(&:refs) }
       saved.each { |key, values| entry[key] = values if values.any? }
       entry[:tool_ids] = ids
       entry
@@ -70,12 +70,12 @@ module Samagotchi
     # call by +tool_call_id+, and its chi-owned id (a one-id +ids+, as
     # #joined's tool_ids).
     def single(run, tool_call_id:, ids:)
-      entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call_id }
-      entry[:images] = run[:images] if run[:images]&.any?
-      entry[:tool_params] = run[:shown_params] if run[:shown_params]
-      entry[:tool_labels] = run[:shown_label] if run[:shown_label]
-      entry[:tool_diffs] = run[:diff] if run[:diff]
-      entry[:tool_refs] = run[:refs] if run[:refs]
+      entry = { role: "tool_response", content: run.capped_output, tool_call_id: tool_call_id }
+      entry[:images] = run.images if run.images&.any?
+      entry[:tool_params] = run.shown_params if run.shown_params
+      entry[:tool_labels] = run.shown_label if run.shown_label
+      entry[:tool_diffs] = run.diff if run.diff
+      entry[:tool_refs] = run.refs if run.refs
       entry[:tool_ids] = ids
       entry
     end

data/lib/samagotchi/tool_row_fields.rb

@@ -7,7 +7,7 @@ require_relative "file_ref"
 module Samagotchi
   # The fields a tool row shows beyond its params, built from the call in
   # one place for every path: the live tool_call_started (ToolRunner#run)
-  # and a reload from the saved call (Web::MessageParts#tool_part). The
+  # and a reload from the saved call (MessageParts#tool_part). The
   # bridge's snapshot and replay (Bridge::TurnAccumulator) copy them by
   # these lists, so a new field is added here and travels everywhere.
   #

data/lib/samagotchi/tool_runner.rb

@@ -15,6 +15,17 @@ require_relative "memory_bundle/index_sync"
 require_relative "memory_bundle/index_size"
 
 module Samagotchi
+  # One call's result from ToolRunner#run, read by ToolResponse (the loops'
+  # tool_response entries) and the loops' activity list. Fields a call didn't
+  # produce (images, shown_params, shown_label, refs, diff, output_file) are nil.
+  ToolRun = Data.define(:output, :capped_output, :truncated, :activity, :images, :shown_params, :shown_label, :refs, :diff,
+                        :output_file) do
+    def initialize(output: nil, capped_output: nil, truncated: nil, activity: nil, images: nil, shown_params: nil,
+                   shown_label: nil, refs: nil, diff: nil, output_file: nil)
+      super
+    end
+  end
+
   # The single per-call path both loops use: the tool_call_started and
   # tool_call_completed events, the guardrail gate (before_tool_call hooks
   # and their veto), dispatch through KernelLoop, the after_tool_call hook
@@ -40,7 +51,7 @@ module Samagotchi
     end
 
     # @param call_index [Integer] 1-based position of the call in its batch
-    # @return [Hash] output:, capped_output:, truncated:, activity:,
+    # @return [ToolRun] output:, capped_output:, truncated:, activity:,
     #   output_file: (the saved whole output of a cut execute result),
     #   images: (refs) when the tool returned images the model gets to see, and
     #   shown_params: the params line the live row showed, and shown_label:
@@ -135,14 +146,10 @@ module Samagotchi
       fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
                                status: status || "error", call: call.dup, elapsed_ms: elapsed_ms, result: tool_text })
 
-      run = { output: output, capped_output: capped, truncated: truncated, activity: result[:activity] }
-      run[:images] = images if images&.any?
-      run[:shown_params] = params if params && plugin_tool?(call[:name])
-      run[:shown_label] = label if label
-      run[:refs] = refs unless refs.empty?
-      run[:diff] = diff if diff
-      run[:output_file] = output_file if output_file
-      run
+      ToolRun.new(output: output, capped_output: capped, truncated: truncated, activity: result[:activity],
+                  images: images&.any? ? images : nil,
+                  shown_params: params && plugin_tool?(call[:name]) ? params : nil,
+                  shown_label: label, refs: refs.empty? ? nil : refs, diff: diff, output_file: output_file)
     end
 
     private

data/lib/samagotchi/toolkit.rb

@@ -77,16 +77,17 @@ module Samagotchi
         super
       end
 
-      # What the prompt carries of it: the declared names, the reachable
-      # and removed ones (the not-loaded line, find_tools' chi line), when
-      # either list has any the kit name the line gives, and the kit's
-      # prompt text. Two equal keys build the same prompt (/toolkit's "no
-      # change", its cost).
-      def prompt_key
-        [declared.map(&:name), reachable, removed, reachable.empty? && removed.empty? ? nil : resolved.name,
-         resolved.prompt]
+      # What the prompt carries before the kit's prompt text: the declared
+      # names, reachable and removed ones (the not-loaded line, find_tools'
+      # chi line), and, when either list has any, the kit name the line gives.
+      def tools_key
+        [declared.map(&:name), reachable, removed, reachable.empty? && removed.empty? ? nil : resolved.name]
       end
 
+      # What the prompt carries of it, including the kit's prompt text. Two
+      # equal keys build the same prompt (/toolkit's "no change", its cost).
+      def prompt_key = [*tools_key, resolved.prompt]
+
       # What the UIs show (the snapshot, command_ran): nil when it declares
       # every tool on full (full, full +delegate), which has no chip.
       # +left_out+ is +reachable+ and +removed+ together; +prompt+ (the

data/lib/samagotchi/toolkit_command.rb

@@ -129,9 +129,9 @@ module Samagotchi
 
     # What the confirm says is read again: from the tools on (the front of
     # every request), or from the kit's prompt text on when only that
-    # changes (Explained#prompt_key's last part: a kit on full's tools).
+    # changes (Explained#tools_key is unchanged: only a kit's prompt text).
     def reread_line(before, after)
-      if before.prompt_key[0...-1] == after.prompt_key[0...-1]
+      if before.tools_key == after.tools_key
         "The kit's prompt text is in the system prompt: the prompt is read again from it on."
       else
         "The tools are the front of every request: the whole prompt is read again from them on."

data/lib/samagotchi/tools/builtins.rb

@@ -144,11 +144,7 @@ module Samagotchi
 
       # The XDG dirs set in +env+, made absolute (nothing for an unset one).
       def xdg_absolute(env = ENV)
-        set = ->(key) { !env.fetch(key, "").to_s.strip.empty? }
-        dirs = {}
-        dirs["XDG_STATE_HOME"] = Paths.state_home(env: env) if set.call("XDG_STATE_HOME")
-        dirs["XDG_CONFIG_HOME"] = Paths.config_home(env: env) if set.call("XDG_CONFIG_HOME")
-        dirs
+        Paths.absolute_xdg(env: env)
       end
 
       # The unsets that keep a `chi --model X` worker's default from passing

data/lib/samagotchi/tools/delegate_relay.rb

@@ -37,7 +37,7 @@ module Samagotchi
       # @param relay [#open_question, #relay_desk] Peers#relay
       # @return [Boolean] a relay can take this question
       def relayable?(relay, question)
-        !relay.nil? && question.is_a?(Hash) && question[:kind].to_s == Guardrails::Approval::KIND
+        !relay.nil? && question.is_a?(PendingQuestion) && question.kind.to_s == Guardrails::Approval::KIND
       end
 
       # Relay the child's pending approval and wait until it settles.
@@ -45,7 +45,7 @@ module Samagotchi
       # @return [Outcome]
       def call(child_id, question, relay:, state_dir:, more: 0)
         child = Session.load(child_id, state_dir: state_dir)
-        qid = question[:id].to_s
+        qid = question.id.to_s
         desk = relay.relay_desk
         relay_id = desk.open(child_id: child_id, child_question_id: qid)
         client = BridgeClient.discover(child_id, session_dir: Session.session_dir(child_id, state_dir: state_dir))
@@ -70,7 +70,7 @@ module Samagotchi
           end
 
           pending = Session.load(child_id, state_dir: state_dir).pending_question
-          pending && pending[:id].to_s == qid ? nil : "answered_on_child"
+          pending && pending.id.to_s == qid ? nil : "answered_on_child"
         rescue ArgumentError
           "child_gone"
         end
@@ -175,7 +175,7 @@ module Samagotchi
           return if waiting.empty?
 
           child_id, question = waiting.first
-          @done[question[:id].to_s] = true
+          @done[question.id.to_s] = true
           outcome = DelegateRelay.call(child_id, question, relay: @relay, state_dir: @state_dir, more: waiting.size - 1)
           @on_outcome.call(child_id, outcome)
           # The next one, if any, right after.
@@ -186,7 +186,7 @@ module Samagotchi
         # @return [Integer]
         def count = waiting.size
 
-        # @return [Array<Array(String, Hash)>] [child id, pending question],
+        # @return [Array<Array(String, PendingQuestion)>] [child id, pending question],
         #   oldest question first
         def waiting
           rows = SessionManager.children_of(@parent_id, state_dir: @state_dir).select do |row|
@@ -194,10 +194,10 @@ module Samagotchi
           end
           rows.filter_map do |row|
             pending = Session.load(row[:id], state_dir: @state_dir).pending_question
-            [row[:id], pending] if pending && pending[:id].to_s == row[:waiting_id].to_s
+            [row[:id], pending] if pending && pending.id.to_s == row[:waiting_id].to_s
           rescue ArgumentError
             nil
-          end.sort_by { |_, pending| pending[:created_at].to_s }
+          end.sort_by { |_, pending| pending.created_at.to_s }
         end
 
         private

data/lib/samagotchi/tools/delegate_wait.rb

@@ -91,7 +91,7 @@ module Samagotchi
           # asked), the relayed question no longer reported: a turn that
           # ends with no reply during the relay's POST or after it still
           # ends the wait.
-          baseline = ReplyWait.baseline_of(wait.session, question_id: wait.question[:id])
+          baseline = ReplyWait.baseline_of(wait.session, question_id: wait.question.id)
         end
       rescue ArgumentError => e
         "Error: #{e.message}"

data/lib/samagotchi/tools/web_fetch.rb

@@ -3,7 +3,6 @@
 require "net/http"
 require "uri"
 require "ipaddr"
-require "nokogiri"
 require_relative "../version"
 
 module Samagotchi
@@ -128,6 +127,9 @@ module Samagotchi
       def self.extract_text_from_html(html)
         return "Error: empty HTML response" if html.nil? || html.empty?
 
+        # Load lazily so workers don't pay for Nokogiri on every start.
+        require "nokogiri"
+
         doc = Nokogiri::HTML(html)
 
         # Extract noscript text before removing it

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -43,7 +43,7 @@ require_relative "../recap_store"
 require_relative "markdown_renderer"
 require_relative "capabilities"
 require_relative "editor"
-require_relative "message_parts"
+require_relative "../message_parts"
 require_relative "session_summary"
 require_relative "../log"
 require_relative "../paths"
@@ -855,7 +855,7 @@ module Samagotchi
           current_turn = turn_snapshot["current_turn"]
           current_turn ? current_turn["pending_question"] : turn_snapshot["pending_question"]
         elsif owner&.worker?
-          session.pending_question
+          session.pending_question&.to_h
         end
       end
 
@@ -1794,6 +1794,9 @@ module Samagotchi
           # before the next turn streams (live over saved).
           context: source["context"],
           tokens: source["tokens"],
+          # The tokens, cost and speeds per model (SessionMetrics'
+          # model_segments; none with one model, or from an older file).
+          model_segments: Array(source["model_segments"]),
           # The memory indexes the session's prompt holds (the ctx tooltip).
           memory_index: source["memory_index"]
         }

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

@@ -45,6 +45,7 @@ import { elementOf, emptyAnswerTemplate } from "./turn_html.js";
 import { createBubbles, hintEl, outputBubbleTemplate, setBubbleDelivery } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView, FOLD_MS } from "./stage_view.js";
+import { createMarkdownPlace } from "./markdown_place.js";
 import { reducedMotion, STAGE_GAP } from "./stage_frame.js";
 import { chainNeighbours, continueRefusal, continuedText, freshLink, openChildrenTemplate, openerText, openTitle } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
@@ -86,6 +87,7 @@ import { liveSlots } from "./stage_model.js";
 import { currentGen } from "./turn_model.js";
 import { toolName } from "./activity.js";
 import { toastBottom } from "./toast_place.js";
+import { createToasts } from "./toasts.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -231,26 +233,25 @@ const viewArgs = {
   // the route (its sidecar features).
   taskStop: createTaskStopper({ sessionId: () => selected, features: () => current.workerFeatures }),
 };
+const markdownPlace = createMarkdownPlace({
+  capabilities: () => pageCapabilities,
+  renderText,
+  roots: () => turnRoots(),
+  touchedFiles,
+  currentDir: () => current.dir,
+  linkRefs,
+  applyFinalAnswer,
+  findInTurnRoots: (selector) => findInTurnRoots(selector),
+  normalize,
+  pairAnswerRefs,
+});
+const { renderMarkdown, linkRefsIn, applyFinalMarkdown, linkTextRefs } = markdownPlace;
 const turnDom = view === "stage"
   ? createStageView({
     ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl,
     renderMarkdown, linkRefs: linkRefsIn,
   })
   : createTurnView(viewArgs);
-// A text the page already shows as its markdown HTML (POST /api/render,
-// sanitised there), or null: markdown off here (no request), or a failed
-// read (the raw text stays).
-function renderMarkdown(text) {
-  if (pageCapabilities.display !== true) return Promise.resolve(null);
-  return renderText(text)
-    .then((d) => (typeof d?.html === "string" && d.html ? d.html : null))
-    .catch(() => null);
-}
-// The `path:line` refs in one rendered text (the stage's asking slot, a
-// kept reply), as linkTextRefs links the answers'.
-function linkRefsIn(el) {
-  linkRefs(el, touchedFiles(turnRoots()), current.dir);
-}
 // Where a running turn's rows can be: the history, and the stage while it
 // holds a turn (lookups by id, copy, annotate, card actions).
 function turnRoots() {
@@ -978,32 +979,6 @@ async function readTurnEnd() {
   } catch(_){}
 }
 
-// The turn's answer as its rendered markdown and with its plugin refs,
-// once it is final (the turn-end read, an answer_display re-read:
-// answer_refs.js applyFinalAnswer); then the refs.
-function applyFinalMarkdown(messages) {
-  applyFinalAnswer(messages, findInTurnRoots(".bubble.output"), normalize);
-  linkTextRefs();
-}
-
-// The refs on the answers' and closed steps' texts, on this page: first
-// each answer's own (a plugin's, answer_refs.js), then the `path:line`
-// refs that name a file the session's rows (and cards) touched
-// (ref_scan.js), which leave a plugin's alone. Not mid-stream: at a
-// turn's end and after a reload's render. A ref already made stays as it
-// is.
-function linkTextRefs() {
-  const roots = turnRoots();
-  const touched = touchedFiles(roots);
-  for (const root of roots) {
-    for (const el of root.querySelectorAll(".bubble.output")) pairAnswerRefs(el);
-  }
-  if (!touched.size) return;
-  for (const root of roots) {
-    for (const el of root.querySelectorAll(".bubble.output, .gen:not(.live) > .gen-text")) linkRefs(el, touched, current.dir);
-  }
-}
-
 function seedSeenFromDom() {
   shownTexts.seed(findInTurnRoots(".bubble").map((b) => normalize(b.textContent)));
 }
@@ -1475,7 +1450,7 @@ async function handleSendTurn({ delivery: chosen = null } = {}) {
     // The chips stay (uploaded ones keep their ref, to sentTo) for another try: an
     // image refused (bad_image, too_large, bad_images) says why below.
     if (e.code === "owned_by_tui") {
-      if (sentTo !== selected) return alert(e.message);
+      if (sentTo !== selected) return showToast(cantText(`send to ${sentTo.slice(0, 8)}`, e), null, { sticky: true });
       current.owner = "tui";
       updateComposerMode();
       return;
@@ -1485,7 +1460,7 @@ async function handleSendTurn({ delivery: chosen = null } = {}) {
     if (e.code === "not_found") return leaveGoneSession(sentTo, "not_found");
     // A /queue to a worker that can't queue (it would steer): its words, the text kept.
     if (e.code === "delivery_unavailable" && sentTo === selected) return addCommandBubble({ label: null, line, text: e.body?.detail || e.message, failed: true });
-    alert(e.message);
+    showToast(cantText("send", e), null, { sticky: true });
   } finally {
     actionBtn.disabled = current.owner === "tui";
     promptEl.focus();
@@ -1502,13 +1477,14 @@ const composerCommands = createComposerCommands({
   refreshHistory: () => refreshHistory(),
   failed: (line, text) => addCommandBubble({ label: null, line, text, failed: true }),
   // As handleSendTurn says a turn's failure after a switch.
-  failedElsewhere: (line, text) => alert(`${line}: ${text}`),
+  failedElsewhere: (line, text, id) => showToast(cantText(`run ${line} in ${id.slice(0, 8)}`, text), null, { sticky: true }),
   ownedByTui: () => {
     current.owner = "tui";
     updateComposerMode();
   },
   composer: {
     busy: () => { actionBtn.disabled = true; },
+    text: () => promptEl.value,
     clear: () => clearComposer(),
     done: () => {
       actionBtn.disabled = current.owner === "tui";
@@ -2052,24 +2028,11 @@ function placeToast() {
     else root.removeProperty("--toast-bottom");
   }
 }
+const toasts = createToasts({ el: $("#toast"), onChange: placeToast });
 // The model panel opening, closing or changing height (its list filters).
 new ResizeObserver(() => placeToast()).observe(document.getElementById("modelPanel"));
 
-// sticky: stays until its action or its ✕ (else gone after 6 s). +text+:
-// words, or a template (chains.js openChildrenTemplate: a link in it, a
-// delegate a continue waits for, opens that session and hides the toast).
-let toastTimer = null;
-function showToast(text, action = null, { sticky = false } = {}) {
-  const el = $("#toast");
-  const hide = () => { el.hidden = true; };
-  render(html`<span @click=${(e) => { if (e.target.closest?.("a[href]")) hide(); }}>${text}</span>${action
-    ? html`<button type="button" class="toast-action" @click=${() => { hide(); action.run(); }}>${action.label}</button>`
-    : nothing}${sticky ? html`<button type="button" class="toast-close" title="Dismiss" aria-label="Dismiss" @click=${hide}>✕</button>` : nothing}`, el);
-  el.hidden = false;
-  placeToast();
-  clearTimeout(toastTimer);
-  if (!sticky) toastTimer = setTimeout(hide, 6000);
-}
+function showToast(text, action = null, options = {}) { toasts.show(text, action, options); }
 
 // Annotate (annotate_bar.js): a selection in the conversation offers
 // "Annotate" and the presets, which append a quote to the composer, and the

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

@@ -230,7 +230,7 @@ export function chainRowsTemplate(f, { activeId = null, now = Date.now() } = {})
     const ago = relativeTime(s.updated_at || s.created_at || "", now);
     const tip = `${s.id} · ${s.status || ""}${ago ? ` · updated ${ago}` : ""}`;
     return html`<div class=${cls.join(" ")} data-id=${s.id} style=${"--depth:1"} role=${"listitem"}><button type="button" class="fr-open"
-      title=${tip}>${rowDotTemplate(s, waiting)}<span class="cr-day">#${n}</span>${
+      title=${tip}>${rowDotTemplate(s, waiting)}<span class="cr-n">#${n}</span>${
       date ? html`<span class=${date.length > 10 ? "cr-date timed" : "cr-date"}>${date}</span>` : nothing}<span class="fr-preview">${s.recap || chainTitle(s, byId)}</span>${
       rowBadgesTemplate(waiting, stopped)}${s.archived ? archivedBadge : nothing}</button></div>`;
   });