samagotchi 0.156.0 → 0.157.0

data/lib/samagotchi/host_address.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require_relative "config"
+
+module Samagotchi
+  # What a host's address says about it, without asking it: whether it is
+  # remote (a provider on the network rather than a local server), and the
+  # configured first-token limit. A leaf: HostRegistry::HostEntry and
+  # BootstrapCommand read it, it reads only Config.
+  module HostAddress
+    # Loopback, private (RFC 1918, IPv6 unique local) and link-local nets.
+    LOCAL_NETS = %w[127.0.0.0/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10
+                    ::1/128 fc00::/7 fe80::/10].map { |net| IPAddr.new(net) }.freeze
+
+    # Name suffixes that stay on a home or office network: mDNS, the
+    # special-use and customary private names, router defaults (fritz.box)
+    # and Tailscale's MagicDNS. Compared on whole labels.
+    LOCAL_NAME_SUFFIXES = %w[localhost local lan home home.arpa internal intranet localdomain private corp test
+                             box ts.net].freeze
+
+    # Whether an address is remote: https, an http IP address outside the
+    # local nets (LOCAL_NETS), or an http name with a dot whose suffix isn't
+    # a local one (LOCAL_NAME_SUFFIXES): `gpu.example.com` is remote, while
+    # `box`, `mac.local`, `gpu.lan` and `pc.tail1234.ts.net` are local. chi
+    # doesn't look names up; hosts.<name>.remote overrides either way.
+    def self.remote_address?(scheme, host)
+      return true if scheme.to_s == "https"
+
+      address = IPAddr.new(host.to_s.delete_prefix("[").delete_suffix("]"))
+      address = address.native if address.ipv4_mapped?
+      LOCAL_NETS.none? { |net| net.family == address.family && net.include?(address) }
+    rescue IPAddr::Error
+      remote_name?(host)
+    end
+
+    def self.remote_name?(host)
+      name = host.to_s.downcase.delete_suffix(".")
+      return false unless name.include?(".")
+
+      LOCAL_NAME_SUFFIXES.none? { |suffix| name == suffix || name.end_with?(".#{suffix}") }
+    end
+    private_class_method :remote_name?
+
+    # server.first_token_timeout, or nil when unset or unreadable.
+    def self.configured_first_token_timeout
+      Config.get("server.first_token_timeout")
+    rescue StandardError # degrade-ok: no configured limit; the host's own or the remote default applies
+      nil
+    end
+  end
+end

data/lib/samagotchi/host_registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "ipaddr"
 require_relative "config"
+require_relative "host_address"
 require_relative "log"
 require_relative "model_ref"
 require_relative "client"
@@ -88,11 +88,11 @@ module Samagotchi
       def dialect_profile = LLM::Dialect.for(dialect)
 
       # A provider on the network rather than a local server: hosts.<name>.remote
-      # when set, else by its address (HostRegistry.remote_address?). An API
+      # when set, else by its address (HostAddress.remote_address?). An API
       # key doesn't decide: a llama.cpp on the LAN can have one. A remote
       # host's model list is cached longer, it gets a first-token limit, and
       # it isn't asked for llama.cpp's /props.
-      def remote? = remote.nil? ? HostRegistry.remote_address?(scheme, host) : remote
+      def remote? = remote.nil? ? HostAddress.remote_address?(scheme, host) : remote
 
       def models_ttl = remote? ? REMOTE_CACHE_TTL_SECONDS : CACHE_TTL_SECONDS
 
@@ -102,7 +102,7 @@ module Samagotchi
       # and read_timeout catches a dead one). 0 turns it off.
       def first_token_limit
         seconds = first_token_timeout
-        seconds = HostRegistry.configured_first_token_timeout if seconds.nil?
+        seconds = HostAddress.configured_first_token_timeout if seconds.nil?
         seconds = remote? ? REMOTE_FIRST_TOKEN_TIMEOUT : nil if seconds.nil?
         seconds&.positive? ? seconds : nil
       end
@@ -115,13 +115,61 @@ module Samagotchi
       def openai_base_url = entry.openai_base_url
     end
 
+    # Raised when a client override is set on the shared registry (.current):
+    # every command and chi web's routes would then send through it.
+    class Shared < StandardError
+      def initialize(msg = "HostRegistry.current is shared: set a client override on a registry of your own") = super
+    end
+
     # A client that every target uses instead of its host's own (specs inject
     # a stub this way; the Engine/TUI `client:` keyword sets it).
-    attr_accessor :client_override
+    attr_reader :client_override
+
+    # @raise [Shared] on the shared registry (.current)
+    def client_override=(client)
+      raise Shared if @shared
+
+      @client_override = client
+    end
+
+    @current_mutex = Mutex.new
+
+    # The registry this process's commands and chi web share: one per
+    # process, built again when config.yml's hosts: no longer equal the ones
+    # it was built from (HostConfig.all, compared as read: the YAML read is
+    # mtime-cached), so a host added while chi web runs is listed on the next
+    # read, and its model lists, index and adapters are kept while hosts:
+    # stay. It doesn't rebuild on server.first_token_timeout or the
+    # server.host/port fallback entry: those are read at construction. It
+    # refuses a client override (Shared). An Engine and the TerminalUI take
+    # it once, at their start: a running worker keeps the hosts it started
+    # with.
+    # For any env but the process ENV (chi self's spec envs): a fresh
+    # registry on that env, never kept.
+    # @return [HostRegistry]
+    def self.current(env: ENV)
+      return new(env: env) unless env.equal?(ENV)
+
+      @current_mutex.synchronize do
+        hosts = HostConfig.all
+        if @current.nil? || hosts != @current_hosts
+          @current = new(hosts_config: hosts, shared: true)
+          @current_hosts = hosts
+        end
+        @current
+      end
+    end
+
+    # Forget the shared registry (specs: one per example).
+    def self.reset_current!
+      @current_mutex.synchronize { @current = @current_hosts = nil }
+    end
 
     # @param clock [#call, nil] monotonic seconds (specs)
-    def initialize(hosts_config: nil, env: ENV, client_override: nil, clock: nil)
+    # @param shared [Boolean] .current's own: refuses a client override
+    def initialize(hosts_config: nil, env: ENV, client_override: nil, clock: nil, shared: false)
       @client_override = client_override
+      @shared = shared
       @env = env
       @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       @adapters = {}
@@ -155,45 +203,9 @@ module Samagotchi
 
     attr_reader :entries
 
-    # Loopback, private (RFC 1918, IPv6 unique local) and link-local nets.
-    LOCAL_NETS = %w[127.0.0.0/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10
-                    ::1/128 fc00::/7 fe80::/10].map { |net| IPAddr.new(net) }.freeze
-
-    # Name suffixes that stay on a home or office network: mDNS, the
-    # special-use and customary private names, router defaults (fritz.box)
-    # and Tailscale's MagicDNS. Compared on whole labels.
-    LOCAL_NAME_SUFFIXES = %w[localhost local lan home home.arpa internal intranet localdomain private corp test
-                             box ts.net].freeze
-
-    # Whether an address is remote: https, an http IP address outside the
-    # local nets (LOCAL_NETS), or an http name with a dot whose suffix isn't
-    # a local one (LOCAL_NAME_SUFFIXES): `gpu.example.com` is remote, while
-    # `box`, `mac.local`, `gpu.lan` and `pc.tail1234.ts.net` are local. chi
-    # doesn't look names up; hosts.<name>.remote overrides either way.
-    def self.remote_address?(scheme, host)
-      return true if scheme.to_s == "https"
-
-      address = IPAddr.new(host.to_s.delete_prefix("[").delete_suffix("]"))
-      address = address.native if address.ipv4_mapped?
-      LOCAL_NETS.none? { |net| net.family == address.family && net.include?(address) }
-    rescue IPAddr::Error
-      remote_name?(host)
-    end
-
-    def self.remote_name?(host)
-      name = host.to_s.downcase.delete_suffix(".")
-      return false unless name.include?(".")
-
-      LOCAL_NAME_SUFFIXES.none? { |suffix| name == suffix || name.end_with?(".#{suffix}") }
-    end
-    private_class_method :remote_name?
-
-    # server.first_token_timeout, or nil when unset or unreadable.
-    def self.configured_first_token_timeout
-      Config.get("server.first_token_timeout")
-    rescue StandardError
-      nil
-    end
+    # The env its hosts, aliases and saved lists are read with (ENV, or chi
+    # self's): what an EffectiveModel's ModelLookup reads every layer with.
+    attr_reader :env
 
     def default_entry
       @entries["default"] || @entries.values.first

data/lib/samagotchi/kernel_loop.rb

@@ -792,20 +792,24 @@ module Samagotchi
       turn.qwen_attempts = 0
       turn.qwen_partial = nil
       runs = []
+      # The batch's ids before it runs (each run's events carry its own):
+      # nothing appends to the conversation during a batch, so they are the
+      # ids the entry would get after it (spec/tool_ids_pin_spec.rb).
+      ids = ToolIds.next_ids(turn.conversation, calls.size)
       begin
         ToolResponse.run_batch(tool_runner, calls, context: @context, iteration: turn.iteration, emit: turn.emit,
-                                                   on_stream_event: turn.on_stream_event, cap: turn.cap) { |run, _| runs << run }
+                                                   on_stream_event: turn.on_stream_event, cap: turn.cap, ids: ids) { |run, _| runs << run }
       rescue Interrupt
         # A Ctrl-C mid-batch: the entry still answers every call (the
         # finished runs, then run_batch's interrupted ones), for #run to
         # hand on with the conversation.
-        turn.conversation << ToolResponse.joined(runs, ids: ToolIds.next_ids(turn.conversation, runs.size))
+        turn.conversation << ToolResponse.joined(runs, ids: ids.first(runs.size))
         raise
       end
       turn.tool_activity.concat(ToolResponse.activities(runs))
       # One entry for the batch: the capped outputs joined (ToolResponse.joined),
       # an id per run (ToolIds).
-      turn.conversation << ToolResponse.joined(runs, ids: ToolIds.next_ids(turn.conversation, runs.size))
+      turn.conversation << ToolResponse.joined(runs, ids: ids.first(runs.size))
       turn.pending_tool_calls = true
       :next
     end

data/lib/samagotchi/llm/chat_loop.rb

@@ -1132,10 +1132,13 @@ module Samagotchi
         def dispatch(tool_calls, iteration, cap)
           log_direct_deferred(tool_calls)
           calls = tool_calls.map { |tool_call| NativeToolNormalizer.normalize(tool_call) }
+          # The batch's ids before it runs (each run's events carry its own):
+          # the same as one next id per result as it lands
+          # (spec/tool_ids_pin_spec.rb).
+          ids = ToolIds.next_ids(@conversation, calls.size)
           runs = ToolResponse.run_batch(@loop.tool_runner, calls, context: @turn_context, iteration: iteration, emit: method(:emit),
-                                                                  on_stream_event: @on_stream_event, cap: cap) do |run, index|
-            @conversation << ToolResponse.single(run, tool_call_id: tool_calls[index].id,
-                                                      ids: ToolIds.next_ids(@conversation, 1))
+                                                                  on_stream_event: @on_stream_event, cap: cap, ids: ids) do |run, index|
+            @conversation << ToolResponse.single(run, tool_call_id: tool_calls[index].id, ids: [ids[index]])
           end
           @tool_activity.concat(ToolResponse.activities(runs))
         end

data/lib/samagotchi/llm_context_strategy.rb

@@ -148,10 +148,10 @@ module Samagotchi
     end
 
     # Where one value came from: :session, :model_setting, :host_setting
-    # or :config, and the place as a warning names it ("the session",
-    # "models: deepseek", "hosts entry 'box'", "llm_context.apply").
+    # or :config, and the place, named as the other settings name theirs
+    # ("session", "models: deepseek", "hosts.box", "llm_context.apply").
     Origin = Data.define(:source, :where)
-    SESSION_ORIGIN = Origin.new(source: :session, where: "the session")
+    SESSION_ORIGIN = Origin.new(source: :session, where: "session")
 
     # What a turn's strategy, apply rule and budget are, each with its
     # Origin (/llm-context, /stats, the web's info bar).
@@ -169,26 +169,22 @@ module Samagotchi
       end
     end
 
-    # The strategy for +target+'s turn.
-    # @param target [HostRegistry::ModelTarget, nil]
-    # @param names [Array<String>] HostRegistry#lookup_names
-    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
+    # The strategy for +lookup+'s model's turn.
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @param session [Array<Symbol>, nil] the session's own layers ([]: none)
     # @param session_apply [Symbol, nil] the session's own apply rule
     # @param session_budget [Integer, nil] the session's own budget (0: off)
     # @return [Resolved]
-    def resolve(target, names:, models: nil, session: nil, session_apply: nil, session_budget: nil)
-      explain(target, names: names, models: models, session: session, session_apply: session_apply,
-                      session_budget: session_budget).resolved
+    def resolve(lookup, session: nil, session_apply: nil, session_budget: nil)
+      explain(lookup, session: session, session_apply: session_apply, session_budget: session_budget).resolved
     end
 
     # #resolve, with where each value came from.
     # @return [Explained]
-    def explain(target, names:, models: nil, session: nil, session_apply: nil, session_budget: nil)
-      models ||= ModelSettings.all
-      layers, source, where = layers_for(target, names, models, session)
-      apply, apply_origin = apply_for(target, names, models, session_apply)
-      budget, budget_origin = budget_for(target, names, models, session_budget)
+    def explain(lookup, session: nil, session_apply: nil, session_budget: nil)
+      layers, source, where = layers_for(lookup, session)
+      apply, apply_origin = apply_for(lookup, session_apply)
+      budget, budget_origin = budget_for(lookup, session_budget)
       resolved = resolved(layers, source, where).with(apply: apply, protect_steps: protect_steps,
                                                       stale_edits: Config.get(STALE_EDITS_SETTING) == true,
                                                       budget_tokens: budget)
@@ -196,79 +192,47 @@ module Samagotchi
                     budget_tokens: budget_origin)
     end
 
-    # A session's LLM context strategy, apply rule and budget, each with
-    # where it came from (Explained#summary), as its worker would resolve
-    # them; nil when they can't be (an unreadable config, a model that
-    # resolves nowhere). Resolves from config and the registry only: no
-    # network, no model call. What a session page, a session list's ctx %
-    # and a spawn-time check all read.
-    # @param session [Session, nil]
-    # @param registry [HostRegistry, nil] the hosts to resolve against;
-    #   HostRegistry.new by default (what the caller usually has)
-    # @return [Hash, nil] Explained#summary, symbol keys
-    def for_session(session, registry: nil)
-      return nil if session.nil?
-
-      # Here, not at the top: config.rb requires this file before ConfigFile
-      # exists, and effective_model.rb requires config.rb (via host_registry.rb).
-      require_relative "effective_model"
-      registry ||= HostRegistry.new
-      own = session.llm_context
-      EffectiveModel.of_session(session, registry: registry).llm_context_explained(own&.resolve_args || {})&.summary(own)
-    rescue StandardError
-      nil
-    end
-
-    # The budget a session's turns run under (for_session's :budget_tokens),
-    # nil when it is off or can't be resolved. What a session list's ctx %
-    # counts against, so a saved session's fill reads as the live meter.
-    # @param session [Session, nil]
-    # @param registry [HostRegistry, nil] see .for_session
-    # @return [Integer, nil]
-    def session_budget(session, registry: nil)
-      for_session(session, registry: registry)&.fetch(:budget_tokens, nil)
-    end
-
     # [the budget, its Origin]: the session's own first (0 there is off,
     # whatever the model says).
-    def budget_for(target, names, models, session_budget)
+    def budget_for(lookup, session_budget)
       return [session_budget.positive? ? session_budget : nil, SESSION_ORIGIN] unless session_budget.nil?
 
-      if (setting = ModelSettings.find(names, :llm_context_budget_tokens, models: models))
+      if (setting = lookup.model(:llm_context_budget_tokens))
         return [setting.value, Origin.new(source: :model_setting, where: "models: #{setting.key}")]
       end
 
-      budget = target&.entry&.llm_context_budget_tokens
-      return [budget, Origin.new(source: :host_setting, where: "hosts entry '#{target.entry.name}'")] if budget
+      budget = lookup.host(:llm_context_budget_tokens)
+      return [budget, Origin.new(source: :host_setting, where: "hosts.#{lookup.host_name}")] if budget
 
-      [parse_budget(Config.get(BUDGET_SETTING), BUDGET_SETTING), Origin.new(source: :config, where: BUDGET_SETTING)]
+      [parse_budget(lookup.global(BUDGET_SETTING).first, BUDGET_SETTING), Origin.new(source: :config, where: BUDGET_SETTING)]
     end
 
-    def layers_for(target, names, models, session)
+    def layers_for(lookup, session)
       return [session, :session, SESSION_ORIGIN.where] if session
 
-      if (setting = ModelSettings.find(names, :llm_context_strategy, models: models))
+      if (setting = lookup.model(:llm_context_strategy))
         return [setting.value, :model_setting, "models: #{setting.key}"]
       end
 
-      layers = target&.entry&.llm_context_strategy
-      return [layers, :host_setting, "hosts entry '#{target.entry.name}'"] if layers
+      layers = lookup.host(:llm_context_strategy)
+      return [layers, :host_setting, "hosts.#{lookup.host_name}"] if layers
 
-      [parse(Config.get(SETTING), SETTING) || [], :config, SETTING]
+      [parse(lookup.global(SETTING).first, SETTING) || [], :config, SETTING]
     end
 
     # [the apply rule, its Origin].
-    def apply_for(target, names, models, session_apply)
+    def apply_for(lookup, session_apply)
       return [session_apply, SESSION_ORIGIN] if session_apply
 
-      if (setting = ModelSettings.find(names, :llm_context_apply, models: models))
+      if (setting = lookup.model(:llm_context_apply))
         return [setting.value, Origin.new(source: :model_setting, where: "models: #{setting.key}")]
       end
 
-      apply = target&.entry&.llm_context_apply
-      return [apply, Origin.new(source: :host_setting, where: "hosts entry '#{target.entry.name}'")] if apply
+      apply = lookup.host(:llm_context_apply)
+      return [apply, Origin.new(source: :host_setting, where: "hosts.#{lookup.host_name}")] if apply
 
-      [parse_apply(Config.get(APPLY_SETTING), APPLY_SETTING) || DEFAULT_APPLY, Origin.new(source: :config, where: APPLY_SETTING)]
+      [parse_apply(lookup.global(APPLY_SETTING).first, APPLY_SETTING) || DEFAULT_APPLY,
+       Origin.new(source: :config, where: APPLY_SETTING)]
     end
 
     # llm_context.protect_steps: 0 or more (a negative one is the default).

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -75,6 +75,20 @@ module Samagotchi
                       plugin_file: plugin_file, script_files: script_files)
       end
 
+      # Whether the bundle file +src+ reads through a symlink: it is one, or
+      # it (or its dir, hooks/ say) resolves outside +bundle_dir+. A tar,
+      # zip or git repo keeps links; copying through one would install any
+      # file the user can read. MemoryFiles skips linked memories the same
+      # way. ShippedUpdate's plan reads it too.
+      def self.linked?(src, bundle_dir)
+        return true if File.symlink?(src)
+
+        root = File.realpath(bundle_dir)
+        !File.realpath(src).start_with?("#{root}/")
+      rescue SystemCallError
+        true
+      end
+
       private
 
       # Copies the bundle's hooks/*.rb into <bundle_dir>/hooks/: the ones
@@ -107,10 +121,8 @@ module Samagotchi
       # One listed hook; an upgrade overwrites a local edit with a warning.
       def install_hook(basename, src)
         dest = File.join(@provenance.hooks_dir, basename)
-        if @dry_run
-          @results[basename] = { status: File.exist?(dest) && !@force ? "would_skip" : "would_install" }
-          return
-        end
+        result = result_for(src, dest, updated: @upgrade && @existing)
+        return @results[basename] = planned(result) if @dry_run
 
         prev_sha = @existing&.hooks&.dig(basename)&.sha256
         if @upgrade && File.exist?(dest) && !@force && !Provenance.recorded_sha(prev_sha).empty? && !Provenance.sha_matches?(dest, prev_sha)
@@ -118,16 +130,9 @@ module Samagotchi
         end
 
         FileUtils.mkdir_p(@provenance.hooks_dir)
-        unchanged = File.exist?(dest) && FileUtils.identical?(src, dest)
         @trash.copy_edit(dest, as: "hooks/#{basename}", recorded: prev_sha, incoming: src)
         place(src, dest)
-        @results[basename] = if unchanged
-                               { status: "skipped", reason: "already up to date" }
-                             elsif @upgrade && @existing
-                               { status: "updated" }
-                             else
-                               { status: "installed" }
-                             end
+        @results[basename] = result
         @hook_files[basename] = dest
       end
 
@@ -139,13 +144,13 @@ module Samagotchi
 
           @bundle_hooks << basename
           if @dry_run
-            @results[basename] = { status: "would_install" }
+            @results[basename] = Installer::FileResult.new(word: :would_install)
           else
             FileUtils.mkdir_p(@provenance.hooks_dir)
             dest = File.join(@provenance.hooks_dir, basename)
             @trash.copy_edit(dest, as: "hooks/#{basename}", recorded: @existing&.hooks&.dig(basename)&.sha256, incoming: src)
             place(src, dest)
-            @results[basename] = { status: "installed" }
+            @results[basename] = Installer::FileResult.new(word: :installed)
             @hook_files[basename] = dest
           end
         end
@@ -166,22 +171,17 @@ module Samagotchi
         end
       end
 
-      # Strict mode: an installed hook whose sha256 differs from the one its
-      # manifest declares warns (as verify_memory_checksums does).
+      # Strict mode: a hook whose sha256 differs from the one its manifest
+      # declares warns (as verify_memory_checksums does). The bundle's file is
+      # checked, the one the install copies, so a dry run checks what it
+      # would install, not the old hook in place.
       def verify_hook_checksums
         @bundle_hooks.each do |basename|
           next if @conflicts.key?(basename)
 
-          expected = @manifest.checksum_for_hook(basename)
-          next unless expected
-
-          dest = File.join(@provenance.hooks_dir, basename)
-          next unless File.exist?(dest)
-
-          actual = FileDigest.hex(dest)
-          if actual != expected
-            @warnings << "Checksum mismatch for hook #{basename}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
-          end
+          warning = FileDigest.mismatch("hook #{basename}", File.join(@bundle_dir, "hooks", basename),
+                                        @manifest.checksum_for_hook(basename))
+          @warnings << warning if warning
         end
       end
 
@@ -190,16 +190,13 @@ module Samagotchi
       # installed are reported up to date, not "Installed".
       # @return [Hash{String => String}] basename => installed path ({} on a dry run)
       def install_guardrails(incoming_rules)
+        target = @provenance.guardrails_dir
+        results = incoming_rules.to_h { |src| [src, result_for(src, File.join(target, File.basename(src)), updated: false)] }
         if @dry_run
-          incoming_rules.each { |src| @results["guardrails/#{File.basename(src)}"] = { status: "would_install" } }
+          results.each { |src, result| @results["guardrails/#{File.basename(src)}"] = planned(result) }
           return {}
         end
 
-        target = @provenance.guardrails_dir
-        unchanged = incoming_rules.select do |src|
-          dest = File.join(target, File.basename(src))
-          File.file?(dest) && FileUtils.identical?(src, dest)
-        end
         @trash.copy_edits(target, "guardrails", @existing&.guardrails, incoming_rules.to_h { |src| [File.basename(src), src] })
         FileUtils.rm_rf(target)
         return {} if incoming_rules.empty?
@@ -208,8 +205,7 @@ module Samagotchi
         incoming_rules.to_h do |src|
           dest = File.join(target, File.basename(src))
           place(src, dest)
-          @results["guardrails/#{File.basename(src)}"] =
-            unchanged.include?(src) ? { status: "skipped", reason: "already up to date" } : { status: "installed" }
+          @results["guardrails/#{File.basename(src)}"] = results[src]
           [File.basename(src), dest]
         end
       end
@@ -235,29 +231,20 @@ module Samagotchi
         if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, @chi_version))
           @warnings << "Plugin #{plugin[:file]} won't load: #{failure}"
         end
+        dest = File.join(@provenance.plugin_dir, plugin[:file])
+        result = result_for(src, dest, updated: @upgrade && @provenance.installed?)
         if @dry_run
-          @results[plugin[:file]] = { status: "would_install" }
+          @results[plugin[:file]] = planned(result)
           return nil
         end
 
-        dest = File.join(@provenance.plugin_dir, plugin[:file])
-        unchanged = File.file?(dest) && FileUtils.identical?(src, dest)
         @trash.copy_edits(@provenance.plugin_dir, "plugin", @existing&.plugin_shas, { plugin[:file] => src })
         FileUtils.rm_rf(@provenance.plugin_dir)
         FileUtils.mkdir_p(@provenance.plugin_dir)
         place(src, dest)
-        @results[plugin[:file]] = if unchanged
-                                    { status: "skipped", reason: "already up to date" }
-                                  elsif @upgrade && @provenance.installed?
-                                    { status: "updated" }
-                                  else
-                                    { status: "installed" }
-                                  end
-        expected = @manifest.checksum_for_plugin
-        actual = FileDigest.hex(dest)
-        if @strict && !@dev && expected && actual != expected
-          @warnings << "Checksum mismatch for plugin #{plugin[:file]}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
-        end
+        @results[plugin[:file]] = result
+        warning = FileDigest.mismatch("plugin #{plugin[:file]}", dest, @manifest.checksum_for_plugin) if @strict && !@dev
+        @warnings << warning if warning
         dest
       end
 
@@ -274,12 +261,15 @@ module Samagotchi
 
           @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src) && !page_only?(file)
         end
-        return {} if @dry_run
-
-        unchanged = scripts.keys.select do |file|
-          dest = File.join(@provenance.scripts_dir, file)
-          File.file?(dest) && FileUtils.identical?(File.join(@bundle_dir, "scripts", file), dest)
+        results = scripts.keys.to_h do |file|
+          [file, result_for(File.join(@bundle_dir, "scripts", file), File.join(@provenance.scripts_dir, file),
+                            updated: @upgrade && @provenance.installed?)]
+        end
+        if @dry_run
+          results.each { |file, result| @results["scripts/#{file}"] = planned(result) }
+          return {}
         end
+
         @trash.copy_edits(@provenance.scripts_dir, "scripts", @existing&.scripts,
                           scripts.keys.to_h { |file| [file, File.join(@bundle_dir, "scripts", file)] })
         FileUtils.rm_rf(@provenance.scripts_dir)
@@ -289,20 +279,36 @@ module Samagotchi
         scripts.to_h do |file, declared|
           dest = File.join(@provenance.scripts_dir, file)
           place(File.join(@bundle_dir, "scripts", file), dest)
-          @results["scripts/#{file}"] = if unchanged.include?(file) then { status: "skipped", reason: "already up to date" }
-                                        elsif @upgrade && @provenance.installed? then { status: "updated" }
-                                        else { status: "installed" }
-                                        end
+          @results["scripts/#{file}"] = results[file]
           FileUtils.chmod(0o755, dest) unless @dev
-          actual = FileDigest.hex(dest)
-          expected = declared.to_s.delete_prefix("sha256:")
-          if @strict && !@dev && !expected.empty? && actual != expected
-            @warnings << "Checksum mismatch for script #{file}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
-          end
+          warning = FileDigest.mismatch("script #{file}", dest, declared.to_s.delete_prefix("sha256:")) if @strict && !@dev
+          @warnings << warning if warning
           [file, dest]
         end
       end
 
+      # What the real run reports for +src+ over +dest+: up to date when the
+      # bytes are the same, else updated (+updated+: an upgrade over an
+      # install) or installed. A dry run records #planned of it, so the two
+      # can't drift.
+      def result_for(src, dest, updated:)
+        word = if File.file?(dest) && FileUtils.identical?(src, dest) then :up_to_date
+               elsif updated then :updated
+               else :installed
+               end
+        Installer::FileResult.new(word: word)
+      end
+
+      # A dry run's word for a result: would_install, would_update, or the
+      # up to date result as it is (nothing would be written).
+      def planned(result)
+        case result.word
+        when :installed then result.with(word: :would_install)
+        when :updated then result.with(word: :would_update)
+        else result
+        end
+      end
+
       # A file only a block renderer's load names: the page loads it, nothing runs it.
       def page_only?(file)
         @manifest.block_renderers.any? { |renderer| renderer.load.include?(file) } &&
@@ -316,19 +322,8 @@ module Samagotchi
         @dev ? File.symlink(File.realpath(src), dest) : FileUtils.cp(src, dest)
       end
 
-      # Whether the bundle file +src+ reads through a symlink: it is one, or
-      # it (or its dir, hooks/ say) resolves outside the bundle dir. A tar,
-      # zip or git repo keeps links; copying through one would install any
-      # file the user can read. MemoryFiles skips linked memories the same
-      # way.
-      def linked?(src)
-        return true if File.symlink?(src)
-
-        root = File.realpath(@bundle_dir)
-        !File.realpath(src).start_with?("#{root}/")
-      rescue SystemCallError
-        true
-      end
+      # AssetInstaller.linked? for this bundle's source.
+      def linked?(src) = self.class.linked?(src, @bundle_dir)
 
       # linked? with a "<label> is a symlink (not installed)" warning.
       def linked_out?(src, label)

data/lib/samagotchi/memory_bundle/builder.rb

@@ -227,7 +227,8 @@ module Samagotchi
           files: files_map,
           hooks: parts.hooks.empty? ? nil : parts.hooks,
           trust_level: trust_level,
-          plugin: parts.plugin && { file: File.basename(parts.plugin), sha256: FileDigest.sha256(parts.plugin) },
+          plugin: parts.plugin && { file: File.basename(parts.plugin), sha256: FileDigest.sha256(parts.plugin),
+                                    required: manifest&.plugin_required },
           requires_chi: manifest&.requires_chi,
           needs: manifest&.needs,
           scripts: parts.scripts.transform_values { |src| FileDigest.sha256(src) },