rubik 0.1.6 → 0.3.0

data/lib/rubik/orchestrator/subagent/dynamic_store.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Reversible dynamic registration stack management for TypeRegistry.
+      # Tracks monotonic revisions, LIFO unregistration, and dead-context pruning.
+      module DynamicStore
+        def init_dynamic_store
+          @stacks = {}
+          @registrations = {}
+          @revision_counter = 0
+        end
+
+        def register_dynamic(type_def, context: nil, replace: false)
+          owner_ctx = context || type_def.context || @default_context
+          raise ArgumentError, "Dynamic archetypes require an active owner context." unless owner_ctx
+
+          raise ArgumentError, "Cannot define archetype in a disposed context." if owner_ctx.respond_to?(:disposed?) && owner_ctx.disposed?
+
+          raise ArgumentError, "Dynamic archetype owner context must support disposal cleanup." unless
+            owner_ctx.respond_to?(:register_disposable) || owner_ctx.respond_to?(:on_dispose)
+
+          clean_name = type_def.name.to_s.downcase.strip
+          raise ArgumentError, "Subagent type name cannot be empty" if clean_name.empty?
+
+          handle = previous_type_state = nil
+          @monitor.synchronize do
+            prune_dead_entries(clean_name)
+
+            raise ArgumentError, "Cannot define archetype '#{clean_name}' because built-in system archetypes are reserved." if @builtins.key?(clean_name)
+
+            stack = @stacks[clean_name]
+            if stack&.any? && !replace
+              raise ArgumentError, "Cannot define archetype '#{clean_name}' because it is already registered. To fix, choose a different name or specify replace: true."
+            end
+
+            # Keep older revisions isolated when the same definition is reused.
+            type_def = type_def.dup if @registrations.values.any? { |registration| registration.type_def.equal?(type_def) }
+            @revision_counter += 1
+            rev = @revision_counter
+            previous_type_state = [type_def.name, type_def.context, type_def.custom_prompt, type_def.handle, type_def.revision]
+            type_def.name = clean_name
+            type_def.context = owner_ctx
+            type_def.custom_prompt = true
+            handle = RegistrationHandle.new(revision: rev, type_def: type_def, context: owner_ctx, registry: self)
+            type_def.handle = handle
+            type_def.revision = rev
+
+            reg = Registration.new(revision: rev, name: clean_name, type_def: type_def, handle: handle, context: owner_ctx, active: true)
+            @registrations[rev] = reg
+            (@stacks[clean_name] ||= []) << reg
+          end
+
+          begin
+            cleanup_method = owner_ctx.respond_to?(:register_disposable) ? :register_disposable : :on_dispose
+            owner_ctx.public_send(cleanup_method) { unregister_dynamic(handle) }
+            raise ArgumentError, "Cannot define archetype in a disposed context." unless handle.active?
+          rescue StandardError
+            unregister_dynamic(handle)
+            type_def.name, type_def.context, type_def.custom_prompt, type_def.handle, type_def.revision = previous_type_state
+            raise
+          end
+          handle
+        end
+
+        def unregister_dynamic(target)
+          @monitor.synchronize do
+            rev = resolve_revision(target)
+            reg = @registrations[rev]
+            return false unless reg&.active
+
+            reg.active = false
+            handle = reg.handle
+            handle&.instance_variable_set(:@active, false)
+
+            stack = @stacks[reg.name]
+            if stack&.last == reg
+              stack.pop
+              prune_dead_entries(reg.name)
+            elsif stack
+              stack.delete(reg)
+            end
+            @registrations.delete(rev)
+            true
+          end
+        end
+
+        private
+
+        def resolve_revision(target)
+          return target.revision if target.respond_to?(:revision)
+          return target if target.is_a?(Integer)
+
+          clean = target.to_s.downcase.strip
+          stack = @stacks[clean]
+          stack&.last&.revision
+        end
+
+        def prune_dead_entries(clean_name)
+          stack = @stacks[clean_name]
+          return unless stack
+
+          while stack.any?
+            top = stack.last
+            is_dead = !top.active || (top.context.respond_to?(:disposed?) && top.context.disposed?)
+            break unless is_dead
+
+            top.active = false
+            top.handle&.instance_variable_set(:@active, false)
+            @registrations.delete(top.revision)
+            stack.pop
+          end
+          @stacks.delete(clean_name) if stack.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/subagent/instance.rb

@@ -2,6 +2,7 @@
 
 require "monitor"
 require_relative "transcript_formatter"
+require_relative "start_gate"
 require_relative "storage_id"
 require_relative "lifecycle"
 require_relative "step_runner"
@@ -29,6 +30,7 @@ module Rubik
         include Lifecycle
         include StepRunner
         include RunCycle
+        include StartGate
         include Teardown
         include Questioner
         include Redeploy
@@ -41,6 +43,7 @@ module Rubik
         # through #state_note — derived, nothing stored to go stale (B3).
         attr_reader :id, :role, :type_name, :prompt, :system_prompt,
                     :workspace, :model, :context, :tool_registry, :buffer_manager,
+                    :profile_snapshot,
                     :state, :started_at, :ended_at, :result,
                     :last_error, :storage_id, :transcript_uri, :history,
                     :context_limit, :max_output_tokens, :config, :pause_facts, :prompt_reconstructible,
@@ -54,13 +57,14 @@ module Rubik
                        system_prompt: nil, workspace: "inherit", model: "inherit",
                        provider: nil, buffer_manager: nil, max_steps: Budget::DEFAULT_MAX_STEPS, root_dir: Dir.pwd,
                        context_limit: nil, config: nil, event_bus: nil, provider_gate: nil, transcript_storage: nil,
-                       prompt_reconstructible: false, owner_task: nil)
+                       prompt_reconstructible: false, owner_task: nil, profile_snapshot: nil)
           @id = id.to_s
           @parent_id = parent_id.to_s
           @role = role.to_s.strip
           @type_name = type_name.to_s.downcase.strip
           @prompt = prompt.to_s.strip
-          @system_prompt = system_prompt
+          @system_prompt = system_prompt.nil? ? nil : system_prompt.to_s.dup.freeze
+          @profile_snapshot = profile_snapshot
           @prompt_reconstructible = prompt_reconstructible # spawn kararı: kurulabilir prompt → kalıcı kopya stub'a iner
           @workspace = workspace.to_s.downcase.strip
           @model = model
@@ -104,6 +108,8 @@ module Rubik
           @error_cond = @monitor.new_cond
           @context_cleaned_up = false
           @thread = nil
+          @start_gate = nil
+          @start_aborted = false
         end
 
         def uptime = @started_at ? ((@ended_at || Time.now) - @started_at).to_f : 0.0
@@ -180,40 +186,6 @@ module Rubik
           grant_budget!(additional_steps, note: ->(extra, total) { Budget.grant_note(extra, total) })
         end
 
-        def start_async(&on_complete)
-          @monitor.synchronize do
-            return false if @thread&.alive?
-
-            @started_at = Time.now
-            @run_seq += 1
-            transition!(:running)
-            @unit&.sync_state!
-            @journal&.record_run_started(run: @run_seq, role: @role, type: @type_name, prompt: @prompt)
-          end
-
-          ready = Queue.new
-          run_gate = Queue.new
-          @thread = Thread.new do
-            Thread.handle_interrupt(Object => :never) do
-              ready << true # cleanup is armed before cancellation is enabled
-              Thread.handle_interrupt(Object => :immediate) do
-                run_gate.pop
-                run_execution_cycle
-              end
-            ensure
-              @ended_at ||= Time.now
-              @journal&.record_run_finished(run: @run_seq, state: @state.to_s, result: @result,
-                                            result_ref: (result_ref if settled?))
-              save_transcript! if @transcript_path.nil?
-              @cancelled_by_operator ? cleanup : cleanup_context
-              on_complete&.call(self)
-            end
-          end
-          ready.pop
-          run_gate << true
-          true
-        end
-
         def to_h
           @monitor.synchronize do
             { id: @id, parent_id: @parent_id, role: @role, type: @type_name, state: @state.to_s,

data/lib/rubik/orchestrator/subagent/journal.rb

@@ -58,6 +58,7 @@ module Rubik
           @bytes = File.exist?(@path) ? File.size(@path) : 0
           @closed = false
           @last_error = nil
+          @run_metrics = {}
         end
 
         # The generic append core: sequence, run, timestamp and type are the
@@ -85,14 +86,24 @@ module Rubik
 
         # --- semantic record vocabulary (the only place event shapes live) ---
 
-        def record_run_started(run:, role:, type:, prompt:)
-          data = { "role" => role.to_s, "type" => type.to_s, "prompt_preview" => clip(prompt, PROMPT_CHARS) }
+        def record_run_started(run:, role:, type:, prompt:, profile_name: nil, profile_version: "unknown")
+          data = { "role" => role.to_s, "type" => type.to_s,
+                   "profile_name" => (profile_name || type).to_s, "profile_version" => profile_version.to_s,
+                   "prompt_preview" => clip(prompt, PROMPT_CHARS) }
           append("run_started", run: run, data: data)
         end
 
-        def record_run_finished(run:, state:, result: nil, result_ref: nil)
+        def record_run_finished(run:, state:, result: nil, result_ref: nil, outcome: nil, error_summary: nil,
+                                duration_ms: nil, step_count: nil, profile_name: nil, profile_version: "unknown")
           text = result.to_s
-          data = { "state" => state.to_s, "result_chars" => text.length,
+          metrics = consume_run_metrics(run)
+          data = { "state" => state.to_s, "outcome" => (outcome || state).to_s,
+                   "profile_name" => profile_name&.to_s, "profile_version" => profile_version.to_s,
+                   "error_summary" => error_summary.nil? ? nil : clip(error_summary, 400),
+                   "duration_ms" => duration_ms, "step_count" => step_count,
+                   "tool_usage" => metrics.fetch("tool_usage"), "token_usage" => metrics.fetch("token_usage"),
+                   "cost" => { "status" => "unavailable" },
+                   "result_chars" => text.length,
                    "result_preview" => clip(text, PROMPT_CHARS), "result_ref" => result_ref }.compact
           append("run_finished", run: run, data: data)
         end
@@ -102,6 +113,12 @@ module Rubik
         end
 
         def record_tool_call(run:, call_id:, tool:, args:)
+          @monitor.synchronize do
+            metrics = (@run_metrics[run.to_i] ||= empty_run_metrics)
+            name = tool.to_s
+            metrics[:tool_usage][name] = metrics[:tool_usage].fetch(name, 0) + 1
+          end
+
           json = Rubik::Platform.safe_json_generate(Rubik::Security::Redactor.mask_value(args))
           data = { "tool" => tool.to_s, "args_chars" => json.length }
           if json.length > ARGS_CHARS
@@ -113,6 +130,25 @@ module Rubik
           append("tool_call", run: run, call_id: call_id, data: data)
         end
 
+        # Record only provider-reported token counts. Missing and malformed
+        # counts remain unavailable; this layer never estimates usage or cost.
+        def record_token_usage(run:, usage:)
+          @monitor.synchronize do
+            metrics = (@run_metrics[run.to_i] ||= empty_run_metrics)
+            metrics[:model_responses] += 1
+            input_tokens = usage_value(usage, :input_tokens)
+            output_tokens = usage_value(usage, :output_tokens)
+            if input_tokens
+              metrics[:input_tokens] += input_tokens
+              metrics[:input_token_responses] += 1
+            end
+            if output_tokens
+              metrics[:output_tokens] += output_tokens
+              metrics[:output_token_responses] += 1
+            end
+          end
+        end
+
         def record_tool_result(run:, call_id:, tool:, status:, duration_ms:, output:, artifact_ref: nil, exit_code: nil,
                                truncated: false)
           text = output.to_s
@@ -163,6 +199,43 @@ module Rubik
 
         private
 
+        def empty_run_metrics
+          { tool_usage: {}, model_responses: 0, input_tokens: 0, output_tokens: 0,
+            input_token_responses: 0, output_token_responses: 0 }
+        end
+
+        def consume_run_metrics(run)
+          metrics = @monitor.synchronize { @run_metrics.delete(run.to_i) || empty_run_metrics }
+          token_usage = if metrics[:model_responses].zero? ||
+                           (metrics[:input_token_responses].zero? && metrics[:output_token_responses].zero?)
+                          { "status" => "unavailable", "model_responses" => metrics[:model_responses] }
+                        else
+                          status = if metrics[:input_token_responses] == metrics[:model_responses] &&
+                                      metrics[:output_token_responses] == metrics[:model_responses]
+                                     "reported"
+                                   else
+                                     "partial"
+                                   end
+                          { "status" => status, "model_responses" => metrics[:model_responses],
+                            "input_token_responses" => metrics[:input_token_responses],
+                            "output_token_responses" => metrics[:output_token_responses] }.tap do |usage|
+                            usage["input_tokens"] = metrics[:input_tokens] if metrics[:input_token_responses].positive?
+                            usage["output_tokens"] = metrics[:output_tokens] if metrics[:output_token_responses].positive?
+                          end
+                        end
+
+          { "tool_usage" => metrics[:tool_usage].sort.to_h, "token_usage" => token_usage }
+        end
+
+        def usage_value(usage, key)
+          value = if usage.is_a?(Hash)
+                    usage.key?(key) ? usage[key] : usage[key.to_s]
+                  elsif usage.respond_to?(key)
+                    usage.public_send(key)
+                  end
+          value if value.is_a?(Integer) && value >= 0
+        end
+
         def mark_truncated
           @closed = true
           marker = { "seq" => @seq + 1, "run" => (@last_run || 1).to_i, "ts" => Time.now.utc.iso8601(3),

data/lib/rubik/orchestrator/subagent/profile_contract.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../coeffects"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      class ProfileValidationError < ArgumentError
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors.map(&:freeze).freeze
+          super(JSON.generate(to_h))
+        end
+
+        def to_h
+          { "error" => "invalid_subagent_profile", "errors" => @errors }
+        end
+      end
+
+      # Validates the model-facing archetype contract before the registry can
+      # observe it. Tool grants expand only to the existing declaration groups.
+      module ProfileContract
+        FIELD_LIMITS = { name: 64, description: 500, system_prompt: 12_000 }.freeze
+        MAX_COEFFECTS = 16
+        MAX_COEFFECT_LENGTH = 64
+        MAX_GRANTS = 2
+        CAPABILITY_GRANTS = ["write", "subagent_spawn"].map(&:freeze).freeze
+        UNSET = Object.new.freeze
+
+        KNOWN_COEFFECTS = Rubik::Coeffects.constants(false).filter_map do |constant|
+          value = Rubik::Coeffects.const_get(constant, false)
+          Rubik::Coeffects.canonical(value) if value.is_a?(String)
+        end.uniq.freeze
+
+        Profile = Struct.new(:name, :description, :system_prompt, :requires, :grants, keyword_init: true)
+
+        module_function
+
+        def validate(name:, description:, system_prompt:, requires: [], grants: UNSET,
+                     enable_write_tools: nil, enable_subagent_tools: nil, reserved_names: [], override_requested: false)
+          errors = []
+          profile_name = normalize_text(name, :name, errors, allow_symbol: true)
+          profile_description = normalize_text(description, :description, errors)
+          profile_prompt = normalize_text(system_prompt, :system_prompt, errors)
+
+          errors << error("name", "too_long", "Name must be at most #{FIELD_LIMITS.fetch(:name)} characters.") if profile_name.length > FIELD_LIMITS.fetch(:name)
+          if profile_description.length > FIELD_LIMITS.fetch(:description)
+            errors << error("description", "too_long", "Description must be at most #{FIELD_LIMITS.fetch(:description)} characters.")
+          end
+          if profile_prompt.length > FIELD_LIMITS.fetch(:system_prompt)
+            errors << error("system_prompt", "too_long", "System prompt must be at most #{FIELD_LIMITS.fetch(:system_prompt)} characters.")
+          end
+
+          reserved = Array(reserved_names).map { |reserved_name| reserved_name.to_s.strip.downcase }
+          if reserved.include?(profile_name.downcase)
+            detail = override_requested ? " even when an override flag is supplied" : ""
+            errors << error("name", "reserved_name", "built-in system archetypes are reserved#{detail}.")
+          end
+
+          normalized_requires = normalize_list(
+            requires, field: "requires", allowed: KNOWN_COEFFECTS, maximum: MAX_COEFFECTS,
+                      unknown_code: "unknown_coeffect", duplicate_code: "duplicate_coeffect", errors: errors
+          ) do |value|
+            Rubik::Coeffects.canonical(value)
+          end
+
+          normalized_grants = normalize_grants(
+            grants, enable_write_tools, enable_subagent_tools, errors
+          )
+
+          raise ProfileValidationError, errors unless errors.empty?
+
+          Profile.new(
+            name: profile_name, description: profile_description, system_prompt: profile_prompt,
+            requires: normalized_requires.map(&:freeze).freeze, grants: normalized_grants.map(&:freeze).freeze
+          )
+        end
+
+        def tool_filter(grants)
+          enabled = grants.freeze
+          write_tools = Rubik::Tools::Catalog.write_grant_tools
+          spawn_tools = Rubik::Tools::Catalog.spawn_tools
+
+          lambda do |tool_name|
+            next false if write_tools.include?(tool_name) && !enabled.include?("write")
+            next false if spawn_tools.include?(tool_name) && !enabled.include?("subagent_spawn")
+
+            true
+          end
+        end
+
+        def normalize_text(value, field, errors, allow_symbol: false)
+          if value.nil?
+            errors << error(field.to_s, "required", "#{field} is required.")
+            return ""
+          end
+
+          valid_type = value.is_a?(String) || (allow_symbol && value.is_a?(Symbol))
+          unless valid_type
+            errors << error(field.to_s, "invalid_type", "#{field} must be a string.")
+            return ""
+          end
+
+          normalized = value.to_s.strip
+          errors << error(field.to_s, "required", "#{field} must not be empty.") if normalized.empty?
+          normalized
+        end
+        private_class_method :normalize_text
+
+        def normalize_list(values, field:, allowed:, maximum:, unknown_code:, duplicate_code:, errors:)
+          unless values.is_a?(Array)
+            errors << error(field, "invalid_type", "#{field} must be an array of strings.")
+            return []
+          end
+
+          errors << error(field, "too_many_values", "#{field} may contain at most #{maximum} values.") if values.length > maximum
+
+          normalized = values.filter_map.with_index do |value, index|
+            unless value.is_a?(String) || value.is_a?(Symbol)
+              errors << error(field, "invalid_type", "#{field}[#{index}] must be a string.")
+              next
+            end
+
+            text = value.to_s.strip.downcase
+            if field == "requires" && text.length > MAX_COEFFECT_LENGTH
+              errors << error(field, "too_long", "#{field}[#{index}] must be at most #{MAX_COEFFECT_LENGTH} characters.")
+              next
+            end
+
+            key = yield(text)
+            if key.empty?
+              errors << error(field, "empty_value", "#{field}[#{index}] must not be empty.")
+              next
+            end
+            unless allowed.include?(key)
+              errors << error(field, unknown_code, "#{field}[#{index}] is not in the allowlist.")
+              next
+            end
+
+            key
+          end
+
+          duplicates = normalized.tally.select { |_value, count| count > 1 }.keys
+          duplicates.each do |duplicate|
+            errors << error(field, duplicate_code, "#{field} contains duplicate value '#{duplicate}'.")
+          end
+          normalized
+        end
+        private_class_method :normalize_list
+
+        def normalize_grants(grants, enable_write_tools, enable_subagent_tools, errors)
+          legacy = {
+            "write" => enable_write_tools,
+            "subagent_spawn" => enable_subagent_tools
+          }
+          legacy_present = legacy.values.any? { |value| !value.nil? }
+
+          unless grants.equal?(UNSET)
+            errors << error("grants", "conflicting_grant_sources", "Use grants or legacy enable_* flags, not both.") if legacy_present
+            return normalize_list(
+              grants, field: "grants", allowed: CAPABILITY_GRANTS, maximum: MAX_GRANTS,
+                      unknown_code: "unknown_grant", duplicate_code: "duplicate_grant", errors: errors
+            ) { |value| value }
+          end
+
+          legacy.each_with_object([]) do |(grant, value), normalized|
+            next if value.nil?
+
+            unless [true, false].include?(value)
+              errors << error("grants", "invalid_legacy_grant", "Legacy capability flags must be booleans.")
+              next
+            end
+            normalized << grant if value
+          end
+        end
+        private_class_method :normalize_grants
+
+        def error(field, code, message)
+          { "field" => field, "code" => code, "message" => message }
+        end
+        private_class_method :error
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/subagent/profile_snapshot.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      class UnsatisfiedCoeffectsError < StandardError
+        attr_reader :profile_name, :missing
+
+        def initialize(profile_name, missing)
+          @profile_name = profile_name.to_s.freeze
+          @missing = missing.map { |name| name.to_s.freeze }.freeze
+          super("Subagent archetype '#{@profile_name}' requires unsatisfied coeffects: #{@missing.join(', ')}")
+        end
+      end
+
+      class ReservedProfileError < StandardError; end
+
+      # Per-spawn copy of the profile fields that affect activation and tool
+      # visibility. Registry updates replace future snapshots; they never
+      # mutate the copy held by an active instance.
+      class ProfileSnapshot
+        attr_reader :name, :description, :system_prompt, :effective_system_prompt,
+                    :requires, :grants, :tool_filter, :custom_prompt, :revision,
+                    :profile_version
+
+        def self.capture(type_definition, effective_system_prompt: nil)
+          legacy_grants = []
+          legacy_grants << "write" if type_definition.enable_write_tools
+          legacy_grants << "subagent_spawn" if type_definition.enable_subagent_tools
+          grants = type_definition.grants.nil? ? legacy_grants : type_definition.grants
+
+          new(
+            name: type_definition.name,
+            description: type_definition.description,
+            system_prompt: type_definition.system_prompt,
+            effective_system_prompt: effective_system_prompt.nil? ? type_definition.system_prompt : effective_system_prompt,
+            requires: type_definition.requires || [],
+            grants: grants,
+            tool_filter: type_definition.tool_filter,
+            custom_prompt: type_definition.custom_prompt,
+            revision: type_definition.revision
+          )
+        end
+
+        def initialize(name:, description:, system_prompt:, effective_system_prompt:, requires:, grants:,
+                       tool_filter:, custom_prompt:, revision:)
+          @name = immutable_string(name)
+          @description = immutable_string(description)
+          @system_prompt = immutable_string(system_prompt)
+          @effective_system_prompt = immutable_string(effective_system_prompt)
+          @requires = immutable_list(requires)
+          @grants = immutable_list(grants)
+          @tool_filter = tool_filter&.freeze
+          @custom_prompt = custom_prompt == true
+          @revision = revision
+          @profile_version = revision || :builtin
+          freeze
+        end
+
+        private
+
+        def immutable_string(value)
+          value.nil? ? nil : value.to_s.dup.freeze
+        end
+
+        def immutable_list(values)
+          Array(values).map { |value| immutable_string(value) }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/subagent/reuse.rb

@@ -104,7 +104,8 @@ module Rubik
             refute_cancelled_owner!(eff_owner)
             validate_concurrency!
             child_ctx = extend_root_context!(:redeploy)
-            scoped_registry = build_scoped_registry(@type_registry.get(inst.type_name), child_ctx, inst.buffer_manager)
+            profile = inst.profile_snapshot || @type_registry.get(inst.type_name)
+            scoped_registry = build_scoped_registry(profile, child_ctx, inst.buffer_manager)
             return false unless inst.redeploy_for!(prompt: prompt_str, max_steps: (max_steps || @default_max_steps).to_i,
                                                    context: child_ctx, tool_registry: scoped_registry,
                                                    owner_task: eff_owner)

data/lib/rubik/orchestrator/subagent/scoped_registry.rb

@@ -77,6 +77,8 @@ module Rubik
             Rubik::Tools::InvokeSubagentTool.new(supervisor: supervisor_for(ctx), runtime_context: ctx)
           when Rubik::Tools::ManageSubagentsTool
             Rubik::Tools::ManageSubagentsTool.new(supervisor: supervisor_for(ctx), runtime_context: ctx)
+          when Rubik::Tools::DefineSubagentTool
+            Rubik::Tools::DefineSubagentTool.new(supervisor: supervisor_for(ctx), runtime_context: ctx)
           else
             tool
           end