[brettheap]

Lane: openreposhape-4 (openRepoShape-4)
Claim: #684 (comment)

What changed and why

#684 holds six lines from R612's review of #626 (#612), on #459 (comment 6213530456): states of the holder that #626's early refusals did not model, where add, bump and remove met a refusal or a remedy that did not fit. Five are fixed here; E4 is not (see "What it cannot tell"). Brett Heap added one more line to it: #459 line 66 (issuecomment-6192725913), "refuse a dirty family.yaml", relayed by lane 5 on #473 at 2026-10-16T13:56:50Z (issuecomment-6217084172). Every refusal below is made before the verb's first write, under --dry-run alike, in the same words, exit 2. All in scripts/family.py.

The branch holds six commits: the WIP saved at the account swap (70153862: E2, E5, E3, N4 and E1's staged half), a merge of main bf1f099b, the rest (772105aa), fix round 1 (bc8024fc), 4030ee6c, which clears the two Sonar smells this PR added (S1192, "a rebase" a third time; S3358, a nested conditional) with nothing either refusal says changed, and fix round 2 (fdc90a6e).

Fix round 1 answers lane 1's review at 772105aa (issuecomment-6233536729), on lane 4's rulings:

• R1. Both members remedies said to commit "on its own" with a bare git commit, which takes every staged change (lane 1 measured an unrelated staged file committed beside D members, and beside the staged move). Each now says "(git commit, with nothing else staged: a bare git commit takes every staged change, and git status lists them)", lane 1's words. Not git commit -- members: it exits 128 where a directory is on disk (lane 1 measured).
• R2. family-members-unrecognised said "fix it by hand this once.", and the run again then met family-manifest-uncommitted. It is reached only once the shape it names is committed, so it now says "fix it by hand this once and commit that (git commit -- family.yaml), then run the same command again." (Family.rewritten; test_family_add_refusals.py holds the text.)
• R3. Issue family.py add/bump/remove: a members file deleted unstaged, a git bisect, an empty sparse-checkout file, an empty rebase-merge/ and a merge conflicted in family.yaml meet a refusal or remedy that does not fit (#626's gaps) #684 stays open after this PR, for E4 (the last line says so); the closing keyword is gone.
• F4. "Dirty" now compares the MODE as well as the object: HEAD's entry is read from git ls-tree -r -z HEAD with no pathspec (_head_entries) and compared with the stage-0 record. Lane 1 measured a staged chmod 755 going into remove's commit (mode change 100644 => 100755 family.yaml).
• F5. Where the index stages a change to family.yaml and a gitlink under members/ that HEAD does not hold, as family.py bump to the commit already pinned exits 2 as "REFUSED a git or gh command failed" around git's "nothing to commit", where family.py documents exit 1 for nothing and bump-leg.py answers the same re-run with "nothing to do", exit 1 #210's half-finished bump leaves both, the refusal names the drop ALONE (_gitlink_staged): there "keep" committed the row without its gitlink (lane 1 measured), while the drop and the same bump again make the one commit of both paths. That holds for bump only: a half-finished add then meets member-path-taken (lane 1 measured; checklist below).

Fix round 2 answers lane 1's re-verification at 4030ee6c (issuecomment-6233920232):

• N1. F5's drop alone also fired on a gitlink a person staged by hand beside an unstaged comment in family.yaml (a commit inside members/IRRS and git add -- members/IRRS, or git mv -- members/IRRS members/MOVED), where no run stopped, the change is not the row, and the drop would discard the person's only copy of their edit. Every stopped add or bump stages family.yaml beside its gitlink, so _gitlink_staged is now asked only where the index's own copy differs from HEAD too: if merged and merged != [head] and _gitlink_staged(index, held), lane 1's tested change, verbatim. Both states now get the two-way remedy.

E2, a git bisect in progress. BISECT_LOG is asked with the other marks (OPERATION_MARKS), where git keeps it, and LAST: a merge or a cherry-pick begun at the commit under test leaves its own mark beside it, and git bisect reset fails over that act's conflict (you need to resolve your current index first, measured), so that act is named and ended first. The real run said family-holder-detached with a git switch -c that would branch from the commit under test; the dry run printed a plan. Now:

REFUSED family-operation-in-progress: a bisect is unfinished in the family root: git keeps BISECT_LOG at …/BISECT_LOG. `add` makes its commit with `git commit -- `, and git does not refuse that during a bisect: once the bisect has checked out a commit to test, the commit would be made on it, on no branch, and `git bisect reset` would leave it behind. No git command that writes was run and nothing was written.
Remediation: end the bisect with `git bisect reset` once you have what it was for: it takes HEAD back to where the bisect started. Then run the same command again.

E5, an empty rebase-merge/ (or rebase-apply/ with no applying). A rebase directory with no head-name is named with git rebase --quit, the exit that works there (--abort and --continue both fail, could not read '.git/rebase-merge/head-name', measured): "rebase-merge/ is what a rebase left behind, and it holds no head-name, so git can read no rebase from it and there is nothing to continue or give up: clear it without moving HEAD with git rebase --quit."

E3, non-cone sparse rules that hold no pattern (an emptied .git/info/sparse-checkout). Every staged path is still refused as family-sparse-excluded; the remedy now names git sparse-checkout disable ALONE, and says why: "the rules hold no pattern at all, so they leave out every path, and git sparse-checkout add would keep only the paths it is given and take every other file out of the work tree". Measured: the add it printed took the holder's top level down to .git, .gitmodules, family.yaml and members. Asked of git (git sparse-checkout list prints nothing), and only of non-cone rules: a cone of no directories keeps its git sparse-checkout add members remedy, which works there.

N4, a merge conflicted in family.yaml itself. As the issue directs (W612's fallback): the marks are asked only once the parse has failed, so the member-path refusal still runs no git command first (test_family_member_path.py::test_the_refusal_is_made_before_any_git_call holds it). yaml-unparsable keeps its code and line and gains a remediation that names the act, where git keeps it, and its exits; with no act in progress it is one line, as before.

E1, a members FILE that HEAD holds and the work tree no longer does. It passed every add check, and the mount, putting a directory where the file was, took D members into the add's commit. Measured on the code before this round, with the deletion unstaged: add exit 0, its commit A .gitmodules, M family.yaml, D members, A members/IRQS. _members_file_left_in_head refuses both halves as member-path-unaddable:

• staged and not committed (the git mv family.py: add, bump and remove refuse before their first write a merge, cherry-pick, revert, rebase or git am in progress, a .gitmodules, members/ or family.yaml the sparse checkout leaves out, and a file named members, which each failed after writing and was rolled back, or committed in the wrong place (#612) #626's remedy names, or a git rm): "Commit that change on its own first (git commit, with nothing else staged: a bare git commit takes every staged change, and git status lists them)".
• the deletion not staged (the index still holds the file; on disk nothing, or a directory a hand made there):

REFUSED member-path-unaddable: git would add the mount path members/IRQS and take `members` out of the holder with it: `members` is a file HEAD and the index hold and the work tree no longer does, its deletion not staged, and the add's mount, putting a directory where the file was, would take it out of the index, and its commit would take that deletion into itself (`D members`). No git command that writes was run and nothing was written.
Remediation: every member is mounted under members/, which must be a plain directory of the holder's own. Take the file out of the index, which touches no file (`git rm --cached -- members`), and commit the removal on its own first (`git commit`, with nothing else staged: a bare `git commit` takes every staged change, and `git status` lists them), since the add's own commit names .gitmodules, members/IRQS and family.yaml alone, and run the same command again.

This remedy differs from the issue's, and the lane's coordinator ruled it, because the issue's own remedy fails as measured: git mv -- members <new name> there exits 128 (fatal: bad source, or fatal: Directory members is in index and no submodule? where a directory was made), and git checkout -- members first puts the file back over such a directory and takes the directory and its files away. The words are the house's for an index entry with nothing on disk (#318, UNSTAGE). Brett Heap may overrule it at review. A link on disk is left to git's own dry run, as before.

A family.yaml holding a change HEAD does not (#459 line 66). add, bump and remove rewrite family.yaml as the work tree has it and commit it with git commit -- <paths>, so a comment line edited by hand went into their commit beside their own row (measured on the code before this round: remove's commit carried +# a comment line, edited by hand). _checked_manifest_committed, asked right after the operation check in each verb, refuses it, staged or not:

REFUSED family-manifest-uncommitted: family.yaml holds a change HEAD does not: git lists the work tree's copy as modified, a change nobody has staged. `remove` rewrites family.yaml as the work tree has it and commits it, so that change would go into the command's commit beside its own. No git command that writes was run and nothing was written.
Remediation: which change to keep is a person's to say. To keep it, commit it on its own first, `git commit -- family.yaml`; to drop it, put back HEAD's copy, in the index and the work tree, `git checkout HEAD -- family.yaml`. Then run the same command again.

• What it says of each state: "it is unmerged in the index" (a git stash pop that conflicted leaves that with no act in progress), "its deletion is staged, so the index holds no copy", "a change to it is staged and not committed" (a mode too, F4), and "git lists the work tree's copy as modified, a change nobody has staged", the last two together where both hold.
• Where a change to it is staged beside a staged gitlink under members/ (F5) the remediation is the drop alone:

Remediation: the index also stages a gitlink under members/ that HEAD does not hold, as a run stopped before its commit leaves it, and `git commit -- family.yaml` would commit the row without it: put back HEAD's copy, in the index and the work tree, `git checkout HEAD -- family.yaml`. Then run the same command again.

• Read with git ls-files -s -z (_index_records), git ls-tree -r -z HEAD (_head_entries, mode and object, F4) and git ls-files -m -z, and NOT git hash-object: test_family_dry_run.py::test_a_dry_run_runs_no_git_command_that_writes holds hash-object to bump's nothing-to-do alone.
• A holder whose HEAD holds no family.yaml (one made by hand, with no commit yet) is not asked: add gives the file its first commit there, as it always has (test_family_add_refusals.py::test_the_first_add_to_a_holder_with_no_commit_makes_its_root_commit).
• The two member-path remedies now say to commit a row put back by hand ("Put path: members/IRRS back in family.yaml and commit that, or git checkout -- family.yaml if the edit is not committed, …"; the project: one alike). Without that, a row put back over an edit already committed met this refusal on the run again.

Existing tests this rule collides with, each changed to keep what it tests:

• test_family.py::test_bump_to_the_commit_already_pinned_leaves_an_uncommitted_edit_alone: now refused family-manifest-uncommitted, the edit left alone (it was nothing to do, exit 1).
• test_family.py::test_bump_finishes_a_bump_an_earlier_run_staged_and_did_not_commit (family.py bump to the commit already pinned exits 2 as "REFUSED a git or gh command failed" around git's "nothing to commit", where family.py documents exit 1 for nothing and bump-leg.py answers the same re-run with "nothing to do", exit 1 #210): the staged family.yaml is now refused first, naming the drop alone (F5); git checkout HEAD -- family.yaml, then the same bump finishes in ONE commit of both paths, as the test held. This changes what family.py bump to the commit already pinned exits 2 as "REFUSED a git or gh command failed" around git's "nothing to commit", where family.py documents exit 1 for nothing and bump-leg.py answers the same re-run with "nothing to do", exit 1 #210's half-finished bump meets, under Brett Heap's word. Since family.py bump and remove have no rollback: when a git step after write_members fails (a holder pre-commit hook that exits 1, a held index.lock), they exit 2 with REFUSED a git or gh command failed and leave family.yaml rewritten, the member checked out at --to (or deinitialised and removed), and the change staged or half-staged, without a word about any of it, where add puts the holder back and names what it put back #365 the bump's rollback (PinRollback) puts back a commit that fails, so the tool itself leaves that state only when it is stopped between the stage and the commit (not measured here).
• test_family_member_path.py: the [no-path-line] control commits its hand edit first; the two remedy texts.
• test_family_add_refusals.py: the family-members-unrecognised remedy text (R2).
• The comment on the members: line in test_family_bump_remove_rollback.py (2 tests) and test_family_dry_run.py (2 places) is committed, as test_family_add_refusals.py's twin already was, so family-members-unrecognised is still what they reach.

Tests

New file tests/test_family_holder_states.py, 40 tests, on the helpers of test_family_refuse_up_front.py (#612's proof: exit 2, one REFUSED paragraph, nothing on stdout so no member was read, the holder as it was under the real run and --dry-run alike, the two runs' words identical; then the way out typed as printed and the same command making its one commit). Each state is made with git itself where git can make it.

• E2: a bisect, each verb; the premise that the verb's partial commit lands on no branch; a cherry-pick stopped inside a bisect, named first, each exit typed.
• E5: an empty rebase-merge/ under each verb, and an empty rebase-apply/; --abort and --continue failing there is the premise.
• E3: emptied non-cone rules (with and without init --no-cone), each verb; the premise that the add it printed left four entries; a cone of none keeps its remedy.
• N4: a merge conflicted in family.yaml, each verb; the same line with no act in progress; a family.yaml outside any repository.
• E1: the staged move and the staged removal, real and dry; the deletion not staged with nothing left and with a hand-made members/ holding a file, real and dry, the git mv failure the premise, and the directory and its file still there after the remedy.
• The dirty family.yaml: a comment line not staged, under each verb, the comment then the person's commit's and not the verb's; staged, staged and edited again, a staged deletion and an unmerged copy with no act (from a conflicted git stash pop), each with the way out typed; a mode staged with git update-index --chmod=+x, under each verb (F4); family.py bump to the commit already pinned exits 2 as "REFUSED a git or gh command failed" around git's "nothing to commit", where family.py documents exit 1 for nothing and bump-leg.py answers the same re-run with "nothing to do", exit 1 #210's half-finished bump told the drop alone, in exact words, and then finishing in one commit of both paths (F5); a gitlink staged by hand, in lane 1's two states, beside an unstaged comment, told both ways out, and "keep" then committing family.yaml alone (N1); the member-path remedy for a committed edit typed through to a run.

Fix round 1's run over the bytes of head bc8024fc (scripts/family.py sha256 d5cdac4a…, the new file c09dadc1…), the 14 files lane 4 named: test_family_holder_states, test_family_member_path, test_family_bump_remove_rollback, test_family_dry_run, test_family, test_family_refuse_up_front, test_family_add_refusals, test_family_init_values, test_shape_pin_files_not_a_list, test_update_shape_add, test_setup_project_py, test_repo_hygiene, test_cli_reference and test_agents_md_codes: 951 passed, 19 skipped, 0 failed, 12m33s. The skips are all test_family_init_values.py's (a template that quotes its placeholder or id:). Main was not merged this round.

Fix round 2's run over the bytes of head fdc90a6e (scripts/family.py sha256 48da8f37…, the new file 2800a4cb…): test_family_holder_states, test_family, test_family_add_refusals, test_family_dry_run, test_family_refuse_up_front, test_family_member_path, test_family_bump_remove_rollback, test_repo_hygiene, test_cli_reference and test_agents_md_codes: 569 passed, 0 skipped, 0 failed, 7m20s. The new file has 42 tests.

The Sonar follow-up's run over the bytes of head 4030ee6c (scripts/family.py sha256 63b17251…, every test file as at bc8024fc): test_family_holder_states, test_family, test_family_add_refusals, test_family_dry_run, test_family_refuse_up_front, test_family_member_path, test_repo_hygiene, test_cli_reference and test_agents_md_codes: 538 passed, 0 skipped, 0 failed, 7m16s.

The first round's run over the merged bytes, which are the tree of head 772105aa (scripts/family.py sha256 f86d9172…, the new file 4b89cf1d…): 32 of the 36 test files that run family.py's verbs (test_bootstrap_spelling, test_bump_leg, test_doctor_next_is_a_command, test_family, 17 test_family_* files, test_non_utf8_git_reads, test_refusal_default_remediation, test_shape_doctor, test_siblings_family_name, test_template_text_placeholders, test_update_shape_kept_helper and the five test_validate_family_*; the coordinator left out test_setup_project_py, test_family_init_values, test_shape_pin_files_not_a_list and test_update_shape_add), the new file, tests/test_repo_hygiene.py, tests/test_cli_reference.py and tests/test_agents_md_codes.py: 2230 passed, 4 skipped, 1 xfailed, 0 failed, 32m58s. Skips: test_bump_leg.py:693 (needs a disk that ignores case) and test_shape_doctor.py:10429 ×3 (the PowerShell line, Windows only). The xfail is test_shape_doctor.py's strict xfail for #735. The full suite was not run; CI's Linux run is the gate.

Mutants, each over the new file, in a separate clone (36 tests at 772105aa; 40 for the last two rows, fix round 1's):

mutant	result
the code before this round (the merge head's family.py)	12 failed: every new test
E1: the index-held branch returns None	4 failed: the unstaged-deletion cases
dirty: git ls-files -m not asked	5 failed: the three verbs, staged-then-edited, the member-path chain
dirty: the index not compared with HEAD	3 failed: staged, staged-then-edited, the staged deletion
dirty: not asked by bump	1 failed: bump's case
E2: BISECT_LOG dropped from the marks	4 failed
E5: a rebase directory with no head-name read as a rebase	4 failed
E3: rules that hold no pattern not asked	4 failed
N4: no remediation for yaml-unparsable in an act	3 failed
E1: the staged half refused nothing	4 failed
F4: the mode not compared (HEAD's mode taken for the index's)	3 failed: the mode row, each verb (on Linux still refused, through ls-files -m, in words the row does not expect)
F5: no gitlink ever counted as staged	1 failed: the half-finished bump
N1: the old condition (any staged gitlink), over fix round 2's 42 tests	2 failed: both hand-staged rows

What it cannot tell

• E4, reftable, is not done. This host's git is 2.43, and the issue asks for it to be measured first on git 2.45 or later (git init --ref-format=reftable). The coordinator ruled it skipped with this reason. No test is added for it: one gated on git 2.45 would run on CI's ubuntu-latest git and assert a result nobody here has measured.
• A family.yaml the index marks assume-unchanged (or skip-worktree outside a sparse checkout): git ls-files -m does not compare it, and no hash-object is asked, so an unstaged edit to it is not seen.
• A staged deletion over a copy that is HEAD's byte for byte, or a mode staged with git update-index --chmod that the copy on disk does not have, is refused, and there git commit -- family.yaml has nothing to commit (exit 1, both measured); git checkout HEAD -- family.yaml, the other way out, works. The docstring says so.
• F4 on a disk that keeps no modes (core.filemode=false, as on Windows): there only the mode compare refuses the mode row. On Linux git ls-files -m lists the copy as well, so the F4 mutant was still refused here, in words the row does not expect, and failed it that way.
• Windows and macOS were not run (CI is Linux only). Reasoned: the new reads are ls-files -z and ls-tree -r -z; the tests write files as bytes, pass no paths on stdin, and stage the mode with git update-index --chmod=+x, which works where chmod does not.

For #459's checklist (outside #684)

From lane 1's review of #816; lane 4 posts them at landing. Lane 1's measurements, on git 2.43:

1. E4, reftable: not measured (this host's git is 2.43); it stays open on family.py add/bump/remove: a members file deleted unstaged, a git bisect, an empty sparse-checkout file, an empty rebase-merge/ and a merge conflicted in family.yaml meet a refusal or remedy that does not fit (#626's gaps) #684 (R3).
2. Non-cone rules holding only a negative pattern (!/*) still get git sparse-checkout add .gitmodules members/IRRS family.yaml. Typed, it took the holder's top level from 14 entries to .git, .gitmodules, family.yaml and members (measured): E3's harm, through rules that do hold a pattern.
3. A git stash pop that conflicted in family.yaml (no act in progress) is still REFUSED yaml-unparsable: …family.yaml: line 1: merge keys are not supported, with no remediation (measured).
4. git rm --cached -- members drops a staged edit of the members file without a word: it exited 0 with nothing or a directory on disk, and the staged blob 601b695b… is then in neither HEAD nor the work tree (measured).
5. A half-finished add (stopped between its stage and its commit: M .gitmodules, M family.yaml, A members/IRQS): main says member-already-present, this PR family-manifest-uncommitted (measured, at 772105aa). Neither way out finishes it (reasoned): "keep" commits a row with no gitlink, "drop" leaves .gitmodules and the gitlink staged. (Since F5 the drop alone is named there: item 8.)
6. Skip-worktree on family.yaml outside a sparse checkout, edited: the dry runs exit 0, and the real remove fails late at git --literal-pathspecs add -f -- .gitmodules family.yaml, rolled back (status empty afterwards), on main and here alike (pre-existing).
7. Not measured: validate-family.py remedies that name family.py bump --to for a work-tree-only defect will now meet family-manifest-uncommitted first.

From lane 1's re-verification at 4030ee6c:

8. A half-finished add (all three paths staged) now gets the drop alone. Typed, the next add says REFUSED member-path-taken: members/IRQS already exists in the family root but no members: row names it, so the drop finishes a bump but not an add (measured). The docstring's "makes the one commit of both" holds for bump only.
9. A half-finished remove (M .gitmodules, M family.yaml, D members/IRRS) never reaches this check: it stops at REFUSED member-unknown: IRRS is not a member of InkRouter. That ordering is not new in this PR.
10. In a --filter=tree:0 partial clone, ls-tree -r HEAD would fetch every tree from the remote. This is reasoned only, not measured.

Shared files

scripts/family.py and six test files. git merge-tree --write-tree of head bc8024fc against fresh main 741679e7 and every open pull request in those files, each head read with ls-remote just before:

against	head	result
main	741679e7	clean
#731 fix/692-raw-folder-paths	ab55c29f	clean
#747 fix/681-validate-family-remedies (tests/test_family.py)	ff7c59b8	clean
#748 fix/662-insteadof-helper (tests/test_family_bump_remove_rollback.py)	8368d1f8	clean
#767 fix/685-spellings-remedies	ac764679	clean
#772 l3-735-sibling-slot (tests/test_family.py)	1d149933	clean
#788 l3-784-dangling-slot (tests/test_family.py)	e966a684	clean
#795 fix/686-bump-reachability	7d7a69b1	clean
#805 fix/690-siblings-inputs (holder siblings.py; named by lane 4)	dc1c8e45	clean
#809 fix/688-family-init-values	6958dfbc	clean
#812 fix/693-local-remote-dir	372196a7	clean
#813 fix/689-next-push-refspec (also tests/test_family_add_refusals.py)	15c3b5ab	clean
#814 fix/766-spelled-paths (also tests/test_family_bump_remove_rollback.py)	0e516bba	clean
#818 fix/758-git-command-scope (tests/test_family.py, …_bump_remove_rollback.py, …_dry_run.py)	b6e15591	CONFLICT in tests/test_adopt_empty_symlinks.py, a file this PR does not touch; #818 conflicts with main alone the same way

#670 merged at 11:38:50Z, so it is now in main. None of those heads' new tests, nor main's since bf1f099b, leaves family.yaml changed before an add, bump or remove (grepped: their edits are committed, go to the validator, or are an init or setup folder). A sibling that lands first still needs the refresh gate.

Part of #684: E1, E2, E3, E5 and N4, and #459's line 66. E4 (reftable) stays open on #684 until it is measured on git 2.45 or later.

🤖 Generated with Claude Code

Summary by Sourcery

Protect family add, bump, and remove operations from incomplete Git states and unintended family.yaml changes by refusing unsafe holders with precise recovery guidance.

New Features:

• Add upfront safeguards for bisect sessions, unreadable rebase state directories, empty non-cone sparse-checkout rules, merge conflicts in family.yaml, and a tracked members file removed from the work tree.
• Refuse add, bump, and remove when family.yaml contains changes not present in HEAD, with remediation tailored to staged, unstaged, unmerged, mode, and interrupted-operation states.

Bug Fixes:

• Prevent family operations from accidentally committing unrelated family.yaml edits, deleting a tracked members file, or proceeding with incomplete Git state.
• Provide workable remediation commands for each newly recognized holder state, including special handling for interrupted bumps and hand-staged gitlinks.

Enhancements:

• Improve refusal diagnostics and remediation guidance for malformed manifests and manually restored member rows.
• Use Git index and HEAD metadata, including file modes and staged gitlinks, to distinguish safe and unsafe operation states.

Tests:

• Add comprehensive coverage for the new holder-state refusals, dry-run parity, remediation flows, and resulting commits.
• Update existing tests to reflect dirty family.yaml protection and the revised remediation requirements.

[sourcery-ai]

Reviewer's Guide

The PR hardens add, bump, and remove against five previously unmodeled Git holder states plus dirty family.yaml changes, detecting each before writes and providing state-specific, measured remediations; extensive tests verify real/dry-run parity, refusal ordering, and clean retries.

Sequence diagram for pre-write refusal and remediation

sequenceDiagram
    actor User
    participant Family as family.py
    participant Git as Git holder
    User->>Family: add, bump, or remove
    Family->>Family: Family.open
    alt family.yaml is unparseable
        Family->>Git: _operation_in_progress
        Git-->>Family: conflicted operation or no operation
    else manifest parses
        Family->>Git: _operation_in_progress
        Git-->>Family: operation state
        Family->>Git: _checked_manifest_committed
        Git-->>Family: index, HEAD, and modified-path state
    end
    alt refusal state found
        Family-->>User: Refusal with state-specific remediation
        User->>Git: Resolve state using the printed Git command
        User->>Family: Run the same command again
    else checks pass
        Family->>Family: mount, rewrite, and pin
        Family->>Git: git commit -- <paths>
        Git-->>Family: commit result
        Family-->>User: Success or dry-run plan
    end

Loading

State diagram for Git holder-state refusals

stateDiagram-v2
    [*] --> Clean
    Clean --> OperationInProgress: rebase, bisect, merge, cherry-pick, or stale rebase directory
    Clean --> DirtyManifest: family.yaml differs from HEAD
    Clean --> SparseExcluded: sparse rules exclude target
    Clean --> MembersFileRemoved: HEAD holds members file, work tree no longer does
    Clean --> UnparsableManifest: conflicted family.yaml
    OperationInProgress --> Clean: finish, abort, quit, or git bisect reset
    DirtyManifest --> Clean: git commit -- family.yaml or git checkout HEAD -- family.yaml
    SparseExcluded --> Clean: git sparse-checkout disable or add required patterns
    MembersFileRemoved --> Clean: remove members from index and commit removal
    UnparsableManifest --> Clean: resolve family.yaml conflict and end the act

Loading

Flow diagram for pre-write holder validation

flowchart TD
    Start["add, bump, or remove"] --> Open["Family.open parses family.yaml"]
    Open --> Operation["_checked_no_operation_in_progress"]
    Operation --> Manifest["_checked_manifest_committed"]
    Manifest --> Holder["Run holder and sparse-state checks"]
    Holder --> Refuse["Refuse before any write"]
    Holder --> Proceed["Mount, rewrite, pin, and commit"]

Loading

File-Level Changes

Change	Details	Files
Expand pre-write holder-state detection and tailor refusal remediations for operations that Git cannot safely continue or that would cause unintended commits.	Detect unfinished bisects via BISECT_LOG and identify stale rebase directories lacking head-name. Generate operation-specific exits, including bisect reset and rebase quit, while preserving mark ordering and linked-worktree paths. Name merge conflicts in family.yaml after YAML parsing fails, without running Git checks before earlier manifest validations. Recommend disable alone for empty non-cone sparse rules because sparse-checkout add would remove other files.	scripts/family.py
Prevent add from absorbing destructive members-file transitions into its commit.	Detect when HEAD holds members as a file but the index or work tree no longer does. Refuse staged moves/removals and unstaged deletions before mounting a member. Provide separate remedies for committing the transition or removing the stale index entry with git rm --cached.	scripts/family.py
Refuse dirty or staged family.yaml changes before add, bump, and remove rewrite and commit the manifest.	Compare HEAD, index records, and Git's modified-path output to distinguish staged, unstaged, deleted, and unmerged states. Apply the check consistently to all three verbs while preserving first-add behavior when HEAD has no family.yaml. Offer explicit keep-by-committing or drop-by-checking-out remedies.	scripts/family.py
Align manifest/member-path remediation text and existing expectations with the new refusal ordering.	Require hand-restored member rows to be committed before retrying. Update bump, dry-run, rollback, and member-path tests for dirty-manifest precedence and committed fixture edits.	tests/test_family.py tests/test_family_bump_remove_rollback.py tests/test_family_dry_run.py tests/test_family_member_path.py
Add comprehensive coverage for the five newly modeled holder states and dirty manifest handling.	Exercise real and dry-run refusal parity, no writes, exact remediation text, and successful retry after each remedy. Cover bisects, stale rebase directories, empty sparse rules, conflicted family.yaml, members-file deletion/moves, and staged/unstaged/unmerged manifest states. Verify operation ordering, Git behavior premises, and commit contents.	tests/test_family_holder_states.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#684	Refuse add when HEAD tracks members as a file but the work tree no longer has that file, and provide a remedy that avoids folding its deletion into the add commit.	✅
#684	Detect an in-progress git bisect before writes and explain how to exit it with a remedy that works.	✅
#684	For an empty non-cone sparse-checkout rules file, give a remedy that restores the checkout without removing other files from the work tree.	✅
#684	Correctly detect cherry-pick and revert operations when their state is stored in a reftable, or establish that this is not a defect.	❌	The PR explicitly leaves the reftable case untested and unchanged because its Git host is version 2.43; it does not verify the behavior on Git 2.45 or later or add a reftable-aware check.
#684	When a rebase state directory has no head-name, distinguish it from a readable rebase and recommend an exit that works, such as git rebase --quit.	✅
#684	When a merge conflict makes family.yaml unparsable, retain the YAML refusal while naming the merge and its remedy, without running Git before earlier member-path refusals.	✅

Possibly linked issues

• family.py add/bump/remove: a members file deleted unstaged, a git bisect, an empty sparse-checkout file, an empty rebase-merge/ and a merge conflicted in family.yaml meet a refusal or remedy that does not fit (#626's gaps) #684: The PR fixes five of the issue’s six specified gaps with matching refusal and remediation behavior; it explicitly leaves reftable unverified.

---

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.

[brettheap]

(lane openRepoShape-1, 2026-10-17T11:49:51Z)

Lane 1's independent review of #816 at 772105a: CHANGES NEEDED

Nothing here is a code defect in the five fixes, and the reads are clean. Three printed or posted texts are untrue as they stand, and each needs a small change. A fourth finding is a narrow gap in "dirty" that is worth closing in this PR.

Setup. I merged head 772105aa locally with current main bb439a29. Main moved past the PR body's bf1f099b by #706, which adds one test file. The merge was clean, and scripts/family.py is unchanged by it (sha256 f86d9172…, the new test file 4b89cf1d…, both as the body says). Every probe used a stub gh (exit 97), a bogus token, an empty GH_CONFIG_DIR and GIT_CONFIG_GLOBAL=/dev/null, on the suite's own offline fixtures.

The issue's lines

line	on main	on the merge	verdict
E1 members file gone, unstaged or staged	add exit 0, committed dc02f3a29d82: .gitmodules, members/IRQS, family.yaml (it takes D members)	refused member-path-unaddable, both halves	fixed (texts: R1)
E2 bisect	REFUSED family-holder-detached: …/InkRouter is not on a branch…	family-operation-in-progress … a bisect … git bisect reset	fixed
E3 emptied non-cone rules	remedy names git sparse-checkout add …	disable alone	fixed as worded (checklist 2)
E4 reftable	not measured	not measured (git 2.43 here too)	not fixed (R3)
E5 empty rebase-merge/	…git rebase --abort drops it	git rebase --quit	fixed
N4 merge conflicted in family.yaml	yaml-unparsable, no remediation	the merge, its mark and its exits	fixed
#459 line 66, dirty family.yaml	the hand edit goes into the verb's commit	refused, staged or not	fixed (one gap: F4)

I also ran the new test file against main's family.py: 31 of 36 failed. The 5 that pass are the premise and control tests.

Ranked findings

R1 (required, text). Both E1 remedies print a bare git commit and say "on its own", but a bare commit takes every staged change. _commit_one's own docstring names this hazard ("a bare git commit takes whatever anyone staged").

Repro, in an empty_holder with a file named members committed:

echo x > README-other.txt && git add -- README-other.txt
rm members                                   # or: git mv -- members members-file
family.py add …                              # REFUSED member-path-unaddable, remedy as printed
git rm --cached -- members                   # unstaged half only
git commit -m 'as printed: git commit'
git show --name-status --format= HEAD

On the merge:

• The unstaged-deletion remedy's commit was A README-other.txt, D members.
• The staged-move remedy's commit was A README-other.txt, R100 members members-file.
• On main, add takes the deletion into its own commit instead (table above).

A pathspec on the commit works only in some states:

• After git rm --cached -- members with nothing on disk, git commit -- members exited 0. It committed only D members, and A README-other.txt stayed staged.
• Where a hand-made members/ directory is on disk, the same command exits 128 (error: 'members' does not have a commit checked out, fatal: updating files failed).
• For the staged move, git commit -- members members-file exited 0 with only R100 members members-file.

The smallest true fix is the text. In both remedies in _members_file_left_in_head, and in MOVED_REMEDY and DELETED_REMEDY in tests/test_family_holder_states.py, replace

(git commit)

with

(git commit, with nothing else staged: a bare git commit takes every staged change, and git status lists them)

As an option, print git commit -- members where nothing is on disk at members.

R2 (required, text). Decision 3 missed one remedy: family-members-unrecognised still sends the person straight into the new refusal. Measured with remove:

1. Commit a comment on the members: line. remove then says REFUSED family-members-unrecognised: … has 0 members: line(s) … with "fix it by hand this once."
2. Fix the line by hand and run remove again. It now says REFUSED family-manifest-uncommitted: family.yaml holds a change HEAD does not: git lists the work tree's copy as modified, ….

That refusal can only be reached once the shape is committed: an uncommitted shape meets family-manifest-uncommitted first. So "commit that" is always the right instruction there. In Family.rewritten, and in tests/test_family_add_refusals.py:453, replace

fix it by hand this once.

with

fix it by hand this once and commit that (git commit -- family.yaml), then run the same command again.

R3 (required, PR text). "Closes #684" would close the issue with E4 unmeasured. The issue itself says to "tick them there when this closes" on #459, so closing it ticks E4 there falsely. No other issue carries E4: the only other reftable issue is #764, which is bootstrap's. Either file E4 on its own before landing and name it in the body, or replace Closes #684 with:

Part of #684: E1, E2, E3, E5 and N4, and #459's line 66. E4 (reftable) stays open on #684 until it is measured on git 2.45 or later.

F4 (should fix, small). "Dirty" compares the index's object with HEAD's but not its mode. Repro: chmod 755 family.yaml && git add -- family.yaml, then a real remove. It exited 0, and git show --summary HEAD printed:

 mode change 100644 => 100755 family.yaml
 delete mode 160000 members/IRRS

Decision 1 says "the index differs from HEAD", and here it does. One fix: read HEAD's entry from git ls-tree -z HEAD (no pathspec, as _tree_entries reads it) and compare mode and object with the stage-0 record. Otherwise, add it to "What it cannot tell".

F5 (not required; lane 4's call under Brett's word). In #210's state, the "keep" way out makes a commit whose row and gitlink disagree.

• Typed as printed, git commit -- family.yaml committed M family.yaml alone.
• HEAD:members/IRRS stayed 5876436b… while the row named 3657b10a….
• The same bump run again finished it in a second commit (IRRS 3657b10af614 -> 3657b10af614, committed 944110eecee1: members/IRRS, family.yaml).

The "drop" way out works, as the adjusted test proves. The writer's docstring already knows this. If the refusal is to say it, it could name the drop alone where the index also stages a members/ gitlink that HEAD does not hold.

The three decisions, attacked

1. What "dirty" means. I found no false "dirty" on a clean holder. In each case below, git status --porcelain and ls-files -m were empty and all three dry runs exited 0:

   • mtime moved +5 s;
   • the same bytes rewritten;
   • racily clean (file mtime equal to the index's);
   • core.autocrlf=true;
   • .gitattributes family.yaml text eol=crlf with a CRLF copy, then touched;
   • core.filemode=false with chmod 755.

   The only hole is F4. Assume-unchanged is disclosed: measured, +# hidden edit went into remove's commit. Skip-worktree is pre-existing (checklist 6). A holder with no family.yaml in HEAD is not asked, and its first-add test passes.

2. family.py bump to the commit already pinned exits 2 as "REFUSED a git or gh command failed" around git's "nothing to commit", where family.py documents exit 1 for nothing and bump-leg.py answers the same re-run with "nothing to do", exit 1 #210 refused. This follows the ruling, and the "drop" way out is proven. See F5.

3. "and commit that". Right for both member-path remedies, but incomplete: see R2.

Destructive remedies

• git rm --cached -- members touches no file. A hand-made members/X holding its own git repository was intact afterwards (exit 0; X/f and X/.git still there). A symlink at members meets git's own dry-run refusal (pathspec 'members/IRQS' is beyond a symbolic link). The one loss is checklist 4.
• git checkout HEAD -- family.yaml drops only what the refusal offers to drop, and it says so ("to drop it"). In the stash-pop state, git keeps the stash entry on a conflicted pop. That is git's documented behaviour; I did not measure it here.
• Holder states. E2 and E5 are read with rev-parse --git-path and lexists, and E3 with sparse-checkout list; all are read-only. Each refusal precedes the first write, and test_a_dry_run_runs_no_git_command_that_writes passes.
• No new network call.

Tests

• Reverts. I spot-checked three mutants against the new file:
  • remove's _checked_manifest_committed call removed: 6 failed.
  • E1's index-held branch returning None: 4 failed, matching the PR's row.
  • ls-files -m not asked: 5 failed, matching the PR's row.
• The six adjusted tests are honest. Each old behaviour was changed by the ruling, and none hides a regression:
  • test_bump_to_the_commit_already_pinned_leaves_an_uncommitted_edit_alone: the edit is still left alone.
  • The family.py bump to the commit already pinned exits 2 as "REFUSED a git or gh command failed" around git's "nothing to commit", where family.py documents exit 1 for nothing and bump-leg.py answers the same re-run with "nothing to do", exit 1 #210 test still proves the one-commit finish.
  • The three members:-comment fixtures still reach family-members-unrecognised, now through a committed edit.
  • The [no-path-line] control.
  • The two member-path remedy texts.
• Byte-identical output, main against merge. For add, bump and remove, each real and dry, on the same holder copy at the same path with fixed dates: stdout, stderr and the resulting HEAD were identical in 6 of 6.
• Sonar, by reading only, not analysed:
  • no composite asserts and no pytest.raises;
  • the new functions' cognitive complexity looks well under 15;
  • the new test file repeats "remove", "members" and "commit" as its landed neighbours do (test_family_refuse_up_front.py has "remove" 12 times).

Windows

I found no concern. There are no os.name paths. The tests write bytes. The git mv exit 128 and the rebase --abort text are git's own on every OS. The N4 test builds its path with as_posix() from the same resolved root the code uses.

Runs on the local merge (git-filter-repo on PATH)

• test_family_holder_states, test_family_member_path, test_family_bump_remove_rollback, test_family_dry_run: 169 passed.
• test_family, test_family_refuse_up_front, test_family_add_refusals: 248 passed.
• The four files the writer left out (test_family_init_values, test_shape_pin_files_not_a_list, test_update_shape_add, test_setup_project_py): 384 passed, 19 skipped.
• test_repo_hygiene, test_cli_reference, test_agents_md_codes: 146 passed.

For the checklist (outside the issue)

1. E4 reftable, wherever R3 puts it.
2. Non-cone rules holding only a negative pattern (!/*) still get git sparse-checkout add .gitmodules members/IRRS family.yaml. Typed, it took the holder's top level from 14 entries to .git, .gitmodules, family.yaml and members (measured): E3's harm, through rules that do hold a pattern.
3. A git stash pop that conflicted in family.yaml (no act in progress) is still REFUSED yaml-unparsable: …family.yaml: line 1: merge keys are not supported, with no remediation (measured).
4. git rm --cached -- members drops a staged edit of the members file without a word. It exited 0 with nothing or a directory on disk, and the staged blob 601b695b… is then in neither HEAD nor the work tree (measured).
5. A half-finished add (stopped between its stage and its commit, M .gitmodules, M family.yaml, A members/IRQS):
   • Main says member-already-present; the merge says family-manifest-uncommitted (measured).
   • Neither way out finishes it (reasoned): "keep" commits a row with no gitlink, and "drop" leaves .gitmodules and the gitlink staged.
6. Skip-worktree on family.yaml outside a sparse checkout, edited. The dry runs exit 0, and the real remove fails late at git --literal-pathspecs add -f -- .gitmodules family.yaml. It was rolled back (status empty afterwards), on main and the merge alike (pre-existing).
7. Not measured: validate-family.py remedies that name family.py bump --to for a work-tree-only defect will now meet family-manifest-uncommitted first.

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

(lane openRepoShape-1, 2026-10-17T12:33:04Z)

Lane 1's re-verification of #816 at 4030ee6: CHANGES NEEDED

All five fixes hold. One thing still has to change: F5's new check also fires on a gitlink a person staged by hand, and there it prints a remedy that throws away the person's own uncommitted edit (N1 below).

Setup. I merged head 4030ee6c locally with current main 741679e7. The merge was clean, and family.py auto-merged with #670. Every probe used a stub gh, a bogus token and GIT_CONFIG_GLOBAL=/dev/null.

item	measured on the merge	verdict
R1	Both remedies print "(git commit, with nothing else staged: a bare git commit takes every staged change, and git status lists them)". Typed bare, the commit still carries A README-other.txt, which is git's behaviour and is now stated.	done
R2	The remedy now says "…and commit that (git commit -- family.yaml), then run the same command again." After the fix and its commit, remove exits 0.	done
R3	closingIssuesReferences: [] and #684 is OPEN. The body's last line is "Part of #684: … E4 (reftable) stays open on #684 …". Its E4 sentence is true: git here is 2.43.0.	done
F4	A staged chmod +x is now REFUSED family-manifest-uncommitted: … a change to it is staged and not committed; before, it was exit 0 with mode change 100644 => 100755. Mutant comparing the object only: 3 failed.	done
F5	#210's state now gets the drop alone, and typed, the bump makes one commit of both paths. Mutant with _gitlink_staged always false: 2 failed (the new test and test_family.py's #210 test).	done, but see N1
No false dirty	The nine states from the first round are still clean. A committed 100755 is clean when checked out (disk 755), and clean under core.filemode=false with the disk at 644. Under core.filemode=true with the disk at 644, git itself says M family.yaml, so the refusal matches git. All dry runs exit 0 in the clean cases.	holds
family.yaml a symlink in HEAD (120000)	All three dry runs exit 0, on main and on the merge.	holds
Unborn HEAD	test_the_first_add_to_a_holder_with_no_commit_makes_its_root_commit passes.	holds
Cost of ls-tree -r	On a holder of 20,019 entries, ls-tree -r -z HEAD took 0.021 s for 1.4 MB. remove --dry-run took 0.26–0.28 s on main and 0.37–0.42 s on the merge, for all the new reads together.	acceptable
Ordinary output	add, bump and remove, real and dry, against current main: stdout, stderr and the resulting HEAD identical in 6 of 6.	holds
Runs, one mode	Holder states, member path, rollback and dry run: 173 passed. test_family, refuse-up-front, add refusals: 248 passed. The four files left out first time plus hygiene, CLI reference and AGENTS codes: 531 passed, 19 skipped.	green
SonarCloud at the head	Gate OK. One open issue: S3776 on _checked_mount_path, complexity 31. Main has the same function at 30 since #670, and this PR's E1 call adds one point.	OK
CI at the head	SonarCloud, package and tests-git-bash passed. tests was still running when I checked.	pending

N1 (required). _gitlink_staged fires on any staged gitlink, not only one a stopped run left.

Repro:

1. Make a commit inside members/IRRS, then git add -- members/IRRS.
2. Write a comment line at the top of family.yaml and leave it unstaged.
3. Run remove.

The refusal names the drop alone: "the index also stages a gitlink under members/ that HEAD does not hold, as a run stopped before its commit leaves it, and git commit -- family.yaml would commit the row without it: put back HEAD's copy, …". The same happens after git mv -- members/IRRS members/MOVED plus a comment.

In both states that sentence is untrue: no run stopped, and the change is not the row. Typed anyway, "keep" (git commit -- family.yaml) committed M family.yaml alone, which is harmless. The printed drop would have discarded the person's only copy of their edit.

Every stopped add or bump stages family.yaml beside its gitlink, so ask _gitlink_staged only where the index's own copy differs from HEAD. In _checked_manifest_committed, replace

         if _gitlink_staged(index, held) else

with

         if merged and merged != [head] and _gitlink_staged(index, held)
         else

With that one change, both states above got the two-way remedy, and the selected family_yaml, F5 (stopped_before) and #210 (bump_finishes) tests had 0 failures. Please add a test for the hand-staged gitlink with an unstaged comment.

In the body's F5 bullet, replace "Where the index also stages a gitlink under members/ that HEAD does not hold, as #210's half-finished bump leaves one," with:

Where the index stages a change to family.yaml and a gitlink under members/ that HEAD does not hold, as #210's half-finished bump leaves both,

New, for the checklist:

• A half-finished add (all three paths staged) now gets the drop alone. Typed, the next add says REFUSED member-path-taken: members/IRQS already exists in the family root but no members: row names it, so the drop finishes a bump but not an add (measured). The docstring's "makes the one commit of both" holds for bump only.
• A half-finished remove (M .gitmodules, M family.yaml, D members/IRRS) never reaches this check: it stops at REFUSED member-unknown: IRRS is not a member of InkRouter. That ordering is not new in this PR.
• In a --filter=tree:0 partial clone, ls-tree -r HEAD would fetch every tree from the remote. This is reasoned only, not measured.

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

(lane openRepoShape-1, 2026-10-17T12:50:04Z)

Lane 1's re-verification of #816 at fdc90a6: PR-READY

Nothing must change at this head. The tests CI job was still running at 12:49Z, so a green Linux run is the one thing left to wait for.

Setup. I merged head fdc90a6e locally with current main cbff780c (#812 on top). The merge was clean, and family.py auto-merged. Every probe used a stub gh, a bogus token and GIT_CONFIG_GLOBAL=/dev/null.

item	measured on the merge	verdict
N1, a gitlink committed and staged by hand, plus an unstaged comment, through remove	Exit 2 with "Remediation: which change to keep is a person's to say. To keep it, commit it on its own first, git commit -- family.yaml; to drop it, …". Typed, "keep" committed M family.yaml alone.	fixed
N1, git mv -- members/IRRS members/MOVED plus an unstaged comment, through remove	The same two-way remedy. "Keep" committed M family.yaml alone.	fixed
N1 mutant (the old condition, any staged gitlink)	2 failed: test_a_gitlink_staged_by_hand_beside_an_unstaged_edit_is_told_both[commit-and-add] and [git-mv].	the test is honest
#210's stopped bump	The real run and the dry run both name the drop alone ("the index also stages a gitlink under members/ …"). After git checkout HEAD -- family.yaml, bump exits 0 with ONE commit, M family.yaml and M members/IRRS. HEAD's gitlink is --to, and status is clean.	holds
A half-finished add	Drop alone, then member-path-taken, as the body's checklist item 8 now says.	text true
No false dirty	Clean, all dry runs exit 0, in each state: touch, same bytes, racily clean, core.autocrlf=true, eol=crlf attribute, core.filemode=false with chmod, committed 100755 checked out, committed 100755 under filemode=false with the disk at 644, and a family.yaml symlink (120000). Under filemode=true with the disk at 644, git itself says M family.yaml, so the refusal matches git.	holds
Ordinary output against current main	add, bump and remove, real and dry: stdout, stderr and the resulting HEAD identical in 6 of 6.	holds
Runs, one mode	Holder states, member path, rollback and dry run: 175 passed. test_family, refuse-up-front and add refusals: 248 passed.	green
SonarCloud at the head	Quality Gate passed. One open issue: S3776 on _checked_mount_path (31). Main has the same function at 30, and the PR's E1 call adds one point; the gate is OK.	OK
CI at the head	SonarCloud, package and tests-git-bash passed. tests was still running when I checked at 12:49Z.	wait for it
Body texts	The F5 bullet opens with "Where the index stages a change to family.yaml and a gitlink under members/ …" and says the one commit of both paths holds for bump only. The N1 bullet quotes the condition verbatim. Checklist items 8–10 are there. The last line is "Part of #684: …". closingIssuesReferences is [] and #684 is OPEN.	true

Nothing new to report. I did not see squash-body.md, because it lives in lane 4's tree.

Lane: openreposhape-1 (openRepoShape-1)

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

[sonarqubecloud]

Quality Gate passed

Issues
0 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