samagotchi 0.36.0 → 0.37.0

data/lib/samagotchi/bundles/mcp/manifest.yml

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.5.0
+version: 0.5.1
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:b946862b2c74734dd5af9ffba12f14a79b760b993a1248630f9fc5ecaaa740f5
+  sha256: sha256:e41b880d70d2574f2be7d64e3ddee209ec77ce203f77d347ccdc6f9df1b358e1
 requires_chi: ">= 0.33.0"

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -247,10 +247,17 @@ class Plugin
     def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 
+  # One tool chi offers from a server (the tools: filter applied): +name+
+  # is the server's, +chi_name+ the model's (mcp_<server>_<tool>), +schema+
+  # its inputSchema (an empty object when it has none). +error+ is why
+  # declaring it failed (a name clash, a bad schema), nil when the model
+  # has it.
+  McpTool = Data.define(:server, :name, :chi_name, :description, :schema, :error)
+
   # One configured server: its service, state and tools. +listed+ is its
   # tools/list as the server answers it (what the cache keeps), +tools+
-  # the ones chi offers (the tools: filter applied, each with chi_name),
-  # +tokens+ their definitions' estimated size (#definition_tokens).
+  # the ones chi offers (McpTool each; #declare swaps in a whole new
+  # list), +tokens+ their definitions' estimated size (#definition_tokens).
   # +client+ is the running process's (a restart replaces it; the
   # service's stop closes the current one), +restarts+ how many it had.
   Server = Struct.new(:name, :config, :service, :state, :error, :tools, :listed, :timeout, :cwd, :command, :env,
@@ -516,31 +523,36 @@ class Plugin
   # tokens go to the log when they changed.
   def declare(target, server, ctx)
     wanted = server.config["tools"] && Array(server.config["tools"]).map(&:to_s)
-    tools = server.listed.map(&:dup)
-    tools = tools.select { |tool| wanted.any? { |w| File.fnmatch(w, tool["name"], File::FNM_EXTGLOB) } } if wanted
-    server.tools = tools
+    listed = server.listed
+    listed = listed.select { |tool| wanted.any? { |w| File.fnmatch(w, tool["name"], File::FNM_EXTGLOB) } } if wanted
     tokens = 0
-    tools.each do |tool|
-      name = tool_name(server.name, tool["name"])
-      schema = tool["inputSchema"] || { "type" => "object", "properties" => {} }
-      target.tool(name, description(tool), schema: schema,
-                                           label: "#{server.name}: #{tool["name"]}", preview: ->(args) { preview(args) }) do |args, call_ctx|
-        call(server, tool["name"], args, call_ctx)
+    tools = listed.map do |listed_tool|
+      tool = McpTool.new(server: server.name, name: listed_tool["name"],
+                         chi_name: tool_name(server.name, listed_tool["name"]), description: description(listed_tool),
+                         schema: listed_tool["inputSchema"] || { "type" => "object", "properties" => {} }, error: nil)
+      target.tool(tool.chi_name, tool.description, schema: tool.schema,
+                                                   label: "#{server.name}: #{tool.name}", preview: ->(args) { preview(args) }) do |args, call_ctx|
+        call(server, tool, args, call_ctx)
       end
-      tool["chi_name"] = name
-      tokens += definition_tokens(name, description(tool), schema)
+      tokens += definition_tokens(tool.chi_name, tool.description, tool.schema)
+      tool
     rescue ArgumentError => e
-      text = "MCP tool #{server.name}/#{tool["name"]} left out: #{e.message}"
+      text = "MCP tool #{server.name}/#{tool.name} left out: #{e.message}"
       ctx.notify(text, level: :warn) unless @left_out.include?(text)
       @left_out << text
+      tool.with(error: e.message)
     end
+    # Whole, in one swap: a reader on another thread never sees half a list.
+    server.tools = tools.freeze
     return if tokens == server.tokens
 
     server.tokens = tokens
-    ctx.log.info("mcp_tools_estimated", server: server.name, tools: tools.count { |tool| tool["chi_name"] },
-                                        tokens: tokens)
+    ctx.log.info("mcp_tools_estimated", server: server.name, tools: offered(server).size, tokens: tokens)
   end
 
+  # The server's tools the model has (declared without an error).
+  def offered(server) = server.tools.reject(&:error)
+
   # A tool's definition as the chat path sends it (LLM::ChatLoop#tool_definitions:
   # the chat schema, wrapped as a function), in estimated tokens
   # (TokenUsage::CHARS_PER_TOKEN). The native prompts (Gemma, Qwen) render a
@@ -579,8 +591,8 @@ class Plugin
     line.length > PREVIEW_CHARS ? "#{line[0, PREVIEW_CHARS - 1]}…" : line
   end
 
-  # A tools/call, as the model's tool result. A cached server starts
-  # here, on its first call.
+  # A tools/call of +tool+ (McpTool), as the model's tool result. A cached
+  # server starts here, on its first call.
   def call(server, tool, args, ctx)
     return "Error: MCP server #{server.name} didn't start: #{server.error}" if server.state == :failed
 
@@ -593,9 +605,9 @@ class Plugin
              end
     return client if client.is_a?(String)
 
-    result = client.request("tools/call", { name: tool, arguments: args }, timeout: server.timeout,
-                                                                           cancelled: -> { ctx.cancelled? })
-    text, images = content(result, server, tool)
+    result = client.request("tools/call", { name: tool.name, arguments: args }, timeout: server.timeout,
+                                                                                cancelled: -> { ctx.cancelled? })
+    text, images = content(result, server, tool.name)
     return "Error: #{text.empty? ? "the tool failed" : text}" if result["isError"]
 
     images.empty? ? text : Samagotchi::Plugin::ToolResult.new(text, images: images)
@@ -778,7 +790,7 @@ class Plugin
     servers = @servers.map do |server|
       head = "**#{server.name}**: #{state_text(server)}"
       # Sorted: a server lists its tools in its own (often grouped) order.
-      tools = server.tools.map { |tool| tool["chi_name"] }.compact.sort
+      tools = offered(server).map(&:chi_name).sort
       tools.empty? ? head : "#{head}\n#{tools.map { |t| "- `#{t}`" }.join("\n")}"
     end
     total = @servers.sum { |server| OFFERED.include?(server.state) ? server.tokens : 0 }
@@ -791,7 +803,7 @@ class Plugin
     case server.state
     when :cached then "cached (not started), #{server.tools.size} tool#{"s" unless server.tools.size == 1}, #{tokens_text(server)}"
     when :running
-      count = server.tools.count { |tool| tool["chi_name"] }
+      count = offered(server).size
       "running (pid #{server.client.pid}), #{count} tool#{"s" unless count == 1}, #{tokens_text(server)}"
     when :starting then "starting"
     else "#{server.state == :failed ? "failed" : "stopped"}: #{server.error}"

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.36.0
+version: 0.37.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/cli/command.rb

@@ -5,9 +5,9 @@ require_relative "exit"
 module Samagotchi
   module CLI
     # The usage side of a subcommand: its error lines, usage errors (exit 2)
-    # and help. The including class sets @stdout and @stderr and defines
-    # #command_name ("chi send"); its usage text is USAGE unless it
-    # overrides #usage_text.
+    # and help, and its piped stdin. The including class sets @stdout and
+    # @stderr (@stdin for #read_stdin) and defines #command_name ("chi
+    # send"); its usage text is USAGE unless it overrides #usage_text.
     module Command
       HELP_WORDS = %w[-h --help help].freeze
 
@@ -47,6 +47,30 @@ module Samagotchi
 
         parsed
       end
+
+      # The including class's @stdin, read only when it is a pipe or a
+      # file. A terminal means nobody piped anything in, and a socket a
+      # launcher or an agent's shell passes down may never close: waiting
+      # on either would hang a script. (A pipe the caller never closes
+      # still hangs, as it would for cat.)
+      # @return [String, nil] nil for a terminal or a socket
+      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
+
+      # +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
 end

data/lib/samagotchi/config.rb

@@ -89,6 +89,15 @@ module Samagotchi
       # delivers it there without triage.
       Entry.new(key: "broadcast.active_hours",   yaml_path: %w[broadcast active_hours],   type: :float,   default: 8.0,             expose: %i[env config]),
       Entry.new(key: "broadcast.ticket_pattern", yaml_path: %w[broadcast ticket_pattern], type: :string,  default: '\b[A-Z][A-Z0-9]+-\d+\b', expose: %i[env config]),
+      # The triage model that judges a recipient no tag matched (Broadcast::TriageModel): unset, recap.*'s, then
+      # default.model. At most triage_parallel requests at a time, all within triage_deadline seconds (the rest are
+      # delivered unchecked); a logprob P(yes) under threshold skips the session.
+      Entry.new(key: "broadcast.triage_model",   yaml_path: %w[broadcast triage_model],   type: :string,  default: nil,             expose: %i[env config]),
+      Entry.new(key: "broadcast.triage_host_ref", yaml_path: %w[broadcast triage_host_ref], type: :string, default: nil,            expose: %i[env config]),
+      Entry.new(key: "broadcast.triage_base_url", yaml_path: %w[broadcast triage_base_url], type: :string, default: nil,            expose: %i[env config]),
+      Entry.new(key: "broadcast.triage_parallel", yaml_path: %w[broadcast triage_parallel], type: :integer, default: 4,             expose: %i[env config]),
+      Entry.new(key: "broadcast.triage_deadline", yaml_path: %w[broadcast triage_deadline], type: :float,  default: 20.0,           expose: %i[env config]),
+      Entry.new(key: "broadcast.threshold",      yaml_path: %w[broadcast threshold],      type: :float,   default: 0.5,             expose: %i[env config]),
 
       Entry.new(key: "session.retention_days",        yaml_path: %w[session retention_days],        type: :integer, default: 14,   expose: %i[env config cli]),
       Entry.new(key: "session.max_count",             yaml_path: %w[session max_count],             type: :integer, default: 500,  expose: %i[env config cli]),

data/lib/samagotchi/context_command.rb

@@ -452,22 +452,5 @@ module Samagotchi
       error_line("#{command_name}: #{message}")
       CLI::Exit::FAILED
     end
-
-    # Only a pipe or a file is read, as chi note does: a terminal or a
-    # socket 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
-
-    def utf8(text)
-      text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
-    end
   end
 end

data/lib/samagotchi/engine.rb

@@ -2352,11 +2352,10 @@ module Samagotchi
     # @return [String] the answer
     def ask_side_model(request, timeout:, max_tokens:, cancel_controller:)
       target = session_model_recap_target
-      client = IdleClient.new(model: target[:model], base_url: target[:base_url], api_key_env: target[:api_key_env],
-                              timeout: timeout)
+      client = IdleClient.for(target, timeout: timeout)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       answer = client.ask(request, max_tokens: max_tokens, cancel_controller: cancel_controller)
-      Log.info(:plugins, "ask_model", model: target[:label], answer_model: answer.model, chars: answer.text.length,
+      Log.info(:plugins, "ask_model", model: target.label, answer_model: answer.model, chars: answer.text.length,
                                       ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       answer.text
     end
@@ -2372,10 +2371,9 @@ module Samagotchi
     # The session's current model as a recap target: its host's OpenAI API
     # (native llama.cpp hosts serve /v1/chat/completions too), key variable
     # and bare model name, as a turn resolves them.
+    # @return [IdleTarget]
     def session_model_recap_target
-      target = @host_registry.resolve(@effective_model_name)
-      { base_url: target.openai_base_url, api_key_env: target.entry.api_key_env,
-        model: target.bare_model, label: @effective_model_name.to_s }
+      IdleTarget.of_model(@host_registry, @effective_model_name)
     end
 
     # Build the idle reminders job. Always created (reminders are opt-in

data/lib/samagotchi/guardrail_wiring.rb

@@ -226,8 +226,13 @@ module Samagotchi
         return verdict.settle!(:deny, decided_by: "no one", note: "No one to approve it (non-interactive run).")
       end
 
-      # A plugin tool is asked about by its label, as its row shows it.
-      label = ToolActivity.plugin_label(verdict.call[:name].to_s, registry: @tools_lookup.call)
+      # A plugin tool is asked about by its targets:' label:, else its
+      # label, as its row shows it; a call that acts as another tool (an MCP
+      # tool behind mcp_call) by that tool's label, else (none registered)
+      # by its name (Approval.payload).
+      acts_as = verdict.targets&.acts_as
+      label = verdict.targets&.label ||
+              ToolActivity.plugin_label(acts_as || verdict.call[:name].to_s, registry: @tools_lookup.call)
       # verdict.call is the call that will run (a hook may have replaced it).
       payload = Guardrails::Approval.payload(verdict, label: label, preview: approval_preview(verdict.call),
                                                       only: (SCRATCH_SCOPES if @scratch))

data/lib/samagotchi/guardrails/approval.rb

@@ -18,7 +18,8 @@ module Samagotchi
 
       # @param verdict [Verdict] an ask, with its targets and context
       # @param label [String, nil] a plugin tool's label ("chrome:
-      #   screenshot"): the question names the tool by it, as its row does;
+      #   screenshot"): the question names the tool by it, as its row does
+      #   (without one, by the tool the call acts as, else its name);
       #   approval[:tool] stays the raw name
       # @param preview [Hash, nil] EditPreview.for(verdict.call) for edit and
       #   write: the card shows its diff, the question text one change line
@@ -37,6 +38,8 @@ module Samagotchi
           kind: KIND,
           approval: {
             tool: targets&.tool || verdict.call[:name].to_s,
+            # The tool the call acts as (an MCP tool behind mcp_call).
+            acts_as: targets&.acts_as,
             label: label,
             command: targets&.command,
             paths: targets && !targets.paths.empty? ? targets.paths : nil,
@@ -126,7 +129,7 @@ module Samagotchi
       #   change: +3 −1                      (edit/write, from the preview)
       def question_text(verdict, label: nil, preview: nil)
         targets = verdict.targets
-        tool = label || targets&.tool || verdict.call[:name].to_s
+        tool = label || targets&.acts_as || targets&.tool || verdict.call[:name].to_s
         what = targets&.command || (targets && targets.paths.join(", "))
         what = Approval.args_text(targets&.args, limit: ARGS_CHARS) if what.to_s.empty?
         lines = ["#{tool}: #{what}"]

data/lib/samagotchi/guardrails/approvals.rb

@@ -90,7 +90,7 @@ module Samagotchi
         return nil unless STORED_SCOPES.include?(scope)
 
         entry = { "scope" => scope, "tool" => verdict.targets&.tool || verdict.call[:name].to_s,
-                  "rule" => verdict.rule, "source" => verdict.source, "created_at" => Time.now.utc.iso8601 }
+                  "acts_as" => verdict.targets&.acts_as, "rule" => verdict.rule, "source" => verdict.source, "created_at" => Time.now.utc.iso8601 }
         case scope
         when "session" then entry.merge!("session_id" => verdict.context&.session_id, "key" => key_for(verdict))
         when "repo"
@@ -110,14 +110,18 @@ module Samagotchi
 
       # tool + the normalized command, or the sorted paths; for a plugin
       # tool with neither (an MCP tool), its arguments, so "this call" is
-      # this call.
+      # this call. A call that acts as another tool keys as
+      # `mcp_call>mcp_github_x`: the real name stays in, so it never reuses
+      # that tool's own approvals (nor they its).
       def self.key_for(verdict)
         t = verdict.targets
         return "#{verdict.call[:name]}:" unless t
-        return "#{t.tool}:#{t.command.to_s.strip.gsub(/\s+/, " ")}" if t.command
-        return "#{t.tool}:#{Approval.args_text(t.args)}" if t.paths.empty?
 
-        "#{t.tool}:#{t.paths.sort.join("\n")}"
+        tool = t.acts_as ? "#{t.tool}>#{t.acts_as}" : t.tool
+        return "#{tool}:#{t.command.to_s.strip.gsub(/\s+/, " ")}" if t.command
+        return "#{tool}:#{Approval.args_text(t.args)}" if t.paths.empty?
+
+        "#{tool}:#{t.paths.sort.join("\n")}"
       end
 
       def self.place_for(verdict)

data/lib/samagotchi/guardrails/rules.rb

@@ -9,7 +9,9 @@ module Samagotchi
     # Declarative rules from config.yml's `guardrails:` section (and, later,
     # installed bundles). All the fields a rule gives must match:
     #   tool:    a tool name, a list, or "shell" (execute + task_create);
-    #            a name may be a glob ("mcp_*", "mcp_{git,gh}_*")
+    #            a name may be a glob ("mcp_*", "mcp_{git,gh}_*"); it
+    #            matches the call's name or the tool a plugin tool's call
+    #            acts as (Targets#acts_as: an MCP tool behind mcp_call)
     #   command: a Ruby regex on a shell tool's command
     #   path:    "outside_repo", or a glob on the resolved paths (absolute
     #            or "**/…" globs match the absolute path; others the path
@@ -51,7 +53,7 @@ module Samagotchi
         def matches?(targets)
           return false unless targets
           return false unless for_model?(targets.model_name, targets.model_key, -> { targets.small_model? })
-          return false if tools && !tool_matches?(targets.tool)
+          return false if tools && !tool_matches?(targets.tool) && !(targets.acts_as && tool_matches?(targets.acts_as))
           return false if command && !(targets.command && command.match?(targets.command))
           return false if path && !path_matches?(targets)
           return false if git && !targets.git_outside_repo?

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,25 @@ 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
@@ -61,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
@@ -79,21 +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, memory_remove: memory_remove,
+            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)
@@ -101,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)
@@ -133,8 +196,10 @@ 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, memory_remove: false)
+      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