kettle-family 1.2.94 → 1.2.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60682b3f2d2f1017624cc67b428ff954b71f03eca4fdb6034cbe229183cba970
-  data.tar.gz: ea873857902fa44d2b2051e6449f21d84515139f005e1a9c148dfedf5062ce2f
+  metadata.gz: d2f776638603414ab6c27f457473dea3f6088bae63f58a45fcbc0f165fe0e026
+  data.tar.gz: b44e74efb8e840e929df24573b815df7b7a749f27e67f86f76561ab654b406ea
 SHA512:
-  metadata.gz: a14c847688ce762dbf03be0229b1c5ac0da23d3892e2e803467b8dc6efe73df4ede2b43d64a6ffedbccaf38f11da162bfad6bbf574a44b29739dafe8b8d70cba
-  data.tar.gz: 8ad7d29e783dace84ef807339b81907fe9e6e7c7f35ee60c4ac95b412a0972983c6eb7d9e8dad708801b270eda6ee0bb87d8759a22e3d4e29d6f254d4bfa6ff3
+  metadata.gz: 77f9c29784b453d8d270398c675ed52e18d8ba5f374fc8add80465bce88f59a679ab254080e3fe349685bff16134bb97541ef087d5c32116123c95e443b64685
+  data.tar.gz: 4e750df4e8f1f7f92ee8a653bac8ed02a95ee7ddfa5daa8f8eef92003b78e2c58c93b41498b0b93f8649626dcaf3a645f36fdedabf78928e35653131f14431c3

data/CHANGELOG.md

@@ -30,6 +30,34 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.2.96] - 2026-09-08
+
+- TAG: [v1.2.96][1.2.96t]
+- COVERAGE: 93.49% -- 6235/6669 lines in 35 files
+- BRANCH COVERAGE: 77.99% -- 2523/3235 branches in 35 files
+- 32.75% documented
+
+### Fixed
+
+- Render branch-worktree template events in distinct live progress rows.
+
+- Run release-state branch targets concurrently and render distinct branch progress rows.
+
+- Preserve configured release waves for ordinary sibling members when another member has release-target branches.
+
+- Restore the version_gem runtime dependency and preserve worktree integration documentation during template updates.
+
+## [1.2.95] - 2026-09-07
+
+- TAG: [v1.2.95][1.2.95t]
+- COVERAGE: 93.49% -- 6199/6631 lines in 35 files
+- BRANCH COVERAGE: 78.03% -- 2515/3223 branches in 35 files
+- 32.58% documented
+
+### Fixed
+
+- Run release-target branch worktrees through the full template bootstrap workflow before member preparation.
+
 ## [1.2.94] - 2026-09-07
 
 - TAG: [v1.2.94][1.2.94t]
@@ -2640,7 +2668,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.94...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.2.96...HEAD
+[1.2.96]: https://github.com/kettle-dev/kettle-family/compare/v1.2.95...v1.2.96
+[1.2.96t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.96
+[1.2.95]: https://github.com/kettle-dev/kettle-family/compare/v1.2.94...v1.2.95
+[1.2.95t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.95
 [1.2.94]: https://github.com/kettle-dev/kettle-family/compare/v1.2.93...v1.2.94
 [1.2.94t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.94
 [1.2.93]: https://github.com/kettle-dev/kettle-family/compare/v1.2.92...v1.2.93

data/README.md

@@ -902,6 +902,23 @@ the template dependency graph. It must not invoke release-lockfile reset logic:
 release normalization intentionally disables local paths, while template
 recovery needs configured sibling paths to resolve unreleased family versions.
 
+### Branch Worktree Equivalence
+
+A release-target branch worktree is a separate checkout of the same template
+member, not a reduced template workflow. Before its member template body runs,
+it executes the same debugger, Appraisal, and Nomono bootstrap boundary as an
+ordinary member. It then executes the same lockfile preparation, dependency
+preparation and recovery, `kettle-jem` invocation, lockfile normalization, and
+template commit path with the same `template_local` environment.
+
+Only checkout mechanics differ: Family creates and trusts the linked worktree,
+rebases that target branch on its own upstream when one exists, attaches the
+branch name to the results, and removes the worktree after completion. These
+steps are necessary because each target has a distinct Git ref and an absolute
+`mise` configuration path. They do not change the dependency graph or omit a
+template phase. Regression specs assert that branch worktrees call the shared
+bootstrap boundary and cannot start a member template body when it fails.
+
 ## 🔐 Security
 
 See [SECURITY.md][🔐security].
@@ -1154,7 +1171,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.613-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-6.669-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

@@ -709,7 +709,7 @@ module Kettle
         display_selected_members = display_members_for(command: command, config: config, members: selected, selected_members: selected)
         print_execution_intent(command: command, config: config, members: display_selected_members, options: options, start_at: start_at)
         started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        state_progress = release_state_progress(command: command, members: result_members, options: options)
+        state_progress = release_state_progress(command: command, config: config, members: result_members, options: options)
         state_progress&.start
         state_event_handler = release_state_event_handler(
           event_tape: state_event_tape,
@@ -901,21 +901,36 @@ module Kettle
         stdout
       end
 
-      def release_state_progress(command:, members:, options:)
+      def release_state_progress(command:, config:, members:, options:)
         return nil unless command == "release-state"
         return nil if options[:events] || options[:json]
         return nil unless stdout.respond_to?(:tty?) && stdout.tty?
 
+        targets = release_state_progress_targets(config: config, members: members)
+
         WorkflowProgress.new(
           io: stdout,
           label: "release state",
-          total: members.length,
-          jobs: Concurrency.wave_jobs(requested: options[:jobs], item_count: members.length),
-          members: members,
-          heading: "release state #{members.length} member#{"s" unless members.length == 1}:"
+          total: targets.length,
+          jobs: Concurrency.wave_jobs(requested: options[:jobs], item_count: targets.length),
+          members: targets.map { |target| target.fetch(:progress_member) },
+          heading: "release state #{targets.length} target#{"s" unless targets.length == 1}:"
         )
       end
 
+      def release_state_progress_targets(config:, members:)
+        members.flat_map do |member|
+          member_config = member_release_config(member: member, config: config)
+          branches = member_config&.release_target_branches.to_a
+          next [{member: member, key: member.name, label: member.name, progress_member: member}] if branches.empty?
+
+          branches.map do |branch|
+            label = "#{member.name}@#{branch}"
+            {member: member, key: label, label: label, progress_member: member.dup.tap { |copy| copy.name = label }}
+          end
+        end
+      end
+
       def release_state_event_handler(event_tape:, progress:, members:)
         return nil unless event_tape || progress
 
@@ -927,18 +942,21 @@ module Kettle
           member = members_by_name[event["member"]]
           next unless member
 
+          branch = event["branch"].to_s
+          progress_key = branch.empty? ? member.name : "#{member.name}@#{branch}"
+
           action = event["action"].to_s
           status = event["status"].to_s
           case action
           when "member_start"
-            progress.start_member(member, total: 5, status: "release_state")
+            progress.start_member(member, total: 5, status: "release_state", key: progress_key, label: progress_key)
           when "member_complete"
-            progress.finish_member(member, success: status == "ok", status: status)
+            progress.finish_member(member, success: status == "ok", status: status, key: progress_key, label: progress_key)
           when "changelog_command", "computed_booleans", "git_state", "github_release", "transfer_changelog"
             if status == "running"
-              progress.update(member, status: action)
+              progress.update(member, status: action, key: progress_key, label: progress_key)
             elsif status == "ok" || status == "failed"
-              progress.advance(member, status: action, success: status == "ok")
+              progress.advance(member, status: action, success: status == "ok", key: progress_key, label: progress_key)
             end
           end
         end

data/lib/kettle/family/discovery.rb

@@ -5,6 +5,11 @@ require "open3"
 module Kettle
   module Family
     class Discovery
+      # Dir.chdir changes process-global state. Legacy gemspecs require this
+      # evaluation context, so serialize only that boundary; discovery callers
+      # may still resolve separate members and worktrees concurrently.
+      GEMSPEC_EVALUATION_MUTEX = Mutex.new
+
       def initialize(config:, release_dependency_member_names: nil)
         @config = config
         @release_dependency_member_names = release_dependency_member_names&.map(&:to_s)
@@ -174,9 +179,11 @@ module Kettle
         # evaluates gemspecs relative to the current process directory.
         # Gem::Specification.load caches by path, which is wrong for branch-stack
         # workflows that checkout different contents at the same path.
-        # rubocop:disable ThreadSafety/DirChdir
-        spec = Dir.chdir(File.dirname(path)) { eval_gemspec(path) }
-        # rubocop:enable ThreadSafety/DirChdir
+        spec = GEMSPEC_EVALUATION_MUTEX.synchronize do
+          # rubocop:disable ThreadSafety/DirChdir
+          Dir.chdir(File.dirname(path)) { eval_gemspec(path) }
+          # rubocop:enable ThreadSafety/DirChdir
+        end
         raise Error, "could not load gemspec #{path}" unless spec
 
         spec

data/lib/kettle/family/release_state_check.rb

@@ -56,20 +56,23 @@ module Kettle
       def branch_results(event_handler: nil)
         root = git_root
         selected_names = members.map(&:name)
-        release_target_branches.each_with_object([]) do |branch, memo|
-          with_branch_worktree(root: root, branch: branch) do |worktree_root|
-            branch_members = discover_branch_members(worktree_root: worktree_root, selected_names: selected_names)
-            if shared_changelog?
-              results = parallel_map(branch_members) { |member| check_shared_changelog_member_or_local(member, branch: branch, event_handler: event_handler) }
-              memo.concat(normalize_shared_version_bump(results))
-              next
-            end
+        parallel_map(release_target_branches) do |branch|
+          branch_results_for(branch: branch, root: root, selected_names: selected_names, event_handler: event_handler)
+        end.flatten
+      end
 
-            memo.concat(parallel_map(branch_members) { |member| check_member(member, branch: branch, event_handler: event_handler) })
+      def branch_results_for(branch:, root:, selected_names:, event_handler:)
+        with_branch_worktree(root: root, branch: branch) do |worktree_root|
+          branch_members = discover_branch_members(worktree_root: worktree_root, selected_names: selected_names)
+          if shared_changelog?
+            results = parallel_map(branch_members) { |member| check_shared_changelog_member_or_local(member, branch: branch, event_handler: event_handler) }
+            next normalize_shared_version_bump(results)
           end
-        rescue Error => error
-          memo << error_result(branch: branch, error: error)
+
+          parallel_map(branch_members) { |member| check_member(member, branch: branch, event_handler: event_handler) }
         end
+      rescue Error => error
+        [error_result(branch: branch, error: error)]
       end
 
       def check_member(member, branch: nil, event_handler: nil)

data/lib/kettle/family/release_state_event_tape.rb

@@ -27,12 +27,12 @@ module Kettle
           "timestamp" => @wall_clock.call,
           "elapsed_seconds" => @clock.call - @started_at
         )
-        member = payload.fetch("member", "family").to_s
+        target = target_key(payload)
         @mutex.synchronize do
-          @sequence_by_member[member] += 1
-          payload["sequence"] = @sequence_by_member.fetch(member)
+          @sequence_by_member[target] += 1
+          payload["sequence"] = @sequence_by_member.fetch(target)
           line = JSON.generate(payload)
-          File.open(path_for(member), "a") { |file| file.puts(line) }
+          File.open(path_for(target), "a") { |file| file.puts(line) }
           @stream&.puts(line)
           @stream.flush if @stream&.respond_to?(:flush)
         end
@@ -43,8 +43,14 @@ module Kettle
 
       private
 
-      def path_for(member)
-        filename = member.gsub(/[^A-Za-z0-9_.-]+/, "_")
+      def target_key(payload)
+        member = payload.fetch("member", "family").to_s
+        branch = payload["branch"].to_s
+        branch.empty? ? member : "#{member}@#{branch}"
+      end
+
+      def path_for(target)
+        filename = target.gsub(/[^A-Za-z0-9_.-]+/, "_")
         File.join(@directory, "#{filename}.ndjson")
       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.94"
+      VERSION = "1.2.96"
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/kettle/family/workflow.rb

@@ -932,14 +932,8 @@ 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?)
-
-        appraisal_results = template_appraisal_bootstrap_results(workflow_members)
-        return debugger_results + appraisal_results unless appraisal_results.all?(&:ok?)
-
-        bootstrap_results = template_bootstrap_dependency_results(workflow_members)
-        return debugger_results + appraisal_results + bootstrap_results unless bootstrap_results.all?(&:ok?)
+        bootstrap_results = template_member_bootstrap_results(workflow_members)
+        return 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|
@@ -948,7 +942,22 @@ module Kettle
           break memo unless wave_results.all?(&:ok?)
         end
         emit_template_progress_summary(results, progress: template_progress)
-        debugger_results + appraisal_results + bootstrap_results + results
+        bootstrap_results + results
+      end
+
+      # This is the common preparation boundary for every template member,
+      # regardless of whether it runs in its primary checkout, a monorepo
+      # worktree, or a release-target branch worktree. Keep branch mechanics
+      # outside this method so they cannot silently omit a bootstrap phase.
+      def template_member_bootstrap_results(workflow_members)
+        debugger_results = template_debugger_bootstrap_results(workflow_members)
+        return debugger_results unless debugger_results.all?(&:ok?)
+
+        appraisal_results = template_appraisal_bootstrap_results(workflow_members)
+        return debugger_results + appraisal_results unless appraisal_results.all?(&:ok?)
+
+        bootstrap_results = template_bootstrap_dependency_results(workflow_members)
+        debugger_results + appraisal_results + bootstrap_results
       end
 
       def template_debugger_bootstrap_results(workflow_members)
@@ -1402,13 +1411,20 @@ module Kettle
         )
       end
 
-      def template_results_for_member(member, progress: nil, commit_changes: true, wave_jobs: 1)
-        progress&.start_member(member, total: template_phase_total(member), status: template_initial_status(member))
+      def template_results_for_member(member, progress: nil, progress_key: nil, progress_label: nil, commit_changes: true, wave_jobs: 1)
+        progress_key ||= member.name
+        progress_label ||= member.name
+        progress&.start_member(
+          member,
+          total: template_phase_total(member),
+          status: template_initial_status(member),
+          **template_progress_identity_options(member, progress_key, progress_label)
+        )
         runner = CommandRunner.new(execute: execute, accept: accept)
         [].tap do |memo|
           if config.normalize_lockfiles?
             normalize_lockfiles(member: member, runner: runner, memo: memo, phase: "prepare_lockfiles", commit_changes: commit_changes)
-            emit_member_result_progress(member, memo.last, progress: progress)
+            emit_member_result_progress(member, memo.last, progress: progress, progress_key: progress_key, progress_label: progress_label)
             return memo unless memo.last.ok?
           end
 
@@ -1419,7 +1435,7 @@ module Kettle
             commit_changes: commit_changes,
             wave_jobs: wave_jobs
           )
-          emit_member_result_progress(member, memo.last, progress: progress) if memo.last&.phase == "prepare_template_dependencies"
+          emit_member_result_progress(member, memo.last, progress: progress, progress_key: progress_key, progress_label: progress_label) if memo.last&.phase == "prepare_template_dependencies"
           return memo if prepared == false
 
           memo << runner.call(
@@ -1427,22 +1443,23 @@ module Kettle
             phase: command,
             command: workflow_command(member),
             env: template_command_env(wave_jobs: wave_jobs),
-            stdout_line_handler: template_event_line_handler(member, progress: progress)
+            stdout_line_handler: template_event_line_handler(member, progress: progress, progress_key: progress_key, progress_label: progress_label)
           )
-          emit_member_result_progress(member, memo.last, progress: progress)
+          emit_member_result_progress(member, memo.last, progress: progress, progress_key: progress_key, progress_label: progress_label)
           return memo unless memo.last.ok?
 
           normalize_lockfiles(member: member, runner: runner, memo: memo, phase: "normalize_lockfiles", commit_changes: commit_changes)
-          emit_member_result_progress(member, memo.last, progress: progress)
+          emit_member_result_progress(member, memo.last, progress: progress, progress_key: progress_key, progress_label: progress_label)
           commit_template_changes(member: member, runner: runner, memo: memo) if commit_changes
-          emit_member_result_progress(member, memo.last, progress: progress) if memo.last&.phase == "commit_template"
+          emit_member_result_progress(member, memo.last, progress: progress, progress_key: progress_key, progress_label: progress_label) if memo.last&.phase == "commit_template"
         ensure
           template_result = memo.find { |result| result.phase == "template" } || memo.last
           if template_result
             progress&.finish_member(
               member,
               success: memo.all?(&:ok?),
-              status: template_member_finish_status(template_result)
+              status: template_member_finish_status(template_result),
+              **template_progress_identity_options(member, progress_key, progress_label)
             )
           end
         end
@@ -1559,7 +1576,13 @@ module Kettle
 
             if outcomes.all?(&:ok?)
               emit_template_event_line(member, ">", "branch worktrees #{entries.length} branches, #{template_jobs(entries)} jobs")
-              outcomes.concat(template_branch_worktree_entries_results(entries))
+              progress = start_template_progress(
+                entries.map { |entry| template_branch_progress_member(entry) },
+                heading: "templating #{entries.length} branch worktree#{"s" unless entries.length == 1} with #{template_jobs(entries)} job#{"s" unless template_jobs(entries) == 1}:"
+              )
+              branch_results = template_branch_worktree_entries_results(entries, progress: progress)
+              emit_template_progress_summary(branch_results, progress: progress)
+              outcomes.concat(branch_results)
             end
           end
         end
@@ -1649,7 +1672,18 @@ module Kettle
         []
       end
 
-      def template_branch_worktree_entries_results(entries)
+      def template_branch_worktree_entries_results(entries, progress: nil)
+        results = template_branch_worktree_sync_results(entries)
+        return results unless results.all?(&:ok?)
+
+        # A branch worktree is a different checkout, not a different template
+        # profile. Run the exact same member bootstrap boundary used by normal
+        # members before any branch begins its member template body.
+        bootstrap_results = template_member_bootstrap_results(entries.map { |entry| entry.fetch(:member) })
+        tag_template_worktree_results(bootstrap_results, entries)
+        results.concat(bootstrap_results)
+        return results unless bootstrap_results.all?(&:ok?)
+
         wave_jobs = template_jobs(entries)
         queue = Queue.new
         entries.each_with_index { |entry, index| queue << [index, entry] }
@@ -1661,7 +1695,7 @@ module Kettle
             loop do
               break if mutex.synchronize { stop }
               index, entry = queue.pop(true)
-              branch_results = template_branch_worktree_entry_results(entry, wave_jobs: wave_jobs)
+              branch_results = template_branch_worktree_entry_results(entry, progress: progress, wave_jobs: wave_jobs)
               mutex.synchronize do
                 ordered_results[index] = branch_results
                 stop = true unless branch_results.all?(&:ok?)
@@ -1671,23 +1705,59 @@ module Kettle
             end
           end
         end.each(&:join)
-        ordered_results.compact.flatten
+        results + ordered_results.compact.flatten
       end
 
-      def template_branch_worktree_entry_results(entry, wave_jobs: 1)
+      def template_branch_worktree_entry_results(entry, progress: nil, wave_jobs: 1)
         member = entry.fetch(:member)
         branch = entry.fetch(:branch)
-        runner = command_runner
-        results = []
-        if git_upstream_for(member)
-          results << runner.call(member: member, phase: "template_branch_sync", command: ["git", "rebase", "@{upstream}"])
-        end
-        results.concat(template_results_for_member(member, wave_jobs: wave_jobs)) if results.all?(&:ok?)
+        # Bootstrap and upstream synchronization are deliberately performed
+        # for the complete branch set before workers start. The member body is
+        # the same method normal template waves invoke.
+        results = template_results_for_member(
+          member,
+          progress: progress,
+          progress_key: template_branch_progress_key(entry),
+          progress_label: template_branch_progress_label(entry),
+          wave_jobs: wave_jobs
+        )
         tag_branch_results(results, branch)
         emit_template_event_line(member, results.all?(&:ok?) ? "." : "F", "branch #{branch}")
         results
       end
 
+      def template_branch_progress_member(entry)
+        entry.fetch(:member).dup.tap { |member| member.name = template_branch_progress_label(entry) }
+      end
+
+      def template_branch_progress_key(entry)
+        template_branch_progress_label(entry)
+      end
+
+      def template_branch_progress_label(entry)
+        "#{entry.fetch(:member).name}@#{entry.fetch(:branch)}"
+      end
+
+      def template_branch_worktree_sync_results(entries)
+        runner = command_runner
+        entries.filter_map do |entry|
+          member = entry.fetch(:member)
+          upstream = git_upstream_for(member)
+          next unless upstream
+
+          result = runner.call(member: member, phase: "template_branch_sync", command: ["git", "rebase", "@{upstream}"])
+          result.branch = entry.fetch(:branch)
+          result
+        end
+      end
+
+      def tag_template_worktree_results(results, entries)
+        branches_by_root = entries.to_h { |entry| [File.expand_path(entry.fetch(:member).root), entry.fetch(:branch)] }
+        results.each do |result|
+          result.branch = branches_by_root[File.expand_path(result.workdir)] if result.workdir
+        end
+      end
+
       def template_branch_worktree_cleanup_results(entries, runner:, control_member:)
         entries.filter_map do |entry|
           worktree_root = entry[:worktree_root]
@@ -1964,18 +2034,21 @@ module Kettle
       end
 
       def release_member_local_branch_target_results
-        runner = command_runner
+        target_members, current_branch_members = members.partition do |member|
+          member_local_release_config(member)
+        end
         results = []
-        append_family_changelog_result(runner: runner, memo: results) unless skip_changelog
+
+        # A member with release targets must not force unrelated sibling
+        # repositories through one-at-a-time release workflows. Run those
+        # members through the normal release scheduler first so configured
+        # waves and their worker budget remain effective.
+        results.concat(current_branch_results(current_branch_members)) unless current_branch_members.empty?
         return results unless results.all?(&:ok?)
 
-        members.each_with_object(results) do |member, memo|
+        target_members.each_with_object(results) do |member, memo|
           member_config = member_local_release_config(member)
-          if member_config
-            memo.concat(member_local_workflow(member: member, member_config: member_config).results)
-          else
-            memo.concat(release_member_results([member], include_family_changelog: false))
-          end
+          memo.concat(member_local_workflow(member: member, member_config: member_config).results)
           break memo unless memo.last&.ok?
         end
       end
@@ -4324,13 +4397,14 @@ module Kettle
         append_command_args(command_text, args)
       end
 
-      def start_template_progress(workflow_members)
+      def start_template_progress(workflow_members, heading: nil)
         progress = WorkflowProgress.new(
           io: progress_io,
           label: "templating",
           total: workflow_members.length,
           jobs: template_jobs(workflow_members),
-          members: workflow_members
+          members: workflow_members,
+          heading: heading
         )
         progress.start
         progress
@@ -4434,10 +4508,16 @@ module Kettle
         kettle_jem_template_command?(command_text)
       end
 
-      def emit_member_result_progress(member, result, progress:)
+      def emit_member_result_progress(member, result, progress:, progress_key: member.name, progress_label: member.name)
         return unless result
 
-        progress&.advance(member, status: result.phase, success: result.ok?, mark: command_result_progress_mark(result))
+        progress&.advance(
+          member,
+          status: result.phase,
+          success: result.ok?,
+          mark: command_result_progress_mark(result),
+          **template_progress_identity_options(member, progress_key, progress_label)
+        )
       end
 
       def command_result_progress_mark(result)
@@ -4484,7 +4564,7 @@ module Kettle
         progress.summary("release summary: #{release_results.count(&:ok?)}/#{release_results.length} members ok")
       end
 
-      def template_event_line_handler(member, progress: nil)
+      def template_event_line_handler(member, progress: nil, progress_key: member.name, progress_label: member.name)
         lambda do |line|
           event = parse_template_event(line)
           next false unless event
@@ -4493,7 +4573,7 @@ module Kettle
             if verbose || debug
               emit_template_event_progress(member, event)
             elsif progress&.tty?
-              emit_template_event_status(member, event, progress: progress)
+              emit_template_event_status(member, event, progress: progress, progress_key: progress_key, progress_label: progress_label)
             end
           end
           true
@@ -4611,7 +4691,7 @@ module Kettle
         end
       end
 
-      def emit_template_event_status(member, event, progress:)
+      def emit_template_event_status(member, event, progress:, progress_key: member.name, progress_label: member.name)
         status = case event["type"]
         when "phase_start", "phase_finish"
           event["phase"].to_s
@@ -4625,7 +4705,20 @@ module Kettle
           template_event_summary_label(event)
         end
         mark = template_event_status_mark(event)
-        progress&.update(member, status: status, mark: mark) if status && !status.empty?
+        if status && !status.empty?
+          progress&.update(
+            member,
+            status: status,
+            mark: mark,
+            **template_progress_identity_options(member, progress_key, progress_label)
+          )
+        end
+      end
+
+      def template_progress_identity_options(member, progress_key, progress_label)
+        return {} if progress_key == member.name && progress_label == member.name
+
+        {key: progress_key, label: progress_label}
       end
 
       def emit_release_event_progress(member, event)

data/lib/kettle/family/workflow_progress.rb

@@ -27,6 +27,7 @@ module Kettle
         @started = false
         @stopped = false
         @member_totals = {}
+        @member_labels = @line_order.to_h { |member_name| [member_name, member_name] }
         @member_counts = Hash.new(0)
         @member_started_at = {}
         @member_finished_elapsed = {}
@@ -55,62 +56,66 @@ module Kettle
         end
       end
 
-      def start_member(member, total:, status:)
+      def start_member(member, total:, status:, key: member.name, label: member.name)
         return unless @enabled
 
         synchronize do
-          @member_totals[member.name] = total.to_i
-          @member_counts[member.name] = 0
-          @member_started_at[member.name] ||= monotonic_now
-          @member_finished_elapsed.delete(member.name)
+          @member_labels[key] = label
+          @member_totals[key] = total.to_i
+          @member_counts[key] = 0
+          @member_started_at[key] ||= monotonic_now
+          @member_finished_elapsed.delete(key)
           if @tty
-            render(member, status: status)
+            render(key, status: status)
           else
-            write_line(non_tty_line(member, mark: ">", status: status))
+            write_line(non_tty_line(key, mark: ">", status: status))
           end
         end
       end
 
-      def advance(member, status:, success: true, mark: nil)
+      def advance(member, status:, success: true, mark: nil, key: member.name, label: member.name)
         return unless @enabled
 
         synchronize do
+          @member_labels[key] = label
           event_mark = mark || (success ? "." : "F")
-          increment_member_count(member)
+          increment_member_count(key)
           if @tty
-            append_event(member, event_mark)
-            render(member, status: status)
+            append_event(key, event_mark)
+            render(key, status: status)
           else
-            write_line(non_tty_line(member, mark: event_mark, status: status))
+            write_line(non_tty_line(key, mark: event_mark, status: status))
           end
         end
       end
 
-      def update(member, status:, mark: nil)
+      def update(member, status:, mark: nil, key: member.name, label: member.name)
         return unless @enabled
         return if status.to_s.empty?
 
         synchronize do
+          @member_labels[key] = label
           if @tty
-            append_event(member, mark) if mark
-            render(member, status: status)
+            append_event(key, mark) if mark
+            render(key, status: status)
           else
-            write_line(non_tty_line(member, mark: mark || ">", status: status))
+            write_line(non_tty_line(key, mark: mark || ">", status: status))
           end
         end
       end
 
-      def finish_member(member, success:, status:)
+      def finish_member(member, success:, status:, key: member.name, label: member.name)
         return unless @enabled
 
         synchronize do
-          total = @member_totals[member.name].to_i
-          @member_counts[member.name] = total if total.positive?
-          @member_finished_elapsed[member.name] = elapsed_seconds(member)
+          @member_labels[key] = label
+          total = @member_totals[key].to_i
+          @member_counts[key] = total if total.positive?
+          @member_finished_elapsed[key] = elapsed_seconds_by_name(key)
           if @tty
-            render(member, status: status)
+            render(key, status: status)
           else
-            write_line(non_tty_line(member, mark: success ? "done" : "failed", status: status))
+            write_line(non_tty_line(key, mark: success ? "done" : "failed", status: status))
           end
         end
       end
@@ -168,15 +173,15 @@ module Kettle
 
       private
 
-      def render(member, status:)
-        render_name(member.name, status: status)
+      def render(member_key, status:)
+        render_name(member_key, status: status)
         render_tty_block if @tty
       end
 
-      def append_event(member, mark)
+      def append_event(member_key, mark)
         return if mark.to_s.empty?
 
-        @member_events[member.name] = (@member_events[member.name] + mark.to_s).chars.last(EVENT_WIDTH).join
+        @member_events[member_key] = (@member_events[member_key] + mark.to_s).chars.last(EVENT_WIDTH).join
       end
 
       def render_name(member_name, status:)
@@ -222,7 +227,7 @@ module Kettle
       def tty_line(member_name)
         Kernel.format(
           FORMAT,
-          member: member_name,
+          member: @member_labels.fetch(member_name, member_name),
           progress: progress_text(member_name),
           duration: elapsed_text(member_name),
           events: @member_events[member_name].rjust(EVENT_WIDTH),
@@ -234,15 +239,15 @@ module Kettle
         "s" unless count == 1
       end
 
-      def non_tty_line(member, mark:, status:)
-        "[#{member.name}] #{progress_text(member.name)} #{elapsed_text(member.name)} #{mark} #{status}"
+      def non_tty_line(member_key, mark:, status:)
+        label = @member_labels.fetch(member_key, member_key)
+        "[#{label}] #{progress_text(member_key)} #{elapsed_text(member_key)} #{mark} #{status}"
       end
 
-      def increment_member_count(member)
-        member_name = member.name
-        total = @member_totals[member_name].to_i
-        @member_counts[member_name] += 1
-        @member_counts[member_name] = total if total.positive? && @member_counts[member_name] > total
+      def increment_member_count(member_key)
+        total = @member_totals[member_key].to_i
+        @member_counts[member_key] += 1
+        @member_counts[member_key] = total if total.positive? && @member_counts[member_key] > total
       end
 
       def progress_text(member_name)
@@ -256,10 +261,6 @@ module Kettle
         format_elapsed(elapsed_seconds_by_name(member_name)).rjust(ELAPSED_WIDTH)
       end
 
-      def elapsed_seconds(member)
-        elapsed_seconds_by_name(member.name)
-      end
-
       def elapsed_seconds_by_name(member_name)
         return @member_finished_elapsed[member_name] if @member_finished_elapsed.key?(member_name)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-family
 version: !ruby/object:Gem::Version
-  version: 1.2.94
+  version: 1.2.96
 platform: ruby
 authors:
 - Peter H. Boling
@@ -89,22 +89,22 @@ dependencies:
   name: kettle-dev
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.31
-    - - "<"
+        version: '3.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 3.0.33
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.31
-    - - "<"
+        version: '3.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 3.0.33
 - !ruby/object:Gem::Dependency
   name: kettle-gha-pins
   requirement: !ruby/object:Gem::Requirement
@@ -131,20 +131,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.23
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.23
 - !ruby/object:Gem::Dependency
   name: kettle-test
   requirement: !ruby/object:Gem::Requirement
@@ -304,7 +304,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2
+        version: 3.2.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -314,7 +314,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2
+        version: 3.2.3
 - !ruby/object:Gem::Dependency
   name: turbo_tests2
   requirement: !ruby/object:Gem::Requirement
@@ -324,7 +324,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.6
+        version: 3.2.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -334,7 +334,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.6
+        version: 3.2.7
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -443,10 +443,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.94
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.94/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.2.96
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.96/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.94
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.96
   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