kettle-dev 2.5.12 → 2.5.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60069f78cc45c33bf7d2616ea76c456e98cf9885da75331a553f5c9e2b96bbe8
-  data.tar.gz: d58499d2f31cbffc408e15af977b93b3254f310d021822d90726c7407f4436c3
+  metadata.gz: fd42849120d31c48755d543918cd96ea2abb0f61d550983853ae6827940099f6
+  data.tar.gz: 5bfc7a99f63937031b7999db6d6a35aa9583f7fc3547db425196fb18d3819458
 SHA512:
-  metadata.gz: b34e918fa0cce724b098ab97e46abd768a65938d52f908f87515a5f64b8c3c8d68e6717c05529045da5ce1670e407fa1fa955cfb3c9c2cbd6a4c72d46b64577b
-  data.tar.gz: d9dcb4194c6f22c6f6ba1b3311b8f7e644766b52bb36f80d4f59130e48f32d2d4917541c3aebf25e253adb4e3914485b9d66b7f77ebf64b73e56804686dc4276
+  metadata.gz: 91ae2809e3092c93f6feaa5b20f4dbc562497917244f95f388ababfe72403f9af76f924314a561c85dc39f8e0f987ed4d19580675612bb01c117fa1e8f1be58e
+  data.tar.gz: 0c77a71e021fe4657903384d45ecf8da00c136b78bc0a6cb7531ecc584606bb9fa7abd0ad7a683ea844ee6d3a0be59ecfe388c3cdce1dafbf65989a72b4b6063

data/CHANGELOG.md

@@ -30,6 +30,61 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [2.5.14] - 2026-07-31
+
+- TAG: [v2.5.14][2.5.14t]
+- COVERAGE: 91.94% -- 5146/5597 lines in 46 files
+- BRANCH COVERAGE: 76.13% -- 1946/2556 branches in 46 files
+- 50.41% documented
+
+### Fixed
+
+- `kettle-reset release-lockfiles` now requires SHA-256 checksums only for
+  registry-sourced gems, allowing valid Git-sourced dependencies such as the
+  `simplecov` fork to remain checksumless.
+
+## [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 +3173,11 @@ 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.14...HEAD
+[2.5.14]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.13...v2.5.14
+[2.5.14t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.5.14
+[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.597-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