samagotchi 0.36.0 → 0.37.0

data/lib/samagotchi/idle_client.rb

@@ -24,10 +24,14 @@ module Samagotchi
     # Raised when summarization fails (server down, timeout, malformed body…).
     class SummarizeError < StandardError; end
 
-    # What #summarize returns: the recap text and the model that answered
-    # (the server's name for it; nil when the reply names none). #to_s is
-    # the text.
-    Summary = Data.define(:text, :model) do
+    # What #summarize and #ask return: the text and the model that
+    # answered (the server's name for it; nil when the reply names none).
+    # +top_logprobs+: the first token's alternatives (LLM::TokenLogprob)
+    # when #ask asked for logprobs and the server sent them, else [].
+    # #to_s is the text.
+    Summary = Data.define(:text, :model, :top_logprobs) do
+      def initialize(top_logprobs: [].freeze, **) = super
+
       def to_s = text
     end
 
@@ -40,12 +44,21 @@ module Samagotchi
     # @param timeout [Numeric] HTTP request timeout. Kept to the recap's own
     #   wait budget (not the chat's global request_timeout) so an abandoned
     #   summarize thread can't outlive the recap attempt by minutes.
-    def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV)
+    # @param purpose [String] what the requests are for, in the HTTP log
+    #   lines and error messages ("recap", "broadcast")
+    def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV, purpose: "recap")
       @model = model
       # A recap is best-effort: one short attempt, no retries. The idle job
       # tries again after the next activity, never on its own.
-      @chat = LLM::OpenAIChat.new(base_url: base_url.to_s, host_name: "recap", api_key_env: api_key_env,
-                                  stream: false, retries: false, timeout: timeout, env: env, purpose: "recap")
+      @chat = LLM::OpenAIChat.new(base_url: base_url.to_s, host_name: purpose, api_key_env: api_key_env,
+                                  stream: false, retries: false, timeout: timeout, env: env, purpose: purpose)
+    end
+
+    # A client for +target+ (an IdleTarget: a recap's, ctx.ask_model's, a
+    # broadcast's triage model).
+    # @return [IdleClient]
+    def self.for(target, **)
+      new(model: target.model, base_url: target.base_url, api_key_env: target.api_key_env, **)
     end
 
     THINK_RE = /<\|think\|.*?\|think\|>/m
@@ -77,25 +90,31 @@ module Samagotchi
       messages = prompt.is_a?(Array) ? prompt : [{ role: "user", content: prompt.to_s.strip }]
       return nil if messages.all? { |m| m[:content].to_s.strip.empty? }
 
-      content, served = generate(messages)
-      cleaned = content.to_s.strip
-      cleaned.empty? ? nil : Summary.new(text: cleaned, model: served)
+      response = generate(messages)
+      cleaned = response.text.to_s.strip
+      cleaned.empty? ? nil : Summary.new(text: cleaned, model: response.model)
     rescue SummarizeError
       raise
     rescue StandardError => e
       raise SummarizeError, "recap summarization failed: #{e.class}: #{e.message}"
     end
 
-    # One side answer (a plugin's ctx.ask_model): +messages+ as they are, no
-    # tools, thinking off. An answer cut off by +max_tokens+ is kept as it
-    # is, marked with "…". Cancelling +cancel_controller+ aborts the request.
+    # One side answer (a plugin's ctx.ask_model, a broadcast's triage):
+    # +messages+ as they are, no tools, thinking off. An answer cut off by
+    # +max_tokens+ is kept as it is, marked with "…". Cancelling
+    # +cancel_controller+ aborts the request.
+    # @param kind [String] what it is for, in the usage log line
+    # @param options [Hash] more request body fields (logprobs: true,
+    #   top_logprobs: 5)
     # @return [Summary] the answer ("" when the model said nothing)
-    # @raise [SummarizeError] any failure but a cancel
+    # @raise [SummarizeError] any failure but a cancel; its #cause is an
+    #   LLM::BadRequest when the host refused the request (+options+ it
+    #   doesn't take, say)
     # @raise [LLM::RequestCancelled] +cancel_controller+ was cancelled
-    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil)
-      content, served = generate(messages, max_tokens: max_tokens, cancel_controller: cancel_controller, whole_sentences: false,
-                                           kind: "ask")
-      Summary.new(text: content.to_s.strip, model: served)
+    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, kind: "ask", options: {})
+      response = generate(messages, max_tokens: max_tokens, cancel_controller: cancel_controller, whole_sentences: false,
+                                    kind: kind, options: options)
+      Summary.new(text: response.text.to_s.strip, model: response.model, top_logprobs: response.top_logprobs)
     rescue SummarizeError, LLM::RequestCancelled
       raise
     rescue StandardError => e
@@ -104,15 +123,16 @@ module Samagotchi
 
     private
 
-    # One plain /chat/completions request. Returns the cleaned assistant text
-    # ("" when there is nothing after stripping) and the served model's name
-    # (nil when the reply names none). Raises SummarizeError when
+    # One plain /chat/completions request. Returns a Summary of the cleaned
+    # assistant text ("" when there is nothing after stripping), the served
+    # model's name (nil when the reply names none) and the first token's
+    # logprobs. Raises SummarizeError when
     # the reply has neither content nor reasoning_content. Cut off by
     # +max_tokens+, the text keeps its finished sentences (+whole_sentences+)
     # or all of it, with "…".
-    def generate(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, whole_sentences: true, kind: "recap")
+    def generate(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, whole_sentences: true, kind: "recap", options: {})
       response = begin
-        request(messages, max_tokens, cancel_controller)
+        request(messages, max_tokens, cancel_controller, options)
       rescue LLM::BadRequest => e
         raise unless e.reasoning_refused? && !@thinking_refused
 
@@ -120,7 +140,7 @@ module Samagotchi
         # fields, and leave them out from now on.
         @thinking_refused = true
         Log.info(:recap, "thinking_refused", model: @model, detail: e.detail)
-        request(messages, max_tokens, cancel_controller)
+        request(messages, max_tokens, cancel_controller, options)
       end
       log_usage(response, kind)
       content = response.text
@@ -130,7 +150,7 @@ module Samagotchi
       cut_off = response.finish_reason == "length"
       # Reasoning cut off by max_tokens is the model's thinking, not a recap
       # (a server that ignores the thinking switch thinks until the limit).
-      return ["", response.model] if content.empty? && cut_off
+      return Summary.new(text: "", model: response.model, top_logprobs: response.top_logprobs) if content.empty? && cut_off
 
       # Prefer content, fall back to a finished reasoning_content (e.g.
       # Qwen3.6), and strip thinking tokens some models (Qwen, Gemma) leave
@@ -138,7 +158,7 @@ module Samagotchi
       text = self.class.strip_thinking(content.empty? ? reasoning : content)
       # Cut off by max_tokens: keep the sentences that finished ("" if none).
       text = whole_sentences ? self.class.full_sentences(text) : "#{text}…" if cut_off && !text.empty?
-      [text, response.model]
+      Summary.new(text: text, model: response.model, top_logprobs: response.top_logprobs)
     rescue LLM::ProtocolError => e
       raise SummarizeError, "server returned no parseable assistant content (#{e.message})"
     end
@@ -153,9 +173,9 @@ module Samagotchi
                                         cached: fields[:cached_tokens], cache_write: fields[:cache_write_tokens])
     end
 
-    def request(messages, max_tokens, cancel_controller)
+    def request(messages, max_tokens, cancel_controller, options = {})
       @chat.chat(messages: messages, model: @model, tools: [], cancel_controller: cancel_controller,
-                 options: { max_tokens: max_tokens, **thinking_fields })
+                 options: { max_tokens: max_tokens, **thinking_fields, **options })
     end
 
     # A recap or side answer is short and tool-less: thinking off, whatever

data/lib/samagotchi/idle_recap.rb

@@ -6,6 +6,7 @@ require "monitor"
 require "time"
 
 require_relative "idle_client"
+require_relative "idle_target"
 require_relative "output_formatter"
 require_relative "steer"
 require_relative "recap_store"
@@ -279,7 +280,7 @@ module Samagotchi
     # attempt (the session's current model, so a /model switch counts).
     # @param base_url [String] the OpenAI API base the recap asks
     # @param api_key_env [String, nil] the variable holding its key
-    # @param target [#call, nil] -> {base_url:, api_key_env:, model:, label:}
+    # @param target [#call, nil] -> IdleTarget
     def initialize(engine:, model: nil, base_url: nil, api_key_env: nil, target: nil,
                    inactivity: DEFAULT_INACTIVITY_SECONDS,
                    min_user_turns: DEFAULT_MIN_USER_TURNS,
@@ -292,7 +293,7 @@ module Samagotchi
 
       @engine = engine
       @target = target || lambda {
-        { base_url: base_url, api_key_env: api_key_env, model: model, label: model }
+        IdleTarget.new(base_url: base_url, api_key_env: api_key_env, model: model, label: model)
       }
       @inactivity = inactivity
       @min_user_turns = min_user_turns
@@ -455,7 +456,7 @@ module Samagotchi
 
       asked = target
       @in_flight = { thread: spawn_summarize(client_for(asked), prompt), generation: gen, deadline: @clock.call + @timeout,
-                     covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked[:label] }
+                     covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked.label }
       :started
     rescue StandardError
       :failed
@@ -534,9 +535,9 @@ module Samagotchi
     def client_for(asked)
       return @client_override if @client_override
 
-      key = asked.values_at(:base_url, :api_key_env, :model)
+      key = [asked.base_url, asked.api_key_env, asked.model]
       unless @client && @client_key == key
-        @client = IdleClient.new(model: asked[:model], base_url: asked[:base_url], api_key_env: asked[:api_key_env], timeout: @timeout)
+        @client = IdleClient.for(asked, timeout: @timeout)
         @client_key = key
       end
       @client

data/lib/samagotchi/idle_target.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # Where a side request goes (a recap, a plugin's ctx.ask_model, a
+  # broadcast's triage): a model on a host's OpenAI API, asked through its
+  # own IdleClient (IdleClient.for), apart from the session's turns.
+  # @!attribute base_url [String] the host's OpenAI API base
+  # @!attribute api_key_env [String, nil] the variable holding its key
+  # @!attribute model [String] the model id sent to the server
+  # @!attribute label [String] the model as configured, for logs
+  IdleTarget = Data.define(:base_url, :api_key_env, :model, :label) do
+    # A configured side model can't be resolved.
+    # @!attribute reason [Symbol] :host_ref_unknown (no such host),
+    #   :model_host_mismatch (the model names another host than host_ref)
+    #   or :incomplete (no base_url or no model)
+    class self::Unresolved < StandardError
+      attr_reader :reason, :model, :host_ref, :named
+
+      def initialize(reason, model: nil, host_ref: nil, named: nil)
+        @reason = reason
+        @model = model
+        @host_ref = host_ref
+        @named = named
+        super("side model #{model.inspect} can't be resolved: #{reason}")
+      end
+    end
+
+    # +name+ (a model ref) as a turn resolves it: its alias applied, its
+    # host, or where a bare --model goes (HostRegistry#resolve, which may
+    # list a host's models).
+    # @param host_registry [HostRegistry]
+    # @return [IdleTarget]
+    def self.of_model(host_registry, name)
+      resolved = host_registry.resolve(name)
+      new(base_url: resolved.openai_base_url, api_key_env: resolved.entry.api_key_env, model: resolved.bare_model,
+          label: name.to_s.strip)
+    end
+
+    # A side model's settings (recap.*, broadcast.triage_*) as a target:
+    # +base_url+ with +model+; +host_ref+ (a hosts: name) with +model+;
+    # +model+ alone (its own host, its alias's, or where a bare --model
+    # goes). Blank values count as unset.
+    # @param host_registry [HostRegistry]
+    # @return [IdleTarget, nil] nil when all three are unset (the caller
+    #   picks its default)
+    # @raise [Unresolved]
+    def self.resolve(model:, host_ref:, base_url:, host_registry:)
+      model, host_ref, base_url = [model, host_ref, base_url].map { |value| blank(value) }
+      return nil if model.nil? && host_ref.nil? && base_url.nil?
+
+      label = model.to_s
+      parsed = model && host_registry.model_ref(model)
+      return of_model(host_registry, model) unless host_named?(model: model, host_ref: host_ref, base_url: base_url,
+                                                               host_registry: host_registry)
+
+      host_ref ||= parsed.host_name if parsed && base_url.nil?
+      api_key_env = nil
+      if host_ref
+        entry = host_registry.find_entry(host_ref)
+        raise self::Unresolved.new(:host_ref_unknown, model: model, host_ref: host_ref) unless entry
+
+        base_url = entry.openai_base_url
+        api_key_env = entry.api_key_env
+        named = parsed&.host_conflict || parsed&.host_name
+        if named && named != entry.name
+          raise self::Unresolved.new(:model_host_mismatch, model: model, host_ref: host_ref, named: named)
+        end
+
+        model = parsed.id if parsed
+      elsif parsed && !parsed.host_name
+        model = parsed.id
+      end
+      raise self::Unresolved.new(:incomplete, model: model, host_ref: host_ref) if blank(base_url).nil? || blank(model).nil?
+
+      new(base_url: base_url.to_s.strip, api_key_env: api_key_env, model: model.to_s.strip, label: label.strip)
+    end
+
+    # Whether the settings fix a host (+base_url+, +host_ref+, or a model
+    # ref naming one), so resolving them once holds; a model alone that
+    # names none goes where a bare --model goes, which a host's model list
+    # decides (resolve it at each request).
+    def self.host_named?(model:, host_ref:, base_url:, host_registry:)
+      return true if blank(base_url) || blank(host_ref)
+
+      model = blank(model)
+      !model.nil? && !host_registry.model_ref(model).host_name.nil?
+    end
+
+    def self.blank(value)
+      text = value.to_s.strip
+      text.empty? ? nil : text
+    end
+    private_class_method :blank
+  end
+end

data/lib/samagotchi/llm/openai_chat.rb

@@ -40,8 +40,34 @@ module Samagotchi
     # OpenRouter's routing name); nil when the server says nothing.
     # +cut+ is set on the empty response the chat loop makes for a
     # generation a plugin cut (stop_generation): {by:, reason:}.
-    ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :provider, :cut) do
-      def initialize(model: nil, provider: nil, cut: nil, **fields) = super
+    # +top_logprobs+: the first answer token's likeliest alternatives
+    # (TokenLogprob) when the request asked for logprobs and the server
+    # sent them (a non-streamed answer only); [] otherwise.
+    ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :provider, :cut,
+                               :top_logprobs) do
+      def initialize(model: nil, provider: nil, cut: nil, top_logprobs: [].freeze, **fields) = super
+    end
+
+    # One alternative for an answer token: its text and log probability.
+    TokenLogprob = Data.define(:token, :logprob) do
+      # The first token's alternatives in a chat completion body's
+      # choices[0].logprobs (OpenAI's shape); [] when there are none or the
+      # body has another shape (it runs on every non-streamed answer: it
+      # never raises).
+      def self.first_of(body)
+        top = [%w[choices], [0], %w[logprobs], %w[content], [0], %w[top_logprobs]].reduce(body) do |node, (key)|
+          break nil unless key.is_a?(Integer) ? node.is_a?(Array) : node.is_a?(Hash)
+
+          node[key]
+        end
+        return [].freeze unless top.is_a?(Array)
+
+        top.filter_map do |entry|
+          next unless entry.is_a?(Hash) && entry["token"].is_a?(String) && entry["logprob"].is_a?(Numeric)
+
+          new(token: entry["token"], logprob: entry["logprob"].to_f)
+        end.freeze
+      end
     end
 
     # The OpenAI Chat Completions API (llama.cpp's /v1, and any compatible
@@ -334,7 +360,7 @@ module Samagotchi
                          reasoning: (message["reasoning_content"] || message["reasoning"]).to_s,
                          tool_calls: calls, usage: Usage.from_payload(body) || Usage.none,
                          finish_reason: body.dig("choices", 0, "finish_reason"), model: served_model(body),
-                         provider: self.class.served_provider(body))
+                         provider: self.class.served_provider(body), top_logprobs: TokenLogprob.first_of(body))
       end
 
       def served_model(payload) = self.class.served_model(payload)

data/lib/samagotchi/log_line.rb

@@ -16,7 +16,7 @@ module Samagotchi
   # (debug dumps) are indented by four spaces and belong to the record above.
   module LogLine
     LEVELS = %w[DEBUG INFO WARN ERROR].freeze
-    TAGS = %w[turn http worker bridge web attached repl idle recap hooks plugins guardrails config memory model context].freeze
+    TAGS = %w[turn http worker bridge web attached repl idle recap hooks plugins guardrails config memory model context broadcast].freeze
     INDENT = "    "
 
     Record = Struct.new(:ts, :level, :tag, :pid, :sid, :event, :fields, :payload, keyword_init: true)

data/lib/samagotchi/note_command.rb

@@ -91,20 +91,6 @@ module Samagotchi
       options
     end
 
-    # Only a pipe or a file is read, as chi send does. A terminal means
-    # nobody piped a note in, and a socket a launcher or an agent's shell
-    # passes down may never close: waiting on either would hang a script.
-    def read_stdin
-      return nil if @stdin.respond_to?(:tty?) && @stdin.tty?
-
-      if @stdin.respond_to?(:stat)
-        stat = @stdin.stat
-        return nil unless stat.pipe? || stat.file?
-      end
-
-      @stdin.read
-    end
-
     # --all: every live session. @return [Integer] exit status
     def deliver_to_live(text, source)
       ids = SessionManager.session_summaries(live: true, include_tests: Session.test_session_env?,
@@ -141,12 +127,5 @@ module Samagotchi
       else "waits for the session's next start (#{result.queued} #{result.queued == 1 ? "note" : "notes"} queued)"
       end
     end
-
-    # The note as UTF-8 whatever the locale says: with no LANG/LC_* (an app
-    # started from Finder, launchd) stdin reads as US-ASCII and ARGV as
-    # binary. Invalid bytes become U+FFFD rather than an error.
-    def utf8(text)
-      text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
-    end
   end
 end

data/lib/samagotchi/recap_setup.rb

@@ -3,6 +3,7 @@
 require_relative "config"
 require_relative "log"
 require_relative "idle_recap"
+require_relative "idle_target"
 require_relative "recap_store"
 
 module Samagotchi
@@ -41,60 +42,21 @@ module Samagotchi
       base_url = string_config(kwarg_config, :base_url) || registry_string("recap.base_url")
       host_ref = string_config(kwarg_config, :host_ref) || string_config(kwarg_config, :host) || registry_string("recap.host_ref")
       model = string_config(kwarg_config, :model) || registry_string("recap.model")
-      label = model
 
-      # The model as any model ref (ModelRef): its alias applied once, and
-      # its host (own or the alias's) picks the recap host when host_ref
-      # doesn't.
-      parsed = model && host_registry.model_ref(model)
-      target = nil
-      if base_url.nil? && host_ref.nil? && model.nil?
-        target = -> { session_target.call }
-      elsif base_url.nil? && host_ref.nil? && !parsed.host_name
-        # A model naming no host goes where a bare --model goes
-        # (HostRegistry#host_for_model: the default host unless another's
-        # list has it), resolved at each attempt.
-        target = lambda do
-          resolved = host_registry.resolve(model)
-          { base_url: resolved.openai_base_url, api_key_env: resolved.entry.api_key_env,
-            model: resolved.bare_model, label: label.to_s.strip }
-        end
-      else
-        host_ref ||= parsed.host_name if parsed && base_url.nil?
-        # If host_ref given, derive base_url (the host's OpenAI base) and its
-        # API key variable from the host_registry entry
-        api_key_env = nil
-        if host_ref && !host_ref.empty?
-          entry = host_registry.find_entry(host_ref)
-          if entry
-            base_url = entry.openai_base_url
-            api_key_env = entry.api_key_env
-            named = parsed&.host_conflict || parsed&.host_name
-            if named && named != entry.name
-              Log.warn(:recap, "model_host_mismatch",
-                       echo: "Warning: recap model '#{model}' names host '#{named}', not recap.host_ref '#{host_ref}'; recap disabled.",
-                       model: model, host_ref: host_ref)
-              return nil
-            end
-            model = parsed.id if parsed
-          else
-            Log.warn(:recap, "host_ref_unknown", echo: "Warning: recap host_ref '#{host_ref}' not found in hosts:; recap disabled.", host_ref: host_ref)
-            return nil
-          end
-        elsif parsed && !parsed.host_name
-          model = parsed.id
-        end
+      settings = { model: model, host_ref: host_ref, base_url: base_url, host_registry: host_registry }
+      target = if base_url.nil? && host_ref.nil? && model.nil?
+                 -> { session_target.call }
+               elsif !IdleTarget.host_named?(**settings)
+                 # A model naming no host goes where a bare --model goes
+                 # (HostRegistry#host_for_model: the default host unless
+                 # another's list has it), resolved at each attempt.
+                 -> { IdleTarget.resolve(**settings) }
+               else
+                 fixed = fixed_target(settings)
+                 return nil unless fixed
 
-        if base_url.to_s.strip.empty? || model.to_s.strip.empty?
-          Log.warn(:recap, "recap_unconfigured",
-                   echo: "Warning: SAMAGOTCHI session recap is enabled but base_url/model are missing; recap disabled. " \
-                         "Set recap: {host_ref:, model:} or SAMAGOTCHI_RECAP_BASE_URL and SAMAGOTCHI_RECAP_MODEL (or pass recap: {base_url:, model:}), " \
-                         "or leave them all out to recap with the session's own model.")
-          return nil
-        end
-        fixed = { base_url: base_url.to_s.strip, api_key_env: api_key_env, model: model.to_s.strip, label: label.to_s.strip }
-        target = -> { fixed }
-      end
+                 -> { fixed }
+               end
 
       IdleRecap.new(
         engine: engine,
@@ -107,6 +69,30 @@ module Samagotchi
       )
     end
 
+    # The recap's pinned host and model (IdleTarget.resolve), or nil after
+    # a warning when they can't be resolved (recap stays off).
+    # @return [IdleTarget, nil]
+    def self.fixed_target(settings)
+      IdleTarget.resolve(**settings)
+    rescue IdleTarget::Unresolved => e
+      case e.reason
+      when :host_ref_unknown
+        Log.warn(:recap, "host_ref_unknown", echo: "Warning: recap host_ref '#{e.host_ref}' not found in hosts:; recap disabled.",
+                                             host_ref: e.host_ref)
+      when :model_host_mismatch
+        Log.warn(:recap, "model_host_mismatch",
+                 echo: "Warning: recap model '#{e.model}' names host '#{e.named}', not recap.host_ref '#{e.host_ref}'; recap disabled.",
+                 model: e.model, host_ref: e.host_ref)
+      else
+        Log.warn(:recap, "recap_unconfigured",
+                 echo: "Warning: SAMAGOTCHI session recap is enabled but base_url/model are missing; recap disabled. " \
+                       "Set recap: {host_ref:, model:} or SAMAGOTCHI_RECAP_BASE_URL and SAMAGOTCHI_RECAP_MODEL (or pass recap: {base_url:, model:}), " \
+                       "or leave them all out to recap with the session's own model.")
+      end
+      nil
+    end
+    private_class_method :fixed_target
+
     # recap.sentences as [min, max]; an invalid value warns and falls back to
     # the default range (the recap stays on).
     def self.recap_sentences(value)

data/lib/samagotchi/send_command.rb

@@ -225,21 +225,6 @@ module Samagotchi
       "#{ContextQuote.block(context)}#{message}"
     end
 
-    # Only a pipe or a file is read. A terminal means nobody piped anything
-    # in, and a socket a launcher or an agent's shell passes down may never
-    # close: with -m, waiting on either would hang a script. (A pipe the
-    # caller never closes still hangs, as it would for cat.)
-    def read_stdin
-      return nil if @stdin.respond_to?(:tty?) && @stdin.tty?
-
-      if @stdin.respond_to?(:stat)
-        stat = @stdin.stat
-        return nil unless stat.pipe? || stat.file?
-      end
-
-      @stdin.read
-    end
-
     # A worker session like the web start page's: saved as running with the
     # message before its worker spawns, so lists and the web show it at
     # once. The full id, so a script can pass it on. The model's host is
@@ -477,12 +462,5 @@ module Samagotchi
       else " with #{@images.size} images"
       end
     end
-
-    # The text as UTF-8 whatever the locale says: with no LANG/LC_* (an app
-    # started from Finder, launchd) stdin reads as US-ASCII and ARGV as
-    # binary. Invalid bytes become U+FFFD rather than an error.
-    def utf8(text)
-      text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
-    end
   end
 end

data/lib/samagotchi/version.rb

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

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

@@ -61,8 +61,9 @@ export function approvalView(pq) {
   const who = a.rule ? [`rule ${a.rule}`, a.source].filter(Boolean).join(", ") : (a.source || "hook");
   const reason = a.reason ? String(a.reason) : "(no reason given)";
   return {
-    // A plugin tool's label ("chrome: screenshot"), as its row shows it.
-    tool: a.label || a.tool || "",
+    // A plugin tool's label ("chrome: screenshot"), as its row shows it;
+    // else the tool the call acts as (an MCP tool behind mcp_call).
+    tool: a.label || a.acts_as || a.tool || "",
     // A tool without a command or path (an MCP tool): its compact args.
     what: command || paths.join("\n") || a.args || "",
     isCommand: !!command,
@@ -142,7 +143,7 @@ export function summaryText(pq, { answer = null, cancelled = false, reason = ""
     const text = asked ? `${truncate(asked, 60)} → ${result}` : result;
     return truncate(relay ? `${relay.who}: ${text}` : text, 120);
   }
-  const label = isApproval(pq) ? `Approve ${pq.approval?.label || pq.approval?.tool || "call"}?`
+  const label = isApproval(pq) ? `Approve ${pq.approval?.label || pq.approval?.acts_as || pq.approval?.tool || "call"}?`
     : isContinue(pq) ? "Step limit" : "Question";
   return truncate(pq.header || label);
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.36.0
+  version: 0.37.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -167,6 +167,9 @@ files:
 - lib/samagotchi/broadcast/recipients.rb
 - lib/samagotchi/broadcast/scope_card.rb
 - lib/samagotchi/broadcast/tags.rb
+- lib/samagotchi/broadcast/triage.rb
+- lib/samagotchi/broadcast/triage_log.rb
+- lib/samagotchi/broadcast/triage_model.rb
 - lib/samagotchi/broadcast_command.rb
 - lib/samagotchi/bundle_command.rb
 - lib/samagotchi/bundle_needs.rb
@@ -284,6 +287,7 @@ files:
 - lib/samagotchi/idle_recap.rb
 - lib/samagotchi/idle_reminders.rb
 - lib/samagotchi/idle_scheduler.rb
+- lib/samagotchi/idle_target.rb
 - lib/samagotchi/image_store.rb
 - lib/samagotchi/installed_gem.rb
 - lib/samagotchi/installed_versions.rb