samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/memory_bundle/trash.rb

@@ -99,28 +99,38 @@ module Samagotchi
         dest
       end
 
-      # Copies the file at +path+ as +as+ before it is replaced or removed, when
-      # that would lose something: its bytes are neither what the record says
-      # was installed (no sha recorded: unknown, so it counts as edited) nor
-      # +incoming+'s. A link (a dev install's) points at its source, which
-      # nothing here touches.
-      def copy_edit(path, as:, recorded: nil, incoming: nil)
-        return if File.symlink?(path) || !File.file?(path)
-        return if incoming && File.file?(incoming) && FileUtils.identical?(incoming, path)
-        return if !Provenance.recorded_sha(recorded).empty? && Provenance.sha_matches?(path, recorded)
-
-        copy(path, as: as)
-      end
-
-      # copy_edit for every file under +dir+, which is about to go, at any depth
-      # (kept as <label>/<its path in dir>). A linked dir isn't followed.
+      # Copies every file under +dir+, which is about to be replaced or
+      # removed, when that would lose something: its bytes are neither what
+      # the record says was installed (no sha recorded: unknown, so it counts
+      # as edited) nor the incoming source's, at any depth (kept as
+      # <label>/<its path in dir>). A link (a dev install's) points at its
+      # source, which nothing here touches; a linked dir isn't followed.
       # @param recorded [Hash, nil] path in dir => its recorded sha256
       # @param incoming [Hash] path in dir => the source replacing it
       def copy_edits(dir, label, recorded = nil, incoming = {})
-        return if File.symlink?(dir) || !File.directory?(dir)
+        self.class.edited_in(dir, recorded, incoming).each { |file| copy(File.join(dir, file), as: "#{label}/#{file}") }
+      end
+
+      # Whether #copy_edits would copy the file at +path+ (read-only): the rule
+      # ShippedUpdate's plan names its replaced files by.
+      def self.edit?(path, recorded: nil, incoming: nil)
+        return false if File.symlink?(path) || !File.file?(path)
+        return false if incoming && File.file?(incoming) && FileUtils.identical?(incoming, path)
+
+        Provenance.recorded_sha(recorded).empty? || !Provenance.sha_matches?(path, recorded)
+      end
+
+      # What #copy_edits would copy (read-only), as <label>/<its path in dir>.
+      def self.edits(dir, label, recorded = nil, incoming = {})
+        edited_in(dir, recorded, incoming).map { |file| "#{label}/#{file}" }
+      end
+
+      # The files under +dir+ (paths in it) #copy_edits copies.
+      def self.edited_in(dir, recorded, incoming)
+        return [] if File.symlink?(dir) || !File.directory?(dir)
 
-        Dir.glob("**/*", File::FNM_DOTMATCH, base: dir).sort.each do |file|
-          copy_edit(File.join(dir, file), as: "#{label}/#{file}", recorded: recorded&.[](file), incoming: incoming[file])
+        Dir.glob("**/*", File::FNM_DOTMATCH, base: dir).sort.select do |file|
+          edit?(File.join(dir, file), recorded: recorded&.[](file), incoming: incoming[file])
         end
       end
 

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -4,8 +4,8 @@ require "fileutils"
 require "digest"
 require_relative "../memory_paths"
 require_relative "provenance"
+require_relative "file_actions"
 require_relative "index_updater"
-require_relative "merger"
 require_relative "trash"
 require_relative "../model_overlay"
 
@@ -64,17 +64,22 @@ module Samagotchi
           [key, Provenance.claimants(key, scope: target_scope, except: @name)]
         end.reject { |_, others| others.empty? }
 
+        # Each file's UNINSTALL row (its source-less FileState): an edit
+        # refuses, unless --force (which moves it to the trash with the rest).
         blocked = []
-        files.each do |file_key, _meta|
-          file_key_str = file_key.to_s
-          target_path = File.join(target_dir, file_key_str)
-          base_path = provenance.base_path(file_key_str)
-          next unless File.exist?(target_path)
-          next if shared.key?(file_key_str)
-
-          if !@force && File.exist?(base_path) && Merger.current_modified?(base_path, target_path)
-            blocked << file_key_str
-            @warnings << "Skipped #{file_key_str}: local edits detected (#{FileStanding::FORCE_MOVES})"
+        unless @force
+          files.each_key do |file_key|
+            key = file_key.to_s
+            state = FileState.of(key, record: bundle, provenance: provenance, target_dir: target_dir, source_dir: nil,
+                                      claimants: ->(k) { shared.fetch(k, []) })
+            next unless FileActions.for(:uninstall, state)&.do == :refuse
+            # Kept for another bundle, read or not.
+            next if state.shared_with.any?
+
+            # Whether it was edited can't be told: the read raises (nothing lost).
+            FileDigest.hex(state.paths[:current]) if state.kind == :unreadable
+            blocked << key
+            @warnings << "Skipped #{key}: local edits detected (#{FileStanding::FORCE_MOVES})"
           end
         end
 

data/lib/samagotchi/memory_orphans.rb

@@ -19,14 +19,14 @@ module Samagotchi
 
     module_function
 
-    # The orphan candidates for +cwd+'s project, or nil: only inside a git
-    # repository (outside one the root is cwd, and every src/ or tmp/ would
-    # match), and only while the computed folder holds no *.md (a
+    # The orphan candidates for +cwd+'s project, or nil: only inside a
+    # project, a git repository or a marked folder (outside both the root is
+    # cwd, and every src/ or tmp/ would match), and only while the computed folder holds no *.md (a
     # memory_write's mkdir_p or a project-scope bundle install alone must
     # not silence it).
     # @return [Found, nil]
     def find(env: ENV, cwd: Dir.pwd)
-      return nil unless MemoryPaths.in_repo?(cwd)
+      return nil unless MemoryPaths.in_project?(cwd)
 
       projects = MemoryPaths.projects_dir(env: env)
       computed = MemoryPaths.project_dir(env: env, cwd: cwd)

data/lib/samagotchi/memory_paths.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 require_relative "config"
+require_relative "guardrails/path_resolve"
 
 module Samagotchi
   # Where memories live: <config dir>/memories, i.e. $XDG_CONFIG_HOME/samagotchi/memories
@@ -9,11 +10,61 @@ module Samagotchi
   # ConfigFile.global_path, so an XDG_CONFIG_HOME set after load (specs, smoke runs,
   # a fixture chi) moves memories together with config.yml.
   #
-  # Project memories are keyed by the project root (see project_root), so every
-  # worktree and subdirectory of one git repository shares one folder.
+  # Project memories are keyed by the project root (see #lookup): one folder
+  # per project root, a git repository (every worktree and subdirectory of it
+  # shares one folder) or a folder marked by `chi project init` (and its
+  # subfolders).
   module MemoryPaths
+    # The file that makes a folder in no git repository a chi project
+    # (`chi project init`). The file, not the bare .chi/ dir, is the marker.
+    MARKER = File.join(".chi", "project.yml").freeze
+
+    # How a folder's project was found (#lookup): +kind+ is :git, :marker or
+    # :none; +root+ is what memories are keyed on (#project_root: git's
+    # common-dir checkout, the marked folder's realpath, or the folder
+    # itself); +top+ is the folder a session reads its AGENTS.md chain from
+    # (the work tree's top, the marked root; nil for :none).
+    ProjectLookup = Data.define(:kind, :root, :top) do
+      def project? = kind != :none
+      def git? = kind == :git
+      def marker? = kind == :marker
+    end
+
     module_function
 
+    # The project +cwd+ belongs to, looked up once: a .git above it wins
+    # (git is the identity wherever it exists); only when there is none, the
+    # nearest MARKER above it, ignoring one in $HOME or any folder above it
+    # (and /), so a marker in ~ never makes every folder under home one
+    # project. The marker walk starts from +cwd+'s real path and the marked
+    # root is a realpath, as git's root is, so every spelling of a folder
+    # (/tmp, /var on macOS, a symlink into or out of a marked tree) gets the
+    # answer the worker's physical Dir.pwd gets.
+    # @param home [String, nil] $HOME by default; nil or blank ignores only /
+    # @return [ProjectLookup]
+    def lookup(cwd = Dir.pwd, home: default_home)
+      dot_git = find_dot_git(cwd)
+      return ProjectLookup.new(kind: :git, root: git_root(dot_git), top: File.dirname(dot_git)) if dot_git
+
+      marked = nearest_marker(cwd, home: home)
+      return ProjectLookup.new(kind: :marker, root: marked, top: marked) if marked
+
+      ProjectLookup.new(kind: :none, root: cwd, top: nil)
+    end
+
+    # Whether a marker at +dir+ is ignored: +dir+ is / or holds $HOME (both
+    # resolved; Guardrails::PathResolve.home_root?).
+    def above_home?(dir, home: default_home)
+      Guardrails::PathResolve.real(dir) == "/" || Guardrails::PathResolve.home_root?(dir, home)
+    end
+
+    # $HOME, or nil when it can't be found (no HOME, no passwd entry).
+    def default_home
+      Dir.home
+    rescue ArgumentError
+      nil
+    end
+
     def system_dir(env: ENV)
       File.join(ConfigFile.config_dir(env: env), "memories")
     end
@@ -28,16 +79,31 @@ module Samagotchi
     # #project_key for a root already resolved (a session's project_root).
     def key_for_root(root) = "#{File.basename(root)}_#{Digest::MD5.hexdigest(root)[0..7]}"
 
-    # The repository's common git directory identifies the project; every linked
-    # worktree shares it. Returns the checkout holding it when it is named .git,
-    # otherwise the git dir itself (a bare repo, a proj/.bare layout,
-    # --separate-git-dir, a submodule's .git/modules/<name>), so for those layouts
-    # the "project root" is a git dir, not a checkout. Outside any repository the
-    # root is cwd. No git subprocess: at most two small files are read.
-    def project_root(cwd = Dir.pwd)
-      dot_git = find_dot_git(cwd)
-      return cwd unless dot_git
+    # The project root (#lookup): in a repository, its common git directory
+    # identifies the project; every linked worktree shares it. Returns the
+    # checkout holding it when it is named .git, otherwise the git dir itself
+    # (a bare repo, a proj/.bare layout, --separate-git-dir, a submodule's
+    # .git/modules/<name>), so for those layouts the "project root" is a git
+    # dir, not a checkout. Outside any repository, the marked folder holding
+    # +cwd+, else cwd. No git subprocess: at most two small files are read.
+    def project_root(cwd = Dir.pwd) = lookup(cwd).root
+
+    # Is +cwd+ in a project: a git repository or a marked folder?
+    def in_project?(cwd = Dir.pwd) = lookup(cwd).project?
+
+    # The marked folder (realpath) +cwd+'s project is, or nil (in a git
+    # repository, or in no project).
+    def marked_root(cwd = Dir.pwd)
+      found = lookup(cwd)
+      found.marker? ? found.root : nil
+    end
+
+    # The top of +cwd+'s project: the git work tree's top (#work_tree_root) or
+    # the marked root; nil in no project.
+    def project_top(cwd = Dir.pwd) = lookup(cwd).top
 
+    # The project root of the checkout whose .git is +dot_git+ (#project_root).
+    def git_root(dot_git)
       holder = File.dirname(dot_git)
       gitdir = File.directory?(dot_git) ? dot_git : gitdir_from_file(dot_git)
       return holder unless gitdir
@@ -78,7 +144,8 @@ module Samagotchi
       File.directory?(dot_git) ? dot_git : gitdir_from_file(dot_git)
     end
 
-    # Is +cwd+ inside a git repository (a .git somewhere above it)?
+    # Is +cwd+ inside a git repository (a .git somewhere above it)? Git only:
+    # a marked folder is not a repository (#in_project?).
     def in_repo?(cwd = Dir.pwd)
       !find_dot_git(cwd).nil?
     end
@@ -96,6 +163,28 @@ module Samagotchi
       end
     end
 
+    # The realpath of the nearest folder at or above +start+ holding MARKER,
+    # git or not (#lookup asks only outside a repository; `chi project` tells
+    # of one a repository makes ignored), or nil. A marker at or above +home+
+    # (#above_home?) ends the walk with nil: every folder above it is above
+    # home too.
+    def nearest_marker(start, home: default_home)
+      dir = Guardrails::PathResolve.real(start)
+      loop do
+        if File.file?(File.join(dir, MARKER))
+          return nil if above_home?(dir, home: home)
+
+          return File.realpath(dir)
+        end
+        parent = File.dirname(dir)
+        return nil if parent == dir
+
+        dir = parent
+      end
+    rescue SystemCallError
+      nil
+    end
+
     # A ".git" file holds "gitdir: <path>", relative to the file's directory.
     def gitdir_from_file(path)
       line = File.read(path, 4096).to_s[/\Agitdir:\s*(.+)$/, 1]&.strip
@@ -115,7 +204,7 @@ module Samagotchi
     rescue SystemCallError
       gitdir
     end
-    private_class_method :find_dot_git, :gitdir_from_file, :common_dir
+    private_class_method :find_dot_git, :git_root, :gitdir_from_file, :common_dir
 
     def project_dir(env: ENV, cwd: Dir.pwd)
       File.join(projects_dir(env: env), project_key(cwd))

data/lib/samagotchi/memory_usage.rb

@@ -89,7 +89,7 @@ module Samagotchi
     def self.load_sessions(state_dir: Session.default_state_dir)
       sessions = []
       unreadable = 0
-      Dir.glob(File.join(state_dir, "*#{Session::FILE_EXT}")).sort.each do |path|
+      Dir.glob(File.join(state_dir, "*#{SessionPaths::FILE_EXT}")).sort.each do |path|
         data = JSON.parse(File.read(path, encoding: "UTF-8"))
         # A project_root that is not a path (a hand-edited file) makes every
         # later step raise, so the file counts as unreadable rather than

data/lib/samagotchi/model_lookup.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Samagotchi
+  # The layered inputs a model's settings resolve from, in one value: the
+  # target (its host entry: the hosts: layer), the names its models: entry
+  # may be under (HostRegistry#lookup_names, most specific first), the
+  # models: map, and the env the CLI/env/file layers are read with.
+  # EffectiveModel builds one per read (with its registry's env); each
+  # setting module (Thinking, ReasoningHistory, SteerCutAfter,
+  # SamplingSettings, VisionSupport, ContextWindow, LLMContextStrategy) keeps
+  # its own ordered resolve over it, and ModelProfile takes its #models.
+  #
+  # The setting modules call it duck-typed and never name it, and it names
+  # none of them (only ModelSettings, ModelSetting, Config, ConfigFile): the
+  # modules' parsers are what ModelSettings calls, so either edge would close
+  # a cycle (spec/model_lookup_spec.rb checks this file's side).
+  #
+  # +given_models+ is a caller's models: map (one for a whole picker, or a
+  # spec's); without one, #models reads config.yml at each call, as every
+  # resolve always did.
+  ModelLookup = Data.define(:target, :names, :given_models, :env) do
+    # @param target [HostRegistry::ModelTarget, nil] nil: the global layers only
+    # @param names [Array<String>] HostRegistry#lookup_names
+    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all by default
+    # @param env [Hash] ENV, or another env whose config file and variables
+    #   every layer reads (chi self's)
+    def self.for(target, names:, models: nil, env: ENV)
+      new(target: target, names: Array(names), given_models: models, env: env)
+    end
+
+    # The models: map: the one given, else ModelSettings.all for #env; {}
+    # when it can't be read.
+    # @return [Hash{String => ModelSettings}]
+    def models
+      return given_models if given_models
+
+      env.equal?(ENV) ? ModelSettings.all : ModelSettings.all(env: env)
+    rescue StandardError # degrade-ok: the setting resolves from its other layers, as it always did
+      {}
+    end
+
+    def entry = target&.entry
+
+    # The host's name, as a "hosts.NAME" label names it.
+    def host_name = entry&.name
+
+    # The first lookup name whose models: entry sets +field+ (a
+    # ModelSettings member): a ModelSetting (key, value), or nil.
+    # @return [ModelSetting, nil]
+    def model(field) = ModelSettings.find(names, field, models: models)
+
+    # The host entry's +field+ (a HostEntry member), nil when unset or
+    # without a host.
+    def host(field) = entry&.public_send(field)
+
+    # [value, origin] of the global config key +key+ (:cli, :env, :file or
+    # :default), as Config.get_with_origin gives it; for another env its
+    # variables and config file, with this process's CLI settings. Raises as
+    # that does.
+    # @return [Array(Object, Symbol)]
+    def global(key)
+      return Config.get_with_origin(key) if env.equal?(ENV)
+
+      file_data = ConfigFile.read_yaml(env: env, path: ConfigFile.global_path(env: env))
+      Config.resolve_with_origin(key, file_data: file_data, env: env, cli_overrides: Config.cli_overrides)
+    end
+
+    # The model and the names only: the default would print the env (it
+    # holds API keys) and the target's client.
+    def inspect = "#<Samagotchi::ModelLookup #{target&.model.inspect} host=#{host_name.inspect} names=#{names.inspect}>"
+    alias_method :to_s, :inspect
+  end
+end

data/lib/samagotchi/model_profile.rb

@@ -286,6 +286,7 @@ module Samagotchi
     def self.default_relist(hosts)
       lambda do |host_name, relist_env|
         require_relative "host_registry"
+        # Not .current: the caller's hosts, and a fresh listing is the point.
         registry = Samagotchi::HostRegistry.new(hosts_config: hosts, env: relist_env)
         answer = nil
         thread = Thread.new { answer = registry.list_models(host_name) }

data/lib/samagotchi/models_command.rb

@@ -73,7 +73,7 @@ module Samagotchi
 
     # @return [Array(Hash, Boolean)] the payload and whether any host listed
     def catalog(timeout)
-      registry = @registry || HostRegistry.new
+      registry = @registry || HostRegistry.current
       results = registry.list_all_models(force: true, wait: timeout)
       listed = results.values.any? { |data| data.error.nil? }
       [ModelCatalog.payload(results, registry: registry, default_name: default_name), listed]

data/lib/samagotchi/note_command.rb

@@ -97,7 +97,7 @@ module Samagotchi
 
     # --all: every live session. @return [Integer] exit status
     def deliver_to_live(text, source)
-      ids = @access.summaries(live: true, include_tests: Session.test_session_env?).map { |s| s[:id] }
+      ids = @access.summaries(live: true, include_tests: Session.test_session_env?).map(&:id)
       if ids.empty?
         error_line("chi note: no live sessions (chi sessions list --live --scope=all)")
         return 1

data/lib/samagotchi/participant_mode.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "delivery"
+require_relative "session_paths"
 
 module Samagotchi
   # The rules for a participant's turn: the one place that decides them.
@@ -75,7 +76,7 @@ module Samagotchi
 
       require_relative "session"
       require_relative "worker_link"
-      dir = Session.session_dir(session.id, state_dir: state_dir || Session.default_state_dir)
+      dir = SessionPaths.session_dir(session.id, state_dir: state_dir || SessionPaths.default_state_dir)
       link = WorkerLink.resolve(dir, unlink: false)
       link.live? ? link.features : nil
     rescue StandardError

data/lib/samagotchi/plugin/api.rb

@@ -32,10 +32,7 @@ module Samagotchi
       # plugin writes it (ApiCalls#keywords: `ctx.sessions.send(…,
       # delivery:)` is seen, a `sessions = ctx.sessions` alias isn't).
       # Events aren't listed: chi.on takes any symbol and an older chi never
-      # fires one it doesn't know (harmless; chi bundle check warns on it),
-      # and a manifest hook's events: list (BundleHook) needs the bundle's
-      # requires_chi set by hand (docs/hooks.md, Bundle Hooks): no source
-      # scan covers manifest.yml.
+      # fires one it doesn't know (harmless; chi bundle check warns on it).
       SINCE = {
         "ctx.steer" => "0.3.0", "ctx.stop_turn" => "0.3.0", "ctx.stop_generation" => "0.6.0",
         "Samagotchi::AtomicFile" => "0.8.0", "ctx.model" => "0.17.0", "ctx.model_key" => "0.17.0",
@@ -57,9 +54,14 @@ module Samagotchi
         "ctx.continues" => "0.141.0", "ctx.context.left_behind" => "0.141.0", "ctx.context.attach(movable:)" => "0.141.0",
         "ctx.session_dir" => "0.143.0", "ctx.session_dir(create:)" => "0.144.0",
         "ctx.objectives" => "0.149.0", "ctx.turn_running?" => "0.149.0",
-        "ctx.last_answer" => "0.154.0"
+        "ctx.last_answer" => "0.154.0",
+        "chi.on(on_error:)" => "0.157.0"
       }.freeze
 
+      # chi.on's on_error: values. :log (the default) logs a raise and goes
+      # on; :fail_closed (before_tool_call only) denies the call it raised on.
+      ON_ERROR = %i[log fail_closed].freeze
+
       # @param bundle [String]
       # @param label [String] "<file> (bundle <name>)": what hooks and
       #   failures are named by
@@ -222,14 +224,31 @@ module Samagotchi
       # logged and skipped; its first failure in this worker also tells the
       # user, once (Registries#hook_failed).
       # @param priority [Integer] lower runs first among bundle hooks
-      def on(event, priority: 100, &block)
+      # @param on_error [Symbol] :log, or :fail_closed for a before_tool_call
+      #   guard: a raise denies that call. A plugin that registers one is a
+      #   guardrail (#fail_closed?): if it then fails to load, every tool call
+      #   is denied (Loader; the manifest's plugin: required: true says so
+      #   before it registers anything).
+      def on(event, priority: 100, on_error: :log, &block)
         raise ArgumentError, "on(#{event.inspect}) needs a block" unless block
         raise ArgumentError, "on: the event must be a Symbol or String" unless event.is_a?(Symbol) || event.is_a?(String)
 
-        @hooks << { event: event.to_sym, priority: Integer(priority), block: block }
+        event = event.to_sym
+        policy = on_error.is_a?(String) ? on_error.to_sym : on_error
+        raise ArgumentError, "on(#{event.inspect}): on_error: must be :log or :fail_closed, not #{on_error.inspect}" unless ON_ERROR.include?(policy)
+        if policy == :fail_closed && event != :before_tool_call
+          raise ArgumentError, "on(#{event.inspect}): on_error: :fail_closed is for :before_tool_call only"
+        end
+
+        @hooks << { event: event, priority: Integer(priority), on_error: policy, block: block }
         nil
       end
 
+      # Whether #register staged a fail-closed hook (chi.on(on_error:
+      # :fail_closed)): the plugin is a guardrail, so its failing to load
+      # denies every tool call (Loader).
+      def fail_closed? = @hooks.any? { |hook| hook[:on_error] == :fail_closed }
+
       # A long-lived thing the plugin keeps (a server process): the block
       # starts it and returns what #value gives; in it, svc.on_stop { }
       # says how to stop it. It starts on first svc.value, or now with
@@ -451,10 +470,13 @@ module Samagotchi
         @tools.each { |tool| @registries.tools.register(tool.name, source: @bundle, **tool.entry_fields(context)) }
         @hooks.each do |hook|
           block = hook[:block]
-          # Never stderr (echo: false): a turn's live region is on screen.
-          handler = Hooks.wrap(label: "#{@label} #{hook[:event]} hook", event: hook[:event], policy: :log,
+          # Never stderr (echo: false): a turn's live region is on screen. A
+          # fail-closed one denies the call it raised on (Hooks.wrap's :deny).
+          policy = hook[:on_error] == :fail_closed ? :deny : :log
+          label = "#{"guardrail " if policy == :deny}#{@label} #{hook[:event]} hook"
+          handler = Hooks.wrap(label: label, event: hook[:event], policy: policy,
                                log: [:plugins, "plugin_hook_failed"], echo: false, fields: { bundle: @bundle },
-                               on_failure: @registries.hook_failed) do |event|
+                               on_failure: hook_failed(policy)) do |event|
             # ctx's helpers act as this event's while the block runs.
             context ? context.with_event(event) { block.call(event, context) } : block.call(event, context)
           end
@@ -478,6 +500,16 @@ module Samagotchi
         @committed = true
       end
 
+      # Registries#hook_failed for a hook under +policy+: a fail-closed one's
+      # notice says it denies (effect: :deny).
+      def hook_failed(policy)
+        told = @registries.hook_failed
+        return told unless told && policy == :deny
+
+        ->(label, failed) { told.call(label, failed, effect: :deny) }
+      end
+      private :hook_failed
+
       # @return [Hash] how many of each it registered (for the log)
       def counts = { commands: @commands.size, annotations: @annotations.size, tools: @tools.size, hooks: @hooks.size,
                      services: @services.size, inits: @inits.size, toolkits: @toolkits.size,