samagotchi 0.35.0 → 0.37.0

data/lib/samagotchi/guardrails/targets.rb

@@ -2,6 +2,7 @@
 
 require_relative "../tools/tool_path"
 require_relative "../tools/memory"
+require_relative "../tool_declarations"
 require_relative "../log"
 require_relative "model_size"
 require_relative "outside"
@@ -21,6 +22,9 @@ module Samagotchi
       SHELL_TOOLS = %w[execute task_create].freeze
       PATH_TOOLS = %w[write edit read memory_write].freeze
 
+      # chi's own tools, by name, whether this session has them or not.
+      CORE_TOOLS = ToolDeclarations::TOOL_SCHEMAS.map { |schema| schema[:name] }.freeze
+
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
       # @return [String, nil] the call's repository (Context#repo: its
@@ -37,11 +41,30 @@ module Samagotchi
       #   prefix) and its key (ModelOverlay.key_for), for a rule's models:
       attr_reader :model_name, :model_key
 
-      # @return [Hash, nil] a plugin tool's arguments (call[:args]), for an
-      #   approval of a call whose targets name no command or path; nil for
-      #   chi's own tools
+      # @return [Hash, nil] a plugin tool's arguments, for an approval of a
+      #   call whose targets name no command or path: its targets:' args:
+      #   when given (the arguments it acts with, a dispatcher's inner
+      #   ones), else call[:args]; nil for chi's own tools
       attr_reader :args
 
+      # @return [String, nil] the tool a plugin tool's call acts as (its
+      #   targets:' acts_as:, an MCP tool behind mcp_call): a rule's tool:
+      #   matches it as well as the call's name. Never a core tool's or
+      #   another bundle's (.plugin_targets drops those). #tool stays the
+      #   call's name.
+      attr_reader :acts_as
+
+      # @return [String, nil] what a plugin tool's targets: says to name the
+      #   call by in the approval question (label:, "github: x"), in place of
+      #   the tool's registered label; display only (no rule or approval key
+      #   reads it)
+      attr_reader :label
+
+      # @return [Boolean] a memory_write call that removes a memory (remove:
+      #   true), for a rule's memory: remove
+      attr_reader :memory_remove
+      alias memory_remove? memory_remove
+
       # @param call [Hash] the parsed tool call
       # @param context [Context]
       # @param model_key [String, nil] for a memory_write model overlay, and
@@ -56,6 +79,8 @@ module Samagotchi
         paths = []
         cwd = base
         args = nil
+        acts_as = nil
+        label = nil
         case tool
         when *SHELL_TOOLS
           command = call[:content].to_s
@@ -74,20 +99,27 @@ module Samagotchi
           cwd = File.expand_path(given_cwd, base) unless given_cwd.empty?
           paths.concat(given[:paths].map { |path| absolute(path, cwd) })
           entry = registry && registry[tool]
-          args = call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
+          args = given[:args] || call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
+          acts_as = given[:acts_as]
+          label = given[:label]
         end
+        memory_remove = tool == "memory_write" && call[:remove].to_s.strip.downcase == "true"
         new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd),
-            repo: context.repo(cwd), args: args,
+            repo: context.repo(cwd), args: args, acts_as: acts_as, label: label, memory_remove: memory_remove,
             model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base,
             chi_dirs: -> { chi_dirs(context, base) })
       end
 
       # What a plugin tool's targets: callable says the call acts on:
-      # {command:, paths:, cwd:}, each optional; a callable that raises or
-      # gives something else counts as nothing (and is logged).
+      # {command:, paths:, cwd:, acts_as:, args:, label:}, each optional; a callable
+      # that raises or gives something else counts as nothing (and is
+      # logged). args: counts when it is a Hash; acts_as: is dropped (and
+      # logged) when it names a core tool or another bundle's tool, so a
+      # call can't pass for one and match (or reuse the approvals of) its
+      # rules. label: counts when it is one short line (.label_of).
       def self.plugin_targets(call, registry)
         entry = registry && registry[call[:name].to_s]
-        none = { command: nil, paths: [], cwd: nil }
+        none = { command: nil, paths: [], cwd: nil, acts_as: nil, args: nil, label: nil }
         return none unless entry && !entry.core? && entry.targets
 
         given = entry.targets.call(call)
@@ -95,13 +127,50 @@ module Samagotchi
 
         given = given.transform_keys(&:to_sym)
         command = given[:command].to_s
-        { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), cwd: given[:cwd] }
+        { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), cwd: given[:cwd],
+          acts_as: acts_as_of(given[:acts_as], entry, registry), args: given[:args].is_a?(Hash) ? given[:args] : nil,
+          label: label_of(given[:label], entry) }
       rescue StandardError => e
         Log.warn(:plugins, "plugin_targets_failed", tool: call[:name].to_s, error: e.class.name,
                                                     msg: "#{call[:name]} targets failed: #{e.message}")
         none
       end
 
+      # +name+ as the acts_as of +entry+'s calls: nil for none, and for a
+      # core tool or a tool another bundle registered (logged); the tool's
+      # own name is no alias either.
+      def self.acts_as_of(name, entry, registry)
+        name = name.to_s.strip
+        return nil if name.empty? || name == entry.name
+
+        other = registry[name]
+        whose = if CORE_TOOLS.include?(name) || other&.core? then "a core tool"
+                elsif other && other.source != entry.source then "bundle #{other.source}'s tool"
+                end
+        return name unless whose
+
+        Log.warn(:plugins, "plugin_acts_as_dropped", tool: entry.name, acts_as: name,
+                                                     msg: "#{entry.name} targets: acts_as #{name} dropped: it is #{whose}")
+        nil
+      end
+
+      # The longest label: the question takes from targets:.
+      LABEL_CHARS = 80
+
+      # +label+ as a call's question label: stripped; nil for none, and for
+      # anything but a String of one line up to LABEL_CHARS (logged).
+      def self.label_of(label, entry)
+        return nil if label.nil?
+
+        text = label.is_a?(String) ? label.strip : nil
+        return nil if text && text.empty?
+        return text if text && !text.include?("\n") && text.length <= LABEL_CHARS
+
+        Log.warn(:plugins, "plugin_label_ignored", tool: entry.name,
+                                                   msg: "#{entry.name} targets: label ignored: not one line of at most #{LABEL_CHARS} characters")
+        nil
+      end
+
       # chi's own dirs (ParentApprovals.chi_dirs) and the session repo's
       # git hooks dir.
       def self.chi_dirs(context, base)
@@ -127,8 +196,11 @@ module Samagotchi
       end
 
       # @param chi_dirs [#call, nil] → the dirs touches_chi? looks for
-      def initialize(tool:, command:, paths:, cwd:, repo_root:, repo: nil, args: nil, model_name: nil, model_key: nil,
-                     session_root: nil, chi_dirs: nil)
+      def initialize(tool:, command:, paths:, cwd:, repo_root:, repo: nil, args: nil, acts_as: nil, label: nil,
+                     model_name: nil, model_key: nil, session_root: nil, chi_dirs: nil, memory_remove: false)
+        @acts_as = acts_as
+        @label = label
+        @memory_remove = memory_remove
         @repo = repo
         @chi_dirs = chi_dirs
         @session_root = session_root || repo_root || cwd

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/memory_bundle/index_updater.rb

@@ -25,7 +25,7 @@ module Samagotchi
           pattern = managed_pattern(entry_name)
           if content.match?(pattern)
             existing = content[pattern].to_s.chomp
-            resolved_desc = description&.to_s&.strip || extract_description(existing)
+            resolved_desc = blank_description?(description) ? extract_description(existing) : description
             resolved_source = source.nil? ? extract_source(existing) : (source || nil)
             new_line = managed_line(entry_name, scope, byte_count, resolved_desc, resolved_source)
             next content.sub(pattern) { new_line + $1 }
@@ -72,11 +72,14 @@ module Samagotchi
       def self.managed_line(name, scope, byte_count, description, source = nil)
         line = "- **#{name}** · #{scope} · #{date_str} · #{byte_count}"
         line += " · from #{source}" unless source.to_s.strip.empty?
-        desc = description&.to_s&.strip
-        line += " — #{desc}" unless desc.to_s.empty?
+        desc = description.to_s.gsub(/\s+/, " ").strip
+        line += " — #{desc}" unless desc.empty?
         line
       end
 
+      # A blank description (nil, "", whitespace) keeps the line's own.
+      def self.blank_description?(description) = description.to_s.strip.empty?
+
       def self.extract_description(line)
         if line =~ /\s—\s(.*)\s*\z/
           $1

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