samagotchi 0.48.0 → 0.50.0

data/lib/samagotchi/model_profile.rb

@@ -40,7 +40,7 @@ module Samagotchi
                 :system_prefix, :user_prefix, :assistant_prefix,
                 :model_prefix,
                 :stop_sequences, :tool_decl_format,
-                :image_template
+                :image_template, :image_check_token
 
     def initialize(config)
       @name = config[:name]
@@ -65,10 +65,12 @@ module Samagotchi
       # How the chat template wraps an image's media marker ("%{marker}"),
       # or nil when chi doesn't know it yet (native images are refused).
       @image_template = config[:image_template]
+      # A token the server's chat template must contain for images to be
+      # sent (VisionSupport); defaults to the template's opening token.
+      @image_check_token = config[:image_check_token] || image_open_token
     end
 
-    # The token the image template opens with, e.g. "<|vision_start|>": the
-    # server's chat template must use it too (VisionSupport).
+    # The token the image template opens with, e.g. "<|vision_start|>".
     def image_open_token
       image_template&.split("%{marker}")&.first.to_s
     end
@@ -92,7 +94,12 @@ module Samagotchi
         assistant_prefix: "",
         model_prefix: "",
         stop_sequences: ["<turn|>", "<|tool_response>"],
-        tool_decl_format: :gemma4
+        tool_decl_format: :gemma4,
+        # The bare marker: llama.cpp's mtmd wraps Gemma 4 images in
+        # <|image>…<image|> itself, as its chat path does (V13 spike). The
+        # template writes <|image|> for an image part; Gemma 3's doesn't.
+        image_template: "%{marker}",
+        image_check_token: "<|image|>"
       )
     end
 

data/lib/samagotchi/plugin/context.rb

@@ -25,9 +25,11 @@ module Samagotchi
     # model's memory overlay key (ctx.model, ctx.model_key).
     # +steer+ takes (text, label), +stop_turn+ and +stop_generation+
     # (reason, label), each true when it acted on a running turn.
+    # +frontend+ returns the Engine's interface (:repl, :worker,
+    # :non_interactive), which ctx.frontend names for plugins.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
                       :ask_model, :model_name, :model_key, :state_dir, :scratch, :llm_context, :steer, :stop_turn, :stop_generation,
-                      keyword_init: true)
+                      :frontend, keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -103,6 +105,16 @@ module Samagotchi
       # Whether the session is a `chi scratch` one (deleted when it ends).
       def scratch? = !!@host.scratch&.call
 
+      # ctx.frontend's values, by the Engine's interface.
+      FRONTENDS = { repl: :repl, non_interactive: :one_shot, worker: :worker }.freeze
+
+      # What runs the session, read now (the host sets it after the plugins
+      # load): :repl (the REPL, -p without --non-interactive), :one_shot
+      # (-p --non-interactive: one turn, then exit) or :worker (a session
+      # worker: the web, an attached TUI). A host without one is :worker.
+      # @return [Symbol]
+      def frontend = FRONTENDS.fetch(@host.frontend&.call, :worker)
+
       # Whether the session is a delegate child (Session#delegate?): a task
       # another session handed over, not the user's own.
       def delegate? = !!saved_session&.delegate?

data/lib/samagotchi/prompt.rb

@@ -59,30 +59,45 @@ module Samagotchi
       [text + prefill_for(messages, profile, prefill), images]
     end
 
-    def self.image_lines(items, profile, images)
-      return "" if items.empty?
+    # A message's image lines: +text+ holds them all in order (what goes
+    # inside the message); +placeholders+ and +markers+ split the lines of
+    # images not sent from the sent ones' media markers, for Gemma's tool
+    # response, whose markers go after the block.
+    ImageLines = Data.define(:lines) do
+      def text = join(lines)
+      def placeholders = join(lines.reject(&:last))
+      def markers = join(lines.select(&:last))
+
+      private
+
+      def join(subset) = subset.empty? ? "" : "\n#{subset.map(&:first).join("\n")}"
+    end
 
+    def self.image_lines(items, profile, images)
       lines = items.each_with_index.map do |item, index|
-        next item.placeholder unless item.sent?
-        next ImageRef.placeholder(item.ref, ImagePlan::CANT_SEE) unless profile.image_template
+        next [item.placeholder, false] unless item.sent?
+        next [ImageRef.placeholder(item.ref, ImagePlan::CANT_SEE), false] unless profile.image_template
 
         images << item.data
-        "[image #{index + 1}: #{ImageRef.name(item.ref)}] " \
-          "#{Kernel.format(profile.image_template, marker: ImagePlan::NATIVE_PLACEHOLDER)}"
+        ["[image #{index + 1}: #{ImageRef.name(item.ref)}] " \
+         "#{Kernel.format(profile.image_template, marker: ImagePlan::NATIVE_PLACEHOLDER)}", true]
       end
-      "\n#{lines.join("\n")}"
+      ImageLines.new(lines: lines)
     end
 
     def self.format_with_turn_markers(messages, profile, suffixes)
       last_user = messages.rindex { |m| m[:role] == "user" } || -1
       parts = messages.each_with_index.map do |m, index|
-        content = prompt_content_for(m, profile) + suffixes[index]
+        lines = suffixes[index]
+        content = prompt_content_for(m, profile) + (m[:role] == "tool_response" ? lines.placeholders : lines.text)
         previous = index.positive? ? messages[index - 1][:role] : nil
         following = messages[index + 1]&.dig(:role)
         case m[:role]
         when "tool_response"
-          # Inside the model's turn; closed when another role follows.
-          tool_response_blocks(content, profile) +
+          # Inside the model's turn; closed when another role follows. Its
+          # sent images go after the blocks, outside the quoted value, as
+          # Gemma's chat template puts them; placeholder lines stay inside.
+          tool_response_blocks(content, profile) + lines.markers +
             (following && following != "tool_response" && following != "model" ? "#{profile.turn_end}\n" : "")
         when "model"
           content = strip_gemma_thought(content) if index < last_user && !content.include?(profile.tool_call_open)
@@ -136,7 +151,7 @@ module Samagotchi
       parts = []
 
       messages.each_with_index do |m, index|
-        content = prompt_content_for(m, profile) + suffixes[index]
+        content = prompt_content_for(m, profile) + suffixes[index].text
         case m[:role]
         when "system"
           parts << "#{profile.system_prefix}#{content}<|im_end|>\n"

data/lib/samagotchi/prompt_literal_guard.rb

@@ -16,7 +16,10 @@ module Samagotchi
       ["[[SAMAGOTCHI_LITERAL_GEMMA_STRING_DELIM]]", '<|"|>'],
       ["[[SAMAGOTCHI_LITERAL_THINK_OPEN]]", "<|think|>"],
       ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_OPEN]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN],
-      ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_CLOSE]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE]
+      ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_CLOSE]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_SOFT]]", "<|image|>"],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_START]]", "<|image>"],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_END]]", "<image|>"]
     ].freeze
 
     QWEN_TOKEN_PAIRS = [

data/lib/samagotchi/send_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "client_id"
 require_relative "session"
+require_relative "session_commands"
 require_relative "session_inbox"
 require_relative "session_manager"
 require_relative "session_chain"
@@ -175,6 +176,14 @@ module Samagotchi
         @stderr.puts("chi send: #{e.message}")
         return 1
       end
+      # A UI-only command (/stats, /exit, …) runs in the terminal and the web,
+      # not in the worker: sent through, the worker doesn't run it and the
+      # line reaches the model as a prompt, costing a whole turn. Refused
+      # before anything is sent (before a --new session is created too); the
+      # session's plugin commands are never local.
+      if prompt && (local = local_command(prompt))
+        return refuse_local_command(local, options)
+      end
       # A file that is not there or not an image: a run-time failure (1),
       # reported in the --format json line too; --image itself was fine.
       return CLI::Exit::FAILED unless ingest_images(options[:images])
@@ -440,6 +449,58 @@ module Samagotchi
     # (a bundle's too).
     def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
 
+    # The UI-only built-in command +text+ (stripped) is a line of (/stats,
+    # /exit, …), or nil: the worker never runs it, so chi send must not pass
+    # it on. What the UIs run: the line as the entry's match takes it — bare
+    # "exit" too (/exit's match), but not with arguments ("/exit --delete" is
+    # a UI line; "/stats please" is a prompt), as in a terminal.
+    # @return [Commands::Registry::Entry, nil]
+    def local_command(text)
+      line = text.to_s.strip
+      return nil unless command_like?(line) || line.match?(/\Aexit\z/i)
+
+      entry = SessionCommands.builtin_registry.lookup_local(line)
+      # Only the exact line the UI runs: "/stats please" is a prompt, and
+      # "/exit --delete" is left to the worker (the TUI runs it as /exit, the
+      # worker answers its unknown-command way). Bare "exit" is /exit's line
+      # as its match takes it; the reply names the command, /exit.
+      return nil unless entry
+      return entry if line == entry.name
+
+      line.match?(/\Aexit\z/i) ? entry : nil
+    end
+
+    # A UI-only command: nothing is sent (with --new, no session is created
+    # either). /stats points at its model-free reader and names the session;
+    # the others just say the worker doesn't run them. Exit 1, as other
+    # refusals; with --wait --format json the line is the usual error object
+    # (ParentWait's end-of-run line when the reply never comes).
+    # @return [Integer] 1
+    def refuse_local_command(entry, options)
+      if options[:new]
+        error_line("chi send: refused: #{local_refusal(entry.name, nil)}")
+      elsif options[:wait]
+        # --wait: the JSON line goes to stdout, @info is stderr; an unknown
+        # or ambiguous id gets resolve's own error line.
+        id = resolve(options[:ids].first) or return CLI::Exit::FAILED
+        @stderr.puts("#{id[0, 8]}  refused: #{local_refusal(entry.name, id)}")
+      else
+        options[:ids].uniq.each do |given|
+          id = resolve(given) or next
+          @info.puts("#{id[0, 8]}  refused: #{local_refusal(entry.name, id)}")
+        end
+      end
+      CLI::Exit::FAILED
+    end
+
+    # Why a UI-only command isn't sent: /stats points at its model-free
+    # reader (naming the session when there is one).
+    def local_refusal(name, id)
+      return "#{name} is a terminal and web command; chi send doesn't run it" unless name == "/stats"
+
+      "#{name} is a terminal and web command; use chi sessions stats #{id ? id[0, 8] : "ID"}"
+    end
+
     # --wait after a message that ran as a session command: no reply comes
     # for it. Its output shows where the session is open.
     # @return [Integer] 0

data/lib/samagotchi/session_commands.rb

@@ -71,8 +71,7 @@ module Samagotchi
         continue_answer(answer.empty? ? CONTINUE_COMMAND : answer)
       end
       # It reads the hosts only (the registry is mutex-guarded): mid-turn too.
-      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)",
-                        mid_turn: ->(_text) { :anytime }) do |text|
+      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)", anytime: true) do |text|
         reply(models_listing(text.delete_prefix(MODELS_COMMAND).strip))
       end
       registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)",

data/lib/samagotchi/session_metrics.rb

@@ -141,6 +141,9 @@ module Samagotchi
       :cuts,
       :capped,
       :model,
+      # The turn the user started by answering the step-limit question with
+      # Continue (:turn_started's +continue+); its record carries it.
+      :continue,
       :id,
       :started_at,
       :started_monotonic,
@@ -539,6 +542,7 @@ module Samagotchi
           cuts: 0,
           capped: 0,
           model: nil,
+          continue: event[:continue] ? true : false,
           id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
@@ -575,6 +579,9 @@ module Samagotchi
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
           record[:cancelled_by] = by.to_s unless by.nil? || by.to_s.empty?
           record[:failure] = failure if failure
+          # Every record says, so the report can tell a file with no Continue
+          # from one written before the mark.
+          record[:continue] = @turn.continue
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)

data/lib/samagotchi/sessions_command.rb

@@ -9,19 +9,22 @@ require_relative "session_metrics"
 require_relative "recap_store"
 require_relative "session_delete_command"
 require_relative "session_archive_command"
+require_relative "bridge_client"
+require_relative "terminal_ui/formatting"
+require_relative "terminal_ui/event_renderer"
 require_relative "cli/command"
 require_relative "cli/flags"
 
 module Samagotchi
-  # `chi sessions`: list, stop, restart, archive/unarchive, delete, prune and clean
-  # sessions from the shell (bin/chi dispatches here before OptionParser;
-  # the subcommands have their own flags). Not SessionCommands, the REPL's
-  # slash commands for sessions (session_commands.rb).
+  # `chi sessions`: list, stop, restart, archive/unarchive, delete, prune,
+  # clean and stats sessions from the shell (bin/chi dispatches here before
+  # OptionParser; the subcommands have their own flags). Not SessionCommands,
+  # the REPL's slash commands for sessions (session_commands.rb).
   class SessionsCommand
     include CLI::Command
 
     USAGE = <<~TEXT
-      Usage: chi sessions <list|stop|restart|archive|unarchive|delete|prune|clean> [options]
+      Usage: chi sessions <list|stop|restart|archive|unarchive|delete|prune|clean|stats> [options]
         list [--sort updated_at|created_at] [--order desc|asc] [--limit N]
              [--live] [--cwd PATH] [--format text|json|tsv] [--archived]
              --live: sessions a worker runs now (the ones chi note reaches), 10 unless --limit
@@ -34,12 +37,18 @@ module Samagotchi
         delete [--force] ID...   # delete sessions for good (IDs or unique prefixes); --force stops a live worker first
         prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]
         clean [--dry-run] [--days N]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days
+        stats ID [--format text|json]   # a session's cost, tokens and progress, without running a model turn:
+             a live worker's GET stats, else the snapshot its saved analytics.json rebuilds (never starts a worker)
       Defaults: days=14 keep=500 keep_status=none (config: session.retention_days, session.max_count, session.keep_status)
     TEXT
 
     STOP_USAGE = "Usage: chi sessions stop ID...\n"
     RESTART_USAGE = "Usage: chi sessions restart ID...\n"
-    SUBCOMMANDS = %w[list stop restart archive unarchive delete prune clean].freeze
+    STATS_USAGE = "Usage: chi sessions stats ID [--format text|json]\n"
+    # How long `stats` waits for a live worker's GET stats before reading the
+    # saved analytics.json instead (a stuck worker must not hold a driver).
+    STATS_TIMEOUT = 3
+    SUBCOMMANDS = %w[list stop restart archive unarchive delete prune clean stats].freeze
 
     # Each subcommand's flags ("--flag V" or "--flag=V" for a value): an
     # unknown flag, a value flag with nothing after it or an argument where
@@ -53,6 +62,9 @@ module Samagotchi
       end,
       "stop" => CLI::Flags.new,
       "restart" => CLI::Flags.new,
+      "stats" => CLI::Flags.new do |f|
+        f.value "--format"
+      end,
       "prune" => CLI::Flags.new(args: false) do |f|
         %w[--days --keep --keep-status].each { |name| f.value name }
         f.switch "--dry-run"
@@ -98,6 +110,7 @@ module Samagotchi
       when "list" then list
       when "stop" then stop(parsed.args)
       when "restart" then restart(parsed.args)
+      when "stats" then stats(parsed.args)
       else prune(@sub)
       end
     end
@@ -105,7 +118,7 @@ module Samagotchi
     private
 
     def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi sessions #{@sub}" : "chi sessions"
-    def usage_text = { "stop" => STOP_USAGE, "restart" => RESTART_USAGE }.fetch(@sub, USAGE)
+    def usage_text = { "stop" => STOP_USAGE, "restart" => RESTART_USAGE, "stats" => STATS_USAGE }.fetch(@sub, USAGE)
 
     # quirk: a number that isn't one is 0 (--days=abc turns the age limit off)
     def integers(options)
@@ -269,6 +282,70 @@ module Samagotchi
       0
     end
 
+    # One session's cost, tokens and progress, for a script or an agent that
+    # drives sessions (chi send --wait): a live worker's GET stats, else the
+    # snapshot its saved analytics.json rebuilds. Never starts a worker, and
+    # never sends the model anything.
+    def stats(ids)
+      return usage_error("give a session id") if ids.empty?
+      return usage_error("stats takes one session id") if ids.size > 1
+
+      format = @opts[:format]
+      unless format.nil? || %w[text json].include?(format)
+        return usage_error("unknown format #{format.inspect}: use --format text|json")
+      end
+
+      id = begin
+        Samagotchi::Session.resolve_id(ids.first)
+      rescue Samagotchi::Session::AmbiguousId => e
+        @stdout.flush
+        @stderr.puts e.message
+        return 1
+      end
+      session = begin
+        Samagotchi::Session.load(id)
+      rescue ArgumentError => e
+        @stdout.flush
+        @stderr.puts e.message
+        return 1
+      end
+
+      metrics, live, note = stats_snapshot_for(session)
+      if format == "json"
+        @stdout.puts JSON.generate({ session_id: session.id, status: session.status, live: live, metrics: metrics })
+      else
+        @stdout.puts "#{session.id[0, 8]}  #{session.status.ljust(7)} #{session.model_name}"
+        @stdout.puts TerminalUI::Formatting.format_session_metrics(metrics)
+        @stdout.puts note if note
+      end
+      0
+    end
+
+    # [snapshot, live, note]: a live worker answers GET stats (no model call);
+    # without one — or one that does not answer in time — the snapshot comes
+    # from the session's saved analytics.json, rebuilt by SessionMetrics (the
+    # same collector a worker runs, loaded from disk). The note says when the
+    # worker did not answer. nil when the session has no analytics.json yet.
+    # Never starts a worker.
+    # @return [Array(Hash, nil, Boolean, String, nil)]
+    def stats_snapshot_for(session)
+      dir = Samagotchi::Session.session_dir(session.id)
+      if (port = Samagotchi::BridgeClient.sidecar_port(dir))
+        client = Samagotchi::BridgeClient.new(session_id: session.id, port: port, read_timeout: STATS_TIMEOUT)
+        body = client.get_json("stats")&.dig("metrics")
+        if body.is_a?(Hash)
+          return [TerminalUI::EventRenderer.deep_symbolize_keys(body), true, nil]
+        end
+      end
+      return [nil, false, nil] unless File.file?(File.join(dir, "analytics.json"))
+
+      snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.snapshot
+      note = live_worker?(session.id) ? "(no live worker answered; from the saved analytics.json)" : nil
+      [snapshot, false, note]
+    end
+
+    def live_worker?(session_id) = Samagotchi::SessionManager.worker_live?(session_id)
+
     def stop(ids)
       return usage_error("give session ids") if ids.empty?
 

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1226,7 +1226,7 @@ module Samagotchi
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }
         "#{format_tool_activity_line(activity, duration_ms: duration_ms)}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}"
       end
 
       # The context notes that came since the last prompt (all of them in a
@@ -1320,7 +1320,7 @@ module Samagotchi
 
         activity = EventRenderer.described(event) || {}
         @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
-                                            description: activity[:description],
+                                            description: activity[:description], output_truncated: event[:output_truncated],
                                             images: event[:images], diff: event[:diff] }))
       end
 

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -72,7 +72,8 @@ module Samagotchi
           # A replayed row (a join) carries its duration (nil: unknown).
           measured = tool_duration_ms(event)
           render_streamed_tool_activity(self.class.described(event), duration_ms: event.fetch(:duration_ms, measured),
-                                                                     images: event[:images], diff: event[:diff])
+                                                                     images: event[:images], diff: event[:diff],
+                                                                     output_truncated: event[:output_truncated])
         when :generation_completed, :generation_cancelled, :tool_dispatch_started
           @view.generation_feedback_finished
         when :pending_input_merged
@@ -211,13 +212,14 @@ module Samagotchi
 
       private
 
-      def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil)
+      def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil, output_truncated: nil)
         return if activity.nil?
 
         @streamed_tool_activity[tool_activity_key(activity)] += 1
         line = @view.format_tool_activity_line(activity, duration_ms: duration_ms)
         line += @view.format_tool_image_suffix(images) if images&.any?
         line += @view.format_tool_diff_suffix(diff) if diff
+        line += @view.format_tool_cut_suffix(output_truncated) if output_truncated
         @view.print_line(line)
       end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -14,6 +14,14 @@ module Samagotchi
     # `tool>` line, elapsed durations. Pure apart from reading whether
     # $stdout is a colour terminal.
     module Formatting
+      # The /stats text for a metrics snapshot, for the REPL and attached
+      # views (an instance includes the module) and for `chi sessions stats`
+      # (no UI: the same text from the CLI).
+      # @return [String] "(no metrics yet)" without a snapshot
+      def self.format_session_metrics(snapshot)
+        (@formatter ||= Object.new.extend(Formatting)).send(:format_session_metrics, snapshot)
+      end
+
       def format_tool_activity_line(activity, duration_ms: nil)
         status = activity[:status].to_s
         elapsed_suffix = duration_ms.nil? ? "" : " (#{format_elapsed_duration(duration_ms)})"
@@ -138,6 +146,12 @@ module Samagotchi
         " #{paint("+#{get.call(:added).to_i}", 32)} #{paint("\u2212#{get.call(:removed).to_i}", 31)}"
       end
 
+      # A row whose output the runner cut (max_tool_output_chars): " [cut]",
+      # dim, beside the diff one.
+      def format_tool_cut_suffix(output_truncated)
+        output_truncated ? " #{paint("[cut]", 90)}" : ""
+      end
+
       # Prompt labels by the sender's client_id: a whole id, or a prefix
       # (ending in ":") it starts with (turn_events.js CLIENT_LABELS;
       # spec/shared/labels_matrix.json).
@@ -212,7 +226,7 @@ module Samagotchi
       def snapshot_tool_line(part)
         status = part[:status].to_s
         "#{paint("tool>", 36)} #{part[:tool]}#{tool_params_suffix(part)}: #{paint(status, status_color(status))}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}"
       end
 
       # A card (Engine#show_card) as a framed block: the title and its
@@ -482,7 +496,8 @@ module Samagotchi
       end
 
       # Render the analytics snapshot as a compact, user-facing report. Raw event
-      # logs (debug-only) are intentionally excluded; this surface is for the REPL.
+      # logs (debug-only) are intentionally excluded; this surface is for the REPL
+      # and `chi sessions stats` (the module function above).
       def format_session_metrics(snapshot)
         return "(no metrics yet)" unless snapshot.is_a?(Hash)
 

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -2,6 +2,7 @@
 
 require_relative "question_slot"
 require_relative "../turn_flow"
+require_relative "../question_desk"
 
 module Samagotchi
   class TerminalUI
@@ -80,9 +81,15 @@ module Samagotchi
         "  waiting in parent #{@relayed_to} too (answering here works)" if @relayed_to
       end
 
+      # The line a question dismissed in a --non-interactive run leaves (no
+      # one could answer it there): the REPL's own, and an attached UI's on
+      # its cancel (QuestionDesk::UNANSWERABLE_REASON).
+      UNANSWERABLE_TEXT = "(dismissed: no one to answer in a non-interactive run)"
+
       # What a question closed with no answer here says: a relayed approval
       # names where it went; else "(question cancelled)".
       def closed_text(reason)
+        return UNANSWERABLE_TEXT if reason.to_s == QuestionDesk::UNANSWERABLE_REASON
         return CONTINUE_CLOSED.fetch(reason.to_s, "(question cancelled)") if continue?
         return "(question cancelled)" unless @delegate
 

data/lib/samagotchi/terminal_ui.rb

@@ -1356,7 +1356,7 @@ module Samagotchi
     # dismissed it.
     def dismiss_unaskable_question(prompt)
       @engine.cancel_question(QuestionDesk::UNANSWERABLE_REASON) rescue nil
-      banner(prompt.summary("(dismissed: no one to answer in a non-interactive run)", paint: method(:paint)))
+      banner(prompt.summary(QuestionPrompt::UNANSWERABLE_TEXT, paint: method(:paint)))
       false
     end
 

data/lib/samagotchi/tools/task_runtime.rb

@@ -213,7 +213,7 @@ module Samagotchi
         return record unless record["status"] == "running"
 
         pid = record["pid"]
-        return record if chis_group?(record)
+        return record if chis_group?(record, started: record["pid_started"])
         # Gone: its exit code says how it ended.
         return mark_finished_without_exit_code(record) if ProcessGroup.signalable?(pid) && !ProcessGroup.alive?(pid)
 
@@ -222,8 +222,9 @@ module Samagotchi
 
       # Whether the record's pid still leads its own group. With +started+
       # (the start time recorded at task_create), also the same process: a
-      # ps per call, so only task_stop asks it, just before the signal;
-      # a refresh (each task_wait poll, task_list) checks the group only.
+      # ps per call on macOS (~5 ms), asked by each refresh (task_list,
+      # task_get, each task_wait poll) so a reused pid reads as exited, and
+      # by task_stop again just before the signal.
       def chis_group?(record, started: nil) = ProcessGroup.leader?(record["pid"], started: started)
 
       # A running record whose pid isn't a group chi started (NOT_CHIS_PROCESS)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -73,9 +73,9 @@ module Samagotchi
       return no("the server gives no media marker (update llama.cpp)") unless media_marker(props)
       return no("profile #{profile&.name || "?"} has no image template yet") unless profile&.image_template
 
-      open = profile.image_open_token
-      unless open.empty? || body["chat_template"].to_s.include?(open)
-        return no("the server's chat template doesn't use #{open} (profile #{profile.name})")
+      check = profile.image_check_token
+      unless check.empty? || body["chat_template"].to_s.include?(check)
+        return no("the server's chat template doesn't use #{check} (profile #{profile.name})")
       end
 
       Answer.new(value: true, reason: nil)

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

@@ -62,7 +62,7 @@ import {
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, historyHasCommandBubble, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -2265,10 +2265,19 @@ const streamHandlers = {
     if (view.resync) await resync();
     // A card's action that isn't anytime (the step-limit question's
     // /continue) has no bubble: nothing to remove. An anytime or queued
-    // one's bubble was drawn at its command_queued: filled in here.
+    // one's bubble was drawn at its command_queued: filled in here. One
+    // queued for after the turn ran after it: its bubble moves from among
+    // the turn's rows to after its answer and timing line.
     const queued = view.anytime || view.queued ? commandBubble(view.commandId) : null;
     if (view.hidden) queued?.remove();
-    else if (queued) drawCommandBubble(queued, view);
+    else if (queued && view.queued && !view.anytime) {
+      queued.remove();
+      addCommandBubble(view);
+    } else if (queued) drawCommandBubble(queued, view);
+    // A command that changed the conversation (!cmd): the redrawn history
+    // ends with its command bubble already (the saved "!(…)\n<output>"
+    // message renders as one) — no second bubble, or the output shows twice.
+    else if (view.resync && historyHasCommandBubble(findInTurnRoots(".bubble.command"), view.line)) { /* drawn by the resync */ }
     else addCommandBubble(view);
   },
   // An anytime command (/help, a plugin's /btw) runs at once, beside a