git 5.1.0 → 5.2.0

data/.github/skills-deprecated/review-backward-compatibility/SKILL.md

@@ -1,275 +0,0 @@
----
-name: review-backward-compatibility
-description: "Audits Git::Lib methods for backward compatibility after commands are moved to Git::Commands::* classes. Use to verify that migrated commands maintain their existing public API."
----
-
-# Review Backward Compatibility
-
-Review `Git::Lib` methods for backward compatibility after commands are moved to
-`Git::Commands::*` classes. This skill guides the process of restoring backward
-compatibility for a specific set of git commands while maintaining the benefits of
-the new command infrastructure.
-
-## Contents
-
-- [How to use this skill](#how-to-use-this-skill)
-- [Related skills](#related-skills)
-- [Objective](#objective)
-- [Current Command Architecture Note](#current-command-architecture-note)
-- [Instructions](#instructions)
-  - [Branch setup](#branch-setup)
-  - [Step 1: Identify Methods Added Since v4.3.0](#step-1-identify-methods-added-since-v430)
-  - [Step 2: Remove New Methods](#step-2-remove-new-methods)
-  - [Step 3: Restore Backward-Compatible Implementations](#step-3-restore-backward-compatible-implementations)
-  - [Step 4: Add Required Dependencies](#step-4-add-required-dependencies)
-  - [Step 5: Verify the Changes](#step-5-verify-the-changes)
-- [Example: Stash Commands](#example-stash-commands)
-  - [Legacy Methods (v4.3.0)](#legacy-methods-v430)
-  - [New Methods (removed)](#new-methods-removed)
-  - [Implementation Pattern](#implementation-pattern)
-- [Key Principles](#key-principles)
-- [Validation Checklist](#validation-checklist)
-- [Usage](#usage)
-
-## How to use this skill
-
-Attach this file to your Copilot Chat context, then invoke it with the git
-command name(s) to audit. Example:
-
-```text
-Remove methods added to Git::Lib since v4.3.0 for the `branch` git command
-and ensure the remaining methods are backward compatible.
-```
-
-Replace `branch` with the specific git command(s) you want to audit (e.g.,
-`worktree`, `tag`, `merge`, `reset`).
-
-## Related skills
-
-- [Refactor Command to CommandLineResult](../refactor-command-to-commandlineresult/SKILL.md) — migrating command classes to Base;
-  the counterpart to this skill's `Git::Lib` facade focus
-- [Command Implementation](../command-implementation/SKILL.md) — class structure, phased rollout gates, and
-  internal compatibility contracts
-
-## Objective
-
-For the specified git command(s), remove methods added to `Git::Lib` since v4.3.0 and ensure that remaining methods (which existed in v4.3.0) are backward compatible.
-
-## Current Command Architecture Note
-
-When auditing modern implementations, assume command classes follow `Git::Commands::Base`:
-
-- classes use `class < Git::Commands::Base` with `arguments do ... end`
-- command entrypoint is `call(*, **)` (inherited from `Base`)
-- exit-status behavior is centralized via `allow_exit_status` declarations on the class
-
-Because of this, backward-compatibility adaptation should happen in `Git::Lib`
-methods (facade/adapter layer), not by reintroducing legacy execution logic inside
-command classes.
-
-## Instructions
-
-### Branch setup
-
-All work must be done on a feature branch. **Never commit or push directly to
-`main`.**
-
-Before starting, create a new branch:
-
-```bash
-git checkout -b <feature-branch-name>
-```
-
-All commits in this workflow go on the feature branch. When work is complete,
-open a pull request — do not merge or push directly into `main`.
-
-### Step 1: Identify Methods Added Since v4.3.0
-
-1. Check out the v4.3.0 tag to examine the historical state:
-
-   **Warning:** `git checkout` modifies the working tree. Stash or commit any
-   uncommitted changes first (`git stash`).
-
-   ```bash
-   git checkout v4.3.0
-   ```
-
-2. Search `lib/git/lib.rb` for all methods related to the specified git command(s):
-   ```bash
-   grep -n "def <command_name>" lib/git/lib.rb
-   ```
-
-3. Document each method found, including:
-   - Method name and signature
-   - Return value type (String, Array, Hash, Boolean, etc.)
-   - Exact return value format (e.g., `Array<[Integer, String]>`, `String` with specific content)
-
-4. Return to your feature branch:
-   ```bash
-   git checkout -
-   ```
-
-5. Search for the same command methods in the current version:
-   ```bash
-   grep -n "def <command_name>" lib/git/lib.rb
-   ```
-
-6. Create two lists:
-   - **Legacy methods**: Methods that existed in v4.3.0 (must be preserved and made compatible)
-   - **New methods**: Methods that don't exist in v4.3.0 (should be removed)
-
-### Step 2: Remove New Methods
-
-1. Identify all new methods that were added after v4.3.0
-2. Remove these methods entirely from `lib/git/lib.rb`
-3. Remove any `require` statements that are only used by the removed methods
-
-### Step 3: Restore Backward-Compatible Implementations
-
-For each legacy method that needs to be preserved:
-
-1. **Use modern command infrastructure internally:**
-   - Call the appropriate `Git::Commands::<Command>::*` class
-   - Ensure all necessary command classes are required at the top of the file
-
-2. **Convert return values to match v4.3.0 exactly:**
-   - Compare the return type from the modern command with the v4.3.0 return type
-   - If they differ, add conversion logic to transform the result
-   - Modern commands typically return `CommandLineResult` objects with `.stdout`, `.stderr`, and `.status`
-   - Legacy methods may have returned raw strings, arrays, or other types
-
-3. **Create helper methods if needed:**
-   - For complex conversions (e.g., parsing output into specific formats), create private helper methods
-   - Name helpers clearly (e.g., `<command>_info_to_legacy`)
-   - Place helpers near the bottom of the file in the private section
-
-### Step 4: Add Required Dependencies
-
-1. Ensure all necessary `require` statements are present:
-   ```ruby
-   require_relative 'git/commands/<command>/<action>'
-   require_relative 'git/parsers/<command>' # if using parsers
-   ```
-
-2. Only keep requires for:
-   - Command classes used by the legacy methods
-   - Parsers needed for conversion
-   - Remove requires for deleted commands
-
-### Step 5: Verify the Changes
-
-1. Check the diff to ensure:
-   ```bash
-   git diff lib/git/lib.rb
-   ```
-   - All new methods are removed
-   - All legacy methods are present with correct signatures
-   - Return value conversions are in place
-   - Correct require statements are present
-
-2. Verify that the implementation uses modern command classes:
-   ```bash
-   git diff lib/git/lib.rb | grep -E "^\+.*Git::Commands::<Command>"
-   ```
-
-3. Check the net line change (should be negative if removing methods):
-   ```bash
-   git diff --stat lib/git/lib.rb
-   ```
-
-## Example: Stash Commands
-
-Here's how this process was applied to the `stash` commands:
-
-### Legacy Methods (v4.3.0)
-- `stashes_all` → returned `Array<[Integer, String]>` (index and message pairs)
-- `stash_save(message)` → returned regex match result (truthy/falsy)
-- `stash_apply(id)` → returned `String` (stdout)
-- `stash_clear` → returned `String` (stdout)
-- `stash_list` → returned `String` (stdout)
-
-### New Methods (removed)
-- `stash_branch`
-- `stash_create`
-- `stash_drop`
-- `stash_pop`
-- `stash_push`
-- `stashes_list`
-- `git_stash_show_*` methods
-
-### Implementation Pattern
-
-```ruby
-# Requires at top of file
-require_relative 'git/commands/stash/apply'
-require_relative 'git/commands/stash/clear'
-require_relative 'git/commands/stash/list'
-require_relative 'git/commands/stash/push'
-require_relative 'git/parsers/stash'
-
-# Legacy method implementations
-def stashes_all
-  result = Git::Commands::Stash::List.new(self).call
-  stashes = Git::Parsers::Stash.parse_list(result.stdout)
-  stashes.map { |info| stash_info_to_legacy(info) }
-end
-
-def stash_save(message)
-  result = Git::Commands::Stash::Push.new(self).call(message: message)
-  result.stdout =~ /HEAD is now at/
-end
-
-def stash_apply(id = nil)
-  result = Git::Commands::Stash::Apply.new(self).call(id)
-  result.stdout
-end
-
-def stash_clear
-  result = Git::Commands::Stash::Clear.new(self).call
-  result.stdout
-end
-
-def stash_list
-  result = Git::Commands::Stash::List.new(self).call
-  result.stdout
-end
-
-# Helper method (in private section)
-private
-
-def stash_info_to_legacy(stash_info)
-  [stash_info.index, stash_info.message]
-end
-```
-
-## Key Principles
-
-1. **Maintain exact v4.3.0 return values**: Don't change return types even slightly
-2. **Use modern infrastructure internally**: Leverage `Git::Commands::*` classes for actual git operations
-3. **Remove all new methods**: Don't try to make new methods backward compatible - just remove them
-4. **Minimize changes**: Only modify what's necessary for backward compatibility
-5. **Document conversions**: Make helper methods clear and well-named
-6. **Apply policy at the facade**: `Git::Lib` methods pass policy options explicitly
-   (e.g. `no_edit: true`, `verbose: true`, `no_progress: true`) — command classes stay
-   neutral. See "Command-layer neutrality" in CONTRIBUTING.md.
-
-## Validation Checklist
-
-- [ ] Working on a feature branch (not `main`)
-- [ ] Identified all methods for the command in v4.3.0
-- [ ] Documented v4.3.0 return values exactly
-- [ ] Removed all methods not present in v4.3.0
-- [ ] Implemented legacy methods using modern command classes
-- [ ] Added conversion logic where return types differ
-- [ ] Created helper methods for complex conversions
-- [ ] Updated require statements correctly
-- [ ] Verified changes with git diff
-- [ ] Net line count decreased (removed more than added)
-
-## Usage
-
-To apply this process, say:
-
-> Remove methods added to Git::Lib since v4.3.0 for `<command_name>` git command(s) and ensure the remaining methods are backward compatible.
-
-Replace `<command_name>` with the specific git command(s) you want to audit (e.g., `branch`, `merge`, `tag`, `reset`, etc.).

data/.github/workflows/continuous_integration.yml

@@ -1,358 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: [main, 4.x]
-  workflow_dispatch:
-
-# Cancel an in-progress run when the same PR (or branch) gets a new push. For
-# pull_request events github.ref is refs/pull/<n>/merge, so runs are grouped per PR
-# and pushing a new commit -- or force-pushing during a rebase -- no longer leaves a
-# full matrix running to completion against a commit nobody will merge.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  # RuboCop and YARD analyze source text, so their results do not depend on the
-  # runtime executing them: RuboCop's verdict is fixed by TargetRubyVersion in
-  # .rubocop.yml, not by the host Ruby. Running them once here instead of inside the
-  # matrix removes the single largest cost in the build -- RuboCop alone accounted for
-  # over half the wall time of the JRuby and TruffleRuby jobs -- while checking exactly
-  # the same things.
-  #
-  # Ruby 3.4 hosts this job rather than the newest supported Ruby because it gates
-  # merges: a lint gate should be insulated from churn in a brand-new major, and Ruby
-  # 4.0 deprecations still surface through the matrix jobs below, which do run 4.0.
-  # 3.3+ is also a hard floor here, since yard-lint is only installed on 3.3 and later
-  # (see the gemspec) and YARD itself cannot build on JRuby or TruffleRuby.
-  lint:
-    name: Lint and Docs
-
-    # Skip this job if triggered by a release PR
-    if: >-
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v6
-
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "3.4"
-          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-
-      - name: Run RuboCop and YARD
-        run: bundle exec rake rubocop yard
-        timeout-minutes: 15
-
-  build:
-    name: Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}
-
-    # Skip this job if triggered by a release PR
-    if: >-
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
-
-    runs-on: ${{ matrix.operating-system }}
-    env: { JAVA_OPTS: -Djdk.io.File.enableADS=true }
-
-    strategy:
-      fail-fast: false
-      matrix:
-        # Only the minimum required versions of JRuby and TruffleRuby are tested.
-        #
-        ruby: ["3.2", "4.0", "truffleruby-24.2.1", "jruby-10.0.0.1"]
-        operating-system: [ubuntu-latest]
-        include:
-          - ruby: "3.2"
-            operating-system: windows-latest
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v6
-
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-
-      # Specs only. RuboCop and YARD run once in the lint job above instead of being
-      # repeated identically on every runtime. `rake build` still runs on every
-      # platform, as a prerequisite of the Test Gem step below.
-      - name: Run Specs
-        run: bundle exec rake spec
-        timeout-minutes: 15
-
-      # The unit suite enforces 100% line and branch coverage (see the "Test coverage
-      # policy" section of CONTRIBUTING.md). The failure log names the uncovered lines
-      # and branches; this artifact adds the browsable HTML report for the same run.
-      - name: Upload Coverage Report
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: coverage-ruby-${{ matrix.ruby }}-${{ matrix.operating-system }}
-          path: coverage/
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: Test Gem
-        run: bundle exec rake test:gem
-
-  # The branch ruleset cannot require the matrix jobs above directly. A required status
-  # check is matched by name, and `build`'s name is a template -- GitHub only expands it
-  # into "Ruby 3.2 on ubuntu-latest" and friends when it evaluates the matrix. The
-  # job-level `if:` short-circuits before that happens, so a release PR reports one check
-  # named literally "Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}" and the
-  # five expanded names never report at all. Required checks that never report block a PR
-  # indefinitely rather than passing, which is what stranded the v5.0.5 release PR.
-  #
-  # So the ruleset requires this job instead: one stable name, no matrix, no template to
-  # expand. It also decouples the required-check list from the matrix, so adding or
-  # dropping a Ruby version no longer needs a matching ruleset edit.
-  #
-  # This job carries the same release-PR guard as every job above, so that a release PR
-  # reports it as skipped rather than as a success for specs that never ran. Skipping is
-  # safe here and was not safe for `build`: this job's name is a literal string, so the
-  # check run exists and reports a skipped conclusion whether or not the job runs, and
-  # rulesets treat skipped as passing. A matrix job's name does not exist at all until the
-  # matrix is evaluated, which is the whole reason this job exists.
-  #
-  # `always()` is load-bearing and must stay. Without a status check function a job-level
-  # `if:` implies `success()`, so a failing matrix would skip this job -- and a skipped
-  # required check counts as passing, meaning a red build would merge. `always()` forces a
-  # real verdict on every run that is not a release PR. `!cancelled()` is not a substitute:
-  # a cancelled run would then skip the gate, and a skipped conclusion is one rulesets treat
-  # as passing -- so a build that never finished would stop blocking the merge.
-  #
-  # The case below accepts `success` only. `build` and this job now carry the same release-PR
-  # guard, so this job runs exactly when `build` ran; a `skipped` result would mean the two
-  # guards have drifted apart, and failing closed on it turns that into a loud failure rather
-  # than a silent pass.
-  build-complete:
-    name: All Specs Passed
-
-    needs: [build]
-
-    # Report a verdict on every non-release PR regardless of the matrix result, and skip
-    # on release PRs, where the matrix was never meant to run.
-    if: >-
-      always() &&
-      (github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--')))
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check the result of the build job
-        run: |
-          case "${{ needs.build.result }}" in
-            success)
-              echo "build: ${{ needs.build.result }}"
-              ;;
-            *)
-              echo "::error::build: ${{ needs.build.result }}"
-              exit 1
-              ;;
-          esac
-
-  # Everything above runs in English, because GitHub-hosted runners generate no locale
-  # beyond C/C.UTF-8. That makes git's translated diagnostics invisible to CI even
-  # though they are the default experience for any contributor whose shell locale is not
-  # English -- so a spec that matches an English git message passes here and fails for
-  # them, on code they did not touch. This job is what stops such a spec from reaching
-  # main. See issue #1670.
-  #
-  # German because git's `de` translation is close enough to complete that a
-  # message-matching assumption cannot hide behind a string that was never translated.
-  # Most of the suite is insulated from this by the LC_ALL pin in Git::ExecutionContext;
-  # what this job really exercises is the code that bypasses that pin.
-  locale:
-    name: Non-English Locale
-
-    # Skip this job if triggered by a release PR
-    if: >-
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
-
-    runs-on: ubuntu-latest
-
-    # Set at job scope rather than on the spec step so that every step -- including the
-    # check below that the locale is real -- sees exactly the environment the suite runs
-    # under. Setting these before locale-gen is harmless: they are simply inert until
-    # the locale exists.
-    env:
-      LANG: de_DE.UTF-8
-      LC_ALL: de_DE.UTF-8
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v6
-
-      # Two separate things are missing from a stock runner, and skipping either one
-      # leaves the env above inert -- git keeps answering in English and the job proves
-      # nothing:
-      #
-      #   1. The locale itself. Only C and C.UTF-8 are generated, so setlocale fails for
-      #      anything else and every process falls back to English.
-      #   2. git's German message catalog. Unlike Debian, Ubuntu strips gettext catalogs
-      #      out of packages and ships them in language packs, so the installed git has
-      #      no de translation until language-pack-de provides one.
-      #
-      # `update-locale` is deliberately not run: it edits /etc/default/locale, which is
-      # only consulted for logins that do not already set LANG and LC_ALL, and this job
-      # sets both explicitly.
-      #
-      # The two apt settings below exist because this step reaches out to the Ubuntu
-      # archive, which is the only part of this job that can fail for reasons that have
-      # nothing to do with the code under test:
-      #
-      #   * `Acquire::Retries` retries an individual download that fails outright,
-      #     rather than failing the job on one unlucky mirror.
-      #   * `timeout-minutes` bounds a mirror that accepts the connection and then
-      #     stops responding, which retries cannot help with. Without it the step
-      #     inherits the 6 hour job default: run 32087601711 sat here for 12 minutes
-      #     before it was cancelled by hand, and would otherwise have held a runner
-      #     for the rest of the day. The whole job normally finishes in 53-118
-      #     seconds, so 5 minutes is generous while still failing the same morning.
-      #
-      - name: Install the German locale and message catalogs
-        timeout-minutes: 5
-        run: |
-          sudo apt-get -o Acquire::Retries=3 update -qq
-          sudo apt-get -o Acquire::Retries=3 install -y --no-install-recommends language-pack-de
-          sudo locale-gen de_DE.UTF-8
-
-      # Ruby 3.4 to share the bundler cache the lint job already warms. Nothing about
-      # this job is Ruby-version specific -- the locale is what is under test.
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "3.4"
-          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-
-      # Guard against a vacuous pass. Diffing git's output against the same command run
-      # under LC_ALL=C proves translation is actually active, without pinning a German
-      # string that a future git release is free to reword.
-      - name: Verify the Locale Took Effect
-        run: |
-          dir="$(mktemp -d)"
-          localized="$(cd "$dir" && git status 2>&1 || true)"
-          english="$(cd "$dir" && LC_ALL=C git status 2>&1 || true)"
-          echo "LC_ALL=$LC_ALL -> $localized"
-          echo "LC_ALL=C -> $english"
-          if [ "$localized" = "$english" ]; then
-            echo "::error::git is still emitting English: de_DE.UTF-8 did not take effect, so this job would test nothing"
-            exit 1
-          fi
-
-      - name: Run Specs
-        run: bundle exec rake spec
-        timeout-minutes: 15
-
-  # On the ubuntu jobs above, `C.UTF-8` and `en_US.UTF-8` both resolve to a UTF-8 ctype
-  # (measured on the runner in issue #1669), and on windows the pinned value makes no
-  # difference under any value at all. So the non-ASCII regex coverage those jobs run
-  # passes whatever `Git::ExecutionContext` pins, and cannot tell a correct `LC_ALL`
-  # value from a wrong one. That blind spot is what let the original defect go
-  # unreported for eighteen months: the gem pinned `en_US.UTF-8`, stock Debian, Ubuntu,
-  # and RHEL images generate no such locale, git silently fell back to a C ctype, and
-  # every non-ASCII regex in `grep`, `log`, and the `config` value regexes returned a
-  # wrong answer with exit status zero -- while CI stayed green throughout.
-  #
-  # This job makes one run discriminating. `LOCPATH` overrides where glibc looks for
-  # compiled locale data, so pointing it at an empty directory takes away every locale
-  # that needs a locale archive -- `en_US.UTF-8` among them -- while leaving `C.UTF-8`
-  # working, because glibc 2.35 and later compile that one into the library itself.
-  # The suite then runs in an environment where the value shipped before #1681 fails
-  # and the value shipped now passes: no container image, no second bundle install,
-  # no cache miss. Measured on ubuntu:24.04 (glibc 2.39, the runner's base) with
-  # `en_US.UTF-8` generated first:
-  #
-  #   normal         en_US.UTF-8 charmap=UTF-8           C.UTF-8 charmap=UTF-8
-  #   LOCPATH=empty  en_US.UTF-8 charmap=ANSI_X3.4-1968  C.UTF-8 charmap=UTF-8
-  #
-  # This has to be a property of the run rather than of a spec. Never gate a spec on
-  # whether the pinned locale loads: such a spec skips itself in exactly the
-  # environments where this defect lives, which is how the defect went unreported for
-  # eighteen months.
-  #
-  # LANG is set explicitly so only `en_US.UTF-8` is taken away and the ambient
-  # environment stays UTF-8. The runner already sets this value; pinning it here keeps
-  # the job from depending on the image's default.
-  missing-locale:
-    name: Missing en_US.UTF-8 Locale
-
-    # Skip this job if triggered by a release PR
-    if: >-
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
-
-    runs-on: ubuntu-latest
-
-    env:
-      LANG: C.UTF-8
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v6
-
-      # Exported through GITHUB_ENV rather than set at job scope because the `runner`
-      # context is not available there, and the directory has to exist before anything
-      # reads a locale -- glibc warns on every process when LOCPATH names a directory
-      # that does not exist. RUNNER_TEMP rather than the workspace so that
-      # actions/checkout cannot clean it away.
-      - name: Point LOCPATH at an Empty Directory
-        run: |
-          mkdir -p "$RUNNER_TEMP/empty-locale-dir"
-          echo "LOCPATH=$RUNNER_TEMP/empty-locale-dir" >> "$GITHUB_ENV"
-
-      # Ruby 3.4 to share the bundler cache the lint job already warms. Nothing about
-      # this job is Ruby-version specific -- the locale environment is what differs.
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "3.4"
-          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-
-      # Guard against a vacuous pass, functionally. `locale -a` still lists en_US.utf8
-      # under LOCPATH (measured) even though setlocale then refuses it, so asking git
-      # to match is the only assertion worth making: `.` spans the two-byte U+00C4 only
-      # under a UTF-8 ctype. The metacharacter-free control has to keep matching under
-      # the removed locale as well -- it matches bytes under any ctype, so if it fails,
-      # the probe never delivered UTF-8 bytes to git and the rest proves nothing.
-      - name: Verify the Run Discriminates
-        run: |
-          dir="$(mktemp -d)"
-          cd "$dir"
-          git init -q .
-          printf '\xc3\x84PFEL sind gut\n' > w.txt
-          git add w.txt
-
-          if ! LC_ALL=C.UTF-8 git grep -q '^.PFEL' -- w.txt; then
-            echo "::error::C.UTF-8 no longer yields a UTF-8 ctype under LOCPATH, so this job would fail for the wrong reason"
-            exit 1
-          fi
-          if ! LC_ALL=en_US.UTF-8 git grep -q 'PFEL sind' -- w.txt; then
-            echo "::error::the control pattern did not match, so this probe is not delivering UTF-8 bytes to git"
-            exit 1
-          fi
-          if LC_ALL=en_US.UTF-8 git grep -q '^.PFEL' -- w.txt; then
-            echo "::error::en_US.UTF-8 still yields a UTF-8 ctype, so this job cannot detect a wrong LC_ALL pin"
-            exit 1
-          fi
-          echo "en_US.UTF-8 is unusable and C.UTF-8 works: a wrong pin fails this job"
-
-      # The whole suite rather than the non-ASCII regex spec alone: the point is that
-      # this run is indistinguishable from any other except for the missing locale, so
-      # every locale-sensitive surface added later is covered without touching this
-      # file. It also keeps the coverage gate satisfied, which a single spec file
-      # cannot do.
-      - name: Run Specs
-        run: bundle exec rake spec
-        timeout-minutes: 15

data/.github/workflows/enforce_conventional_commits.yml

@@ -1,35 +0,0 @@
----
-name: Conventional Commits
-
-permissions:
-  contents: read
-
-on:
-  pull_request:
-    branches:
-      - main
-      - 4.x
-
-# Cancel an in-progress run when the same PR gets a new push; only the commit messages
-# as they stand after the latest push are worth linting.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  commit-lint:
-    name: Verify Conventional Commits
-
-    # Skip this job if this is a release PR
-    if: (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with: { fetch-depth: 0 }
-
-      - name: Check Commit Messages
-        uses: wagoid/commitlint-github-action@v6
-        with: { configFile: .commitlintrc.yml }