kettle-family 1.2.29 → 1.2.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a59d676b17391390f1887d2dce0aeaf28da50217dd0e31fd36ee6a44cac34c46
-  data.tar.gz: 22667d4505dc471ac6b8ea0cb10d97c636316ea97103e2b4b411a18aefaf3155
+  metadata.gz: 945e285ec99d1d336abdf5a51c05135c99485cafeb1b47a65b81ab72818a6786
+  data.tar.gz: 29bd40256a7b84edaf06dd9adc4f0d21db43a470b07e71b17dc3295e23f9fe4e
 SHA512:
-  metadata.gz: 24f2c25f781d82b4fefc119b3ff04a07ff5fcc95396f624c8f42dbb33fd4f0fd5d51c66089ac8cd5e740e3df18d645c4c35cac837f73d3a3710b477a06ca4745
-  data.tar.gz: cf0e8f529773c0d8550f19e824dd572c716085eb07d3ac13e5938e8d5c8fff69a20862e17be6252bc1f8ae5212e064017836ea666ffcb7a87d56ea88b69e4bc0
+  metadata.gz: 6a25b8669590d61a7a2ecd48fc64bf7d32d7d6090fcea810b13673534827f6609f700ecbeb0ef8b5dded509c4de135f385323a034a236bfd092a9d789c93d178
+  data.tar.gz: '0508285a2bc3905833dffe7e0387909613f0ff669d9e600f640d1a052ab53f06fb67d6a7bc64a4bfbae1b8175f4bf5efc268f22e012fe6978802cbc01b4da55b'

data/CHANGELOG.md

@@ -30,6 +30,51 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.2.30] - 2026-08-04
+
+- TAG: [v1.2.30][1.2.30t]
+- COVERAGE: 94.10% -- 4944/5254 lines in 32 files
+- BRANCH COVERAGE: 76.51% -- 1964/2567 branches in 32 files
+- 29.86% documented
+
+### Added
+
+- Emit per-member NDJSON event tapes while deriving release state.
+
+- Render plain state analysis as stable per-member TTY progress rows before the final release-state table.
+
+### Fixed
+
+- Anchor TTY progress redraws and reserve a terminal column to prevent stale or wrapped rows.
+
+- Recover template autostashes when generated lockfiles are uncommitted.
+
+- Keep release secret-provider notifications on the dedicated TTY line.
+
+- Recover autostashes when generated lockfiles cause staged merge conflicts
+
+- Recognize nested monorepo lockfiles during template autostash recovery
+
+- TTY release progress now anchors redraws at column one so out-of-band notifications cannot concatenate with event tape rows.
+
+- Keep transient progress notifications on a dedicated line above the event tape with independent row accounting.
+
+- Preserve inherited local-path dependency environments during template bootstrap and lockfile recovery.
+
+- Keep secret-provider notifications off the TTY event tape in verbose and debug modes.
+
+- Normalize release-state event detail keys before writing NDJSON tapes.
+
+- Forward --events so state analysis is streamed as NDJSON instead of falling back to the text report.
+
+- Separate state analysis progress from the final release-state report on TTY output.
+
+- Restore all generated lockfiles during monorepo template autostash recovery.
+
+- Recover nested monorepo autostashes from the repository root.
+
+- Restore generated Gemfile.lock files between branch-matrix test and lint targets.
+
 ## [1.2.29] - 2026-08-03
 
 - TAG: [v1.2.29][1.2.29t]
@@ -1742,7 +1787,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.29...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.2.30...HEAD
+[1.2.30]: https://github.com/kettle-dev/kettle-family/compare/v1.2.29...v1.2.30
+[1.2.30t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.30
 [1.2.29]: https://github.com/kettle-dev/kettle-family/compare/v1.2.28...v1.2.29
 [1.2.29t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.29
 [1.2.28]: https://github.com/kettle-dev/kettle-family/compare/v1.2.27...v1.2.28

data/README.md

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

@@ -21,6 +21,7 @@ module Kettle
       option :config, value: {type: String, usage: "PATH"}, desc: "Family config path"
       option :json, desc: "Print JSON report to stdout"
       option :report, value: {type: String, usage: "PATH"}, desc: "Write JSON report to PATH"
+      option :events, desc: "Stream release-state analysis as NDJSON"
 
       def self.call(argv, out: $stdout, err: $stderr)
         main(argv, stdout: out, stderr: err)
@@ -32,6 +33,7 @@ module Kettle
           base.option :config, value: {type: String, usage: "PATH"}, desc: "Family config path"
           base.option :json, desc: "Print JSON report to stdout"
           base.option :report, value: {type: String, usage: "PATH"}, desc: "Write JSON report to PATH"
+          base.option :events, desc: "Stream release-state analysis as NDJSON"
         end
       end
 
@@ -136,6 +138,7 @@ module Kettle
             exclude: options[:exclude],
             start_at: options[:start_at],
             json: truthy_option?(:json),
+            events: truthy_option?(:events),
             report: options[:report],
             execute: truthy_option?(:execute),
             debug: truthy_option?(:debug),
@@ -613,7 +616,11 @@ module Kettle
       def run_command(command, options)
         report = build_report(command, options)
         write_report(report, options)
-        stdout.puts(options[:json] ? report.to_json : report.to_text)
+        if options[:events] && command == "release-state"
+          stdout.puts(JSON.generate("event_version" => 1, "type" => "summary", "report" => report.to_h))
+        else
+          stdout.puts(options[:json] ? report.to_json : report.to_text)
+        end
         report.success? ? 0 : 1
       rescue Error, OptionParser::ParseError => error
         stderr.puts("kettle-family: #{error.message}")
@@ -638,6 +645,7 @@ module Kettle
         else
           Orderer.new(members: members, mode: config.order_mode, hints: config.order_hints).ordered
         end
+        state_event_tape = release_state_event_tape(command: command, config: config, options: options)
         release_state_results = release_state_results_for_selection(config: config, members: ordered, only: effective_only)
         selected = Selection.new(members: ordered, release_state_results: release_state_results).apply(only: effective_only, exclude: options[:exclude], start_at: start_at.member)
         result_members = selected
@@ -645,7 +653,22 @@ 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)
-        results = command_results(command: command, config: config, members: result_members, options: options, start_at: start_at)
+        state_progress = release_state_progress(command: command, members: result_members, options: options)
+        state_progress&.start
+        state_event_handler = release_state_event_handler(
+          event_tape: state_event_tape,
+          progress: state_progress,
+          members: result_members
+        )
+        results = command_results(
+          command: command,
+          config: config,
+          members: result_members,
+          options: options,
+          start_at: start_at,
+          state_event_handler: state_event_handler
+        )
+        state_progress&.finish
         elapsed_seconds = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
         Report.new(
           family_name: config.family_name,
@@ -661,17 +684,18 @@ module Kettle
           command: command,
           results: results,
           warnings: discovery.warnings,
+          event_log_dirs: state_event_tape ? [state_event_tape.directory] : [],
           elapsed_seconds: elapsed_seconds
         )
       end
 
       StartAt = Struct.new(:member, :branch)
 
-      def command_results(command:, config:, members:, options:, start_at:)
+      def command_results(command:, config:, members:, options:, start_at:, state_event_handler: nil)
         return branch_target_command_results(command: command, config: config, members: members, options: options, start_at: start_at) if branch_target_command?(command, config)
         return member_local_branch_target_command_results(command: command, config: config, members: members, options: options, start_at: start_at) if member_local_branch_target_command?(command, config, members)
 
-        command_results_for_current_branch(command: command, config: config, members: members, options: options, start_at: start_at)
+        command_results_for_current_branch(command: command, config: config, members: members, options: options, start_at: start_at, state_event_handler: state_event_handler)
       end
 
       def release_state_results_for_selection(config:, members:, only:)
@@ -712,14 +736,14 @@ module Kettle
         members
       end
 
-      def command_results_for_current_branch(command:, config:, members:, options:, start_at: StartAt.new(nil, nil))
+      def command_results_for_current_branch(command:, config:, members:, options:, start_at: StartAt.new(nil, nil), state_event_handler: 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 release_state_results(config: config, members: members, event_handler: state_event_handler) if command == "release-state"
         return install_results(config: config, members: members, options: options) if command == "install"
         return [] unless WORKFLOW_COMMANDS.include?(command)
 
@@ -777,6 +801,49 @@ module Kettle
         stdout
       end
 
+      def release_state_progress(command:, members:, options:)
+        return nil unless command == "release-state"
+        return nil if options[:events] || options[:json]
+        return nil unless stdout.respond_to?(:tty?) && stdout.tty?
+
+        WorkflowProgress.new(
+          io: stdout,
+          label: "release state",
+          total: members.length,
+          jobs: [options[:jobs].to_i, 1].max,
+          members: members,
+          heading: "release state #{members.length} member#{"s" unless members.length == 1}:"
+        )
+      end
+
+      def release_state_event_handler(event_tape:, progress:, members:)
+        return nil unless event_tape || progress
+
+        members_by_name = members.to_h { |member| [member.name, member] }
+        lambda do |event|
+          event_tape&.call(event)
+          next unless progress
+
+          member = members_by_name[event["member"]]
+          next unless member
+
+          action = event["action"].to_s
+          status = event["status"].to_s
+          case action
+          when "member_start"
+            progress.start_member(member, total: 5, status: "release_state")
+          when "member_complete"
+            progress.finish_member(member, success: status == "ok", status: status)
+          when "changelog_command", "computed_booleans", "git_state", "github_release", "transfer_changelog"
+            if status == "running"
+              progress.update(member, status: action)
+            elsif status == "ok" || status == "failed"
+              progress.advance(member, status: action, success: status == "ok")
+            end
+          end
+        end
+      end
+
       def print_execution_intent(command:, config:, members:, options:, start_at:)
         return unless command == "release"
         return unless options[:execute]
@@ -1022,8 +1089,16 @@ module Kettle
         LocalInstall.new(config: config, members: members, execute: options[:execute], jobs: options[:jobs]).results
       end
 
-      def release_state_results(config:, members:)
-        ReleaseStateCheck.new(config: config, members: members).results
+      def release_state_results(config:, members:, event_handler: nil)
+        ReleaseStateCheck.new(config: config, members: members).results(event_handler: event_handler)
+      end
+
+      def release_state_event_tape(command:, config:, options:)
+        return unless command == "release-state"
+
+        tape = ReleaseStateEventTape.new(root: config.root, stream: options[:events] ? stdout : nil)
+        stderr.puts("release state event tapes: #{tape.directory}") unless options[:events]
+        tape
       end
 
       def release_mode(command:, options:)

data/lib/kettle/family/release_state_check.rb

@@ -28,16 +28,16 @@ module Kettle
         @transfer_changelog_total_count = TRANSFER_CHANGELOG_TOTAL_UNSET
       end
 
-      def results
-        return branch_results unless release_target_branches.empty?
-        return members.map { |member| check_shared_changelog_member_or_local(member) } if shared_changelog?
+      def results(event_handler: nil)
+        return branch_results(event_handler: event_handler) unless release_target_branches.empty?
+        return members.map { |member| check_shared_changelog_member_or_local(member, event_handler: event_handler) } if shared_changelog?
 
         members.each_with_object([]) do |member, memo|
-          member_branch_results = member_local_branch_results(member)
+          member_branch_results = member_local_branch_results(member, event_handler: event_handler)
           if member_branch_results
             memo.concat(member_branch_results)
           else
-            memo << check_member(member)
+            memo << check_member(member, event_handler: event_handler)
           end
         end
       end
@@ -46,63 +46,87 @@ module Kettle
 
       attr_reader :members, :config
 
-      def branch_results
+      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?
-              memo.concat(branch_members.map { |member| check_shared_changelog_member_or_local(member, branch: branch) })
+              memo.concat(branch_members.map { |member| check_shared_changelog_member_or_local(member, branch: branch, event_handler: event_handler) })
               next
             end
 
-            memo.concat(branch_members.map { |member| check_member(member, branch: branch) })
+            memo.concat(branch_members.map { |member| check_member(member, branch: branch, event_handler: event_handler) })
           end
         rescue Error => error
           memo << error_result(branch: branch, error: error)
         end
       end
 
-      def check_member(member, branch: nil)
+      def check_member(member, branch: nil, event_handler: nil)
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         command = release_state_command
+        emit_event(event_handler, member: member, branch: branch, action: "member_start", status: "running", command: command)
+        emit_event(event_handler, member: member, branch: branch, action: "changelog_command", status: "running", command: command)
         stdout, stderr, status = Open3.capture3(release_state_env(member), *command, chdir: release_state_workdir(member))
         elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
         success = status.success?
+        emit_event(event_handler, member: member, branch: branch, action: "changelog_command", status: success ? "ok" : "failed", elapsed_seconds: elapsed, status_code: status.exitstatus)
         state = success ? JSON.parse(stdout) : {}
+        emit_event(event_handler, member: member, branch: branch, action: "computed_booleans", status: "running") if success
         state = branch_filtered_state(member, state, branch) if success && branch
         state = state_with_computed_booleans(state) if success
+        emit_event(event_handler, member: member, branch: branch, action: "computed_booleans", status: "ok") if success
+        emit_event(event_handler, member: member, branch: branch, action: "git_state", status: "running") if success
         state = enrich_git_state(member.root, state, branch: branch) if success
+        emit_event(event_handler, member: member, branch: branch, action: "git_state", status: "ok") if success
+        emit_event(event_handler, member: member, branch: branch, action: "github_release", status: "running") if success
         state = enrich_github_release(member.root, state, branch: branch) if success
+        emit_event(event_handler, member: member, branch: branch, action: "github_release", status: "ok") if success
+        emit_event(event_handler, member: member, branch: branch, action: "transfer_changelog", status: "running") if success
         state = enrich_transfer_changelog_lag(member.root, state) if success
-        result(member: member, command: command, stdout: stdout, stderr: stderr, status: status.exitstatus, elapsed: elapsed, success: success, state: state, branch: branch)
+        emit_event(event_handler, member: member, branch: branch, action: "transfer_changelog", status: "ok") if success
+        result = result(member: member, command: command, stdout: stdout, stderr: stderr, status: status.exitstatus, elapsed: elapsed, success: success, state: state, branch: branch)
+        emit_event(event_handler, member: member, branch: branch, action: "member_complete", status: success ? "ok" : "failed", elapsed_seconds: elapsed, status_code: status.exitstatus)
+        result
       rescue JSON::ParserError => error
-        result(member: member, command: command || release_state_command, stdout: stdout, stderr: stderr, status: 1, elapsed: elapsed || 0.0, success: false, state: {}, reason: "invalid release-state JSON: #{error.message}", branch: branch)
+        result = result(member: member, command: command || release_state_command, stdout: stdout, stderr: stderr, status: 1, elapsed: elapsed || 0.0, success: false, state: {}, reason: "invalid release-state JSON: #{error.message}", branch: branch)
+        emit_event(event_handler, member: member, branch: branch, action: "member_complete", status: "failed", elapsed_seconds: elapsed || 0.0, status_code: 1, reason: result.reason)
+        result
       end
 
       def release_state_command
         [RbConfig.ruby, "-S", "kettle-changelog", "--release-state", "--json"]
       end
 
-      def check_shared_changelog_member_or_local(member, branch: nil)
-        return check_member(member, branch: branch) if member_local_changelog?(member)
+      def check_shared_changelog_member_or_local(member, branch: nil, event_handler: nil)
+        return check_member(member, branch: branch, event_handler: event_handler) if member_local_changelog?(member)
 
-        check_shared_changelog_member(member, branch: branch)
+        check_shared_changelog_member(member, branch: branch, event_handler: event_handler)
       end
 
-      def check_shared_changelog_member(member, branch: nil)
+      def check_shared_changelog_member(member, branch: nil, event_handler: nil)
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         command = release_state_command
+        emit_event(event_handler, member: member, branch: branch, action: "member_start", status: "running", command: command)
+        emit_event(event_handler, member: member, branch: branch, action: "changelog_command", status: "running", command: command)
         stdout, stderr, status = Open3.capture3(shared_changelog_env(member), *command, chdir: config.root)
         elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
         success = status.success?
+        emit_event(event_handler, member: member, branch: branch, action: "changelog_command", status: success ? "ok" : "failed", elapsed_seconds: elapsed, status_code: status.exitstatus)
         state = success ? JSON.parse(stdout) : {}
         state = branch_filtered_state(member, state, branch) if success && branch
+        emit_event(event_handler, member: member, branch: branch, action: "git_state", status: "running") if success
         state = enrich_git_state(member.root, state, branch: branch) if success
+        emit_event(event_handler, member: member, branch: branch, action: "git_state", status: "ok") if success
+        emit_event(event_handler, member: member, branch: branch, action: "github_release", status: "running") if success
         state = enrich_github_release(member.root, state, branch: branch) if success
+        emit_event(event_handler, member: member, branch: branch, action: "github_release", status: "ok") if success
+        emit_event(event_handler, member: member, branch: branch, action: "transfer_changelog", status: "running") if success
         state = enrich_transfer_changelog_lag(member.root, state) if success
-        result(
+        emit_event(event_handler, member: member, branch: branch, action: "transfer_changelog", status: "ok") if success
+        result = result(
           member: member,
           command: command,
           stdout: stdout,
@@ -113,10 +137,14 @@ module Kettle
           state: state,
           branch: branch
         )
+        emit_event(event_handler, member: member, branch: branch, action: "member_complete", status: success ? "ok" : "failed", elapsed_seconds: elapsed, status_code: status.exitstatus)
+        result
       rescue JSON::ParserError => error
-        result(member: member, command: command || release_state_command, stdout: stdout, stderr: stderr, status: 1, elapsed: elapsed || 0.0, success: false, state: {}, reason: "invalid release-state JSON: #{error.message}", branch: branch)
+        result = result(member: member, command: command || release_state_command, stdout: stdout, stderr: stderr, status: 1, elapsed: elapsed || 0.0, success: false, state: {}, reason: "invalid release-state JSON: #{error.message}", branch: branch)
+        emit_event(event_handler, member: member, branch: branch, action: "member_complete", status: "failed", elapsed_seconds: elapsed || 0.0, status_code: 1, reason: result.reason)
+        result
       rescue Error => error
-        result(
+        result = result(
           member: member,
           command: command || release_state_command,
           stdout: "",
@@ -128,6 +156,8 @@ module Kettle
           reason: "release state check failed",
           branch: branch
         )
+        emit_event(event_handler, member: member, branch: branch, action: "member_complete", status: "failed", elapsed_seconds: elapsed || 0.0, status_code: 1, reason: result.reason)
+        result
       end
 
       def release_state_workdir(member)
@@ -626,11 +656,24 @@ module Kettle
         config.release_target_branches
       end
 
-      def member_local_branch_results(member)
+      def member_local_branch_results(member, event_handler: nil)
         member_config = member_local_release_config(member)
         return unless member_config
 
-        self.class.new(config: member_config, members: [member]).results
+        self.class.new(config: member_config, members: [member]).results(event_handler: event_handler)
+      end
+
+      def emit_event(event_handler, member:, branch:, action:, status:, **details)
+        return unless event_handler
+
+        event_handler.call({
+          "member" => member.name.to_s,
+          "branch" => branch,
+          "action" => action,
+          "status" => status
+        }.merge(details.each_with_object({}) { |(key, value), memo| memo[key.to_s] = value }))
+      rescue
+        nil
       end
 
       def member_local_release_config(member)

data/lib/kettle/family/release_state_event_tape.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module Kettle
+  module Family
+    class ReleaseStateEventTape
+      attr_reader :directory
+
+      def initialize(root:, stream: nil, clock: nil, wall_clock: nil)
+        @directory = File.join(root, "tmp", "kettle-family", "release-state-#{Time.now.strftime("%Y%m%d-%H%M%S")}-#{Process.pid}")
+        FileUtils.mkdir_p(@directory)
+        @stream = stream
+        @clock = clock || lambda { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        @wall_clock = wall_clock || lambda { Time.now.utc.iso8601 }
+        @started_at = @clock.call
+        @sequence_by_member = Hash.new(0)
+        @mutex = Mutex.new
+      end
+
+      def call(event)
+        payload = event.merge(
+          "event_version" => 1,
+          "type" => "release_state",
+          "timestamp" => @wall_clock.call,
+          "elapsed_seconds" => @clock.call - @started_at
+        )
+        member = payload.fetch("member", "family").to_s
+        @mutex.synchronize do
+          @sequence_by_member[member] += 1
+          payload["sequence"] = @sequence_by_member.fetch(member)
+          line = JSON.generate(payload)
+          File.open(path_for(member), "a") { |file| file.puts(line) }
+          @stream.puts(line) if @stream
+          @stream.flush if @stream&.respond_to?(:flush)
+        end
+        payload
+      rescue
+        nil
+      end
+
+      private
+
+      def path_for(member)
+        filename = member.gsub(/[^A-Za-z0-9_.-]+/, "_")
+        File.join(@directory, "#{filename}.ndjson")
+      end
+    end
+  end
+end

data/lib/kettle/family/report.rb

@@ -30,9 +30,9 @@ module Kettle
         up
       ].freeze
 
-      attr_reader :family_name, :family_mode, :order_mode, :members, :selected_members, :config_path, :command, :results, :branch_lanes, :release_target_branches, :member_release_target_branches, :release_mode, :warnings
+      attr_reader :family_name, :family_mode, :order_mode, :members, :selected_members, :config_path, :command, :results, :branch_lanes, :release_target_branches, :member_release_target_branches, :release_mode, :warnings, :event_log_dirs
 
-      def initialize(family_name:, order_mode:, members:, selected_members:, config_path:, family_mode: nil, branch_lanes: {}, release_target_branches: [], member_release_target_branches: {}, release_mode: nil, command: nil, results: [], warnings: [], elapsed_seconds: nil)
+      def initialize(family_name:, order_mode:, members:, selected_members:, config_path:, family_mode: nil, branch_lanes: {}, release_target_branches: [], member_release_target_branches: {}, release_mode: nil, command: nil, results: [], warnings: [], event_log_dirs: [], elapsed_seconds: nil)
         @family_name = family_name
         @family_mode = family_mode
         @order_mode = order_mode
@@ -46,6 +46,7 @@ module Kettle
         @member_release_target_branches = member_release_target_branches
         @release_mode = release_mode
         @warnings = warnings
+        @event_log_dirs = event_log_dirs
         @elapsed_seconds = elapsed_seconds
       end
 
@@ -62,6 +63,7 @@ module Kettle
           "member_release_target_branches" => member_release_target_branches,
           "release_mode" => release_mode,
           "warnings" => warnings,
+          "event_log_dirs" => event_log_dirs,
           "command" => command,
           "results" => results.map(&:to_h),
           "summary" => summary,
@@ -135,6 +137,7 @@ module Kettle
         lines << "summary:"
         lines << "  outcome: #{data.fetch("outcome")}"
         lines << "  elapsed: #{format_elapsed(data.fetch("elapsed_seconds"))}"
+        lines << "  events: #{event_log_dirs.join(", ")}" unless event_log_dirs.empty?
         lines << "  logs: #{data.fetch("release_log_dirs").join(", ")}" unless data.fetch("release_log_dirs").empty?
         lines << "  selected: #{data.fetch("selected_count")}"
         lines << "  results: #{data.fetch("result_count")}"

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

data/lib/kettle/family/workflow.rb

@@ -238,21 +238,78 @@ module Kettle
             phase: "template_autostash_restore",
             command: ["git", "stash", "pop", stash.fetch(:ref)]
           )
-          next restore if restore.ok? || !template_generated_lockfile_only_conflict?(stash.fetch(:member))
+          next restore if restore.ok?
+
+          if template_generated_lockfile_restore_refusal?(stash.fetch(:member), restore)
+            next runner.call(
+              member: stash.fetch(:member),
+              phase: "template_autostash_generated_lockfile_recovery",
+              command: template_generated_lockfile_restore_command(stash)
+            )
+          end
+
+          next restore if !template_generated_lockfile_only_conflict?(stash.fetch(:member))
 
           runner.call(
             member: stash.fetch(:member),
             phase: "template_autostash_generated_lockfile_recovery",
             command: [
               "sh", "-lc",
-              "paths=$(git diff --name-only --diff-filter=U); " \
-                "git checkout --ours -- $paths && git add -- $paths && " \
+              "set -eu; cd \"$(git rev-parse --show-toplevel)\"; " \
+                "paths=$(git diff --name-only --diff-filter=U); " \
+                "for path in $paths; do " \
+                "case \"$path\" in " \
+                "Gemfile.lock|*/Gemfile.lock|Appraisal.root.gemfile.lock|*/Appraisal.root.gemfile.lock|.structuredmerge/kettle-jem.lock|*/.structuredmerge/kettle-jem.lock) " \
+                "git restore --ours -- \"$path\"; git add -- \"$path\" ;; " \
+                "*) printf 'unresolved non-generated conflict: %s\\n' \"$path\" >&2; exit 1 ;; " \
+                "esac; " \
+                "done; " \
+                "test -z \"$(git diff --name-only --diff-filter=U)\"; " \
                 "git stash drop #{Shellwords.escape(stash.fetch(:ref))}"
             ]
           )
         end
       end
 
+      def template_generated_lockfile_restore_refusal?(member, restore)
+        output = [restore.stdout, restore.stderr].compact.join("\n")
+        return false unless output.include?("would be overwritten by merge")
+
+        dirty_paths = GitStatus.dirty_paths(member.root)
+        dirty_paths.any? && dirty_paths.all? { |path| template_generated_lockfile_path?(path) }
+      end
+
+      def template_generated_lockfile_restore_command(stash)
+        member = stash.fetch(:member)
+        generated_paths = GitStatus.dirty_paths(member.root).filter_map do |status_line|
+          path = status_line.to_s.sub(/\A.../, "").strip
+          path if template_generated_lockfile_path?(status_line)
+        end.uniq
+        reset_commands = generated_paths.map do |path|
+          escaped_path = Shellwords.escape(path)
+          "if git ls-files --error-unmatch #{escaped_path} >/dev/null 2>&1; then " \
+            "git restore --source=HEAD --staged --worktree -- #{escaped_path}; " \
+            "else rm -f -- #{escaped_path}; fi"
+        end
+
+        [
+          "sh",
+          "-lc",
+          "set -eu; cd \"$(git rev-parse --show-toplevel)\"; " \
+            "#{reset_commands.join("; ")}; git stash pop #{Shellwords.escape(stash.fetch(:ref))}"
+        ]
+      end
+
+      def template_generated_lockfile_path?(status_line)
+        path = status_line.to_s.sub(/\A.../, "").strip
+        [
+          "Gemfile.lock",
+          "Appraisal.root.gemfile.lock",
+          ".structuredmerge/kettle-jem.lock"
+        ].include?(path) ||
+          path.end_with?("/Gemfile.lock", "/Appraisal.root.gemfile.lock", "/.structuredmerge/kettle-jem.lock")
+      end
+
       def rollback_failed_template_worktrees(stashes, workflow_results, runner:)
         failed_members = workflow_results.reject(&:ok?).map(&:member_name).compact.uniq
         stashes.filter_map do |stash|
@@ -276,7 +333,7 @@ module Kettle
       def template_generated_lockfile_only_conflict?(member)
         stdout, _stderr, status = Open3.capture3("git", "diff", "--name-only", "--diff-filter=U", chdir: member.root)
         conflicts = stdout.lines.map(&:strip).reject(&:empty?).sort
-        status.success? && !conflicts.empty? && conflicts.all? { |path| ["Gemfile.lock", ".structuredmerge/kettle-jem.lock"].include?(path) }
+        status.success? && !conflicts.empty? && conflicts.all? { |path| template_generated_lockfile_path?(" M #{path}") }
       end
 
       def template_branch_sync_results(branch_members, runner:)
@@ -561,12 +618,12 @@ module Kettle
       def template_bootstrap_dependency_env(member)
         env = release_lockfile_local_path_env_overrides(member).merge(workflow_env)
         env.each_key do |key|
-          env[key] = "false" if key.end_with?("_DEV") && !env_overrides.key?(key)
+          env[key] = "false" if key.end_with?("_DEV") && !local_path_env_requested?(key)
         end
         env["K_JEM_TEMPLATING"] = "false"
         env["BUNDLE_DISABLE_CHECKSUM_VALIDATION"] = "true"
         family_env_name = config.family_local_path_env_name
-        env[family_env_name] = "false" if family_env_name && !env_overrides.key?(family_env_name)
+        env[family_env_name] = "false" if family_env_name && !local_path_env_requested?(family_env_name)
         env
       end
 
@@ -632,6 +689,7 @@ module Kettle
 
           branch_members = rediscovered_selected_members(selected_names)
           branch_members = members if branch_members.empty?
+          dirty_paths_before = branch_generated_lockfile_dirt(branch_members)
           if command == "template" && execute
             memo.concat(template_branch_sync_results(branch_members, runner: runner))
             break memo unless memo.last&.ok?
@@ -639,6 +697,16 @@ module Kettle
           branch_results = current_branch_results(branch_members)
           tag_branch_results(branch_results, branch)
           memo.concat(branch_results)
+
+          if branch_generated_lockfile_cleanup_required?
+            cleanup_branch_generated_lockfiles(
+              branch_members: branch_members,
+              dirty_paths_before: dirty_paths_before,
+              runner: runner,
+              memo: memo,
+              branch: branch
+            )
+          end
           break memo unless memo.last&.ok?
 
           commit_normalized_lockfiles(branch_members: branch_members, runner: runner, memo: memo)
@@ -661,6 +729,57 @@ module Kettle
         end
       end
 
+      def branch_generated_lockfile_cleanup_required?
+        execute && %w[test lint].include?(command)
+      end
+
+      def branch_generated_lockfile_dirt(branch_members)
+        branch_members.each_with_object({}) do |member, memo|
+          root = git_root_for(member)
+          memo[root] ||= GitStatus.dirty_paths(root)
+        end
+      end
+
+      def cleanup_branch_generated_lockfiles(branch_members:, dirty_paths_before:, runner:, memo:, branch:)
+        processed_roots = []
+        branch_members.each do |member|
+          root = git_root_for(member)
+          next if processed_roots.include?(root)
+
+          processed_roots << root
+          before = dirty_paths_before.fetch(root, []).map { |path| normalized_dirty_path(path) }
+          generated_paths = GitStatus.dirty_paths(root).filter_map do |status_line|
+            path = normalized_dirty_path(status_line)
+            path unless before.include?(path) || !template_generated_lockfile_path?(status_line)
+          end.uniq
+          next if generated_paths.empty?
+
+          result = runner.call(
+            member: member,
+            phase: "branch_generated_lockfile_recovery",
+            command: branch_generated_lockfile_restore_command(generated_paths)
+          )
+          result.branch = branch if result.respond_to?(:branch=)
+          memo << result
+          break unless result.ok?
+        end
+      end
+
+      def normalized_dirty_path(status_line)
+        status_line.to_s.sub(/\A.../, "").strip
+      end
+
+      def branch_generated_lockfile_restore_command(paths)
+        reset_commands = paths.map do |path|
+          escaped_path = Shellwords.escape(path)
+          "if git ls-files --error-unmatch #{escaped_path} >/dev/null 2>&1; then " \
+            "git restore --source=HEAD --staged --worktree -- #{escaped_path}; " \
+            "else rm -f -- #{escaped_path}; fi"
+        end
+
+        ["sh", "-lc", "set -eu; #{reset_commands.join("; ")}"]
+      end
+
       def release_preflight_results
         phases = release_preflight_phases
         progress = start_release_preflight_progress(phases)
@@ -1082,15 +1201,10 @@ module Kettle
         return unless progress
 
         member = release_progress_member_for(member_name)
+        if progress_io && suppress_release_secret_provider_event?(event, progress: progress)
+          return
+        end
         if progress_io
-          if event["type"] == "secret_provider"
-            case event["action"].to_s
-            when "prompt_request", "manual_prompt"
-              progress.notification(secret_provider_notification_label(event))
-            when "prompt_response"
-              progress.notification("")
-            end
-          end
           if verbose || debug
             emit_release_event_progress(member, event)
           elsif progress.tty?
@@ -2113,7 +2227,9 @@ module Kettle
       def workflow_family_local_path_env
         return {} if implicit_single_member_template_root?
 
-        config.family_local_path_env
+        config.family_local_path_env.each_with_object({}) do |(name, default), env|
+          env[name] = ENV.key?(name) ? ENV.fetch(name) : default
+        end
       end
 
       def implicit_single_member_template_root?
@@ -2372,7 +2488,9 @@ module Kettle
           next false unless event
 
           if progress_io
-            if verbose || debug
+            if suppress_release_secret_provider_event?(event, progress: progress)
+              next true
+            elsif verbose || debug
               emit_release_event_progress(member, event)
             elsif progress&.tty?
               emit_release_event_status(member, event, progress: progress)
@@ -2382,6 +2500,26 @@ module Kettle
         end
       end
 
+      def suppress_release_secret_provider_event?(event, progress:)
+        return false unless event["type"] == "secret_provider"
+        return false unless progress
+
+        case event["action"].to_s
+        when "prompt_request", "manual_prompt"
+          progress.notification(secret_provider_notification_label(event))
+        when "prompt_response"
+          progress.notification("")
+        end
+
+        # Prompt and provider status are transient operator notifications, not
+        # tape events. Keeping them out of the member row prevents external
+        # prompt output from competing with the fixed-width event tape.
+        # A TTY always has a dedicated notification line. Prompt/provider
+        # events must never fall through to the member-row event tape, even
+        # when verbose or debug output is enabled.
+        progress.tty?
+      end
+
       def parse_template_event(line)
         payload = JSON.parse(line.to_s)
         (payload.is_a?(Hash) && payload["event_version"]) ? payload : nil
@@ -2822,7 +2960,16 @@ module Kettle
       end
 
       def template_lockfile_recovery_env(member)
-        release_lockfile_env(member).merge("K_JEM_TEMPLATING" => "false")
+        env = release_lockfile_env(member).merge(workflow_env)
+        ENV.each do |key, value|
+          env[key] = value if key.end_with?("_DEV", "_LOCAL") && local_path_env_requested?(key)
+        end
+        env.merge!(env_overrides)
+        env.merge!(
+          "K_JEM_TEMPLATING" => "false",
+          "BUNDLE_DISABLE_CHECKSUM_VALIDATION" => "true"
+        )
+        env
       end
 
       def normalize_lockfiles_command(member:, phase:, skip_checksum_option: false)
@@ -3027,10 +3174,14 @@ module Kettle
       def template_prepare_env
         env = workflow_env
         family_env_name = config.family_local_path_env_name
-        env[family_env_name] = "false" if family_env_name && !env_overrides.key?(family_env_name)
+        env[family_env_name] = "false" if family_env_name && !local_path_env_requested?(family_env_name)
         env
       end
 
+      def local_path_env_requested?(name)
+        env_overrides.key?(name) || ENV.key?(name)
+      end
+
       def template_thread_worker_budget
         member_jobs = template_jobs(members)
         [1, (Etc.nprocessors / member_jobs) - 1].max

data/lib/kettle/family/workflow_progress.rb

@@ -36,7 +36,8 @@ module Kettle
         @mutex = Mutex.new
         @tty = @enabled && io.respond_to?(:tty?) && io.tty?
         @tty_rendered = false
-        @tty_rows = 0
+        @tty_block_rows = 0
+        @tty_tape_rows = 0
       end
 
       def start
@@ -122,6 +123,21 @@ module Kettle
         end
       end
 
+      # Finish a TTY progress block before the caller prints a second report.
+      # The blank line keeps the final report physically separate from the
+      # redraw block instead of making the terminal cursor its first row.
+      def finish
+        return unless @enabled
+
+        synchronize do
+          next if @stopped
+
+          render_tty_block if @tty && @started && !@line_order.empty?
+          write_line("") if @tty && @started
+          @stopped = true
+        end
+      end
+
       def tty?
         @tty
       end
@@ -174,15 +190,31 @@ module Kettle
         return if rows.empty?
 
         output = +""
-        output << "\e[#{@tty_rows}A" if @tty_rendered && @tty_rows.positive?
-        output << "\e[1G\e[2K#{truncate_display(@notification, terminal_width)}\n"
-        rows.each do |line|
-          output << "\e[1G\e[2K#{line}\n"
+        if @tty_rendered && @tty_block_rows.positive?
+          # Restore the bottom-of-block cursor before moving to the first row.
+          # This keeps unrelated prompt output from changing the redraw anchor.
+          output << "\e[u\e[#{@tty_block_rows}A"
         end
+        # The notification line is deliberately separate from the event tape.
+        # It is transient operator guidance, not a member row or an event.
+        output << render_tty_notification_line
+        output << render_tty_tape_rows(rows)
+        # LF moves down without necessarily returning to column 1. Reset the
+        # anchor explicitly so external prompt output starts on a fresh line.
+        output << "\e[1G\e[s"
         @io.write(output)
         @io.flush if @io.respond_to?(:flush)
         @tty_rendered = true
-        @tty_rows = rows.length + 1
+        @tty_tape_rows = rows.length
+        @tty_block_rows = @tty_tape_rows + 1
+      end
+
+      def render_tty_notification_line
+        "\e[1G\e[2K#{truncate_display(@notification, render_width)}\n"
+      end
+
+      def render_tty_tape_rows(rows)
+        rows.map { |line| "\e[1G\e[2K#{line}\n" }.join
       end
 
       def tty_line(member_name)
@@ -278,7 +310,15 @@ module Kettle
       end
 
       def status_width
-        [terminal_width - MEMBER_WIDTH - 1 - PROGRESS_WIDTH - 1 - ELAPSED_WIDTH - 1 - EVENT_WIDTH - 1, MIN_STATUS_WIDTH].max
+        available = [render_width - MEMBER_WIDTH - 1 - PROGRESS_WIDTH - 1 - ELAPSED_WIDTH - 1 - EVENT_WIDTH - 1, 1].max
+        [available, MIN_STATUS_WIDTH].max.clamp(1, available)
+      end
+
+      def render_width
+        # Leave the last terminal column unused. Writing into it can trigger
+        # an automatic wrap before the explicit newline, which invalidates the
+        # fixed physical-row cursor accounting used by the redrawer.
+        [terminal_width - 1, 1].max
       end
 
       def terminal_width

data/lib/kettle/family.rb

@@ -11,6 +11,7 @@ require_relative "family/branch_lane_audit"
 require_relative "family/config"
 require_relative "family/secrets"
 require_relative "family/branch_target_config"
+require_relative "family/release_state_event_tape"
 require_relative "family/release_state_check"
 require_relative "family/release_reconciler"
 require_relative "family/unreleased_gem_cleanup"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-family
 version: !ruby/object:Gem::Version
-  version: 1.2.29
+  version: 1.2.30
 platform: ruby
 authors:
 - Peter H. Boling
@@ -342,6 +342,7 @@ files:
 - lib/kettle/family/readiness_check.rb
 - lib/kettle/family/release_reconciler.rb
 - lib/kettle/family/release_state_check.rb
+- lib/kettle/family/release_state_event_tape.rb
 - lib/kettle/family/release_state_result.rb
 - lib/kettle/family/release_waves.rb
 - lib/kettle/family/report.rb
@@ -359,10 +360,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.29
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.29/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.2.30
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.30/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.29
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.30
   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