markdown-prose-hooks 0.0.1__tar.gz

markdown_prose_hooks-0.0.1/.codespellrc

@@ -0,0 +1,57 @@
+[codespell]
+# codespell earns its place next to typos for exactly one dictionary. Measured on this
+# tree at the time this file landed: `clear,rare,usage` finds nothing typos does not
+# already gate, and adding `en-GB_to_en-US` finds eight. typos does not do dialect
+# conversion at all -- it corrects misspellings, and a British spelling is not one -- so
+# nothing else here would ever catch them. The wider two are kept anyway because they
+# cost nothing measurable on this tree and this repository is mostly prose, which is
+# where `rare` and `usage` earn out.
+#
+# The net is not complete, and the gap is worth knowing rather than rediscovering. The
+# dictionary carries a base form and its plural but not every inflection, and it does
+# not split identifiers -- so a past participle, a prefixed form, or a British spelling
+# inside a name such as `test_a_dispatch_is_honoured` passes clean. This gates the easy
+# majority; it does not retire the need for a person.
+builtin = clear,rare,usage,en-GB_to_en-US
+# Load-bearing, not decorative. codespell skips dotfiles and dotted directories by
+# default, which here means all of .github/ plus .git-blame-ignore-revs -- six of the
+# eight findings in the sweep that preceded this file. Without this line the hook lands
+# green over the bulk of what it is meant to read.
+check-hidden = true
+# `Nd` is the Unicode general category of decimal digits, which is what Python's `\d`
+# selects and what the Rust port has to reproduce; _typos.toml carries the same
+# exemption for the same reason. This list is case-sensitive -- verified, not assumed:
+# `Nd` is spared while the lowercase form still blocks, which is what keeps the
+# exemption to the category name without also excusing a typo for "and".
+ignore-words-list = Nd
+# Globs, not directory prefixes: codespell matches each entry against the basename and
+# against the path as a glob, so a bare `corpus/cli` silently matches nothing. The
+# leading `*` is load-bearing too, and is why these are not written `corpus/cli/*`:
+# pre-commit passes `corpus/cli/...` while a shell `codespell .` walks to
+# `./corpus/cli/...`, and only a pattern indifferent to the prefix covers both. The
+# corpus entries are belt-and-braces -- the `exclude:` in .pre-commit-config.yaml
+# already keeps every tier of it away from the hook -- and what they buy is a bare
+# `codespell` run free of decode warnings from the deliberately non-UTF8 fixture under
+# corpus/cli/. `corpus/README.md` is prose about the corpus and stays in scope,
+# matching the other four engines.
+#
+# .gitignore is generated by concatenating community templates, and its .NET
+# boilerplate trips this twelve times: package-manager names, and the word fragments a
+# split bracket expression leaves behind. They are described rather than quoted, and
+# that is the finding worth keeping -- a spell-check config that names a false positive
+# contains one, and there is no single directive that buys silence from both gates on
+# this tree. codespell wants a bare `codespell:ignore` as the last thing on the line
+# (the word-list form `codespell:ignore a,b` is unrecognized, and reads its own words
+# as prose, so the line flags twice rather than none), while typos wants
+# `spellchecker:disable-line` in that same final position. Describing beats quoting.
+# Not ours to correct either way, which is the same call _typos.toml makes.
+#
+# CHANGELOG.md is preemptive: none ships yet, but cliff.toml means one will, and it is
+# generated from commit messages already gated by gitlint.
+#
+# Unlike the typos hook above it in .pre-commit-config.yaml, this needs no duplicate
+# `exclude:` there. That hook repeats its exclusion because typos treats `[files]
+# extend-exclude` as file-discovery config and pre-commit hands it an explicit list
+# instead. codespell's `skip` does apply to explicitly-passed filenames -- verified --
+# so this file is the only place the rule is written.
+skip = uv.lock,.git,.venv,.gitignore,CHANGELOG.md,*corpus/cases/*,*corpus/cli/*

markdown_prose_hooks-0.0.1/.git-blame-ignore-revs

@@ -0,0 +1,6 @@
+# Reformats only. Skipped by `git blame` so a line points at the change that
+# wrote it rather than at the pass that requoted it. GitHub honors this file
+# automatically; locally it needs `blame.ignoreRevsFile`, which `make develop`
+# sets.
+33b7cc6809cd23e9110dfe507e5201f7f8c2e0cb  # style: single-quote the TOML in pyproject
+47b72dc10e4724f3a2ab56a69e615dcbfa79e01a  # style: format Python with single quotes

markdown_prose_hooks-0.0.1/.gitattributes

@@ -0,0 +1,50 @@
+# List any file patterns that are text and should have line endings
+# normalized, i.e. convert crlf => lf
+.dockerignore   text
+.editorconfig   text
+.gitattributes  text
+.gitignore      text
+.project        text
+.yamllint       text diff=yaml eol=lf
+*.cfg           text
+*.conf          text
+*.csv           text eol=lf
+*.css           text diff=css
+*.htm           text diff=html
+*.html          text diff=html
+*.java          text diff=java
+*.js            text
+*.json          text
+*.jsp           text
+*.md            text diff=markdown
+*.php           text diff=php
+*.properties    text
+*.py            text eol=lf diff=python
+*.pyi           text eol=lf diff=python
+*.rs            text eol=lf diff=rust
+*.sh            text eol=lf diff=bash
+*.sql           text
+*.tf            text
+*.toml          text
+*.ts            text
+*.txt           text
+*.xml           text
+*.yaml          text
+*.yml           text
+CODEOWNERS      text
+Dockerfile      text
+
+*.gif  filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.jpg  filter=lfs diff=lfs merge=lfs -text
+*.png  filter=lfs diff=lfs merge=lfs -text
+
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+corpus/cases/**/*.md -text -diff
+
+# The CLI tier for the same reason, widened from `*.md` to the whole subtree:
+# its `case.txt` and `stdout.txt` are asserted byte for byte alongside the
+# fixtures, and a case pinning CRLF stops pinning anything once git normalizes
+# it on checkout.
+corpus/cli/** -text -diff

markdown_prose_hooks-0.0.1/.github/dependabot.yml

@@ -0,0 +1,85 @@
+---
+# Two ecosystems, not three. There is deliberately no `pre-commit` entry: pre-commit.ci
+# is installed on this repository and its `autoupdate_schedule` accepts only weekly,
+# monthly or quarterly -- no value stands it down -- so it raises hook bumps whatever
+# this file says. Adding the ecosystem would duplicate those pull requests rather than
+# replace them, and two bots opening the same bump is worse than either owning it.
+# .pre-commit-config.yaml sets that cadence; bot-automerge.yml arms both authors.
+version: 2
+updates:
+  # Nothing here is a runtime dependency: `dependencies = []`, and the lock file covers
+  # the dev group alone -- pytest, pytest-cov, ruff. A bump cannot reach a repository
+  # that installs this hook, only the test run that would catch it, so patch and minor
+  # ride on green CI and a major waits for a person.
+  #
+  # For ruff that split does almost no work, and saying so is the honest version. Ruff
+  # is on 0.x, where a breaking release lands as 0.16 -> 0.17 and Dependabot types it
+  # `semver-minor`, so the major hold will not fire until 1.0 -- and ruff decides this
+  # repository's formatting, which is the one dev dependency whose bump arrives as a
+  # diff rather than as a passing build. The `default-days` below is what actually
+  # covers it: a soak on every update, not only the class that never occurs.
+  #
+  # Both keys, deliberately. `semver-major-days` alone left the soak on the class this
+  # repository already holds for a human, while the updates that merge unattended --
+  # polled daily -- had none at all, which is the threat model backwards.
+  - package-ecosystem: uv
+    directory: /
+    schedule:
+      interval: daily
+    groups:
+      uv-major:
+        update-types: [major]
+      uv-minor-patch:
+        update-types: [minor, patch]
+    cooldown:
+      semver-major-days: 30
+
+  # Actions here ride a floating major tag wherever upstream publishes one, so Dependabot
+  # raises a pull request only when a major moves. Holding majors -- the obvious policy,
+  # and the one the sibling repositories started with -- would therefore hold nearly every
+  # actions pull request this repository ever receives. That is an outage, not a policy.
+  # The cooldown below is what replaces the hold, and the two are a matched pair:
+  # bot-automerge.yml arms actions majors, and this delay is the only soak period between
+  # a release being published and it merging here unattended.
+  #
+  # Three pins do not float, and `grep -rn 'uses:' .github/workflows` lists them rather
+  # than this comment counting them. `astral-sh/setup-uv` is pinned exactly because
+  # upstream stopped publishing major tags at v8, which makes it the one action whose
+  # patch and minor releases show up here; CI.yml carries that reasoning at the pin
+  # itself. `dtolnay/rust-toolchain` carries the declared MSRV rather than a version to
+  # bump, which is what the `ignore:` entry below is for. `pypa/gh-action-pypi-publish`
+  # is used through the `release/v1` branch upstream documents, so it has no major tag
+  # to follow.
+  #
+  # Still no cargo ecosystem, for the reason there is no runtime Python one: the
+  # Rust crate declares no dependencies either, so the entry would poll a lock
+  # file that only ever records the crate itself.
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: cron
+      cronjob: '0 0 1,15 * *' # 1st and 15th monthly at midnight UTC
+    groups:
+      actions:
+        patterns: ['*']
+    ignore:
+      # `dtolnay/rust-toolchain@1.86.0` is not a dependency held at a version --
+      # the version *is* the declared MSRV, matching `rust-version` in
+      # Cargo.toml. Dependabot reads the tag as semver and would raise it to the
+      # newest release, and bot-automerge.yml arms actions updates, so the floor
+      # this repository promises could rise unattended and untested. Raising it
+      # is a decision with a changelog entry, taken in both files at once.
+      - dependency-name: dtolnay/rust-toolchain
+    cooldown:
+      # `default-days` only. GitHub rejects the `semver-*` keys for this ecosystem --
+      # "not supported for the package ecosystem 'github-actions'" -- and an invalid key
+      # here does not degrade gracefully: it invalidates the file and drops this whole
+      # entry, grouping included. Nothing local catches that. The published schema admits
+      # the key in a cooldown block generally and the ecosystem restriction is enforced
+      # server-side, so the file lints clean and fails in the Dependabot tab.
+      #
+      # One number therefore covers every actions update, which is the right net anyway:
+      # these packages execute with this repository's own token inside jobs holding
+      # contents and pull-requests write, and a patch is not safer than a major when the
+      # risk is a compromised publisher rather than a changed interface.
+      default-days: 30

markdown_prose_hooks-0.0.1/.github/workflows/CI.yml

@@ -0,0 +1,234 @@
+---
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+# `astral-sh/setup-uv` is pinned to an exact version where most of the actions here ride
+# a floating major tag, and that asymmetry is upstream's rather than a slip here: v8
+# stopped publishing major and minor tags outright, citing the tj-actions compromise, so
+# `@v9` is not a ref that exists. The exact pin is what its release notes prescribe.
+#
+# The consequence worth knowing is for dependabot.yml: this is the one action whose patch
+# and minor releases raise a pull request. The floating majors move only on a major;
+# `dtolnay/rust-toolchain` is held out there because its version is the declared MSRV, as
+# the comment above `rust-lint` says; and `pypa/gh-action-pypi-publish` in release.yml
+# follows upstream's `release/v1` branch.
+#
+# Also from v9: `prune-cache` now defaults to false. Left at the new default -- with
+# `dependencies = []` there is next to nothing to prune, so the cache this grows is small
+# enough that the repository limit is not in play.
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v9.0.0
+        with:
+          enable-cache: true
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # Every supported interpreter on Linux, plus the floor and the ceiling on
+        # macOS and Windows. Windows earns its place here rather than being taken
+        # on trust: this tool decides what a line ending is, and that is the one
+        # platform where getting it wrong rewrites every file it touches.
+        os: [ubuntu-latest]
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+        include:
+          - os: macos-latest
+            python-version: '3.10'
+          - os: macos-latest
+            python-version: '3.13'
+          - os: windows-latest
+            python-version: '3.10'
+          - os: windows-latest
+            python-version: '3.13'
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v9.0.0
+        with:
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+      - run: uv run --python ${{ matrix.python-version }} python -m pytest -q
+
+  coverage:
+    # One upload on Ubuntu is enough: the suite is interpreter-agnostic Python, and
+    # Codecov merges flags rather than needing a matrix of identical reports.
+    #
+    # `use_oidc` rather than an upload token, for the reason release.yml prefers
+    # Trusted Publishing: a long-lived secret in a repository that needs none is
+    # a liability with no offsetting convenience. Codecov refuses an anonymous
+    # upload outright -- "Token required - not valid tokenless upload" -- so this
+    # is the only authentication left that stores nothing, and `id-token: write`
+    # is what mints the assertion it checks. The permission is granted on this
+    # job alone; the workflow default above stays read-only.
+    #
+    # `fail_ci_if_error` is on because the alternative had already happened: with
+    # it off, every upload since the badge was added was refused for want of a
+    # token while this job reported success, so the only place the failure showed
+    # was the badge reading "unknown". This job is not a required context, so a
+    # Codecov outage is visible here without blocking a merge.
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    env:
+      COVERAGE_REPORT: coverage.xml
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 2 # fetch-depth of 2 enables diff coverage
+      - uses: astral-sh/setup-uv@v9.0.0
+        with:
+          enable-cache: true
+          python-version: '3.13'
+      - run: uv run python -m pytest --cov --cov-report=xml -q
+      - uses: codecov/codecov-action@v7
+        with:
+          files: ${{ env.COVERAGE_REPORT }}
+          fail_ci_if_error: true
+          use_oidc: true
+
+  hook:
+    # Resolving the hook through the framework is the only check that reads
+    # `.pre-commit-hooks.yaml` the way a consumer does; the console script passing
+    # says nothing about whether the hook definition is valid.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: '3.13'
+      - run: python -m pip install --disable-pip-version-check pre-commit
+      # `--all-files`, with no list to build and nothing to keep in step. The tool
+      # reads `.unwrapignore` itself, so the exclusion reaches this caller exactly as
+      # it reaches `pre-commit run` and the action -- which is what `exclude:` could
+      # never do here, since try-repo builds its config from `.pre-commit-hooks.yaml`
+      # and never reads `.pre-commit-config.yaml`.
+      - run: pre-commit try-repo . unwrap-markdown-prose-py --all-files --verbose
+      - run: pre-commit try-repo . unwrap-markdown-prose-py-check --all-files --verbose
+      # The Rust pair resolves through the same framework, and `language: rust`
+      # builds it from source -- which is the install cost the README tells a
+      # consumer about, exercised here rather than asserted.
+      - uses: dtolnay/rust-toolchain@1.86.0
+      - run: pre-commit try-repo . unwrap-markdown-prose-rs --all-files --verbose
+      - run: pre-commit try-repo . unwrap-markdown-prose-rs-check --all-files --verbose
+
+  action:
+    # The composite action shares no code path with the hook beyond the CLI, so a
+    # green `hook` job does not cover it.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      # No `paths`: the action's default sweep is every tracked Markdown file, and
+      # the tool now drops the corpus from that list on its own. Letting the default
+      # run is the stronger test anyway -- it exercises the path a consumer takes.
+      - name: Run the action against this repository
+        uses: ./
+        with:
+          write: 'false'
+          fail-on-change: 'true'
+
+  # The toolchain is pinned to the MSRV rather than to `stable`, so a language
+  # feature newer than `rust-version` in Cargo.toml fails here rather than in a
+  # consumer's `cargo install`. The two have to move together, which is why
+  # dependabot.yml holds this action out of its actions group.
+  #
+  # No build cache on either job. `[dependencies]` is empty and stays that way,
+  # so a cold compile is a couple of seconds -- less than restoring a cache
+  # would cost, and one fewer action running with this repository's token.
+  rust-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@1.86.0
+        with:
+          components: rustfmt, clippy
+      - run: cargo fmt --check
+      - run: cargo clippy --all-targets -- -D warnings
+
+  rust-test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # The same three platforms the Python matrix uses, for the same reason:
+        # this tool decides what a line ending is, and Windows is where getting
+        # that wrong rewrites every file it touches. The corpus is checked out
+        # verbatim there -- `.gitattributes` marks it `-text` -- so a case
+        # pinning CRLF pins it on every runner.
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@1.86.0
+      - run: cargo test
+
+  parity:
+    # The CLI tier over both implementations. It is its own job rather than a
+    # step on `test` because it needs a Rust toolchain, and rather than a step on
+    # `rust-test` because it needs an interpreter: the harness that drives both
+    # binaries is the Python one.
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@1.86.0
+      - uses: astral-sh/setup-uv@v9.0.0
+        with:
+          enable-cache: true
+      - run: cargo build --release
+      # `_runners()` skips the Rust binary when it is absent, so that a
+      # Python-only checkout still runs the tier. Here that skip would turn a
+      # failed build into a silent half-run reported as a pass, so the harness is
+      # told to fail instead.
+      - run: uv run python -m pytest tests/test_cli_corpus.py -q
+        env:
+          REQUIRE_RUST_BINARY: '1'
+      # The enumerated tier says the two implementations agree about what was
+      # anticipated; only this says anything about what was not. The fixed range
+      # is a regression net *only while the generator is frozen* -- any edit to
+      # its fragment bank renames every seed -- so a fresh range derived from the
+      # run number rides along and keeps exploring. A divergence worth keeping
+      # becomes a corpus case, never a seed number.
+      - name: Fuzz both implementations differentially
+        shell: bash
+        run: |
+          python="$(uv run python -c 'import sys; print(sys.executable)')"
+          cargo run --release --quiet --example fuzz -- \
+            --start 1 --count 400 --python "$python -m markdown_prose_hooks"
+          cargo run --release --quiet --example fuzz -- \
+            --start $(( ${{ github.run_number }} * 400 + 100000 )) --count 200 \
+            --python "$python -m markdown_prose_hooks"
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v9.0.0
+        with:
+          enable-cache: true
+      - run: uv build
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/

markdown_prose_hooks-0.0.1/.github/workflows/bot-automerge-disarm.yml

@@ -0,0 +1,107 @@
+---
+name: Bot auto-merge disarm
+
+# The half that makes arming defensible. bot-automerge.yml arms GitHub's native
+# auto-merge with no human action, and that has to be revocable: a label that cannot
+# take the merge back is a one-way door, and the margin it removes is the one a mistake
+# needs.
+#
+# Gating the arming job on the label is not enough. Once auto-merge is enabled it lives
+# server-side, so a label applied afterwards stops the workflow from running again while
+# GitHub still merges the moment requirements pass. Something has to actively turn it
+# off.
+#
+# No branch filter and no fork guard, deliberately. A suppressor must be at least as
+# broad as the thing it suppresses, and disarming a pull request that was never armed is
+# a no-op -- so the cheap failure is running when it need not, and the expensive one is
+# declining to run when it should. A `branches:` filter in particular would mean a pull
+# request retargeted after arming kept its armed state and lost its switch.
+
+on:
+  pull_request:
+    types: [labeled]
+
+# `pull-requests: write` alone. This job never checks out and never writes a ref -- it
+# reads pull request state and calls `disablePullRequestAutoMerge` -- so the
+# `contents: write` its sibling needs to complete a merge grants real authority here for
+# no reader. Declaring this block sets every unlisted scope to `none`, which is the
+# point: the suppressor should not be able to do more than suppress.
+permissions:
+  pull-requests: write
+
+concurrency:
+  # Keyed on the label as well as the number, and not canceled in flight: a disarm must
+  # not be superseded by a different label event arriving on the same pull request.
+  # Setting cancel-in-progress here would mean labeling twice in quick succession could
+  # cancel the disarm and leave the pull request armed.
+  group: bot-automerge-disarm-${{ github.event.pull_request.number }}-${{ github.event.label.name }}
+  cancel-in-progress: false
+
+jobs:
+  disarm:
+    # Case-insensitive already, and deliberately left as a bare `==`. Expression string
+    # comparison ignores case -- "GitHub ignores case when comparing strings" -- so
+    # "Do Not Auto-Merge" reaches this job just as the lowercase spelling does, which is
+    # what it has to do: GitHub treats label names as unique case-insensitively, so the
+    # two are one switch to a human. Recorded because it reads like a bug and has already
+    # been reported as one; the usual suggested repair, `toLower(...)`, is not a function
+    # Actions has. The shell in bot-automerge.yml matches with `grep -qixF` instead
+    # because that check runs in bash, where the case-folding is not free.
+    if: github.event.label.name == 'do not auto-merge'
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    env:
+      GH_TOKEN: ${{ github.token }}
+      GH_REPO: ${{ github.repository }}
+      PR_NUMBER: ${{ github.event.pull_request.number }}
+    steps:
+      # Fails closed, which is the property to preserve if this is ever edited. The
+      # tempting shape -- read the label back, and disable only when the answer is `true`
+      # -- inverts the guard: a swallowed read then reports "the label is absent", skips
+      # the disable, and leaves the pull request armed with its kill switch applied. A
+      # swallowed read on a guard removes the guard rather than relaxing it, so there is
+      # no `2>/dev/null` and no `|| false` anywhere below.
+      #
+      # Verified rather than trusted: each attempt re-reads whether auto-merge is still
+      # on, so a `--disable-auto` that reported success without taking effect is caught.
+      - name: Disarm auto-merge
+        run: |
+          # An unreadable state falls through to the disarm loop rather than exiting, so
+          # the fallback here is the safe direction. Only a confirmed CLOSED or MERGED
+          # short-circuits, because those are the two states where there is nothing to
+          # disarm and the loop would spin for no reason.
+          state=$(gh pr view "$PR_NUMBER" --json state --jq .state || echo "")
+          if [ "$state" = "CLOSED" ] || [ "$state" = "MERGED" ]; then
+            echo "::notice::PR #${PR_NUMBER} is ${state}; nothing to disarm."
+            exit 0
+          fi
+          for attempt in 1 2 3; do
+            # stderr stays visible on purpose: this probe is allowed to fail, because the
+            # disable below runs regardless, but a silent failure would hide why a disarm
+            # needed three attempts.
+            armed=$(gh pr view "$PR_NUMBER" --json autoMergeRequest \
+              --jq '.autoMergeRequest != null') || armed=""
+            if [ "$armed" = "false" ]; then
+              echo "::notice::Auto-merge is off on PR #${PR_NUMBER}."
+              exit 0
+            fi
+            # Attempt the disable whenever "off" was not positively confirmed, which
+            # includes the probe having failed and left $armed empty. Only confirmed-off
+            # exits above. Gating this on "true" would mean a transient error skipped the
+            # attempt entirely and left the pull request armed -- the outcome this
+            # workflow exists to prevent.
+            gh pr merge --disable-auto "$PR_NUMBER" || true
+            echo "::warning::attempt ${attempt}: auto-merge not yet confirmed off on #${PR_NUMBER}."
+            sleep 5
+          done
+          # One last read: the loop disables on its final pass and then falls straight
+          # through, so without this a disarm that worked on attempt three still reports
+          # failure and pages somebody to do what has already been done.
+          if [ "$(gh pr view "$PR_NUMBER" --json autoMergeRequest \
+              --jq '.autoMergeRequest != null')" = "false" ]; then
+            echo "::notice::Auto-merge is off on PR #${PR_NUMBER}."
+            exit 0
+          fi
+          echo "::error::Could not confirm auto-merge is off on #${PR_NUMBER}. Disable it by hand:"
+          echo "::error::gh pr merge --disable-auto ${PR_NUMBER} --repo ${GH_REPO}"
+          exit 1