samagotchi 0.36.0 → 0.38.0

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/kernel_loop.rb

@@ -176,8 +176,9 @@ module Samagotchi
     # @param on_stream_event [Proc, nil]         optional callback for generation events
     # @param cancel_controller [CancellationController, nil] optional cancellation source
     # @param model_name [String, nil]            optional per-run model override
-    # @param max_tool_output_chars [Integer, nil] per-output char cap for the
-    #   :tool_call_completed event's `output:` (nil → max_tool_output_chars)
+    # @param max_tool_output_chars [Integer, nil] per-output char cap on what
+    #   the model gets back and the :tool_call_completed event's `output:`
+    #   (nil → max_tool_output_chars)
     # @param pending_input [#call, nil]  optional drain proc returning
     #   Array<String> of user steering messages queued while the turn runs.
     #   Drained at iteration boundaries (llama.cpp's /completion cannot accept
@@ -223,7 +224,8 @@ module Samagotchi
       @model_key_fallback = fallback
     end
 
-    # Resolve the per-output character cap for the emitted tool call events.
+    # Resolve the per-output character cap for the tool outputs the model
+    # gets back and the emitted tool call events.
     #
     # Precedence: an explicit override wins, then max_tool_output_chars
     # (Config). A non-positive value falls back to
@@ -539,7 +541,7 @@ module Samagotchi
       runs = ToolResponse.run_batch(tool_runner, calls, iteration: turn.iteration, emit: turn.emit,
                                                         on_stream_event: turn.on_stream_event, cap: turn.cap)
       turn.tool_activity.concat(ToolResponse.activities(runs))
-      # One entry for the batch: the full outputs joined (ToolResponse.joined).
+      # One entry for the batch: the capped outputs joined (ToolResponse.joined).
       turn.conversation << ToolResponse.joined(runs)
       turn.pending_tool_calls = true
       :next

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/plugin/api.rb

@@ -178,9 +178,11 @@ module Samagotchi
       # down) and returns a short summary ("3 tools") or raises (the UIs
       # show a warn card). Every UI shows it running (the label) and done.
       # @param label [String] what it does, shown while it runs
-      # @param provides_tools [Boolean] it registers tools (chi.replace_tools):
-      #   a turn sent meanwhile waits for it before its first model request,
-      #   up to +timeout+; a Ctrl-C ends the wait
+      # @param provides_tools [Boolean] it provides what the plugin's tools
+      #   need (its own, or through chi.replace_tools; the mcp bundle's
+      #   index of a server's tools): a turn sent meanwhile waits for it
+      #   before its first model request, up to +timeout+; a Ctrl-C ends
+      #   the wait
       # @param quiet [Boolean] shown only if it fails (a background refresh)
       # @param timeout [Numeric, nil] seconds a turn waits for it (default 60)
       # @param failed [String, nil] the warn card's short title if it raises

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/tool_response.rb

@@ -4,9 +4,9 @@ module Samagotchi
   # A tool batch and the conversation entries its results become, for both
   # loops. The calls run through ToolRunner between the dispatch events;
   # what the model gets back is per format: the native loop answers a batch
-  # with ONE tool_response (#joined: the full outputs), the chat loop each
-  # call with its own, paired by tool_call_id (#single: the capped output,
-  # D-P2-6).
+  # with ONE tool_response (#joined), the chat loop each call with its own,
+  # paired by tool_call_id (#single). Both feed the capped outputs
+  # (max_tool_output_chars).
   module ToolResponse
     SEPARATOR = "\n\n---\n\n"
     # Saved with a result for the web's reload (a plugin tool's params line
@@ -37,12 +37,12 @@ module Samagotchi
       runs.filter_map { |run| run[:activity] }
     end
 
-    # The native loop's entry for a batch: the outputs joined, every image
+    # The native loop's entry for a batch: the capped outputs joined, every image
     # in call order with how many each call returned (the web's reload puts
     # each on its own tool row), and the saved-only fields one per call.
     def joined(runs)
       images = runs.flat_map { |run| Array(run[:images]) }
-      entry = { role: "tool_response", content: runs.map { |run| run[:output] }.join(SEPARATOR) }
+      entry = { role: "tool_response", content: runs.map { |run| run[:capped_output] }.join(SEPARATOR) }
       unless images.empty?
         entry[:images] = images
         entry[:image_counts] = runs.map { |run| Array(run[:images]).size }

data/lib/samagotchi/tool_runner.rb

@@ -13,9 +13,9 @@ module Samagotchi
   # The single per-call path both loops use: the tool_call_started and
   # tool_call_completed events, the guardrail gate (before_tool_call hooks
   # and their veto), dispatch through KernelLoop, the after_tool_call hook
-  # and the output cap. Each loop picks what the model gets back: native
-  # feeds the full `output:`, the chat loop feeds `capped_output:` (the cap
-  # on the event applies to both).
+  # and the output cap. Both loops feed the model `capped_output:` (cut to
+  # the cap with a "[cut: N of M chars …]" line), the text the event and
+  # the hook get too.
   class ToolRunner
     # More images in one result are left out, each with a line (a tool
     # that returns many screenshots can't flood the context).
@@ -83,12 +83,8 @@ module Samagotchi
       if (changed = changed_call_line(original, call))
         output = "#{changed}\n#{output}"
       end
-      capped = output
-      truncated = false
-      if max_tool_output_chars && output.length > max_tool_output_chars
-        truncated = true
-        capped = output[0, max_tool_output_chars]
-      end
+      truncated = !max_tool_output_chars.nil? && output.length > max_tool_output_chars
+      capped = truncated ? cut(output, max_tool_output_chars) : output
 
       # The call's outcome as its activity line has it (worked out from the
       # full output: ok, error, blocked, stopped); a dispatcher that raised
@@ -118,6 +114,19 @@ module Samagotchi
 
     private
 
+    # +output+ cut to +cap+ chars, the cut line included: the model knows
+    # what it didn't get. A cap smaller than the line keeps +cap+ chars and
+    # the line goes past it.
+    def cut(output, cap)
+      keep = cap - cut_line(cap, output.length).length
+      keep = cap unless keep.positive?
+      "#{output[0, keep]}#{cut_line(keep, output.length)}"
+    end
+
+    def cut_line(kept, total)
+      "\n[cut: #{kept} of #{total} chars; read it in parts]"
+    end
+
     # edit/write only: the file just before the call runs. The row diffs it
     # with the file after, whatever the result says, so an edit that fails
     # after writing still shows its change and one that wrote nothing shows

data/lib/samagotchi/update_command.rb

@@ -80,7 +80,7 @@ module Samagotchi
       @stderr = stderr
       @gem_spec = gem_spec
       @shipped_dir = shipped_dir
-      @platform = platform || ->(register:) { Desktop::MacOS.new(register: register, kitty: Desktop::MacOS.kitty_settings) }
+      @platform = platform || Desktop::MacOS.method(:from_config)
       @supported = supported
       @state_dir = state_dir
       @web = web || [Web::Lan.local_host(Config.get("web.host")), Config.get("web.port").to_i]

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.36.0"
+  VERSION = "0.38.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.38.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
@@ -234,6 +237,7 @@ files:
 - lib/samagotchi/desktop.rb
 - lib/samagotchi/desktop/macos.rb
 - lib/samagotchi/desktop/macos/App.swift
+- lib/samagotchi/desktop/macos/Broadcast.swift
 - lib/samagotchi/desktop/macos/ChiRunner.swift
 - lib/samagotchi/desktop/macos/Hotkey.swift
 - lib/samagotchi/desktop/macos/Images.swift
@@ -284,6 +288,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