kettle-family 1.2.99 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3fff3ab628dc6f5338ddf0a820485b986ce5f40aec27a905f1ee15e18450ab9
-  data.tar.gz: fa34533d50ee506f05e2f1cd9f865c011d12e91996b1c38cbabfe76eb0f9c676
+  metadata.gz: c2e7e86419a5d960e83f3e8f7cb5aa1348f5acbe217b02b43e27ca479b9dafd9
+  data.tar.gz: cb5de478d104da8759b0746db6a58f415afb768aae9cd6622e3b4d2a42cdbd09
 SHA512:
-  metadata.gz: 81f62b1263cd2afbe483f7af09d0a4c1b3e4efac0328938592c84e381d5d731188031e1e9dad97ce343573b025a50d9de62424ce92d12be7245beced5de9996d
-  data.tar.gz: 95713fbc85dd8e285b7b94364bfe799735df2d2b9f19b1205d2ad0819d793f66c94e39aa3b3816826b2987dacabc14519e24f01a0447f29af1edb55567d49f95
+  metadata.gz: a60488bf1fc40699a0317e52d6b62318bf0eb243cc42f6950b39b1f7e2e785e7be4de6163a436057d2fcef5a602446dd1acbce249f6ecad7912ccfbc947d7526
+  data.tar.gz: 7c35f5fb09c6edbd5dc63235c0e3a97b69e9aa21a2dffff7c453fa557ab54f9383b7d1d69a9d08972bd1a7f078352dff5cc32991e203d588765570eaecc3ed18

data/CHANGELOG.md

@@ -30,6 +30,32 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.3.0] - 2026-09-10
+
+- TAG: [v1.3.0][1.3.0t]
+- COVERAGE: 93.47% -- 6322/6764 lines in 36 files
+- BRANCH COVERAGE: 77.95% -- 2559/3283 branches in 36 files
+- 33.49% documented
+
+### Fixed
+
+- Serialize explicit release dependency graph contracts so CI-resident monorepo paths are preserved while sibling and branch-target releases reject ambient local paths.
+
+## [1.2.100] - 2026-09-09
+
+- TAG: [v1.2.100][1.2.100t]
+- COVERAGE: 93.51% -- 6283/6719 lines in 35 files
+- BRANCH COVERAGE: 78.15% -- 2553/3267 branches in 35 files
+- 32.84% documented
+
+### Fixed
+
+- Run each family member through its own mise runtime instead of inheriting the orchestrator runtime.
+
+- Refresh dependent release lockfiles after a runtime sibling publishes without waiting for later Gemfile-only tooling dependencies.
+
+- Preserve the Mise launcher path when running commands in member worktrees from a Bundler environment.
+
 ## [1.2.99] - 2026-09-09
 
 - TAG: [v1.2.99][1.2.99t]
@@ -2705,7 +2731,11 @@ Please file a bug if you notice a violation of semantic versioning.
 - Fixed CI load failures on engines without compatible `pty` support by falling back to Open3 for interactive release commands.
 - Fixed Ruby 3.2 version-bump support by loading Prism lazily and wiring the Prism gem only for MRI versions that need it.
 
-[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.2.99...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.3.0...HEAD
+[1.3.0]: https://github.com/kettle-dev/kettle-family/compare/v1.2.100...v1.3.0
+[1.3.0t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.3.0
+[1.2.100]: https://github.com/kettle-dev/kettle-family/compare/v1.2.99...v1.2.100
+[1.2.100t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.100
 [1.2.99]: https://github.com/kettle-dev/kettle-family/compare/v1.2.98...v1.2.99
 [1.2.99t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.99
 [1.2.98]: https://github.com/kettle-dev/kettle-family/compare/v1.2.97...v1.2.98

data/README.md

@@ -1186,7 +1186,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-6.695-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-6.764-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/kettle-dev/kettle-family/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/kettle/family/command_runner.rb

@@ -10,6 +10,7 @@ module Kettle
       SENSITIVE_ENV_KEYS = [
         "KETTLE_RELEASE_GEM_SIGNING_PASSPHRASE"
       ].freeze
+      MISE_SESSION_ENV_PREFIX = "__MISE_"
 
       class OtpCoordinator
         def initialize(input: $stdin, output: $stdout, queue_total: nil, secrets_provider: nil, event_handler: nil)
@@ -616,11 +617,14 @@ module Kettle
 
       def process_env(member:, env:)
         base_env = unbundled_process_env
+        clear_outer_mise_session!(base_env) if mise_configured?(member)
         # Bundler's unbundled environment intentionally omits activation
         # variables, but it may also omit PATH. When `unsetenv_others` is used
         # for mise-managed members, dropping PATH makes nested commands such
         # as `bundle` unresolvable inside kettle-jem.
-        base_env["PATH"] = if base_env.key?("PATH")
+        base_env["PATH"] = if mise_configured?(member)
+          mise_member_path(base_env["PATH"], ENV["PATH"])
+        elsif base_env.key?("PATH")
           executable_path(base_env["PATH"])
         else
           ENV["PATH"]
@@ -647,6 +651,33 @@ module Kettle
         paths.compact.map(&:to_s).flat_map { |value| value.split(File::PATH_SEPARATOR) }.reject(&:empty?).uniq.join(File::PATH_SEPARATOR)
       end
 
+      # `mise exec` selects a member's declared runtime. Do not let the
+      # orchestrator's Ruby or gem bin directory precede it on PATH: Bundler
+      # otherwise executes the outer runtime after `mise` has entered the
+      # member directory, and can rewrite that member's lockfile with the
+      # wrong Bundler version.
+      def mise_member_path(*paths)
+        outer_runtime_paths = [Gem.bindir, File.dirname(RbConfig.ruby)].filter_map do |entry|
+          canonical_path(entry) unless entry.to_s.empty?
+        end
+        paths.flat_map { |path| path.to_s.split(File::PATH_SEPARATOR) }.reject(&:empty?).reject do |entry|
+          outer_runtime_paths.include?(canonical_path(entry))
+        end.uniq.join(File::PATH_SEPARATOR)
+      end
+
+      # Mise records its active configuration in private `__MISE_*` variables.
+      # Retaining them across a nested `mise exec -C member` makes Mise reuse
+      # the orchestrator's tool set instead of loading the member's mise.toml.
+      def clear_outer_mise_session!(env)
+        env.delete_if { |key, _value| key.start_with?(MISE_SESSION_ENV_PREFIX) }
+      end
+
+      def canonical_path(path)
+        File.realpath(path)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        File.expand_path(path)
+      end
+
       def unbundled_process_env
         return Bundler.unbundled_env if defined?(Bundler) && Bundler.respond_to?(:unbundled_env)
         return Bundler.original_env if defined?(Bundler) && Bundler.respond_to?(:original_env)

data/lib/kettle/family/config.rb

@@ -284,6 +284,23 @@ module Kettle
         fetch_path("release", "local_path_strategy").to_s
       end
 
+      def release_graph_contract
+        configured = fetch_path("release", "graph_contract").to_s.strip
+        return configured unless configured.empty?
+
+        return "monorepo_ci_local" if ci_resident_local_release_graph?
+        return "wave_transition" if release_local_path_strategy == "waves"
+
+        "registry_only"
+      end
+
+      def release_branch_target_graph_contract
+        configured = fetch_path("release", "branch_target_graph_contract").to_s.strip
+        return configured unless configured.empty?
+
+        "branch_terminal"
+      end
+
       def release_allowed_local_path_roots
         inferred = ci_resident_monorepo_local_path_graph? ? [family_local_path_root] : []
         configured = Array(fetch_path("release", "allowed_local_path_roots"))
@@ -306,6 +323,8 @@ module Kettle
         path_within_root?(family_local_path_root)
       end
 
+      alias_method :ci_resident_local_release_graph?, :ci_resident_monorepo_local_path_graph?
+
       # This remains the repository-topology predicate used by release
       # scheduling. CI-safe local path inference is deliberately narrower.
       def configured_monorepo_release?

data/lib/kettle/family/dependency_floor.rb

@@ -7,6 +7,24 @@ module Kettle
     class DependencyFloor
       DEPENDENCY_METHODS = %i[add_dependency add_runtime_dependency add_development_dependency].freeze
 
+      # Return only dependencies declared by the gemspec itself. Release
+      # ordering also observes Gemfile-only tooling dependencies, but those
+      # cannot have their published floor rewritten by this class.
+      def self.gemspec_dependency_names(member)
+        return [] unless member.gemspec_path && File.file?(member.gemspec_path)
+
+        source = File.read(member.gemspec_path)
+        parse_result = Kettle::Dev::VersionBump.parse_source(source, member.gemspec_path)
+        Kettle::Dev::VersionBump.each_node(parse_result.value).filter_map do |node|
+          next unless node.is_a?(Prism::CallNode) && DEPENDENCY_METHODS.include?(node.name)
+
+          name_node = node.arguments&.arguments&.first
+          name_node.unescaped if name_node.is_a?(Prism::StringNode)
+        end.uniq
+      rescue Kettle::Dev::Error => error
+        raise Error, error.message
+      end
+
       def initialize(released_members:, dependent_members:, mode: :dry_run)
         @released_members = released_members
         @dependent_members = dependent_members

data/lib/kettle/family/execution_profile.rb

@@ -68,8 +68,8 @@ module Kettle
           host_platform_policy: :active_platform_must_resolve,
           allowed_mutations: %i[canonical_release_lockfiles configured_wave_paths]
         ),
-        release_recovery: Definition.new(
-          name: :release_recovery,
+        release_wave_transition: Definition.new(
+          name: :release_wave_transition,
           path_gem_policy: :configured_release_wave,
           lockfile_role: :canonical,
           install_location: :disposable,

data/lib/kettle/family/release_graph.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kettle
+  module Family
+    # Immutable release dependency graph selected for one member or branch
+    # target. It is passed to kettle-dev as data, never reconstructed from
+    # whichever *_DEV variables happened to launch the family command.
+    class ReleaseGraph
+      ENV_KEY = "KETTLE_RELEASE_GRAPH_CONTRACT_JSON"
+      NAMES = %w[registry_only wave_transition monorepo_ci_local branch_terminal].freeze
+
+      attr_reader :name, :ci_root, :local_path_roots, :selector_env
+
+      def initialize(name:, ci_root: nil, local_path_roots: [], selector_env: {})
+        @name = name.to_s
+        @ci_root = canonical_path(ci_root) if ci_root
+        @local_path_roots = Array(local_path_roots).map { |path| canonical_path(path) }.uniq.freeze
+        @selector_env = selector_env.to_h.transform_keys(&:to_s).transform_values(&:to_s).freeze
+        validate!
+        freeze
+      end
+
+      def registry_only?
+        name == "registry_only" || name == "branch_terminal"
+      end
+
+      def local_paths?
+        !local_path_roots.empty?
+      end
+
+      def environment
+        selector_env.merge(ENV_KEY => JSON.generate(to_h))
+      end
+
+      def to_h
+        {
+          "name" => name,
+          "ci_root" => ci_root,
+          "local_path_roots" => local_path_roots,
+          "selector_env" => selector_env
+        }
+      end
+
+      private
+
+      def validate!
+        raise Error, "unknown release graph contract #{name.inspect}" unless NAMES.include?(name)
+
+        if registry_only? && (local_paths? || !selector_env.empty?)
+          raise Error, "#{name} release graph cannot declare local paths or selectors"
+        end
+        return unless %w[wave_transition monorepo_ci_local].include?(name)
+
+        raise Error, "#{name} release graph requires at least one local path root" unless local_paths?
+        raise Error, "#{name} release graph requires a local path selector" if selector_env.empty?
+
+        selector_env.each_value do |value|
+          next if local_path_roots.any? { |root| value == root || value.start_with?("#{root}/") }
+
+          raise Error, "#{name} selector #{value.inspect} is outside its declared local path roots"
+        end
+
+        return unless name == "monorepo_ci_local"
+
+        raise Error, "monorepo_ci_local release graph requires a CI root" if ci_root.to_s.empty?
+        local_path_roots.each do |path|
+          next if path == ci_root || path.start_with?("#{ci_root}/")
+
+          raise Error, "monorepo_ci_local path #{path.inspect} is outside CI root #{ci_root.inspect}"
+        end
+      end
+
+      def canonical_path(path)
+        expanded = File.expand_path(path)
+        File.realpath(expanded)
+      rescue Errno::ENOENT
+        expanded
+      end
+    end
+  end
+end

data/lib/kettle/family/version.rb

@@ -5,7 +5,7 @@ module Kettle
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = "1.2.99"
+      VERSION = "1.3.0"
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/kettle/family/workflow.rb

@@ -2723,13 +2723,16 @@ module Kettle
         end
       end
 
-      # A release-valid lockfile must resolve every selected sibling dependency
-      # from the registry. Defer refreshes for dependents that still require a
-      # selected sibling from a later release wave; their gemspec floors can be
-      # updated now, but Bundler cannot resolve the future sibling remotely yet.
+      # A release-valid lockfile must resolve every selected sibling whose
+      # gemspec floor can be rewritten by DependencyFloor. Release ordering
+      # deliberately also includes Gemfile-only tooling dependencies, but
+      # those do not have a floor to reconcile and must not delay a runtime
+      # dependency's lockfile refresh until a later wave.
       def dependency_floor_refresh_ready?(member, released_members:)
         selected_names = members.map(&:name)
-        selected_dependencies = release_dependency_names(member).select { |dependency| selected_names.include?(dependency) }
+        selected_dependencies = DependencyFloor.gemspec_dependency_names(member).select do |dependency|
+          selected_names.include?(dependency)
+        end
         completed_names = Array(@release_completed_member_names) + released_members.map(&:name)
         selected_dependencies.all? { |dependency| completed_names.include?(dependency) }
       end
@@ -3665,16 +3668,16 @@ module Kettle
       # changelog may live at the family root. Pass the shared paths to the
       # member release phase as well as to the separate family phase.
       def release_env_for_member(member, family_root: config.root, wave_jobs: 1)
+        graph = release_graph_for(member, family_root: family_root)
         env = execution_profile(release_bootstrap_execution_profile, release_env)
-        env.merge!(release_wave_local_path_env_for(member, family_root: family_root))
-        env.merge!(release_local_path_policy_env(family_root: family_root))
+        env.merge!(release_lockfile_local_path_env_overrides(member, graph: graph))
+        env.merge!(graph.environment)
         # A resumed child kettle-release starts in the member's mise
         # environment after the release candidate was already prepared.
         # Disable sibling paths so mise cannot reactivate them before the
         # resumed release validates that immutable lockfile. A new release
         # retains the staged local-graph policy until kettle-release reaches
         # its own release-lockfile boundary.
-        env.merge!(release_lockfile_local_path_env_overrides(member)) if release_step_resume?
         # Family release performs one live pin review before member releases.
         # Child kettle-release must consume that reviewed cache instead of
         # repeating the GitHub API lookup for every member.
@@ -3752,37 +3755,6 @@ module Kettle
         family_gemfile if File.file?(family_gemfile)
       end
 
-      # A release task may start with local sibling paths so a member can
-      # consume a selected dependency that has not been published yet. Once
-      # that dependency is complete in an earlier wave, use its registry
-      # release for the next member. Dependencies outside the selected set are
-      # already treated as registry dependencies; this is what makes resume
-      # runs work after an earlier wave has been published.
-      def release_wave_local_path_env_for(member, family_root: config.root)
-        # Monorepo members and their sibling dependencies share the same CI
-        # checkout, so their canonical development lockfile may keep those
-        # paths throughout every release wave.
-        if config.configured_monorepo_release?
-          env_name = config.family_local_path_env_name
-          return env_name ? {env_name => family_local_path_root_for(family_root)} : {}
-        end
-
-        return {} unless config.release_local_path_strategy == "waves"
-
-        env_name = config.family_local_path_env_name
-        return {} if env_name.to_s.empty?
-
-        local_value = release_env[env_name]
-        return {} unless local_path_env_value?(local_value)
-
-        selected_names = members.map(&:name)
-        completed_names = Array(@release_completed_member_names)
-        unresolved_selected_dependency = release_dependency_names(member).any? do |dependency|
-          selected_names.include?(dependency) && !completed_names.include?(dependency)
-        end
-        {env_name => unresolved_selected_dependency ? local_value : "false"}
-      end
-
       # simplecov:disable Covered by monorepo release integration, not sibling-repository suite.
       def aggregate_monorepo_github_release(members)
         version = members.map { |member| member.version.to_s }.uniq
@@ -5414,14 +5386,61 @@ module Kettle
       end
 
       def release_lockfile_execution_profile
-        return ExecutionProfile.fetch(:release_recovery) if release_recovery?
-        return ExecutionProfile.fetch(:release_monorepo) if preserve_monorepo_template_context?
+        release_graph_execution_profile(release_graph_for(family_member))
+      end
 
-        ExecutionProfile.fetch(:release_registry)
+      def release_graph_execution_profile(graph)
+        case graph.name
+        when "monorepo_ci_local"
+          ExecutionProfile.fetch(:release_monorepo)
+        when "wave_transition"
+          ExecutionProfile.fetch(:release_wave_transition)
+        when "branch_terminal", "registry_only"
+          ExecutionProfile.fetch(:release_registry)
+        else
+          raise Error, "unknown release graph contract #{graph.name.inspect}"
+        end
       end
 
-      def release_recovery?
-        !start_step.nil? || !skip_steps.to_s.empty? || fast_recovery || skip_ci
+      def release_graph_for(member, family_root: config.root)
+        name = if config.release_target_branches.any?
+          config.release_branch_target_graph_contract
+        else
+          config.release_graph_contract
+        end
+
+        case name
+        when "registry_only", "branch_terminal"
+          ReleaseGraph.new(name: name, ci_root: family_root)
+        when "monorepo_ci_local"
+          unless config.ci_resident_local_release_graph?
+            raise Error, "monorepo_ci_local requires family.local_path_root to be contained by the family repository"
+          end
+
+          env_name = config.family_local_path_env_name
+          raise Error, "monorepo_ci_local requires family.local_path_env" if env_name.to_s.empty?
+
+          root = family_local_path_root_for(family_root)
+          ReleaseGraph.new(name: name, ci_root: family_root, local_path_roots: [root], selector_env: {env_name => root})
+        when "wave_transition"
+          env_name = config.family_local_path_env_name
+          raise Error, "wave_transition requires family.local_path_env" if env_name.to_s.empty?
+
+          local_value = release_local_path_env_sources[env_name]
+          return ReleaseGraph.new(name: "registry_only", ci_root: family_root) unless local_path_env_value?(local_value)
+
+          selected_names = members.map(&:name)
+          completed_names = Array(@release_completed_member_names)
+          unresolved_selected_dependency = release_dependency_names(member).any? do |dependency|
+            selected_names.include?(dependency) && !completed_names.include?(dependency)
+          end
+          return ReleaseGraph.new(name: "registry_only", ci_root: family_root) unless unresolved_selected_dependency
+
+          root = File.expand_path(local_value)
+          ReleaseGraph.new(name: name, ci_root: family_root, local_path_roots: [root], selector_env: {env_name => root})
+        else
+          raise Error, "unknown release graph contract #{name.inspect}"
+        end
       end
 
       def release_step_resume?
@@ -5435,7 +5454,7 @@ module Kettle
         when :template_local
           env["K_JEM_TEMPLATING"] = "true"
           env["BUNDLE_DISABLE_CHECKSUM_VALIDATION"] = "true"
-        when :release_bootstrap, :release_registry, :release_monorepo, :release_recovery
+        when :release_bootstrap, :release_registry, :release_monorepo, :release_wave_transition
           # Release profiles deliberately leave Bundler mutation decisions to
           # kettle-dev. The profile selection controls which local-path
           # overrides this workflow contributes below.
@@ -5489,12 +5508,14 @@ module Kettle
       end
 
       def release_lockfile_env(member = nil)
+        graph = release_graph_for(member || family_member)
         execution_profile(
-          release_lockfile_execution_profile,
+          release_graph_execution_profile(graph),
           base_release_env
           .merge(release_lockfile_bundler_env_resets)
           .merge(env_overrides)
-          .merge(release_lockfile_local_path_env_overrides(member))
+          .merge(release_lockfile_local_path_env_overrides(member, graph: graph))
+          .merge(graph.environment)
         )
       end
 
@@ -5505,8 +5526,8 @@ module Kettle
         }
       end
 
-      def release_allowed_local_path_roots
-        config.release_allowed_local_path_roots
+      def release_allowed_local_path_roots(member = family_member)
+        release_graph_for(member).local_path_roots
       end
 
       def family_local_path_root_for(family_root)
@@ -5516,38 +5537,13 @@ module Kettle
         File.expand_path(relative, family_root)
       end
 
-      def release_allowed_local_path_env_names
-        names = config.release_allowed_local_path_env_names
-        names << "K_JEM_TEMPLATING" if preserve_monorepo_template_context?
-        names.uniq
-      end
-
-      def release_local_path_policy_env(family_root: config.root)
-        roots = release_allowed_local_path_roots.map do |root|
-          if File.expand_path(family_root) == File.expand_path(config.root)
-            root
-          else
-            relative = Pathname.new(root).relative_path_from(Pathname.new(config.root))
-            File.expand_path(relative, family_root)
-          end
-        end
-        env_names = release_allowed_local_path_env_names
-        return {} if roots.empty? && env_names.empty?
-
-        {
-          "KETTLE_RELEASE_ALLOWED_LOCAL_PATH_ROOTS" => roots.join(File::PATH_SEPARATOR),
-          "KETTLE_RELEASE_ALLOWED_LOCAL_PATH_ENVS" => env_names.join(",")
-        }
-      end
-
-      def release_lockfile_local_path_env_overrides(member = nil)
+      def release_lockfile_local_path_env_overrides(member = nil, graph: release_graph_for(member || family_member))
         explicit = config.release_disable_local_path_env.to_h { |key| [key.to_s, "false"] }
-        explicit.delete("K_JEM_TEMPLATING") if preserve_monorepo_template_context?
         derived = release_local_path_env_detection_sources.each_with_object({}) do |(key, value), memo|
           key = key.to_s
           next unless key.end_with?("_LOCAL", "_DEV")
           next unless local_path_env_value?(value)
-          next if release_allowed_local_path_env_names.include?(key)
+          next if graph.selector_env.key?(key)
 
           memo[key] = "false"
         end
@@ -5555,24 +5551,7 @@ module Kettle
         explicit
           .merge(derived)
           .merge(inferred)
-          .merge(release_member_local_path_env(member))
-          .merge(preserve_monorepo_template_context? ? {"K_JEM_TEMPLATING" => "true"} : {})
-      end
-
-      # K_JEM_TEMPLATING activates the generated monorepo dependency closure;
-      # it is not an unrelated local checkout switch. Preserve it only when
-      # the caller explicitly enabled it for a configured monorepo release.
-      def preserve_monorepo_template_context?
-        return false unless config.configured_monorepo_release?
-
-        value = release_local_path_env_sources["K_JEM_TEMPLATING"].to_s.strip.downcase
-        %w[true yes 1 on].include?(value)
-      end
-
-      def release_member_local_path_env(member)
-        return {} unless config.configured_monorepo_release?
-
-        release_wave_local_path_env_for(member)
+          .merge(graph.selector_env)
       end
 
       def release_lockfile_inferred_local_path_env(member)

data/lib/kettle/family.rb

@@ -22,6 +22,7 @@ require_relative "family/nomono_bootstrap"
 require_relative "family/debugger_bootstrap"
 require_relative "family/appraisal_bootstrap"
 require_relative "family/release_waves"
+require_relative "family/release_graph"
 require_relative "family/execution_profile"
 require_relative "family/workflow"
 require_relative "family/discovery"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-family
 version: !ruby/object:Gem::Version
-  version: 1.2.99
+  version: 1.3.0
 platform: ruby
 authors:
 - Peter H. Boling
@@ -94,7 +94,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.33
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -104,7 +104,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.33
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: kettle-gha-pins
   requirement: !ruby/object:Gem::Requirement
@@ -422,6 +422,7 @@ files:
 - lib/kettle/family/nomono_bootstrap.rb
 - lib/kettle/family/orderer.rb
 - lib/kettle/family/readiness_check.rb
+- lib/kettle/family/release_graph.rb
 - lib/kettle/family/release_reconciler.rb
 - lib/kettle/family/release_state_check.rb
 - lib/kettle/family/release_state_event_tape.rb
@@ -443,10 +444,10 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-family.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.2.99
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.99/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.3.0
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.3.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.99
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.3.0
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-dev/kettle-family/wiki
   news_uri: https://www.railsbling.com/tags/kettle-family