kettle-family 1.2.20 → 1.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 971f2fe5b4d5a64435ee332ba8d083f494f8ba8b5a6f1a31a81885e504b3a585
-  data.tar.gz: 9ea743325bbf23369827a7220361a765db24a9c2a6d1b893b7233135946d253f
+  metadata.gz: 351c882553083a30e5c52c10fb650195f5e00d5a77e452e19058da6e32c69c94
+  data.tar.gz: c3cf82b1ec51d6f9d043e579e3de5d2b09fd16f0d187d71b3abdfa9626db4576
 SHA512:
-  metadata.gz: 2efbf5d7424ae7f3d758a73d3d5e9390a55e6fe09f5207eec73b932024cf700910e89001f5f116daa2aa567daa61aacdc5e66b9849ccbb87420e545de72c0d6d
-  data.tar.gz: dbaf11ae29801f3f0f4f784dd06117e0b6e5cc361494e6c0633197ea754af21505e399f6b8cc47bcf4521d34765e6672d76822d09f9d83aa49d8ec27fd2ab7f1
+  metadata.gz: 0b2ff66410811aa28af2f578fd354cb9f9d7174a648f3863c7ad68e3e3098b129cb4a2bc9678a24a0fe8d478bba7a81bf61bae35013c48fae124ed0e113c56a2
+  data.tar.gz: e25a8ee6c06843662c0e2da1d9fa68d15b1aa6af30c5f5bbcdafe1690c0912e0d04e7f1b8bc1e814d4e5fef79850f1f4c430a69191d647679b393fa001547632

checksums.yaml.gz.sig

@@ -1,4 +1 @@
-�ۥ.؇!�R����B�j,��]�
-�'���z���ʊ��?��ޭ��۟�-��ȿ'g
-�w*$
-�}*'�ݠ��z��RU6�2Y�Zc���Q�ĸ�ԭY��]�zF�2>�f�&���i���gT�FO� ���,T�}���d@��q�r*���ʙ�3g5P����%���a/`[mR���W?���zw:�-�"{�����O�
���<?a�)�*��&
+��OA�73�M����*h�C���6��&u;d��^D\.��:��t��E���'E�~����0{���pqmɸhDg�U�u�c]��޻1��lDq4q�@�ҋ%�

data/CHANGELOG.md

@@ -30,6 +30,35 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.2.21] - 2026-08-01
+
+- TAG: [v1.2.21][1.2.21t]
+- COVERAGE: 93.95% -- 4453/4740 lines in 30 files
+- BRANCH COVERAGE: 76.28% -- 1733/2272 branches in 30 files
+- 29.12% documented
+
+### Added
+
+- Add version and mise-trust commands and run template members in dependency waves.
+
+- Add reconcile-releases for verified RubyGems to GitHub Release backfills.
+
+### Fixed
+
+- Template lockfile recovery preserves compound shell commands when appending lockfile bootstrap gems.
+
+- Preserve the original template bootstrap failure when lockfile recovery finds no release lockfiles.
+
+- Replace obsolete byebug debugger dependency stacks with debug before templating legacy members.
+
+- Skip nomono-specific lockfile normalization until a legacy member declares nomono.
+
+- Report actionable GitHub release reconciliation checks in family summaries.
+
+- Honor KETTLE_DEV_DEV when release reconciliation invokes kettle-gh-release.
+
+- Retry CI dependency installation while newly published family runtime floors propagate through gem.coop.
+
 ## [1.2.20] - 2026-07-31
 
 - TAG: [v1.2.20][1.2.20t]
@@ -1579,7 +1608,9 @@ 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.20...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.2.21...HEAD
+[1.2.21]: https://github.com/kettle-dev/kettle-family/compare/v1.2.20...v1.2.21
+[1.2.21t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.21
 [1.2.20]: https://github.com/kettle-dev/kettle-family/compare/v1.2.19...v1.2.20
 [1.2.20t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.20
 [1.2.19]: https://github.com/kettle-dev/kettle-family/compare/v1.2.18...v1.2.19

data/README.md

@@ -819,7 +819,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-4.547-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-4.741-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/cli.rb

@@ -10,7 +10,7 @@ module Kettle
     class CLI < CommandKit::Command
       include CommandKit::Commands
 
-      COMMANDS = %w[discover plan report metadata check clean-unreleased reset test lint docs template gha-sha-pins bup bupb bex install bump bump-version add-changelog release push pull sync up branch-lanes release-state state].freeze
+      COMMANDS = %w[version mise-trust discover plan report metadata check clean-unreleased reconcile-releases reset test lint docs template gha-sha-pins bup bupb bex install bump bump-version add-changelog release push pull sync up branch-lanes release-state state].freeze
       WORKFLOW_COMMANDS = %w[check reset test lint docs template gha-sha-pins bup bupb bex release push pull sync up].freeze
 
       command_name "kettle-family"
@@ -204,6 +204,30 @@ module Kettle
         end
       end
 
+      class Version < CommandKit::Command
+        command_name "version"
+        usage ""
+        description "Print the kettle-family version."
+
+        def run(*args)
+          raise OptionParser::InvalidArgument, "unexpected argument(s): #{args.join(" ")}" unless args.empty?
+
+          stdout.puts(Kettle::Family::Version::VERSION)
+          0
+        end
+      end
+
+      class MiseTrust < BaseCommand
+        command_name "mise-trust"
+        usage "[options]"
+        description "Trust mise.toml at the family root and selected member roots."
+
+        def run(*args)
+          unexpected_arguments!(args)
+          run_family("mise-trust", execute: true)
+        end
+      end
+
       class Plan < Discover
         command_name "plan"
         description "Alias for discover while execution workflows are built."
@@ -290,6 +314,19 @@ module Kettle
         description "Uninstall locally installed family gem versions newer than the latest released version."
       end
 
+      class ReconcileReleases < BaseCommand
+        include ExecutionOptions
+
+        command_name "reconcile-releases"
+        usage "[options]"
+        description "Check RubyGems releases for missing GitHub Releases; --execute creates only verified backfills."
+
+        def run(*args)
+          unexpected_arguments!(args)
+          run_family("reconcile-releases")
+        end
+      end
+
       class Reset < WorkflowCommand
         command_name "reset"
         usage "[options] TARGET"
@@ -524,11 +561,14 @@ module Kettle
       end
 
       command Discover
+      command Version
+      command MiseTrust
       command Plan
       command "report", ReportCommand
       command Metadata
       command Check
       command CleanUnreleased
+      command ReconcileReleases
       command Reset
       command Test
       command Lint
@@ -639,9 +679,11 @@ module Kettle
       end
 
       def command_results_for_current_branch(command:, config:, members:, options:, start_at: StartAt.new(nil, nil))
+        return mise_trust_results(config: config, members: members) if command == "mise-trust"
         return bump_version_results(members: members, options: options, phase: command) if %w[bump bump-version].include?(command)
         return add_changelog_results(members: members, options: options) if command == "add-changelog"
         return clean_unreleased_results(config: config, members: members, options: options) if command == "clean-unreleased"
+        return reconcile_release_results(config: config, members: members, options: options) if command == "reconcile-releases"
         return branch_lane_results(config: config, members: members) if command == "branch-lanes"
         return release_state_results(config: config, members: members) if command == "release-state"
         return install_results(config: config, members: members, options: options) if command == "install"
@@ -683,6 +725,15 @@ module Kettle
         ).results
       end
 
+      def mise_trust_results(config:, members:)
+        roots = [config.root, *members.map(&:root)].uniq
+        runner = CommandRunner.new(execute: true, accept: true)
+        roots.map.with_index do |root, index|
+          member = members.find { |candidate| candidate.root == root } || Member.new("family", root, nil, nil, nil, [], [], nil, [], [])
+          runner.call(member: member, phase: "mise_trust", command: ["mise", "trust", "-C", root], env: {})
+        end
+      end
+
       def progress_io(command, options)
         return nil unless %w[release template].include?(command)
         return nil unless options[:execute]
@@ -928,6 +979,10 @@ module Kettle
         UnreleasedGemCleanup.new(config: config, members: members, execute: options[:execute]).results
       end
 
+      def reconcile_release_results(config:, members:, options:)
+        ReleaseReconciler.new(config: config, members: members, execute: options[:execute]).results
+      end
+
       def install_results(config:, members:, options:)
         LocalInstall.new(config: config, members: members, execute: options[:execute], jobs: options[:jobs]).results
       end

data/lib/kettle/family/debugger_bootstrap.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "kettle/dev"
+
+module Kettle
+  module Family
+    # Removes the obsolete byebug debugger stack before Bundler evaluates a
+    # legacy member. This must happen before kettle-jem can template Gemfile.
+    class DebuggerBootstrap
+      DEBUG_GEM = "debug"
+      OBSOLETE_NAME_FRAGMENT = "byebug"
+      DECLARATION_METHODS = %i[gem add_dependency add_development_dependency].freeze
+
+      def initialize(mode: :dry_run)
+        @mode = mode
+      end
+
+      attr_reader :mode
+
+      def member_needs_bootstrap?(member)
+        edits_for(member).any?
+      end
+
+      def bootstrap_member(member)
+        edits = edits_for(member)
+        write_edits(edits)
+        CommandResult.new(
+          member.name,
+          "template_bootstrap_debugger",
+          ["internal", "debugger-bootstrap", DEBUG_GEM],
+          member.root,
+          0,
+          true,
+          "replaced obsolete byebug debugger dependencies with #{DEBUG_GEM} in #{edits.map { |edit| File.basename(edit.fetch(:path)) }.uniq.join(", ")}\n",
+          "",
+          0.0,
+          mode != :execute,
+          (mode == :execute) ? nil : "dry run"
+        )
+      end
+
+      private
+
+      def write_edits(edits)
+        return if mode != :execute || edits.empty?
+
+        Kettle::Dev::VersionBump.write_edits(edits)
+      end
+
+      def edits_for(member)
+        [File.join(member.root, "Gemfile"), member.gemspec_path].filter_map { |path| file_edits(path) }.flatten
+      end
+
+      def file_edits(path)
+        return [] unless File.file?(path)
+
+        source = File.read(path)
+        declarations = debugger_declarations(source, path)
+        return [] if declarations.empty?
+
+        declarations.filter_map.with_index do |declaration, index|
+          debugger_edit(path, source, declaration, replace: index.zero?)
+        end
+      end
+
+      def debugger_declarations(source, path)
+        parse_result = Kettle::Dev::VersionBump.parse_source(source, path)
+        Kettle::Dev::VersionBump.each_node(parse_result.value).filter_map do |node|
+          next unless node.is_a?(Prism::CallNode)
+          next unless DECLARATION_METHODS.include?(node.name)
+
+          name_node = node.arguments&.arguments&.first
+          next unless name_node.is_a?(Prism::StringNode)
+          next unless name_node.unescaped.include?(OBSOLETE_NAME_FRAGMENT)
+
+          {node: node, name_node: name_node}
+        end
+      end
+
+      def debugger_edit(path, source, declaration, replace:)
+        node = declaration.fetch(:node)
+        if replace
+          replacement = debugger_replacement(node, declaration.fetch(:name_node))
+          return Kettle::Dev::VersionBump.file_edit(
+            path, source, node.location.start_offset, node.location.end_offset, replacement
+          )
+        end
+
+        line_start = source.rindex("\n", node.location.start_offset - 1).to_i + 1
+        line_end = source.index("\n", node.location.end_offset) || source.length
+        line_end += 1 if line_end < source.length
+        Kettle::Dev::VersionBump.file_edit(path, source, line_start, line_end, "")
+      end
+
+      def debugger_replacement(node, name_node)
+        receiver = node.receiver ? "#{node.receiver.location.slice}." : ""
+        quote = Kettle::Dev::VersionBump.quote_like(name_node.location.slice, DEBUG_GEM)
+        suffix = (node.name == :gem) ? ", require: false" : ""
+        "#{receiver}#{node.name} #{quote}#{suffix}"
+      end
+    end
+  end
+end

data/lib/kettle/family/release_reconciler.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "json"
+
+module Kettle
+  module Family
+    # Reconciles RubyGems publications with GitHub Release metadata without
+    # creating tags or publishing gems. The child executable performs the
+    # authoritative prerequisite checks before an optional GitHub API call.
+    class ReleaseReconciler
+      CHECK_PHASE = "reconcile_github_release_check"
+      CREATE_PHASE = "reconcile_github_release"
+
+      def initialize(config:, members:, execute: false, runner: nil)
+        @config = config
+        @members = members
+        @execute = execute
+        @runner = runner || CommandRunner.new(execute: true)
+      end
+
+      def results
+        release_states = release_state_by_member
+        members.flat_map do |member|
+          reconcile_member(member: member, release_state: release_states[member.name])
+        end
+      end
+
+      private
+
+      attr_reader :config, :members, :execute, :runner
+
+      def release_state_by_member
+        ReleaseStateCheck.new(config: config, members: members).results.each_with_object({}) do |result, memo|
+          memo[result.member_name] = result
+        end
+      end
+
+      def reconcile_member(member:, release_state:)
+        return [state_failure(member: member, release_state: release_state)] unless release_state&.ok?
+
+        state = release_state.state || {}
+        version = published_version(state)
+        return [informational_result(member: member, message: "RubyGems release version is unknown; no reconciliation attempted")] unless version
+        return [informational_result(member: member, message: "GitHub release already matches v#{version}")] if github_release_matches?(state, version)
+
+        check = runner.call(member: member, phase: CHECK_PHASE, command: gh_release_command("--check", "--release-version", version, "--events"))
+        return [check] unless check.ok?
+        check = summarize_check(check: check, member: member, version: version)
+        return [check] unless execute
+
+        [check, runner.call(member: member, phase: CREATE_PHASE, command: gh_release_command("--release-version", version, "--events"))]
+      end
+
+      def published_version(state)
+        version = state.fetch("latest_released", nil).to_s.delete_prefix("v")
+        return nil if version.empty? || version == "unknown"
+
+        version
+      end
+
+      def github_release_matches?(state, version)
+        state.fetch("github_latest_release", nil).to_s.delete_prefix("v") == version
+      end
+
+      def gh_release_command(*args)
+        [RbConfig.ruby, kettle_gh_release_path, *args]
+      end
+
+      def kettle_gh_release_path
+        local_path = local_kettle_dev_executable
+        return local_path if local_path
+
+        specification = Gem.loaded_specs["kettle-dev"] || Gem::Specification.find_by_name("kettle-dev")
+        File.join(specification.full_gem_path, "exe", "kettle-gh-release")
+      end
+
+      def local_kettle_dev_executable
+        root = ENV.fetch("KETTLE_DEV_DEV", "").strip
+        return if root.empty? || %w[false 0 no off].include?(root.downcase)
+
+        candidates = [
+          File.join(root, "exe", "kettle-gh-release"),
+          File.join(root, "kettle-dev", "exe", "kettle-gh-release")
+        ]
+        candidates.find { |path| File.file?(path) }
+      end
+
+      def informational_result(member:, message:)
+        CommandResult.new(
+          member_name: member.name,
+          phase: CHECK_PHASE,
+          command: ["internal", CHECK_PHASE],
+          workdir: member.root,
+          status: 0,
+          success: true,
+          stdout: message,
+          stderr: "",
+          elapsed_seconds: 0.0,
+          skipped: false,
+          reason: nil
+        )
+      end
+
+      def summarize_check(check:, member:, version:)
+        payload = check.stdout.to_s.each_line.filter_map do |line|
+          candidate = JSON.parse(line)
+          candidate if candidate["type"] == "github_release"
+        rescue JSON::ParserError
+          nil
+        end.last
+        message = payload&.fetch("message", nil) || "GitHub release v#{version} is eligible to be created"
+
+        CommandResult.new(
+          member_name: member.name,
+          phase: check.phase,
+          command: check.command,
+          workdir: check.workdir,
+          status: check.status,
+          success: check.success,
+          stdout: message,
+          stderr: check.stderr,
+          elapsed_seconds: check.elapsed_seconds,
+          skipped: check.skipped,
+          reason: check.reason,
+          branch: check.branch,
+          output_streamed: check.output_streamed,
+          log_path: check.log_path
+        )
+      end
+
+      def state_failure(member:, release_state:)
+        CommandResult.new(
+          member_name: member.name,
+          phase: CHECK_PHASE,
+          command: ["internal", CHECK_PHASE],
+          workdir: member.root,
+          status: release_state&.status || 1,
+          success: false,
+          stdout: "",
+          stderr: release_state&.stderr.to_s,
+          elapsed_seconds: 0.0,
+          skipped: false,
+          reason: "release state unavailable"
+        )
+      end
+    end
+  end
+end

data/lib/kettle/family/report.rb

@@ -20,6 +20,7 @@ module Kettle
         lint
         pull
         push
+        reconcile-releases
         release
         release-state
         reset

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.20"
+      VERSION = "1.2.21"
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/kettle/family/workflow.rb

@@ -228,21 +228,43 @@ module Kettle
       end
 
       def template_member_workflow_results(workflow_members)
+        debugger_results = template_debugger_bootstrap_results(workflow_members)
+        return debugger_results unless debugger_results.all?(&:ok?)
+
         bootstrap_results = template_bootstrap_dependency_results(workflow_members)
-        return bootstrap_results unless bootstrap_results.all?(&:ok?)
+        return debugger_results + bootstrap_results unless bootstrap_results.all?(&:ok?)
+
+        template_progress = start_template_progress(workflow_members)
+        results = template_dependency_waves(workflow_members).each_with_object([]) do |wave, memo|
+          wave_results = template_results_for_wave(wave, progress: template_progress)
+          memo.concat(wave_results)
+          break memo unless wave_results.all?(&:ok?)
+        end
+        emit_template_progress_summary(results, progress: template_progress)
+        debugger_results + bootstrap_results + results
+      end
+
+      def template_debugger_bootstrap_results(workflow_members)
+        bootstrap = DebuggerBootstrap.new(mode: :execute)
+        workflow_members.filter_map do |member|
+          bootstrap.bootstrap_member(member) if bootstrap.member_needs_bootstrap?(member)
+        end
+      rescue => error
+        [template_bootstrap_failure_result(workflow_members.first, error.message)]
+      end
 
+      def template_results_for_wave(wave, progress:)
         queue = Queue.new
-        workflow_members.each_with_index { |member, index| queue << [index, member] }
-        ordered_results = Array.new(workflow_members.length)
+        wave.each_with_index { |member, index| queue << [index, member] }
+        ordered_results = Array.new(wave.length)
         mutex = Mutex.new
         stop = false
-        template_progress = start_template_progress(workflow_members)
-        Array.new(template_jobs(workflow_members)) do
+        Array.new([template_jobs(wave), wave.length].min) do
           Thread.new do # rubocop:disable ThreadSafety/NewThread -- family templating intentionally runs independent members concurrently.
             loop do
               break if mutex.synchronize { stop }
               index, member = queue.pop(true)
-              member_results = template_results_for_member(member, progress: template_progress)
+              member_results = template_results_for_member(member, progress: progress)
               mutex.synchronize do
                 ordered_results[index] = member_results
                 stop = true unless member_results.all?(&:ok?)
@@ -252,9 +274,23 @@ module Kettle
             end
           end
         end.each(&:join)
-        flattened = ordered_results.compact.flatten
-        emit_template_progress_summary(flattened, progress: template_progress)
-        bootstrap_results + flattened
+        ordered_results.compact.flatten
+      end
+
+      def template_dependency_waves(workflow_members)
+        by_name = workflow_members.to_h { |member| [member.name, member] }
+        remaining = workflow_members.dup
+        completed = Set.new
+        [].tap do |waves|
+          until remaining.empty?
+            wave = remaining.select { |member| (member.dependencies & by_name.keys).all? { |name| completed.include?(name) } }
+            raise Error, "template dependency wave could not resolve: #{remaining.map(&:name).join(", ")}" if wave.empty?
+
+            waves << wave
+            completed.merge(wave.map(&:name))
+            remaining -= wave
+          end
+        end
       end
 
       def template_bootstrap_dependency_results(workflow_members)
@@ -2558,9 +2594,10 @@ module Kettle
         return configured unless template_prepare_lockfiles_phase?(phase)
         return %w[bundle install] if bundle_update_command?(configured) && !File.file?(File.join(member.root, "Gemfile.lock"))
 
-        command = PRE_TEMPLATE_BOOTSTRAP_GEMS.select { |gem_name| member_lockfile_contains_gem?(member, gem_name) }.reduce(configured) do |command_text, gem_name|
+        command = PRE_TEMPLATE_BOOTSTRAP_GEMS.select { |gem_name| member_declares_or_locks_gem?(member, gem_name) }.reduce(configured) do |command_text, gem_name|
           append_command_arg(command_text, gem_name)
         end
+        command = remove_command_arg(command, "nomono") unless member_declares_or_locks_gem?(member, "nomono")
         skip_checksum_option ? remove_command_arg(command, "--add-checksums") : command
       end
 
@@ -2575,7 +2612,19 @@ module Kettle
       def append_command_arg(command_text, arg)
         return command_text if normalize_command_includes_arg?(command_text, arg)
 
-        argv = command_text.is_a?(Array) ? command_text.map(&:to_s) : Shellwords.split(command_text.to_s)
+        return append_command_arg_to_argv(command_text.map(&:to_s), arg) if command_text.is_a?(Array)
+
+        # CommandRunner executes String commands through `sh -lc`. Ruby has no
+        # shell AST, so only parse the leading command segment and retain a
+        # configured compound-command operator and its remaining segments.
+        command, separator, remainder = command_text.to_s.partition(/\s(?:&&|\|\||;)\s/)
+        argv = append_command_arg_to_argv(Shellwords.split(command), arg)
+        [argv.shelljoin, separator, remainder].join
+      rescue ArgumentError
+        "#{command_text} #{Shellwords.escape(arg)}"
+      end
+
+      def append_command_arg_to_argv(argv, arg)
         update_index = argv.index("update")
         if update_index
           option_index = argv[(update_index + 1)..]&.index { |token| token.start_with?("-") }
@@ -2584,11 +2633,7 @@ module Kettle
         else
           argv << arg
         end
-        return argv if command_text.is_a?(Array)
-
-        argv.shelljoin
-      rescue ArgumentError
-        "#{command_text} #{Shellwords.escape(arg)}"
+        argv
       end
 
       def remove_command_arg(command_text, arg)
@@ -2618,6 +2663,20 @@ module Kettle
         File.readlines(lockfile).any? { |line| line.match?(/\A    #{Regexp.escape(gem_name)} \(/) }
       end
 
+      def member_declares_or_locks_gem?(member, gem_name)
+        return true if member_lockfile_contains_gem?(member, gem_name)
+
+        gemfile = File.join(member.root, "Gemfile")
+        return false unless File.file?(gemfile)
+
+        parsed = Kettle::Dev::VersionBump.parse_source(File.read(gemfile), gemfile)
+        Kettle::Dev::VersionBump.each_node(parsed.value).any? do |node|
+          node.is_a?(Prism::CallNode) && node.name == :gem &&
+            node.arguments&.arguments&.first.is_a?(Prism::StringNode) &&
+            node.arguments.arguments.first.unescaped == gem_name
+        end
+      end
+
       def template_prepare_lockfiles_phase?(phase)
         command == "template" && phase == "prepare_lockfiles"
       end
@@ -2666,6 +2725,11 @@ module Kettle
             memo: memo,
             phase: "prepare_template_dependencies_recovery"
           )
+          if no_release_lockfiles_failure?(memo.last)
+            memo.pop
+            memo << result
+            return false
+          end
           return false unless memo.last&.ok?
 
           result = runner.call(
@@ -2679,6 +2743,10 @@ module Kettle
         result.ok?
       end
 
+      def no_release_lockfiles_failure?(result)
+        result && !result.ok? && [result.stdout, result.stderr].join("\n").include?("kettle-reset: no release lockfiles found")
+      end
+
       def commit_template_changes(member:, runner:, memo:)
         return unless deferred_monorepo_template_commit?(member)
         return unless memo.all?(&:ok?)

data/lib/kettle/family.rb

@@ -13,9 +13,11 @@ require_relative "family/config"
 require_relative "family/secrets"
 require_relative "family/branch_target_config"
 require_relative "family/release_state_check"
+require_relative "family/release_reconciler"
 require_relative "family/unreleased_gem_cleanup"
 require_relative "family/local_install"
 require_relative "family/nomono_bootstrap"
+require_relative "family/debugger_bootstrap"
 require_relative "family/release_waves"
 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.20
+  version: 1.2.21
 platform: ruby
 authors:
 - Peter H. Boling
@@ -74,7 +74,7 @@ dependencies:
         version: '2.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.13
+        version: 2.5.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -84,7 +84,7 @@ dependencies:
         version: '2.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.13
+        version: 2.5.15
 - !ruby/object:Gem::Dependency
   name: kettle-test
   requirement: !ruby/object:Gem::Requirement
@@ -316,6 +316,7 @@ files:
 - lib/kettle/family/command_result.rb
 - lib/kettle/family/command_runner.rb
 - lib/kettle/family/config.rb
+- lib/kettle/family/debugger_bootstrap.rb
 - lib/kettle/family/dependency_floor.rb
 - lib/kettle/family/discovery.rb
 - lib/kettle/family/git_status.rb
@@ -324,6 +325,7 @@ files:
 - lib/kettle/family/nomono_bootstrap.rb
 - lib/kettle/family/orderer.rb
 - lib/kettle/family/readiness_check.rb
+- lib/kettle/family/release_reconciler.rb
 - lib/kettle/family/release_state_check.rb
 - lib/kettle/family/release_state_result.rb
 - lib/kettle/family/release_waves.rb
@@ -342,10 +344,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.20
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.20/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.2.21
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.21/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.20
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.21
   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