[brettheap]

Title

family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840)

Body

Was stacked on #828, which landed on main as 9b0a7038 (its final head 3546118b). GitHub retargeted this PR to main, and the branch is restacked onto it (6ef6e4c1).

Goal (#840): where add refuses a member recorded in another case, no printed command leaves a section of .gitmodules naming another spelling, moves a live checkout out from under its .git file, or fails through a link.

#840 lists six states, and a seventh came from lane 2's rv828 review (SHOULD 3). The coordinator added an eighth on the way: a link at a variant the index holds as the member's gitlink. Each state was first typed as printed at ce0f2a5f, on git 2.43, with the gate run in all three modes and the same add run after. The link states were also typed on git 2.47.1. Every change is in scripts/family.py, which is not a pinned copy, so no upstream-changed row follows. The validator is not touched.

Fix round 4 (rv865b's third re-check, READY at 6ef6e4c1, one NIT)

The commit after the restack, 231c404c, adds one test for rv865b's NIT 1, test_a_second_paths_checkout_is_asked_in_its_own_spelling. The state is a gitlink at Members/IRRS, committed, with its skip-worktree bit set, and Members a link to members, which makes Members/IRRS resolve to the member's own checkout, as a disk that folds case would.

The test asserts the whole text:

• the link is moved out first;
• then git rm -r --cached --sparse -- Members/IRRS and its commit;
• and no line says to delete a checkout.

It then types that text as printed, and the gate passes. Mutant C5, which asks for the checkout whatever the spelling on disk, is caught by it.

Fix round 3 (rv865b's second re-check, NOT READY at 38e0d503)

The sixth and seventh commits, adb20242 and 4e92867a, answer rv865b's findings. The round is two commits because the first was a pause's work in progress, and nothing is amended.

• MUST 1. The second path's git rm -r --cached now takes -f where the move back's would. That is where the index stages the gitlink at a commit HEAD does not record there and a checkout is on disk at it (_forced, family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's rule). It prints the move back's own words on what -f does (FORCED_SAID, now one constant for both), and --sparse -f where both apply. At 38e0d503, plain git rm --cached was refused there (staged content different from both the file and the HEAD, exit 1), for (a) staged with an untracked file or a commit of its own, and for K2 reset with work in the checkout.
• SHOULD 1. The checkout a second path leaves on disk is named to delete by hand in the same round, with its git -C <path> status, before the update.
  • At 38e0d503, K2 committed's update pointed the store that checkout shares with the member at members/IRRS, so the status printed nothing while WIP.txt was there. The next run then said to delete the checkout.
  • The update is not left to the next run instead, because nothing would print it there once the checkout is gone, and the member would be checked out nowhere.
  • (a), (b), K2 committed, reset and foreign, and the sparse state now each take one round.
• NIT 1. The count for _members_spellings is corrected and recounted (line 4).
• NIT 2. typed_as_printed's def line is f7072d08's again.
• N2. rv865b ruled it acceptable as is, so nothing changed for it.

Fix round 2 (rv865b's re-review, NOT READY at f7072d08)

The fifth commit, 38e0d503, answers rv865b's findings:

• MUST 1. A gitlink at a case variant of a row's path, beside the member's own gitlink at that path, is now taken out of the index with git rm -r --cached -- <variant>, the gate's own line for a second path. It is no longer renamed with git mv. At f7072d08, git mv carried the section that gives its path along under the same name, and the take-out then stripped it, so renamed-1 was a gitlink no section names. The gate passed, but a plain clone's git submodule update --init --recursive exited 128, and that is the holder's own CI path (validate.yml). The checkout left on disk is the next run's CHECKOUT, deleted by hand. See line 1.
• K2. The clause "never point back a section whose path is a gitlink in the index" is dropped, together with the change above, as rv865b rules. Its four states are tests now.
• NIT 1. _variant_in_members asks os.path.islink before samefile, so a link members/irrs -> IRRS is named again on Linux. See line 3.
• NIT 2. rv865b's surviving mutants X1, X2 and X6 are pinned.
• NIT 3. A take-out printed after the point-back's own commit is committed too: that commit takes a staged .gitmodules into HEAD.
• NIT 4. The closing guard takes the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839's form, [ ! -L V ] && { [ ! -e V ] || [ V -ef R ] || [ -e V/.git ]; } || mv -- V ../<V>, with its words. That is the form lane 5's the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839 prints in validate-family.py (77f8a6c8), so the two texts agree. A link at the variant is now moved in the first round. See the added state.
• NIT 5. This body: line 1's claim now carries its caveat, and the merge checks name main 3bf2d3c9.

Fix round 1 (rv865's review, NOT READY at 4268f804)

The third and fourth commits, dde7e9cc and f7072d08, answer rv865's findings:

• MUST 1. A section beside the member's own section is no longer pointed back. It is taken out with the gate's own --unset-all lines. Only the section named after the row's path is pointed back, and only where no section gives that path. See line 1.
• SHOULD 1. On a disk that folds case, the member's own checkout listed in another spelling is no longer refused. See line 3.
• NIT 1. R7, R8, R9, R10, R13, R23, R25, R25b, R26 and R42 are pinned by tests now. R20 and R21 are not, and "Not here" says why.
• NIT 2. This body's mutant count and merge checks are corrected.
• NIT 3. _checked_gitmodules_as_staged has base's def line again, and its complexity went down. See line 4.

A point-back printed after a commit is now committed too. That earlier commit (a pending change, or the index's rename or removal) takes a staged .gitmodules into HEAD. At 4268f804, a staged section edit beside a committed Members/README left the point-back staged, and the gate found member-gitmodules-absent in every mode.

Line 1: a section that names a variant, with the gitlink at the row's path

Measured at ce0f2a5f. The gitlink stays at members/IRRS, and the section is hand-edited to Members/IRRS.

• Committed or staged, add exits 0 and commits that .gitmodules beside the new member.
• The gate exits 1 in every mode: gitmodules-path-unnamed, plus member-gitmodules-absent once committed.
• With the edit not staged, gitmodules-unstaged comes first; typed, it leads to the staged state, and add goes through.
• A section giving members/irrs behaves the same way.

What changed. _sections_astray finds each section that gives a case variant of a row's path, where the index holds the member's gitlink at that path. _row_sections_astray then tells two cases apart, as the gate does:

• No section gives the row's path. This is the gate's member-gitmodules-absent case. The section named after the row's path, the name add gives a member's section, is pointed back with the gate's own line: git config -f .gitmodules submodule.members/IRRS.path members/IRRS, then git add -- .gitmodules. Its place is "in .gitmodules, its gitlink at its row's path". A gitlink at its path is taken out of the index first (below), which leaves the section where the point-back finds it, in the same round.
• A section gives the row's path. Each other one is a second section beside it, which the gate's gitmodules-path-unnamed calls STRAY. It is taken out, every key it holds, with the gate's own lines: git config -f .gitmodules --unset-all submodule.Members/IRRS.path and the same for url, each key quoted for a POSIX shell, then git add -- .gitmodules. Its place is "in .gitmodules, beside the section giving its row's path".
• A gitlink at such a path, beside the member's own gitlink, is a second path to the member's directory (fix round 2). It is taken out of the index alone, git rm -r --cached -- Members/IRRS, as the gate's own line does (UNSTAGE_SECOND). It takes --sparse where the sparse rules leave it out or its bit is set, and -f where the index stages it at a commit HEAD does not record there beside a checkout (fix round 3). That comes before the take-out, and git rm --cached leaves the section for it. A checkout there that git submodule add or git mv made, on disk in its own spelling, is named to delete by hand in the same round, with its git -C <path> status, before the update (fix round 3). A clone of its own is not named: the next run moves it out whole.
• Once the member's own section is pointed back, any other variant section is beside it, and is taken out the same way.
• A variant section that is neither is left to the gate, which names it and prints no command for it.

The code is family-members-dir-variant, as for any other path under another spelling of members/. Each part commits where HEAD's copy holds what it changes, or where a commit printed before it took a staged .gitmodules into HEAD: a pending change, the index's rename or removal, or, for a take-out, the point-back's own commit (fix round 2). After a staged edit alone there is nothing to commit, and git commit would fail. A change nobody has staged is staged first, as #685 does for the move back.

A point-back closes with the update, git submodule update --init --recursive, where nothing is checked out at the row's path. That is the state of a fresh clone: no section gives members/IRRS, so nothing is checked out there. Beside a move back of another member, the one closing update names both rows. A take-out needs no update: the member's own section gave its path all along.

Why the take-out (rv865's MUST 1). At 4268f804, every variant section was pointed back, whatever submodule it belonged to. Measured again on that head with the text checks left out, on git 2.43: after git submodule add <IRSS's remote> Members/IRRS (kept, at members/irrs, or with its checkout deleted), or with the section git rm --cached leaves behind, the remedy typed as printed gave members/IRRS twice. The gate exited 1 in every mode, and a recursive clone of the pushed branch exited 128: Fetched in submodule path 'members/IRRS', but it did not contain <commit>.

Caveat on fix round 1's claim (rv865b's MUST 1). The first fix round said that the same four states and a fifth type clean, that the recursive clone checks members/IRRS out, and that the gate passes. That held for a recursive clone only. In (a) and (b), the take-out ran after git mv of the same gitlink. It stripped the section git mv had carried along, and left renamed-1 a gitlink no section names. A plain clone's git submodule update --init --recursive then exited 128 (No url found for submodule path 'renamed-1' in .gitmodules), and so did git submodule status, in the holder and in the clone. The gate cannot see this, since it asks only gitlinks under members/.

Since fix round 2, that gitlink is taken out of the index and never renamed. Measured at 4e92867a on git 2.43 and 2.47.1, the five states and two more type clean:

• the two more are a staged section taken out after the point-back's commit, and a staged one whose name needs quoting;
• each takes one round; in (a) and (b), the checkout git rm --cached leaves is deleted by hand where the text says (two rounds at 38e0d503);
• a recursive clone checks members/IRRS out from IRRS's remote at its commit;
• a plain clone's git submodule update --init --recursive exits 0 with every member checked out;
• git submodule status exits 0 in the holder and in both clones;
• the gate passes in all three modes, and the same add goes through.

rv865b's four K2 states (the gitlink at Members/IRRS beside the member's own, with the member's section astray: committed, reset, checkout deleted, and beside a foreign section) do the same, in one round each.

Work in the second path's checkout (fix round 3). These states type clean in one round too:

• (a) staged with an untracked file;
• (a) staged with a commit of its own;
• (a) staged and left out by the sparse rules, which gives --sparse -f;
• K2 reset with work;
• K2 committed with work.

Where the text says to delete the checkout, its git -C Members/IRRS status still names the untracked file, and its commit is kept in its store.

Line 2: git mv of a directory moves an untracked checkout inside it

Measured at ce0f2a5f. Members/X/notes is committed, and a checkout that git submodule add made at Members/X/Y is taken out of the index. #574's git mv -- Members/X <new name> typed as printed moved the checkout too. git -C renamed-1/Y status then said fatal: not a git repository: .../renamed-1/Y/../../../.git/modules/Members/X/Y.

A checkout the index still records under that directory is moved by git mv with its .git file mended: git -C renamed-1/Y status exits 0.

What changed. Each checkout git does not track, inside a directory that a git mv (RENAME) or a plain mv (MOVE) moves, is named first (CHECKOUT_FIRST, _checkouts_in_the_way). It is to be deleted by hand once nothing only it holds is needed, as #828's CHECKOUT says of one found on disk. Its commits stay in the holder's store. git -C <checkout> status shows what is not committed.

• The walk does not follow links, and does not enter a directory that holds a .git entry, so a checkout's own legs are not named again.
• A gitlink the index holds is not named, and neither is a clone of its own, whose .git is a directory: the move takes it whole.
• The moved directory itself is not entered when it holds a .git entry.
• The plain mv case is the same fault, so it is covered too.

The fix round pins the last three (rv865's R7, R8, R9, R10) with a clone of its own at Members/X, legs checked out, and with a plain Members/X holding such a clone and a link to a directory outside the holder. In both, only mv -- Members/X <new name> is printed. #828's test_a_checkout_under_an_index_entry_is_the_indexs_to_name did not pin R7: that directory has no subdirectories.

Line 3: a variant of a row's path under members/ itself

Measured at ce0f2a5f, beside the row members/IRRS. In each of these states add exits 0, so a person meets nothing:

• a file members/irrs in the index;
• the same file on disk;
• that file in HEAD alone, its removal staged;
• an untracked directory there;
• a second gitlink there;
• the member's own gitlink moved there, family.py add: where another member's own gitlink sits at a case variant (Members/<P> for its row members/<P>), the refusal's remedy prints git rm -r --cached or git mv, which takes that member's gitlink away from its row #646's state under members/.

The gate passes the first four. It refuses the second gitlink in every mode (member-gitlink-unnamed). For the member's own gitlink it exits 2 in members mode, and member-gitlink-unnamed under --no-members.

What changed. _spelled_target takes the rows' paths. Under members/ itself, a case variant of a row's path that is no row's own path is now a target, as a variant of the mount path already was.

• It flows through the index, HEAD and disk checks, so each state gets family.py: add refuses, before the member is read and on every disk, any path under another spelling of members/, in its index, in HEAD or on disk, and names a remedy per entry that never moves the members' checkouts (#362, #363, #364) #574's remedy.
• The member's own gitlink gets family.py add: where another member's own gitlink sits at a case variant (Members/<P> for its row members/<P>), the refusal's remedy prints git rm -r --cached or git mv, which takes that member's gitlink away from its row #646's move back.
• A section whose gitlink's removal is staged gets family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's IN_GITMODULES put-back.
• A second gitlink that git submodule add made there, with its own section, is taken out of the index, its section is taken out, and its checkout is named to delete by hand in the same round (line 1, fix rounds 2 and 3). A second gitlink with nothing on disk is taken out of the index as before.

The code is family-members-dir-variant. Its first sentence says what was found (_lead): "a case variant of the path of a members: row under members/, the same path as that row's on a case-insensitive disk". It is joined to the other-spelling sentence where both are found. A folding disk, asked in process with disk_as, gives the same text.

On a disk that folds case (rv865's SHOULD 1), _variant_in_members lets through an entry of members/ that the disk takes for the row's own path (os.path.samefile, as _members_dir_on_disk asks of members/). macOS and Windows list a directory in the spelling it was made in. So after git mv members/IRRS members/irrs and line 3's move back, whose closing guard [ members/irrs -ef members/IRRS ] is true there, the member's only checkout is listed as members/irrs. At 4268f804 the next add refused it as on disk and untracked, every time. Now it goes through. On Linux the two are two paths, members/IRRS holds nothing, and members/irrs is still named.

A link is never the row's own (rv865b's NIT 1). samefile follows a link, so at f7072d08 a link members/irrs -> IRRS was let through on Linux and add went through beside it; 4268f804 named it. _variant_in_members now asks os.path.islink first, as _members_dir_on_disk never takes a link for members/. The link is named on disk, on disk and untracked: members/irrs (a symlink), and moved out of the holder, the link alone.

Line 4: an unmerged .gitmodules the work tree also lacks

Measured at ce0f2a5f. git mv members Members is committed, then .gitmodules is left unmerged (stages 1, 2 and 3) and deleted from the work tree. _checked_gitmodules_as_staged leaves a missing copy to git for add, so the rename back was printed. Its commit failed: Committing is not possible because you have unmerged files. In #646's state the commit fails the same way, and the update says No url found.

What changed. _gitmodules_first asks first. For this state it raises gitmodules-missing (_gitmodules_missing) with the restore git takes there, as remove prints it: git checkout --merge -- .gitmodules, resolve it, git add .gitmodules.

The detail says why for add. remove's text is unchanged, byte for byte. An unmerged copy is now asked first wherever the spelling refusal is raised, not only beside a gitlink, since any printed commit fails beside it.

NIT 3. _checked_gitmodules_as_staged has the def line base had, def _checked_gitmodules_as_staged(root: Path, verb: str) -> None:, and no spelled parameter. The missing-file refusal moved into _gitmodules_missing, which it raises for remove and _gitmodules_first raises for add. By hand, its cognitive complexity went from 35 at 4268f804 (34 at base) to about 18, so Sonar keeps that issue as the old one, lower. The new functions are under 15 by hand: _gitmodules_missing about 12, _row_sections_astray about 8 (9 before fix round 2 dropped K2's clause), _variant_in_members about 9 (8 before NIT 1's islink).

Fix rounds 2 and 3, measured with rv865b's estimator (cogc.py, comprehensions not counted):

• New functions: _second_gitlink 2, _second_path_part 5, _second_checkout_part 2, _forced 1, _removed 2.
• _point_back_part: up 1, to 3.
• _spellings_refusal: down 2, from 38 at f7072d08 to 36, since the removal's condition moved into _removed.
• _move_back_line: unchanged at 9.
• _members_spellings: from 41 at f7072d08 to 45 at 38e0d503, then 46 now. Round 2 added 4: its if, nesting, its and, and out = … or …. Round 3 adds 1, the and in checkout = present and …. The fix round 2 body said 3. Its def line is unchanged, and it was over 15 before this PR.
• typed_as_printed: 31, as at f7072d08, and its def line is that commit's again.

Line 5: a deletion of .gitmodules already staged

Measured at ce0f2a5f. git rm .gitmodules, with HEAD holding the file. The printed rename back, or move back, and its commit took .gitmodules out of HEAD with every member's section. The gate then found member-gitmodules-absent for each member.

With git rm --cached .gitmodules, a copy stays on disk, untracked:

• beside the rename back, git mv staged that copy again, and the result passed;
• beside the move back, the commit took the deletion as well, and left the copy untracked.

What changed. _gitmodules_beside tells the two apart: GITMODULES_DELETED where the work tree has no copy, and GITMODULES_UNTRACKED where it has one.

• Deleted: the refusal's first part puts HEAD's copy back, git checkout HEAD -- .gitmodules, as remove prints it and as family.py add: a members/ renamed with git mv is renamed back in two steps through a free name, after what the disk lacks under it is put back, and a printed --sparse says the git it needs, so no remedy fails as typed (#685) #767 does for a copy deleted from disk.
• Untracked copy: gitmodules-unstaged comes first ("its deletion is staged"), since which copy to keep is the person's.

Both apply wherever anything is found, so a lone Members/README rename is covered too: its commit took the deletion as well.

Line 6: Members a link to a directory outside the holder

Measured at ce0f2a5f, which does not answer it. #828's set-aside part does not reach this state. git rm -r --cached --ignore-unmatch -- Members/IRRS Members/IRSS exits 128: fatal: not a git repository: Members/IRRS/../../.git/modules/members/IRRS.

The rest of the line then ran, but the gitlinks stayed under Members/, and the next add refused again. Through the same link, plain git mv -- Members/README x moves the file in from where the link points.

What changed. A symbolic link that the index holds entries under is named on disk and moved out of the way first (LINK_OUT, _disk_found). The words are those member-path-unaddable has for members itself: "must be a plain directory of the holder's own".

_on_disk_as_named now takes nothing beyond a link as on disk. So a file under it is taken out of the index (git rm -r --cached), not given a git mv that would fail once the link is gone (bad source).

Typed as printed:

• the link moves;
• the move back runs with both sections;
• the guarded mv moves nothing;
• the update checks both members out at their rows' paths.

The directory the link named is left where it is. A checkout there was unusable already, since its .git file is relative.

Line 7 (rv828's SHOULD 3): an unmerged file in the way of the move back

Measured at ce0f2a5f. After git mv members/IRRS Members/IRRS, an unmerged file at or under members/IRRS left the row neither blocked nor a stray. So the gitlink kept #574's git mv -- Members/IRRS <new name>, which took it away from its row, and the commit failed.

An unmerged file at members itself, off disk: each git update-index ran, and the commit failed. On disk, member-path-unaddable printed git mv -- members <new name>, which exits 128 (fatal: conflicted).

What changed.

• _rows_held counts a file or link at any stage as in the way.
• _set_aside takes an unmerged entry out of the index, every stage, with git rm -r --cached, which git allows there (ASIDE_UNMERGED). Where the entry is on disk as the index holds it, it is then moved out of the way with mv (ASIDE_UNMERGED_MV).
• Measured why the mv is needed: a file left at the row's path made the update fail (could not create directories for members/IRRS/.git). One left under it stayed in the member's checkout, which git status then lists as modified.
• The removal is a change to commit only where HEAD holds the entry. With the move staged, no commit is printed.
• An entry held at stages 1 and 3 alone, which this side deleted, is unmerged too.
• _members_is_a_file gives an unmerged members the same two steps, plus the commit on its own where HEAD holds the file.

The coordinator's added state: a link at a variant the index holds

Already answered at ce0f2a5f. Measured on git 2.43 and 2.47.1, with #646's state and a link Members/IRRS on disk, pointing to the member's checkout or to nowhere. git 2.47.1 refuses git status itself: error: expected submodule path 'Members/IRRS' not to be a symbolic link. add reads no git status on this path, and gives its spelling refusal first: no git fatal: and no traceback, for add --dry-run and the real run alike.

At f7072d08, typed as printed on 2.47.1:

• the move back ran;
• the closing guard kept a link to the row's own directory ([ Members/IRRS -ef members/IRRS ] follows it);
• the next add named it on disk, with its mv;
• typed, the gate passed and add went through: three rounds.

Since fix round 2 (rv865b's NIT 4), the closing guard takes #839's form, which asks [ ! -L Members/IRRS ] first, so a link there is always moved, the link and never what it points at. The guard now moves the link in the first round, and the next add goes through: two rounds, typed under dash and under bash, on git 2.43 and 2.47.1. A link to nowhere was moved in the first round before, and still is.

test_a_link_at_a_variant_the_index_holds_is_refused_first pins this. Its refusal check is refused_untouched(..., status=False), so snapshot skips git status, which git 2.45.1 and later refuse here, and keeps every other key.

The guard holds ; inside its braces, so the tests' typed_as_printed now splits the remedy into parts at ; outside backticks only (remedy_parts).

Tests

New file tests/test_family_add_spelling_leftovers.py, 70 cases. Each typing test types every printed command as printed, with typed_as_printed, in the state it describes. Each one then checks that every member is where its row says, that the gate passes in all three modes, and that the same add goes through.

Line	Cases
1	committed, staged, not staged, under members/ itself, a fresh clone, beside a move back; a staged edit after a pending change, a rename and a removal; rv865's four states, the point-back beside a take-out, a staged take-out after the point-back's commit, and a staged one whose name needs quoting; rv865b's four K2 states; the second gitlink left out by the sparse rules or marked by hand; five states with work in the second path's checkout; a staged second gitlink with nothing on disk, which takes no -f; a clone of its own at a second path, moved whole on the next run; a second gitlink marked at Members/IRRS with Members a link to members, which names no checkout (fix round 4); the section named after the row beside one giving its path; a variant section left to the gate; an unreadable .gitmodules
2	under a git mv, under an mv, a tracked gitlink's control, and a clone of its own moved whole, alone and beside a link
3	six states, a section whose gitlink's removal is staged, both disks in process for two of them, the member's checkout a folding disk lists in another case, on both disks, and a link members/irrs -> IRRS
4	one case
5	beside the rename back, the move back and a file, and the untracked copy
6	the gitlinks alone, and a file under the link
added state	two cases, typed under dash and under bash
7	five unmerged states, two with the move staged, one at stages 1 and 3 alone; members off disk, and members on disk with and without HEAD's file

Every case of line 1 that a section beside the member's own or a second path takes part in (rv865's four, the two staged take-outs, the K2 states, the sparse ones and the work states) ends the same way (typed_through):

• HEAD is pushed to a branch of its own;
• a recursive clone checks members/IRRS out from IRRS's remote at its commit;
• a plain clone, as the holder's CI makes it, runs git submodule update --init --recursive, which must exit 0 with every member checked out;
• git submodule status must exit 0 in the holder and in both clones.

Where the text says to delete a checkout by hand, it is deleted there, after the parts before it and before the update. In the work states, the hand step first asserts that git -C <checkout> status still names its untracked file.

Changed: tests/test_family_add_move_back_sections.py. Its set_aside builds the unmerged part (unmerged=, moved=). In fix round 2, one docstring names the guard's new form.

Changed, in the second commit: tests/test_family_members_case_variants.py. refused_untouched takes a keyword status=True and passes it to both of its snapshots. The link test calls it with status=False, and the narrower helper it had (refused_beside_a_link) is gone. In the third commit, its one literal Spelled tuple gains the new keys field, and in fix round 3 the new checkout field.

Changed, in fix round 2: tests/test_family_add_member_variant.py.

• guarded and the closing words take the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839's form.
• typed_in_sh types into the module's SHELL, sh unless a test sets dash or bash with monkeypatch (fix round 3). Its def line and typed_as_printed's are f7072d08's, so the remedy's split is their only change (rv865b's NIT 2).
• The remedy is split into parts at ; outside backticks (remedy_parts).

No test needs a git newer than 2.34, but for the sparse case. The second gitlink left out by cone-mode rules needs git 2.38 or later (sparse_cone, as #828's tests). So does the work state left out by those rules. The sparse cases skip where git has no git sparse-checkout check-rules, as does the staged second gitlink marked by hand. Symlink cases skip on Windows, the added state skips where its shell is missing, and states that need two names differing only in case skip on a disk that folds case, as in #828's files.

Fails on the base. The first 35 cases, run against ce0f2a5f's family.py: 33 failed and 2 passed (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w840f/base.log). The two passes pin what the base already does: the added state and line 2's control.

Fails on 4268f804. The fix round's 16 new cases, run against 4268f804's family.py: 9 failed and 7 passed, on git 2.43 and on 2.47.1 (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/oldfinal243.log, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/oldfinal247.log).

• The 9 that fail are the fixes: rv865's four states and the point-back beside a take-out, the section named after the row, the variant section left to the gate, the staged edit after a rename, and the folding disk's checkout.
• The 7 that pass pin code that was already right, as rv865 found it: the staged edit after a pending change (R26), the unreadable .gitmodules (R13), the two clones (R7 to R10), the two new unmerged states (R23, R42), and the Linux side of the folding-disk test.

Fails on f7072d08. Fix round 2's 17 new or changed cases, run against f7072d08's family.py: 16 failed and 1 passed, on git 2.43 and on 2.47.1 (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/old243.log, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/old247.log). The one that passes is the staged edit after a removal (X2), which pins code that was already right.

A copy with no check on the text was also run on both heads, git 2.43: each state is typed as printed, round after round, then put through the same checks (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/test_w865f_r2_behaviour.py).

• At f7072d08: 11 of 16 failed (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/bh-old243.log).
  • The plain clone's update failed for (a), (b) and both sparse states.
  • HEAD's .gitmodules was not the holder's for the K2 states committed, reset and foreign, and for the staged take-out after the point-back's commit, which left stale in HEAD.
  • The link members/irrs was let through.
  • The link at the variant took 2 rounds of typing before add went through, in dash and in bash.
• At 38e0d503: 16 passed (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/bh-head243.log).
• The 5 that pass at f7072d08 are (c), (d), the point-back beside a committed take-out, the staged name that needs quoting (X1, X6: f7072d08 already quoted the key and printed no commit), and K2 with its checkout deleted, which took two rounds there and ended right.

Fails on 38e0d503. Fix round 3's new and changed cases, run against 38e0d503's family.py:

• Of the 20 cases with the round's changes, 12 failed and 8 passed, on git 2.43 and on 2.47.1 (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/old243.log, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/old247.log).
  • The 12 that fail are (a), (b), K2 committed, reset and foreign, both sparse states, and the five work states.
  • The 8 that pass are the BESIDE states with no second path, K2 with its checkout deleted, and the link test under dash and bash, none of whose text or typing changed.
• The two cases added last both fail (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/old243b.log).
• A copy of the five work states with no check on the text (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/test_w865f_r3_behaviour.py) types round after round, and its hand step asserts that the status names the untracked file:
  • At 38e0d503, all five fail (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/old243b.log). Four stop at git rm -r --cached (staged content different from both the file and the HEAD): (a) staged with an untracked file, with a commit of its own, left out by the rules, and K2 reset with work. K2 committed with work fails the hand step: WIP.txt on disk but not in its status.
  • At 4e92867a, all five pass (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/bh-head243.log).

Runs

Every run went through run9.sh or run9s.sh, with the real gh unreachable and basetemps under v110/bt/.

Log	Git	Head	Files	Result
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/final243.log	2.43	4e92867a	the same 15 files, 3 shards	721 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r3/final247.log	2.47.1	4e92867a	the same 15 files, 3 shards	721 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/final243.log	2.43	38e0d503	the same 15 files, 3 shards	714 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/final247.log	2.47.1	38e0d503	the same 15 files, 3 shards	714 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/probe-head-243.log	2.43	38e0d503	rv865b's probe, which records and never asserts (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/r2/probe-head-243.jsonl)	29 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/final243.log	2.43	f7072d08	15 files, 3 shards (below)	703 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/final247.log	2.47.1	f7072d08	the same 15 files, 3 shards	703 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/full243.log	2.43	dde7e9cc	15 files, 3 shards: the 3 touched test files, the other 5 test_family_add_* files, the trio, test_family.py, test_family_remove_gitmodules.py, test_family_head_lost_gitmodules.py, test_family_holder_states.py	702 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/full247.log	2.47.1	dde7e9cc	the same 15 files, 3 shards	702 passed, rc 0
va.log	2.43	2c97e759	the new file, the issue's Verify files, test_family_holder_states.py, the trio	471 passed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w840f/vb1.log	2.43	2c97e759	the first 33 of the 65 other files that run or import family.py	2070 passed, 24 skipped, 1 xfailed, rc 0
/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w840f/vb2.log	2.43	2c97e759	the other 32 of those 65 files	1739 passed, rc 0

The 15 files are the 3 that fix round 1 touched, rv865's other five test_family_add_* files (excludes, member_id, member_variant, refusals, spellings_remedies; fix round 2 touches member_variant too), the trio (test_repo_hygiene.py, test_agents_md_codes.py, test_cli_reference.py), test_family.py, and the three files that drive .gitmodules refusals for add and remove. CI's git 2.55 was not run here. macOS and Windows disks are emulated in process (disk_as) for lines 1 and 3.

rv865b's probe at 38e0d503, git 2.43. Its typing stops after three rounds and never deletes a checkout by hand, so a state that leaves one shows the checkout named in rounds 2 and 3. Each state ends with the gate passing in all three modes.

• P1 (a) and (b) as printed, and P2: round 1 takes the gitlink out of the index. HEAD's gitlinks are then the two members alone, and git submodule status exits 0 in the holder and in the recursive clone. Rounds 2 and 3 name the checkout left at the variant.
• P3, K2: committed, reset and foreign end the same way. "Deleted" ends in one round, and add goes through.
• P4 and P4b: the take-out commits after the point-back's commit. HEAD no longer holds stale (head_has_stale: false).
• P5: members/irrs -> IRRS is refused (code 2), and so is members/irrs -> IRSS.
• P6: all four link layouts take two rounds, and the link is gone.
• L7: all six states are clean.
• P7 (a), (b) and (c) as printed: a plain clone's update exits 0, with every member checked out.
• P7's control, the rename typed by hand followed by the gate's own --unset-all lines, still gives a plain update that exits 128 while the gate passes. That is the validator's gap, which rv865b named; this PR does not print that rename.

Mutants

First round: 30 mutants, M1 to M27 plus M11b, M13b and M15b, at least one per new hunk, each run -x on the test that names its state. All 30 are caught. (The earlier text said 31.)

Mutant	What it undoes	Caught by
M1	_spelled_target: no row variant under members/	line 3 (add exits 0)
M2	_on_disk_as_named: on disk beyond a link	line 6, a file under the link
M3	_disk_spellings: no row variant on disk	line 3, a directory on disk
M4	_sections_restored: no row variant for a staged removal	line 3, the section state
M5	_rows_held: an unmerged file not in the way	line 7
M6	_in_the_way: nothing unmerged	line 7
M7	_aside_remedy: an unmerged file on disk not moved	line 7
M8	no section astray	line 1 (add exits 0)
M9	_disk_found: no LINK_OUT	line 6
M10	no checkout inside a moved directory	line 2
M11	_checkouts_under: a tracked gitlink named	line 2's control
M11b	_checkouts_under: a checkout entered (its legs named)	line 2
M12	_gitmodules_beside: no staged deletion	line 5
M13	_gitmodules_first: unmerged not asked first	line 4
M13b	_gitmodules_first: an untracked copy not asked first	line 5, the untracked copy
M14	add leaves a missing unmerged copy to git	line 4
M15	_members_is_a_file: unmerged taken for merged	line 7, members on disk
M15b	_members_is_a_file: HEAD's file not committed out	line 7, HEAD holds the file
M16	_lead: a row variant said as another spelling	line 3
M17	_point_back_part: the commit always printed	line 1, staged
M18	no update for a section alone	line 1, a fresh clone
M19	the update names the moved rows alone	line 1 beside a move back
M20	_gitmodules_part: no put-back from HEAD	line 5
M21	_set_aside_part: unmerged not said	line 7
M22	_link_part: never said	line 6
M23	_checkout_first_part: never said	line 2
M24	an unmerged removal always committed	line 7, the move staged
M25	HEAD's row variants not asked	line 3, in HEAD alone
M26	the index's row variants not asked	line 3, a file in the index
M27	refused_untouched ignores status	the link test, on git 2.47.1 only

Fix round: 19 mutants of this round's new hunks in scripts/family.py (K1 to K18 and K3a), and the 8 of rv865's survivors pinned here run again, 27 in all, on dde7e9cc's family.py, which f7072d08 keeps, each -x on the tests named (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/mutate.py, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/mut/summary.txt). All caught but K2.

Mutant	What it undoes	Caught by
K1	point back even where a section gives the row's path	the section named after the row
K2	point back a section whose path is a gitlink in the index	survived; fix round 2 drops the clause, and N14, which puts it back, is caught
K3	any variant section is the member's own, not only the one named after the row	the point-back beside a take-out
K3a	the take-out set off by any variant section	the variant section left to the gate (it survived until f7072d08 added that test)
K4	nothing taken out once the member's own is pointed back	the point-back beside a take-out
K5	nothing taken out beside a section giving the row's path	(a)
K6	a take-out never a change to commit by itself	(d)
K7	a point-back never a change to commit by itself	line 1, committed
K8	_committed ignores the earlier commit	the staged edit after a pending change
K9	only the path key taken out	(a)
K10	the earlier commit is the pending change alone	the staged edit after a rename
K11	the earlier commit leaves out the pending change (rv865's R26)	the staged edit after a pending change
K12	_variant_in_members: no samefile	the folding disk's checkout
K13	_variant_in_members: a row variant on disk never named	the same test on Linux
K14	_gitmodules_first: no gitmodules-missing for an unmerged copy off disk	line 4
K15	_gitmodules_missing: a staged copy taken for unmerged	test_family_remove_gitmodules.py
K16	_checked_gitmodules_as_staged: add no longer leaves a missing file to git	test_family_dry_run.py
K17	_sections_astray: an unreadable .gitmodules raises there (rv865's R13)	the unreadable .gitmodules
K18	the place "beside the section giving its row's path" not listed	(a)
R7	_checkouts_under: a moved directory that is a repository entered	the clone moved whole
R8	a clone (.git a directory) named too	the clone beside a link
R9	the walk follows links	the clone beside a link
R10	a directory holding a .git directory entered	the clone beside a link
R23	an unmerged entry moved with mv always a change to commit	line 7, on disk with the move staged
R25	_lead: the row sentence alone	the point-back beside a take-out
R25b	_lead: the joined sentence without the row clause	the point-back beside a take-out
R42	unmerged only where stage 2 is held	line 7, stages 1 and 3 alone

Fix round 2: 19 mutants of the round's new hunks in scripts/family.py (N1 to N18 and N7b), on 38e0d503, each run -x on the tests named (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/mutate2.py, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/mut2/summary2.txt). 18 are caught and N2 survives. N2 was run over all 200 cases of the leftovers, member_variant, move_back_sections and case_variants files, which all passed: see "Not here".

Mutant	What it undoes	Caught by
N1	_second_gitlink: any entry, not only a gitlink	line 3, a file on disk
N2	_second_gitlink: the row's path need not hold a gitlink	survives (200 passed): see "Not here"
N3	_second_gitlink: any gitlink while a row's gitlink is held, whatever its path	test_a_gitlink_the_sparse_rules_leave_out_is_renamed_with_sparse
N4	the second path renamed with git mv again	(a)
N5	a second path with nothing on disk rerouted too	(c)
N6	the second path's removal never takes --sparse	the second gitlink left out by the rules
N7	--sparse only where the rules leave it out	the second gitlink marked by hand
N7b	--sparse only where the bit is set	the second gitlink left out by the rules
N8	the second path's part never printed	(a)
N9	_second_path_part: --sparse never printed	the sparse cases
N10	_second_path_part: the git --sparse needs never said	the sparse cases
N11	_removed: the second path's removal never a change to commit	(a)
N12	_removed: a pending change committed first no longer makes a removal one	test_every_place_is_named_and_the_pending_change_is_committed_first
N13	_removed: a removal said wherever anything is committed	line 3, in HEAD alone
N14	K2's gitlink clause put back	K2 committed
N15	the point-back's own commit not counted for the take-out (NIT 3)	the staged take-out after the point-back's commit
N16	_variant_in_members: no islink (NIT 1)	the link members/irrs
N17	_closing_sentences: #828's guard again	the added state
N18	#839's form without its -L test	the added state

Fix round 3: 13 mutants of the round's new hunks in scripts/family.py, on 4e92867a, each run -x on the tests named (/tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/mutate3.py, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/w865f/mut3/summary3.txt). 12 were caught, and C5 survived until fix round 4's test test_a_second_paths_checkout_is_asked_in_its_own_spelling caught it (on 231c404c).

Mutant	What it undoes	Caught by
F1	the second path's -f never printed	(a) staged with an untracked file
F2	_forced always true	(a), which takes no -f
F3	the clause on -f never said	(a) staged with an untracked file
F4	_forced without the question whether a checkout is on disk	the staged second gitlink with nothing on disk
F5	_forced without the question whether HEAD records it at that commit	(a)
F6	a second path never forced	(a) staged with an untracked file
F7	the move back's clause dropped, now the shared constant	test_family_add_move_back_sections.py
C1	the checkout a second path leaves never named	(a)
C2	that checkout named after the update, not before	K2 committed with work
C3	every second path has a checkout	the second gitlink marked by hand
C4	a second path's checkout never noticed	(a)
C5	the checkout asked whatever the spelling on disk	the second gitlink marked with Members a link to members (fix round 4)
C6	any directory, a clone of its own too, is a checkout	the clone of its own at a second path

Merge checks

git merge-tree --write-tree of 4e92867a, after a fetch of main at 08:38Z on 2026-10-18:

• Clean: family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's final head 3546118b (tree 923bb23b), the restack's first merge.
• For information: main def45de6, which holds family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's squash 9b0a7038, conflicts in family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's own files: scripts/family.py, tests/test_family_add_member_variant.py, tests/test_family_add_move_back_sections.py and tests/test_family_members_case_variants.py. This PR still holds family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's commits from before the squash, and the restack resolves those files.

Fix round 2's check of 38e0d503 was clean against main 3bf2d3c9 and 5c54af20, and against #828's 90649e53 and 54b7699e.

Fix round 1's check of f7072d08, at about 02:55Z, was clean against main 4dea85ee, 90649e53, and the open PRs that change scripts/family.py: #814 4f6e7f83, #846 2d0e884f, #849 d98df568. Those three were not checked again in fix round 2.

The restack onto #828's squash comes next. The first commit's wider check, against every open branch of 2026-10-16 and 2026-10-17 that touches these files, found no conflict of its own.

Docs

No line of README.md, docs/handbook.html, docs/cli.md, AGENTS.md or templates/family-root/*.md states the changed text or any of these codes. --help is unchanged, and no finding code is new. The docstrings of the changed functions say what each now does.

Not here

• The validator's own text. _wrong_case_move is lane 5's the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839 (fix/839-holder-bootstrap-texts), whose guard this PR's text now matches. The validator is a pinned file and is not touched here. rv865b also found that typing the gate's own --unset-all lines after a hand rename of a second gitlink leaves the same orphan gitlink while the gate passes, since _check_gitlinks_named asks only gitlinks under members/. That gap is the validator's, and this PR no longer prints that rename.
• A harmless -f on a folding disk. On a disk that folds case, a second gitlink marked off disk at Members/IRRS resolves to the member's own checkout. So _forced prints a harmless -f there, as family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's move back does. The checkout question is asked in the path's own spelling (present), so no line says to delete that checkout. Fix round 4's test pins this with Members a link to members, the folding emulation tests/test_validate_family_remedies_typed.py uses (rv865b's round-3 NIT 1, mutant C5).
• A second gitlink whose row's path holds index entries under it (a gitlink below members/IRRS, say) rather than a gitlink at it. No rule here decides whose gitlink the variant is there, so it keeps family.py: add refuses, before the member is read and on every disk, any path under another spelling of members/, in its index, in HEAD or on disk, and names a remedy per entry that never moves the members' checkouts (#362, #363, #364) #574's remedy. Mutant N2, which drops _second_gitlink's question whether the row's path holds a gitlink, survives for that reason. It differs only there, or where the row's path is an unmerged entry whose first stage is no gitlink, which is R21's state. Each of those is a state no rule rules on, and pinning either remedy would decide it.
• A checkout that is itself the moved directory, beside an index entry inside it, keeps the index's remedy, as family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's test pins.
• An unmerged entry outside the sparse definition. git rm --cached of it may need --sparse. This was not measured, and no --sparse is printed for one.
• The "stage the change" part's reason names git mv and git rm of a gitlink (family.py add: #574's spelling remedy gives a generic <new name> after git mv members Members, git rm --cached for a pulled Members/README, and a git mv --sparse that needs git 2.34 or later #685's text). For line 1 alone, the reason is the git add -- .gitmodules that follows. The text is unchanged.
• R20 and R21 are not pinned. R20 (_members_is_a_file takes HEAD's members of any kind for the file) differs only where HEAD holds members as a tree, a link or a gitlink while the index holds an unmerged file members: a directory/file or link/file conflict that a merge may not even leave, and whether a link in HEAD should ask for the commit too is a question of its own. R21 (_rows_held takes an entry with any non-gitlink stage as in the way) differs only for an entry at the row's path unmerged with a gitlink at one stage and a file at another, made only by update-index; whose gitlink that is, and so which remedy is right, is not ruled.

Checklist candidates

• The closing guard kept a link to the row's own directory. Done in fix round 2, in the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839's form (rv865b's NIT 4).
• _sections_restored (family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828) points back every variant section of a member it moves back. It has the fault MUST 1 found in _sections_astray, for a member whose gitlink is at a variant: a second variant section, another submodule's, would be pointed back too, and the path given twice. Read from the code, not measured.
• Found in the checklist pass (t114 row 5), and done in the second commit. refused_untouched and snapshot in the tests ask git status, which git 2.45.1 and later refuse while a gitlink the index holds is a symbolic link on disk. snapshot already took status=False. refused_untouched now takes it too, and the link test passes it, so the full snapshot is kept except git status. Mutant M27 fails the link test on git 2.47.1.

Closes #840

Summary by Sourcery

Ensure family.py add names all known spelling-related leftovers first and emits remedies that can be applied cleanly without failed commits, broken checkouts, or invalid submodule metadata.

Bug Fixes:

• Make family.py add identify and remediate additional leftover path, link, checkout, .gitmodules, and unmerged-entry states before printing commands that would fail or leave members inconsistent.

Enhancements:

• Extend spelling detection and remediation ordering for case variants under members/, astray .gitmodules sections, symlinks, untracked nested checkouts, staged .gitmodules deletions, and unmerged index entries.
• Improve remediation guidance so commands restore, move, remove, or update affected paths in a safe order and correctly handle staged versus committed changes.

Tests:

• Add comprehensive coverage for the newly handled spelling-leftover states, including typed remediation sequences, cross-platform case-folding behavior, symlinks, unmerged entries, and Git versions that reject symlinked gitlinks.
• Update existing move-back and case-variant test helpers to model unmerged entries and snapshots that can omit git status.

[brettheap]

(lane openRepoShape-5, 2026-10-17T22:28Z) @codex review

[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-17T22:32:01.231744Z	4268f80	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.

[sourcery-ai]

Reviewer's Guide

The PR hardens family.py add against eight classes of path, checkout, link, .gitmodules, and unmerged-entry leftovers by detecting them in a safe order and printing executable cleanup/remediation commands, with extensive tests that type every remedy and verify the resulting repository state.

Sequence diagram for .gitmodules-first add remediation

sequenceDiagram
    participant User
    participant Add as family.py add
    participant Gitmodules as .gitmodules
    participant Git as Git index and HEAD
    User->>Add: add
    Add->>Gitmodules: _gitmodules_first
    alt unmerged .gitmodules
        Add-->>User: gitmodules-unstaged or gitmodules-missing
        User->>Git: git checkout --merge -- .gitmodules
        User->>Git: Resolve conflicts and git add .gitmodules
    else staged deletion
        Add-->>User: gitmodules-deleted
        User->>Git: git checkout HEAD -- .gitmodules
    else unstaged modification
        Add-->>User: gitmodules-unstaged
        User->>Git: git add -- .gitmodules
    else safe to continue
        Add->>Git: _spellings_refusal
        Add-->>User: Executable spelling remediation
    end

Loading

Sequence diagram for path leftovers before move-back

sequenceDiagram
    participant User
    participant Add as family.py add
    participant Disk
    participant Index
    participant Git
    User->>Add: add
    Add->>Index: Detect links, untracked checkouts, and unmerged entries
    alt indexed link contains entries
        Add-->>User: Move link out of the way first
        User->>Disk: mv link
    else untracked checkout inside moved directory
        Add-->>User: Inspect checkout with git -C checkout status
        User->>Disk: Delete checkout by hand
    else unmerged entry blocks move back
        Add-->>User: git rm -r --cached unmerged aside
        User->>Git: Remove every index stage
        Add-->>User: mv unmerged aside
        User->>Disk: mv entry
    end
    Add-->>User: Continue with git mv, mv, or move-back remedies

Loading

Flow diagram for safe family add refusal handling

flowchart TD
    A[family.py add detects spelling or leftover] --> B{.gitmodules needs priority handling?}
    B -->|unmerged or missing| C[Restore .gitmodules with git checkout --merge -- .gitmodules]
    B -->|staged deletion| D[Restore HEAD copy with git checkout HEAD -- .gitmodules]
    B -->|unstaged change| E[Stage .gitmodules with git add -- .gitmodules]
    B -->|no| F{Link or checkout blocks a move?}
    C --> G[Resolve conflicts and git add .gitmodules]
    D --> F
    E --> F
    G --> F
    F -->|indexed link| H[Move link out of the way with mv]
    F -->|untracked checkout inside moved directory| I[Inspect with git -C checkout status and delete by hand]
    F -->|no| J{Unmerged entry blocks move back?}
    H --> J
    I --> J
    J -->|yes| K[Remove all index stages with git rm -r --cached]
    K --> L{Entry remains on disk?}
    L -->|yes| M[Move it aside with mv]
    L -->|no| N[Continue]
    M --> N
    J -->|no| N
    N --> O[Run spelling and move-back remedies]
    O --> P[Run git submodule update --init --recursive]
    P --> Q[Re-run add]

Loading

File-Level Changes

Change	Details	Files
Expand add spelling/refusal analysis and remediation so every tested leftover state is identified before any unsafe Git command is printed.	Detect row-path case variants under members/, astray .gitmodules sections, staged .gitmodules deletion, links containing indexed entries, untracked checkouts inside moved directories, and unmerged entries. Order remedies so links, Git-module state, untracked checkouts, index cleanup, section correction, and move-back operations do not invalidate one another. Add targeted remediation text, commit/update handling, and support for unmerged .gitmodules and mount entries.	scripts/family.py
Add comprehensive behavioral coverage for the new refusal states and verify that printed remedies can be executed successfully.	Add 35 tests covering section spelling mismatches, case variants, moved checkouts, staged or unmerged .gitmodules, links, and unmerged files. Type printed commands, then validate member placement, gate behavior, and subsequent add success across disk and Git-version-sensitive cases. Add mutation-oriented and control coverage for tracked checkouts and already-supported link behavior.	tests/test_family_add_spelling_leftovers.py
Update existing move-back and case-variant test helpers to model unmerged entries and Git versions that reject status on symlinked gitlinks.	Extend move-back setup and expected remedy construction for unmerged index stages and on-disk moves. Allow refusal snapshots to skip git status while retaining all other state checks.	tests/test_family_add_move_back_sections.py tests/test_family_members_case_variants.py

Possibly linked issues

• family.py add: six states its case-spelling remedies still miss after #828, from a section that names a variant beside a correct gitlink to a Members that is a link to a directory outside the holder #840: The PR implements remedies and tests for the issue’s six states, including section paths, moved checkouts, links, and gitmodules conflicts or deletions.
• family.py add: six states its case-spelling remedies still miss after #828, from a section that names a variant beside a correct gitlink to a Members that is a link to a directory outside the holder #840: The PR directly fixes the issue’s .gitmodules path, row-path variant, link, and live-checkout remedy failures, with typed-remedy 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.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 4268f804ee

ℹ️ 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".

[chatgpt-codex-connector]

Preserve sparse handling for unmerged entries

When an unmerged entry blocking a move is outside the sparse-checkout definition, this branch discards its left_out/marked state and _set_aside_part consequently prints plain git rm -r --cached. Git refuses that command with “matched paths that exist outside of your sparse-checkout definition”; git rm -h defines --sparse as allowing updates to those entries. Thus the advertised remediation cannot be executed in this supported sparse-checkout case; retain the sparse state and print git rm ... --sparse for the unmerged entry.

Useful? React with 👍 / 👎.

[brettheap]

(lane openRepoShape-5, 2026-10-18T00:08:36Z) Independent review of #865 (#840) at 4268f804, for lane openRepoShape-5: NOT READY

$Q = /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad. All my logs and probe results are under $Q/v118/rv865/. On git 2.43 and 2.47.1, every one of #840's six lines and rv828's SHOULD 3 now types clean and the gate passes. But the new line-1 code (_sections_astray) takes some states the base left clonable and leaves them unclonable.

Findings, most severe first

MUST 1: scripts/family.py:4335-4346 (_sections_astray, called at :4043) points back sections that belong to other submodules. Typed as printed, the remedy breaks every recursive clone of the holder, and add then goes through.

• The fault. It points back every section whose path is a case variant of a row's path, wherever the row's gitlink is at its path. It never asks:
  • whether another section already gives the row's path exactly;
  • whether the section is the one for a variant gitlink in the index, which the same refusal renames or takes out.
• What the gate says. For that state the gate's finding is gitmodules-path-unnamed, and its own remedy is "Take the section out by hand … git config -f .gitmodules --unset-all submodule.Members/IRRS.path …". It does not point the section back. Line 1's Direction asked for the gate's own lines.
• Measured at head, git 2.43 and 2.47.1 (probe-head-e34.jsonl, probe-head-e4b.jsonl, probe-head-e4c.jsonl, probe-head-247.jsonl). The state: git submodule add <IRSS.git> Members/IRRS, committed, checkout kept. add printed git mv -- Members/IRRS <new name>, a commit, then git config -f .gitmodules submodule.Members/IRRS.path members/IRRS. Typed as printed:
  • git mv moves that section to renamed-1, and the point-back then sends it back to members/IRRS with IRSS's url. The gitlink renamed-1 is left with no section.
  • add then exits 0.
  • The gate exits 1 in every mode: FINDING gitmodules-path-twice: .gitmodules gives the path members/IRRS to 2 submodules, members/IRRS (url …/IRRS.git), Members/IRRS (url …/IRSS.git).
  • A recursive clone of the pushed branch exits 128: fatal: Fetched in submodule path 'members/IRRS', but it did not contain 5def5224… Direct fetching of that commit failed.
• Three more states end the same way, clone exit 128, on both gits:
  • the same submodule added at members/irrs. That is line 3's "a second gitlink" state made the way git submodule add makes it; the PR's test plants that gitlink without a section;
  • Members/IRRS with its checkout deleted, where the remedy is git rm -r --cached and then the same point-back;
  • a leftover section alone, IRSS's url at Members/IRRS. This is what git rm --cached of such a submodule leaves behind.
• At base ce0f2a5f, the same four states (probe-base-243.jsonl, probe-base-247.jsonl): no point-back is printed, and the recursive clone exits 0 with members/IRRS from IRRS.git. So this is a regression.
• Fix direction: point back only where no section gives the row's path exactly (the gate's member-gitmodules-absent case), and never a section whose path is a gitlink in the index. Where a stray section sits beside the member's own, print the gate's --unset-all lines or leave it to the gate. Add these states as tests.

SHOULD 1: scripts/family.py:3636-3642 (_disk_spellings, which now passes rows to _spelled_target) refuses the member's own checkout on a disk that folds case.

• The fault. macOS and Windows list a directory in the spelling it was made with. So a checkout stored as members/irrs for the row members/IRRS is named "on disk and untracked" every time add runs.
• How a holder gets there. Line 3's own move back does it. Its closing guard [ members/irrs -ef members/IRRS ] is true on such a disk, so nothing moves, and the remedy's own text says "a directory left at members/irrs is the row's own where the disk folds case" (:5011).
• Measured with disk_as(folding=True), in process, on both gits (test_e1b…). The next add says: REFUSED family-members-dir-variant … on disk and untracked: members/irrs (a directory) / "Delete by hand each checkout on disk and untracked, members/irrs …". That is the member's only checkout.
• Base goes through in the same state: code 0, E1 folding=True.
• The test does not cover this. test_every_disk_gives_the_same_answer (tests/test_family_add_spelling_leftovers.py:442-447) says each state reads "never the disk", but this branch does read the disk.
• Fix direction: skip a row-variant entry that samefiles the row's path, as _members_dir_on_disk does.

NIT 1: mutants that survive (detail under "Checked and true"). The code is right in each case; the tests just don't pin it.

• R7: the guard that stops _checkouts_under walking into a moved directory that is itself a repository (:4424) is not pinned. The body says family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's test_a_checkout_under_an_index_entry_is_the_indexs_to_name pins it (body line 36). It does not: that directory has no subdirectories. Removing the guard passed all 217 tests in 5 files.
• Other survivors: R8, R9, R10, R13, R20, R21, R23, R25, R25b, R26, R42.
• I probed three of their states at head (probe-head-g.jsonl), and each types clean with the gate passing:
  • G23: an unmerged file on disk with the move staged;
  • G25: the joined first sentence;
  • G26: a staged section beside a pending commit.

NIT 2: the body.

• It says "31 mutants … All 31 are caught". The table holds M1–M27 plus M11b, M13b and M15b, which is 30. The writer's mut/summary.txt has 29 lines, plus the verifier's M27.
• "Merge checks" still names main 190133d5. Main is 2e476a77 now, and the merge is clean.

NIT 3: SonarCloud may report S3776 on scripts/family.py:8166 as new. _checked_gitmodules_as_staged's def line changed. By my hand count its complexity went from 34 to 35 (the added and not spelled, :8267).

Checked and true

Six lines and SHOULD 3 at head. Probe results are probe-head-243.jsonl and probe-head-247.jsonl; the new tests confirm them.

• Lines 1, 2, 3, 5 and 6 and SHOULD 3: the printed remedy is typed with typed_as_printed, the gate passes in all three modes, and the same add goes through.
• Line 4 and line 5's untracked copy: gitmodules-missing and gitmodules-unstaged come first, and the tests type what follows.
• An unmerged members file on disk: the new git rm --cached and mv text is printed.

At base, each state fails the way the issue says, on both gits:

• lines 1 and 3: add exits 0, and the gate exits 1 or 2 where the issue says;
• line 4 and SHOULD 3: "Committing is not possible because you have unmerged files";
• line 5: HEAD loses .gitmodules;
• line 6: on 2.43 fatal: not a git repository: Members/IRRS/../../.git/modules/members/IRRS; on 2.47.1 expected 'Members' in submodule path 'Members/IRRS' not to be a symbolic link;
• an unmerged members on disk: git mv gives fatal: conflicted, source=members;
• line 2: the moved checkout's git -C gives not a git repository.

The optional seventh state holds on 2.47.1.

• git status gives rc 128: expected submodule path 'Members/IRRS' not to be a symbolic link.
• add gives its spelling refusal first, at base and at head.
• It takes three rounds, then the gate passes.
• The test passes at base on both gits.

Fails on base. Head's three test files copied onto ce0f2a5f give 33 failed, 2 passed on 2.43 (b243.log) and on 2.47.1 (b247.log). The two passes are test_a_checkout_git_tracks_inside_a_directory_moved_is_not_named and test_a_link_at_a_variant_the_index_holds_is_refused_first. The 33 failures are the right assertions, such as add exiting 0 ("checking InkRouter/IRQS before mounting it").

Mutants. I wrote 24 of my own, plus R19x to recheck R19 on other files.

• Caught: R2, R4, R6a, R6b, R11, R12, R16, R34, R38, R44, R47, and R19x (by test_family_refuse_up_front.py).
• Survived: R7, R8, R9, R10, R13, R19 (on the new file and family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's file only), R20, R21, R23, R25, R25b, R26, R42. Results are in mut/summary.txt and mut/runA*.log / runB.log.
• Both mutant clones were checked clean afterwards.

The helper change.

• Only one call passes status=False: the link test's first refused_untouched. Its second call, and every other caller in 5 files, keeps the default True.
• The M27 recheck (m27-247.log, m27-243.log): with status ignored, the link test fails on 2.47.1 with "expected submodule path 'Members/IRRS' not to be a symbolic link", and passes on 2.43.

Runs.

• h243.log: the 8 test_family_add_* / test_family_members_* files plus the hygiene trio, git 2.43, 466 passed, rc 0.
• h247.log: the 3 touched test files, git 2.47.1, 136 passed, rc 0.
• merged243.log: the same 11 files on head merged with main 2e476a77 (local probe commit b958fb18), 467 passed, rc 0.

Merges. merge-tree --write-tree of 4268f804 is clean (rc 0) against:

• main 2e476a77 (tree 3bdc5432);
• family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828 ce0f2a5f, an ancestor;
• family.py, scaffold-project.py and bump-leg.py: init's plan rows, seven refusals and bump-leg's root name each path as shown_path names it, so an ESC or a line break in a holder, folder, lock, local remote or root no longer reaches the terminal from those plan rows or those refusals' details #814 b050dc71, family.py: add, bump and remove refuse a cherry-pick or a revert stopped in a holder whose refs are a reftable, asking its ref store for CHERRY_PICK_HEAD and REVERT_HEAD by their exact names where no file holds them (#684) #846 6a71ff8d and update-shape.py, family.py and bump-leg.py: the branch HEAD is on is read as the bytes git wrote, so a branch ending in U+00A0 is no longer read as its neighbour, and a name that is not UTF-8 is refused by name before anything is written (#765) #849 25692a37.

Sonar.

• Duplication: no duplicated window of 8 or 10 lines touches new lines across scripts/family.py and the tests/test_family*.py files. There is one 6-line window, at tests/test_family_add_spelling_leftovers.py:523-528 and :858-863.
• Complexity by hand, new functions all 15 or under: _members_is_a_file 12, _spelled_target 13, _set_aside_part 11, _disk_found 9, _gitmodules_first 7, the rest 7 or under.
• The functions over 15 (_members_spellings, _spellings_refusal, _checked_mount_path, _disk_spellings, _sections_restored) were already over 15 at base. They kept their def lines and their complexity went down or stayed the same.

Could not verify

• Real macOS and Windows disks. SHOULD 1 rests on in-process emulation (disk_as), plus the known fact that those disks list a name in the spelling they keep.
• CI's git 2.55.
• SonarCloud's own analysis, since the SonarQube MCP server failed to connect.

Scratch left (nothing deleted)

• Clones: /workspace/projects/openRepoShape-worktrees/_lane5-scratch/ rv865-head, rv865-base, rv865-mut, rv865-mut2, rv865-merged.
  • rv865-head and rv865-base each hold an untracked tests/test_rv865_probe.py.
  • rv865-base also holds head's 3 test files copied in.
  • rv865-merged is detached at the local commit b958fb18.
• Notes and logs: $Q/v118/rv865/.
• Basetemps: $Q/v110/bt/ rv865-b243, b247, h243, h247, m243, m27a, m27b, pb243, pb247, pe2d, pe34, pe4b, pe4c, pg, ph243, ph247, r2, r4, r6a, r6b, r7, r8, r9, r10b, r11a, r12a, r13a, r16a, r19a, r19xa, r20b, r23b, r25b, r25bb, r26b, r34a, r38b, r44a, r47a.
• The shared checkout is untouched (on main, ?? handoffs). No push, no post, no real gh, and no process of mine is still running.

Lane 5's plan

• family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865 takes a fix round for MUST 1 and SHOULD 1, with tests for the four states, before it lands. It lands after family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828 in lane 5's order.
• Main has moved since the review: family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828 is refreshed as 90649e53, and family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865 restacks onto family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's squash when family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828 lands.

Lane: openreposhape-5 (openRepoShape-5)

[brettheap]

Fix round 2 of #865 (#840): f7072d08..38e0d503.

One commit on f7072d08, 38e0d503: the fix, its tests and pins. There is no merge of #828 or main: the restack onto #828's squash comes later. $Q below is lane 5's scratchpad, /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad.

Files: scripts/family.py, tests/test_family_add_spelling_leftovers.py, tests/test_family_add_member_variant.py (#839's guard, a shell for typing, and the parts split outside backticks), and tests/test_family_add_move_back_sections.py (one docstring). In all, +587/-149.

1. MUST 1 (new)

the take-out runs after git mv of the same gitlink. It strips the section git mv carried along, so renamed-1 is a gitlink no section names, and a plain clone's git submodule update --init --recursive exits 128.

Done. A new helper, _second_gitlink(name, mode, rows, indexed), picks out a gitlink in the index at a case variant of a row's path where the index records a gitlink at that path itself: the gate's STRAY, a second path to the member's directory.

• In _members_spellings' index loop, such an entry gets a new remedy, UNSTAGE_SECOND, wherever it would have been renamed (RENAME, or RENAME_SPARSE).
• UNSTAGE_SECOND prints git rm -r --cached -- <variant>, the gate's own line for a second path, through _second_path_part.
• It takes --sparse, and names the git that needs, where the rules leave the entry out or its skip-worktree bit is set. Measured: plain git rm --cached refuses a marked entry even with no sparse checkout ("outside of your sparse-checkout definition", exit 1, on git 2.43 and 2.47.1).
• git rm --cached leaves the section, so the take-out after it finds it.
• The checkout left on disk is the next run's CHECKOUT: "delete by hand each checkout on disk and untracked".
• With nothing on disk, the entry keeps plain UNSTAGE, whose command is the same.
• _removed(found, by) now counts both removals for the commit. It replaces the old inline condition, so _spellings_refusal loses 2 of cognitive complexity.

The take-out's reason no longer cites git mv. It now says that "git rm --cached of a gitlink at that path leaves it".

Tests. typed_through types the remedy as printed. Where the next run names a checkout, it asserts that text, with nothing to type, and deletes the checkout by hand. Then it checks:

• registered;
• a recursive clone, with IRRS's url and commit;
• a plain clone through submodule_update_through_git(... "--init", "--recursive"), which must exit 0, holding the same gitlinks as the holder, every one under members/ and checked out;
• git submodule status, through the git helper, which asserts exit 0, in the holder and in both clones;
• gate_then_add: the gate in all three modes, and the same add.

Every state of test_a_section_beside_the_members_own_is_taken_out now goes through it:

• (a), at Members/IRRS: git rm -r --cached -- Members/IRRS, commit, --unset-all of path and url, git add, commit. Round 2 names the checkout Members/IRRS.
• (b), at members/irrs: the same.
• (c), (d), and the point-back beside a take-out are unchanged, with the new checks.

2. K2

drop the gitlink clause, together with the change above, as rv865b rules. Add its four K2 states as tests

Done. _row_sections_astray loses the clause, and its indexed parameter with it: back = row not in paths and any(name == row for name, _, _ in astray).

test_a_second_gitlink_beside_the_members_own_is_taken_out_of_the_index[committed|reset|checkout deleted|foreign] each go through typed_through:

• committed (git mv members/IRRS Members/IRRS committed, then update-index of members/IRRS committed): git rm -r --cached -- Members/IRRS, commit, the point-back, git add, commit, then the update. Round 2 names the checkout.
• reset (git mv staged, then git reset -- members/IRRS): the same lines with no commit, since nothing HEAD holds changes. Round 2 names the checkout.
• checkout deleted: UNSTAGE as before, the point-back, commits and the update, in one round. At f7072d08 it took two.
• foreign (the member's section astray, committed, plus git submodule add <IRSS> Members/IRRS): the removal, the point-back, the take-out of IRSS's section, each with a commit. Round 2 names the checkout.

Each ends with plain and recursive clones that work, and the gate passing in all three modes.

3. NIT 1

in _variant_in_members, ask not os.path.islink(...) before samefile, as _members_dir_on_disk does. Add a test with a link members/irrs -> IRRS.

Done. _variant_in_members asks if os.path.islink(root / name / entry): return True before the samefile loop: a link is always named.

test_a_link_in_members_at_a_rows_variant_is_named covers it:

• it refuses with on disk and untracked: members/irrs (a symlink);
• typed, mv -- members/irrs ../moved-1 moves the link, whose readlink is IRRS;
• registered holds, and gate_then_add passes.

4. NIT 2

pin X1 (a take-out with nothing to commit), X2 (removed in earlier) and X6 (a section name that needs quoting).

Done.

• X1 and X6: BESIDE state "a staged one whose name needs quoting". A section named a stale one, giving members/irrs, is staged and never committed. Typed, it gives git config -f .gitmodules --unset-all 'submodule.a stale one.path' and the same for .url, then git add -- .gitmodules, with no commit. The tests' unset() quotes with shlex.quote.
• X2: COMMITTED_BEFORE state "a removal". Members/README is planted in the index and HEAD with nothing on disk: git rm -r --cached -- Members/README and its commit come first, then the staged point-back with its commit.

All three pass on f7072d08 too, since that code was already right; they pin the mutants.

5. NIT 3

_committed should count the point-back's own commit as an earlier commit for the take-out. Fix it, or say why not.

Fixed. In _point_back_part, committed = _committed(found, POINT_BACK, earlier), then earlier = earlier or bool(committed) before the take-out.

The test is BESIDE state "pointed back, and a staged one taken out": rv865b's P4, the member's section astray and committed, with stale at members/irrs staged only. The take-out now commits after the point-back's commit, and registered checks HEAD's .gitmodules against the holder's. At f7072d08, HEAD kept stale.

6. NIT 4

take #839's link form in _closing_sentences [...] Bring test_a_link_at_a_variant_the_index_holds_is_refused_first down to two rounds. Type it under dash and bash.

Done. _closing_sentences now prints [ ! -L V ] && { [ ! -e V ] || [ V -ef R ] || [ -e V/.git ]; } || mv -- V ../<V>, each path shell_quoted. It adds #839's words: "..., a checkout, and moves a symbolic link there wherever it points, the link and never what it points at". _spellings_refusal's docstring and the comment say so.

In the tests (test_family_add_member_variant.py):

• guarded() and the closing words in moved_back take the same form.
• typed_in_sh and typed_as_printed take a shell, defaulting to sh.
• remedy_parts splits the remedy at ; outside backticks only. The guard's ]; } would otherwise split one command in two.

The link test is parametrized over dash and bash, and skips where the shell is missing. Round 1 types the move back and the guard, which moves the link to ../Members-IRRS; the test asserts the link is gone and its readlink. Round 2 is gate_then_add's add, which goes through.

7. NIT 5

the body. Add the caveat to line 1's claim, and name the main of your merge check (now 0905eef5 or later).

Done in $Q/v118/w865f/body2.md:

• a "Fix round 2" section;
• line 1's claim now carries the caveat, that at f7072d08 it held for a recursive clone only and a plain clone's update exited 128, with what is measured since;
• line 3 and the added state are updated;
• tests, runs, mutants (round 2's table), "Not here" and the checklist are updated;
• the merge checks name main 3bf2d3c9, and family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's 90649e53 and 54b7699e.

body-guard.py passes it.

Each new test fails on f7072d08

The 17 new or changed cases are 7 BESIDE states, [a removal], 4 K2 states, 2 sparse states, the link in members/, and the link at the variant under dash and bash. Copied with the round's test files onto a clone at f7072d08 (/workspace/projects/openRepoShape-worktrees/_lane5-scratch/w865f-r2old):

• 16 failed and 1 passed, on git 2.43 and on 2.47.1 ($Q/v118/w865f/r2/old243.log, $Q/v118/w865f/r2/old247.log).
• The one that passes is [a removal], X2's pin, which pins code that was already right.

A copy with no check on the text ($Q/v118/w865f/r2/test_w865f_r2_behaviour.py) types each state as printed, round after round, then makes the same checks:

• At f7072d08: 11 of 16 fail ($Q/v118/w865f/r2/bh-old243.log). The failures:
  • the plain clone's update fails (submodule_update_through_git) for (a), (b) and both sparse states;
  • HEAD's .gitmodules is not the holder's for K2 committed, reset and foreign, and for the staged take-out after the point-back;
  • "the link is left" for members/irrs;
  • "2 rounds typed before add goes through" for the link at the variant, under dash and bash.
• The 5 that pass there are (c), (d), the point-back beside a committed take-out, the quoting state (X1, X6), and K2 with its checkout deleted, which took 2 rounds and ended right.
• At 38e0d503: 16 passed ($Q/v118/w865f/r2/bh-head243.log).

Mutants

19 mutants of the round's new hunks in scripts/family.py ($Q/v118/w865f/mutate2.py; results in $Q/v118/w865f/mut2/summary2.txt, logs in $Q/v118/w865f/mut2/). Each was run on 38e0d503 in /workspace/projects/openRepoShape-worktrees/_lane5-scratch/w865f-r2mut, -x on the tests named, and the clone was clean afterwards. 18 are caught; N2 survives.

• _second_gitlink: N1 (any entry, not only a gitlink) is caught by line 3's "a file on disk". N3 (the fold dropped) is caught by test_a_gitlink_the_sparse_rules_leave_out_is_renamed_with_sparse.
• N2 SURVIVES: the question whether the row's path holds a gitlink, dropped. Run over all 200 cases of the leftovers, member_variant, move_back_sections and case_variants files, all pass. It differs only where the row's path holds index entries UNDER it, with a gitlink among them, or is an unmerged entry whose first stage is no gitlink (R21's state). Those keep family.py: add refuses, before the member is read and on every disk, any path under another spelling of members/, in its index, in HEAD or on disk, and names a remedy per entry that never moves the members' checkouts (#362, #363, #364) #574's rename. No rule rules on whose gitlink the variant is there, so I did not pin either remedy. A state for it would be built with update-index alone.
• The loop: N4 (renamed with git mv again) is caught by (a). N5 (the off-disk one rerouted too) is caught by (c).
• --sparse: N6 (never), N7 (only where the rules leave it out) and N7b (only where the bit is set) are caught by the two sparse cases.
• _second_path_part: N8 (never printed) is caught by (a). N9 (--sparse text dropped) and N10 (the git note dropped) are caught by the sparse cases.
• _removed: N11 (the second path's removal not counted) is caught by (a). N12 (the pending change not counted) is caught by test_every_place_is_named_and_the_pending_change_is_committed_first. N13 (a removal said wherever anything is committed) is caught by line 3.
• N14 (K2's clause put back) is caught by K2 committed.
• N15 (NIT 3 undone) is caught by the staged take-out after the point-back.
• N16 (NIT 1 undone) is caught by the link in members/.
• N17 (family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's guard again) and N18 (the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839's form without its -L) are caught by the link at the variant.

rv865b's probe at 38e0d503

The probe was copied into /workspace/projects/openRepoShape-worktrees/_lane5-scratch/w865f-r2probe/tests/ and run with RV865B_OUT on git 2.43: 29 passed, rc 0 ($Q/v118/w865f/r2/probe-head-243.log, records in $Q/v118/w865f/r2/probe-head-243.jsonl, summarized by $Q/v118/w865f/r2/probe_sum.py). The probe never deletes a checkout by hand, so states that leave one show it named in rounds 2 and 3. Every state ends with the gate exiting 0 in all three modes.

• P1 (a) and (b) as printed, and P2's two states: round 1 takes the gitlink out. HEAD's gitlinks are then members/IRRS and members/IRSS alone. git submodule status exits 0 in the holder (it gave 128 at f7072d08) and in the recursive clone, whose members/IRRS is IRRS.git at its commit.
• P3, K2: committed, reset and foreign end the same way. "Deleted" ends in one round, and add goes through.
• P4: one round, then add goes through. P4b: head_has_stale: false and index_has_stale: false.
• P5: a link members/irrs to IRRS gives code 2, where f7072d08 gave 0. A link to IRSS gives 2 as well.
• P6: all four layouts take two rounds, and link_left is false. The probe's "839 form" regex matches only the old guard, so it typed nothing more.
• L7: all six states are clean in one round.
• P7 (a), (b) and (c) as printed: the plain update exits 0, with every member checked out.
• P7 "(a) rename, then the gate's lines": 128, as rv865b found. That is the validator's gap after a hand rename; this PR no longer prints that rename.

Runs (run9s.sh, SHARDS=3, the same 15 files as round 1)

Log	Git	Head	Result
$Q/v118/w865f/r2/final243.log (shards final243-s1.log to -s3.log)	2.43	38e0d503	714 passed, rc 0 (202 + 239 + 273)
$Q/v118/w865f/r2/final247.log (shards final247-s1.log to -s3.log)	2.47.1	38e0d503	714 passed, rc 0 (202 + 239 + 273)

The 15 files are test_family_add_spelling_leftovers.py, test_family_add_move_back_sections.py, test_family_members_case_variants.py, test_family_add_excludes.py, test_family_add_member_id.py, test_family_add_member_variant.py, test_family_add_refusals.py, test_family_add_spellings_remedies.py, test_repo_hygiene.py, test_agents_md_codes.py, test_cli_reference.py, test_family.py, test_family_remove_gitmodules.py, test_family_head_lost_gitmodules.py and test_family_holder_states.py. Round 1 gave 703. The 11 more are the leftovers file's new cases, 62 now against 51.

For the 2.47.1 run, $Q/v115/w764/git247/bin was first on PATH. With run9.sh's PATH laid over it, command -v git gives that git, git --version says 2.47.1, and gh is the stub. Both runs had a clean tree (dirty=0), and run9s removed its shard worktrees on rc 0.

During the work, before the commit, $Q/v110/run9.sh runs on 2.43 gave:

• $Q/v118/w865f/r2/a.log: 38 passed, the new and changed leftovers cases;
• $Q/v118/w865f/r2/b.log: 98 passed, the leftovers and member_variant files;
• $Q/v118/w865f/r2/c.log: 145 passed, move_back_sections, case_variants and spellings_remedies;
• $Q/v118/w865f/r2/d.log: 2 passed, the two sparse cases.

Merge checks

Main was fetched at 05:05Z. git merge-tree --write-tree of 38e0d503:

• Clean against main 5c54af20 (tree 61aab1ad): $Q/v118/w865f/r2/mt-origin-main.txt.
• Clean against family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's 90649e53 (tree 8c4a385b): $Q/v118/w865f/r2/mt-90649e53efe873628a889f6d941ea64f33647df1.txt.

Main and #828 moved before the push, so both were fetched again at 05:39Z:

• Clean against main 3bf2d3c9 (tree 32ea287a): $Q/v118/w865f/r2/mt2-origin-main.txt.
• Clean against family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's head now, 54b7699e (tree 61aab1ad), a merge of main 5c54af20 into fix/761-add-move-back-gitmodules, of which 90649e53 is an ancestor: $Q/v118/w865f/r2/mt2-origin-fix-761-add-move-back-gitmodules.txt.

Push

One commit, made by pathspec with the identity Brett Heap <service@opensoft.dev> and the two trailers ($Q/v118/w865f/commit3-msg.txt). It is a fast-forward of f7072d08 (merge-base --is-ancestor: yes).

git push origin HEAD:refs/heads/fix/840-spelling-leftovers printed f7072d08..38e0d503 HEAD -> fix/840-spelling-leftovers and exited 0. git ls-remote origin refs/heads/fix/840-spelling-leftovers reads 38e0d503a258c42a05283945b627649d52ea8e4a. Nothing was posted.

Doubts

• N2 survives, for the reason above.
• Sonar's complexity was counted by hand only, since the SonarQube MCP server failed to connect in this session. _members_spellings goes up 3, and its def line is unchanged.
• CI's git 2.55 and real macOS and Windows disks were not run.

[brettheap]

Re-check of #865 (#840) fix round 2 at 38e0d503, for lane openRepoShape-5: NOT READY

$Q = /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad. My logs are under $Q/v118/rv865b/logs/ and my probes under $Q/v118/rv865b/probe/.

My first re-review's MUST 1 (the gitlink no section names) is closed for every state I typed, on both gits, and all five NITs are closed. But the new git rm -r --cached line has no -f. git refuses it for a gitlink that is staged and not committed, wherever its checkout holds work. A plain git submodule add that has not been committed yet is enough. The round's tests miss this because every checkout in them is clean.

Findings, most severe first

MUST 1: scripts/family.py:4856-4883 (_second_path_part, chosen at :4074-4078) prints git rm -r --cached -- <variant> with no -f, and git refuses it.

• When git refuses: the index stages the gitlink at a commit HEAD does not record there, and the checkout on disk has moved on or holds an untracked file.
• What git says: exit 1, error: the following file has staged content different from both the file and the HEAD: Members/IRRS (use -f to force removal). Typed as printed, the remedy stops at its first line.
• Measured on 2.43 and 2.47.1 (logs/astaged-243.jsonl, logs/astaged-247.jsonl, logs/r2probe-243.jsonl, logs/r2probe-247.jsonl):
  • (a) staged: git submodule add <IRSS> Members/IRRS, not committed, with only an untracked WIP.txt in it. Refused.
  • The same with a commit made in the checkout. Refused.
  • K2 reset (git mv staged, then git reset -- members/IRRS) with work in the checkout. Refused.
  • (a) staged with a clean checkout: types clean. This is why w865f's K2 reset test passes; mount_moved adds no work to the checkout.
• What is already done elsewhere for this same refusal:
  • family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's move back prints -f: forced=in_head.get(name) != recorded and os.path.lexists(... ".git") at :4062, with "with --cached touches no file" at :5184.
  • the family root's bootstrap.py and validate-family.py: the credential advice and a member's exit code say what happened, and the gate's git rm --cached, guarded mv and section lines type as printed where they failed (#839) #876's validator does the same (_forced, FORCED_SAID).
• Direction:
  • Give UNSTAGE_SECOND the same forced rule and the same clause.
  • Add tests: (a) staged with an untracked file, and K2 reset with work in the checkout.

SHOULD 1: K2 committed. The round's own update makes git status hide the uncommitted files of the checkout that the next round says to delete.

• The state: the second gitlink's checkout is the member's own checkout, moved by git mv. Its .git file names .git/modules/members/IRRS, which it shares with the member.
• What happens:
  • Round 1 prints git submodule update --init --recursive. Typed, it points that shared store's core.worktree at members/IRRS.
  • Round 2 then says to delete Members/IRRS by hand "once nothing only it holds is needed".
• Measured on both gits:
  • git -C Members/IRRS status --porcelain printed nothing, and its --show-toplevel is members/IRRS.
  • Members/IRRS/WIP.txt was on disk the whole time. Deleted as the text says, it is lost.
  • The checkout's commit is kept on refs/heads/main in the store, so commits are safe. The untracked file is not.
• Why it matters: family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828 orders its move back against exactly this. The checkout is named with its git -C … status "before the update below, which points a store the row shares at the row's path" (:5235).
• Direction:
  • Where the second gitlink's checkout names the member's store, name it in the same round, before the update, as the move back's closing sentences do; or leave the update to the next run.
  • K2 reset has the same problem once it gets -f.

NIT 1: _members_spellings goes up 4 by my count, not 3 as the body says. The new if adds 1, plus 1 for nesting, plus 1 for and, and out = … or … adds 1 more (41 to 45 by my estimator; the def line is unchanged, so it is the existing issue).

NIT 2: tests/test_family_add_member_variant.py:236. typed_as_printed's def line changed again, gaining shell. Its complexity is about 31 by my count, over 15 (33 on main). SonarCloud may report S3776 on it as new, the same class as rv865's NIT 3.

Rulings

N2 (dropping the check that the row's path holds a gitlink): acceptable as is. No test to add, and no new rule needed for this PR. I built both of w865f's states and typed them at the head and with N2 applied, on git 2.43 (logs/n2-head-243.jsonl, logs/n2-mut-243.jsonl):

• The row's path unmerged, a file at stage 1: both versions' commit fails with Committing is not possible because you have unmerged files. The variant's remedy is irrelevant here.
• A gitlink under members/IRRS: both versions end with add going through while the gate exits 1 (member-gitlink-unnamed). The head leaves renamed-1 with no section; N2 leaves nothing behind.
• git rm --cached is never worse in either state, so dropping the check would be a harmless simplification.
• The real gap is the row's path itself: R21's state, and a gitlink under the row's path, which add does not refuse. Both are older than this PR. That is a checklist candidate, not something to fix here.

NIT 4 (the guard): it is byte for byte #876's _guarded_move, and the clause after it matches #876's wording.

• I generated both from their own code. They are equal for Members/IRRS, members/irrs, Members/IR RS and Members/-x.
• They differ only for a path containing '. family.py's shell_quoted writes '\'' there, and shlex.quote writes '"'"'. No path the guard can be given contains one, since it is a case variant of a member's row path.

Checked and true

My re-review's MUST 1 is closed. I ran 8 states on 2.43 and on 2.47.1, with work in each checkout, typed round after round. Each named checkout was deleted by hand, after recording what its status showed. The states:

• (a)
• (b)
• my P2
• K2 foreign
• (a) with skip-worktree set and its checkout kept, which gets git rm -r --cached --sparse and types clean
• K2 deleted
• K2 committed
• K2 reset

Apart from K2 reset (refused, MUST 1) and K2 committed's hidden status (SHOULD 1):

• The gate exits 0 in all three modes.
• A plain clone plus git submodule update --init --recursive exits 0, with members/IRQS, members/IRRS and members/IRSS checked out.
• A recursive clone gets members/IRRS from IRRS.git.
• git submodule status exits 0.
• The checkout's work commit is kept in its store.

Other closures.

• K2's clause is dropped, and its four states are tests.
• NIT 1 to NIT 5 are closed. My X1, X2 and X6 mutants are now caught (mut/summary.txt). The link tests pass under dash and bash.

Runs.

• logs/r2-head-243.log: the leftovers, member_variant, move_back_sections and trio files at 38e0d503 on 2.43. 287 passed, rc 0.
• logs/r2-head-247.log: the leftovers file on 2.47.1. 62 passed, rc 0.
• w865f's final243.log and final247.log: 714 each (202 + 239 + 273), clean tree, at 38e0d503. This matches its account, as does its 18 of 19 mutants caught.

Restack. simrestack.sh 865 38e0d503 828 54b7699e printed:

• #828: simulated update-branch 755aac81
• predicted squash dc0c789e (tree 7aa6e875)
• resolved ours-side: scripts/family.py tests/test_family_add_member_variant.py tests/test_family_add_move_back_sections.py tests/test_family_members_case_variants.py
• #865: simulated restack 515140c8 (tree 32ea287a), clean

Tree 32ea287a equals w865f's merge-tree with main 3bf2d3c9. In a detached scratch worktree at 515140c8:

• The leftovers file plus test_no_auto_maintenance.py: 120 passed, 2 skipped. The 2 skips came from my own GIT_CONFIG_GLOBAL=/dev/null.
• test_no_auto_maintenance.py run again without it: 60 passed.

Sonar-style.

• Duplication: no window of 6, 8 or 10 lines touches round 2's new lines.
• No assert joins conditions with and; the hits are inside strings.
• New functions, by my count: _second_gitlink 2, _second_path_part 3, _removed 2.
• Changed functions: _point_back_part 3, _variant_in_members 9, _row_sections_astray 8. _spellings_refusal goes down 2, to 36, with its def line unchanged.

Could not verify

• CI's git 2.55, and real macOS or Windows disks.
• SonarCloud itself.
• Whether an issue for the validator gap already exists on GitHub: lane 5's notes have none, and I may not run the real gh.

The issue line for check 4

The gap is real on main 3bf2d3c9 (git 2.43 and 2.47.1) and on #876's head 77f8a6c8 (git 2.43). #876 does not change it.

• The gate's gitmodules-path-unnamed remedy takes out the section of a submodule no row names and leaves its gitlink, which no finding names. A plain clone's git submodule update --init --recursive then exits 128 before it checks out any member, and the holder's CI skips the member half of the gate.
  • Source: rv865b's re-checks of family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865.
  • Why the gate misses it: _member_gitlinks (templates/family-root/scripts/validate-family.py:1417, filtered at about :1466) lists only gitlinks under a spelling of members/. So _check_gitlinks_named (:1634) never asks about one anywhere else, and gitmodules-path-unnamed (:1849-1869) prints only the --unset-all lines.
  • Measured:
    • The state: git submodule add <IRSS> tools/x, committed. Or IRSS added at Members/IRRS and then git mv'd by hand to renamed-1.
    • The gate exits 1 in all three modes (gitmodules-path-unnamed) and prints git config -f .gitmodules --unset-all submodule.tools/x.path and .url.
    • After typing those lines, git add .gitmodules and a commit: the gate exits 0 in all three modes.
    • git submodule status exits 128: fatal: no submodule mapping found in .gitmodules for path 'tools/x'.
    • A plain clone's git submodule update --init --recursive exits 128 (fatal: No url found for submodule path 'tools/x' in .gitmodules), with no member checked out.
    • That is the holder's own CI path: templates/family-root/.github/workflows/validate.yml:46 checks out with submodules: false, and :236-238 runs the update. CI then sets members_available=false and runs --no-members alone.
    • bootstrap.py's init_stop (:387) already names this state.
    • A recursive clone exits 0, because it sets submodule.active.
  • Direction:
    • Where a section's path is a gitlink in the index that no row names, print git rm --cached -- <path> and a commit before the --unset-all lines, as member-gitlink-unnamed does for a second path.
    • Give a gitlink outside members/ that no section names a finding of its own.
  • Verify:
    • Both states above, typed as printed, then the gate in every mode.
    • A plain clone plus git submodule update --init --recursive exits 0 with every member checked out, and git submodule status exits 0.
    • A mutant that drops the git rm --cached, caught.
    • The file is pinned: one upstream-changed row per holder.
  • Overlaps: the family root's bootstrap.py and validate-family.py: the credential advice and a member's exit code say what happened, and the gate's git rm --cached, guarded mv and section lines type as printed where they failed (#839) #876 edits the same validator and does not change this.

Scratch left

• Removed with git worktree remove: rv865b-restack and rv865b-g876.
• Clones kept under /workspace/projects/openRepoShape-worktrees/_lane5-scratch/. They are plain clones, and I may not rm -rf:
  • rv865b-head: at 38e0d503, with untracked probe files.
  • rv865b-mut: at 38e0d503, with untracked probe files; family.py restored and clean.
  • rv865b-run: at 38e0d503, clean.
  • rv865b-old: at 3bf2d3c9, with an untracked gap probe.
• Basetemps: $Q/v110/bt/rv865b-*.
• Logs: $Q/v118/rv865b/.
• The shared repo: the simulator wrote objects with no refs, and the checkout is still on main with ?? handoffs.
• No push, no post, no real gh, and nothing of mine is still running.

[brettheap]

Fix round 3 of #865 (#840): 38e0d503..4e92867a.

There are two commits on 38e0d503. adb20242 (WIP round 3: …) is the fix and its tests, committed at the usage pause. 4e92867a adds two more pins and a rewrap. The round is two commits because nothing is amended.

There is no merge of #828 or main: the coordinator restacks afterwards. $Q below is /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad.

38e0d503..4e92867a changes 4 files, +396/-120:

• scripts/family.py
• tests/test_family_add_spelling_leftovers.py
• tests/test_family_add_member_variant.py
• tests/test_family_members_case_variants.py, whose literal Spelled tuple gains the new field.

1. MUST 1

_second_path_part [...] prints git rm -r --cached -- <variant> with no -f. git refuses it where the index stages the gitlink at a commit HEAD does not record there and the checkout on disk has moved on or holds an untracked file.

Done.

• The rule. _forced(root, name, recorded, in_head) is family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's rule word for word: in_head.get(name) != recorded and os.path.lexists(root / name / ".git"). _members_spellings sets Spelled.forced from it for every UNSTAGE_SECOND, on the index's record of the entry.
• The printed line. _second_path_part prints git rm -r --cached[ --sparse][ -f] -- <path>, in the move back's order. After the command come SPARSE_RM_GIT where --sparse is printed, and the clause where -f is.
• The clause. It is one module constant now, FORCED_SAID ("whose -f takes out a staged gitlink whose checkout has moved on or holds a file git does not track, which git rm otherwise refuses, and with --cached touches no file"). _move_back_line (family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's :5184) uses the same constant, so the two cannot drift. Its bytes are the move back's.

Tests. All are in test_a_second_paths_checkout_with_work_is_forced_and_named_first, typed as printed through typed_through:

State	Removal printed
(a) staged (git submodule add, not committed), only an untracked WIP.txt in the checkout	git rm -r --cached -f -- Members/IRRS; the take-out, not committed; the checkout deleted by hand
(a) staged, a commit of its own in the checkout	the same; the commit is then asserted kept in .git/modules/Members/IRRS
(a) staged and left out by cone-mode sparse rules, its bit cleared, with WIP.txt	git rm -r --cached --sparse -f -- Members/IRRS, the combination
K2 reset (git mv staged, then git reset -- members/IRRS) with a commit and WIP.txt in the checkout	-f, the point-back, the checkout by hand, then the update; the commit is kept in .git/modules/members/IRRS
K2 committed with the same work	no -f (index == HEAD), the rest as for K2 reset (SHOULD 1 below)

Each then checks:

• registered;
• a recursive clone with members/IRRS from IRRS.git;
• a plain clone plus git submodule update --init --recursive, exit 0, holding the holder's gitlinks, every one checked out;
• git submodule status exiting 0 in the holder and in both clones;
• the gate in all three modes, and the same add going through.

Two pins came in 4e92867a:

• test_a_staged_second_gitlink_with_nothing_on_disk_takes_no_f: (a) staged, its checkout deleted, its bit set. It gets --sparse and no -f, which pins _forced's checkout question.
• test_a_clone_of_its_own_at_a_second_path_is_moved_whole_next: below, in point 2.

The existing K2 reset state (second_reset) now prints -f too.

2. SHOULD 1, K2 committed

name that checkout, with its git -C … status, in the same round, before the update. Or leave the update to the next run. Choose one, and say why.

I chose to name it in the same round.

• How. Spelled.checkout is a new field, set for UNSTAGE_SECOND where the entry is on disk in its own spelling and is a directory holding a .git FILE (_moved_or_kept(...) == CHECKOUT). Then _second_checkout_part prints, just before the closing sentences and the update: "delete by hand each checkout that git rm --cached of a second path leaves on disk, Members/IRRS, once nothing only it holds is needed, rather than move it, and before any update below: …, so only what is not committed is in it alone (git -C Members/IRRS status shows it), and the update points a store it may share with the row at the row's path, after which that status shows the row's checkout instead".
• Why not the alternative. Leaving the update to the next run means a run whose only part is the by-hand deletion, and after it nothing prints the update. add would then go through with the member checked out nowhere, and the gate's members mode exits 2 (member-uninitialized). Naming the checkout first, as family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's move back does (:5235), keeps the update in the same text.
• Side effect. (a), (b), K2 committed, reset and foreign, and the rules' sparse state each take one round now.
• Two guards:
  • "On disk in its own spelling" means a disk that folds case never names the member's own checkout, which Members/IRRS resolves to there.
  • A clone of its own, its .git a directory, is not named to delete. The next run moves it out whole, which test_a_clone_of_its_own_at_a_second_path_is_moved_whole_next pins: one round with git rm -r --cached and its commit, then mv -- Members/IRRS ../moved-1, with the clone's .git directory intact.

Tests. K2 committed with work and K2 reset with work, in the table above. Their hand step is deleted_by_hand(VARIANT), which asserts that git -C Members/IRRS status --porcelain lists ?? WIP.txt before deleting. It runs after the checkout part and before the update. Mutant C2, which moves the part after the update, is caught by K2 committed.

3. NIT 1

the body's count for _members_spellings should be +4, not +3 [...] recount after your change and write what you measure.

Done. I measured with rv865b's estimator, $Q/v118/rv865b/cogc.py (comprehensions not counted, then counted):

Function	f7072d08	38e0d503	4e92867a
_members_spellings	41 / 56	45 / 60	46 / 61
_spellings_refusal	38	36	36
_point_back_part	2	3	3
_move_back_line	9	9	9
typed_as_printed	31	31	31

• _members_spellings went up 4 in round 2, as rv865b counted. Round 3 adds 1, the and in checkout = present and …. The and that moved from the if into present = … counts the same.
• The def lines of _members_spellings, _spellings_refusal and typed_as_printed are unchanged.
• The new functions measure: _second_path_part 5, _second_checkout_part 2, _forced 1, _second_gitlink 2, _removed 2.
• body3.md says so.

4. NIT 2

typed_as_printed's def line [...] changed again in round 2. If it is simple, keep that def line byte for byte as it is at f7072d08

Done.

• typed_as_printed's def line and docstring are f7072d08's byte for byte. The only change from f7072d08 is one body line, parts = remedy_parts(said), which the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839's guard needs.
• typed_in_sh has f7072d08's def line too.
• It types into a module constant, SHELL = "sh". The link test sets that constant with monkeypatch.setattr(member_variant, "SHELL", shell) for dash and for bash, in place of a parameter.
• Checked with a diff of the function against f7072d08: one line differs.

5. N2

rv865b rules it acceptable as is, so nothing changed for it.

Each new test fails on 38e0d503

I copied the four test files from the head into a clone at 38e0d503 (/workspace/projects/openRepoShape-worktrees/_lane5-scratch/w865f-r3old).

• The 20 cases with the round's changes: 12 failed and 8 passed, on git 2.43 and 2.47.1 ($Q/v118/w865f/r3/old243.log, $Q/v118/w865f/r3/old247.log).
  • The 12 are (a), (b), K2 committed, reset and foreign, both sparse states, and the five work states.
  • The 8 that pass are the five BESIDE states with no second path, K2 with its checkout deleted, and the link test under dash and bash, whose texts did not change.
• The two pins added in 4e92867a: both fail there ($Q/v118/w865f/r3/old243b.log).
• Behaviour without the text checks ($Q/v118/w865f/r3/test_w865f_r3_behaviour.py): each work state is typed round after round, and the hand step asserts the status names WIP.txt.
  • At 38e0d503: all five fail ($Q/v118/w865f/r3/old243b.log). Four stop at git rm -r --cached -- Members/IRRS (--sparse for one), which git refuses (staged content different from both the file and the HEAD): (a) staged untracked, (a) staged committed, (a) staged and left out, and K2 reset. K2 committed fails the hand step: WIP.txt on disk but not in its status.
  • At 4e92867a: 5 passed ($Q/v118/w865f/r3/bh-head243.log, run in the clone w865f-r3probe).

Mutants

13 mutants of the round's new hunks, on 4e92867a in /workspace/projects/openRepoShape-worktrees/_lane5-scratch/w865f-r3mut ($Q/v118/w865f/mutate3.py; $Q/v118/w865f/mut3/summary3.txt, logs in $Q/v118/w865f/mut3/). Each was run -x, and the clone was clean afterwards. 12 are caught; C5 survives.

Mutant	What it undoes	Result
F1	-f dropped from _second_path_part	caught (W (a) staged untracked)
F2	the forced rule always true	caught ((a), which takes no -f)
F3	the clause dropped	caught (W (a) staged untracked)
F4	_forced without the checkout question	caught (the staged second gitlink with nothing on disk)
F5	_forced without the HEAD question	caught ((a))
F6	a second path never forced	caught (W (a) staged untracked)
F7	the move back's clause dropped (the shared constant)	caught (test_family_add_move_back_sections.py)
C1	the SHOULD 1 naming dropped	caught ((a))
C2	the naming placed after the update	caught (W K2 committed)
C3	every second path has a checkout	caught (sparse, marked by hand)
C4	a checkout never noticed	caught ((a))
C5	the checkout asked whatever the spelling on disk (present dropped)	SURVIVES, 69 passed
C6	a clone of its own counted as a checkout	caught (the clone at a second path)

The four the brief names are all caught: -f dropped (F1), the forced rule always true (F2), the clause dropped (F3), and the naming dropped (C1).

C5 survives because it only differs on a disk that folds case. There, Members/IRRS resolves to the member's own members/IRRS, and the guard keeps the text from saying to delete that checkout. On Linux the path is not there, so the mutant cannot be told apart. The suite's disk_as emulates os.path.isdir, lexists and samefile but not the Path.lstat and is_dir that _moved_or_kept uses, and a Members link is itself refused first. The body names it under "Not here".

Runs

Log	Git	Head	What	Result
$Q/v118/w865f/r3/final243.log (shards final243-s1.log to -s3.log)	2.43	4e92867a	run9s.sh, SHARDS=3, the same 15 files	721 passed (216 + 234 + 271), rc 0
$Q/v118/w865f/r3/final247.log (shards final247-s1.log to -s3.log)	2.47.1	4e92867a	the same	721 passed (216 + 234 + 271), rc 0
$Q/v118/w865f/r3/old243.log	2.43	adb20242's tests on 38e0d503's family.py	20 new or changed ids	12 failed, 8 passed (intended)
$Q/v118/w865f/r3/old247.log	2.47.1	the same	the same	12 failed, 8 passed (intended)
$Q/v118/w865f/r3/old243b.log	2.43	38e0d503's family.py	the two 4e92867a pins plus the behaviour copy	7 failed (intended)
$Q/v118/w865f/r3/bh-head243.log	2.43	4e92867a	the behaviour copy	5 passed
$Q/v118/w865f/r3/e.log	2.43	adb20242	the literal Spelled tuple test, after the pause	1 passed
$Q/v118/w865f/r3/f.log	2.43	adb20242 plus the two new pins	the two new pins	2 passed
$Q/v118/w865f/r3/g.log	2.43	the same, rewrapped	the BESIDE, work and pin cases	29 passed

The 15 files are round 1's and 2's. 721 is 714 plus the 7 new cases (5 work states and 2 pins); the leftovers file holds 69. Both gates ran on a clean tree (dirty=0), and run9s removed its shard worktrees on rc 0. For 2.47.1, $Q/v115/w764/git247/bin was first on PATH, as in round 2.

Before the pause (pause-r3.md): a.log (39 passed, 1 failed, then fixed), b.log (6 passed), c.log (104 passed) and d.log (144 passed, 1 failed: the literal tuple, which the run had imported before its fix; e.log above then passed).

Merge checks

Main was fetched with git -c gc.auto=0 -c maintenance.auto=false fetch --no-write-fetch-head origin main at 08:38Z; FETCH_HEAD was never read.

• git merge-tree --write-tree 3546118bdebae1fdef5d373b5c82c295bd59f84b 4e92867a: clean, tree 923bb23b ($Q/v118/w865f/r3/mt-3546118b.txt). 3546118b was already in the object store.
• origin/main (def45de6), for information: conflicts in family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's own files, scripts/family.py, tests/test_family_add_member_variant.py, tests/test_family_add_move_back_sections.py (add/add) and tests/test_family_members_case_variants.py ($Q/v118/w865f/r3/mt-origin-main.txt). 9b0a7038, family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's squash, is an ancestor of def45de6. The conflicts are the squash against this branch's copy of family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's commits from before the squash, which the restack resolves.

Push

adb20242 and 4e92867a were made by pathspec, with the identity Brett Heap <service@opensoft.dev> and the two trailers ($Q/v118/w865f/commit4-wip-msg.txt, $Q/v118/w865f/commit5-msg.txt). Together they are a fast-forward of 38e0d503.

git push origin HEAD:refs/heads/fix/840-spelling-leftovers printed 38e0d503..4e92867a HEAD -> fix/840-spelling-leftovers, exit 0. git ls-remote origin refs/heads/fix/840-spelling-leftovers reads 4e92867a25fe179118b90ea7ef48f52ef7e69573. Nothing was posted.

Files

• $Q/v118/w865f/body3.md: the PR body from body2.md, with a "Fix round 3" section. The changed tests, counts, mutants, runs, merge checks and sentences are updated, including the stacking line, now that family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828 has landed.
• This file.

Both pass /usr/bin/python3 $Q/v113/body-guard.py.

[brettheap]

Re-check of #865 (#840) fix round 3 and its restack at 6ef6e4c1, for lane openRepoShape-5: READY

$Q = /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad. My logs are under $Q/v118/rv865b/logs/ and the round-3 probe is $Q/v118/rv865b/probe/test_rv865b_r3.py.

Both of my findings from the 38e0d503 re-check are closed, on git 2.43 and 2.47.1. No checkout loses work, and the checkout is named before anything hides its untracked file. The restack leaves #865's own changed lines exactly as they were. The only thing left is a NIT: a test for C5 can be written.

Findings

NIT 1: C5, the own-spelling guard (scripts/family.py:4283, checkout = present and …), is pinnable on Linux after all. Add the test.

• What I measured (logs/r3probe-243.jsonl, logs/c5-mut-243.jsonl):
  • The state: Members a link to members, the folding emulation tests/test_validate_family_remedies_typed.py already uses, plus a second gitlink at Members/IRRS, committed, with skip-worktree set.
  • At the head, no checkout part is printed.
  • With C5 applied, the text gains "delete by hand each checkout that git rm --cached of a second path leaves on disk, Members/IRRS … before any update below". Members/IRRS resolves to the member's own checkout.
• Why it matters: in this emulation the link's mv comes earlier in the same remedy, so the line deletes nothing. On a real folding disk there is no link, and that line would name the member's own checkout. The guard protects data.
• Direction: pin it with this state, asserting the full text. It applies only where the variant is routed through skip-worktree (RENAME_SPARSE), so it is narrow and does not block.

Checked and true

Your MUST 1 and SHOULD 1, closed. I typed 10 states as printed at 6ef6e4c1, on 2.43 and 2.47.1, with each named checkout deleted by hand only after recording its git status. Work means a commit made in the checkout plus an untracked WIP.txt. The states:

• (a) committed, with work
• (b) committed, with work
• my P2
• K2 committed, with work
• K2 reset, with work
• K2 foreign
• (a) staged, an untracked file only
• (a) staged, with a commit
• (a) staged and left out by cone-mode sparse rules
• (a) with skip-worktree set by hand, its checkout kept

What they show:

• -f is printed where it should be.
  • (a) staged and K2 reset get git rm -r --cached -f -- Members/IRRS.
  • The sparse state gets git rm -r --cached --sparse -f -- ….
  • The committed states get no -f.
  • Every one types clean.
• Every state ends the same way:
  • one refusal, then add goes through;
  • the gate exits 0 in all three modes;
  • a plain clone plus git submodule update --init --recursive exits 0, with members/IRQS, members/IRRS and members/IRSS checked out;
  • a recursive clone gets members/IRRS from IRRS.git;
  • git submodule status exits 0 in the holder and in the clone.
• The naming comes first. At the moment the checkout is named, git -C <checkout> status lists ?? WIP.txt in every state. For K2 committed and K2 reset it ran before the update (row_checked_out_yet: False), and its toplevel was the checkout itself.
• No work is lost. The work commit is on refs/heads/main in its store before the deletion, after it, and after add (logs/r3stores2-243.jsonl). A plain git --git-dir=<store> read exits 128 once the checkout is gone, because the store's core.worktree then names a missing directory. Reading with an explicit --work-tree finds the commit. This is not a loss.

C5. It survives only because nothing pins it. My ruling is NIT 1 above.

The restack.

• The coordinator's literal pair differs (3492 against 3092 changed lines). That is because 3546118b is family.py add: the move back of a member's gitlink points its section of .gitmodules back, sets aside first what the index holds in its way and puts back a member whose removal is staged, its closing mv is guarded and leaves a checkout to delete by hand, and --sparse follows the sparse rules, so no printed line leaves a section naming another spelling or un-registers a member (#761) #828's final head, merges of main included, and 4e92867a does not contain it, so 3546118b..4e92867a also carries those changes in reverse.
• restack3.sh's own comparison is the right one. git diff -U0 ce0f2a5f 4e92867a (ce0f2a5f being the merge base of 4e92867a and 3546118b) against git diff -U0 281df263 6ef6e4c1, over family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865's 5 files: identical, 3053 changed lines each.
• The files changed against main are exactly family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865's 5.
• The merge with main changes none of family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865's lines. Main's only change to those files since the squash is def45de6, which adds 39 lines in class Family (scripts/family.py:309 and :421-458). family.py add: a section astray beside its gitlink, a variant of a row's path under members/, a link or checkout in a move's way, an unmerged entry and a staged or unmerged .gitmodules are named first, so each remedy types clean (#840) #865 changes nothing before :3278.

Runs at 6ef6e4c1 through run9.sh.

• logs/r3-head-243.log: the leftovers, member_variant, move_back_sections, case_variants and test_no_auto_maintenance.py files plus the trio, on 2.43. 415 passed, 0 skipped, rc 0.
• logs/r3-head-247.log: the leftovers file on 2.47.1. 69 passed, rc 0.
• w865f's final243.log and final247.log: 721 each (216 + 234 + 271), clean tree. This matches its account, as do its 12 of 13 mutants caught.

Sonar-style.

• Duplication in the round's new lines: none at 8 or 10 lines. The only 6-line window is the test's expected copy of _second_checkout_part's text (scripts/family.py:4943-4948 at 4e92867a, and tests/test_family_add_spelling_leftovers.py:212-217), a string mirror below the threshold.
• No assert joins conditions with and; the one hit is inside a string.
• By my count, with the comprehension-counted figure after the slash:
  • _members_spellings 46 / 61, def line unchanged; this is the issue that already exists.
  • _forced 1, _second_checkout_part 2, _second_path_part 5, _second_gitlink 2, _removed 2.
  • New test helpers all 5 or under.
  • typed_as_printed and typed_in_sh have f7072d08's def lines again.
• The body draft passes body-guard.py.

Could not verify

• CI's git 2.55.
• A real macOS or Windows disk: C5 was measured only through the link emulation.
• SonarCloud itself.

Scratch left

• Clones under /workspace/projects/openRepoShape-worktrees/_lane5-scratch/. I created no worktrees this round, so there was nothing to git worktree remove.
  • rv865b-head: at 6ef6e4c1, with untracked probe files.
  • rv865b-mut: at 6ef6e4c1, with untracked probes; family.py restored and clean.
  • rv865b-run: at 6ef6e4c1, clean.
  • rv865b-old: at 3bf2d3c9, with the untracked gap probe.
• Basetemps: $Q/v110/bt/rv865b-*.
• Logs: $Q/v118/rv865b/.
• No rm was run, nothing was pushed or posted, and nothing of mine is running.

[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

[brettheap]

Fix round 4 of #865 (#840): 6ef6e4c1..231c404c.

There is one commit on the coordinator's restack 6ef6e4c1, 231c404c, and it is a fast-forward. It changes one file, tests/test_family_add_spelling_leftovers.py, +38/-0. scripts/family.py is unchanged. $Q below is /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad.

NIT 1, mutant C5

C5, the own-spelling guard at scripts/family.py:4283 (checkout = present and …), can be pinned on Linux.

Done. The new test is test_a_second_paths_checkout_is_asked_in_its_own_spelling (line 1041), built from the file's existing helpers.

The state:

• the holder's row members/IRRS, as in the other cases;
• a second gitlink at Members/IRRS at the row's commit, committed, with its skip-worktree bit set, so it routes through RENAME_SPARSE;
• Members a link to members, so Members/IRRS resolves to the member's own checkout, as on a disk that folds case.

The test skips on Windows and on a disk that folds case, as the file's other link tests do.

What it asserts. The whole refusal (DIR_VARIANT, then link_out("Members") and second_out(VARIANT, commit="the removal", sparse=True)):

• the link is moved out first;
• then git rm -r --cached --sparse -- Members/IRRS and its commit;
• no part says to delete a checkout.

It then types the text as printed, which gives mv -- Members ../moved-1, git rm -r --cached --sparse -- Members/IRRS and git commit. The moved link is still a link, the member is registered at its row, and gate_then_add passes: the gate in every mode, the same add, and the gate again.

C5 is caught by tests/test_family_add_spelling_leftovers.py::test_a_second_paths_checkout_is_asked_in_its_own_spelling.

• Where. I ran $Q/v118/w865f/mutate3.py C5 with W865F_MUT set to a clone at 231c404c, /workspace/projects/openRepoShape-worktrees/_lane5-scratch/w865f-r4mut. The clone was clean afterwards.
• Result. Run -x over the leftovers file, it gave 1 failed and 32 passed, rc 1, failing on the new test ($Q/v118/w865f/r4/C5-mut.log, summary line in $Q/v118/w865f/r4/c5.log, $Q/v118/w865f/mut3/C5.log). In round 3, without this test, C5 survived with 69 passed ($Q/v118/w865f/mut3/C5-round3.log).
• The diff. A -vvv rerun of the new test alone with C5 applied ($Q/v118/w865f/c5probe4.py, $Q/v118/w865f/r4/C5-vv.log; 1 failed, the clone clean afterwards) shows what C5 adds. Before "then re-run.", the text gains "delete by hand each checkout that git rm --cached of a second path leaves on disk, Members/IRRS, once nothing only it holds is needed, rather than move it, and before any update below: …". That is the part asking to delete the member's own checkout, which the guard keeps out.

Runs

Log	Git	Head	What	Result
$Q/v118/w865f/r4/a.log	2.43	6ef6e4c1 plus the new test, before the commit	the new test	1 passed
$Q/v118/w865f/r4/b247.log	2.47.1	the same	the new test	1 passed
$Q/v118/w865f/r4/v243.log	2.43	231c404c, dirty=0	the leftovers file, test_family_add_member_variant.py, and the trio test_repo_hygiene.py, test_agents_md_codes.py, test_cli_reference.py	255 passed, rc 0
$Q/v118/w865f/r4/v247.log	2.47.1	231c404c, dirty=0	the leftovers file	70 passed, rc 0
$Q/v118/w865f/r4/C5-mut.log	2.43	231c404c with C5, in w865f-r4mut	the leftovers file, -x	1 failed, 32 passed (intended)
$Q/v118/w865f/r4/C5-vv.log	2.43	the same	the new test, -vvv	1 failed (intended)

• Every run went through $Q/v110/run9.sh, with the gh stub and a bogus token, and no more than two pytest processes at a time.
• For 2.47.1, $Q/v115/w764/git247/bin was first on PATH, and the log's first line is git version 2.47.1.
• The leftovers file holds 70 cases now (69 plus this one).

Merge check

Main was fetched with git -c gc.auto=0 -c maintenance.auto=false fetch --no-write-fetch-head origin main, at 09:32Z and again at 09:42Z. FETCH_HEAD was never read, and origin/main was 1ef1a0182d2c0eaeb3c15667021a421a4edba349 both times.

git merge-tree --write-tree origin/main 231c404c: clean, rc 0, tree eb07050652b85dd4f7a0d5ab7e896f51c130b31f ($Q/v118/w865f/r4/mt-origin-main.txt).

Push

231c404c was committed by pathspec, with the identity Brett Heap <service@opensoft.dev> given by -c and the two trailers ($Q/v118/w865f/commit6-msg.txt). git merge-base --is-ancestor 6ef6e4c1 HEAD held, and the remote read 6ef6e4c1a618b2d3cad084bdca40b964c05a7c26 before the push.

git push origin HEAD:refs/heads/fix/840-spelling-leftovers printed 6ef6e4c1..231c404c HEAD -> fix/840-spelling-leftovers, exit 0. git ls-remote origin refs/heads/fix/840-spelling-leftovers reads 231c404c57cfcc7246f3d14001e34cbe8dfcf69b. Nothing was posted.

Files

• $Q/v118/w865f/body4.md: the PR body, made from body3.md. It has a "Fix round 4" section and the new test in line 1. The count is 70 cases, and the mutant line now says C5 is caught by the new test. The stacking line says the branch is restacked at 6ef6e4c1.
• This file.

Both pass /usr/bin/python3 $Q/v113/body-guard.py.

[brettheap]

Re-check of #865 (#840) fix round 4 at 231c404c, for lane openRepoShape-5: READY

The new test pins C5 the way I described it, my own C5 edit fails exactly that test, and the round touches tests only. I have no findings.

$Q = /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad. My logs are in $Q/v118/rv865b/logs/.

Checked and true

1. The test builds the state I described. test_a_second_paths_checkout_is_asked_in_its_own_spelling is at tests/test_family_add_spelling_leftovers.py:1041.

• It adds a second gitlink at Members/IRRS at the row's commit, sets its skip-worktree bit and commits it. It then makes Members a link to members.
• It asserts the whole refusal (:1065): the lead, then remedy_of(link_out("Members"), second_out(VARIANT, commit="the removal", sparse=True)). So no checkout part may appear.
• It then types the text as printed and checks the typed list: mv -- Members ../moved-1, git rm -r --cached --sparse -- Members/IRRS, git commit. After that come the moved link, registered and gate_then_add.
• My own C5 edit fails it. I dropped present and at scripts/family.py:4283 in my clone rv865b-mut at 231c404c and ran the leftovers file.
  • Result: 1 failed, 69 passed, rc 1 (logs/r4-c5-mut.log).
  • The one failure is the new test, at the full-text assertion (:1065).
  • family.py was restored afterwards and the clone is clean.
• On 2.43 and 2.47.1 the test ran rather than skipped: neither log has a SKIPPED line.

2. Runs at 231c404c through run9.sh, both on a clean tree:

• logs/r4-head-243.log: the leftovers file plus the trio, git 2.43. 218 passed (70 + 148), 0 skipped, rc 0.
• logs/r4-head-247.log: the leftovers file, git 2.47.1. 70 passed, rc 0.
• w865f's count of 70 cases is right.

3. The diff.

• git diff 6ef6e4c1 231c404c touches only tests/test_family_add_spelling_leftovers.py, +38/−0. It is a fast-forward of 6ef6e4c1.
• No duplicated block: zero windows of 6, 8 or 10 lines touch the new lines.
• No assert joins conditions with and. The new asserts are a tuple equality, a list equality and an islink.
• The new test's cognitive complexity is 1.
• merge-tree against main 1ef1a018 is clean, tree eb070506, the same tree w865f reports.

Scratch left

Clones under /workspace/projects/openRepoShape-worktrees/_lane5-scratch/:

• rv865b-run: at 231c404c, clean.
• rv865b-mut: at 231c404c, family.py clean, untracked probe files.
• rv865b-head: at 6ef6e4c1, untracked probe files.
• rv865b-old: at 3bf2d3c9, untracked gap probe.

Basetemps are under $Q/v110/bt/rv865b-*. No rm was run, I created no worktrees, nothing was pushed or posted, and nothing of mine is running.

[sourcery-ai]

Sorry @brettheap, your pull request is larger than the review limit of 150,000 diff characters