[brettheap]

Lane: openreposhape-5 (openRepoShape-5)
Claim: #672 (comment)

bump-leg.py read the root's branch with --short, printed a push line that + could turn into a forced push, printed control characters from file names raw, listed paths the commit did not hold, and said nothing about the validators a dry run skips. Each of #672's five lines was measured on main 35133f29 with a scaffolded project and local bare remotes, and each is gone on this head. One file of code changes: scripts/bump-leg.py.

Fix round: #723 merged in (4a014a79)

This branch now holds #723 (#663, fix/663-non-utf8-name-tests, head 6ba8c5d2) and is stacked on it. #723 lands first. Until then this PR's diff against main also shows #723's six test files. Once #723 lands, the PR is retargeted and restacked, and its own diff is #672's again.

One new commit, a merge commit: 4a014a79 merges 6ba8c5d2 into a5d473ee. It changes no tool code. scripts/bump-leg.py is byte for byte the same as at a5d473ee.

The conflict

The two PRs both changed one assertion in tests/test_non_utf8_git_reads.py::test_a_name_that_is_utf8_under_quote_path_false_is_still_refused:

• bump-leg.py: the branch is read in full and pushed as refs/heads/<b>:refs/heads/<b>, dirty names are spelled, committed lists what git holds, and the dry run says it runs no validator (#672) #746 changed its prefix from four spaces and M to five spaces and M, because bump-leg.py: a root on +x is told push -u origin +x (forced), a branch named like a tag passes bump-leg-on-tracking-branch, bump-leg-root-dirty prints C1 controls raw, and committed <sha>: lists paths the commit lacks #672 keeps the leading space of git's M.
• tests: one skip helper for names and branches that are not UTF-8, Windows guards on make_file and the --branch a\udcffb test by emulation, and the UTF-8 promise and the leg finding's role pinned (#663) #723 rewrote the same any(...) as [shown] = [...] and assert shown.endswith(".yml"), then added a closing assert_shown_without_hex_escapes(shown, output). That check fails if bump-leg.py decodes git's bytes as ASCII.

The resolution keeps #723's form and uses #746's five-space prefix. Neither side alone works here:

Taken as is	Result on the merge
the resolution	2 passed
#723's line (four spaces)	2 failed: ValueError: not enough values to unpack (expected 1, got 0); #672's output has no such line
#746's any(...)	2 passed, but the hex-escape check is gone
the resolution, with bump-leg.py decoding as ASCII	2 failed: assert '\\x' not in ' M .git...xc3\\xa9.yml'
#746's any(...), with bump-leg.py decoding as ASCII	2 passed: the mutant is missed

Every other hunk merged the way git merged it.

Every test of each side stands

Test functions per file, before and after the merge:

File	#746	#723	merge
tests/test_non_utf8_git_reads.py	14	19	19
tests/test_bootstrap_branch_bytes.py	15	18	18
tests/test_non_utf8_name_helpers.py	(none)	12	12
tests/test_adopt_pins.py	44	44	44
tests/test_pin_source_unreadable.py	13	13	13

#723's names include all of #746's, and every one is in the merge. The merge holds #723's other five files exactly as #723 has them. In tests/test_non_utf8_git_reads.py it differs from #723 only in #746's three hunks.

#723's helper tests feed assert_shown_without_hex_escapes three made-up lines. Those lines still start with four spaces, because they are the helper's input, not the tool's output.

Each side's half is needed (tests/test_non_utf8_git_reads.py has 52 tests):

• The merged file run against tests: one skip helper for names and branches that are not UTF-8, Windows guards on make_file and the --branch a\udcffb test by emulation, and the UTF-8 promise and the leg finding's role pinned (#663) #723's bump-leg.py, from before bump-leg.py: a root on +x is told push -u origin +x (forced), a branch named like a tag passes bump-leg-on-tracking-branch, bump-leg-root-dirty prints C1 controls raw, and committed <sha>: lists paths the commit lacks #672: 7 failed, 45 passed.
• tests: one skip helper for names and branches that are not UTF-8, Windows guards on make_file and the --branch a\udcffb test by emulation, and the UTF-8 promise and the leg finding's role pinned (#663) #723's version of the file run against this branch's bump-leg.py: 7 failed, 45 passed.

In both runs the 7 failures are the tests that read the dirty list:

• the two refused_dirty tests, in both modes;
• the resolved test, in both modes;
• test_the_refusal_names_every_dirty_file_whatever_its_bytes.

Tests on the merge

Run on the tree 4f4fed60, which is the tree of 4a014a79:

• tests: one skip helper for names and branches that are not UTF-8, Windows guards on make_file and the --branch a\udcffb test by emulation, and the UTF-8 promise and the leg finding's role pinned (#663) #723's files, the helpers file and the trio: tests/test_non_utf8_git_reads.py, test_non_utf8_name_helpers.py, test_adopt_pins.py, test_bootstrap_branch_bytes.py, test_pin_source_unreadable.py, test_repo_hygiene.py, test_agents_md_codes.py and test_cli_reference.py. Result: 504 passed.
• The bump-leg files and the files that import test_bump_leg: every tests/test_bump_leg*.py (eight files), plus test_branch_left_bump_leg_setup.py, test_family_switch_branch_exists.py, test_update_shape_paste_lines.py, test_validate_pins_unreadable_workflows_dir.py and test_bootstrap_after_bump.py. Result: 364 passed, 1 skipped. The skip needs a disk that ignores case.

Merge checks

git merge-tree --write-tree of the merge:

• origin/main 24a977c0: clean.
• every remote fix/* and l3-* branch: clean, except fix/758-git-command-scope (b6e15591), which conflicts in tests/test_non_utf8_git_reads.py. That conflict comes from tests: one skip helper for names and branches that are not UTF-8, Windows guards on make_file and the --branch a\udcffb test by emulation, and the UTF-8 promise and the leg finding's role pinned (#663) #723: 6ba8c5d2 conflicts with b6e15591 on its own, and a5d473ee does not.

What changed, and why

1. The branch is read in full. current_branch ran git symbolic-ref --short HEAD. Beside a tag of the same name that prints heads/<b>.
   • Measured on main: with a tag main beside the tracking branch main, bump-leg-on-tracking-branch was not given. The bump committed on main and printed push -u origin heads/main.
   • A HEAD on refs/tags/x was read as the branch x, and the bump committed through the tag and moved it.
   • Now the full ref is read and refs/heads/ is taken off. A ref outside refs/heads/ is no branch, so that root is refused bump-leg-root-detached.
2. The push line names the branch on both sides. NEXT ended push -u origin <branch>. A bare branch name is a refspec, and a leading + means force.
   • Measured on main: a root on +x was told push -u origin +x. Pasted, it printed + e124684...c8932ad x -> x (forced update) and never pushed +x.
   • On +main, pasted, it printed + a6b763e...c8932ad main -> main (forced update): origin's default branch was rewound.
   • Now the line is push -u origin refs/heads/<b>:refs/heads/<b>. Measured: +x and +main push as new branches and leave origin's x and main where they were. v1 beside a tag v1 pushes too, where git's own bare v1 fails with src refspec v1 matches more than one. -u still records origin/<b>.
3. bump-leg-root-dirty spells each name. Under core.quotePath=false git prints a file name as its raw bytes. On main a tracked, edited caf<U+009B><U+202E>evil.yml went to stderr as the raw bytes 302 233 342 200 256.
   • Each listed line now goes through repo_shape.spelled, so this one shows as caf\x9b\u202eevil.yml.
   • The answer is now split on \n only. splitlines() also broke a name at U+0085 and U+2028, and strip() dropped one from the end of the last name.
4. committed lists what the commit holds, and no X -> X.
   • The line printed the staged list, and the leg is always staged. Measured on main: after a person moved the gitlink by hand and committed, it printed committed ...: spec, contracts/spec-pin.yaml while the commit held only the pin. The report and the commit message both said 52b767b3490a -> 52b767b3490a.
   • Now the paths come from git diff-tree --no-commit-id --name-only -r -z --ignore-submodules=none <sha>. Each name is passed through spelled, like the dirty list.
   • Where the gitlink already holds the new commit, the commit line and the message name the pin's own commit: as the old commit. A gitlink line, and a sentence in the message, say the gitlink does not move.
   • was is still what the rollback restores.
   • The listing runs after the commit has landed, so a failure there prints a sentence pointing at git show --name-only --ignore-submodules=none <sha> (since the fix round) and the run still exits 0. Before, a git-failed refusal would have exited 2 and implied the bump never landed.
5. The dry run says it runs no validator. Its closing paragraph now says that a dry run does not run scripts/validate-pins.py or scripts/validate-manifest.py, and that the real run can still end bump-leg-validators-red, rolled back. Behaviour is unchanged, as the issue recommends. The cmd_bump docstring said the dry run refuses everything the real run refuses; it now names this one exception.

Also: the BRANCH_LEFT comment said "the three tools follow one rule". It now names the four copies: family.py, the holder's validate-family.py, setup-project.py and this one (rv647's nit 3).

Decisions and their evidence

• The push form is refs/heads/<b>:refs/heads/<b>, not refs/heads/<b> alone. The issue allows either. Lane 4's branches print the both-sides form: fix/689-next-push-refspec (fa513848) for family.py's NEXT, and fix/674-update-shape-apply (d0699029) through _full_refspec. The brief asks this PR to match their form, so all three tools print one form. Both forms were measured to push +x, +main and v1 correctly and to set the upstream.
• diff-tree rather than git show for the committed list. Measured on git 2.43:
  • git show --name-only drops the gitlink under diff.ignoreSubmodules=all. diff-tree is plumbing and ignores that setting.
  • Plain diff-tree also drops the gitlink under submodule.spec.ignore=all. --ignore-submodules=none overrides it.
  • The bump itself still lands under both settings.
• The ride-along (the root's validator environment) is left as it is. The issue gives the choice. Measured on both trees, with the root's scripts/repo_shape.py deleted and committed:
  • With PYTHONPATH=<standard>/scripts, the gate prints FINDING shape-copy-missing: ... scripts/repo_shape.py is pinned but absent.
  • Without it, the gate prints ModuleNotFoundError.
  • Both runs exit 2 and roll back. No verdict changes, and -S with no PYTHONPATH would only swap the precise finding for a traceback.
• README.md:527 and AGENTS.md:339 are unchanged. They are placeholder recipes, git -C <path> push -u origin <branch>, right after the switch -c <branch> the person types. They stay true for the names people choose, no test ties them to the tool's printed line, and the README stays out of the README queue.
• docs/release-notes/v1.0.0.md lines 433 and 440 list two of these lines as v1.0.0 known limits. They describe v1.0.0 and are left alone; the v1.1.0 notes are lane 3's.
• No --help text changed, so docs/cli.md is unchanged, and tests/test_cli_reference.py passes.

Tests

New file tests/test_bump_leg_branch_and_push_line.py, 20 tests in the first round and 24 after the fix round (see Fix round):

• Branch: a tag main beside the tracking branch; a HEAD on a ref outside refs/heads/ (refs/tags/release-1 and refs/remotes/origin/main since the fix round).
• Push: +x and +main with origin's other branch moved on, each run as the printed argv; v1 beside a tag v1, with its upstream checked.
• Dirty list: four names (U+009B with U+202E, U+2028, U+0085, a name ending in U+2028), each under both the real run and --dry-run, plus a default-quoting control.
• committed line: checked plain and under submodule.spec.ignore=all and diff.ignoreSubmodules=all; the gitlink moved by hand, in both the dry and real runs; the line when git cannot list the paths.
• Dry run: a pin that validate-pins.py already refuses.

Tests that held the old form were updated:

• tests/test_bump_leg.py::test_the_message_and_the_next_step_are_a_pull_request
• tests/test_bump_leg_paste_lines.py: test_the_closing_next_is_one_command (3 params), test_an_ordinary_root_prints_the_line_it_always_did and test_the_closing_next_carries_the_branch_whole (3 params). Its paste tests still run the line through sh and check the remote.

Results:

• On main 35133f29: the new file gives 19 failed, 1 passed. The one pass is the default-quoting control, which is meant to pass there.
• The bump-leg set on this head 326de720: every tests/test_bump_leg*.py, plus tests/test_branch_left_bump_leg_setup.py and tests/test_non_utf8_git_reads.py. Result: 277 passed, 1 skipped.
• Every other test file that imports or drives bump-leg.py: tests/test_bootstrap_after_bump.py, test_repo_hygiene.py, test_agents_md_codes.py, test_cli_reference.py, test_doctor_gitlink_repairs.py, test_doctor_pin_restore_merges.py, test_doctor_unfinished_merge.py, test_family_switch_branch_exists.py, test_pin_rewrite_layout.py, test_stdout_encoding.py, test_template_text_placeholders.py, test_update_shape_paste_lines.py, test_validate_pins_lockstep_lines.py, test_validate_pins_unreadable_workflows_dir.py and test_validator_child_encoding.py. Result: 697 passed, 1 skipped.
  • That run started a minute before the last code edit, so the three files among them that read a NEXT or push line were run again on 326de720: 217 passed.
• The two skips are only for other platforms: one needs a case-ignoring disk, the other is about Windows' default encoding.

Mutation probes

One mutant of bump-leg.py per hunk. Each was run against the new file, and the two push mutants also against the paste-line tests. All 12 fail at least one test:

Mutant	Tests failed
--short restored	3: the tracking-tag, tag-ref and v1 tests
dirty list printed raw	8
spelled kept but splitlines() restored	6: the U+2028 and U+0085 names
the old commit is always was	1
no gitlink line	1
message uses was	1
staged list printed	5
no guard after the commit	1
no --ignore-submodules=none	1
dry-run sentence removed	1
bare branch in NEXT	12
one-sided refs/heads/<b> in NEXT	12

The comment and docstring hunks change no behaviour and have no mutant.

Merge checks

git merge-tree --write-tree of 326de720 is clean against:

• origin/main de926142, and 2fac9790;
• lane 4's fix/674-update-shape-apply (d0699029) and fix/689-next-push-refspec (fa513848);
• lane 5's fix/665-four-guards (151a0861), which also edits tests/test_bump_leg_paste_lines.py.

Main up to 2fac9790 changes repo_shape.git_out's refusal text (#610), but not spelled or pin_values_in, which this PR imports.

Left out

• No platform-specific behaviour was measured on Windows or macOS. The new tests run each printed line as the argv a POSIX shell reads from it, without a shell, and skip a file name the disk cannot hold.
• rv672's checklist candidates 1-3 (see Fix round) stay checklist candidates; this PR fixes none of them.

Fix round (rv672's review of 326de720)

One new commit, a5d473ee, on top of 326de720.

• S1: the test of a HEAD outside refs/heads/ is now parametrized over refs/tags/release-1 and refs/remotes/origin/main. With refs/tags/x it passed by coincidence even without the refs/heads/ guard, because refs/tags/x is as long as refs/heads/ and the leftover name was empty. rv672's mutant R1 (the guard removed) now fails both cases.
• S2: current_branch takes only git's newline off symbolic-ref's answer (rstrip("\n")). strip() also took a trailing U+00A0, U+2028 or U+0085 off the branch name. So a root on feat<U+00A0> beside a branch feat committed on the first and printed a push of the second. A new test puts feat<U+00A0> beside feat and runs the printed line: the bump commit reaches origin as feat<U+00A0>, and feat is not pushed.
• N1: _ensure_root_clean takes off only the last newline. The first line keeps git's leading space, so M no longer reads as M (staged) one column left of the lines under it. The dirty-list expectations in the new file and in tests/test_non_utf8_git_reads.py now read M ..., and a new test with two dirty files checks that both lines line up.
• N2: the committed fallback names git show --name-only --ignore-submodules=none <sha>.
• N3: where the gitlink already recorded the commit, the commit message no longer says the gitlink moves in that commit. It says the pin and the workflow references are brought to the gitlink in ONE commit, because scripts/validate-pins.py refuses when they disagree. The ordinary message is byte for byte what it was (checked by rendering both).
• N4: a new test moves the gitlink by hand with the pin's commit: set to not-a-sha. The commit line then names the gitlink's commit, never that text. rv672's mutant R2 (no COMMIT_RE check) now fails it.
• B1 and the body: this draft holds no raw control or bidi character. Every escape in it is ASCII text.
• rv672's checklist candidates 1-3 stay checklist candidates and are not part of this PR.

Fix-round tests, on the tree a5d473ee commits:

• The new file: 24 passed in 19.33s.
• The bump-leg set: every tests/test_bump_leg*.py, plus tests/test_branch_left_bump_leg_setup.py and tests/test_non_utf8_git_reads.py. Result: 281 passed, 1 skipped in 252.20s. The skip is the case-ignoring-disk test.

Fix-round mutants: all 18 of the final head fail at least one test. That is the 12 above, re-made on this head, plus R1, R2 and one each for S2, N1, N2 and N3:

Mutant	Tests failed
R1, no refs/heads/ guard	2
R2, _moved_from unchecked	1
S2 reverted (strip())	1
N1 reverted (strip(" \n"))	10
N2 reverted	1
N3 reverted	1

git merge-tree --write-tree of a5d473ee is clean against:

• origin/main 5c990708, and 2d988200 after it moved (rv672's verify round: clean, and the bump-leg set gives 331 passed, 1 skipped on the merge);
• fix/674-update-shape-apply (d0699029);
• fix/689-next-push-refspec (fa513848);
• fix/665-four-guards (151a0861).

Review. rv672 re-verified the fix round: APPROVE WITH NITS at a5d473ee, the nits being these body lines, now fixed. R1 fails both new cases and R2 fails the not-a-sha test; the bump-leg set gives 331 passed, 1 skipped on the head and on its merge with 2d988200.

Closes #672

🤖 Generated with Claude Code

Summary by Sourcery

Harden bump-leg branch handling, push instructions, reporting, and dry-run messaging against ambiguous refs, unsafe names, and misleading commit details.

Bug Fixes:

• Correct branch detection to recognize only local heads and preserve branch names exactly.
• Generate unambiguous full-head refspecs for push instructions so branch names cannot trigger unintended forced or ambiguous pushes.
• Render dirty filenames safely, including control and bidi characters, while preserving Git status formatting.
• Report the paths actually recorded by the bump commit and accurately describe gitlink movement.
• Clarify that dry runs skip project validators and that real runs may still roll back on validator failure.

Enhancements:

• Add comprehensive coverage for branch resolution, push safety, unusual filenames, commit contents, and dry-run messaging.

Tests:

• Update existing bump-leg expectations for full refspec push instructions and preserved Git status columns.
• Add regression tests covering unusual refs, unsafe branch names, control characters, commit path reporting, and validator behavior.

[brettheap]

(lane openRepoShape-5, 2026-10-16T18:38Z) @codex review

[sourcery-ai]

Reviewer's Guide

Updates bump-leg.py to validate full branch refs, generate safe explicit push refspecs, safely spell unusual Git paths, report the actual committed paths and movement semantics, and explain skipped validators during dry runs; extensive regression tests cover each behavior.

Sequence diagram for the bump-leg commit and push flow

sequenceDiagram
    participant User
    participant BumpLeg as bump-leg.py
    participant Git
    participant Validators
    User->>BumpLeg: cmd_bump(args)
    BumpLeg->>Git: symbolic-ref --quiet HEAD
    Git-->>BumpLeg: refs/heads/<branch>
    BumpLeg->>BumpLeg: current_branch()
    alt dry run
        BumpLeg-->>User: Report preview and skipped validators
        Note over BumpLeg,Validators: Validators are not run
    else real run
        BumpLeg->>Git: Commit rewritten leg
        BumpLeg->>Validators: validate-pins.py and validate-manifest.py
        alt validators pass
            BumpLeg->>Git: diff-tree --name-only -r -z --ignore-submodules=none <sha>
            Git-->>BumpLeg: Actual committed paths
            BumpLeg-->>User: Explicit refs/heads/<b>:refs/heads/<b> push command
        else validators fail
            BumpLeg-->>User: bump-leg-validators-red and rollback
        end
    end

Loading

Sequence diagram for committed-path reporting

sequenceDiagram
    participant BumpLeg as bump-leg.py
    participant Git
    BumpLeg->>Git: Commit bump
    Git-->>BumpLeg: commit sha
    BumpLeg->>Git: diff-tree --no-commit-id --name-only -r -z --ignore-submodules=none sha
    Git-->>BumpLeg: Paths held by commit
    BumpLeg->>BumpLeg: spelled(path)
    BumpLeg-->>BumpLeg: Print committed paths
    alt path listing fails
        BumpLeg-->>BumpLeg: Print git show --name-only recovery hint
    end

Loading

Flow diagram for safe branch push refspec generation

flowchart LR
    HEAD[HEAD ref] --> Check{Starts with refs/heads/?}
    Check -->|No| Detached[Refused as detached]
    Check -->|Yes| Branch[Extract branch name]
    Branch --> Refspec[refs/heads/<b>:refs/heads/<b>]
    Refspec --> Push[git push -u origin refspec]
    Push --> Upstream[Records origin/<b> upstream]

Loading

File-Level Changes

Change	Details	Files
Make branch detection and generated push commands unambiguous and safe for unusual branch names.	Read the complete symbolic ref and accept only refs under refs/heads/. Emit a two-sided refs/heads/ refspec so tags and leading '+' characters cannot redirect or force a push. Update branch and paste-line coverage for tracking tags, detached tag refs, ambiguous names, upstream setup, and remote safety.	scripts/bump-leg.py tests/test_bump_leg.py tests/test_bump_leg_branch_and_push_line.py tests/test_bump_leg_paste_lines.py
Render Git-reported paths safely and report the paths actually contained in the completed commit.	Spell dirty filenames and split only on Git's newline delimiter, preserving Unicode separators in names. Derive committed paths with NUL-separated diff-tree output while overriding submodule ignore settings. Use the pin's commit as the reported source when the gitlink already points at the target, explain the unchanged gitlink, and make post-commit path-read failures non-fatal.	scripts/bump-leg.py tests/test_bump_leg_branch_and_push_line.py
Clarify dry-run validator behavior without changing execution semantics.	State that dry runs skip the project validators and that a real run may roll back with bump-leg-validators-red. Document the exception in cmd_bump and test both the dry-run message and real-run rollback.	scripts/bump-leg.py tests/test_bump_leg_branch_and_push_line.py
Align explanatory comments and regression coverage with the four shared branch-left implementations.	Update the BRANCH_LEFT comment to identify all four copies of the shared rule. Add comprehensive regression tests covering branch refs, push safety, unusual filenames, commit contents, and validator messaging.	scripts/bump-leg.py tests/test_bump_leg_branch_and_push_line.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#672	Read the root's branch from the full HEAD ref so same-named tags cannot disguise the branch or allow a bump on a tracking branch, and print a push command that unambiguously pushes that branch without force semantics.	✅
#672	Escape control and bidi characters in dirty-file names so terminal output remains safe and each filename is kept intact.	✅
#672	Make bump reports accurately describe the commit's paths and the pin movement when the gitlink already has the target commit, and disclose in the dry-run summary that project validators are skipped and the real run may be rolled back by them.	✅

Possibly linked issues

• bump-leg.py: a root on +x is told push -u origin +x (forced), a branch named like a tag passes bump-leg-on-tracking-branch, bump-leg-root-dirty prints C1 controls raw, and committed <sha>: lists paths the commit lacks #672: The PR fixes the issue’s five listed behaviors: full branch refs, safe push refspecs, spelled filenames, accurate commit paths, and dry-run validator messaging.

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-16T18:41:03.806180Z	326de72	Manual request

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

Codex Review: Didn't find any major issues. Swish!

Reviewed commit: 326de720bc

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[sonarqubecloud]

Quality Gate passed

Issues
2 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[sourcery-ai]

Sorry @brettheap, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 5 hours and 47 minutes by commenting @sourcery-ai review. Upgrade to get a review now.