kettle-dev 2.5.12 → 2.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60069f78cc45c33bf7d2616ea76c456e98cf9885da75331a553f5c9e2b96bbe8
-  data.tar.gz: d58499d2f31cbffc408e15af977b93b3254f310d021822d90726c7407f4436c3
+  metadata.gz: 76cf339458385418bcf752559dbb9c6278f3b95ebfa27b26781591564179f263
+  data.tar.gz: 66cae3bfb62ecd922bf2b6ecc16049389a860a20dbaa8492fd6578bdcf3b4922
 SHA512:
-  metadata.gz: b34e918fa0cce724b098ab97e46abd768a65938d52f908f87515a5f64b8c3c8d68e6717c05529045da5ce1670e407fa1fa955cfb3c9c2cbd6a4c72d46b64577b
-  data.tar.gz: d9dcb4194c6f22c6f6ba1b3311b8f7e644766b52bb36f80d4f59130e48f32d2d4917541c3aebf25e253adb4e3914485b9d66b7f77ebf64b73e56804686dc4276
+  metadata.gz: 0ae8aa5d0113e226dab9dbb332b42328bfe738c84ce88a21d919c3a0249d2ad3f70d905aa4cbd76c903608846da8a485a6e68c710934e7eac2443517d71d6a96
+  data.tar.gz: 4470d0bd47c7c95a616b8513a6b590911a4086e6d6f31330e96c45059774ac4d172a0c98ccf5aad53384208cf40fb02de237c68c6326a430acaf89adfe9a89c2

data/CHANGELOG.md

@@ -30,6 +30,48 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [2.5.13] - 2026-07-31
+
+- TAG: [v2.5.13][2.5.13t]
+- COVERAGE: 91.81% -- 5137/5595 lines in 46 files
+- BRANCH COVERAGE: 76.06% -- 1944/2556 branches in 46 files
+- 50.41% documented
+
+### Fixed
+
+- `kettle-release` now treats `origin` as the default required parity remote
+  while allowing optional mirror remotes to be skipped after fetch retries,
+  so a transient Codeberg/GitLab mirror outage does not block publishing.
+
+### Added
+
+- `kettle-release --events` now emits `remote_parity` events for remote parity
+  fetch attempts, skipped optional remotes, required failures, and parity
+  completion.
+- `kettle-release --events` now emits `ci_monitor` events around CI monitoring
+  start, per-workflow GitHub Actions progress, GitLab pipeline outcomes,
+  success, and failure.
+- `kettle-release --events` now emits `pre_release` events around
+  `kettle-pre-release` checks and selected check summaries.
+- `kettle-changelog --events` now emits `changelog` events around release plan,
+  coverage generation, and changelog update activity, and `kettle-release
+  --events` forwards those child events.
+- `kettle-release --events` now emits `release_lockfile` and `release_probe`
+  events for release lockfile reset/validation and published-gem availability
+  probes.
+- `kettle-dev` now requires `kettle-ndjson` 0.1.9 or newer so release event
+  streams resolve against the protocol that includes remote parity and CI
+  monitor, pre-release, changelog, release lockfile, and release probe events.
+
+- `kettle-release --events` now emits GitHub CI wait/start/tick monitor events
+  while waiting for workflow runs to appear and complete.
+
+### Changed
+
+- `kettle-release --events` now emits clearer `command_step` names and compact
+  per-command summaries for common release commands instead of shell-derived
+  labels such as `env__u`.
+
 ## [2.5.12] - 2026-07-31
 
 - TAG: [v2.5.12][2.5.12t]
@@ -3118,7 +3160,9 @@ Please file a bug if you notice a violation of semantic versioning.
   - Selecting will run the selected workflow via `act`
   - This may move to its own gem in the future.
 
-[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.12...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.13...HEAD
+[2.5.13]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.12...v2.5.13
+[2.5.13t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.5.13
 [2.5.12]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.11...v2.5.12
 [2.5.12t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.5.12
 [2.5.11]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.10...v2.5.11

data/README.md

@@ -1005,7 +1005,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.408-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-5.595-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/kettle-dev/kettle-dev/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/exe/kettle-changelog

@@ -50,9 +50,11 @@ begin
 
   # This library
   require "kettle/dev"
+  require "kettle/ndjson"
   require "kettle/dev/executable_version"
   Kettle::Dev::ExecutableVersion.print_and_exit!(script_basename, ARGV, value_option: true)
-  Kettle::Dev::ExecutableVersion.print_header(script_basename) unless ARGV.include?("--json")
+  machine_output = ARGV.any? { |arg| arg == "--json" || arg.start_with?("--events") }
+  Kettle::Dev::ExecutableVersion.print_header(script_basename) unless machine_output
 rescue LoadError => e
   warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
   warn("Hint: Ensure the host project has kettle-dev as a dependency and run bundle install.")
@@ -61,7 +63,7 @@ end
 
 if ARGV.include?("-h") || ARGV.include?("--help")
   puts <<~USAGE
-    Usage: kettle-changelog [--version VERSION] [--yes] [--update-prep] [--pending-release] [--release-state] [--refresh-cache] [--add-unreleased-entry --section SECTION --entry TEXT] [--json] [--no-strict] [--no-coverage-threshold]
+    Usage: kettle-changelog [--version VERSION] [--yes] [--update-prep] [--pending-release] [--release-state] [--refresh-cache] [--add-unreleased-entry --section SECTION --entry TEXT] [--json|--events[=TYPES]] [--no-strict] [--no-coverage-threshold]
 
     Detects the current version from lib/**/version.rb, the latest live release, and
     the most recent CHANGELOG.md release section, then prompts to confirm the selected plan:
@@ -82,6 +84,7 @@ if ARGV.include?("-h") || ARGV.include?("--help")
       --section SECTION         Unreleased section to receive the entry (Added, Changed, Deprecated, Removed, Fixed, Security)
       --entry TEXT              Changelog entry text; "- " is added when omitted
       --json                    Print query output as JSON
+      --events[=TYPES]          Print newline-delimited JSON changelog events
       --no-strict               Allow missing coverage and yard data (warnings only, no errors)
       --no-coverage-threshold   Generate coverage without hard-failing below configured thresholds
 
@@ -137,6 +140,22 @@ begin
     Kettle::Dev::Versioning.normalize_explicit_version(version)
   end
 
+  def extract_events_arg!(argv)
+    events = false
+    event_types = nil
+    argv.delete_if do |arg|
+      if arg == "--events"
+        events = true
+      elsif arg.start_with?("--events=")
+        events = true
+        event_types = arg.split("=", 2)[1]
+      else
+        false
+      end
+    end
+    [events, event_types]
+  end
+
   # Determine if strict mode is enabled (default: true)
   strict_mode = !ARGV.include?("--no-strict") && ENV.fetch("K_CHANGELOG_STRICT", "true").downcase != "false"
   update_prep = ARGV.delete("--update-prep")
@@ -146,6 +165,8 @@ begin
   refresh_cache = ARGV.delete("--refresh-cache")
   add_unreleased_entry = ARGV.delete("--add-unreleased-entry") || ARGV.delete("--add-changelog-entry")
   json_output = ARGV.delete("--json")
+  events_output, event_types = extract_events_arg!(ARGV)
+  Kettle::Dev::ExitAdapter.abort("--events cannot be combined with --json") if events_output && json_output
   coverage_threshold_disabled = ARGV.include?("--no-coverage-threshold") || ARGV.include?("--no-coverage-thresholds")
   coverage_hard = !coverage_threshold_disabled && ENV.fetch("K_CHANGELOG_COVERAGE_HARD", "true").downcase != "false"
   version_override = extract_version_arg!(ARGV)
@@ -180,7 +201,8 @@ begin
     exit(0)
   end
 
-  cli = Kettle::Dev::ChangelogCLI.new(strict: strict_mode, enforce_coverage_thresholds: coverage_hard, update_prep: update_prep, version: version_override, refresh_cache: refresh_cache, yes: yes)
+  event_stream = events_output ? Kettle::Ndjson.event_stream($stdout, types: event_types) : nil
+  cli = Kettle::Dev::ChangelogCLI.new(strict: strict_mode, enforce_coverage_thresholds: coverage_hard, update_prep: update_prep, version: version_override, refresh_cache: refresh_cache, yes: yes, event_stream: event_stream)
   if release_state_query
     state = cli.release_state
     puts(json_output ? JSON.pretty_generate(state) : cli.release_state_table(state))

data/exe/kettle-release

@@ -49,7 +49,7 @@ end
 # Do not guard with __FILE__ == $PROGRAM_NAME because binstubs use Kernel.load.
 if ARGV.include?("-h") || ARGV.include?("--help")
   puts <<~USAGE
-    Usage: kettle-release [--version VERSION] [--local-ci] [--yes] [--appraisal-update] [--skip-bundle-audit] [--skip-steps STEPS] [--ci-workflows WORKFLOWS] [--skip-remotes REMOTES] [--secrets-provider NAME] [--json|--events[=TYPES]] [--report PATH] [start_step=<0-19>]
+    Usage: kettle-release [--version VERSION] [--local-ci] [--yes] [--appraisal-update] [--skip-bundle-audit] [--skip-steps STEPS] [--ci-workflows WORKFLOWS] [--skip-remotes REMOTES] [--required-remotes REMOTES] [--secrets-provider NAME] [--json|--events[=TYPES]] [--report PATH] [start_step=<0-19>]
 
     Automates the release flow for a Ruby gem in the host project.
 
@@ -90,6 +90,7 @@ if ARGV.include?("-h") || ARGV.include?("--help")
       --skip-bundle-audit         # Skip bundle:audit/update during release rake checks
       --ci-workflows WORKFLOWS    # Comma-separated workflow files or stems to monitor at CI step 10
       --skip-remotes REMOTES      # Comma-separated git remote names to exclude from release fetch/push parity
+      --required-remotes REMOTES  # Comma-separated remote names that must fetch for release parity; defaults to origin
       --secrets-provider NAME     # Release secrets provider: interactive, 1password
       --json                      # Print final machine-readable release report as JSON
       --events[=TYPES]            # Print newline-delimited JSON release events, optionally filtered by type
@@ -104,6 +105,7 @@ if ARGV.include?("-h") || ARGV.include?("--help")
       K_RELEASE_LOCAL_CI_WORKFLOW # Name of workflow (without .yml) for local CI; defaults to locked_deps or first
       K_RELEASE_CI_WORKFLOWS      # Comma-separated workflow files or stems to monitor at CI step 10
       K_RELEASE_SKIP_REMOTES      # Comma-separated git remote names to exclude from release fetch/push parity
+      K_RELEASE_REQUIRED_REMOTES  # Comma-separated remotes that must fetch for release parity; defaults to origin
       KETTLE_RELEASE_SECRETS_PROVIDER=1password
                                   # Load release secrets through the configured provider
       KETTLE_RELEASE_1PASSWORD_ITEM=Rubygems
@@ -215,6 +217,27 @@ def extract_skip_remotes_arg!(argv)
   remotes
 end
 
+def extract_required_remotes_arg!(argv)
+  remotes = nil
+  if (idx = argv.index("--required-remotes"))
+    remotes = argv[idx + 1]
+    if remotes.to_s.empty? || remotes.to_s.start_with?("-")
+      Kettle::Dev::ExitAdapter.abort("--required-remotes requires a comma-separated remote list")
+    end
+    argv.slice!(idx, 2)
+  end
+  argv.delete_if do |arg|
+    if arg.start_with?("--required-remotes=", "required_remotes=")
+      remotes = arg.split("=", 2)[1]
+      Kettle::Dev::ExitAdapter.abort("--required-remotes requires a comma-separated remote list") if remotes.to_s.empty?
+      true
+    else
+      false
+    end
+  end
+  remotes
+end
+
 def extract_report_arg!(argv)
   report_path = nil
   if (idx = argv.index("--report"))
@@ -286,12 +309,13 @@ version_override = extract_version_arg!(ARGV)
 skip_steps = extract_skip_steps_arg!(ARGV)
 ci_workflows = extract_ci_workflows_arg!(ARGV)
 skip_remotes = extract_skip_remotes_arg!(ARGV)
+required_remotes = extract_required_remotes_arg!(ARGV)
 report_path = extract_report_arg!(ARGV)
 secrets_provider = extract_secrets_provider_arg!(ARGV)
 
 begin
   event_stream = events_output ? Kettle::Ndjson.event_stream($stdout, types: event_types) : nil
-  Kettle::Dev::ReleaseCLI.new(start_step: start_step, local_ci: local_ci, version: version_override, appraisal_task: appraisal_task, skip_steps: skip_steps, skip_bundle_audit: skip_bundle_audit, ci_workflows: ci_workflows, skip_remotes: skip_remotes, secrets_provider_name: secrets_provider, yes: yes, event_stream: event_stream, json_output: json_output, json_io: $stdout, report_path: report_path).run
+  Kettle::Dev::ReleaseCLI.new(start_step: start_step, local_ci: local_ci, version: version_override, appraisal_task: appraisal_task, skip_steps: skip_steps, skip_bundle_audit: skip_bundle_audit, ci_workflows: ci_workflows, skip_remotes: skip_remotes, required_remotes: required_remotes, secrets_provider_name: secrets_provider, yes: yes, event_stream: event_stream, json_output: json_output, json_io: $stdout, report_path: report_path).run
 rescue LoadError => e
   warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
   warn(Array(e.backtrace).join("\n")) if ENV["DEBUG"]

data/lib/kettle/dev/changelog_cli.rb

@@ -5,6 +5,7 @@ require "json"
 require "net/http"
 require "uri"
 require "fileutils"
+require "kettle/ndjson"
 
 module Kettle
   module Dev
@@ -28,7 +29,7 @@ module Kettle
       # @param update_prep [Boolean] when true, update the most recent prepared release section in place
       # @param version [String, nil] explicit version override for gems without a literal VERSION constant
       # @param yes [Boolean] when true, approve the selected release plan without prompting
-      def initialize(strict: true, enforce_coverage_thresholds: true, update_prep: false, version: nil, root: Kettle::Dev::CIHelpers.project_root, refresh_cache: false, yes: false)
+      def initialize(strict: true, enforce_coverage_thresholds: true, update_prep: false, version: nil, root: Kettle::Dev::CIHelpers.project_root, refresh_cache: false, yes: false, event_stream: nil)
         @root = root
         @changelog_path = resolved_changelog_path
         @coverage_root = resolved_coverage_root
@@ -39,6 +40,7 @@ module Kettle
         @version_override = Kettle::Dev::Versioning.normalize_explicit_version(version)
         @refresh_cache = refresh_cache
         @yes = !!yes
+        @event_recorder = Kettle::Ndjson.event_recorder(event_stream, phase_timings: [])
       end
 
       # Main entry point to update CHANGELOG.md
@@ -70,6 +72,7 @@ module Kettle
 
         if plan.fetch(:action) == :update_prepared_release
           update_prepared_release!(changelog, today, owner, repo, line_cov_line, branch_cov_line, yard_line)
+          emit_changelog_event(action: "update", status: "ok", version: version, plan: plan.fetch(:action).to_s)
           return
         end
 
@@ -140,6 +143,7 @@ module Kettle
         updated = updated.rstrip + "\n"
 
         File.write(@changelog_path, updated)
+        emit_changelog_event(action: "update", status: "ok", version: version, plan: plan.fetch(:action).to_s)
         puts "CHANGELOG.md updated with v#{version} section."
       end
 
@@ -348,6 +352,16 @@ module Kettle
         puts "  latest released for current series: #{plan.fetch(:latest_for_series) || "unknown"}"
         puts "  latest CHANGELOG.md release: #{plan.fetch(:latest_changelog_version) || "none"}"
         puts "  gem: #{plan.fetch(:gem_name) || "unknown"}"
+        emit_changelog_event(
+          action: "plan",
+          status: "ok",
+          plan: plan.fetch(:action).to_s,
+          version: plan.fetch(:version),
+          gem_name: plan.fetch(:gem_name),
+          latest_overall: plan.fetch(:latest_overall),
+          latest_for_series: plan.fetch(:latest_for_series),
+          latest_changelog_version: plan.fetch(:latest_changelog_version)
+        )
         if @yes
           puts("Continue with this plan? [y/N]: y")
           return
@@ -665,20 +679,25 @@ module Kettle
           coverage_dir = File.dirname(@coverage_path)
           if Dir.exist?(coverage_dir)
             puts "Cleaning old coverage data from #{Kettle::Dev.display_path(coverage_dir)}..."
+            emit_changelog_event(action: "coverage_clean", status: "started", path: Kettle::Dev.display_path(coverage_dir))
             Dir.glob(File.join(coverage_dir, "*")).each do |file|
               File.delete(file) if File.file?(file)
             end
+            emit_changelog_event(action: "coverage_clean", status: "ok", path: Kettle::Dev.display_path(coverage_dir))
           end
 
           puts "Generating fresh coverage data by running: bundle exec kettle-test"
+          emit_changelog_event(action: "coverage", status: "started", command: "bundle exec kettle-test", root: Kettle::Dev.display_path(@coverage_root))
 
           success = system(changelog_coverage_env, "bundle", "exec", "kettle-test", chdir: @coverage_root)
 
           unless success
+            emit_changelog_event(action: "coverage", status: "failed", command: "bundle exec kettle-test", root: Kettle::Dev.display_path(@coverage_root), reason: "exit status #{$?.exitstatus || "unknown"}")
             raise "bundle exec kettle-test failed with exit status #{$?.exitstatus || "unknown"}"
           end
 
           puts "Coverage generation complete."
+          emit_changelog_event(action: "coverage", status: "ok", command: "bundle exec kettle-test", root: Kettle::Dev.display_path(@coverage_root))
 
           ensure_changelog_coverage_json!
         else
@@ -739,6 +758,29 @@ module Kettle
         end
       end
 
+      def emit_changelog_event(action:, status:, **payload)
+        mark = case status.to_s
+        when "started"
+          ">"
+        when "ok", "skipped"
+          "."
+        when "failed"
+          "!"
+        else
+          "?"
+        end
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "changelog",
+          payload.merge(
+            action: action,
+            phase: "release",
+            status: status,
+            mark: mark
+          )
+        )
+      end
+
       def changelog_coverage_env
         env = BundlerEnvGuard.unbundled_env.merge(
           "PATH" => ENV.fetch("PATH", ""),

data/lib/kettle/dev/ci_monitor.rb

@@ -4,6 +4,7 @@
 require "uri"
 require "json"
 require "net/http"
+require "kettle/ndjson"
 
 module Kettle
   module Dev
@@ -47,10 +48,10 @@ module Kettle
       #
       # @param restart_hint [String] guidance command shown on failure
       # @return [void]
-      def monitor_all!(restart_hint: "bundle exec kettle-release start_step=10", workflows: nil, keepalive: nil, **options)
+      def monitor_all!(restart_hint: "bundle exec kettle-release start_step=10", workflows: nil, keepalive: nil, event_recorder: nil, **options)
         checks_any = false
-        checks_any |= monitor_github_internal!(restart_hint: restart_hint, workflows: workflows, keepalive: keepalive)
-        checks_any |= monitor_gitlab_internal!(restart_hint: restart_hint, keepalive: keepalive)
+        checks_any |= monitor_github_internal!(restart_hint: restart_hint, workflows: workflows, keepalive: keepalive, event_recorder: event_recorder)
+        checks_any |= monitor_gitlab_internal!(restart_hint: restart_hint, keepalive: keepalive, event_recorder: event_recorder)
         abort("CI configuration not detected (GitHub or GitLab). Ensure CI is configured and remotes point to the correct hosts.") unless checks_any
       end
 
@@ -267,7 +268,7 @@ module Kettle
       end
       module_function :collect_gitlab
 
-      def monitor_github_internal!(restart_hint:, workflows: nil, keepalive: nil)
+      def monitor_github_internal!(restart_hint:, workflows: nil, keepalive: nil, event_recorder: nil)
         root = Kettle::Dev::CIHelpers.project_root
         workflows = Array(workflows).empty? ? Kettle::Dev::CIHelpers.workflows_list(root) : Array(workflows)
         gh_remote = preferred_github_remote
@@ -288,8 +289,31 @@ module Kettle
 
         passed = {}
         started = {}
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_discover",
+          status: "started",
+          provider: "github",
+          remote: gh_remote,
+          owner: owner,
+          repo: repo,
+          branch: branch,
+          head_sha: head_sha,
+          workflows: workflows,
+          total: total
+        )
         puts "Ensuring GitHub Actions workflows pass on #{branch} (#{owner}/#{repo}) via remote '#{gh_remote}'"
         puts "Waiting for GitHub Actions runs to start for HEAD #{head_sha[0, 12]}."
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_wait",
+          status: "started",
+          provider: "github",
+          branch: branch,
+          head_sha: head_sha,
+          completed: 0,
+          total: total
+        )
         pbar = if defined?(ProgressBar)
           ProgressBar.create(title: "CI", total: total, format: "%t %b %c/%C", length: 30)
         end
@@ -308,27 +332,105 @@ module Kettle
         start_deadline = monotonic_time + start_timeout
         keepalive_timer = keepalive_timer(keepalive)
         idx = 0
+        all_started_emitted = false
         loop do
           keepalive_timer.call
           wf = workflows[idx]
           run = Kettle::Dev::CIHelpers.latest_run(owner: owner, repo: repo, workflow_file: wf, branch: branch, require_head: true, head_sha: head_sha)
+          completed_workflow = nil
           if run
-            started[wf] = true
+            unless started[wf]
+              started[wf] = true
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "github_workflow",
+                status: "started",
+                provider: "github",
+                workflow: wf,
+                url: run["html_url"],
+                run_status: run["status"],
+                conclusion: run["conclusion"],
+                completed: passed.size,
+                total: total
+              )
+            end
+            if started.size == total && !all_started_emitted
+              all_started_emitted = true
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "github_started",
+                status: "ok",
+                provider: "github",
+                completed: passed.size,
+                total: total,
+                started: started.size
+              )
+            end
             if Kettle::Dev::CIHelpers.success?(run)
               unless passed[wf]
                 passed[wf] = true
+                completed_workflow = wf
                 pbar&.increment
+                emit_ci_monitor_event(
+                  event_recorder,
+                  action: "github_workflow",
+                  status: "ok",
+                  provider: "github",
+                  workflow: wf,
+                  url: run["html_url"],
+                  run_status: run["status"],
+                  conclusion: run["conclusion"],
+                  completed: passed.size,
+                  total: total
+                )
               end
             elsif Kettle::Dev::CIHelpers.failed?(run)
               puts
               wf_url = run["html_url"] || "https://github.com/#{owner}/#{repo}/actions/workflows/#{wf}"
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "github_workflow",
+                status: "failed",
+                provider: "github",
+                workflow: wf,
+                url: wf_url,
+                run_status: run["status"],
+                conclusion: run["conclusion"],
+                completed: passed.size,
+                total: total,
+                reason: "Workflow failed"
+              )
               abort("Workflow failed: #{wf} -> #{wf_url} Fix the workflow, then restart this tool from CI validation with: #{restart_hint}")
             end
           end
+          emit_ci_monitor_event(
+            event_recorder,
+            action: "github_tick",
+            status: "started",
+            provider: "github",
+            workflow: wf,
+            run_status: run && run["status"],
+            conclusion: run && run["conclusion"],
+            completed_workflow: completed_workflow,
+            completed: passed.size,
+            total: total,
+            started: started.size
+          )
           break if passed.size == total
           if started.size < total && monotonic_time >= start_deadline
             missing = (workflows - started.keys).join(", ")
             puts
+            emit_ci_monitor_event(
+              event_recorder,
+              action: "github_timeout",
+              status: "failed",
+              provider: "github",
+              missing: workflows - started.keys,
+              head_sha: head_sha,
+              total: total,
+              completed: passed.size,
+              reason: "Timed out waiting for workflows to start"
+            )
             abort("Timed out after #{start_timeout}s waiting for GitHub Actions workflows to start for HEAD #{head_sha[0, 12]}: #{missing}. Confirm GitHub Actions started, then restart this tool from CI validation with: #{restart_hint}")
           end
 
@@ -336,6 +438,15 @@ module Kettle
           sleep(poll_interval)
         end
         pbar&.finish unless pbar&.finished?
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_complete",
+          status: "ok",
+          provider: "github",
+          workflows: workflows,
+          completed: passed.size,
+          total: total
+        )
         puts "\nAll GitHub workflows passing (#{passed.size}/#{total})."
         true
       end
@@ -391,7 +502,7 @@ module Kettle
       end
       module_function :keepalive_interval
 
-      def monitor_gitlab_internal!(restart_hint:, keepalive: nil)
+      def monitor_gitlab_internal!(restart_hint:, keepalive: nil, event_recorder: nil)
         root = Kettle::Dev::CIHelpers.project_root
         gitlab_ci = File.exist?(File.join(root, ".gitlab-ci.yml"))
         gl_remote = gitlab_remote_candidates.first
@@ -403,6 +514,17 @@ module Kettle
         owner, repo = Kettle::Dev::CIHelpers.repo_info_gitlab
         return false unless owner && repo
 
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "gitlab_discover",
+          status: "started",
+          provider: "gitlab",
+          remote: gl_remote,
+          owner: owner,
+          repo: repo,
+          branch: branch,
+          total: 1
+        )
         puts "Ensuring GitLab pipeline passes on #{branch} (#{owner}/#{repo}) via remote '#{gl_remote}'"
         pbar = if defined?(ProgressBar)
           ProgressBar.create(title: "CI", total: 1, format: "%t %b %c/%C", length: 30)
@@ -412,8 +534,19 @@ module Kettle
           keepalive_timer.call
           pipe = Kettle::Dev::CIHelpers.gitlab_latest_pipeline(owner: owner, repo: repo, branch: branch)
           if pipe
+            pipe_url = pipe["web_url"] || "https://gitlab.com/#{owner}/#{repo}/-/pipelines"
             if Kettle::Dev::CIHelpers.gitlab_success?(pipe)
               pbar&.increment unless pbar&.finished?
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "gitlab_pipeline",
+                status: "ok",
+                provider: "gitlab",
+                url: pipe_url,
+                run_status: pipe["status"],
+                completed: 1,
+                total: 1
+              )
               break
             elsif Kettle::Dev::CIHelpers.gitlab_failed?(pipe)
               # Special-case: if failure is due to exhausted minutes/insufficient quota, treat as unknown and continue
@@ -421,27 +554,93 @@ module Kettle
               if /insufficient|quota|minute/i.match?(reason)
                 puts "\nGitLab reports pipeline cannot run due to quota/minutes exhaustion. Result is unknown; continuing."
                 pbar&.finish unless pbar&.finished?
+                emit_ci_monitor_event(
+                  event_recorder,
+                  action: "gitlab_pipeline",
+                  status: "skipped",
+                  provider: "gitlab",
+                  url: pipe_url,
+                  run_status: pipe["status"],
+                  reason: reason,
+                  completed: 0,
+                  total: 1
+                )
                 break
               else
                 puts
-                url = pipe["web_url"] || "https://gitlab.com/#{owner}/#{repo}/-/pipelines"
+                emit_ci_monitor_event(
+                  event_recorder,
+                  action: "gitlab_pipeline",
+                  status: "failed",
+                  provider: "gitlab",
+                  url: pipe_url,
+                  run_status: pipe["status"],
+                  reason: reason,
+                  completed: 0,
+                  total: 1
+                )
+                url = pipe_url
                 abort("Pipeline failed: #{url} Fix the pipeline, then restart this tool from CI validation with: #{restart_hint}")
               end
             elsif pipe["status"] == "blocked"
               # Blocked pipeline (e.g., awaiting approvals) — treat as unknown and continue
               puts "\nGitLab pipeline is blocked. Result is unknown; continuing."
               pbar&.finish unless pbar&.finished?
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "gitlab_pipeline",
+                status: "skipped",
+                provider: "gitlab",
+                url: pipe_url,
+                run_status: pipe["status"],
+                reason: "blocked",
+                completed: 0,
+                total: 1
+              )
               break
             end
           end
           sleep(1)
         end
         pbar&.finish unless pbar&.finished?
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "gitlab_complete",
+          status: "ok",
+          provider: "gitlab",
+          completed: 1,
+          total: 1
+        )
         puts "\nGitLab pipeline passing."
         true
       end
       module_function :monitor_gitlab_internal!
 
+      def emit_ci_monitor_event(event_recorder, action:, status:, provider:, **payload)
+        mark = case status.to_s
+        when "started"
+          ">"
+        when "ok", "skipped"
+          "."
+        when "failed"
+          "!"
+        else
+          "?"
+        end
+        Kettle::Ndjson.emit_event(
+          event_recorder,
+          "ci_monitor",
+          payload.merge(
+            action: action,
+            phase: "release",
+            provider: provider,
+            status: status,
+            mark: mark
+          )
+        )
+      end
+      module_function :emit_ci_monitor_event
+
       # -- tiny wrappers around GitAdapter-like helpers used by ReleaseCLI --
       def remotes_with_urls
         Kettle::Dev::GitAdapter.new.remotes_with_urls

data/lib/kettle/dev/pre_release_cli.rb

@@ -10,6 +10,7 @@ require "net/http"
 require "openssl"
 require "time"
 require_relative "cache_progress"
+require "kettle/ndjson"
 begin
   require "addressable/uri"
 rescue LoadError
@@ -271,9 +272,10 @@ module Kettle
       end
 
       # @param check_num [Integer] 1-based index to resume from
-      def initialize(check_num: 1)
+      def initialize(check_num: 1, event_recorder: nil)
         @check_num = (check_num || 1).to_i
         @check_num = 1 if @check_num < 1
+        @event_recorder = event_recorder
         @image_url_cache_path = configured_image_url_cache_path
         @refresh_image_url_cache = env_truthy?(ENV["KETTLE_IMAGE_URL_CACHE_REFRESH"])
         @image_url_skip_patterns = configured_image_url_skip_patterns
@@ -294,7 +296,14 @@ module Kettle
         checks[begin_idx..-1].each_with_index do |check, i|
           idx = begin_idx + i + 1
           puts "[kettle-pre-release] Running check ##{idx} of #{checks.size}"
-          check.call
+          emit_pre_release_event(action: "check", status: "started", check: check_name(check), index: idx, total: checks.size)
+          begin
+            check.call
+            emit_pre_release_event(action: "check", status: "ok", check: check_name(check), index: idx, total: checks.size)
+          rescue => error
+            emit_pre_release_event(action: "check", status: "failed", check: check_name(check), index: idx, total: checks.size, reason: "#{error.class}: #{error.message}")
+            raise
+          end
         end
         nil
       end
@@ -355,6 +364,7 @@ module Kettle
         end
 
         puts "[kettle-pre-release] Normalization candidates: #{total_candidates}. Files changed: #{changed.uniq.size}."
+        emit_pre_release_event(action: "markdown_urls", status: "ok", candidates: total_candidates, changed_files: changed.uniq.size)
         nil
       end
 
@@ -408,10 +418,12 @@ module Kettle
         puts "[kettle-pre-release] Image URL checks: #{progress.cached_count} cached, #{progress.live_count} live."
         puts "[kettle-pre-release] Skipped #{progress.skipped_count} image URL check(s)." if skipped.any?
         if failures.any?
+          emit_pre_release_event(action: "image_links", status: "failed", urls: urls.size, cached: progress.cached_count, live: progress.live_count, skipped: progress.skipped_count, failures: failures.size)
           warn("[kettle-pre-release] #{failures.size} image URL(s) failed validation:")
           failures.each { |u| warn("  - #{u}") }
           Kettle::Dev::ExitAdapter.abort("Image link validation failed")
         else
+          emit_pre_release_event(action: "image_links", status: "ok", urls: urls.size, cached: progress.cached_count, live: progress.live_count, skipped: progress.skipped_count, failures: 0)
           puts "[kettle-pre-release] All image links validated."
         end
         nil
@@ -419,6 +431,33 @@ module Kettle
 
       private
 
+      def check_name(check)
+        check.name.to_s.sub(/\Acheck_/, "").sub(/!\z/, "")
+      end
+
+      def emit_pre_release_event(action:, status:, **payload)
+        mark = case status.to_s
+        when "started"
+          ">"
+        when "ok", "skipped"
+          "."
+        when "failed"
+          "!"
+        else
+          "?"
+        end
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "pre_release",
+          payload.merge(
+            action: action,
+            phase: "release",
+            status: status,
+            mark: mark
+          )
+        )
+      end
+
       def image_url_cache
         return nil if @image_url_cache_path.to_s.empty?
 

data/lib/kettle/dev/release_cli.rb

@@ -117,14 +117,15 @@ module Kettle
 
       public
 
-      def initialize(start_step: 0, local_ci: false, version: nil, appraisal_task: nil, skip_steps: nil, skip_bundle_audit: nil, ci_workflows: nil, skip_remotes: nil, secrets_provider_name: nil, yes: false, **options)
+      def initialize(start_step: 0, local_ci: false, version: nil, appraisal_task: nil, skip_steps: nil, skip_bundle_audit: nil, ci_workflows: nil, skip_remotes: nil, required_remotes: nil, secrets_provider_name: nil, yes: false, **options)
         @root = Kettle::Dev::CIHelpers.project_root
         @git = Kettle::Dev::GitAdapter.new(@root)
         @start_step = (start_step || 0).to_i
         @start_step = 0 if @start_step < 0
         @skip_steps = normalize_skip_steps(skip_steps)
         @ci_workflows = normalize_ci_workflows(ci_workflows || ENV["K_RELEASE_CI_WORKFLOWS"])
-        @skip_remotes = normalize_skip_remotes(skip_remotes || ENV["K_RELEASE_SKIP_REMOTES"])
+        @skip_remotes = normalize_remote_names(skip_remotes || ENV["K_RELEASE_SKIP_REMOTES"], "skip remotes")
+        @required_remotes = normalize_required_remotes(required_remotes)
         @local_ci = !!local_ci
         @skip_bundle_audit = truthy_value?(skip_bundle_audit) || truthy_value?(ENV["KETTLE_DEV_SKIP_BUNDLE_AUDIT"])
         @yes = !!yes
@@ -479,14 +480,19 @@ module Kettle
         workflows.map { |workflow| workflow.match?(/\.ya?ml\z/) ? workflow : "#{workflow}.yml" }.uniq
       end
 
-      def normalize_skip_remotes(value)
+      def normalize_remote_names(value, label)
         remotes = Array(value).flat_map { |part| part.to_s.split(",") }.map(&:strip).reject(&:empty?)
         invalid = remotes.find { |remote| !remote.match?(/\A[A-Za-z0-9_.-]+\z/) }
-        abort("Invalid skip remotes value #{invalid.inspect}; use comma-separated git remote names.") if invalid
+        abort("Invalid #{label} value #{invalid.inspect}; use comma-separated git remote names.") if invalid
 
         remotes.uniq
       end
 
+      def normalize_required_remotes(value)
+        remotes = normalize_remote_names(value.nil? ? ENV["K_RELEASE_REQUIRED_REMOTES"] : value, "required remotes")
+        remotes.empty? ? ["origin"] : remotes
+      end
+
       private
 
       def local_ci?
@@ -571,7 +577,7 @@ module Kettle
 
       def run_pre_release_checks!
         puts "Running pre-release checks via kettle-pre-release..."
-        Kettle::Dev::PreReleaseCLI.new(check_num: 1).run
+        Kettle::Dev::PreReleaseCLI.new(check_num: 1, event_recorder: @event_recorder).run
         run_changelog!
       end
 
@@ -590,9 +596,11 @@ module Kettle
         attempts = release_lockfile_reset_attempts(stage)
         attempts.times do |index|
           attempt = index + 1
+          emit_release_lockfile_event(action: "reset", status: "started", stage: stage, attempt: attempt, attempts: attempts)
           puts "Resetting release lockfiles with local path dependencies disabled #{stage} (attempt #{attempt}/#{attempts})..."
           begin
             lockfile_reset.reset(Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET)
+            emit_release_lockfile_event(action: "reset", status: "ok", stage: stage, attempt: attempt, attempts: attempts)
             break
           rescue Kettle::Dev::Error => error
             raise unless error.message.start_with?("Reset #{Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET} failed validation:")
@@ -600,9 +608,26 @@ module Kettle
             # Keep release-facing failures shaped like the lockfile validation
             # guard, even when the shared reset helper is the component that
             # detects the unrepaired lockfile.
+            emit_release_lockfile_event(
+              action: "reset",
+              status: "blocked",
+              stage: stage,
+              attempt: attempt,
+              attempts: attempts,
+              reason: error.message
+            )
             break
           rescue => error
-            raise unless retryable_release_lockfile_reset_error?(error) && attempt < attempts
+            retryable = retryable_release_lockfile_reset_error?(error) && attempt < attempts
+            emit_release_lockfile_event(
+              action: "reset",
+              status: retryable ? "retrying" : "failed",
+              stage: stage,
+              attempt: attempt,
+              attempts: attempts,
+              reason: error.message
+            )
+            raise unless retryable
 
             puts "Release lockfile reset could not resolve a gem from #{RELEASE_VALIDATION_SOURCE}; waiting before retry #{attempt + 1}/#{attempts}."
             sleep(release_availability_probe_interval)
@@ -611,7 +636,16 @@ module Kettle
 
         diagnostics = release_lockfile_paths.flat_map { |path| release_lockfile_diagnostics(path) }
         if diagnostics.empty?
+          emit_release_lockfile_event(action: "validate", status: "ok", stage: stage, count: release_lockfile_paths.length)
           puts "Release lockfile reset complete: #{release_lockfile_paths.length} lockfile(s) checked, no diagnostics remain."
+        else
+          emit_release_lockfile_event(
+            action: "validate",
+            status: "failed",
+            stage: stage,
+            count: diagnostics.length,
+            reason: "#{diagnostics.length} diagnostic(s)"
+          )
         end
         @release_lockfiles_reset_for_release_tasks = true if stage == "before release task bundle installs"
       end
@@ -758,6 +792,7 @@ module Kettle
         cmd = "bundle exec kettle-changelog"
         cmd = "#{cmd} --version #{Shellwords.escape(@version_override)}" if @version_override
         cmd = "#{cmd} --yes" if @yes
+        cmd = "#{cmd} --events=changelog" if @event_stream
         run_cmd!(cmd)
         @changelog_generated_coverage = true
       end
@@ -1010,12 +1045,24 @@ module Kettle
       def monitor_workflows_after_push!
         ensure_github_pull_request_for_ci!
         keep_release_secrets_alive!("CI monitoring")
+        restart_hint = "bundle exec kettle-release start_step=10"
+        emit_ci_monitor_event(action: "start", status: "started", workflows: @ci_workflows, restart_hint: restart_hint)
         # Use abort-on-failure CI monitor to match historical behavior and specs
-        Kettle::Dev::CIMonitor.monitor_all!(
-          restart_hint: "bundle exec kettle-release start_step=10",
-          workflows: @ci_workflows,
-          keepalive: release_secrets_configured? ? -> { keep_release_secrets_alive!("CI monitoring") } : nil
-        )
+        begin
+          Kettle::Dev::CIMonitor.monitor_all!(
+            restart_hint: restart_hint,
+            workflows: @ci_workflows,
+            keepalive: release_secrets_configured? ? -> { keep_release_secrets_alive!("CI monitoring") } : nil,
+            event_recorder: @event_recorder
+          )
+          emit_ci_monitor_event(action: "finish", status: "ok", workflows: @ci_workflows, restart_hint: restart_hint)
+        rescue SystemExit => error
+          emit_ci_monitor_event(action: "finish", status: "failed", workflows: @ci_workflows, restart_hint: restart_hint, reason: error.message)
+          raise
+        rescue => error
+          emit_ci_monitor_event(action: "finish", status: "failed", workflows: @ci_workflows, restart_hint: restart_hint, reason: "#{error.class}: #{error.message}")
+          raise
+        end
       end
 
       def ensure_github_pull_request_for_ci!
@@ -1412,6 +1459,7 @@ module Kettle
         sleep(release_availability_probe_initial_delay)
         attempts.times do |index|
           attempt = index + 1
+          emit_release_probe_event(action: "availability", status: "started", candidate: candidate, attempt: attempt, attempts: attempts)
           puts("Validating #{candidate.gem_name} #{candidate.version} from #{RELEASE_VALIDATION_SOURCE} (attempt #{attempt}/#{attempts})")
           stdout_str = nil
           stderr_str = nil
@@ -1420,10 +1468,21 @@ module Kettle
             stdout_str, stderr_str, status = Open3.capture3(self.class.send(:command_env), Gem.ruby, script_path)
           end
           $stdout.print(stdout_str) unless stdout_str.to_s.empty?
-          return true if status.success?
+          if status.success?
+            emit_release_probe_event(action: "availability", status: "ok", candidate: candidate, attempt: attempt, attempts: attempts)
+            return true
+          end
 
           last_stderr = stderr_str
           last_status = status
+          emit_release_probe_event(
+            action: "availability",
+            status: (attempt < attempts) ? "retrying" : "failed",
+            candidate: candidate,
+            attempt: attempt,
+            attempts: attempts,
+            reason: "exit #{status.exitstatus}"
+          )
           sleep(release_availability_probe_interval) if attempt < attempts
         end
 
@@ -1590,6 +1649,7 @@ module Kettle
           name: command_event_name(command),
           status: status,
           reason: reason,
+          summary: command_event_summary(command),
           command: command,
           changed_files: []
         }
@@ -1598,7 +1658,80 @@ module Kettle
       end
 
       def command_event_name(command)
-        command.to_s.split(/\s+/, 3).first(2).join("_").gsub(/[^A-Za-z0-9_]+/, "_").sub(/_+\z/, "")
+        words = Shellwords.split(command.to_s)
+        effective_words = command_event_effective_words(words)
+        joined = effective_words.join(" ")
+
+        return "kettle_changelog" if joined.start_with?("bundle exec kettle-changelog")
+        return "gem_build" if joined == "bundle exec rake build"
+        return "gem_release" if joined == "bundle exec rake release"
+        return "gem_push" if effective_words.first(2) == ["gem", "push"]
+        return "gem_checksums" if effective_words.first == "bin/gem_checksums"
+        return "bundle_lock" if effective_words.first(2) == ["bundle", "lock"]
+        return "bin_setup" if effective_words == ["bin/setup"]
+        return "default_task" if effective_words == ["bin/rake"]
+        return "appraisal_generate" if effective_words == ["bin/rake", "appraisal:generate"]
+        return "appraisal_update" if effective_words == ["bin/rake", "appraisal:update"]
+        return "yard" if effective_words == ["bin/rake", "yard"]
+        return "git_fetch" if effective_words.first(2) == ["git", "fetch"]
+        return "git_pull" if effective_words.first(2) == ["git", "pull"]
+        return "git_rebase" if effective_words.first(2) == ["git", "rebase"]
+        return "git_merge" if effective_words.first(2) == ["git", "merge"]
+        return "git_push" if effective_words.first(2) == ["git", "push"]
+
+        effective_words.first(2).join("_").gsub(/[^A-Za-z0-9_]+/, "_").sub(/_+\z/, "")
+      end
+
+      def command_event_effective_words(words)
+        words = words.dup
+        words.shift while words.first&.match?(/\A[A-Za-z_][A-Za-z0-9_]*=/)
+
+        if words.first == "env"
+          words.shift
+          while words.any?
+            if words.first == "-u"
+              words.shift(2)
+            elsif words.first&.include?("=")
+              words.shift
+            else
+              break
+            end
+          end
+        end
+
+        words
+      end
+
+      def command_event_summary(command)
+        words = Shellwords.split(command.to_s)
+        effective_words = command_event_effective_words(words)
+        joined = effective_words.join(" ")
+
+        return "changelog" if joined.start_with?("bundle exec kettle-changelog")
+        return command_event_bundle_lock_summary(words) if effective_words.first(2) == ["bundle", "lock"]
+        return "setup" if effective_words == ["bin/setup"]
+        return "default task" if effective_words == ["bin/rake"]
+        return "appraisals" if effective_words == ["bin/rake", "appraisal:generate"]
+        return "appraisals" if effective_words == ["bin/rake", "appraisal:update"]
+        return "documentation" if effective_words == ["bin/rake", "yard"]
+        return "build gem" if joined == "bundle exec rake build"
+        return "publish gem" if joined == "bundle exec rake release"
+        return "push gem" if effective_words.first(2) == ["gem", "push"]
+        return "checksums" if effective_words.first == "bin/gem_checksums"
+        return effective_words[2] if effective_words.first(2) == ["git", "fetch"] && effective_words[2]
+        return effective_words[2] if effective_words.first(2) == ["git", "push"] && effective_words[2]
+        return effective_words[2] if effective_words.first(2) == ["git", "pull"] && effective_words[2]
+        return effective_words[2] if effective_words.first(2) == ["git", "rebase"] && effective_words[2]
+        return effective_words[2] if effective_words.first(2) == ["git", "merge"] && effective_words[2]
+
+        nil
+      end
+
+      def command_event_bundle_lock_summary(words)
+        gemfile = words.find { |word| word.start_with?("BUNDLE_GEMFILE=") }&.split("=", 2)&.last
+        return "lockfile" unless gemfile
+
+        File.basename(gemfile)
       end
 
       def record_diagnostic(kind, message, severity:, blocking:)
@@ -1635,6 +1768,97 @@ module Kettle
         )
       end
 
+      def emit_remote_parity_event(action:, remote: nil, status: nil, trunk: nil, attempt: nil, attempts: nil, required: nil, reason: nil, remotes: nil)
+        mark = release_progress_mark(status)
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "remote_parity",
+          action: action,
+          phase: "release",
+          remote: remote,
+          status: status,
+          trunk: trunk,
+          attempt: attempt,
+          attempts: attempts,
+          required: required,
+          reason: reason,
+          remotes: remotes,
+          mark: mark
+        )
+      end
+
+      def emit_release_lockfile_event(action:, status:, stage:, attempt: nil, attempts: nil, count: nil, reason: nil)
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "release_lockfile",
+          action: action,
+          phase: "release",
+          status: status,
+          stage: stage,
+          attempt: attempt,
+          attempts: attempts,
+          count: count,
+          reason: reason,
+          mark: release_progress_mark(status)
+        )
+      end
+
+      def emit_release_probe_event(action:, status:, candidate:, attempt:, attempts:, reason: nil)
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "release_probe",
+          action: action,
+          phase: "release",
+          status: status,
+          gem: candidate.gem_name,
+          version: candidate.version,
+          source: RELEASE_VALIDATION_SOURCE,
+          attempt: attempt,
+          attempts: attempts,
+          reason: reason,
+          mark: release_progress_mark(status)
+        )
+      end
+
+      def release_progress_mark(status)
+        case status.to_s
+        when "started"
+          ">"
+        when "ok", "skipped"
+          "."
+        when "failed", "blocked"
+          "!"
+        when "retrying"
+          ">"
+        else
+          ">"
+        end
+      end
+
+      def emit_ci_monitor_event(action:, status:, workflows:, restart_hint:, reason: nil)
+        mark = case status.to_s
+        when "started"
+          ">"
+        when "ok"
+          "."
+        when "failed"
+          "!"
+        else
+          "?"
+        end
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "ci_monitor",
+          action: action,
+          phase: "release",
+          status: status,
+          workflows: workflows,
+          restart_hint: restart_hint,
+          reason: reason,
+          mark: mark
+        )
+      end
+
       def finish_release_report(status:, error:)
         return if @finished_report
 
@@ -1798,6 +2022,10 @@ module Kettle
         @skip_remotes.include?(name)
       end
 
+      def required_remote?(name)
+        @required_remotes.include?(name)
+      end
+
       def active_remotes
         list_remotes.reject { |remote| skipped_remote?(remote) }
       end
@@ -1836,26 +2064,30 @@ module Kettle
         if has_remote?("all")
           remotes = active_remotes
           skipped = list_remotes.select { |remote| skipped_remote?(remote) }
+          required = remotes.select { |remote| required_remote?(remote) }
           puts "Remote 'all' detected. Fetching from active remotes and enforcing strict trunk parity..."
           puts "Skipping configured remotes: #{skipped.join(", ")}" unless skipped.empty?
+          puts "Required release parity remotes: #{required.join(", ")}" unless required.empty?
+          fetched_remotes = []
+          emit_remote_parity_event(action: "start", status: "started", trunk: trunk, remotes: remotes - ["all"])
           remotes.each do |remote|
             next if remote == "all"
 
-            fetch_remote_for_parity!(remote)
+            fetched_remotes << remote if fetch_remote_for_parity!(remote)
           end
           missing_from = []
-          remotes.each do |r|
-            next if r == "all"
-
+          fetched_remotes.each do |r|
             if remote_branch_exists?(r, trunk)
               _ahead, behind = ahead_behind_counts(trunk, "#{r}/#{trunk}")
               missing_from << r if behind.positive?
             end
           end
           unless missing_from.empty?
+            emit_remote_parity_event(action: "missing", status: "failed", trunk: trunk, remotes: missing_from, reason: "missing commits")
             abort("Local #{trunk} is missing commits present on: #{missing_from.join(", ")}. Please sync trunk first.")
           end
-          puts "Local #{trunk} has all commits from remotes: #{(remotes - ["all"]).join(", ")}"
+          puts "Local #{trunk} has all commits from remotes: #{fetched_remotes.join(", ")}"
+          emit_remote_parity_event(action: "ok", status: "ok", trunk: trunk, remotes: fetched_remotes)
           return
         end
 
@@ -1924,8 +2156,10 @@ module Kettle
         attempts.times do |index|
           attempt = index + 1
           puts "Fetching remote '#{remote}' for release parity (attempt #{attempt}/#{attempts})"
+          emit_remote_parity_event(action: "fetch", remote: remote, status: "started", attempt: attempt, attempts: attempts, required: required_remote?(remote))
           begin
             run_cmd!(command)
+            emit_remote_parity_event(action: "fetch", remote: remote, status: "ok", attempt: attempt, attempts: attempts, required: required_remote?(remote))
             return true
           rescue SystemExit => error
             last_error = error
@@ -1935,7 +2169,17 @@ module Kettle
           sleep(remote_fetch_parity_interval) if attempt < attempts
         end
 
-        abort(remote_fetch_failure_message(remote, last_error&.message.to_s))
+        detail = last_error&.message.to_s
+        if required_remote?(remote)
+          emit_remote_parity_event(action: "fetch", remote: remote, status: "failed", attempts: attempts, required: true, reason: detail)
+          abort(remote_fetch_failure_message(remote, detail))
+        end
+
+        message = optional_remote_fetch_failure_message(remote, detail)
+        warn(message)
+        emit_remote_parity_event(action: "skip", remote: remote, status: "skipped", attempts: attempts, required: false, reason: detail)
+        record_diagnostic("release_remote_skipped", message, severity: "warning", blocking: false)
+        false
       end
 
       def remote_fetch_parity_attempts
@@ -1948,7 +2192,7 @@ module Kettle
 
       def remote_fetch_failure_message(remote, detail)
         <<~MSG
-          Unable to fetch git remote '#{remote}' during release parity checks.
+          Unable to fetch required git remote '#{remote}' during release parity checks.
           kettle-release enforces trunk parity across active remotes before publishing.
 
           If this remote is temporarily unavailable or intentionally not part of this release,
@@ -1961,6 +2205,20 @@ module Kettle
         MSG
       end
 
+      def optional_remote_fetch_failure_message(remote, detail)
+        <<~MSG
+          Unable to fetch optional git remote '#{remote}' during release parity checks; skipping this remote for this release.
+          Required remotes still block release parity checks.
+
+          To make this remote block releases, configure:
+            kettle-release --required-remotes #{remote}
+            K_RELEASE_REQUIRED_REMOTES=#{remote} kettle-release
+
+          Original failure:
+          #{detail}
+        MSG
+      end
+
       def merge_feature_into_trunk_and_push!(trunk, feature)
         return if feature.nil? || feature == trunk
 

data/lib/kettle/dev/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-dev
 version: !ruby/object:Gem::Version
-  version: 2.5.12
+  version: 2.5.13
 platform: ruby
 authors:
 - Peter H. Boling
@@ -80,7 +80,7 @@ dependencies:
         version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -90,7 +90,7 @@ dependencies:
         version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.9
 - !ruby/object:Gem::Dependency
   name: kettle-rb
   requirement: !ruby/object:Gem::Requirement
@@ -401,10 +401,10 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-dev.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.5.12
-  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.5.12/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.5.13
+  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.5.13/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-dev/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.5.12
+  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.5.13
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-dev/kettle-dev/wiki
   news_uri: https://www.railsbling.com/tags/kettle-dev