[brettheap]

Lane: openRepoTools-3
Closes #32

commit_push's true-rebase-conflict die no longer says "nothing was pushed." Three of the five occurrences #32 records (Eagle, 2026-09-13/14, several lanes writing the register concurrently) named a commit that WAS on origin by the time anyone read the line — carried there by the very next lanes-edit.sh write out of the same shared checkout, which pulls the dangling local commit onto its own and pushes both together. A caller who trusted "nothing was pushed" and redid the write wrote a duplicate line. An aborted pull is not proof the commit never reached origin — the same rule RV-B3 took for the handoff stamp's own push in lane-start.

The change (lanes-edit.sh :1167–1181)

• The die now reads rebase conflict on origin/<branch> — not pushed by this attempt; a later write from this checkout may already carry it, so look before you retry. Exit 3 is unchanged.
• RECOVERY is reordered to LOOK first: git fetch origin <branch> && git log --oneline origin/<branch> -3; then — only if the commit is not there — the diff that reads back what was written; then the reset --hard; then the redo. The old order put reset --hard second, before anyone had looked.
• The comment above it (:1167–1174) names the mechanism and RV-B3 so the next reader does not put "nothing was pushed" back.

Tests (tests/test_lane_helpers.sh :3501–3601, 13 new assertions)

A new #32 section. A second clone plays the peer that moves origin between this invocation's own commit and its push — the same device the lost-claim race above it uses. Its preamble explains why it first commits the sandbox checkout's leftover dirt from the rejectgit cases: otherwise dirty_elsewhere would route these cases through Amendment 5(d)'s skip-the-pull branch instead of the rebase they exist to exercise.

• RACE-RETRY-WINS (:3534–3564) — a fake git lands an unrelated peer commit in the exact window the retry loop exists for: after this attempt's own pull --rebase and just before its push. Asserts exit 0; the message names pushed origin/main (attempt 2) and never (attempt 1); and the row's text is in the register exactly once, never twice.
• OURS-CONFLICT (:3566–3601) — the peer rewrites the SAME row, a conflict the rebase truly cannot resolve. Asserts exit 3; REBASE CONFLICT is still named; the abort message appears and git status --porcelain really is empty; the fetch-and-look line, the "only if it is not there" gate and the attempt-scoped die are all present; the old unconditional nothing was pushed. is absent; and the look is printed BEFORE the reset --hard it gates.

Verification

• bash -n lanes-edit.sh and bash -n tests/test_lane_helpers.sh: clean.
• bash tests/test_lane_helpers.sh on this branch's HEAD (8202742, with main 8345d2f merged in): 1691 passed, 0 failed, 0 skipped, 0 pending. Main alone is 1678; the 13 new assertions are the whole delta.
• python3 -m pytest tests -q: 571 passed in 1051.30s (0:17:31), serialized behind the shared pytest lock (sibling worktrees were testing concurrently).

Lane: openrepotools-3 (openRepoTools-3)

🤖 Generated with Claude Code

Summary by Sourcery

Make rebase-conflict recovery distinguish an unpushed attempt from a commit that may already have reached origin through a later shared-checkout write.

Bug Fixes:

• Prevent exit-3 rebase-conflict handling from falsely claiming that the commit was never pushed, avoiding duplicate writes when a later shared-checkout write has already carried it to origin.

Enhancements:

• Reorder conflict recovery to fetch and verify the published change by patch content before reading back, resetting, or retrying.
• Expand exit-code documentation to describe the uncertainty and all relevant causes of exit 3 consistently across the script and user documentation.

Documentation:

• Document shared-checkout propagation, fetch requirements, and content-based recovery for aborted rebase conflicts.

Tests:

• Add race and true-conflict coverage for retry behavior, recovery ordering, duplicate prevention, clean aborts, and synchronized exit-code documentation.

[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 1 day and 4 hours by commenting @sourcery-ai review. Upgrade to get a review now.

[sourcery-ai]

Reviewer's Guide

Updates commit_push true-conflict messaging and recovery so an aborted pull is not treated as proof that the commit never reached origin, then adds race-focused tests covering both successful retry propagation and genuine same-row conflicts.

Sequence diagram for shared-checkout conflict recovery

sequenceDiagram
    participant Lane as Lane write
    participant Checkout as Shared checkout
    participant Origin as origin/branch
    participant Peer as Later lane write

    Lane->>Checkout: git pull --rebase
    Checkout-->>Lane: Rebase conflict
    Lane->>Checkout: git rebase --abort
    Checkout-->>Lane: Clean worktree
    Lane->>Origin: git fetch origin branch
    Origin-->>Lane: Recent origin commits
    alt Commit already carried by later write
        Lane->>Lane: Stop and inspect before retrying
    else Commit not on origin
        Lane->>Checkout: git diff origin/branch..HEAD
        Lane->>Checkout: git reset --hard origin/branch
        Lane->>Lane: Re-read and redo edit
    end
    Peer->>Checkout: Later write may carry dangling commit
    Checkout->>Origin: Push combined commits

Loading

Flow diagram for true-conflict recovery decision

flowchart TD
    A[Rebase conflict] --> B[git rebase --abort]
    B --> C[git fetch origin branch and git log origin/branch -3]
    C --> D{Commit already on origin?}
    D -->|Yes| E[Do not assume nothing was pushed; inspect before retry]
    D -->|No| F[git diff origin/branch..HEAD]
    F --> G[git reset --hard origin/branch]
    G --> H[Re-read LANES.md and redo edit]
    E --> I[Exit 3 with attempt-scoped conflict message]
    H --> I

Loading

File-Level Changes

Change	Details	Files
Make true rebase-conflict recovery acknowledge that a later shared-checkout write may have propagated the commit.	Replace the misleading “nothing was pushed” failure text with an attempt-scoped warning and explicit look-before-retry guidance. Document the shared-checkout propagation mechanism and RV-B3 rationale. Reorder recovery instructions to fetch and inspect origin before reading the diff, resetting, or redoing the edit.	lanes-edit.sh
Add regression coverage for retry races and unrecoverable same-row conflicts.	Simulate a peer landing a commit between pull and push, verifying retry success, attempt-accurate messaging, and no duplicate row. Simulate a peer rewrite of the same row, verifying exit 3, clean abort state, look-before-reset guidance, and removal of the old claim. Normalize fixture checkout state so the scenarios exercise the intended rebase paths.	tests/test_lane_helpers.sh

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#32	Ensure lanes-edit.sh reports the result of the final commit/push attempt, including identifying which retry successfully pushed, so callers do not incorrectly retry and create duplicate entries.	✅
#32	When a genuine rebase conflict aborts the operation, leave the shared checkout clean and report that the commit was not pushed by this attempt without making the unsupported claim that it was never pushed; provide recovery guidance to check the remote before retrying.	✅
#32	Add regression coverage using a concurrent sandbox clone for both a retry that eventually succeeds and a genuine same-row rebase conflict, including verification of the exit status, messages, checkout cleanliness, and absence of duplicate writes.	✅

Possibly linked issues

• lanes-edit.sh: 'rebase conflict on origin/main — nothing was pushed' is printed after a write that DID land (three times on 2026-09-13/14); a retry then writes a duplicate line #32: PR directly fixes issue lanes-edit.sh: 'rebase conflict on origin/main — nothing was pushed' is printed after a write that DID land (three times on 2026-09-13/14); a retry then writes a duplicate line #32 by scoping failure messages to attempts and adding conflict recovery checks and tests.

---

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.

[Copilot]

🟡 Changes recommended

Conflict recovery still permits a duplicate redo after the commit is found on origin, and the exit-code documentation is inconsistent.

Get a fresh assessment by requesting another Copilot review.

Pull request overview

Updates commit_push conflict recovery to prevent duplicate writes when later shared-checkout activity carries a commit to origin.

Changes:

• Clarifies conflict messaging and recovery ordering.
• Adds race and same-row conflict regression tests.

File summaries

File	Summary	Review findings
tests/test_lane_helpers.sh	Adds concurrent push and conflict coverage.	No findings.
lanes-edit.sh	Updates conflict messaging and recovery guidance.	Moderate: Reset and redo should be conditional on the commit being absent from origin. Nit: Update the exit-code table’s conflicting wording.

Review details

Suppressed comments (1)

lanes-edit.sh:1180

• The gate is only attached to the diagnostic diff line. If the preceding fetch/log shows that a later write already carried this commit to origin, the next two lines still instruct the caller to reset and redo the edit, which can create the duplicate this PR is meant to prevent. Make the reset and redo explicitly conditional on the commit being absent, and tell the caller to stop when it is present, as the existing lane-start recovery does.

      note "  git -C $LANES_REPO diff origin/$LANES_BRANCH..HEAD -- ${CP_PATHS[*]}   # only if it is not there: read back exactly what you wrote"
      note "  git -C $LANES_REPO reset --hard origin/$LANES_BRANCH                # then drop the local commits (NOTE: also drops any"
      note "                                                          # uncommitted peer edit in this checkout)"
      note "  then re-read LANES.md and redo the edit with lanes-edit.sh, on top of the peer's version."

• Files reviewed: 2/2 changed files
• Comments generated: 1
• Review effort level: Lite

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[sourcery-ai]

Sourcery assessment

Approved.

[Copilot]

🟡 Changes recommended

Recovery ancestry checking, manual guidance, and runtime-message coverage remain unresolved.

Get a fresh assessment by requesting another Copilot review.

Review details

Suppressed comments (1)

tests/test_repo_hygiene.py:1910

• This test never reads the exit-3 die at all; it only checks the table and manual. If the runtime message at lanes-edit.sh:1183 regresses to nothing was pushed while those two docs remain unchanged, this test still passes, so it does not enforce the code/documentation contract its name claims. Extract the rebase-conflict die message and assert its attempt-scoped wording here.

    assert "not pushed BY THIS ATTEMPT" in table, (
        "lanes-edit.sh's exit-3 row no longer names the attempt-scoped wording")
    assert "not pushed by this attempt" in manual, (
        "docs/README-lanes.md's exit-3 row no longer names the attempt-scoped wording")

• Files reviewed: 4/4 changed files
• Comments generated: 2
• Review effort level: Lite

[Copilot]

🟡 Changes recommended

Fix failed fetch handling before reset/redo and complete the exit-3 documentation contract.

Get a fresh assessment by requesting another Copilot review.

Review details

Suppressed comments (2)

docs/README-lanes.md:946

• This manual copy still describes exit 3 as only a rebase conflict, while the implementation also uses it for network timeouts and the exhausted dirty-peer path. The caller-facing table is therefore incomplete after this update; mirror the chosen complete exit-3 contract here.

| 3 | rebase conflict — not pushed by this attempt; a later write from this checkout may already carry it to origin, so look before you retry |

lanes-edit.sh:189

• Exit 3 is not only the rebase-conflict path: git_timeout_die at line 1002 and the blocked-peer exhaustion at line 1140 also call die ... 3. Since this table says "one table, no two meanings", the new row remains incomplete and callers cannot interpret those refusals from the documented contract. Include these cases or assign distinct documented codes, and mirror the choice in the manual.

#   3  rebase conflict — not pushed BY THIS ATTEMPT; a later write from this
#      checkout may already carry it to origin, so LOOK before you retry

• Files reviewed: 4/4 changed files
• Comments generated: 2
• Review effort level: Lite

[Copilot]

🟡 Changes recommended

The publication check can still miss a rebased equivalent commit and permit duplicate entries.

Get a fresh assessment by requesting another Copilot review.

Review details

Suppressed comments (2)

docs/README-lanes.md:196

• The manual repeats the exact-SHA ancestry check, but a later shared-checkout write that successfully rebases the dangling commit publishes a rewritten commit, not <your commit> itself. This wording can therefore say not-there and authorize reset/redo after the change is already on origin; update it together with the implementation to check the published change rather than only the pre-rebase SHA.

eyeballing a capped log — `git -C <the workspace checkout> merge-base
--is-ancestor <your commit> origin/main` exits 0 once it is already there, in
which case STOP. Only once fetch succeeded AND this answers non-zero do you

tests/test_repo_hygiene.py:1952

• The new documentation test only checks for the substring timeout, so it would pass the current push-only wording and would not catch the omitted pull-timeout path (git_timeout_die is invoked for git pull --rebase at lanes-edit.sh:1166). Assert that the exit-3 documentation covers a timeout in both push and pull (or uses an explicitly generic network-timeout phrase) so this consistency test protects the full contract.

    for name, flat in (("lanes-edit.sh's own exit-code table", table_flat),
                        ("docs/README-lanes.md's own exit-codes table", manual_flat)):
        for cause in ("timeout", "peer's"):
            assert cause in flat, (

• Files reviewed: 4/4 changed files
• Comments generated: 3
• Review effort level: Lite

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
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

[Copilot]

🔵 Needs a closer look

Unresolved moderate comments remain for timeout recovery, cherry-range/path handling, and integration/documentation test coverage.

Review details

Suppressed comments (6)

Previously missed (1) — in code that hasn't changed since the last review.

lanes-edit.sh:1212

• These are copy/paste recovery commands, but the interpolated $LANES_REPO is unquoted. The helper explicitly supports a checkout living anywhere (docs/README-lanes.md:205-208) and quotes it for its own Git calls, so a valid path such as /tmp/lane workspace makes the fetch/cherry command fail and prevents the required lookup. Emit a shell-quoted -C path for every command in this recovery block (including the existing diff/reset lines).

docs/README-lanes.md:952

• By adding timed-out pushes and pulls to exit 3, this row also documents git_timeout_die, but that shared runtime path still prints a push-specific recovery (a hung push often means it LANDED, then git log ... -3 and git push; lanes-edit.sh:1006-1009). A timed-out pull reaches the same function at lanes-edit.sh:1168, so callers receive the wrong operation and the capped three-line lookup can miss a commit that a later shared-checkout write rebased and published. Make the timeout recovery distinguish pull from push and use the same successful-fetch/content check before permitting a retry.

| 3 | the edit is never a permanent loss, but this attempt cannot confirm whether it also reached origin — a rebase conflict (not pushed by this attempt; a later write from this checkout may already carry it to origin, so look by content before you retry), a network timeout on a push or a pull (a hung one often already landed), or six attempts exhausted because a peer's uncommitted file blocks every rebase |

docs/README-lanes.md:198

• The manual repeats the same unbounded git cherry check: with multiple local commits, it counts unmatched patches from older commits as well as <your commit>. That can report nonzero even after the current edit was carried to origin, sending the reader into the duplicate-producing reset/redo path. Pass the current commit's parent as git cherry's limit so this check evaluates only the edit being recovered.

actually published. `git -C <the workspace checkout> cherry origin/main <your
commit> | grep -c '^+'` compares by patch instead and still finds it; 0 means

lanes-edit.sh:1209

• git cherry origin/$LANES_BRANCH $cp_sha walks every commit reachable from $cp_sha, not just the commit this invocation created. If an older local commit is still unmatched while the current commit's patch has already been carried to origin, grep -c '^+' remains nonzero, so the recovery permits reset/redo and can recreate the duplicate this change is meant to prevent. Limit the comparison to $cp_sha (for example, pass ${cp_sha}^ as git cherry's limit) and cover the multiple-local-commit case.

      note "  git -C $LANES_REPO cherry origin/$LANES_BRANCH $cp_sha | grep -c '^+'   # BY CONTENT, not by sha: a peer's rebase changes the hash but git cherry still finds the same patch"

tests/test_lane_helpers.sh:3614

• The new assertions only inspect the recovery text and its ordering; they never execute the fetch/git cherry lookup against the peer-rebased and local-only histories described in the surrounding comment. A regression such as using the wrong git cherry range or treating a lookup error as 0 would still pass. Add an integration case that runs the lookup and verifies that a landed patch stops while a genuinely local patch permits recovery.

has   "…checked by CONTENT (git cherry), never by a sha a peer's rebase can change" "$err" \
      "cherry origin/main"
cp_sha_printed="$(printf '%s\n' "$err" | grep -oE 'cherry origin/main [0-9a-f]{7,40}' | head -n1 | awk '{print $3}')"
is    "…naming a real local commit to check, not a placeholder" \
      "$([ -n "$cp_sha_printed" ] && printf 'has-sha' || printf 'MISSING')" "has-sha"
has   "…counting only the patches git cherry could not find upstream" "$err" \
      "grep -c '^+'"
has   "…the reset is now conditional on that look, not unconditional" "$err" \
      "only if it is not there: read back exactly what you wrote"

tests/test_repo_hygiene.py:1926

• This new regression guard extracts only the rebase-conflict die and checks one shared phrase. Exit 3 is also produced by git_timeout_die and by the six-attempt peer-file branch, yet the later assertions merely look for timeout, push, pull, and peer's in the docs; either runtime message can drift from the table/manual while this test still passes. Check all exit-3-producing messages (or derive the documented causes from every call site) so the test actually enforces the agreement claimed by its name and docstring.

    m = re.search(r'die "(rebase conflict on origin/\$LANES_BRANCH[^"]*)" 3\b', src)
    assert m, "no exit-3 die message found in lanes-edit.sh to check the docs against"
    die_text = m.group(1)
    assert "not pushed by this attempt" in die_text, (
        "the exit-3 die message itself no longer names the attempt-scoped "
        f"wording the table and the manual are checked against: {die_text!r}")

• Files reviewed: 4/4 changed files
• Comments generated: 0 new
• Review effort level: Lite