[brettheap]

Closes #1136

#1169 targets main, after #1119 squash-landed there as b7edd881, through three merges: #1119's final head 9b856443 (ce1938a8), then its squash b7edd881 (93a561c9), then origin/main at 50ce8ab1 (fe25bb14, no conflict). The second merge took this branch's side (git checkout --ours) for the two files that conflicted, adopt-project.py and tests/test_adopt_check_throwaway_repos.py, both #1119's; git diff 9b856443 b7edd881 is empty over the whole tree, so that merge changes no file. The first merge had one conflict, in the module docstring of tests/test_adopt_check_throwaway_repos.py, where #1119's #1033 paragraph and this PR's #1136 paragraph stand at the same place: both stay, #1033 first. The restack is proved under "The restack" in Tests. It was left out of v1.2.0 by Brett Heap's ruling of 2026-10-21T10:32:04Z. It is now on milestone v1.2.1, and lands under Brett Heap's v1.2.1 merge word in its held slot.

What

#910's throwaways (the rehearsal, _stored_as_written, _AttributesProbe) are made with _inherited_env(), which leaves out GIT_CONFIG_PARAMETERS (a parent git's -c), GIT_ATTR_SOURCE, and any attr.tree in GIT_CONFIG_COUNT; _stored_as_written held none of the source's objects; and the rehearsal chose the files it asks about with check-attr --cached, which reads no attr.tree. So check answered as a git with none of them would, and execute stopped after both legs existed, or refused a plan its own git would carry out. Measured with git 2.43; "base" is bba168bd (#1119's head when this PR was written), "head" is this branch before its restack (76c9b767, a commit that changes one comment only: with docstrings emptied, its AST is equal to 1e958ca6's; the tests, mutants and gate below ran at 1e958ca6, but for the one call marked at 76c9b767; the restack's head, fe25bb14, carries the same changed lines, as "The restack" in Tests shows):

Case	Base	Head
parent -c core.protectHFS=true over a source path .g + U+200C + it/x	check exit 0 plan ok; execute exit 2 REFUSED extracting the spec leg (invalid path, unable to checkout working tree); both legs exist	check exit 1 plan-path-git-refuses; execute exit 2 REFUSED plan-path-git-refuses; remotes/ absent
the same setting in GIT_CONFIG_COUNT (control)	plan-path-git-refuses; refused; remotes/ absent	same
no setting (control)	plan ok; adoption verified	same
parent -c filter.<name>.clean=false, smudge=cat, required=true, over a root .gitattributes that names the filter for itself	plan ok; execute exit 2 extracting the spec leg (clean filter '<name>' failed); both legs exist	plan-attributes-reencoded; refused; remotes/ absent
the same filter in GIT_CONFIG_COUNT (control)	plan-attributes-reencoded; refused	same
a parent's attr.tree naming the empty tree, in GIT_CONFIG_PARAMETERS or GIT_CONFIG_COUNT, over a CRLF notes.txt the plan keeps under a root * text eol=lf (r1169's probe p8)	check exit 1 plan-file-reencoded; execute exit 2 REFUSED plan-file-reencoded before any leg, where its own git reads no rule either	check exit 0 plan ok; execute exit 0 adoption verified
the same in a global config, and no attr.tree (controls)	global: plan ok, adoption verified; none: plan-file-reencoded, refused, remotes/ absent	same
a parent's attr.tree naming by its object id a tree the source holds on a side branch, whose .gitattributes says /.gitattributes filter=w1136, with that failing filter, over a root *.png binary (probes p2, p7), in either form or a global config	check exit 0 plan ok in all three; execute made both legs and stopped in the spec leg, fatal: .gitattributes: clean filter 'w1136' failed, nothing rolled back (measured on b8e63bcf with check's refusal stubbed, in all three)	plan-attributes-reencoded naming clean filter 'w1136' failed, in all three; execute refuses before any leg; remotes/ absent
the same filter with no attr.tree (control)	plan ok	same
the same side tree and filter over a root *.md text in place of *.png binary (r1169b's P7), in each form	global: plan-file-reencoded alone, naming specs/001-feature/spec.md; parameters and count: plan ok. On 25805102: plan-attributes-reencoded and also plan-file-reencoded naming specs/001-feature/spec.md, in all three	plan-attributes-reencoded alone, naming clean filter 'w1136' failed, in all three
a parent's attr.tree naming by its object id a side-branch tree whose .gitattributes says * text eol=lf, over a CRLF notes.txt that no rule of the source's own reaches, sent to the spec leg (r1169b's P3) or kept under a root *.png binary (P5), in the global, parameters and count forms	check exit 0 plan ok in all six; execute is not refused before any leg: P3 exit 2 REFUSED mounting the legs (the following file has local modifications), P5 exit 1 adopt-lost naming notes.txt; both legs pushed, nothing rolled back (r1169b's real runs, the same on bba168bd and 25805102)	check exit 1 plan-file-reencoded naming notes.txt, in all six; execute refuses plan-file-reencoded before any leg; remotes/ absent
the same with no attr.tree (control)	plan ok	same
GIT_ATTR_SOURCE=bogus	plan ok; execute exit 2 extracting the spec leg (fatal: bad --attr-source or GIT_ATTR_SOURCE); both legs exist	adopt-git-unasked; refused; remotes/ absent
GIT_ATTR_SOURCE= (empty)	plan ok; execute exit 2 extracting the spec leg; both legs exist	adopt-git-unasked; refused
GIT_ATTR_SOURCE=HEAD, code leg seeded	plan ok; execute exit 2 REFUSED seeding the code leg; both legs exist	adopt-git-unasked; refused
GIT_ATTR_SOURCE= the source tree's abbreviated oid, code leg seeded	plan ok; execute exit 2 REFUSED pushing the spec leg; both legs exist	adopt-git-unasked; refused
GIT_ATTR_SOURCE=HEAD, no seeded leg; or a full tree oid, seeded or not (KNOWN LIMIT, below)	plan ok; adoption verified	adopt-git-unasked; refused
no GIT_ATTR_SOURCE (control)	plan ok; verified	same

The first round (b8e63bcf) answered the attr.tree rows as base does (r1169's SHOULD-1). The second (25805102) still said plan ok for P3 and P5, as base does, and gave P7 a second, misnamed finding (r1169b's SHOULD-1). Then 1e958ca6 answers r1169b's ruling X1, with item 4 below (one argument and the two docstrings that explain it, +16/-5 against 25805102) and 17 new rows, (j) and (k) in Tests. The head was then 76c9b767, which changes comments only: w1169b found that the comment above the rehearsal's attribute read still said check-attr --cached, and it now says the read is made without it (+3/-2 against 1e958ca6; with docstrings emptied, its AST is equal to 1e958ca6's). The restack that followed makes the head fe25bb14 and writes no line of its own. The change is adopt-project.py (+211/-57 against bba168bd, and the same against main at fe25bb14; no --help, doc or code change), and the tests below:

1. A parent's -c, attr.tree too. The rehearsal (_SplitRehearsal) and _stored_as_written take _split_checkout_env(): this process's environment less _NOT_INHERITED but GIT_CONFIG_PARAMETERS, so a parent's settings in GIT_CONFIG_PARAMETERS and GIT_CONFIG_COUNT reach them as they stand, attr.tree among them, as they reach execute's checkout, git rm and git add. _stored_as_written now borrows the source's objects as the rehearsal does (_objects_borrowed, which both use), so a tree's object id names there the tree the split's clones read.
2. GIT_ATTR_SOURCE. _attr_source_unasked(source) raises _Unasked, the existing adopt-git-unasked, whatever the value is, the empty one included, with an ending of its own ("execute refuses it too, whatever it names, before it makes either leg. Unset GIT_ATTR_SOURCE, ... and run check again.") in place of the shared one, which said execute refuses "while git cannot answer there" and offered another --work-dir (r1169's NIT-3). It runs first in _entry_findings' try, before the split's own clone is asked, so check gives one finding and asks nothing after it, and execute refuses before either leg.
3. Environment first. _AttributesProbe.__init__, _stored_as_written and _SplitRehearsal.__init__ read their environment before _throwaway makes the directory, so a read that raises leaves nothing behind, as adopt-project.py: check asks the split's own clone of the source in the work directory, so a clone this git will not make is adopt-git-unasked before any leg, and _resolved and _answers make their repositories as check's other throwaways do (#1083) #1119 made _resolved and _answers. _probe_env now takes (nothing, inherited); _AttributesProbe is its only caller.
4. No --cached. _SplitRehearsal.reached, which both _rules_reaching calls use (the files a rule reaches as the source holds its rules, and as the split's root will), asks check-attr without --cached, which reads the index's rules and no attr.tree. A file only a parent's attr.tree reaches is now asked about.

Why

• Why a parent's -c is handed to the rehearsal and to _stored_as_written. execute's checkout, git rm and git add run in the whole environment, so they take a parent's settings; the throwaways must answer as they do, as the same settings in GIT_CONFIG_COUNT already did. A throwaway's own -c still wins (git reads a command's own -c after the parent's and takes a key's last value), so a parent's core.hooksPath or core.fsmonitor runs nothing there; a row holds that.
• Why attr.tree is handed on too (r1169's SHOULD-1; lane 1's ruling: fix (b)). The first round dropped it from both forms, and r1169 measured check answering otherwise than execute both ways on b8e63bcf: under the empty tree check said plan-file-reencoded while execute's own git read no rule either (probe p8), and under the side tree check said plan ok while the split's git add of the root fails (probes p2, p7). A global config's attr.tree reached the rehearsal all along, but _stored_as_written held none of the source's objects, so a tree id named nothing there, and the side tree in a global config was plan ok too. Measured with git 2.43 in a commitless throwaway: without the source's objects a full tree id read no rule and an abbreviated one was ignored; borrowing them, both read that tree's rules, as the split's clones do; the empty tree read no rule either way; HEAD, a branch name and bogus were ignored either way. So _stored_as_written borrows the source's objects as the rehearsal does, and nothing of a parent's settings is dropped, which retires the first round's GIT_CONFIG_PARAMETERS reader (_parent_settings, _parameter_entries, _single_quoted), and with it r1169's NIT-2 and NIT-6.
• Why check-attr is asked without --cached (r1169b's SHOULD-1; ruling X1). r1169b measured with git 2.43, in a repository whose side tree says * text eol=lf: under attr.tree, check-attr --cached text eol -- notes.txt gives unspecified for both, and without --cached it gives text: set, eol: lf; the same in a commitless throwaway that borrows the source's objects, and in the parameters form. So a file only that tree's rules reach was left out of the files the rehearsal asks about, and check said plan ok where the split's checkout and git add, which do read attr.tree, change the file (P3, P5). Without --cached, git's check-in direction reads a work-tree .gitattributes first; _rules_reaching asks before any checkout or place() writes one, so git falls back to the index, and the answers with no setting do not change (the no-setting controls; the gate below). --cached was also the cause of P7's second, misnamed finding: with it restored, (k) fails in all three forms (M1 below), as it does on 25805102.
• Why GIT_ATTR_SOURCE is refused, not inherited. Measured on 2.43, no throwaway can answer for it. An abbreviated source-tree oid gave plan ok and execute stopped at pushing the spec leg after both legs existed. A commitless repository that borrows the source's objects, as the rehearsal does, takes that value (check-attr exits 0); one that does not borrow them refuses it (exit 128). So inheriting would still say plan ok where execute stops. HEAD resolves in the source yet stops execute at seeding the code leg, so a "bad value" question put to the source would fail too. The existing code adopt-git-unasked carries it, so there is no new code and no doc trio.
• Why _AttributesProbe takes no parent settings. It models a clone on another machine, which has none of them. It still keeps GIT_CONFIG_COUNT: that predates this PR and is left alone (a known limit only).

Tests

At head 1e958ca6 (the head was then 76c9b767, a comment-only commit that touches no test; the restack's fe25bb14 is under "The restack"). In tests/test_adopt_check_throwaway_repos.py (+630/-5 against bba168bd, and the same against main at fe25bb14; +674/-5 with row (l) below, at d9224ecf), the section # #1136 holds 56 ids, and the existing test_an_environment_read_that_raises_leaves_no_throwaway gains 3 params: 59 new ids, 17 of them from this round, (j) and (k); row (l), added after r1169d's review, makes 62. Rows that need a feature of git skip, with a reason, where probing git itself shows it is missing (a git that reads no attr.tree; one that holds the U+200C path under core.protectHFS); the real-execute rows skip where git filter-repo is not installed.

• (a) core.protectHFS=true over the U+200C path: plan-path-git-refuses from a parent's -c, and execute refuses before any leg; with the no-setting control.
• (b) a parent's clean filter: plan-attributes-reencoded, and execute refuses before any leg.
• (c) test_a_parent_gits_attr_tree_is_read_as_the_split_reads_it: under attr.tree=<empty tree>, plan ok in the global, parameters and count forms, and plan-file-reencoded with no setting. test_execute_reads_a_parent_gits_attr_tree_as_check_does (p8) runs a real execute under the same: adoption verified in the three forms, and REFUSED plan-file-reencoded with no setting, remotes/ absent. Each first asks the source's own check-attr eol: unspecified under the setting, lf without.
• (h) p2/p7: test_a_parent_gits_attr_tree_is_read_where_the_root_is_stored (global, parameters, count): one plan-attributes-reencoded naming clean filter 'w1136' failed; test_execute_refuses_a_parent_gits_attr_tree_filter_before_any_leg (the three forms); and the control test_the_failing_filter_alone_is_read_for_no_file, plan ok. Each first asks the source's own check-attr filter -- .gitattributes: w1136 under the setting. The source's root says *.png binary, which names none of its files; (k) has *.md text there.
• (j) r1169b's P3 and P5: test_a_file_only_a_parent_gits_attr_tree_reaches_is_asked_about (no setting, global, parameters, count; each for a CRLF notes.txt sent to the spec leg and kept under a root *.png binary; 8 ids): plan-file-reencoded naming notes.txt under the setting, plan ok with none. test_execute_refuses_a_file_only_a_parent_gits_attr_tree_reaches (the three forms, both cases; 6 ids): execute refuses plan-file-reencoded before any leg, and remotes/ is absent. The side tree says * text eol=lf; each row first asks the source's own check-attr eol -- notes.txt: lf under the setting, unspecified without.
• (k) adopt-project.py: under a failing clean filter that a rule names for .gitattributes, check also prints plan-file-reencoded for a file the split stores as its blob, beside the right plan-attributes-reencoded (#1136) #1192's case, r1169b's P7: test_a_parent_gits_attr_tree_filter_is_one_finding_over_an_own_rule (the three forms; 3 ids): the side tree of (h) over a root *.md text, one plan-attributes-reencoded naming clean filter 'w1136' failed and no plan-file-reencoded.
• (l) r1169d's SHOULD-1, added at d9224ecf: test_a_pinned_copy_under_a_parent_gits_attr_tree_unsets_the_trees_rule (the three forms; 3 ids). A side tree says /scripts/*.py filter=w1136upper, an upper-casing clean filter, over a source root that says /scripts/*.py ident, and attr.tree names the tree. Each row first asks the source's own check-attr filter ident -- scripts/bootstrap.py: w1136upper and unspecified under the setting. The copies finding (plan-file-reencoded, "store 5 pinned shape copies") then names -filter for each of the 5 copies and no -ident: the split's git add of the copies reads the tree's rule and not the root's. Head: 3 passed, no skip; with M3 below, 3 failed (assert '/scripts/validate-pins.py -filter' in "... -ident ..."). r1169d measured it on 25805102, which names -ident as M3 does: 3 failed; and on bba168bd: the global form failed the same way, the parameters and count forms said plan ok.
• (d) a parent's core.hooksPath and core.fsmonitor run 0 times where the rehearsal and _stored_as_written ask (global config, parameters and count), with the git add control in the same row.
• (e) GIT_ATTR_SOURCE is one adopt-git-unasked finding that names it, for 7 values (bogus, empty, HEAD seeded, the abbreviated tree seeded, HEAD and the full tree as the known limit, and the empty tree), ending with its own words (ATTR_SOURCE_ENDS, r1169's NIT-3); execute refuses the first 3 before any leg, with the same ending.
• (i) r1169's NIT-1: test_git_attr_source_is_refused_before_the_splits_own_clone_is_asked records _split_clone_asked: under GIT_ATTR_SOURCE, execute refuses adopt-git-unasked, the recorder stays empty, the work directory holds nothing, and remotes/ is absent.
• (f) the three new params, _AttributesProbe, _stored_as_written and _SplitRehearsal, with _inherited_env and _split_checkout_env both made to raise.
• (g) test_the_checkout_questions_take_the_settings_and_no_attr_source: _split_checkout_env() is this process's environment less the six variables of ANOTHER_REPOSITORY (GIT_DIR, GIT_WORK_TREE, GIT_INDEX_FILE, GIT_COMMON_DIR, GIT_OBJECT_DIRECTORY, GIT_ATTR_SOURCE), with GIT_CONFIG_PARAMETERS and the GIT_CONFIG_COUNT entries as they stand, attr.tree in each; with no GIT_CONFIG_PARAMETERS there is none. The first round's 13 parser rows went with _parent_settings. Every setting a row gives is appended after what the environment holds, never overwritten, so tests/test_no_auto_maintenance.py still holds.

Older rows changed in other files (outside the one test file the plan named; the change forces them):

• The first round dropped six GIT_ATTR_SOURCE params (HEAD, and the empty tree's oid) from test_adopt_nested_attributes.py (two functions) and test_adopt_reencoded_files.py (one): the head refuses GIT_ATTR_SOURCE first, so each found adopt-git-unasked where the older finding stood. Each docstring points to test_git_attr_source_is_one_finding_that_names_it, which holds HEAD and the empty tree.
• The second round flipped the two attr-tree-in-the-command-scope rows, which asked that the count-form empty tree NOT be read and found the file: test_adopt_reencoded_files.py's, now test_a_tree_this_machine_names_steers_the_question_as_it_steers_the_split, and test_adopt_nested_attributes.py's split-question row, now test_a_tree_this_machine_names_steers_the_split_question_as_the_split. Each now expects plan ok, with a no-setting control in the same row that finds the file. Measured on the head tool with a real execute, under that setting each source gives adoption verified, and with none execute refuses before any leg. test_command_scopes_built_at_the_test.py's SITES names the reencoded row by its new name. The nested-question row (test_no_tree_this_machine_names_steers_the_question) is unchanged: _AttributesProbe still takes no attr.tree.

Base vs head, 67 ids: the 50 of the earlier rounds (the 42 new then, row (f)'s 3 older params, the clone row (its six variables are now the shared ANOTHER_REPOSITORY), the 2 flipped rows and SITES' 2) and the 17 of (j) and (k). The head's tests ran over each tool in a scratch clone:

• bba168bd: 49 failed, 18 passed (101.9 s). Over the 50 ids: 34 failed, 16 passed (58.6 s). Failed: (f) all 6, at the new monkeypatch.setattr(adopter, "_split_checkout_env", ...), which finds nothing to set there, so bba168bd does not measure (f) (the first round measured its 3 new params leaving a throwaway behind there, and its 3 older ones passing); (a) and (b), the parameters form, check and execute (4); (c) and p8, parameters and count (4: plan-file-reencoded, refused); p2/p7 in all three forms (3: plan ok) and their execute rows (3: no refusal); (e) 7 + 3; (i); (g), with no _split_checkout_env; the two flipped rows (each found the file). Passed: the clone row; (a) and (b) count, check and execute (4), and the (a) control; (c) and p8, no-setting and global (4); the filter control; (d) all 3; SITES 2. Over the 17 ids: 15 failed, 2 passed (the 2 no-setting controls of (j)); P7: global plan-file-reencoded alone, parameters and count plan ok; P3 and P5: check plan ok in all six, and execute not refused (both legs pushed).
• b8e63bcf (the first round), over the 50 ids: 23 failed, 27 passed (56.0 s). Failed: (c) and p8, parameters and count (4, r1169's p8); p2/p7 and their execute rows (6, r1169's p2 and p7, the global form included); (e)'s 7 on the ending and its 3 execute rows on the same (r1169's NIT-3); (g), whose GIT_CONFIG_PARAMETERS lacked attr.tree; the two flipped rows. Passed: (f) all 6, and (i), which is a guard there (b8e63bcf asks in this order already; M6 below is what it kills). The 17 were not run on b8e63bcf.
• 25805102: 15 failed, 52 passed (92.9 s). The 50 pass. Of the 17, the same 15 fail and the 2 controls pass: P7 gives plan-attributes-reencoded and also plan-file-reencoded in all three forms; P3 and P5: check plan ok in all six, and execute not refused (both legs pushed).
• Head: 67 passed (inside G2 and Gf2 below), and 67 passed under a 3.14-like shim (88.4 s; Path.exists.__qualname__ read _quiet.<locals>.quiet, so the shim was active).

Mutants at head 1e958ca6: 2 killed of 3, and M3 survived; with row (l), M3 is killed too, 3 of 3. The head was then 76c9b767, which changes a comment and no code, and the restack's fe25bb14 writes no line of this PR, so they were not run again. Run in a scratch clone over the 67 ids, without -x; each file was restored in a finally, and its blob was HEAD's after each:

• M1, --cached restored in _SplitRehearsal.reached (both calls): killed, 15 failed (the 15 rows of (j) and (k) with a setting).
• M2, --cached for the first _rules_reaching call only (the source's own rules): killed, 9 failed (P7 in three forms; P3, the file sent to a leg, in three forms, check and execute). P5, a kept file, is still found by the second call.
• M3 (r1169d's K3), --cached for the second call only (the split's root): survived the 67 ids, and it is not equivalent (r1169d's SHOULD-1). Under an attr.tree the first call already reads that tree for every file, so reached | (kept & at_the_root) can only grow, by files asked about needlessly, which the real git add then stores as their blobs; with no attr.tree the work tree is empty when _rules_reaching asks, so both forms read the index. But M3 does change at_the_root, which _copies_finding reads for the unset line of a pinned copy under an attr.tree (r1169c's 33 probes per tool: 12 differ, 21 are byte-equal): with the side tree saying /scripts/*.py filter=... and the source's own root saying nothing or a neutral rule, head names /scripts/validate-pins.py -filter for the copy and M3 says "a line that keeps the rule off scripts/validate-pins.py"; with the own root saying /scripts/*.py ident, head names -filter, the tree's rule, which the split's git add reads, and M3 names -ident, as 25805102 does, which git does not read there. Row (l) holds it: M3 fails its 3 ids of 3 (measured at fe25bb14 plus the row, in a scratch clone, by adding a cached argument to _SplitRehearsal.reached, which puts --cached in the check-attr call, and passing cached=True at the AS_SPLIT call; adopt-project.py's blob was HEAD's after the restore).
• r1169d's K4 to K6, --cached only where GIT_CONFIG_PARAMETERS, a GIT_CONFIG_KEY_<n> or a global config file names attr.tree: killed by (k), in [git-config-parameters], [git-config-count] and [global-config].
• r1169d's K7, every .gitattributes checked out before _rules_reaching runs, which breaks the precondition reached's docstring names: not equivalent, and killed by two rows, though it survived the 129 ids of the throwaway file. Over the nested and reencoded files it gave 2 failed, 124 passed: test_adopt_nested_attributes.py::test_an_encoding_the_root_attributes_is_not_in_is_found (assert set() == {'plan-file-reencoded'}: the root's working-tree-encoding=UTF-16LE copy, checked out, gives git no rules) and test_adopt_reencoded_files.py::test_every_file_is_read_again_whatever_the_clock (.gitattributes ctime).
• r1169d's K8, --cached where attr.tree is unset: equivalent. It passed all 255 ids (129, and 126 over the nested and reencoded files). With no attribute source, check-attr without --cached reads a .gitattributes in the work tree first, and the index otherwise; the work tree holds none when _rules_reaching asks (the precondition K7 breaks, which those two rows hold). The only other attribute source, GIT_ATTR_SOURCE, never reaches the rehearsal: _NOT_INHERITED names it, _split_checkout_env drops it (row (g)), and _attr_source_unasked refuses it before any throwaway is made (rows (e) and (i)).
• Tally with r1169d's K1 to K8: 6 of 8 killed by the rows before row (l), K3 by row (l), K8 equivalent: 7 of 7 non-equivalent killed.
• f1169's 13 older mutants were not re-run at this head. They ran at 948d1771, whose tool is 25805102's, so with --cached in reached; since then the tool changes by that argument, two docstrings and, at 76c9b767, one comment.

The 13 older mutants: 13 killed of 13, no survivor. Run in a scratch clone at 948d1771 (the tests there differ from 25805102 in one row's name, one docstring and the ATTR_SOURCES comment) over the 50 ids with -x; each file was restored in a finally, and its blob was HEAD's after each. Each was killed by the first row named:

• r1169's M6, _attr_source_unasked after _split_clone_asked: (i). r1169's M10 (_PARAMETER_SPACE) is moot: that reader is gone.
• the count form's attr.tree dropped again (_split_checkout_env as _split_clone_env()): (c) [git-config-count];
• no _objects_borrowed in _stored_as_written: p2/p7 [global-config];
• GIT_CONFIG_PARAMETERS dropped from _split_checkout_env: (a) [git-config-parameters];
• the environment read after _throwaway, in _stored_as_written, _SplitRehearsal and _AttributesProbe (three mutants): (f) [stored-as-written], [split-rehearsal], [attributes-probe];
• the shared ending for GIT_ATTR_SOURCE: (e) [bogus];
• extras: no _attr_source_unasked call: (e) [bogus]; an empty GIT_ATTR_SOURCE allowed: (e) [empty]; no _objects_borrowed in the rehearsal: (a)'s control; _split_checkout_env keeping GIT_ATTR_SOURCE, and returning the whole environment (two mutants): (g).

The gate at 1e958ca6 (the head was then 76c9b767, a comment-only commit; the one call marked below ran at it; the calls at the restack's fe25bb14 are under "The restack"), in the worktree, CPython 3.12.3, git 2.43, in the probe environment (a stub gh, GH_TOKEN=bogus-f1169d, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null, GIT_SSH_COMMAND=false), each call under 9 minutes and at most two at once, node ids passed line by line. The last row ran in a scratch clone at the merge with #1180:

Call	Files	Result
G2	test_adopt_check_throwaway_repos.py	129 passed (182.9 s), no skip
Gf2	test_adopt_nested_attributes.py, test_adopt_reencoded_files.py, test_command_scopes_built_at_the_test.py, test_adopt_printed_sentences.py (it imports from the reencoded file), test_path_guard_hygiene.py, test_no_auto_maintenance.py, test_validator_child_encoding.py	452 passed, 2 skipped (338.4 s). Both skips are test_no_auto_maintenance.py:222: "the session began with GIT_CONFIG_GLOBAL set, and its file includes that one", which the probe environment's GIT_CONFIG_GLOBAL=/dev/null causes; they do not come from this PR
G4	test_scaffold_leg_path_collisions.py	104 passed (4.9 s)
G3	test_adopt_root_symlinks.py	205 passed, 3 skipped (350.4 s). The 3 skips: "the reftable backend needs git 2.45 or later" (this bench has git 2.43)
D0	test_shape_doctor.py, shard 0 of 4 (112 ids)	111 passed, 1 skipped (175.9 s), the PowerShell skip: "the PowerShell line is printed, and powershell.exe exists, only on a Windows host"
D1	test_shape_doctor.py, shard 1 of 4 (112 ids)	112 passed (158.3 s)
D2	test_shape_doctor.py, shard 2 of 4 (112 ids)	111 passed, 1 skipped (201.1 s), the same PowerShell skip
D3	test_shape_doctor.py, shard 3 of 4 (112 ids)	111 passed, 1 skipped (184.8 s), the same PowerShell skip
G9	test_adopt_submodule_url_answers.py, test_adopt_manifest_values.py, test_adopt_relative_submodule_url.py (the three that call _entry_findings directly)	138 passed (225.7 s), no skip
H2	test_repo_hygiene.py and test_path_guard_hygiene.py at 76c9b767, in the same probe environment (GH_TOKEN=bogus-w1169c); test_repo_hygiene.py is one of the doc trio, and the other two did not run, as no docstring that reaches --help changed	149 passed (14.1 s)
merged with #1180	the 67 ids and test_adopt_partial_clone_source.py (37 ids), on the merge of this head with #1180's b316f415 (Known limits)	104 passed (115.0 s)

The doctor's 4 shards are 448 ids (from a fresh collect): 445 passed, 3 skipped.

The gate files named by what the change touches: adopt-project.py (the doctor shards and the scaffold collisions file), the symbols it names (GIT_ATTR_SOURCE, _inherited_env, _AttributesProbe, _SplitRehearsal, plan-path-git-refuses: a git grep finds only the files above), the three files that call _entry_findings directly, before which _attr_source_unasked now runs, the file that imports from a changed test file, and the hygiene and config gates. No doc, code or --help text changed, so the doc trio did not run.

The restack, at fe25bb14 (three merges and no line written; w1169e, Claude Sonnet 5.5). The real base is bba168bd (git merge-base 76c9b767 e0a98f13, where e0a98f13 is a later head of #1119, between bba168bd and its final head 9b856443); the old head is 76c9b767.

• The second merge changed no file: git diff ce1938a8 93a561c9 is empty, over adopt-project.py: check asks the split's own clone of the source in the work directory, so a clone this git will not make is adopt-git-unasked before any leg, and _resolved and _answers make their repositories as check's other throwaways do (#1083) #1119's four files (adopt-project.py, tests/test_adopt_check_throwaway_repos.py, tests/test_adopt_reencoded_files.py, tests/test_adopt_root_symlinks.py) and every other.
• git diff --name-only origin/main fe25bb14 lists the same 5 files as git diff --name-only bba168bd 76c9b767: adopt-project.py, tests/test_adopt_check_throwaway_repos.py, tests/test_adopt_nested_attributes.py, tests/test_adopt_reencoded_files.py, tests/test_command_scopes_built_at_the_test.py. --numstat is the same too: +211/-57, +630/-5, +26/-16, +24/-13, +2/-1.
• The changed lines of git diff -U0 origin/main fe25bb14 and of git diff -U0 bba168bd 76c9b767 are equal (the + and - lines, with the +++ and --- headers left out): 985 lines each, the same sha256.
• At fe25bb14, in the probe environment (a stub gh, GH_TOKEN=bogus-w1169e, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null, GIT_SSH_COMMAND=false), two calls at once, each under 9 minutes:

Call	Files	Result
R1	the four test files of the diff: test_adopt_check_throwaway_repos.py, test_adopt_nested_attributes.py, test_adopt_reencoded_files.py, test_command_scopes_built_at_the_test.py	276 passed, 1 skipped (372.7 s). The skip is test_on_a_disk_that_ignores_case_each_twin_is_held_or_named, "needs a disk that ignores case" (a row #1119 added; this bench's disk keeps case); it does not come from this PR
R2	test_no_auto_maintenance.py	58 passed, 2 skipped (12.4 s). The 2 skips are the GIT_CONFIG_GLOBAL ones the gate above explains

The doctor's shards, test_scaffold_leg_path_collisions.py, test_adopt_root_symlinks.py and the hygiene files did not run again at fe25bb14: their calls are above, at 1e958ca6. Row (l) then makes the head d9224ecf, one commit on fe25bb14: +44/-0 in tests/test_adopt_check_throwaway_repos.py and no other file; its 3 ids ran at fe25bb14 plus the row (and under M3, below), and R1 did not run again with it.

The full suite did not run here, and CI's CPython 3.14 did not run (this bench has 3.12.3 only; the 3.14-like shim ran the 67 ids). A grep of the new rows finds no ast.dump, repr( or Python version test; the git answers they compare with are read at run time (check-attr, git add in a repository of their own).

Known limits

• A valid GIT_ATTR_SOURCE is refused too (lane 1's ruling: accepted). HEAD with no seeded code leg, and a full tree oid, took execute to adoption verified on base (rows (e) hold them); now check says adopt-git-unasked and execute refuses. It is the only rule with no plan ok where execute stops, for a variable the split has no use for; the way out is to run without it, which the finding says (and that a git --attr-source running this tool also sets it).
• _AttributesProbe keeps GIT_CONFIG_COUNT (lane 1's ruling: a known limit only). It models a clone on another machine, yet still reads GIT_CONFIG_COUNT; that predates adopt-project.py: #910's throwaways leave out a parent's -c settings and GIT_ATTR_SOURCE, so check says plan ok where execute stops after both legs, and three read the environment after making the throwaway (follow-up of #1083) #1136 and is not changed here.
• A name in attr.tree. HEAD or a branch names nothing in a throwaway, which holds no ref, so git reads the files' own rules there, as with no setting (measured with git 2.43). In the split's clones HEAD, a tag and the split's own branch resolve; another source branch is held there only as origin/<name>, so attr.tree=<that branch> names nothing there either (r1169b's NIT-1: measured in a plain local clone, side read no rule and origin/side read them; HEAD and a tag were not run through the tool). An object id, the empty tree included, is read as the split reads it (rows (c), (h), (j), (k)).
• The findings point at the source's own rules. Under a parent's attr.tree, plan-file-reencoded still ends "Commit it in the source as git stores it ..., or change the rule that reaches it", where the rule is in the tree attr.tree names and the source holds none for the file (r1169b's NIT-2). The finding is right; the advice does not name the setting. Under a parent's attr.tree the copies finding (plan-file-reencoded, "store 5 pinned shape copies") names the right attribute but puts the lines in the source's root .gitattributes, which git does not read there; following it gives the same finding again (r1169d's NIT-1: with the own root holding *.png binary plus the five /scripts/<copy> -filter lines the finding asks for, and the side tree's filter rule read through attr.tree, head gives exit=1 with the same finding, asking for the same five lines, in all three forms; with the same rule in the own root, followed by the five lines, and no attr.tree, plan ok). 25805102 loops the same way, with the generic line, so it is not new here. Row (l) checks only which attribute is named, so it holds after any rewording of this ending. Not changed here.
• A misnamed second finding wherever both rules are read from one place. With both rules in the source's own root .gitattributes, which says /.gitattributes filter=w1136 and *.md text (either order), the failing filter in the global config, GIT_CONFIG_PARAMETERS or GIT_CONFIG_COUNT, and no attr.tree, check says the right plan-attributes-reencoded and also plan-file-reencoded naming specs/001-feature/spec.md, a file the split stores as its blob. Measured on this head and on 25805102, in all six (three forms, two orders); on bba168bd the global and count forms gave the same two findings, and the parameters form plan ok. With the filter alone, plan-attributes-reencoded comes alone everywhere (plan ok on bba168bd's parameters form). The same comes when both rules are in the side tree attr.tree names (r1169d, measured at 76c9b767 with git 2.43: the source's own root says *.png binary, the side tree says /.gitattributes filter=w1136 and *.md text, and attr.tree names that tree with the failing filter): in each of the three forms, head gives exit=1 with plan-attributes-reencoded and also plan-file-reencoded naming specs/001-feature/spec.md; 25805102 gives plan-attributes-reencoded alone; bba168bd gives exit=0, plan ok. The control, the tree's *.md text alone with no filter, is plan ok on head, 25805102 and bba168bd in all three forms, so spec.md (# The feature, LF only) is stored as its blob and the second finding names a file that is not reencoded. This case comes with ruling X1: the read without --cached now reaches spec.md through the tree's *.md text, so the file is asked about, where base said plan ok. Either way check refuses with the right first finding, and execute refuses before any leg, so it is no false plan ok. The cause is traced (r1169c's expB, git 2.43): under the failing required filter, the rehearsal's asked.git(["update-index", "-q", "--refresh"], TAKEN), whose exit code is never read, exits 128 with fatal: .gitattributes: clean filter 'w1136' failed; the diff-files --name-only after it exits 0 and lists .gitattributes specs/spec.md, the files it did not refresh; with no filter, the refresh exits 0 and diff-files lists nothing. The own-rules case predates this PR, which only lets its parameters form reach it; the side-tree case does not predate it, because this PR's read without --cached brings it in. adopt-project.py: under a failing clean filter that a rule names for .gitattributes, check also prints plan-file-reencoded for a file the split stores as its blob, beside the right plan-attributes-reencoded (#1136) #1192's attr.tree case (P7: the filter in the side tree and *.md text in the source's own root) is the two-places case, not this one: --cached made the check read the own root's *.md text, which git does not read under attr.tree, so spec.md was asked about and the refresh's list named it; without --cached it is not asked about, and the one finding stays (row (k)).
• An org/repo source not cloned yet (r1169's NIT-4). gh repo clone checks out in the whole environment, so under GIT_ATTR_SOURCE=bogus or an empty value the clone is refused as source-unclonable, whose remediation names gh auth status, before _entry_findings asks anything; HEAD clones (r1169's probe p5, with plain git clone; the tool path read, not run). It is no false plan ok.
• adopt-project.py check: a partial-clone source missing blobs that check reads is fetched into, so check's own reads run the upload-pack its config names and write a promisor pack into the source #1145 overlap. adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180 (fix/1145-partial-clone-source-no-fetch) was also stacked on bba168bd, at head b316f415; it has been restacked onto main since, and its head is a0e8cded. Before the restacks: git merge-tree --write-tree --merge-base=bba168bd 1e958ca6 b316f415 exits 0 with tree 1a9ec825 (no conflict: adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180 touches adopt-project.py, docs/cli.md and its own test file). On that tree, in a scratch clone, this PR's 67 ids and adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's test_adopt_partial_clone_source.py (37 ids) gave 104 passed (115.0 s) (r1169b's NIT-3). The head was then 76c9b767: the same git merge-tree command with it in place of 1e958ca6 exits 0 with tree ee59fb02, which differs from 1a9ec825 only in the one comment of adopt-project.py that this commit changes (git diff --stat of the two trees: 1 file, +2/-3); the 104 were not run again on it. After both restacks, with both branches on main 50ce8ab1: git merge-tree --write-tree fe25bb14 a0e8cded exits 0 with tree ac442d4c (no conflict: adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180 touches adopt-project.py, docs/cli.md and tests/test_adopt_partial_clone_source.py); the 104 were not run again on it either.

Not in this PR

• No _AttributesProbe change for a parent's settings (it models another machine), and no change to _split_clone_env, which hands the split's clone the settings whole and was only reworded in one docstring sentence.
• No inheriting of GIT_ATTR_SOURCE into any throwaway, and no new code, doc, --help text or doc-trio row.
• No change to execute's own commands: they already run in the whole environment.
• No change to the rehearsal's refresh under a failing filter (the misnamed second finding above, wherever both rules are read from one place: the source's own root, or the side tree attr.tree names, which this PR's read without --cached brings in).
• No change to the findings' wording under a parent's attr.tree (the limit above).

Lane: openreposhape-1 (openRepoShape-1)

🤖 Generated with Claude Code

Summary by Sourcery

Make adoption planning match execution under inherited Git configuration and refuse unsupported attribute-source settings before any repository work begins.

Bug Fixes:

• Make check accurately model the parent Git settings and attribute trees used by execute, preventing plans that would fail during checkout or staging.
• Refuse any GIT_ATTR_SOURCE setting before asking further questions or creating adoption legs.

Enhancements:

• Align attribute reachability checks with Git's non-cached checkout and add behavior, including source-object access for attr.tree object IDs.
• Ensure throwaway repositories read their environment before creation so environment failures leave no temporary repositories behind.

Tests:

• Add coverage for inherited configuration, attr.tree, GIT_ATTR_SOURCE, environment-read ordering, and early execution refusal behavior.

[sourcery-ai]

Reviewer's Guide

Implementation

Make the rehearsal and stored-as-written checks mirror the split’s checkout environment, borrow the source’s objects, refuse GIT_ATTR_SOURCE before asking questions, and read throwaway environments before creating them.

• adopt-project.py L11418-11429, L11646-11755, L12745-12756 (+21 small edits)

Tests

Update regression coverage for inherited settings, attribute trees, early GIT_ATTR_SOURCE refusal, environment-read ordering, and related existing attribute-question expectations.

• tests/test_adopt_check_throwaway_repos.py L54-75, L1491-1499, L1686-2318 (+3 small edits)
• tests/test_adopt_nested_attributes.py L433-437, L639-660 (+2 small edits)
• tests/test_adopt_reencoded_files.py L436 (removed lines), L438-462
• tests/test_command_scopes_built_at_the_test.py L33-34

---

Tips and commands

Interacting with Sourcery

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

Customizing Your Experience

Access your dashboard to:

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

Getting Help

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

[brettheap]

(lane openRepoShape-1, 2026-10-22T21:25:15Z) Independent review r1169 of #1169 at b8e63bcf, partial, stopped at the shared window's STOP: NOT READY, for one SHOULD.

• SHOULD: dropping attr.tree makes check's rehearsal answer differently from execute, in both directions, and row (c) pins one wrong answer. It is not a regression from base.
• NITs: 6.
• What checks out: the -c reader matched git over 3000 fuzzed values, base against head matches the body, and the merged tree with adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180 passes 67.
• Mutants: 9 of 11 killed.

Lane 1 rules on SHOULD-1 and runs the fix round in a later window.

PR #1169 review by r1169: verdict NOT READY

I stopped early on lane 1's STOP. No run of mine is still live: every run was a foreground call and all of them finished. The mutant clone's adopt-project.py was put back after each mutant, and its blob matched HEAD's after the last one (M11, restored=True). The review checkout /workspace/projects/openRepoShape-worktrees/l1-r1169 was never written to.

The verdict rests on SHOULD-1. If lane 1 rules that gap a known limit, and the body and the row (c) docstring are corrected, I would expect READY on the parts I covered.

What I measured that matches the PR body

• Base against head, the 45 ids. On head, 45 passed (31.7 s). With the base tool (bba168bd) under the head tests, 31 failed and 14 passed (42.6 s).

  • The failures group exactly as the body says: (f) the 3 new params; (a) and (b) in the parameters form, check and execute; (e) all 7 values plus the 3 execute rows; (g) all 14 (AttributeError).
  • The rows that pass on base are the ones the body names: the 3 older (f) params, the (a) and (b) count forms, the (a) control, and all of (c) and (d).

• Six older rows. At bba168bd, tool and tests together, the 6 git-attr-source-* params passed. The same old rows run against the head tool failed, all 6, each with FINDING adopt-git-unasked: ... where the older finding stood. git grep finds no other GIT_ATTR_SOURCE row in tests/. Lane 1's ruling on these rows is honest and complete.

• The 3.14-like shim. It makes exists, is_file and is_dir answer False to any OSError. Under it the 45 ids passed (33.3 s).

• The -c reader against git's own reading. I fuzzed 3000 random GIT_CONFIG_PARAMETERS values (seed 1169) with /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1169/fuzz.py. They mixed:

  • quotes, '\'' and '\!' escapes, case, subsections, empties and implicit bools;
  • separators of space, tab, LF and CR, plus VT and FF, which git does not take as spaces.

  Results:

  • Of the 489 values git reads (205 of them had an attr.tree dropped), git's config -z --list under _parent_settings() matched the raw list less attr.tree every time.
  • Of the 2511 values git refuses, the reader made none readable. 66 changed when an attr.tree entry was dropped, and git still refused all of them (an invalid key).
  • Total: 0 mismatches.

• A boolean -c attr.tree (with no value) makes every git command die (missing value for 'attr.tree'). check stops with REFUSED git-failed at git rev-parse --is-inside-git-dir in the source, on base and on head. So it gives no false plan ok.

• adopt-project.py check: a partial-clone source missing blobs that check reads is fetched into, so check's own reads run the upload-pack its config names and write a promisor pack into the source #1145 overlap. adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's head is now 2c8082a2. git merge-tree --write-tree --merge-base=bba168bd b8e63bcf 2c8082a2 exits 0 with tree 3a74e27a. On that merged tree, the 45 ids plus adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's 22 ids gave 67 passed (46.3 s).

• Body facts.

  • Line counts: adopt-project.py +242/-39, the main test file +455/-4, the other two 11/11 and 7/8.
  • 112 ids in the main test file.
  • The title is 240 characters.
  • There is exactly one closing line, Closes #1136.
  • The base is fix/1083-check-asks-the-split-clone at bba168bd (read back with gh api). closingIssuesReferences is [] only because the base is not main.

• Known limit 1, a valid GIT_ATTR_SOURCE refused. The [head] and [the-tree] rows fail on base and pass on head, so the refusal is measured. It is honest, and "whatever the value is" covers branch names and commit ids too. I did not re-measure adoption verified on base.

• Known limit 2, _AttributesProbe keeping GIT_CONFIG_COUNT. This is honest, by reading only. The probe's own -c for core.attributesFile, core.ignorecase, core.hooksPath and core.fsmonitor comes after GIT_CONFIG_COUNT, and attr.tree is dropped. I found no key in GIT_CONFIG_COUNT that steers its answer. Not measured.

• Can the environment read still leave a directory behind? By reading, no. All six throwaway makers (_resolved, _answers, _split_clone_asked, _AttributesProbe, _stored_as_written, _SplitRehearsal) read their environment before _throwaway. Nothing that can raise sits between _throwaway and the try/__enter__ cleanup. The (f) rows pass on head and the 3 new ones fail on base; I did not run my own mutants of the reorder (M15–M17).

Findings

SHOULD-1: dropping attr.tree makes the rehearsal and _stored_as_written answer differently from execute, in both directions, and row (c) pins one wrong answer as correct.

Where: adopt-project.py:11708-11733 (_parent_settings), adopt-project.py:11736-11764 (_split_checkout_env), and row (c) at tests/test_adopt_check_throwaway_repos.py:1648-1679. It is not a regression: base drops GIT_CONFIG_PARAMETERS whole, and the GIT_CONFIG_COUNT drop dates from #910.

1. A false refusal (probe p8, head). I used row (c)'s source and ran cmd_execute with _refuse_what_check_finds stubbed, so that execute's own git shows.

   • With a parent's 'attr.tree'='<empty tree>': check gives FINDING plan-file-reencoded, exit 1, yet execute goes on to adoption verified: every source path is in exactly one place.
   • Control, with no setting: the same finding, and execute fails after both legs ("NOTHING has been rolled back: .../Northwind-spec.git and .../Northwind-code.git exist").

   So the body's reason "the empty tree's oid silences every rule" applies to execute as well. Row (c)'s premise, "which in the rehearsal would silence what it finds", is wrong for this machine's split.

2. A false plan ok (probes p2 and p7, base and head alike). The parent sets -c attr.tree=<a tree on a side branch whose .gitattributes says /.gitattributes filter=w1136>, plus a failing required filter, in either the parameters or the count form.

   • check exits 0 with plan ok.
   • The split's git add of .gitattributes, run in a clone of the source under the same environment, exits 128: clean filter 'w1136' failed. Without the attr.tree entry the same add exits 0.

3. The drop is not consistent across config scopes (probe p7). The same settings in a global config file give plan-file-reencoded, on base and head. The rehearsal borrows the source's objects, so it does read a global attr.tree; only the command-scope forms are dropped.

Fix: at minimum, add a measured Known-limits bullet. Then correct the body's "Why attr.tree is dropped" paragraph, row (c)'s docstring and _parent_settings' docstring, and open a follow-up issue. The better fix is to hand attr.tree on to the rehearsal, which resolves an object id as the split's clones do, and to settle _stored_as_written the same way.

NIT-1: nothing pins "before any question". Mutant M6 moves _attr_source_unasked(source) after _split_clone_asked(source) at adopt-project.py:9530, and it survives: 45 passed. The split's clone is --no-checkout and removes itself, so nothing observable changes. Fix: a row asserting that _split_clone_asked is never called under GIT_ATTR_SOURCE.

NIT-2: no row separates entries with a tab, LF or CR. Mutant M10 (_PARAMETER_SPACE = " ") survives: 45 passed. The fuzz shows the code itself is right. Fix: a READABLE param built with appended_by_hand that uses \t and \n before an attr.tree entry.

NIT-3: the GIT_ATTR_SOURCE finding reuses _Unasked's generic text. See adopt-project.py:11773-11809 and the test's UNASKED_ENDS at tests/test_adopt_check_throwaway_repos.py:121. Probe p4 on head prints ... and it could not: GIT_ATTR_SOURCEis set in its environment, tobogus, ..., and the finding then ends with:

• "execute asks the same ... and refuses while git cannot answer there", though execute refuses whatever git answers;
• "... or pass another --work-dir", which does not help.

Fix: give _Unasked an optional ending of its own for this case.

NIT-4: an org/repo source that is not cloned yet is refused before _entry_findings, under another code. gh repo clone (adopt-project.py:2765) checks out in the whole environment. Under GIT_ATTR_SOURCE=bogus or an empty value, a plain git clone exits 128 (fatal: bad --attr-source or GIT_ATTR_SOURCE / warning: Clone succeeded, but checkout failed.); with HEAD it exits 0 (probe p5). So that path would refuse as source-unclonable, with a remediation about gh auth status. That is not a false plan ok. Measured only with plain git clone; the tool path was read, not run. Fix: add a Known-limits line, or move the check to the start of the command.

NIT-5: the #1145 overlap line is stale. It names 179b58ef and tree 87d0289c. #1180's head is now 2c8082a2, with merged tree 3a74e27a, which I tested as above.

NIT-6, by reading only: a branch in _parameter_entries changes nothing. The elif parameters.startswith("'", at): return None branch can be removed without effect, because the check that follows already returns None. Mutant M14 was not run.

Mutants

11 were run, in /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1169/mut: 9 killed, 2 survived (M6 and M10, above).

• Killed: M1 (the rehearsal's environment), M2 (_stored_as_written's environment), M3 (no attr.tree drop), M4 (case-sensitive key), M5 (no call), M7 (empty value allowed), M8 (the fallback returns None), M9 (old-style key not trimmed), M11 (the '\!' escape not read).
• Defined but not run (M12–M21): no escape read at all, None versus "", the redundant branch (M14), the three environment-order mutants (M15–M17), GIT_CONFIG_PARAMETERS handed whole, the old-style key not cut at =, the message for the empty value, and GIT_ATTR_SOURCE kept in _split_checkout_env.

Not covered

• Mutants M12–M21.
• The gate, G1–G9: the doctor shards, the root-symlink file, collisions, hygiene, no-auto-maintenance and the G9 files. I re-ran none of them.
• A re-measure of the body's execute rows on base. Only p8 ran execute.
• An org/repo source end to end.
• CPython 3.14 itself.

Logs, probe outputs and scripts are in /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1169/, under logs/, probe-out/, fuzz.py, mutants.py and logs/mutants-1-11.txt.

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

(lane openRepoShape-1, 2026-10-23T20:43:13Z) r1169d, lane 1's independent reviewer (not the writer), finished r1169c's review of #1169 at 76c9b767: NOT READY, with no MUST and two SHOULDs. Each has a measured fix, and no code change is asked for.

• SHOULD-1: mutant M3 (K3) is not equivalent: under attr.tree, it changes which rule the copies finding's unset line names. The review gives the missing row, which kills K3 (3 of 3).
• SHOULD-2: the Known-limits bullet on the misnamed second finding is wrong for the case where both rules sit in the attr.tree tree. The cause is traced: update-index -q --refresh exits 128 under the failing filter. The fix is in the body only.
• NIT-1 is a body sentence. NIT-2 (the stale stacking statement) is already fixed by the restack. r1169c's NIT-4 is withdrawn.
• K7 is killed by two rows in other files, and K8 is equivalent.
• The restack: w1169e merged adopt-project.py: check asks the split's own clone of the source in the work directory, so a clone this git will not make is adopt-git-unasked before any leg, and _resolved and _answers make their repositories as check's other throwaways do (#1083) #1119's final head 9b856443, its squash b7edd881 and main 50ce8ab1, giving fe25bb14. Lane 1's own delta check: against 50ce8ab1, the changed lines equal the reviewed ones (sha256 5c59dd53), over adopt-project.py: check's rehearsal and _stored_as_written take a parent's -c settings, attr.tree too, and the source's objects, GIT_ATTR_SOURCE is refused by name before any question, and each throwaway reads its environment first (#1136) #1169's five files. The first merge kept both sides of one docstring conflict, so fe25bb14 is the new H0, and CI is running there.
• Next: a fix round for SHOULD-1, SHOULD-2 and NIT-1, then a delta check.

The full review

r1169d: review of PR #1169 at 76c9b767 (this finishes r1169c's partial)

Verdict: NOT READY. There is no MUST. There are two SHOULDs, and both are cheap to fix:

• a test row is missing for a mutant that survives on the line this round changed;
• one Known-limits bullet is wrong, as measured, for one attr.tree case.

No code change is asked for. w1169e's restack is not reviewed here.

How this was measured. Everything ran at 76c9b767, in scratch clones under _lane1-scratch/r1169d/, with git 2.43.0 and CPython 3.12.3, in the probe environment: a stub gh first on PATH, GH_TOKEN=bogus-r1169d, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null, GIT_SSH_COMMAND=false, and env -u LANES_LANE. The review worktree l1-r1169 is still clean: git status --short prints nothing. r1169c's partial and lane 1's chain results are folded in below and were not run again.

What holds (r1169c's results, unchanged)

• Ruling X1 is fully in. _SplitRehearsal.reached (adopt-project.py:12756) runs check-attr -z --stdin with no --cached, and both _rules_reaching calls (12791 and 12803) go through it. A logging git wrapper over the 11 check rows of (j) and (k) saw 22 such calls, none with --cached.
• The 17 new rows:
  • bba168bd: 15 failed, 2 passed (the 2 no-setting controls of (j)).
  • 25805102: 15 failed, 2 passed.
  • Head: 17 passed.
• The body's sizes, checked with git diff --numstat:
  • bba168bd..76c9b767: 211 57 adopt-project.py and 630 5 tests/test_adopt_check_throwaway_repos.py.
  • 25805102..1e958ca6: 16 5.
  • 1e958ca6..76c9b767: 3 2. It changes one comment only, and ast.dump of the two tools is equal: AST equal: True.
• The gate at 76c9b767 (lane 1's chain):
  • G2: 129 passed.
  • G4: 104 passed.
  • The doctor's 4 shards: 445 passed, 3 skipped.
  • Merged with adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's a4ec51d2: 167 passed.
  • These agree with the body's counts.
• Exactly one closing form. Grepping the body for close, fix and resolve forms before an issue number finds only 1:Closes #1136, and closingIssuesReferences is [1136].

Findings

SHOULD-1: M3 (K3) is not equivalent. It changes the copies finding's unset line under attr.tree, and no row holds that.

• Where:
  • adopt-project.py:12803-12805 (at_the_root = asked.reached(AS_SPLIT, ...)), read by _copy_unset_line (12922-12930) through _copies_finding (12933-12949).
  • The body's Mutants paragraph, which says M3's "effect on that line was not measured".
• Evidence: r1169c's 33 probes per tool (outputs in r1169c/probe-out/, compared with cmp):

  K3: same=21 differ: advice-tree-{count,global,parameters} copies-{count,global,parameters}-{neutral,none,own-ident}
  

  • Own root empty or neutral. The side tree says /scripts/*.py filter=w654upper, and attr.tree names it.
    • Head gives /scripts/validate-pins.py -filter, and the same for the other four copies.
    • K3 gives a line that keeps the rule off scripts/validate-pins.py``.
  • Own root /scripts/*.py ident.
    • Head names -filter, the tree's rule, which the split's git add reads.
    • K3 and 25805102 both name /scripts/validate-pins.py -ident. Under attr.tree git does not read that rule (r1169c's expA).
  • Everything else is equal. The codes and the paths named are the same, and the other 21 probes are byte-equal. So the body's "can only grow" holds for reached | (kept & at_the_root).
  • K3 survives the other attribute files too: nr-K3 ENDED exit=0 126 passed in 205.87s over test_adopt_nested_attributes.py and test_adopt_reencoded_files.py. That is on top of the 129 ids of the throwaway file.
• Fix: add this row to tests/test_adopt_check_throwaway_repos.py after row (k). I tested it as a separate module that imports the file's helpers. Inside the file it needs no new import.

  #: A clean filter that stores a file as other bytes, and two rules for the
  #: pinned copies the split writes under `scripts/`: the source's own root's,
  #: and a side tree's.
  COPY_UPPER = "w1136upper"
  COPY_UPPER_CLEAN = [(f"filter.{COPY_UPPER}.clean", "tr a-z A-Z")]
  OWN_COPY_RULE = b"/scripts/*.py ident\n"
  TREE_COPY_RULE = f"/scripts/*.py filter={COPY_UPPER}\n".encode()
  COPIES = ("validate-pins.py", "validate-manifest.py", "bootstrap.py",
            "repo_shape.py", "validate-repository-naming.py")
  
  
  @pytest.mark.parametrize("handed", EVERY_FORM)
  def test_a_pinned_copy_under_a_parent_gits_attr_tree_unsets_the_trees_rule(
          tmp_path, handed):
      """A parent's `attr.tree` names a side tree that says `/scripts/*.py
      filter=<an upper-casing clean>`, over a source root that says
      `/scripts/*.py ident`. The split's `git add` of the pinned copies reads
      the tree's `filter` and not the root's `ident`, so the copies finding
      names `-filter` for each copy, and no `-ident`. `_rules_reaching` asks
      the split's root without `--cached`; with it there (M3) each line said
      `-ident`, as on 25805102."""
      source = a_source(tmp_path, files={ROOT_ATTRIBUTES: OWN_COPY_RULE})
      env = handed(tmp_path, [*COPY_UPPER_CLEAN,
                              ("attr.tree",
                               on_a_side_branch(source, TREE_COPY_RULE))])
      read = subprocess.run(["git", "check-attr", "filter", "ident", "--",
                             "scripts/bootstrap.py"], cwd=str(source),
                            env={**os.environ, **env}, capture_output=True,
                            text=True, check=True)
      if "filter: unspecified" in read.stdout:
          pytest.skip("this git reads no `attr.tree`")
      assert read.stdout.splitlines() == [
          f"scripts/bootstrap.py: filter: {COPY_UPPER}",
          "scripts/bootstrap.py: ident: unspecified"]
      result = checked(planned(source, tmp_path, {}), env)
      assert result.returncode == 1, result.stderr
      assert codes(result) == [REENCODED_FILES], result.stderr
      line = finding_lines(result)[0]
      assert "store 5 pinned shape copies" in line, line
      for name in COPIES:
          assert f"`/scripts/{name} -filter`" in line, line
      assert "-ident" not in line, line

  • Measured. Each tool was swapped into a scratch clone and restored, and its blob was HEAD's after each one.
    • Head: 3 passed, no skip (9 passed in 18.89s together with the probes).
    • K3: 3 failed: assert '/scripts/validate-pins.py -filter' in "... -ident ..."`.
    • 25805102: 3 failed, the same way.
    • bba168bd: the global form failed the same way; the parameters and count forms failed with assert 0 == 1 (plan ok).
  • Then update the body's Mutants paragraph: M3 is killed by this row, 3 of 3.

SHOULD-2 (r1169c's NIT-1, now measured): the misnamed second finding also comes when both rules are in the attr.tree tree, and this PR is what brings that case in. The bullet says otherwise.

• Where:
  • The body's Known-limits bullet "A misnamed second finding where both rules are the source's own", and the matching "Not in this PR" line.
  • The cause is at adopt-project.py:13021, asked.git(["update-index", "-q", "--refresh"], TAKEN), whose exit code is never read, and then diff-files at 13022-13023.
• Evidence: the both-rules-in-the-tree probe. The own root says *.png binary. The side tree says /.gitattributes filter=w1136 and *.md text. attr.tree names that tree, with the failing filter, in each form.
  • Head: exit=1, plan-attributes-reencoded and also plan-file-reencoded naming specs/001-feature/spec.md, in all three forms.
  • 25805102: exit=1, plan-attributes-reencoded alone, in all three forms.
  • bba168bd: exit=0 | plan ok in all three forms.
• Control: the tree's *.md text alone, with no filter, gives exit=0 | plan ok on head, K3, 25805102 and bba168bd, in all three forms. So spec.md (# The feature\n, LF only) is stored as its blob, and the second finding names a file that is not reencoded.
• The own-rules case is as the bullet says. Head and 25805102 both give two findings in all six cases (three forms, two orders), and the filter alone gives one finding.
• The cause is traced (r1169c's expB, git 2.43).
  • Under the failing required filter, update-index -q --refresh exits 128 with fatal: .gitattributes: clean filter 'w1136' failed.
  • diff-files --name-only then exits 0 and lists .gitattributes specs/spec.md.
  • With no filter, the refresh exits 0 and diff-files lists nothing.
• Three of the bullet's claims are wrong as measured:
  • "Probably ... (not traced)": it is traced.
  • "It predates this PR, which only lets the parameters form reach it": with both rules in the side tree, the base says plan ok, and this PR's read without --cached brings the misnamed finding in all three forms.
  • "adopt-project.py: under a failing clean filter that a rule names for .gitattributes, check also prints plan-file-reencoded for a file the split stores as its blob, beside the right plan-attributes-reencoded (#1136) #1192's attr.tree case ... gave the second finding because of --cached, and no longer does": --cached only made the source's own *.md text reach spec.md, so that spec.md was asked about. The second finding comes from the refresh, and it still comes wherever one place holds both rules.
• This is not wrong behaviour. check refuses with the right first finding, where the base said plan ok.
• Fix (the body only):
  1. Retitle the bullet "wherever both rules are read from one place".
  2. Add the side-tree results: head two findings, 25805102 one, bba168bd plan ok, in all three forms.
  3. Replace "Probably ... (not traced)" with the traced cause.
  4. Say that the side-tree case comes with X1.
  5. Make the same change in "Not in this PR".
  6. Lane 1: post the side-tree case and expB's trace on adopt-project.py: under a failing clean filter that a rule names for .gitattributes, check also prints plan-file-reencoded for a file the split stores as its blob, beside the right plan-attributes-reencoded (#1136) #1192.

NIT-1 (r1169c's NIT-2, now measured): under attr.tree, the copies finding asks for lines that are already there.

• Where:
  • adopt-project.py:12946-12949, which says "these lines after them in the source's root .gitattributes".
  • The body's bullet "The findings point at the source's own rules", which names only the kept and moved endings.
• Evidence (the advice probes):
  • Under attr.tree. The own root holds *.png binary plus the five /scripts/<copy> -filter lines the finding asks for, and the side tree's filter rule is read through attr.tree. Head gives exit=1 with the same finding, asking for the same five lines, in all three forms.
  • Control: the same rule in the own root, then the five lines, with no attr.tree. Head, K3 and 25805102 all give exit=0 plan ok in all three forms.
  • Not new in this PR. 25805102 loops the same way, with the generic line.
• Fix: extend the bullet: "under a parent's attr.tree, the copies finding names the right attribute but puts the lines in the source's root .gitattributes, which git does not read there; following it gives the same finding again". SHOULD-1's row checks only which attribute is named, so it still holds after any rewording of this ending.

NIT-2 (r1169c's NIT-3, updated): the stacking line and the #1145 bullet are out of date.

• Evidence:
  • gh pr view 1119: "state":"MERGED","mergedAt":"2026-10-23T19:45:11Z","merge":"b7edd881...".
  • gh pr view 1169: "base":"main".
  • gh pr view 1180: "head":"a0e8cded...","base":"main".
• What is out of date:
  • Body line 3 says "Stacked on adopt-project.py: check asks the split's own clone of the source in the work directory, so a clone this git will not make is adopt-git-unasked before any leg, and _resolved and _answers make their repositories as check's other throwaways do (#1083) #1119 (... head bba168bd); it lands after adopt-project.py: check asks the split's own clone of the source in the work directory, so a clone this git will not make is adopt-git-unasked before any leg, and _resolved and _answers make their repositories as check's other throwaways do (#1083) #1119".
  • The Known-limits bullet "adopt-project.py check: a partial-clone source missing blobs that check reads is fetched into, so check's own reads run the upload-pack its config names and write a promisor pack into the source #1145 overlap" names adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's head as b316f415, "also stacked on bba168bd".
• Fix: after the restack, rewrite both against main and adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's current head.

r1169c's NIT-4 is withdrawn. The row at tests/test_adopt_check_throwaway_repos.py:1903 has no docstring. Neither do the section's other three execute rows, so it follows the section's own pattern. An AST listing of the section's rows gives 1602 NO DOCSTRING, 1644 NO DOCSTRING, 1804 NO DOCSTRING and 1903 NO DOCSTRING, and every check row there has one.

K7 and K8

• K7 is not equivalent, and it is killed. K7 checks out every .gitattributes before _rules_reaching runs, which breaks the precondition reached's docstring names. It survived the 129 ids of the throwaway file. Over the nested and reencoded files it gave nr-K7 ENDED exit=1 2 failed, 124 passed:

  • test_adopt_nested_attributes.py::test_an_encoding_the_root_attributes_is_not_in_is_found: assert set() == {'plan-file-reencoded'}. The root's working-tree-encoding=UTF-16LE copy, checked out, gives git no rules, as the row's own docstring explains.
  • test_adopt_reencoded_files.py::test_every_file_is_read_again_whatever_the_clock: AssertionError: .gitattributes ctime: 0:0 ....

  No row is missing for K7.

• K8 is equivalent. K8 adds --cached wherever git config --get attr.tree exits non-zero. It passed all 255 ids: 129 in the partial's run and 126 passed in mine.

  • With no attribute source, check-attr without --cached reads a .gitattributes in the work tree first, and the index otherwise (expA).
  • The work tree holds none when _rules_reaching asks. That is the precondition K7 breaks, and the two rows above hold it.
  • The only other attribute source, GIT_ATTR_SOURCE, never reaches the rehearsal. _NOT_INHERITED (adopt-project.py:11972-11973) names it and _split_checkout_env drops it (row (g)). _attr_source_unasked also refuses it before any throwaway is made (rows (e) and (i)).

Mutant table

Mutant	Change	Ids	Result
K1 (M1)	--cached at both calls	throwaway file, -x	killed: (k) [global-config]
K2 (M2)	--cached at the AS_HELD call	same	killed: (k) [global-config]
K3 (M3)	--cached at the AS_SPLIT call	129 + 126	survives, not equivalent (SHOULD-1); the row kills it, 3 of 3
K4	--cached where GIT_CONFIG_PARAMETERS names attr.tree	throwaway file, -x	killed: (k) [git-config-parameters]
K5	--cached where a GIT_CONFIG_KEY_<n> is attr.tree	same	killed: (k) [git-config-count]
K6	--cached where a global config file is named	same	killed: (k) [global-config]
K7	every .gitattributes checked out first	129 (survived) + 126	killed by 2 rows
K8	--cached where attr.tree is unset	129 + 126	survives, equivalent

6 of 8 are killed, which is 6 of the 7 non-equivalent ones, and 7 of 7 with SHOULD-1's row. Every run restored the tool, with restored to HEAD's blob: True after each mutant.

Not covered

• CPython 3.14 and a 3.14-like shim: no reviewer built one. The body reports the writer's shim run of the 67 ids, and the changed line has no path check.
• The full suite.
• The body's Gf2, G3, G9 and H2 gate calls: no reviewer ran them at 76c9b767. They ran at 1e958ca6, whose tool has the same AST.
• f1169's 13 older mutants, at this head.
• A real execute for the both-rules-in-the-tree case, and for the followed copies advice: only check was run.
• The earlier rounds' rows (a) to (i), beyond G2's 129 passing.
• The restack onto main, and the merge with adopt-project.py: check and execute run with GIT_NO_LAZY_FETCH=1 and refuse a partial-clone source that lacks an object its branches, tags or HEAD reach as source-partial-clone, so neither fetches into the source any more (#1145) #1180's a0e8cded. Lane 1 checks those.

The evidence is in /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1169c/: probe-out/, logs/, expA.sh and expB.sh. My probes, including the proposed row as test_r1169d_probes.py, are in /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1169d/: out/ and logs/ (status.txt, nr-K3/K7/K8.log, pr-*.log).

Lane: openreposhape-1 (openRepoShape-1)

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

(lane openRepoShape-1, 2026-10-23T20:53:09Z) The fix round for r1169d's review is pushed at d9224ecf. Lane 1's delta check of it holds; r1169d re-checks it in lane 1's next window.

• The code: d9224ecf adds exactly r1169d's row (l) and its constants.
  • Its 40 non-blank lines equal the review's block, in order.
  • It is one test file, +44/-0, with nothing removed.
  • The row passes at head, 3 of 3. With K3 applied (--cached at the AS_SPLIT call) it fails, 3 of 3, and the tool's blob was HEAD's after the restore.
• The body, posted at 20:48Z:
  • SHOULD-2: the bullet is retitled, the side-tree results are added, the traced cause is in, and the side-tree case is said to come with X1, here and in "Not in this PR".
  • NIT-1: the copies-finding sentence is added.
  • The mutant tally: K3 is killed by row (l), K7 by the two rows the review names, and K8 is equivalent.
• Before landing, still owed:
  • r1169d's re-check;
  • a merge of main, since d9224ecf is one behind e04826db;
  • tests and SonarCloud green on the H0. That is d9224ecf, because the restack kept both sides of one docstring conflict by hand.
  • Lane 1's gate on d9224ecf is running now.

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

(lane openRepoShape-1, 2026-10-23T21:34:31Z) r1169e, lane 1's independent re-checker (not the writer), re-checked #1169's fix round at d9224ecf: READY, with no MUST, no SHOULD and two wording NITs in the body.

• Both of r1169d's SHOULDs are fixed:
  • row (l) passes at head and fails with K3, 3 of 3;
  • the five body items say what r1169d measured, and its NIT-1 sentence is in.
• K7 is killed by the two named rows, and K8 is equivalent.
• The tool at d9224ecf is byte-equal to the reviewed 76c9b767's, and the restack's changed lines equal the reviewed delta.
• Lane 1's gate passed on d9224ecf: 7 calls, 1,253 passed and 9 skipped, with the doctor's 4 shards (tree 358288a4).
• Landing: adopt-project.py: check's rehearsal and _stored_as_written take a parent's -c settings, attr.tree too, and the source's objects, GIT_ATTR_SOURCE is refused by name before any question, and each throwaway reads its environment first (#1136) #1169 lands in its held slot once tests is green on its H0 d9224ecf, with update-branch merging main (merge-tree with e04826db is clean). Lane 1 fixes NIT-1's phrase in the body first.

The full re-check

r1169e: re-check of PR #1169's fix round at d9224ecfa69fb7a8df9e4f25988afca1e078d180

Verdict: READY. There is no MUST and no SHOULD. r1169d's two SHOULDs are fixed and r1169d's NIT-1 is in the body. There are two NITs, both wording in the body. Neither blocks.

How this was measured.

• Environment: git 2.43.0, CPython 3.12.3, the probe environment of the rules, env -u LANES_LANE.
• Probe environment: stub gh first on PATH, GH_TOKEN=bogus-r1169e, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null, GIT_SSH_COMMAND=false.
• Per lane 1's disk rule, TMPDIR and every basetemp sat in my scratch folder, and I checked df on / and /workspace before each call.
• The review worktree l1-r1169e is detached at d9224ecf. git status --short is empty and its adopt-project.py blob is a530fdfa, equal to HEAD's.
• One gap: one small pytest call ran at 4982M free on /, just under the 5G line. It was the 3-id run against the bba168bd tool in item 1. / then fell to 3.5G while other lanes were using it, and I paused until it read 7.5G. Every later call passed the check first.

1. SHOULD-1: row (l) passes at head and K3 fails it. Fixed.

• Head. I ran the three ids once with a $(cat) list and once through @ids_l, an args file. Both runs, with -rs:

  ...                                                                      [100%]
  3 passed in 5.10s
  

  There is no skip. Under a 3.14-like shim (Path.exists.__qualname__ read _quiet.<locals>.quiet) it was also 3 passed in 4.95s.

• K3 as r1169d describes it. I added a cached argument to _SplitRehearsal.reached, which puts --cached in its check-attr call. I passed cached=True at at_the_root = asked.reached(AS_SPLIT, ...). The edit was in a clone under my scratch folder.

  K3: mutated; blob now a85f3d3ed918 vs HEAD a530fdfacc9b
   adopt-project.py | 6 ++++--   (4 insertions, 2 deletions)
  K3: pytest exit=1
  FFF
  E   assert '`/scripts/validate-pins.py -filter`' in "FINDING plan-file-reencoded: ... Keep the rules off them with these lines ...: `/scripts/validate-pins.py -ident`, ... -ident` ..."
  3 failed in 6.24s
  K3: restored to HEAD's blob: True (a530fdfacc9b)
  

  All three ids failed, at test_adopt_check_throwaway_repos.py:2048, with -ident named in place of -filter.

• Row (l) against other tools. The tool was swapped into a clone and restored each time. It matches the body's sentence.

  Tool	Result
  25805102	3 failed, all -ident at :2048
  bba168bd (blob b17f7a41)	global form failed at :2048 with -ident; parameters and count failed at :2043 with assert 0 == 1 (plan ok)

• The block equals r1169d's. git diff -U0 fe25bb14 d9224ecf adds 44 lines, 40 of them non-blank. They are identical to the python block in r1169d-on-1169.md: review non-blank: 40 added non-blank: 40, equal (non-blank, exact): True.

• Placement and names. The row sits after row (k), at lines 2008-2051. COPY_UPPER, COPY_UPPER_CLEAN, OWN_COPY_RULE, TREE_COPY_RULE and COPIES each have one definition, and no other test file uses them.

• Whole file at head. tests/test_adopt_check_throwaway_repos.py: 151 passed, 1 skipped in 198.60s. The skip is :482, "needs a disk that ignores case". It is adopt-project.py: check asks the split's own clone of the source in the work directory, so a clone this git will not make is adopt-git-unasked before any leg, and _resolved and _answers make their repositories as check's other throwaways do (#1083) #1119's row and not this PR's.

• Id count. Collecting the file at main 50ce8ab1 gives 90 ids and at head 152. Head has 62 ids not in main, and none removed. That matches the body's "59 ... row (l) makes 62".

2. SHOULD-2 and NIT-1: each of the five body items, and the NIT-1 sentence, is in and says what r1169d measured.

The "Known limits" bullet is now titled "A misnamed second finding wherever both rules are read from one place." (the old title was "where both rules are the source's own").

r1169d's item	In the body	Matches
1. Retitle the bullet	The title above	yes
2. Side-tree results	"in each of the three forms, head gives exit=1 with plan-attributes-reencoded and also plan-file-reencoded naming specs/001-feature/spec.md; 25805102 gives plan-attributes-reencoded alone; bba168bd gives exit=0, plan ok", with the *.md text-alone control as plan ok	yes
3. The traced cause	The refresh's exit code is never read; it exits 128 with fatal: .gitattributes: clean filter 'w1136' failed; diff-files exits 0 and lists .gitattributes specs/spec.md; with no filter the refresh exits 0 and diff-files lists nothing	yes (see below)
4. "Comes with X1"	"This case comes with ruling X1: the read without --cached now reaches spec.md through the tree's *.md text ... where base said plan ok"	yes
5. Same change in "Not in this PR"	"... wherever both rules are read from one place: the source's own root, or the side tree attr.tree names, which this PR's read without --cached brings in"	yes

• Item 3: one phrase goes past r1169d's wording, and it holds. The body says the files are "the files it did not refresh". I reproduced r1169c's expB in the probe environment, with the same rows, the same filter, update-index -q --refresh against a fresh index, then diff-files.

  == failing: refresh
  fatal: .gitattributes: clean filter 'w1136' failed
  refresh exit=128
  .gitattributes   ctime: 0:0
  specs/spec.md    ctime: 0:0
  diff-files exit=0 out: .gitattributes specs/spec.md
  == none: refresh
  refresh exit=0
  .gitattributes   ctime: 1792790432:171663157
  specs/spec.md    ctime: 1792790432:171663157
  diff-files exit=0 out:
  

  ctime: 0:0 on specs/spec.md after the failed refresh shows it was never refreshed, so the phrase holds.
• Item 4 and the own-rules sentences. The body keeps "The own-rules case predates this PR, which only lets its parameters form reach it". r1169d agreed with this for the own-rules case. The body also corrects the adopt-project.py: under a failing clean filter that a rule names for .gitattributes, check also prints plan-file-reencoded for a file the split stores as its blob, beside the right plan-attributes-reencoded (#1136) #1192 claim to the two-places case (row (k)), as r1169d asked.
• adopt-project.py: under a failing clean filter that a rule names for .gitattributes, check also prints plan-file-reencoded for a file the split stores as its blob, beside the right plan-attributes-reencoded (#1136) #1192. Lane 1's comment with the trace is there, posted 2026-10-23T20:44:08Z.
• The NIT-1 sentence. It is in the "The findings point at the source's own rules" bullet and matches r1169d's measurement. I measured it independently with a probe module that imports the file's helpers:

  attr.tree, own root `*.png binary` (no five lines): exit=1 plan-file-reencoded, the 5 `-filter` lines  (3 forms)
  attr.tree, own root `*.png binary` + the five `-filter` lines: exit=1 plan-file-reencoded, the SAME 5 lines  (global, parameters, count)
  no attr.tree, own root `/scripts/*.py filter` + the five lines: exit=0 plan ok
  no attr.tree, own root `/scripts/*.py filter` alone: exit=1 plan-file-reencoded, the same 5 lines
  

  "25805102 loops the same way, with the generic line" is r1169d's, and I did not re-measure it. "Row (l) checks only which attribute is named" is true of the row's code: store 5 pinned shape copies, -filter per copy, no -ident.

3. The mutant paragraph

All mutants ran in clones of d9224ecf, with the file restored in a finally and its blob checked against HEAD's after each.

Mutant	Ids	Result	Claim
K3	row (l), 3	3 failed (item 1)	killed by (l): holds
K7	test_adopt_nested_attributes.py and test_adopt_reencoded_files.py (126)	2 failed, 124 passed in 188.50s	killed by the two named rows: holds
K8	the throwaway file	151 passed, 1 skipped	equivalent: holds
K8	nested and reencoded files	126 passed in 188.68s	equivalent: holds
K1	(j) and (k), 17	15 failed, 2 passed	body's "M1: 15 failed": holds
K2	(j) and (k), 17	9 failed, 8 passed	body's "M2: 9 failed": holds

Head over the same 17 ids: 17 passed.

• K7's two failures are exactly the two rows the body names:
  • test_adopt_nested_attributes.py::test_an_encoding_the_root_attributes_is_not_in_is_found: assert set() == {'plan-file-reencoded'}.
  • test_adopt_reencoded_files.py::test_every_file_is_read_again_whatever_the_clock: .gitattributes ctime: 0:0, assert 1 > 1.
• K7 and K8 are r1169d's mutants. My tool blobs equal r1169d's status.txt: K7 62b23082..., K8 e1f78c0a....
• K8's reason holds in the code.
  • _NOT_INHERITED names GIT_ATTR_SOURCE at 11972-11973.
  • _split_checkout_env() returns only names that are CONFIG_PARAMETERS or not in _NOT_INHERITED.
  • _attr_source_unasked raises _Unasked before any throwaway whenever the variable is set.
  • The work tree holds no .gitattributes when _rules_reaching asks, which is the precondition K7 breaks.
• The tally "6 of 8 killed before row (l), K3 by (l), K8 equivalent: 7 of 7 non-equivalent killed" follows from the table.

4. Nothing else changed.

• git diff fe25bb14 d9224ecf: 1 file changed, 44 insertions(+), tests/test_adopt_check_throwaway_repos.py, 44 0, one commit.
• adopt-project.py's blobs.

  d9224ecf a530fdfacc9be36995080ba0cdae051698ab751e
  fe25bb14 a530fdfacc9be36995080ba0cdae051698ab751e
  76c9b767 a530fdfacc9be36995080ba0cdae051698ab751e
  50ce8ab1 b17f7a41b2d74d3b31d1c9ff1c7b8f8ecbeb15b7
  bba168bd b17f7a41b2d74d3b31d1c9ff1c7b8f8ecbeb15b7
  

  So the tool at d9224ecf is byte-equal to 76c9b767's, and main's tool is byte-equal to bba168bd's.
• The two diffs you named. I compared them by changed lines (the + and - lines, headers left out).

  git diff -U0 50ce8ab1 d9224ecf -- adopt-project.py  268 lines  sha256 b9d14b4f43f6...ddf
  git diff -U0 bba168bd 76c9b767  -- adopt-project.py  268 lines  sha256 b9d14b4f43f6...ddf
  numstat: 211 57 and 211 57
  

• The whole tree. The changed lines of 50ce8ab1..fe25bb14 and of bba168bd..76c9b767 are both 985 lines with sha256 5c59dd53e8c0...5c81. That is the value lane 1 recorded. git diff --numstat 50ce8ab1 d9224ecf lists the same 5 files, with 674/5 in the throwaway file (630/5 plus row (l)'s 44).
• The restack statement.
  • fe25bb14 has parents 93a561c9 and 50ce8ab1.
  • 93a561c9 has parents ce1938a8 and b7edd881.
  • ce1938a8 has parents 76c9b767 and 9b856443.
  • gh pr view 1119 gives MERGED with merge commit b7edd881, and 9b856443 as its final head.
  • git diff 9b856443 b7edd881 and git diff ce1938a8 93a561c9 are both empty (0 lines).
  • The module docstring has adopt-project.py: refused_paths' update-index -z --index-info is untested with core.ignorecase and case twins (a and A) on a case-insensitive disk #1033's paragraph at line 47 and adopt-project.py: #910's throwaways leave out a parent's -c settings and GIT_ATTR_SOURCE, so check says plan ok where execute stops after both legs, and three read the environment after making the throwaway (follow-up of #1083) #1136's at line 55.
  • PR base is main, and the PR is a draft on milestone v1.2.1.
  • origin/main has moved one commit since to e04826db, which touches templates/family-root/scripts/validate-family.py and tests/test_validate_family_index_gitmodules.py, neither of which the PR touches. git merge-tree --write-tree origin/main d9224ecf exits 0 with tree aa2a2d7c, no conflict.

5. Exactly one closing form. Holds.

3:Closes #1136
closingIssuesReferences: 1136

• A grep for close/fix/resolve forms before an issue reference finds only line 3.
• "fix (b)" at line 42 and the branch name fix/1145-... at line 136 are not closing forms.
• The body has no "Part of" or "Covers".

New findings

NIT-1: the NIT-1 control omits "then the five lines". The body's wording is ambiguous.

• Where: the body's bullet "The findings point at the source's own rules", its sentence "with the same rule in the own root and no attr.tree, plan ok". It sits in the restack-era body, where r1169d's text sits.
• Evidence (the probe above): the rule in the own root with no attr.tree is plan ok only when the five -filter lines follow it. With the rule alone and no attr.tree, the copies finding comes (exit=1, the same five lines). r1169d's control was "the same rule in the own root, then the five lines".
• Fix: write "with the same rule in the own root, followed by the five lines, and no attr.tree, plan ok".

NIT-2: the mutant paragraph names the restack's fe25bb14 but not row (l)'s head for M3.

• Where: the body's M3 bullet. It says M3 was measured "at fe25bb14 plus the row".
• Evidence: I measured at d9224ecf, and adopt-project.py's blob is the same, a530fdfa, at both commits. So the claim is true.
• Fix: none needed. Optionally say "at d9224ecf".

What I did not cover

• Not measured at d9224ecf.
  • The doctor's four shards, G3, G4, G9 and the hygiene gates. The tool and the other four test files are byte-equal to what lane 1's and w1169e's calls ran, and row (l) adds only tests.
  • R1's other three test files: they are unchanged since fe25bb14, where R1 ran.
  • The doc trio, which this round does not touch.
• Not re-measured. The older body claims from earlier rounds, which I did not touch. These include f1169's 13 older mutants and the own-rules both-rules table: the bba168bd global and count forms giving two findings, and the parameters form plan ok. A real execute run of the side-tree both-rules case and of the copies advice: only check was run.
• No CPython 3.14. I used the 3.12 shim for row (l) only. The changed lines have no path check.
• The full suite.

Evidence is in /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1169e/:

• logs/: mut-K3-x.log, run-K7-nr.out, run-K8-nr.out, run-K8-thr.out, head-thr.log, swap-p25805102.log, swap-pbba168bd.log
• probe/: out.txt, test_r1169e_probes.py
• expB/run-2/
• ids-main.txt, ids-head.txt
• mutate.py, swap_tool.py

Lane: openreposhape-1 (openRepoShape-1)

Lane: openreposhape-1 (openRepoShape-1)

[sonarqubecloud]

Quality Gate passed

Issues
3 New issues
0 Accepted issues

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

See analysis details on SonarQube Cloud

[sourcery-ai]

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

You can request another review in 6 days and 23 hours by commenting @sourcery-ai review. Upgrade to get a review now.